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 def compile(self, start, terminals_to_keep) -> Tuple[List[TerminalDef], List[Rule], List[str]]:

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

692 # So deepcopy allows calling compile more than once.

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

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

695

696 # ===================

697 # Compile Terminals

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

699

700 # Convert terminal-trees to strings/regexps

701

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

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

704 continue

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

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

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

708

709 transformer = PrepareLiterals() * TerminalTreeToPattern()

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

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

712

713 # =================

714 # Compile Rules

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

716

717 # 1. Pre-process terminals

718 anon_tokens_transf = PrepareAnonTerminals(terminals)

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

720

721 # 2. Inline Templates

722

723 transformer *= ApplyTemplates(rule_defs)

724

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

726 ebnf_to_bnf = EBNF_to_BNF()

727 rules = []

728 i = 0

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

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

731 i += 1

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

733 continue

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

735 ebnf_to_bnf.rule_options = rule_options

736 ebnf_to_bnf.prefix = name

737 anon_tokens_transf.rule_options = rule_options

738 tree = transformer.transform(rule_tree)

739 res: Tree = ebnf_to_bnf.transform(tree)

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

741 rules += ebnf_to_bnf.new_rules

742

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

744

745 # 4. Compile tree to Rule objects

746 rule_tree_to_text = RuleTreeToText()

747

748 simplify_rule = SimplifyRule_Visitor()

749 compiled_rules: List[Rule] = []

750 for rule_content in rules:

751 name, tree, options = rule_content

752 simplify_rule.visit(tree)

753 expansions = rule_tree_to_text.transform(tree)

754

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

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

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

758

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

760 if any(empty_indices):

761 exp_options = copy(options) or RuleOptions()

762 exp_options.empty_indices = empty_indices

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

764 else:

765 exp_options = options

766

767 for sym in expansion:

768 assert isinstance(sym, Symbol)

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

770 assert isinstance(sym, Terminal)

771 sym.filter_out = False

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

773 compiled_rules.append(rule)

774

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

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

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

778 for dups in duplicates.values():

779 if len(dups) > 1:

780 if dups[0].expansion:

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

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

783

784 # Empty rule; assert all other attributes are equal

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

786

787 # Remove duplicates

788 compiled_rules = list(OrderedSet(compiled_rules))

789

790 # Filter out unused rules

791 while True:

792 c = len(compiled_rules)

793 used_rules = {s for r in compiled_rules

794 for s in r.expansion

795 if isinstance(s, NonTerminal)

796 and s != r.origin}

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

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

799 for r in unused:

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

801 if len(compiled_rules) == c:

802 break

803

804 # Filter out unused terminals

805 if terminals_to_keep != '*':

806 used_terms = {t.name for r in compiled_rules

807 for t in r.expansion

808 if isinstance(t, Terminal)}

809 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)

810 if unused:

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

812

813 return terminals, compiled_rules, self.ignore

814

815

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

817

818

819class FromPackageLoader:

820 """

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

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

823

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

825

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

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

828 """

829

830 pkg_name: str

831 search_paths: Sequence[str]

832

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

834 self.pkg_name = pkg_name

835 self.search_paths = search_paths

836

837 def __repr__(self):

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

839

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

841 if base_path is None:

842 to_try = self.search_paths

843 else:

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

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

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

847 raise IOError()

848 to_try = [base_path.path]

849

850 err = None

851 for path in to_try:

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

853 try:

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

855 except IOError as e:

856 err = e

857 continue

858 else:

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

860

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

862

863

864stdlib_loader = FromPackageLoader('lark', IMPORT_PATHS)

865

866

867

868def resolve_term_references(term_dict):

869 # TODO Solve with transitive closure (maybe)

870

871 while True:

872 changed = False

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

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

875 continue

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

877 item ,= exp.children

878 if isinstance(item, NonTerminal):

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

880 elif isinstance(item, Terminal):

881 try:

882 term_value = term_dict[item.name]

883 except KeyError:

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

885 assert term_value is not None

886 exp.children[0] = term_value

887 changed = True

888 else:

889 assert isinstance(item, Tree)

890 if not changed:

891 break

892

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

894 if term: # Not just declared

895 for child in term.children:

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

897 if id(term) in ids:

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

899

900

901

902def symbol_from_strcase(s):

903 assert isinstance(s, str)

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

905

906@inline_args

907class PrepareGrammar(Transformer_InPlace):

908 def terminal(self, name):

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

910

911 def nonterminal(self, name):

912 return NonTerminal(name.value)

913

914

915def _find_used_symbols(tree):

916 assert tree.data == 'expansions'

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

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

919

920

921def _get_parser():

922 try:

923 return _get_parser.cache

924 except AttributeError:

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

926

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

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

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

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

931

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

933 import re

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

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

936 lexer_conf.lexer_type = 'basic'

937 parser_conf.parser_type = 'lalr'

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

939 return _get_parser.cache

940

941GRAMMAR_ERRORS = [

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

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

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

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

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

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

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

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

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

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

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

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

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

955 ]

956

957def _translate_parser_exception(parse, e):

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

959 if error:

960 return error

961 elif 'STRING' in e.expected:

962 return "Expecting a value"

963

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

965 try:

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

967 except UnexpectedCharacters as e:

968 context = e.get_context(text)

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

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

971 except UnexpectedToken as e:

972 context = e.get_context(text)

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

974 if error:

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

976 raise

977

978 return PrepareGrammar().transform(tree)

979

980

981def _error_repr(error):

982 if isinstance(error, UnexpectedToken):

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

984 if error2:

985 return error2

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

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

988 else:

989 return str(error)

990

991def _search_interactive_parser(interactive_parser, predicate):

992 def expand(node):

993 path, p = node

994 for choice in p.choices():

995 t = Token(choice, '')

996 try:

997 new_p = p.feed_token(t)

998 except ParseError: # Illegal

999 pass

1000 else:

1001 yield path + (choice,), new_p

1002

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

1004 if predicate(p):

1005 return path, p

1006

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

1008 errors = []

1009 def on_error(e):

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

1011

1012 # recover to a new line

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

1014 for token_type in token_path:

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

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

1017 return True

1018

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

1020

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

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

1023

1024 for e in errors:

1025 e[0].interactive_parser = None

1026 return errors

1027

1028

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

1030 def mangle(s):

1031 if s in aliases:

1032 s = aliases[s]

1033 else:

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

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

1036 else:

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

1038 if base_mangle is not None:

1039 s = base_mangle(s)

1040 return s

1041 return mangle

1042

1043def _mangle_definition_tree(exp, mangle):

1044 if mangle is None:

1045 return exp

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

1047 for t in exp.iter_subtrees():

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

1049 if isinstance(c, Symbol):

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

1051

1052 return exp

1053

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

1055 if modifiers_tree.children:

1056 m ,= modifiers_tree.children

1057 expand1 = '?' in m

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

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

1060 keep_all_tokens = '!' in m

1061 else:

1062 keep_all_tokens = False

1063 expand1 = False

1064

1065 if priority_tree.children:

1066 p ,= priority_tree.children

1067 priority = int(p)

1068 else:

1069 priority = None

1070

1071 if params is not None:

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

1073

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

1075 template_source=(name if params else None))

1076

1077

1078class Definition:

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

1080 self.is_term = is_term

1081 self.tree = tree

1082 self.params = tuple(params)

1083 self.options = options

1084

1085class GrammarBuilder:

1086

1087 global_keep_all_tokens: bool

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

1089 used_files: Dict[str, str]

1090

1091 _definitions: Dict[str, Definition]

1092 _ignore_names: List[str]

1093

1094 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:

1095 self.global_keep_all_tokens = global_keep_all_tokens

1096 self.import_paths = import_paths or []

1097 self.used_files = used_files or {}

1098

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

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

1101

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

1103 args = {}

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

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

1106 args['name' + postfix] = name

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

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

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

1110

1111 def _check_options(self, is_term, options):

1112 if is_term:

1113 if options is None:

1114 options = 1

1115 elif not isinstance(options, int):

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

1117 else:

1118 if options is None:

1119 options = RuleOptions()

1120 elif not isinstance(options, RuleOptions):

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

1122 if self.global_keep_all_tokens:

1123 options.keep_all_tokens = True

1124 return options

1125

1126

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

1128 if name in self._definitions:

1129 if not override:

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

1131 elif override:

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

1133

1134 if name.startswith('__'):

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

1136

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

1138

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

1140 if name not in self._definitions:

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

1142

1143 d = self._definitions[name]

1144

1145 if is_term != d.is_term:

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

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

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

1149

1150 if d.tree is None:

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

1152

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

1154 base = d.tree

1155

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

1157 base.children.insert(0, exp)

1158

1159 def _ignore(self, exp_or_name):

1160 if isinstance(exp_or_name, str):

1161 self._ignore_names.append(exp_or_name)

1162 else:

1163 assert isinstance(exp_or_name, Tree)

1164 t = exp_or_name

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

1166 t2 ,= t.children

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

1168 item ,= t2.children

1169 if item.data == 'value':

1170 item ,= item.children

1171 if isinstance(item, Terminal):

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

1173 self._ignore_names.append(item.name)

1174 return

1175

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

1177 self._ignore_names.append(name)

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

1179

1180 def _unpack_import(self, stmt, grammar_name):

1181 if len(stmt.children) > 1:

1182 path_node, arg1 = stmt.children

1183 else:

1184 path_node, = stmt.children

1185 arg1 = None

1186

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

1188 dotted_path = tuple(path_node.children)

1189 names = arg1.children

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

1191 else: # Single import

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

1193 if not dotted_path:

1194 name ,= path_node.children

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

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

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

1198

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

1200 base_path = None

1201 else: # Relative import

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

1203 try:

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

1205 except AttributeError:

1206 base_file = None

1207 else:

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

1209 if base_file:

1210 if isinstance(base_file, PackageResource):

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

1212 else:

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

1214 else:

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

1216

1217 return dotted_path, base_path, aliases

1218

1219 def _unpack_definition(self, tree, mangle):

1220

1221 if tree.data == 'rule':

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

1223 is_term = False

1224 else:

1225 name = tree.children[0].value

1226 params = () # TODO terminal templates

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

1228 exp = tree.children[-1]

1229 is_term = True

1230

1231 if mangle is not None:

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

1233 name = mangle(name)

1234

1235 exp = _mangle_definition_tree(exp, mangle)

1236 return name, is_term, exp, params, opts

1237

1238

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

1240 tree = _parse_grammar(grammar_text, grammar_name)

1241

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

1243

1244 for stmt in tree.children:

1245 if stmt.data == 'import':

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

1247 try:

1248 import_base_path, import_aliases = imports[dotted_path]

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

1250 import_aliases.update(aliases)

1251 except KeyError:

1252 imports[dotted_path] = base_path, aliases

1253

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

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

1256

1257 for stmt in tree.children:

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

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

1260 elif stmt.data == 'override':

1261 r ,= stmt.children

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

1263 elif stmt.data == 'extend':

1264 r ,= stmt.children

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

1266 elif stmt.data == 'ignore':

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

1268 if mangle is None:

1269 self._ignore(*stmt.children)

1270 elif stmt.data == 'declare':

1271 for symbol in stmt.children:

1272 assert isinstance(symbol, Symbol), symbol

1273 is_term = isinstance(symbol, Terminal)

1274 if mangle is None:

1275 name = symbol.name

1276 else:

1277 name = mangle(symbol.name)

1278 self._define(name, is_term, None)

1279 elif stmt.data == 'import':

1280 pass

1281 else:

1282 assert False, stmt

1283

1284

1285 term_defs = { name: d.tree

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

1287 if d.is_term

1288 }

1289 resolve_term_references(term_defs)

1290

1291

1292 def _remove_unused(self, used):

1293 def rule_dependencies(symbol):

1294 try:

1295 d = self._definitions[symbol]

1296 except KeyError:

1297 return []

1298 if d.is_term:

1299 return []

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

1301

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

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

1304

1305

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