Skip to main content

EFSPIntegration.efm_client

logging​

re​

pycountry​

Dict​

Union​

requests​

LoggerAdapter​

Response​

PreparedRequest​

all_variables​

get_config​

DAObject​

log​

Person​

Individual​

DAStore​

DAEmpty​

DADateTime​

as_datetime​

reconsider​

current_context​

ALDocumentBundle​

ALIndividual​

ApiResponse​

LoggerWithContext​

EfspConnection​

_user_visible_resp​

__all__​

DALogger Objects​

class DALogger(LoggerAdapter)

__init__​

def __init__(logger)

log​

def log(level, msg, *args, **kwargs)

Delegate a log call to Docassemble's log function, after adding contextual information from this adapter instance.

state_name_to_code​

def state_name_to_code(state_name: str) -> str

_give_data_url​

def _give_data_url(bundle: ALDocumentBundle, key: str = "final") -> None

Prepares the filing documents by setting a semi-permanent enabled and a data url The document bundle can either consist of documents or other document bundles. But each top element will sent to Tyler as a separate filing document, and needs to have the necessary attributes set (tyler_filing_id, etc)

_remove_all_da_emptys​

def _remove_all_da_emptys(json_val)

_get_all_vars​

def _get_all_vars(bundle: ALDocumentBundle, key: str = "final") -> Dict

Strips out some extra big variables that we don't need to serialize and send across the network

ProxyConnection Objects​

class ProxyConnection(EfspConnection)

The main class you use to communicate with the E-file proxy server from docassemble.

Many methods are unchanged from the parent class, EfspConnection, and are documented there.

__init__​

def __init__(*,
             url: str = None,
             api_key: str = None,
             credentials_code_block: str = "tyler_login",
             default_jurisdiction: str = None)

Creates the connection. Tries to get params from docassemble's config, but can be overriden with parameters to init.

_call_proxy​

def _call_proxy(req: PreparedRequest) -> ApiResponse

get_logger​

def get_logger()

authenticate_user​

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

Params: tyler_email (str) tyler_password (str)

register_user​

def register_user(person: Union[Individual, 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

update_firm​

def update_firm(firm: Union[Dict, Person]) -> ApiResponse

update_service_contact​

def update_service_contact(service_contact_id: str,
                           service_contact: Union[Individual, 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: Union[Dict, Individual],
                           *,
                           is_public: bool,
                           is_in_master_list: bool,
                           admin_copy: str = None) -> ApiResponse

check_filing​

def check_filing(court_id: str, court_bundle: Union[ALDocumentBundle,
                                                    dict]) -> ApiResponse

file_for_review​

def file_for_review(
        court_id: str, court_bundle: Union[ALDocumentBundle,
                                           dict]) -> ApiResponse

get_service_types​

def get_service_types(
        court_id: str,
        court_bundle: Union[ALDocumentBundle, 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, court_bundle: Union[ALDocumentBundle,
                                                             dict])

get_return_date​

def get_return_date(court_id: str, req_return_date,
                    court_bundle: Union[ALDocumentBundle, dict])

get_cases​

def get_cases(court_id: str,
              *,
              person: ALIndividual = None,
              docket_number: str = None)

serialize_person​

def serialize_person(person: Union[Person, Individual]) -> Dict

Converts a Docassemble Person or Individual into a dictionary suitable for json.dumps and in format expected by Tyler-specific endpoints on the EFSPProxy