Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/lark/load

685 def __init__(self, rule_defs: List[Tuple[str, Tuple[str, ...], Tree, RuleOptions]], term_defs: List[Tuple[str, Tuple[Tree, int]]], ignore: List[str]) -> None:

686 self.term_defs = term_defs

687 self.rule_defs = rule_defs

688 self.ignore = ignore

689

690 __serialize_fields__ = 'term_defs', 'rule_defs', 'ignore'

691

692 def compile(self, start, terminals_to_keep) -> Tuple[List[TerminalDef], List[Rule], List[str]]:

693 # We change the trees in-place (to support huge grammars)

694 # So deepcopy allows calling compile more than once.

695 term_defs = [(n, (nr_deepcopy_tree(t), p)) for n, (t, p) in self.term_defs]

696 rule_defs = [(n, p, nr_deepcopy_tree(t), o) for n, p, t, o in self.rule_defs]

697

698 # ===================

699 # Compile Terminals

700 # ===================

701

702 # Convert terminal-trees to strings/regexps

703

704 for name, (term_tree, priority) in term_defs:

705 if term_tree is None: # Terminal added through %declare

706 continue

707 expansions = list(term_tree.find_data('expansion'))

708 if len(expansions) == 1 and not expansions[0].children:

709 raise GrammarError("Terminals cannot be empty (%s)" % name)

710

711 transformer = PrepareLiterals() * TerminalTreeToPattern()

712 terminals = [TerminalDef(name, transformer.transform(term_tree), priority)

713 for name, (term_tree, priority) in term_defs if term_tree]

714

715 # =================

716 # Compile Rules

717 # =================

718

719 # 1. Pre-process terminals

720 anon_tokens_transf = PrepareAnonTerminals(terminals)

721 transformer = PrepareLiterals() * ValidateSymbols() * anon_tokens_transf # Adds to terminals

722

723 # 2. Inline Templates

724

725 transformer *= ApplyTemplates(rule_defs)

726

727 # 3. Convert EBNF to BNF (and apply step 1 & 2)

728 ebnf_to_bnf = EBNF_to_BNF()

729 rules = []

730 i = 0

731 while i < len(rule_defs): # We have to do it like this because rule_defs might grow due to templates

732 name, params, rule_tree, options = rule_defs[i]

733 i += 1

734 if len(params) != 0: # Dont transform templates

735 continue

736 rule_options = RuleOptions(keep_all_tokens=True) if options and options.keep_all_tokens else None

737 ebnf_to_bnf.rule_options = rule_options

738 ebnf_to_bnf.prefix = name

739 anon_tokens_transf.rule_options = rule_options

740 tree = transformer.transform(rule_tree)

741 res: Tree = ebnf_to_bnf.transform(tree)

742 rules.append((name, res, options))

743 rules += ebnf_to_bnf.new_rules

744

745 assert len(rules) == len({name for name, _t, _o in rules}), "Whoops, name collision"

746

747 # 4. Compile tree to Rule objects

748 rule_tree_to_text = RuleTreeToText()

749

750 simplify_rule = SimplifyRule_Visitor()

751 compiled_rules: List[Rule] = []

752 for rule_content in rules:

753 name, tree, options = rule_content

754 simplify_rule.visit(tree)

755 expansions = rule_tree_to_text.transform(tree)

756

757 for i, (expansion, alias) in enumerate(expansions):

758 if alias and name.startswith('_'):

759 raise GrammarError("Rule %s is marked for expansion (it starts with an underscore) and isn't allowed to have aliases (alias=%s)"% (name, alias))

760

761 empty_indices = tuple(x==_EMPTY for x in expansion)

762 if any(empty_indices):

763 exp_options = copy(options) or RuleOptions()

764 exp_options.empty_indices = empty_indices

765 expansion = [x for x in expansion if x!=_EMPTY]

766 else:

767 exp_options = options

768

769 for sym in expansion:

770 assert isinstance(sym, Symbol)

771 if sym.is_term and exp_options and exp_options.keep_all_tokens:

772 assert isinstance(sym, Terminal)

773 sym.filter_out = False

774 rule = Rule(NonTerminal(name), expansion, i, alias, exp_options)

775 compiled_rules.append(rule)

776

777 # Remove duplicates of empty rules, throw error for non-empty duplicates

778 if len(set(compiled_rules)) != len(compiled_rules):

779 duplicates = classify(compiled_rules, lambda x: x)

780 for dups in duplicates.values():

781 if len(dups) > 1:

782 if dups[0].expansion:

783 raise GrammarError("Rules defined twice: %s\n\n(Might happen due to colliding expansion of optionals: [] or ?)"

784 % ''.join('\n * %s' % i for i in dups))

785

786 # Empty rule; assert all other attributes are equal

787 assert len({(r.alias, r.order, r.options) for r in dups}) == len(dups)

788

789 # Remove duplicates

790 compiled_rules = list(OrderedSet(compiled_rules))

791

792 # Filter out unused rules

793 while True:

794 c = len(compiled_rules)

795 used_rules = {s for r in compiled_rules

796 for s in r.expansion

797 if isinstance(s, NonTerminal)

798 and s != r.origin}

799 used_rules |= {NonTerminal(s) for s in start}

800 compiled_rules, unused = classify_bool(compiled_rules, lambda r: r.origin in used_rules)

801 for r in unused:

802 logger.debug("Unused rule: %s", r)

803 if len(compiled_rules) == c:

804 break

805

806 # Filter out unused terminals

807 if terminals_to_keep != '*':

808 used_terms = {t.name for r in compiled_rules

809 for t in r.expansion

810 if isinstance(t, Terminal)}

811 terminals, unused = classify_bool(terminals, lambda t: t.name in used_terms or t.name in self.ignore or t.name in terminals_to_keep)

812 if unused:

813 logger.debug("Unused terminals: %s", [t.name for t in unused])

814

815 return terminals, compiled_rules, self.ignore

816

817

818PackageResource = namedtuple('PackageResource', 'pkg_name path')

819

820

821class FromPackageLoader:

822 """

823 Provides a simple way of creating custom import loaders that load from packages via ``pkgutil.get_data`` instead of using `open`.

824 This allows them to be compatible even from within zip files.

825

826 Relative imports are handled, so you can just freely use them.

827

828 pkg_name: The name of the package. You can probably provide `__name__` most of the time

829 search_paths: All the path that will be search on absolute imports.

830 """

831

832 pkg_name: str

833 search_paths: Sequence[str]

834

835 def __init__(self, pkg_name: str, search_paths: Sequence[str]=("", )) -> None:

836 self.pkg_name = pkg_name

837 self.search_paths = search_paths

838

839 def __repr__(self):

840 return "%s(%r, %r)" % (type(self).__name__, self.pkg_name, self.search_paths)

841

842 def __call__(self, base_path: Union[None, str, PackageResource], grammar_path: str) -> Tuple[PackageResource, str]:

843 if base_path is None:

844 to_try = self.search_paths

845 else:

846 # Check whether or not the importing grammar was loaded by this module.

847 if not isinstance(base_path, PackageResource) or base_path.pkg_name != self.pkg_name:

848 # Technically false, but FileNotFound doesn't exist in python2.7, and this message should never reach the end user anyway

849 raise IOError()

850 to_try = [base_path.path]

851

852 err = None

853 for path in to_try:

854 full_path = os.path.join(path, grammar_path)

855 try:

856 text: Optional[bytes] = pkgutil.get_data(self.pkg_name, full_path)

857 except IOError as e:

858 err = e

859 continue

860 else:

861 return PackageResource(self.pkg_name, full_path), (text.decode() if text else '')

862

863 raise IOError('Cannot find grammar in given paths') from err

864

865

866stdlib_loader = FromPackageLoader('lark', IMPORT_PATHS)

867

868

869

870def resolve_term_references(term_dict):

871 # TODO Solve with transitive closure (maybe)

872

873 while True:

874 changed = False

875 for name, token_tree in term_dict.items():

876 if token_tree is None: # Terminal added through %declare

877 continue

878 for exp in token_tree.find_data('value'):

879 item ,= exp.children

880 if isinstance(item, NonTerminal):

881 raise GrammarError("Rules aren't allowed inside terminals (%s in %s)" % (item, name))

882 elif isinstance(item, Terminal):

883 try:

884 term_value = term_dict[item.name]

885 except KeyError:

886 raise GrammarError("Terminal used but not defined: %s" % item.name)

887 assert term_value is not None

888 exp.children[0] = term_value

889 changed = True

890 else:

891 assert isinstance(item, Tree)

892 if not changed:

893 break

894

895 for name, term in term_dict.items():

896 if term: # Not just declared

897 for child in term.children:

898 ids = [id(x) for x in child.iter_subtrees()]

899 if id(term) in ids:

900 raise GrammarError("Recursion in terminal '%s' (recursion is only allowed in rules, not terminals)" % name)

901

902

903

904def symbol_from_strcase(s):

905 assert isinstance(s, str)

906 return Terminal(s, filter_out=s.startswith('_')) if s.isupper() else NonTerminal(s)

907

908@inline_args

909class PrepareGrammar(Transformer_InPlace):

910 def terminal(self, name):

911 return Terminal(str(name), filter_out=name.startswith('_'))

912

913 def nonterminal(self, name):

914 return NonTerminal(name.value)

915

916

917def _find_used_symbols(tree):

918 assert tree.data == 'expansions'

919 return {t.name for x in tree.find_data('expansion')

920 for t in x.scan_values(lambda t: isinstance(t, Symbol))}

921

922

923def _get_parser():

924 try:

925 return _get_parser.cache

926 except AttributeError:

927 terminals = [TerminalDef(name, PatternRE(value)) for name, value in TERMINALS.items()]

928

929 rules = [(name.lstrip('?'), x, RuleOptions(expand1=name.startswith('?')))

930 for name, x in RULES.items()]

931 rules = [Rule(NonTerminal(r), [symbol_from_strcase(s) for s in x.split()], i, None, o)

932 for r, xs, o in rules for i, x in enumerate(xs)]

933

934 callback = ParseTreeBuilder(rules, ST).create_callback()

935 import re

936 lexer_conf = LexerConf(terminals, re, ['WS', 'COMMENT', 'BACKSLASH'])

937 parser_conf = ParserConf(rules, callback, ['start'])

938 lexer_conf.lexer_type = 'basic'

939 parser_conf.parser_type = 'lalr'

940 _get_parser.cache = ParsingFrontend(lexer_conf, parser_conf, None)

941 return _get_parser.cache

942

943GRAMMAR_ERRORS = [

944 ('Incorrect type of value', ['a: 1\n']),

945 ('Unclosed parenthesis', ['a: (\n']),

946 ('Unmatched closing parenthesis', ['a: )\n', 'a: [)\n', 'a: (]\n']),

947 ('Expecting rule or terminal definition (missing colon)', ['a\n', 'A\n', 'a->\n', 'A->\n', 'a A\n']),

948 ('Illegal name for rules or terminals', ['Aa:\n']),

949 ('Alias expects lowercase name', ['a: -> "a"\n']),

950 ('Unexpected colon', ['a::\n', 'a: b:\n', 'a: B:\n', 'a: "a":\n']),

951 ('Misplaced operator', ['a: b??', 'a: b(?)', 'a:+\n', 'a:?\n', 'a:*\n', 'a:|*\n']),

952 ('Expecting option ("|") or a new rule or terminal definition', ['a:a\n()\n']),

953 ('Terminal names cannot contain dots', ['A.B\n']),

954 ('Expecting rule or terminal definition', ['"a"\n']),

955 ('%import expects a name', ['%import "a"\n']),

956 ('%ignore expects a value', ['%ignore %import\n']),

957 ]

958

959def _translate_parser_exception(parse, e):

960 error = e.match_examples(parse, GRAMMAR_ERRORS, use_accepts=True)

961 if error:

962 return error

963 elif 'STRING' in e.expected:

964 return "Expecting a value"

965

966def _parse_grammar(text, name, start='start'):

967 try:

968 tree = _get_parser().parse(text + '\n', start)

969 except UnexpectedCharacters as e:

970 context = e.get_context(text)

971 raise GrammarError("Unexpected input at line %d column %d in %s: \n\n%s" %

972 (e.line, e.column, name, context))

973 except UnexpectedToken as e:

974 context = e.get_context(text)

975 error = _translate_parser_exception(_get_parser().parse, e)

976 if error:

977 raise GrammarError("%s, at line %s column %s\n\n%s" % (error, e.line, e.column, context))

978 raise

979

980 return PrepareGrammar().transform(tree)

981

982def _error_repr(error):

983 if isinstance(error, UnexpectedToken):

984 error2 = _translate_parser_exception(_get_parser().parse, error)

985 if error2:

986 return error2

987 expected = ', '.join(error.accepts or error.expected)

988 return "Unexpected token %r. Expected one of: {%s}" % (str(error.token), expected)

989 else:

990 return str(error)

991

992def _search_interactive_parser(interactive_parser, predicate):

993 def expand(node):

994 path, p = node

995 for choice in p.choices():

996 t = Token(choice, '')

997 try:

998 new_p = p.feed_token(t)

999 except ParseError: # Illegal

1000 pass

1001 else:

1002 yield path + (choice,), new_p

1003

1004 for path, p in bfs_all_unique([((), interactive_parser)], expand):

1005 if predicate(p):

1006 return path, p

1007

1008def find_grammar_errors(text: str, start: str='start') -> List[Tuple[UnexpectedInput, str]]:

1009 errors = []

1010 def on_error(e):

1011 errors.append((e, _error_repr(e)))

1012

1013 # recover to a new line

1014 token_path, _ = _search_interactive_parser(e.interactive_parser.as_immutable(), lambda p: '_NL' in p.choices())

1015 for token_type in token_path:

1016 e.interactive_parser.feed_token(Token(token_type, ''))

1017 e.interactive_parser.feed_token(Token('_NL', '\n'))

1018 return True

1019

1020 _tree = _get_parser().parse(text + '\n', start, on_error=on_error)

1021

1022 errors_by_line = classify(errors, lambda e: e[0].line)

1023 errors = [el[0] for el in errors_by_line.values()] # already sorted

1024

1025 for e in errors:

1026 e[0].interactive_parser = None

1027 return errors

1028

1029

1030def _get_mangle(prefix, aliases, base_mangle=None):

1031 def mangle(s):

1032 if s in aliases:

1033 s = aliases[s]

1034 else:

1035 if s[0] == '_':

1036 s = '_%s__%s' % (prefix, s[1:])

1037 else:

1038 s = '%s__%s' % (prefix, s)

1039 if base_mangle is not None:

1040 s = base_mangle(s)

1041 return s

1042 return mangle

1043

1044def _mangle_definition_tree(exp, mangle):

1045 if mangle is None:

1046 return exp

1047 exp = deepcopy(exp) # TODO: is this needed?

1048 for t in exp.iter_subtrees():

1049 for i, c in enumerate(t.children):

1050 if isinstance(c, Symbol):

1051 t.children[i] = c.renamed(mangle)

1052

1053 return exp

1054

1055def _make_rule_tuple(modifiers_tree, name, params, priority_tree, expansions):

1056 if modifiers_tree.children:

1057 m ,= modifiers_tree.children

1058 expand1 = '?' in m

1059 if expand1 and name.startswith('_'):

1060 raise GrammarError("Inlined rules (_rule) cannot use the ?rule modifier.")

1061 keep_all_tokens = '!' in m

1062 else:

1063 keep_all_tokens = False

1064 expand1 = False

1065

1066 if priority_tree.children:

1067 p ,= priority_tree.children

1068 priority = int(p)

1069 else:

1070 priority = None

1071

1072 if params is not None:

1073 params = [t.value for t in params.children] # For the grammar parser

1074

1075 return name, params, expansions, RuleOptions(keep_all_tokens, expand1, priority=priority,

1076 template_source=(name if params else None))

1077

1078

1079class Definition:

1080 def __init__(self, is_term, tree, params=(), options=None):

1081 self.is_term = is_term

1082 self.tree = tree

1083 self.params = tuple(params)

1084 self.options = options

1085

1086class GrammarBuilder:

1087

1088 global_keep_all_tokens: bool

1089 import_paths: List[Union[str, Callable]]

1090 used_files: Dict[str, str]

1091

1092 _definitions: Dict[str, Definition]

1093 _ignore_names: List[str]

1094

1095 def __init__(self, global_keep_all_tokens: bool=False, import_paths: Optional[List[Union[str, Callable]]]=None, used_files: Optional[Dict[str, str]]=None) -> None:

1096 self.global_keep_all_tokens = global_keep_all_tokens

1097 self.import_paths = import_paths or []

1098 self.used_files = used_files or {}

1099

1100 self._definitions: Dict[str, Definition] = {}

1101 self._ignore_names: List[str] = []

1102

1103 def _grammar_error(self, is_term, msg, *names):

1104 args = {}

1105 for i, name in enumerate(names, start=1):

1106 postfix = '' if i == 1 else str(i)

1107 args['name' + postfix] = name

1108 args['type' + postfix] = lowercase_type = ("rule", "terminal")[is_term]

1109 args['Type' + postfix] = lowercase_type.title()

1110 raise GrammarError(msg.format(**args))

1111

1112 def _check_options(self, is_term, options):

1113 if is_term:

1114 if options is None:

1115 options = 1

1116 elif not isinstance(options, int):

1117 raise GrammarError("Terminal require a single int as 'options' (e.g. priority), got %s" % (type(options),))

1118 else:

1119 if options is None:

1120 options = RuleOptions()

1121 elif not isinstance(options, RuleOptions):

1122 raise GrammarError("Rules require a RuleOptions instance as 'options'")

1123 if self.global_keep_all_tokens:

1124 options.keep_all_tokens = True

1125 return options

1126

1127

1128 def _define(self, name, is_term, exp, params=(), options=None, *, override=False):

1129 if name in self._definitions:

1130 if not override:

1131 self._grammar_error(is_term, "{Type} '{name}' defined more than once", name)

1132 elif override:

1133 self._grammar_error(is_term, "Cannot override a nonexisting {type} {name}", name)

1134

1135 if name.startswith('__'):

1136 self._grammar_error(is_term, 'Names starting with double-underscore are reserved (Error at {name})', name)

1137

1138 self._definitions[name] = Definition(is_term, exp, params, self._check_options(is_term, options))

1139

1140 def _extend(self, name, is_term, exp, params=(), options=None):

1141 if name not in self._definitions:

1142 self._grammar_error(is_term, "Can't extend {type} {name} as it wasn't defined before", name)

1143

1144 d = self._definitions[name]

1145

1146 if is_term != d.is_term:

1147 self._grammar_error(is_term, "Cannot extend {type} {name} - one is a terminal, while the other is not.", name)

1148 if tuple(params) != d.params:

1149 self._grammar_error(is_term, "Cannot extend {type} with different parameters: {name}", name)

1150

1151 if d.tree is None:

1152 self._grammar_error(is_term, "Can't extend {type} {name} - it is abstract.", name)

1153

1154 # TODO: think about what to do with 'options'

1155 base = d.tree

1156

1157 assert isinstance(base, Tree) and base.data == 'expansions'

1158 base.children.insert(0, exp)

1159

1160 def _ignore(self, exp_or_name):

1161 if isinstance(exp_or_name, str):

1162 self._ignore_names.append(exp_or_name)

1163 else:

1164 assert isinstance(exp_or_name, Tree)

1165 t = exp_or_name

1166 if t.data == 'expansions' and len(t.children) == 1:

1167 t2 ,= t.children

1168 if t2.data=='expansion' and len(t2.children) == 1:

1169 item ,= t2.children

1170 if item.data == 'value':

1171 item ,= item.children

1172 if isinstance(item, Terminal):

1173 # Keep terminal name, no need to create a new definition

1174 self._ignore_names.append(item.name)

1175 return

1176

1177 name = '__IGNORE_%d'% len(self._ignore_names)

1178 self._ignore_names.append(name)

1179 self._definitions[name] = Definition(True, t, options=TOKEN_DEFAULT_PRIORITY)

1180

1181 def _unpack_import(self, stmt, grammar_name):

1182 if len(stmt.children) > 1:

1183 path_node, arg1 = stmt.children

1184 else:

1185 path_node, = stmt.children

1186 arg1 = None

1187

1188 if isinstance(arg1, Tree): # Multi import

1189 dotted_path = tuple(path_node.children)

1190 names = arg1.children

1191 aliases = dict(zip(names, names)) # Can't have aliased multi import, so all aliases will be the same as names

1192 else: # Single import

1193 dotted_path = tuple(path_node.children[:-1])

1194 if not dotted_path:

1195 name ,= path_node.children

1196 raise GrammarError("Nothing was imported from grammar `%s`" % name)

1197 name = path_node.children[-1] # Get name from dotted path

1198 aliases = {name.value: (arg1 or name).value} # Aliases if exist

1199

1200 if path_node.data == 'import_lib': # Import from library

1201 base_path = None

1202 else: # Relative import

1203 if grammar_name == '<string>': # Import relative to script file path if grammar is coded in script

1204 try:

1205 base_file = os.path.abspath(sys.modules['__main__'].__file__)

1206 except AttributeError:

1207 base_file = None

1208 else:

1209 base_file = grammar_name # Import relative to grammar file path if external grammar file

1210 if base_file:

1211 if isinstance(base_file, PackageResource):

1212 base_path = PackageResource(base_file.pkg_name, os.path.split(base_file.path)[0])

1213 else:

1214 base_path = os.path.split(base_file)[0]

1215 else:

1216 base_path = os.path.abspath(os.path.curdir)

1217

1218 return dotted_path, base_path, aliases

1219

1220 def _unpack_definition(self, tree, mangle):

1221

1222 if tree.data == 'rule':

1223 name, params, exp, opts = _make_rule_tuple(*tree.children)

1224 is_term = False

1225 else:

1226 name = tree.children[0].value

1227 params = () # TODO terminal templates

1228 opts = int(tree.children[1]) if len(tree.children) == 3 else TOKEN_DEFAULT_PRIORITY # priority

1229 exp = tree.children[-1]

1230 is_term = True

1231

1232 if mangle is not None:

1233 params = tuple(mangle(p) for p in params)

1234 name = mangle(name)

1235

1236 exp = _mangle_definition_tree(exp, mangle)

1237 return name, is_term, exp, params, opts

1238

1239

1240 def load_grammar(self, grammar_text: str, grammar_name: str="<?>", mangle: Optional[Callable[[str], str]]=None) -> None:

1241 tree = _parse_grammar(grammar_text, grammar_name)

1242

1243 imports: Dict[Tuple[str, ...], Tuple[Optional[str], Dict[str, str]]] = {}

1244

1245 for stmt in tree.children:

1246 if stmt.data == 'import':

1247 dotted_path, base_path, aliases = self._unpack_import(stmt, grammar_name)

1248 try:

1249 import_base_path, import_aliases = imports[dotted_path]

1250 assert base_path == import_base_path, 'Inconsistent base_path for %s.' % '.'.join(dotted_path)

1251 import_aliases.update(aliases)

1252 except KeyError:

1253 imports[dotted_path] = base_path, aliases

1254

1255 for dotted_path, (base_path, aliases) in imports.items():

1256 self.do_import(dotted_path, base_path, aliases, mangle)

1257

1258 for stmt in tree.children:

1259 if stmt.data in ('term', 'rule'):

1260 self._define(*self._unpack_definition(stmt, mangle))

1261 elif stmt.data == 'override':

1262 r ,= stmt.children

1263 self._define(*self._unpack_definition(r, mangle), override=True)

1264 elif stmt.data == 'extend':

1265 r ,= stmt.children

1266 self._extend(*self._unpack_definition(r, mangle))

1267 elif stmt.data == 'ignore':

1268 # if mangle is not None, we shouldn't apply ignore, since we aren't in a toplevel grammar

1269 if mangle is None:

1270 self._ignore(*stmt.children)

1271 elif stmt.data == 'declare':

1272 for symbol in stmt.children:

1273 assert isinstance(symbol, Symbol), symbol

1274 is_term = isinstance(symbol, Terminal)

1275 if mangle is None:

1276 name = symbol.name

1277 else:

1278 name = mangle(symbol.name)

1279 self._define(name, is_term, None)

1280 elif stmt.data == 'import':

1281 pass

1282 else:

1283 assert False, stmt

1284

1285

1286 term_defs = { name: d.tree

1287 for name, d in self._definitions.items()

1288 if d.is_term

1289 }

1290 resolve_term_references(term_defs)

1291

1292

1293 def _remove_unused(self, used):

1294 def rule_dependencies(symbol):

1295 try:

1296 d = self._definitions[symbol]

1297 except KeyError:

1298 return []

1299 if d.is_term:

1300 return []

1301 return _find_used_symbols(d.tree) - set(d.params)

1302

1303 _used = set(bfs(used, rule_dependencies))

1304 self._definitions = {k: v for k, v in self._definitions.items() if k in _used}

1305

1306

1307 def do_import(self, dotted_path: Tuple[str, ...], base_path: Optional[str], aliases: Dict[str, str], base_mangle: Optional[Callable[[str], str]]=None) -> None: