code: def import_from_grammar_into_namespace(grammar, namespace, aliases):
      
  
      imported_terms = dict(grammar.term_defs)
      imported_rules = {n:(n,deepcopy(t),o) for n,t,o in grammar.rule_defs}
  
      term_defs = []
      rule_defs = []
  
      def rule_dependencies(symbol):
          if symbol.type != 'RULE':
              return []
          try:
              _, tree, _ = imported_rules[symbol]
          except KeyError:
              raise GrammarError("Missing symbol '%s' in grammar %s" % (symbol, namespace))
          return tree.scan_values(lambda x: x.type in ('RULE', 'TERMINAL'))
  
      def get_namespace_name(name):
          try:
              return aliases[name].value
          except KeyError:
              if name[0] == '_':
                  return '_%s__%s' % (namespace, name[1:])
              return '%s__%s' % (namespace, name)
  
      to_import = list(bfs(aliases, rule_dependencies))
      for symbol in to_import:
          if symbol.type == 'TERMINAL':
              term_defs.append([get_namespace_name(symbol), imported_terms[symbol]])
          else:
              assert symbol.type == 'RULE'
              rule = imported_rules[symbol]
              for t in rule[1].iter_subtrees():
                  for i, c in enumerate(t.children):
                      if isinstance(c, Token) and c.type in ('RULE', 'TERMINAL'):
                          t.children[i] = Token(c.type, get_namespace_name(c))
              rule_defs.append((get_namespace_name(symbol), rule[1], rule[2]))
  
      return term_defs, rule_defs
docs: Returns all rules and terminals of grammar, prepended
      with a 'namespace' prefix, except for those which are aliased.