lib-typ-parse 0.0.0

No project description provided

Typon Client

Typon Client is the client library for producing typon code.

import lib_typ_parse.typon_client as typon_client

serviceEndpoint = 'http://127.0.0.1:8081'
api_key = 'API_KEY'
target_module = 'drivers.cache_server_driver'
module_dir = '/home/user/software/cache'
out_dir = '/home/user/software/cache/bin'
exe_name = 'cache_server_driver'

# retrieve .cpp source from server; stores .cpp file in {out_dir}/{exe_name}.cpp
# AND compiles {out_dir}/{exe_name}.cpp to {out_dir}/{exe_name}.exe
typon_client.compileCpp(serviceEndpoint, target_module, module_dir, out_dir, exe_name)
# retrieve .exe source from server; stores .exe file in {out_dir}/{exe_name}.exe
typon_client.compileExe(serviceEndpoint, api_key, target_module, module_dir, out_dir, exe_name)

This client intends to support modular software development in the typon language. E.g.

# in {module_dir}
python3 -m {target_module}

Except only executable software is generated, not executed.

Installing Typon Client and Supported Versions

Typon Client is available on PyPI:

$ python3 -m pip install typon_client

Typon Client officially supports Python 3.7+.

Typon Language

Typon is a statically typed language (derived from c++) with an efficient grammar resembling Python3. This language seeks to capture the performance benefits of c++ while maintaining python level simplicity. We list the basic grammatical constructs below; then we provide some sample code to fill in the blanks. Typing is optional when the right-hand side is type resolvable. Scope (e.g.) brackets are determined by indentation level, like in python.

# type list
primitives = int, int32, uint32, uint64, dbl, char, str, bool, fileptr
# vector
varName: vec[item_type] = [v_1, ... , v_n]
# hash map
varName: hmap[key_type, val_type] = { k_1 : v_1, ... , k_n : v_n }
# sorted map
varName: smap[key_type, val_type] = s{ k_1 : v_1, ... , k_n : v_n }
# tuple
varName: tupl[type_1, ... , type_n ] = t[ v_1, ... , v_n ]

# typed statement
[varName]: [varType] = [varValue]
# non-typed statement
[varName] = [varValue]

# control flow
if [condition]:
  [statement]
else:
  [statement]

for [varName] in [vector]:
  [loopBody]

while [condition]:
  [loopBody]

# function definition
fxn [fxnName](arg_1: [type_1], ... , arg_n: [type_n]) -> [ret_type]:
  [fxn_body]

# class definition, no inheritance
class [className]():
  # constructor
  fxn __init__(args):
    [constructorBody]

  # destructor
  fxn __deinit__():
    [destructorBody]

# imports grammar
include [c_pkg_name]
import [subpkg].[module_name] as [module_alias]

Typon Sample

Sample Typon Code to demonstrate features. Note that custom class instances must be deleted upon use.

include ds_utils
import core.search_index as search_index
import utils.eval_utils as eval_utils
import utils.eval_utils2 as eval_utils2
import utils.eval_structs as eval_structs
import utils.search_utils as search_utils
import parsing.condition_parsing as condition_parsing

# resolution of attr_name type:
# on parse attr_name: check [table_obj.doc_attrs.attr_type_map]
# recall:
# [table_obj.doc_attrs.attr_type_map]: ( attr_id ) => ( attr_type in [ int, dbl, str ] )
# [ int, dbl, str ] ~ [ char(0), char(1), char(2) ]

class search_condition():

    fxn __members__():
        table_obj: search_index.search_table
        eval_tree: eval_structs.evaluation_tree
        valid: bool

    fxn __init__(
        table_obj: search_index.search_table,
        attr_cond_query: str,
        attr_cond_int_values: vec[int],
        attr_cond_dbl_values: vec[dbl],
        attr_cond_str_values: vec[str]
    ):

        this.table_obj = table_obj
        tok_stream = condition_parsing.tokenize_query_text( attr_cond_query, table_obj.condl_consts.delim_chars )
        eval_tree, parse_success = eval_utils2.compute_eval_tree(
            tok_stream,
            0,
            len(tok_stream),
            this,
            attr_cond_int_values,
            attr_cond_dbl_values,
            attr_cond_str_values
        )

        this.eval_tree = eval_tree

        this.valid = true
        if not parse_success:
            this.valid = false

    fxn __deinit__():
        delete this.eval_tree

    fxn matches_doc(
        doc_id: int
    ) -> bool:
        if not this.valid:
            return false

        eval_type = this.eval_tree.evaluate( doc_id, this )
        this.eval_tree.value_type = eval_type

        # case: undefined
        if eval_type == char(4):
            return false
        # case: bool
        if eval_type == char(3):
            return this.eval_tree.val_bool
        # case: str
        if eval_type == char(2):
            return len( this.eval_tree.val_str ) > 0
        # case: dbl
        if eval_type == char(1):
            return this.eval_tree.val_dbl != 0.0
        # case: int
        return this.eval_tree.val_int != 0

AutoGeneratedDocs: -- package_name -- function_name -- class_name -- internal_method_name

lib_typ_parse.helper.__init__



lib_typ_parse.helper.type_resolver

    def reduce_rel_type( target_module, current_module, rel_type, reverse_imports_map )
    
    def compute_relative_type(abs_type, current_module, reverse_imports_map)
    
    def resolve_map_type_L0_skeleton(typon_map_type, L0_skeleton)
    
    def read_tuple_types_typon_L0_skeleton(ws_removed_typon_tuple_type, L0_skeleton)
    
    def read_args_ret_from_fxn_typon_type(ws_removed_typon_fxn_type)

lib_typ_parse.helper.eval_service

    def resolve_func_type_from_arguments(arguments)
    
    def resolve_args_only_func_type(arguments)
    
    def resolve_func_type_from_arguments_msa(arguments, module_L0_skeleton, current_module)
    
    def resolve_args_only_func_type_msa(arguments, module_L0_skeleton, current_module)
    
    def is_valid_var_name(var_name)

lib_typ_parse.helper.eval_helper

    def extract_id_var_tuple(S2)
    
    def read_fxn_params(arg_str)
    
    def fmt_type_module_space_aware_module_L0_skeleton(input_typon_type, current_module, module_L0_skeleton)

lib_typ_parse.__init__



lib_typ_parse.__api__



lib_typ_parse.parse.__init__



lib_typ_parse.parse.parser

    def parse_fxn(code, index, scope)
    
    def parse_class(code, index, scope)
    
    def parse_try(code, index, scope)
    
    def parse_except(code, index, scope)
    
    def parse_L1_CE(code, index, scope, token)
    
    def parse_L0_statement(code, index, scope)
    
    def parse_import(code, index, scope)
    
    def parse_include(code, index, scope)
    
    def parse_abstract_statement(code, index, scope, start_token)
    
    def read_scope(code, index, scope)

lib_typ_parse.parse.parse_L0_skeleton

    def assert_code_topology(current_module, item_skeleton)
    
    def assert_single_main(item_skeletons)
    
    def select_modules_to_read(item_skeleton)
    
    def read_import_to_skeleton(item, module_L0_skeleton, current_module)
    
    def read_include_to_skeleton(item, module_L0_skeleton, current_module)
    
    def read_fxn_to_skeleton(item, module_L0_skeleton, current_module)
    
    def read_class_members_to_skeleton(class_name, statement, module_L0_skeleton, current_module)
    
    def read_constructor_to_skeleton(class_name, statement, module_L0_skeleton, current_module)
    
    def read_destructor_to_skeleton(class_name, statement, module_L0_skeleton, current_module)
    
    def read_class_fxn_to_skeleton(class_name, statement, module_L0_skeleton, current_module)
    
    def read_class_to_skeleton(item, module_L0_skeleton, current_module)
    
    def read_instruction_to_skeleton(item, module_L0_skeleton, current_module)
    
    def read_ordered_L0_statements(item_skeleton)
    
    def format_L0_skeleton(item_skeleton, current_module, code)
    
    def read_L0_skeleton(current_module, item_skeleton, code)
    
    def fmt_code(src_dir)
    
    def select_code_skeletons(target_module, module_dir)

lib_typ_parse.parse.parse_skeleton

    def select_reverse_imports_map(skeleton)
    
    def map_rel_type( abs_type, module_name, reverse_imports_map )
    
    def condense_fxn(fxn_def, module_name, reverse_imports_map)
    
    def condense_class(class_def, module_name, reverse_imports_map)
    
    def read_absolute_skeleton(target_module, module_dir)
    
    def read_relative_skeleton(target_module, module_dir)
    
    def p1()
    
    def main()

lib_typ_parse.typon_client

    def compileCpp(serviceEndpoint, api_key, target_module, module_dir, out_dir, exe_name, printProg=True)
    
    def compileExe(serviceEndpoint, api_key, target_module, module_dir, out_dir, exe_name, printProg=True)

lib_typ_parse.utils.__init__



lib_typ_parse.utils.constants

    def select_item_prefix(item_name)
    
    def select_primitives()
    
    def select_bracket_map()

lib_typ_parse.utils.exceptions

    def find_all(s, t, index)
    
    def raise_exception_msg(code, index, error_msg)
    
    def raise_exception_msgs(code, index, error_msgs)
    
    def raise_exception_raw(error_msgs)
    
    def raise_exception_ue(error_msgs)
    
    def raise_exception_ue_cm(error_msgs, current_module)
    
    def raise_exception_ST(symbol_table, errors)
    
    def format_parse_tree(abstract_tree)
    
    def raise_inv_exception_decl(exception_decl, symbol_table)
    
    def raise_invalid_raise_exception(symbol_table)
    
    def raise_class_not_found_exception(symbol_table, class_name, target_module)
    
    def raise_inv_assertion_declaration(symbol_table, interior_assert_typon_type)
    
    def raise_exception_L0_skeleton(errors, current_module, L0_skeleton)
    
    def raise_parsing_exception(error_msg_str, current_module, src_dir)

lib_typ_parse.utils.fmt_utils

    def format_indent(indent_str, multiline_str)
    
    def serialize_json(py_dict)
    
    def print_json(py_dict)
    
    def select_module_src_dir(module_dir, target_module)
    
    def read_module_src(module_dir, target_module)

lib_typ_parse.utils.parsing_utils

    def indent_multiline_str(indent_str, multiline_str)
    
    def get_fmt_str_expr_closure(target_substr, open_index, symbol_table)
    
    def get_char_closure(s, index)
    
    def get_unescaped_quote(s, index, quote)
    
    def close_triple_quote(s, index, trq)
    
    def get_quote_closure(s, index)
    
    def is_escaped_quote(s, index)
    
    def get_cleared_char_closure(s, index)
    
    def read_next_cleared_char(s, index, target_char)
    
    def parse_current_scope(source_code, scope_start_index)
    
    def read_init_token(source_code, index, scope)
    
    def select_token_index(tok_stream, target_token)
    
    def get_token_stream_closure(tok_stream, i_start)
    
    def get_expr_aware_closure(tok_stream, index, symbol_table)
    
    def find_all_expr_aware(tok_stream, index, symbol_table, target_token)
    
    def split_expr_aware(tok_stream, symbol_table, target_token)
    
    def split_arg_typle(s, index)
    
    def read_delimited_types(type_str)
    
    def parse_fxn_type(function_type, symbol_table)

lib_typ_parse.utils.transform_data