PK!*Ilfastest/__init__.pyname = "fastest" PK!X fastest/__main__.pyimport argparse import os import fnmatch import time import subprocess from fastest.io.read_file import read_file from fastest.code_assets.function import get_functions from fastest.compiler import compile_tests from watchdog.observers import Observer from watchdog.events import PatternMatchingEventHandler parser = argparse.ArgumentParser(description='Create test cases automatically') parser.add_argument('--path', required=True, help='Project root, use $(pwd) to be sure') parser.add_argument('--source',required=False, help='Modules to check coverage for') parser.add_argument( '--exclude', help='Comma separated names of files/dirs that should NOT be watched', ) args = parser.parse_args() def main(): print('Monitoring started...') if not os.path.exists('./test'): os.mkdir('./test') open('./test/__init__.py', 'a') report_path = os.path.abspath(os.path.join(args.path, 'htmlcov/index.html')) class PyFileHandler(PatternMatchingEventHandler): patterns = ['*.py'] exclude_files = args.exclude if args.exclude is not None else '' ignore_patterns = [path.strip() for path in exclude_files.split(',')] ignore_patterns += ['test/*', '__pycache__', '*.pyc', '*__test.py'] def process(self, event): """ event.event_type 'modified' | 'created' | 'moved' | 'deleted' event.is_directory True | False event.src_path path/to/observed/file """ print(event.src_path, event.event_type) test_files = [ test_file.replace('.py', '') for test_file in os.listdir('./test') if '.pyc' not in test_file and '__pycache__' not in test_file ] for ignored_pattern in self.ignore_patterns: if fnmatch.fnmatch(event.src_path.replace(args.path + '/', ''), ignored_pattern): return page = read_file(args.path, event.src_path) functions = get_functions(page) compile_tests.build(functions, event.src_path, args.path) command = ['test.{}'.format(test_file) for test_file in test_files] if (args.source): subprocess.call(['pytest', 'run', '--source', args.source, '-m', 'unittest'] + command) else: subprocess.call(['coverage', 'run', '-m', 'unittest'] + command) subprocess.call(['coverage', 'report']) subprocess.call(['coverage', 'html']) print(report_path) def on_modified(self, event): self.process(event) def on_created(self, event): self.process(event) observer = Observer() observer.schedule(PyFileHandler(), args.path, recursive=True) observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join() PK!fastest/bodies/__init__.pyname = "bodies_pkg"PK!q ??fastest/bodies/f.pyimport uuid from fastest.constants import KEYS, CONTENT from fastest import code_style from fastest.bodies.testers_notes import get_testers_notes def case_generator(): return str(uuid.uuid4()).upper().replace("-", "")[0:10] def create_naive_test_case(function_object, test): function_body = function_object[KEYS.STR] function_too_long = code_style.is_function_too_long(function_body) has_too_many_conditions = code_style.has_too_many_if_statements(function_body) control_structure_overuse = code_style.get_loop_complexity(function_body) testers_notes = get_testers_notes( function_too_long, has_too_many_conditions, control_structure_overuse ) test_template = CONTENT.TEST_CASE_TEMPLATE.format( function_name=function_object[KEYS.NAME], case_id=case_generator(), ) if testers_notes: test_template += CONTENT.TESTERS_NOTES_TEMPLATE.format(testers_notes=testers_notes) if function_object[KEYS.TESTS][KEYS.VARIABLES]: for variable in function_object[KEYS.TESTS][KEYS.VARIABLES]: test_template += CONTENT.VARIABLES_TEMPLATE.format(variables=variable) test_template += CONTENT.ASSERTION_TEMPLATE.format(function=test[KEYS.FROM], value=test[KEYS.EXPECT]) return test_template PK!=JJfastest/bodies/testers_notes.pydef on_depth(depth): return """ # testers notes: # -------------- # Your function has {depth} lines of code, it is strongly advised to break them # when they are doing too many operations. """.format(depth=depth) def on_conditional_complexity(condition_complexity): return """ # testers notes: # -------------- # Your function has {condition_complexity} conditions, it is strongly advised to convert them # to individual functions. It is likely that they are doing different tasks. """.format(condition_complexity=condition_complexity) def on_control_overuse(control_overuse): return """ # testers notes: # -------------- # Your function has {control_overuse} number of nested loops!! # please try to find a better way, there has to be one. """.format(control_overuse=control_overuse) def get_testers_notes(depth, condition_complexity, control_overuse): function_too_deep, lines = depth complex_conditions, complexity = condition_complexity control_overuse, nested_loops = control_overuse notes = '' if function_too_deep: notes += on_depth(lines) + '\n\n' if complex_conditions: notes += on_conditional_complexity(complexity) + '\n\n' if control_overuse: notes += on_control_overuse(nested_loops) + '\n\n' return notes PK!"fastest/case_labyrinth/__init__.pyname = "case_labyrinth_pkg"PK!U4fastest/case_labyrinth/type_check_detect/__init__.pyname = "type_check_detect_pkg" PK!P$6fastest/case_labyrinth/type_check_detect/type_check.pydef detect_type_check(statements, argument): """ example: detect_type_check(["if type(var) is str"], "var") -> True # example: detect_type_check(["if True"], "var") -> False # :param statements: :param argument: :return: """ for statement in statements: # TODO: Does not scale need patterns for string if 'if type({argument})'.format(argument=argument) in statement: return True return False PK!XE}fastest/code_assets/__init__.pyname = "code_assets_pkg" PK!X& fastest/code_assets/arguments.pydef get_args(args_str): """ example: get_args(' (arg1, arg2) ') -> ['arg1', 'arg2'] # example: get_args('(arg1, arg2)') -> ['arg1', 'arg2'] # :param args_str: :return: """ args_str = args_str.strip() args_str = args_str.replace('(', '') args_str = args_str.replace(')', '') args = args_str.split(',') args = [arg.strip() for arg in args] return args PK!fastest/code_assets/function.pyimport re from fastest.code_assets.arguments import get_args from fastest.code_assets.variables import get_variables from fastest.code_assets.return_value import get_return_values from fastest.code_assets.naive_case_detector import get_test_from_example_passage def get_functions(page): """ example: get_functions("def fn(arg1, arg2):\narg1 += 1\n\treturn arg1 + arg2") -> [{ 'name': 'fn', 'args': ['arg1', 'arg2'], 'str': 'def fn(arg1, arg2):\n\treturn arg1 + arg2', 'vars': [], 'tests': [] }] # :param page: :return: """ statements = re.split(r'\n', page) function_map = [] function_finder = None function_running = False function_object = {} function_body_start = 0 for statement_number, _ in enumerate(statements): if function_running is False: function_finder = re.search(r'def ((\w[A-Za-z_]*[^\(])(\(.*[^:]\)))', statements[statement_number]) function_body_start = statement_number if function_finder is not None: function_running = True function_object['name'] = function_finder.group(2) function_object['args'] = get_args(function_finder.group(3)) function_finder = None if function_body_start != statement_number and re.match(r'^\s+', statements[statement_number]) is None: function_object['str'] = '\n'.join(statements[function_body_start: statement_number]) function_object['returns'] = get_return_values(function_object['str']) function_object['vars'] = get_variables(function_object['str'], function_object['args']) function_object['tests'] = get_test_from_example_passage(function_object['str']) function_map.append(function_object) function_object = {} function_running = False function_finder = None return function_map PK!}77fastest/code_assets/keywords.pyFALSE = 'False' CLASS = 'class' FINALLY = 'finally' IS = 'is' RETURN = 'return' NONE = 'None' CONTINUE = 'continue' FOR = 'for' LAMBDA = 'lambda' TRY = 'try' TRUE = 'True' DEF = 'def' FROM = 'from' NONLOCAL = 'nonlocal' WHILE = 'while' AND = 'and' DEL = 'del' GLOBAL = 'global' NOT = 'not' WITH = 'with' AS = 'as' ELIF = 'elif' IF = 'if' OR = 'or' YIELD = 'yield' ASSERT = 'assert' ELSE = 'else' IMPORT = 'import' PASS = 'pass' BREAK = 'break' EXCEPT = 'except' IN = 'in' RAISE = 'raise' RESERVED = [ FALSE, CLASS, FINALLY, IS, RETURN, NONE, CONTINUE, FOR, LAMBDA, TRY, TRUE, DEF, FROM, NONLOCAL, WHILE, AND, DEL, GLOBAL, NOT, WITH, AS, ELIF, IF, OR, YIELD, ASSERT, ELSE, IMPORT, PASS, BREAK, EXCEPT, IN, RAISE, "+", "-", "/", "*", "+=", "-=", "/=", "*=", "**", "%", "!", "@", "^", "&", "(", ")", "=", "'", "\"", "|", ">", ">=", "<", "<=", ",", "!=", "==", ":", '.' ]PK!sǀT T *fastest/code_assets/naive_case_detector.pyimport re from fastest.constants import KEYS, PATTERNS FUNCTION_CALL = 0 OUTPUT = 1 def stack_imports(import_statements): return [ import_statement.strip() + '\n' for import_statement in import_statements if len(import_statement) > 0 ] def stack_variables(variable_string): if type(variable_string) is not str: return '' variables = [ variable.strip() for variable in variable_string.split(PATTERNS.VAR_DEC) ] return variables def get_imports_from_docstring(example_passage): needed_imports = re.findall(PATTERNS.NEED_IMPORT, example_passage, re.M) needed_imports = needed_imports if len(needed_imports) > 0 else None if needed_imports is None: return [] needed_imports = ''.join(needed_imports).replace(PATTERNS.IMPORT_DEC, '').split('\n') return stack_imports(needed_imports) def get_variables_from_docstring(example_passage): needed_variables = re.findall(r'@let[\s\S]+?(?=\d\))', example_passage) needed_variables = needed_variables if len(needed_variables) > 0 else [] return stack_variables(''.join(needed_variables)) def stack_examples(examples_strings): example_stack = [] for example in examples_strings: test_function, expectation = re.sub(PATTERNS.NUMBER_BULLET, '', example, 1).split(PATTERNS.TEST_SEP) example_stack.append({ KEYS.FROM: test_function, KEYS.EXPECT: expectation }) return example_stack def get_test_case_examples(example_passage): examples_strings = re.findall(PATTERNS.TEST_CASE_EXAMPLE, example_passage, re.M) examples_strings = examples_strings if len(examples_strings) > 0 else None return stack_examples(examples_strings) def get_test_from_example_passage(statements): example_passage = re.findall(PATTERNS.EXAMPLE_PASSAGE, statements, re.I) example_passage = example_passage[0] if len(example_passage) > 0 else None if example_passage is None: return None import_statements = get_imports_from_docstring(example_passage) variables = get_variables_from_docstring(example_passage) examples = get_test_case_examples(example_passage) return None \ if examples is None \ else { KEYS.IMPORTS: import_statements, KEYS.VARIABLES: variables, KEYS.EXAMPLES: examples } PK!AMegii#fastest/code_assets/return_value.pyimport re def get_return_values(statements): """ example: get_return_values('return 5') -> ['5'] # example: get_return_values('') -> [None] # :param statements: :return: """ return_values = re.findall(r'return [\s\S]+?(?=\n)', statements) if len(return_values) > 0: return return_values else: return [None] PK!~~ fastest/code_assets/variables.pyimport re from fastest.code_assets import keywords def get_variables(statements, arguments): """ example: get_variables("def fn(arg1, arg2):\n\tc = 4\n\treturn arg1 + arg2", ["arg1", "arg2"]) -> ["c"] # :param statements: :param arguments: :return: """ statements = statements.split('\n') statements = statements[1:] statements = ' '.join(statements) statements = re.sub(r'\s+', ' ', statements).replace(':', '') words = statements.split(' ') exclude_options = keywords.RESERVED + arguments return list(set([word for word in words if word not in exclude_options and word.isalpha()])) PK!c__fastest/code_style/__init__.pyfrom fastest.code_style.control_overuse import * from fastest.code_style.depth_metric import * PK!,occ%fastest/code_style/control_overuse.pyimport re CURRENT_CONDITIONAL_THRESHOLD = 5 CURRENT_CONTROL_COMPLEXITY_THRESHOLD = 3 def has_too_many_if_statements(function_body): """ example: has_too_many_if_statements("if \nif \nif \nif \nif \nif \nif ") -> (True, 7) # example: has_too_many_if_statements("if if if") -> (False, 3) # :param function_body: :return: """ matches = re.findall(r'if|elif|else', function_body) return len(matches) >= CURRENT_CONDITIONAL_THRESHOLD, len(matches) def get_indent_of_loop(statement): """ example: get_indent_of_loop(" for i in range(10):") -> 3 # :param statement: :return: """ return len(re.findall(r'\s+?(?=for)', statement)[0]) def get_statements_from_function_body(function_body): """ example: get_statements_from_function_body("a\n b") -> ['a', ' b'] # :param function_body: :return: """ return [ statement for statement in function_body.split('\n') if len(statement.strip()) > 0 ] def count_loop_indents(function_body): """ example: count_loop_indents(" for i in range(1):") -> [3] # :param function_body: :return: """ statements = get_statements_from_function_body(function_body) loops = [] for statement in statements: if re.match(r'for ', statement.strip()): loops.append(get_indent_of_loop(statement)) return loops def get_loop_complexity(function_body): """ example: get_loop_complexity(" for i in range(1):\n for i in range(1):") -> (False, 1) # :param function_body: :return: """ loop_indents = count_loop_indents(function_body) complexity = 0 for i, _ in enumerate(loop_indents): if len(loop_indents) > i + 1 and loop_indents[i] < loop_indents[i + 1]: complexity += 1 return CURRENT_CONTROL_COMPLEXITY_THRESHOLD < complexity, complexity PK!`"fastest/code_style/depth_metric.pyCURRENT_DEPTH_THRESHOLD = 20 def is_function_too_long(function_body): """ example: is_function_too_long("\n\n\n\n\n") -> (False, 6)# example: is_function_too_long("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n") -> (True, 31) # :param function_body: :return: """ naive_code_depth = len(function_body.split('\n')) return naive_code_depth >= CURRENT_DEPTH_THRESHOLD, naive_code_depth PK!Wfastest/compiler/__init__.pyname = "compiler_pkg" PK!!fastest/compiler/compile_tests.pyimport os from fastest.bodies import f from fastest.constants import CONTENT, KEYS, SYS def add_imports_for_test_case(test, imports): if test[KEYS.IMPORTS] is None: return imports for import_statement in test[KEYS.IMPORTS]: imports.add(import_statement) return imports def create_test_class(imports, contents, deps_import, function_object, root_module_name): if len(function_object[KEYS.TESTS]) == 0: return None imports.add(CONTENT.IMPORT_UNITTEST) imports.add(CONTENT.DEPS_IMPORT_TEMPLATE.format(deps_import, function_object[KEYS.NAME])) contents.append(CONTENT.CLASS_CREATE_TEMPLATE.format(root_module_name, function_object[KEYS.NAME])) return imports, contents def create_test_case_content(function_object, imports, contents): for example in function_object[KEYS.TESTS][KEYS.EXAMPLES]: contents.append(f.create_naive_test_case(function_object, example)) imports = add_imports_for_test_case(function_object[KEYS.TESTS], imports) return imports, contents def create_test_case(function_objects, deps_import, root_module_name): imports = set() contents = [] for function_object in function_objects: if function_object is None: continue if function_object[KEYS.TESTS] is None: continue imports, contents = create_test_class(imports, contents, deps_import, function_object, root_module_name) imports, contents = create_test_case_content(function_object, imports, contents) return imports, contents def write_tests_to_file(fp, imports, contents): return fp.write(''.join(sorted(list(imports)) + contents)) def build(function_objects, src_file_path, base_path): last_file = -1 test_file_name = src_file_path.split(SYS.SLASH)[last_file].replace('.py', SYS.TEST_FILE_ENDING) deps_import = src_file_path.replace(base_path + SYS.SLASH, '').replace(SYS.SLASH, '.').replace('.py', '') root_module_name = deps_import.split('.')[-1] test_file_path = os.path.join(base_path, KEYS.TEST, test_file_name) with open(test_file_path, 'w+') as fp: imports, contents = create_test_case(function_objects, deps_import, root_module_name) write_tests_to_file(fp, imports, contents) PK! fastest/constants.pyimport platform class SYS: __UNIX_SLASH = '/' __WINDOWS_SLASH = '\\' PY = '.py' SLASH = __WINDOWS_SLASH if platform.system == 'Windows' else __UNIX_SLASH TEST_FILE_ENDING = '__test.py' class KEYS: IMPORTS = 'imports' NAME = 'name' TESTS = 'tests' TEST = 'test' STR = 'str' EXAMPLES = 'examples' FROM = 'from' EXPECT = 'expect' VARIABLES = 'variables' class CONTENT: CLASS_CREATE_TEMPLATE = '\nclass Test{}{}(unittest.TestCase):\n' IMPORT_UNITTEST = 'import unittest\n' DEPS_IMPORT_TEMPLATE = 'from {} import {}\n' TEST_CASE_TEMPLATE = ' def test__{function_name}__{case_id}(self):' TESTERS_NOTES_TEMPLATE = ' {testers_notes}' VARIABLES_TEMPLATE = ' {variables}\n' ASSERTION_TEMPLATE = ' self.assertEqual({function}, {value})\n\n' class PATTERNS: FUNCTION_CALL = r'example: [\s\S]+?(?=->)' IMPORT_DEC = '@need\n' VAR_DEC = r'@let ' NEED_IMPORT = r'@need[\s\S]+?(?=@let|\d\))' NEEDED_VARIABLES = r'@let[\s\S]+?(?=\d\))' NUMBER_BULLET = r'\d\) ' TEST_CASE_EXAMPLE = r'\d\) [\s\S]+?(?=\n)' EXAMPLE_PASSAGE = r'-{3,}[\s\S]+?(?=---)' TEST_SEP = ' -> ' PK![nfastest/io/__init__.pyname = "io_pkg" PK!ً9fastest/io/read_file.pyimport os def get_current_directory(): return os.path.dirname(os.path.realpath(__file__)) def read_file(dir_path, file_path): goal_dir = os.path.join(dir_path, file_path) with open(os.path.abspath(goal_dir), 'r') as fp: contents = fp.read() return contents PK!_RSfastest/type/__init__.pyname = "type_pkg" PK!fastest/type/type_inference.pyfrom fastest.type import type_usage_patterns INT = 0 STR = 1 LIST = 2 TUPLE = 3 DICT = 4 type_map = ['int', 'str', 'list', 'tuple', 'dict'] def infer(variable, statements): """ example: infer("list_var", "def fn():\n\tlist_var = [1]") -> ['list'] # example: infer("some_var", "def fn():\n\tsome_var + some_other") -> ['int', 'str'] # :param variable: :param statements: :return: """ statements = statements.split('\n') statements = statements[1:] type_chances = [0] * 5 for statement in statements: type_chances[INT] += type_usage_patterns.used_as_int(statement, variable) type_chances[STR] += type_usage_patterns.used_as_str(statement, variable) type_chances[LIST] += type_usage_patterns.used_as_list(statement, variable) type_chances[TUPLE] += type_usage_patterns.used_as_tuple(statement, variable) type_chances[DICT] += type_usage_patterns.used_as_dict(statement, variable) max_prob_type = max(type_chances) if type_chances.count(max_prob_type) > 1: return [type_map[i] for i, type_chance in enumerate(type_chances) if type_chance == max_prob_type] else: return [type_map[type_chances.index(max_prob_type)]] PK!rwL#fastest/type/type_usage_patterns.pyimport re from fastest.utils import count_truthy def used_as_int(statement, variable): """ example: used_as_int("a = 4", "a") -> 1 # example: used_as_int("a + 4", "a") -> 1 # example: used_as_int("a * 4", "a") -> 1 # example: used_as_int("a - 4", "a") -> 1 # :param statement: :param variable: :return: """ statement = statement.strip() assignment = re.search(r'{variable}\s*=\s*\d+'.format(variable=variable), statement) addition = re.search(r'{variable}\s*\+\s*'.format(variable=variable), statement) addition_inc = re.search(r'{variable}\s*\+=\s*\d+'.format(variable=variable), statement) multiplication = re.search(r'{variable}\s*\*\s*'.format(variable=variable), statement) subtraction = re.search(r'{variable}\s*-\s*'.format(variable=variable), statement) division = re.search(r'{variable}\s*/\s*'.format(variable=variable), statement) return count_truthy([assignment, addition, subtraction,multiplication, division, addition_inc]) def used_as_str(statement, variable): """ example: used_as_str("string_var = 'something'", "string_var") -> 1 # example: used_as_str("string_var + 'something'", "string_var") -> 1 # example: used_as_str("string_var * 5", "string_var") -> 1 # :param statement: :param variable: :return: """ statement = statement.strip() assignment = re.match('{variable}\s*=\s*"|\'\w*"|\''.format(variable=variable), statement) addition = re.match(r'{variable}\s*\+\s*'.format(variable=variable), statement) multiplication = re.match(r'{variable}\s*\*\d*'.format(variable=variable), statement) return count_truthy([assignment, addition, multiplication]) def used_as_iterable(statement, variable): """ example: used_as_iterable("for word in words", "words") -> 1 # :param statement: :param variable: :return: """ statement = statement.strip() loop = re.match(r'for \w+ in {variable}'.format(variable=variable), statement) map_fn = re.search(r'map\(.*[^,)],\s*{variable}'.format(variable=variable), statement) filter_fn = re.search(r'filter\(.*[^,)],\s*{variable}'.format(variable=variable), statement) reduce_fn = re.search(r'reduce\(.*[^,)],\s*{variable}'.format(variable=variable), statement) item_index = re.match(r'{variable}\[\d+\]'.format(variable=variable), statement) return count_truthy([loop, map_fn, filter_fn, reduce_fn, item_index]) def used_as_list(statement, variable): """ example: used_as_list("apples.append(10)", "apples") -> 1 # example: used_as_list("apples = [11, 12]", "apples") -> 1 # :param statement: :param variable: :return: """ statement = statement.strip() assignment = re.match(r'{variable}\s*=\s*\['.format(variable=variable), statement) assignment_as_instance = re.match(r'{variable}\s*=\s*list\('.format(variable=variable), statement) append = re.search(r'{variable}.append\('.format(variable=variable), statement) return count_truthy([assignment_as_instance, assignment, append]) + used_as_iterable(statement, variable) def used_as_tuple(statement, variable): """ example: used_as_tuple("words = (11, 2)", "words") -> 1 # :param statement: :param variable: :return: """ statement = statement.strip() assignment = re.match(r'{variable}\s*=\s*\('.format(variable=variable), statement) assignment_as_instance = re.match(r'{variable}\s*=\s*tuple\('.format(variable=variable), statement) insert = re.match(r'{variable}.insert\('.format(variable=variable), statement) return count_truthy([assignment_as_instance, assignment, insert]) + used_as_iterable(statement, variable) def used_as_dict(statement, variable): """ example: used_as_dict("dict_input['val']", "dict_input") -> 1 # :param statement: :param variable: :return: """ statement = statement.strip() assignment = re.search(r'{variable}\s*=\s*\{{'.format(variable=variable), statement) key_ref_str = re.search(r'{variable}\[\"|\'\w+\"|\'\]'.format(variable=variable), statement) key_ref_var = re.search(r'{variable}\[\w+\]'.format(variable=variable), statement) get_access = re.search(r'{variable}.get\('.format(variable=variable), statement) return count_truthy([assignment, key_ref_str, key_ref_var, get_access]) PK!No'@fastest/utils.pydef count_truthy(items): counter = 0 for item in items: if item is not None: counter += 1 return counter PK!H<+1)fastest-0.0.11.dist-info/entry_points.txtN+I/N.,()JK,.I-.z񹉙yV PK!HڽTUfastest-0.0.11.dist-info/WHEEL A н#Z;/"d&F[xzw@Zpy3Fv]\fi4WZ^EgM_-]#0(q7PK!Hʰ!fastest-0.0.11.dist-info/METADATAX8ː`Olf°.e󃢬ԶzGRk[xSC3OǓ;ݲ<2Ōws/pb4VjF7I(化:i]mqW,x&\h<<ܮe)T1#wnQ|ypzܟ֪Pjٌ~~յk3m\yiʈ\T|7߸7AyQ O =828qꡍpi>H1PL3z%kmf;?65vLWNVnf[N^xwMEGc{HpRS)2qitIBu U垚3wŖlS8ކ Z-ttUlQwg:l%vZ-тOnD&GB'dr{' 9-o/tz7_V_qƤt_yjS#Q4 zi PjUza&3S)4+@0Uo(muz8-UdN8#ʲm>+ kaDZU+mB]5"dZQXLisP}Ѭ_vE75$¼{\6Wȼz[2NLMʎ4u8f]UttD*E%ILΣT/w [(]:m{ӾRq႒eKmvRkd<\oΚBO&g &x3%A@r,p !#-nk8O(\sWG{"HkQ4P^_C6<7ME֯kid4C|re2[9#7 !4.2P4xt>4Q+jlqGO㄂,G$]S+<Ŗ2M!ttLA]VVՍ-CR1IfQD9&IpB?%cg撟2-mu `Е#}ϖ &-YCcNR "-ʻAU8qi*,Թ$g>S?_\kCX&T<($w1mk׮!~aa{N4::fkLE7 &Pxq3hN~F4N? tFb~=+e?zֲRs/+qFbJ,c3g}:J#MczT~y >8!ʷQz}8X. }cTU`^}]8koL^2R T/Ꮉ)kk r8\ԴH,tJ^8 >4S؟YgLyAyp>*p5bgNԙfF]Pu:ACYX.2kdSQEdu,r%Fj|"#/?{No]/u4lb38RZkΩR"iyu*oe8|U \kB-H/ƈ>ʀ9`t̀)PIUɵrQ~ah>Em!v[]>.H[Ucê1EVi?U[pj[6GjŤ5>EPZ)@sKq9 SQ6c@ 8"K̥)aww 9bӶh*$5}G d<>SOE A꣟ WĜ'3[ 2(q|RGHI&8 { J W2Bá<'uڮ/j seIo|X/>] A|7`|UUj(dBpE=/dBMq/Bold[HLN&ovXU~E~Ѿrwċ<'@۞K~_قN_n`l 1SowiIxu7߇6|h͕n,Ѝ33dgnv"*Qp| th8 ^l;_iC4|Ч(H#7WXAMs܍_P^{ Zz14H۝;"/}oN+V =DPK!Hf{O fastest-0.0.11.dist-info/RECORDɒXE-,ޢLB @b1;鶌̴UbetT;B7+Qےo[Wdѽ6N“-0O4wJ~&/JAXrv^BB= 8I>>.[$͒nIBb|5IM2ϻss|$M}qC>o]\6dNKvmo+G*Z=A q,ۘlG?}Ia!҅V(Hoe  "ƳAG7WSžLU'ibhUpk1ds?~Zz1V-7pwӊiNZɎC)2o>w:<[zr*kdYRbYBpz+ `.],Dfa9uJmQq'Z喀 g*W2LsJgyuZzC3?ES |}N-a( ⃀q.t ƱBч%25hxKwG|r$EeCӦ[L eỞTV#/yzjoCw2u6L<_ ŲCx{wF`ֺCܺm@i~s& _ H<U=`S1#ݏ~꜡`3b)G!; v4Z|~OWud0g[-_KxepG " boMc^nޖbRt-:^بM U>\UM _D<)7ug5T:QJhϝxTG({H &sxWp?z)źʽl`툵DXP]8 u!v%zEP칄RqTqϒ`EoPK!*Ilfastest/__init__.pyPK!X Bfastest/__main__.pyPK! fastest/bodies/__init__.pyPK!q ??_ fastest/bodies/f.pyPK!=JJfastest/bodies/testers_notes.pyPK!"Vfastest/case_labyrinth/__init__.pyPK!U4fastest/case_labyrinth/type_check_detect/__init__.pyPK!P$6"fastest/case_labyrinth/type_check_detect/type_check.pyPK!XE}>fastest/code_assets/__init__.pyPK!X& fastest/code_assets/arguments.pyPK!`fastest/code_assets/function.pyPK!}77*$fastest/code_assets/keywords.pyPK!sǀT T *)fastest/code_assets/naive_case_detector.pyPK!AMegii#:3fastest/code_assets/return_value.pyPK!~~ 4fastest/code_assets/variables.pyPK!c__7fastest/code_style/__init__.pyPK!,occ%;8fastest/code_style/control_overuse.pyPK!`"?fastest/code_style/depth_metric.pyPK!WAfastest/compiler/__init__.pyPK!! Bfastest/compiler/compile_tests.pyPK! ;Kfastest/constants.pyPK![nPfastest/io/__init__.pyPK!ً9_Pfastest/io/read_file.pyPK!_RSQfastest/type/__init__.pyPK!Qfastest/type/type_inference.pyPK!rwL#0Wfastest/type/type_usage_patterns.pyPK!No'@kifastest/utils.pyPK!H<+1)"jfastest-0.0.11.dist-info/entry_points.txtPK!HڽTUjfastest-0.0.11.dist-info/WHEELPK!Hʰ!$kfastest-0.0.11.dist-info/METADATAPK!Hf{O -tfastest-0.0.11.dist-info/RECORDPKM (z