Skip to main content

EFSPIntegration.py_efsp_client

The base python client used to communicate with the E-file proxy server.

Doesn't include anything from docassemble, and can be used without having it installed.

re​

logging​

requests​

LoggerAdapter​

Request​

PreparedRequest​

UUID​

uuid4​

Response​

datetime​

Optional​

Union​

List​

Dict​

http_client​

deepcopy​

__all__​

SESSION_ID_HEADER​

CORR_ID_HEADER​

TODO(brycew): Figure out how to add

REQUEST_ID_HEADER​

LoggerWithContext Objects​

class LoggerWithContext(LoggerAdapter)

Acts like the merge_extra feature from LoggerAdapter (python 3.13) is always on.

See https://github.com/python/cpython/pull/107292/files.

__init__​

def __init__(logger, extra)

process​

def process(msg, kwargs)

ApiResponse Objects​

class ApiResponse(object)

__init__​

def __init__(response_code: int,
             error_msg: Optional[str],
             data,
             *,
             session_id: Optional[str] = None,
             req_id: Optional[str] = None)

__str__​

def __str__()

__repr__​

def __repr__()

is_ok​

def is_ok()

get_session_id​

def get_session_id()

get_req_id​

def get_req_id()

_user_visible_resp​

def _user_visible_resp(resp: Union[Response, str, None]) -> ApiResponse

This function takes the essentials of a response and puts in into a simple object.

EfspConnection Objects​

class EfspConnection()

A python client that communicates with the E-file proxy server.

__init__​

def __init__(*,
             url: str,
             api_key: str,
             default_jurisdiction: str = None,
             interview_name: str = None,
             logger=None)

Arguments​

url (str) api_key (str) default_jurisdiction (str)

_call_proxy​

def _call_proxy(req: PreparedRequest) -> ApiResponse

_send​

def _send(to_send: Request, *, req_id: Optional[UUID] = None) -> ApiResponse

Handle sending the request / structuring the response

get_session_id​

def get_session_id()

get_interview_name​

def get_interview_name()

get_logger​

def get_logger()

verbose_logging​

@staticmethod
def verbose_logging(turn_on: bool) -> None

set_verbose_logging​

def set_verbose_logging(turn_on: bool) -> None

full_url​

def full_url(endpoint: str, jurisdiction: str = None) -> str

tyler_token​

def tyler_token() -> Optional[str]

authenticate_user​

def authenticate_user(*,
                      tyler_email: Optional[str] = None,
                      tyler_password: Optional[str] = None,
                      jurisdiction: str = None) -> ApiResponse

Authenticates the user with the EFM server (not the E-file proxy).

register_user​

def register_user(person: dict,
                  registration_type: str,
                  *,
                  password: str = None,
                  firm_name_or_id: str = None) -> ApiResponse

registration_type needs to be INDIVIDUAL, FIRM_ADMINISTRATOR, or FIRM_ADMIN_NEW_MEMBER. If registration_type is INDIVIDUAL or FIRM_ADMINISTRATOR, you need a password. If it's FIRM_ADMINISTRATOR or FIRM_ADMIN_NEW_MEMBER, you need a firm_name_or_id

get_password_rules​

def get_password_rules() -> ApiResponse

Password rules are stored in the global court, id 0.

TODO: They're in other courts too, including 1. Could they ever be different?

is_valid_password​

def is_valid_password(password: str) -> Optional[bool]

get_user_list​

def get_user_list() -> ApiResponse

get_users​

def get_users() -> ApiResponse

get_user​

def get_user(id: str = None) -> ApiResponse

get_user_roles​

def get_user_roles(id: str) -> ApiResponse

add_user_roles​

def add_user_roles(id: str, roles: List[dict]) -> ApiResponse

remove_user_roles​

def remove_user_roles(id: str, roles: List[dict]) -> ApiResponse

change_password​

def change_password(id: str, email: str, new_password: str) -> ApiResponse

self_change_password​

def self_change_password(current_pwd: str, new_pwd: str) -> ApiResponse

self_resend_activation_email​

def self_resend_activation_email(email: str) -> ApiResponse

resend_activation_email​

def resend_activation_email(id: str) -> ApiResponse

update_notification_preferences​

def update_notification_preferences(
        notif_preferences: List[dict]) -> ApiResponse

get_notification_preferences​

def get_notification_preferences() -> ApiResponse

get_notification_options​

def get_notification_options() -> ApiResponse

AKA NotificationPreferencesList

self_update_user​

def self_update_user(email: str = None,
                     first_name: str = None,
                     middle_name: str = None,
                     last_name: str = None) -> ApiResponse

update_user​

def update_user(id: str,
                email: str = None,
                first_name: str = None,
                middle_name: str = None,
                last_name: str = None) -> ApiResponse

remove_user​

def remove_user(id: str) -> ApiResponse

reset_user_password​

def reset_user_password(email: str) -> ApiResponse

get_firm​

def get_firm() -> ApiResponse

Gets info about the "firm" for an associated user. If a user is a pro-se, this contains their address information.

update_firm​

def update_firm(firm: dict) -> ApiResponse

firm should have the below keys:

  • firstName, middleName, lastName if it's a person
  • firmName if it's a business
  • address (a dict), with keys addressLine1 addressLine2, city, state, zipCode, country
  • phoneNumber
  • email

get_attorney_list​

def get_attorney_list() -> ApiResponse

get_attorney​

def get_attorney(attorney_id)

update_attorney​

def update_attorney(attorney_id,
                    bar_number: str = None,
                    first_name: str = None,
                    middle_name: str = None,
                    last_name: str = None) -> ApiResponse

create_attorney​

def create_attorney(bar_number: str,
                    first_name: str,
                    middle_name: str = None,
                    last_name: str = None) -> ApiResponse

remove_attorney​

def remove_attorney(attorney_id) -> ApiResponse

get_payment_account_type_list​

def get_payment_account_type_list() -> ApiResponse

get_payment_account_list​

def get_payment_account_list(court_id: Optional[str] = None) -> ApiResponse

get_payment_account​

def get_payment_account(payment_account_id: str) -> ApiResponse

update_payment_account​

def update_payment_account(payment_account_id: str,
                           account_name: str = None,
                           active: bool = True) -> ApiResponse

remove_payment_account​

def remove_payment_account(payment_account_id: str) -> ApiResponse

create_waiver_account​

def create_waiver_account(account_name: str, is_global: bool) -> ApiResponse

get_global_payment_account_list​

def get_global_payment_account_list() -> ApiResponse

get_global_payment_account​

def get_global_payment_account(global_payment_account_id: str) -> ApiResponse

update_global_payment_account​

def update_global_payment_account(global_payment_account_id: str,
                                  account_name: str = None,
                                  active: bool = True) -> ApiResponse

remove_global_payment_account​

def remove_global_payment_account(
        global_payment_account_id: str) -> ApiResponse

get_service_contact_list​

def get_service_contact_list() -> ApiResponse

get_service_contact​

def get_service_contact(service_contact_id) -> ApiResponse

update_service_contact​

def update_service_contact(service_contact_id: str,
                           service_contact: dict,
                           *,
                           is_public: bool = None,
                           is_in_master_list: bool = None,
                           admin_copy: str = None) -> ApiResponse

create_service_contact​

def create_service_contact(service_contact: dict,
                           *,
                           is_public: bool,
                           is_in_master_list: bool,
                           admin_copy: str = None) -> ApiResponse

remove_service_contact​

def remove_service_contact(service_contact_id) -> ApiResponse

get_public_service_contacts​

def get_public_service_contacts(first_name: str = None,
                                middle_name: str = None,
                                last_name: str = None,
                                email: str = None) -> ApiResponse

attach_service_contact​

def attach_service_contact(service_contact_id: str,
                           case_id: str,
                           case_party_id: str = None) -> ApiResponse

detach_service_contact​

def detach_service_contact(service_contact_id: str,
                           case_id: str,
                           case_party_id: str = None) -> ApiResponse

get_attached_cases​

def get_attached_cases(court_id: str, service_contact_id: str) -> ApiResponse

get_public_list​

def get_public_list()

get_courts​

def get_courts(fileable_only: bool = False,
               fileable_type: str = "",
               with_names: bool = False) -> ApiResponse

Gets the list of courts.

get_court​

def get_court(court_id: str) -> ApiResponse

Gets codes for a specific court

get_court_list​

def get_court_list() -> ApiResponse

Gets a list of all of the courts that you can file into. Slightly more limited than get_courts

get_filing_list​

def get_filing_list(court_id: str,
                    user_id: str = None,
                    start_date: datetime = None,
                    before_date: datetime = None) -> ApiResponse

Returns a list of filings that a particular user has made with a court.

get_filing​

def get_filing(court_id: str, filing_id: str) -> ApiResponse

get_policy​

def get_policy(court_id: str) -> ApiResponse

get_filing_status​

def get_filing_status(court_id: str, filing_id: str) -> ApiResponse

cancel_filing_status​

def cancel_filing_status(court_id: str, filing_id: str) -> ApiResponse

check_filing​

def check_filing(court_id: str, all_vars: dict) -> ApiResponse

file_for_review​

def file_for_review(court_id: str, all_vars: dict) -> ApiResponse

get_service_types​

def get_service_types(court_id: str, all_vars: dict = None) -> ApiResponse

Checks the court info: if it has conditional service types, call a special API with all filing info so far to get service types

calculate_filing_fees​

def calculate_filing_fees(court_id: str, all_vars: dict) -> ApiResponse

get_return_date​

def get_return_date(court_id: str, req_return_date: datetime,
                    all_vars_obj: dict) -> ApiResponse

reserve_court_date​

def reserve_court_date(court_id: str,
                       doc_id: str,
                       range_after: Union[datetime, str] = None,
                       range_before: Union[datetime, str] = None,
                       estimated_duration=None) -> ApiResponse

get_cases_raw​

def get_cases_raw(court_id: str,
                  *,
                  person_name: dict = None,
                  business_name: str = None,
                  docket_number: str = None) -> ApiResponse

Finds existing cases at a particular court. Only one of person_name, business_name, or docket_number should be provided at a time. Params: court_id (str) person_name (dict) business_name (str) docket_number (str)

get_case​

def get_case(court_id: str, case_id: str) -> ApiResponse

get_document​

def get_document(court_id: str, case_id: str) -> ApiResponse

get_service_attach_case_list​

def get_service_attach_case_list(court_id: str,
                                 service_contact_id: str) -> ApiResponse

get_service_information​

def get_service_information(court_id: str,
                            case_tracking_id: str) -> ApiResponse

get_service_information_history​

def get_service_information_history(court_id: str,
                                    case_tracking_id: str) -> ApiResponse

search_case_categories​

def search_case_categories(search_term: Optional[str] = None) -> ApiResponse

retrieve_case_categories​

def retrieve_case_categories(
        retrieve_name: Optional[str] = None) -> ApiResponse

get_case_categories​

def get_case_categories(court_id: str,
                        fileable_only: bool = False,
                        timing: Optional[str] = None) -> ApiResponse

get_filer_types​

def get_filer_types(court_id: str) -> ApiResponse

search_case_types​

def search_case_types(search_term: Optional[str] = None) -> ApiResponse

retrieve_case_types​

def retrieve_case_types(retrieve_name: Optional[str] = None) -> ApiResponse

get_case_types​

def get_case_types(court_id: str,
                   case_category: str,
                   timing: str = None) -> ApiResponse

get_case_type​

def get_case_type(court_id: str, case_type: str) -> ApiResponse

get_case_subtypes​

def get_case_subtypes(court_id: str, case_type: str) -> ApiResponse

search_filing_types​

def search_filing_types(search_term: Optional[str] = None) -> ApiResponse

retrieve_filing_types​

def retrieve_filing_types(retrieve_name: Optional[str] = None) -> ApiResponse

get_filing_types​

def get_filing_types(court_id: str, case_category: str, case_type: str,
                     initial: bool) -> ApiResponse

get_service_type_codes​

def get_service_type_codes(court_id: str) -> ApiResponse

search_party_types​

def search_party_types(search_term: Optional[str] = None) -> ApiResponse

retrieve_party_types​

def retrieve_party_types(retrieve_name: Optional[str] = None) -> ApiResponse

get_party_types​

def get_party_types(court_id: str, case_type_id: Optional[str]) -> ApiResponse

get_document_types​

def get_document_types(court_id: str, filing_type: str) -> ApiResponse

get_motion_types​

def get_motion_types(court_id: str, filing_type: str) -> ApiResponse

get_filing_components​

def get_filing_components(court_id: str, filing_type: str) -> ApiResponse

search_optional_services​

def search_optional_services(search_term: Optional[str] = None) -> ApiResponse

retrieve_optional_services​

def retrieve_optional_services(
        retrieve_name: Optional[str] = None) -> ApiResponse

get_optional_services​

def get_optional_services(court_id: str, filing_type: str) -> ApiResponse

get_cross_references​

def get_cross_references(court_id: str, case_type: str) -> ApiResponse

get_damage_amounts​

def get_damage_amounts(court_id: str,
                       case_category: Optional[str] = None) -> ApiResponse

get_procedure_or_remedies​

def get_procedure_or_remedies(court_id: str,
                              case_category: Optional[str] = None
                              ) -> ApiResponse

get_datafield​

def get_datafield(court_id: str, field_name: str) -> ApiResponse

get_disclaimers​

def get_disclaimers(court_id: str) -> ApiResponse

get_server_id​

def get_server_id() -> ApiResponse

get_server_name​

def get_server_name() -> ApiResponse

get_logs​

def get_logs() -> ApiResponse