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 if next(term_tree.find_data('template_usage'), None) is not None:

708 raise GrammarError("Templates cannot be used inside terminals (%s)" % name)

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

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

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

712

713 transformer = PrepareLiterals() * TerminalTreeToPattern()

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

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

716

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

718 # Compile Rules

719 # =================

720

721 # 1. Pre-process terminals

722 anon_tokens_transf = PrepareAnonTerminals(terminals)

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

724

725 # 2. Inline Templates

726

727 transformer *= ApplyTemplates(rule_defs)

728

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

730 ebnf_to_bnf = EBNF_to_BNF()

731 rules = []

732 i = 0

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

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

735 i += 1

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

737 continue

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

739 ebnf_to_bnf.rule_options = rule_options

740 ebnf_to_bnf.prefix = name

741 anon_tokens_transf.rule_options = rule_options

742 tree = transformer.transform(rule_tree)

743 res: Tree = ebnf_to_bnf.transform(tree)

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

745 rules += ebnf_to_bnf.new_rules

746

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

748

749 # 4. Compile tree to Rule objects

750 rule_tree_to_text = RuleTreeToText()

751

752 simplify_rule = SimplifyRule_Visitor()

753 compiled_rules: List[Rule] = []

754 for rule_content in rules:

755 name, tree, options = rule_content

756 simplify_rule.visit(tree)

757 expansions = rule_tree_to_text.transform(tree)

758

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

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

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

762

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

764 if any(empty_indices):

765 exp_options = copy(options) or RuleOptions()

766 exp_options.empty_indices = empty_indices

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

768 else:

769 exp_options = options

770

771 for sym in expansion:

772 assert isinstance(sym, Symbol)

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

774 assert isinstance(sym, Terminal)

775 sym.filter_out = False

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

777 compiled_rules.append(rule)

778

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

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

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

782 for dups in duplicates.values():

783 if len(dups) > 1:

784 if dups[0].expansion:

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

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

787

788 # Empty rule; assert all other attributes are equal

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

790

791 # Remove duplicates

792 compiled_rules = list(OrderedSet(compiled_rules))

793

794 # Filter out unused rules

795 while True:

796 c = len(compiled_rules)

797 used_rules = {s for r in compiled_rules

798 for s in r.expansion

799 if isinstance(s, NonTerminal)

800 and s != r.origin}

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

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

803 for r in unused:

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

805 if len(compiled_rules) == c:

806 break

807

808 # Filter out unused terminals

809 if terminals_to_keep != '*':

810 used_terms = {t.name for r in compiled_rules

811 for t in r.expansion

812 if isinstance(t, Terminal)}

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

814 if unused:

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

816

817 return terminals, compiled_rules, self.ignore

818

819

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

821

822

823class FromPackageLoader:

824 """

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

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

827

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

829

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

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

832 """

833

834 pkg_name: str

835 search_paths: Sequence[str]

836

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

838 self.pkg_name = pkg_name

839 self.search_paths = search_paths

840

841 def __repr__(self):

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

843

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

845 if base_path is None:

846 to_try = self.search_paths

847 else:

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

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

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

851 raise IOError()

852 to_try = [base_path.path]

853

854 err = None

855 for path in to_try:

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

857 try:

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

859 except IOError as e:

860 err = e

861 continue

862 else:

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

864

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

866

867

868stdlib_loader = FromPackageLoader('lark', IMPORT_PATHS)

869

870

871

872def resolve_term_references(term_dict):

873 # TODO Solve with transitive closure (maybe)

874

875 while True:

876 changed = False

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

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

879 continue

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

881 item ,= exp.children

882 if isinstance(item, NonTerminal):

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

884 elif isinstance(item, Terminal):

885 try:

886 term_value = term_dict[item.name]

887 except KeyError:

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

889 assert term_value is not None

890 exp.children[0] = term_value

891 changed = True

892 else:

893 assert isinstance(item, Tree)

894 if not changed:

895 break

896

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

898 if term: # Not just declared

899 for child in term.children:

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

901 if id(term) in ids:

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

903

904

905

906def symbol_from_strcase(s):

907 assert isinstance(s, str)

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

909

910@inline_args

911class PrepareGrammar(Transformer_InPlace):

912 def terminal(self, name):

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

914

915 def nonterminal(self, name):

916 return NonTerminal(name.value)

917

918

919def _find_used_symbols(tree):

920 assert tree.data == 'expansions'

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

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

923

924

925def _get_parser():

926 try:

927 return _get_parser.cache

928 except AttributeError:

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

930

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

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

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

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

935

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

937 import re

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

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

940 lexer_conf.lexer_type = 'basic'

941 parser_conf.parser_type = 'lalr'

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

943 return _get_parser.cache

944

945GRAMMAR_ERRORS = [

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

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

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

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

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

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

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

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

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

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

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

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

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

959 ]

960

961def _translate_parser_exception(parse, e):

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

963 if error:

964 return error

965 elif 'STRING' in e.expected:

966 return "Expecting a value"

967

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

969 try:

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

971 except UnexpectedCharacters as e:

972 context = e.get_context(text)

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

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

975 except UnexpectedToken as e:

976 context = e.get_context(text)

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

978 if error:

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

980 raise

981

982 return PrepareGrammar().transform(tree)

983

984def _error_repr(error):

985 if isinstance(error, UnexpectedToken):

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

987 if error2:

988 return error2

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

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

991 else:

992 return str(error)

993

994def _search_interactive_parser(interactive_parser, predicate):

995 def expand(node):

996 path, p = node

997 for choice in p.choices():

998 t = Token(choice, '')

999 try:

1000 new_p = p.feed_token(t)

1001 except ParseError: # Illegal

1002 pass

1003 else:

1004 yield path + (choice,), new_p

1005

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

1007 if predicate(p):

1008 return path, p

1009

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

1011 errors = []

1012 def on_error(e):

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

1014

1015 # recover to a new line

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

1017 for token_type in token_path:

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

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

1020 return True

1021

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

1023

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

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

1026

1027 for e in errors:

1028 e[0].interactive_parser = None

1029 return errors

1030

1031

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

1033 def mangle(s):

1034 if s in aliases:

1035 s = aliases[s]

1036 else:

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

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

1039 else:

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

1041 if base_mangle is not None:

1042 s = base_mangle(s)

1043 return s

1044 return mangle

1045

1046def _mangle_definition_tree(exp, mangle):

1047 if mangle is None:

1048 return exp

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

1050 for t in exp.iter_subtrees():

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

1052 if isinstance(c, Symbol):

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

1054

1055 return exp

1056

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

1058 if modifiers_tree.children:

1059 m ,= modifiers_tree.children

1060 expand1 = '?' in m

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

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

1063 keep_all_tokens = '!' in m

1064 else:

1065 keep_all_tokens = False

1066 expand1 = False

1067

1068 if priority_tree.children:

1069 p ,= priority_tree.children

1070 priority = int(p)

1071 else:

1072 priority = None

1073

1074 if params is not None:

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

1076

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

1078 template_source=(name if params else None))

1079

1080

1081class Definition:

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

1083 self.is_term = is_term

1084 self.tree = tree

1085 self.params = tuple(params)

1086 self.options = options

1087

1088class GrammarBuilder:

1089

1090 global_keep_all_tokens: bool

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

1092 used_files: Dict[str, str]

1093

1094 _definitions: Dict[str, Definition]

1095 _ignore_names: List[str]

1096

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

1098 self.global_keep_all_tokens = global_keep_all_tokens

1099 self.import_paths = import_paths or []

1100 self.used_files = used_files or {}

1101

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

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

1104

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

1106 args = {}

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

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

1109 args['name' + postfix] = name

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

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

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

1113

1114 def _check_options(self, is_term, options):

1115 if is_term:

1116 if options is None:

1117 options = 1

1118 elif not isinstance(options, int):

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

1120 else:

1121 if options is None:

1122 options = RuleOptions()

1123 elif not isinstance(options, RuleOptions):

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

1125 if self.global_keep_all_tokens:

1126 options.keep_all_tokens = True

1127 return options

1128

1129

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

1131 if name in self._definitions:

1132 if not override:

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

1134 elif override:

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

1136

1137 if name.startswith('__'):

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

1139

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

1141

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

1143 if name not in self._definitions:

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

1145

1146 d = self._definitions[name]

1147

1148 if is_term != d.is_term:

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

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

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

1152

1153 if d.tree is None:

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

1155

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

1157 base = d.tree

1158

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

1160 base.children.insert(0, exp)

1161

1162 def _ignore(self, exp_or_name):

1163 if isinstance(exp_or_name, str):

1164 self._ignore_names.append(exp_or_name)

1165 else:

1166 assert isinstance(exp_or_name, Tree)

1167 t = exp_or_name

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

1169 t2 ,= t.children

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

1171 item ,= t2.children

1172 if item.data == 'value':

1173 item ,= item.children

1174 if isinstance(item, Terminal):

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

1176 self._ignore_names.append(item.name)

1177 return

1178

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

1180 self._ignore_names.append(name)

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

1182

1183 def _unpack_import(self, stmt, grammar_name):

1184 if len(stmt.children) > 1:

1185 path_node, arg1 = stmt.children

1186 else:

1187 path_node, = stmt.children

1188 arg1 = None

1189

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

1191 dotted_path = tuple(path_node.children)

1192 names = arg1.children

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

1194 else: # Single import

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

1196 if not dotted_path:

1197 name ,= path_node.children

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

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

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

1201

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

1203 base_path = None

1204 else: # Relative import

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

1206 try:

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

1208 except AttributeError:

1209 base_file = None

1210 else:

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

1212 if base_file:

1213 if isinstance(base_file, PackageResource):

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

1215 else:

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

1217 else:

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

1219

1220 return dotted_path, base_path, aliases

1221

1222 def _unpack_definition(self, tree, mangle):

1223

1224 if tree.data == 'rule':

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

1226 is_term = False

1227 else:

1228 name = tree.children[0].value

1229 params = () # TODO terminal templates

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

1231 exp = tree.children[-1]

1232 is_term = True

1233

1234 if mangle is not None:

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

1236 name = mangle(name)

1237

1238 exp = _mangle_definition_tree(exp, mangle)

1239 return name, is_term, exp, params, opts

1240

1241

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

1243 tree = _parse_grammar(grammar_text, grammar_name)

1244

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

1246

1247 for stmt in tree.children:

1248 if stmt.data == 'import':

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

1250 try:

1251 import_base_path, import_aliases = imports[dotted_path]

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

1253 import_aliases.update(aliases)

1254 except KeyError:

1255 imports[dotted_path] = base_path, aliases

1256

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

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

1259

1260 for stmt in tree.children:

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

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

1263 elif stmt.data == 'override':

1264 r ,= stmt.children

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

1266 elif stmt.data == 'extend':

1267 r ,= stmt.children

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

1269 elif stmt.data == 'ignore':

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

1271 if mangle is None:

1272 self._ignore(*stmt.children)

1273 elif stmt.data == 'declare':

1274 for symbol in stmt.children:

1275 assert isinstance(symbol, Symbol), symbol

1276 is_term = isinstance(symbol, Terminal)

1277 if mangle is None:

1278 name = symbol.name

1279 else:

1280 name = mangle(symbol.name)

1281 self._define(name, is_term, None)

1282 elif stmt.data == 'import':

1283 pass

1284 else:

1285 assert False, stmt

1286

1287

1288 term_defs = { name: d.tree

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

1290 if d.is_term

1291 }

1292 resolve_term_references(term_defs)

1293

1294

1295 def _remove_unused(self, used):

1296 def rule_dependencies(symbol):

1297 try:

1298 d = self._definitions[symbol]

1299 except KeyError:

1300 return []

1301 if d.is_term:

1302 return []

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

1304

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

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

1307

1308

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