osbot-utils 1.7.7__py3-none-any.whl

osbot_utils/helpers/ast/Ast.py

@@ -0,0 +1,35 @@
+import ast
+import inspect
+from osbot_utils.utils.Files                    import file_contents
+from osbot_utils.utils.Str                      import str_dedent
+from osbot_utils.helpers.ast.nodes.Ast_Module   import Ast_Module
+
+
+class Ast:
+
+    def __init__(self):
+        pass
+
+    def source_code__from(self, target):
+        source_raw = inspect.getsource(target)
+        source     = str_dedent(source_raw)             # remove any training spaces or it won't compile
+        return source
+
+    def ast_module__from(self, target):
+        source_code = self.source_code__from(target)
+        ast_module = self.ast_module__from_source_code(source_code)
+        return ast_module
+
+    def ast_module__from_file(self, path_file):
+        source_code = file_contents(path_file)
+        return self.ast_module__from_source_code(source_code)
+
+    def ast_module__from_source_code(self, source_code):
+        result = ast.parse(source_code)
+        if type(result) is ast.Module:
+            return Ast_Module(result)
+
+    def parse(self, source_code):
+        return ast.parse(source_code)
+
+

osbot_utils/helpers/ast/Ast_Base.py

@@ -0,0 +1,124 @@
+import ast
+import inspect
+
+from osbot_utils.utils.Dev import pprint, jprint
+from osbot_utils.utils.Exceptions import syntax_error
+from osbot_utils.utils.Files import is_file, file_contents
+from osbot_utils.utils.Objects import obj_data, obj_info
+from osbot_utils.utils.Str import str_dedent
+
+
+class Ast_Base:
+    def __init__(self, node):
+        if node.__module__ != 'ast':
+             raise Exception(f'Expected node.__module__ to be ast, got: {node.__module__}')
+        self.node      = node
+
+    def __repr__(self):
+        return self.__class__.__name__
+
+    def is_ast(self, target):
+        if hasattr(target, "__module__"):
+            if target.__module__ == 'ast':
+                return True
+        return False
+
+    def is_not_ast(self, target):
+        return self.is_ast(target) is False
+
+    def dump(self):
+        return ast.dump(self.node, indent=4)
+
+    def execute_code(self, exec_locals=None, exec_namespace=None):
+        exec_locals    = exec_locals    or {}
+        #exec_namespace = exec_namespace or {'__builtins__': {}}        # this has quite a lot of side effects
+        exec_namespace = exec_namespace or {}
+        exec_error  = None
+        try:
+            exec(self.source_code(), exec_namespace, exec_locals)
+            status = 'ok'
+        except Exception as error:
+            status = 'error'
+            exec_error = str(error)
+        return { 'status'    : status         ,
+                 'error'     : exec_error     ,
+                 'locals'    : exec_locals    ,
+                 'namespace' : exec_namespace }
+
+    def info(self):
+        return {}                   # to be overwritten by calles that uses this base class
+
+    def json_data(self, target):
+        if type(target) is dict:
+            data = {}
+            for key, value in target.items():
+                data[key] = self.json_data(value)
+            return data
+        if type(target) is list:
+            data = []
+            for item in target:
+                data.append(self.json_data(item))
+            return data
+        if isinstance(target, Ast_Base):
+            return self.json_data(target.info())
+        return target
+
+    def jprint(self):
+        return self.jprint_json()
+
+    def jprint_json(self):
+        jprint(self.json())
+
+    def json(self):
+        return self.json_data(self.info())
+
+    def key(self):
+        return str(self)
+
+    def obj_data(self, remove_source_info=True):
+        data = obj_data(self.node)
+        if remove_source_info:
+            vars_to_del = ['col_offset', 'end_col_offset', 'lineno', 'end_lineno', 'type_comment']
+            for var_to_del in vars_to_del:
+                if data.get(var_to_del):
+                    del data[var_to_del]
+        return data
+
+    def parse(self, target):
+        try:
+            if type(target) is str:
+                if is_file(target):
+                    source = file_contents(target)
+                else:
+                    source = target
+            else:
+                source = inspect.getsource(target)
+            code = str_dedent(source)                         # remove any training spaces or it won't compile
+            return ast.parse(code)
+        except SyntaxError as error:
+            raise syntax_error(error) from None
+
+    def print(self):
+        return self.print_dump()
+
+    def print_dump(self):
+        print(self.dump())
+        return self
+
+    def print_json(self):
+        pprint(self.json())
+        return self
+
+    def print_obj_info(self):
+        obj_info(self.node)
+        return self
+
+    def print_source_code(self):
+        print(self.source_code())
+        return self
+
+    def source_code(self):
+        return ast.unparse(self.node)
+
+
+

osbot_utils/helpers/ast/Ast_Data.py

@@ -0,0 +1,28 @@
+from osbot_utils.helpers.ast import Ast_Module
+
+class Ast_Data:
+
+    def __init__(self, target):
+        if type(target) is Ast_Module:
+            self.target = target
+        else:
+            self.target = Ast_Module(target)
+        self.ast_visit = None
+
+    # def add_file(self, target):
+    #     self.ast_load.load_file(target)
+    #     return self
+    #
+    # def add_files(self, target):
+    #     self.ast_load.load_files(target)
+    #     return self
+    #
+    # def add_target(self, target):
+    #     self.ast_load.load_target(target)
+    #     return self
+    #
+    # def module(self):
+    #     return self.target
+    #
+    # def stats(self):
+    #     return self.ast_load.stats()

osbot_utils/helpers/ast/Ast_Load.py

@@ -0,0 +1,62 @@
+import ast
+
+from osbot_utils.helpers.Type_Registry import type_registry
+from osbot_utils.utils.Files import file_contents, file_exists
+from osbot_utils.utils.Functions import python_file
+from osbot_utils.helpers.ast.Ast_Node import Ast_Node
+
+#todo: check if this is stll needed since it Ast_Visit does it similar
+class Ast_Load(ast.NodeVisitor):
+
+    def __init__(self):
+        self.ast_nodes = {}
+        self.files_visited = []
+
+    def load_file(self, file_path):
+        if file_exists(file_path):
+            file_visited = "/".join(file_path.split('/')[-4:])
+            source_code  = file_contents(file_path)
+            tree         = ast.parse(source_code)
+            self.visit(tree)
+            self.files_visited.append(file_visited)
+            return True
+        return False
+
+    def load_files(self, files_paths):
+        for file_path in files_paths:
+            self.load_file(file_path)
+
+    def load_target(self, file_path):
+        file = python_file(file_path)
+        return self.load_file(file)
+
+    def add_visited_node(self, node):
+        ast_node     = self.create_ast_node(node)
+        ast_node_key = ast_node.key()  #ast_node.__class__.__name__
+        if self.ast_nodes.get(ast_node_key) is None:
+            self.ast_nodes[ast_node_key] = []
+        self.ast_nodes[ast_node_key].append(ast_node)
+
+    def create_ast_node(self, node):
+        type_key      = type(node)
+        resolved_type = type_registry.resolve(type_key)
+        if resolved_type:
+           return resolved_type(node)
+        return Ast_Node(node)
+
+    def generic_visit(self, node):
+        #print(f'entering {node.__class__.__name__}')
+        self.add_visited_node(node)
+        super().generic_visit(node)
+
+    def stats(self):
+        nodes = {}
+        node_count = 0
+        for key,list in self.ast_nodes.items():
+            key_count = len(list)
+            nodes[key] = key_count
+            node_count += key_count
+        stats = { 'files_visited': self.files_visited,
+                  'node_count' : node_count,
+                  'nodes'      : nodes    }
+        return stats

osbot_utils/helpers/ast/Ast_Merge.py

@@ -0,0 +1,26 @@
+from osbot_utils.utils.Files import is_file, file_contents
+from osbot_utils.helpers.ast import Ast_Module
+from osbot_utils.helpers.ast.Ast_Data import Ast_Data
+
+
+class Ast_Merge:
+
+    def __init__(self):
+        self.module = Ast_Module("")                    # create an empty Ast_Module
+        self.ast_data = Ast_Data(self.module)
+
+    def merge_file(self, file_to_merge):
+        if is_file(file_to_merge):
+            ast_module = Ast_Module(file_to_merge)
+            return self.merge_module(ast_module)
+        return False
+
+    def merge_module(self, module_to_merge):
+        if type(module_to_merge) is Ast_Module:
+            nodes_to_add = module_to_merge.node.body
+            self.module.node.body.extend(nodes_to_add)
+            return True
+        return False
+
+    def source_code(self):
+        return self.module.source_code()

osbot_utils/helpers/ast/Ast_Node.py

@@ -0,0 +1,117 @@
+import ast
+from osbot_utils.helpers.Type_Registry  import type_registry
+from osbot_utils.utils.Lists            import list_stats
+from osbot_utils.helpers.ast.Ast_Base   import Ast_Base
+
+
+class Ast_Node(Ast_Base):
+
+    def __repr__(self):
+        if self.__class__ is Ast_Node:
+            return f"[Ast_Node][????] {self.node.__class__}"
+        return super().__repr__()
+
+    def ast_node(self, node):
+        type_key      = type(node)
+        resolved_type = type_registry.resolve(type_key)
+        if resolved_type:
+           return resolved_type(node)
+        return Ast_Node(node)
+
+    def ast_value(self, value):
+        if value is None:
+            return None
+        if hasattr(value, '__module__') and value.__module__ == 'ast':
+            return self.ast_node(value)
+        if type(value) is list:
+            return self.ast_nodes(value)
+        return value
+
+    def ast_nodes(self, nodes):
+        ast_nodes = []
+        for node in nodes:
+            ast_node = self.ast_node(node)
+            ast_nodes.append(ast_node)           # todo: see the use of .info() here (should be better to return the ast_node)
+        return ast_nodes
+
+    def all_ast_nodes(self):
+        nodes = []
+        for node in ast.walk(self.node):
+            node = self.ast_node(node)
+            nodes.append(node)
+        return nodes
+
+    def stats(self):
+        ast_node_types   = []
+        node_types       = []
+        all_keys         = []
+        all_values       = []
+        for ast_node in self.all_ast_nodes():
+            ast_node_types.append(ast_node     .__class__.__name__)
+            node_types    .append(ast_node.node.__class__.__name__)
+
+            for _,info in ast_node.info().items():
+                if type(info) is dict:
+                    for key,value in info.items():
+                        if not isinstance(value, Ast_Node):
+                            if type(value) not in [list, dict, tuple]:
+                                if type(value) is str:
+                                    value = value[:20].strip()
+                                if value and 'ast.Constant' in str(value):
+                                    print(key, str(value))
+                                all_keys  .append(key)
+                                all_values.append(value)
+
+                    assert _ == ast_node.__class__.__name__     # todo: revove after refactoring
+
+        stats = {'all_keys'       : list_stats(all_keys)        ,
+                 'all_values'     : list_stats(all_values)      ,
+                 'ast_node_types' : list_stats(ast_node_types ) ,
+                 'node_types'     : list_stats(node_types) }
+
+        #pprint(stats)
+        return stats
+
+
+    # node vars mappings
+    def args        (self): return self.ast_value(self.node.args        )
+    def bases       (self): return self.ast_value(self.node.bases       )
+    def body        (self): return self.ast_value(self.node.body        )
+    def cause       (self): return self.ast_value(self.node.cause       )
+    def comparators (self): return self.ast_value(self.node.comparators )
+    def context_expr(self): return self.ast_value(self.node.context_expr)
+    def ctx         (self): return self.ast_value(self.node.ctx         )
+    def dims        (self): return self.ast_value(self.node.dims        )
+    def elt         (self): return self.ast_value(self.node.elt         )
+    def elts        (self): return self.ast_value(self.node.elts        )
+    def exc         (self): return self.ast_value (self.node.exc        )
+    def func        (self): return self.ast_value(self.node.func        )
+    def id          (self): return self.ast_value(self.node.id          )
+    def ifs         (self): return self.ast_value(self.node.ifs         )
+    def items       (self): return self.ast_value(self.node.items       )
+    def iter        (self): return self.ast_value(self.node.iter        )
+    def generators  (self): return self.ast_value(self.node.generators  )
+    def finalbody   (self): return self.ast_value(self.node.finalbody   )
+    def handlers    (self): return self.ast_value(self.node.handlers    )
+    def keys        (self): return self.ast_value(self.node.keys        )
+    def keywords    (self): return self.ast_value(self.node.keywords    )
+    def left        (self): return self.ast_value(self.node.left        )
+    def level       (self): return self.ast_value(self.node.level       )
+    def lower       (self): return self.ast_value(self.node.lower       )
+    def module      (self): return self.ast_value(self.node.module      )
+    def name        (self): return self.ast_value(self.node.name        )
+    def names       (self): return self.ast_value(self.node.names       )
+    def op          (self): return self.ast_value(self.node.op          )
+    def operand     (self): return self.ast_value(self.node.operand     )
+    def ops         (self): return self.ast_value(self.node.ops         )
+    def orelse      (self): return self.ast_value(self.node.orelse      )
+    def right       (self): return self.ast_value(self.node.right       )
+    def msg         (self): return self.ast_value(self.node.msg         )
+    def slice       (self): return self.ast_value(self.node.slice       )
+    def target      (self): return self.ast_value(self.node.target      )
+    def targets     (self): return self.ast_value(self.node.targets     )
+    def test        (self): return self.ast_value(self.node.test        )
+    def type        (self): return self.ast_value(self.node.type        )
+    def upper       (self): return self.ast_value (self.node.upper      )
+    def value       (self): return self.ast_value(self.node.value       )
+    def values      (self): return self.ast_value(self.node.values      )

osbot_utils/helpers/ast/Ast_Visit.py

@@ -0,0 +1,85 @@
+from osbot_utils.helpers.ast            import Ast_Module
+from osbot_utils.helpers.ast.Ast_Base   import Ast_Base
+
+class Ast_Visit:
+
+    def __init__(self, target):
+        if isinstance(target, Ast_Base):                    # support when we pass an Ast_Node
+            self.ast_node = target
+        else:
+            self.ast_node = Ast_Module(target)                # or when we pass source code, or a python object
+        self.node_handlers    = {}
+        self.capture_handlers = {}
+
+    def __enter__(self): return self
+    def __exit__(self, exc_type, exc_val, exc_tb): pass
+
+    def capture(self, node_type, callback):
+        self.capture_handlers[node_type] = { 'callback': callback,
+                                             'nodes'   : []      }
+        return self
+
+    def capture_calls(self, callback=None):
+        return self.capture('Ast_Call', callback)
+
+    def capture_imports(self, callback=None):
+        self.capture('Ast_Import'     , callback)
+        self.capture('Ast_Import_From', callback)
+        return self
+
+    def capture_modules(self, callback=None):
+        return self.capture('Ast_Module', callback)
+
+    def capture_functions(self, callback=None):
+        return self.capture('Ast_Function_Def', callback)
+
+    def captured_nodes(self):
+        captured = {}
+        for node_type, data in self.capture_handlers.items():
+            captured[node_type] = data['nodes']
+        return captured
+
+    def invoke_capture_callbacks(self):
+        for node_type, data in self.capture_handlers.items():
+            callback = data['callback']
+            nodes    = data['nodes']
+            if callback:
+                callback(nodes)
+
+    def on_node(self, node):
+        node_type = type(node).__name__
+        if node_type in self.capture_handlers:
+            self.capture_handlers[node_type]['nodes'].append(node)
+        if node_type in self.node_handlers:
+            for handler in self.node_handlers[node_type]:
+                handler(node)
+
+    def stats(self):
+        stats = {}
+        for node_type, data in self.capture_handlers.items():
+            stats[node_type] = len(data['nodes'])
+        return stats
+
+    def register_node_handler(self, node_type, handler):
+        if node_type not in self.node_handlers:
+            self.node_handlers[node_type] = []
+        self.node_handlers[node_type].append(handler)
+        return self
+
+    def visit(self):
+        self.visit_node(self.ast_node)
+        self.invoke_capture_callbacks()
+        return self
+
+    def visit_node(self, node):
+        if isinstance(node, Ast_Base):
+            self.on_node(node)
+            self.visit_node(node.info())
+        elif type(node) is dict:
+            for _, value in node.items():
+                self.visit_node(value)
+        elif type(node) is list:
+            for item in node:
+                self.visit_node(item)
+
+

osbot_utils/helpers/ast/Call_Tree.py

@@ -0,0 +1,38 @@
+import ast
+import inspect
+from osbot_utils.utils.Str import str_dedent
+
+
+class Call_Tree:
+
+    def get_called_methods(self, func):
+        source = inspect.getsource(func)
+        source = str_dedent(source)
+        tree    = ast.parse(source)
+
+
+        class CallVisitor(ast.NodeVisitor):
+            def __init__(self):
+                self.called_methods = []
+
+            def visit_FunctionDef(self, node):
+                node.name = 'aaaaa'
+                print(node)
+
+
+            def visit_Call(self, node):
+
+
+                if isinstance(node.func, ast.Attribute):        # This handles method calls like obj.method()
+                    self.called_methods.append(node.func.attr)
+                elif isinstance(node.func, ast.Name):           # This handles direct function calls like func()
+                    self.called_methods.append(node.func.id)
+                self.generic_visit(node)
+
+        visitor = CallVisitor()
+        visitor.visit(tree)
+
+        print()
+        #print(ast.dump(tree, indent=2))
+        return ast.unparse(tree)            #todo: finish implementation
+        return visitor.called_methods

osbot_utils/helpers/ast/__init__.py

@@ -0,0 +1,145 @@
+# note 1: this __init__.py file needs to be here (vs inside the /utils/ast/nodes folder)
+#         so that the methods registration happens as soon as somebody uses a method from the /utils/ast folder/package
+# note 2: this is needed due to the circular dependencyes between the Ast_Node and the
+#         clases that use it as a base class
+
+import ast
+from osbot_utils.helpers.Type_Registry                import type_registry
+from osbot_utils.helpers.ast.nodes.Ast_Add            import Ast_Add
+from osbot_utils.helpers.ast.nodes.Ast_Alias          import Ast_Alias
+from osbot_utils.helpers.ast.nodes.Ast_And            import Ast_And
+from osbot_utils.helpers.ast.nodes.Ast_Argument       import Ast_Argument
+from osbot_utils.helpers.ast.nodes.Ast_Arguments      import Ast_Arguments
+from osbot_utils.helpers.ast.nodes.Ast_Assert         import Ast_Assert
+from osbot_utils.helpers.ast.nodes.Ast_Assign         import Ast_Assign
+from osbot_utils.helpers.ast.nodes.Ast_Attribute      import Ast_Attribute
+from osbot_utils.helpers.ast.nodes.Ast_Aug_Assign     import Ast_Aug_Assign
+from osbot_utils.helpers.ast.nodes.Ast_Bin_Op         import Ast_Bin_Op
+from osbot_utils.helpers.ast.nodes.Ast_Bool_Op        import Ast_Bool_Op
+from osbot_utils.helpers.ast.nodes.Ast_Break          import Ast_Break
+from osbot_utils.helpers.ast.nodes.Ast_Call           import Ast_Call
+from osbot_utils.helpers.ast.nodes.Ast_Class_Def      import Ast_Class_Def
+from osbot_utils.helpers.ast.nodes.Ast_Compare        import Ast_Compare
+from osbot_utils.helpers.ast.nodes.Ast_Comprehension  import Ast_Comprehension
+from osbot_utils.helpers.ast.nodes.Ast_Constant       import Ast_Constant
+from osbot_utils.helpers.ast.nodes.Ast_Continue       import Ast_Continue
+from osbot_utils.helpers.ast.nodes.Ast_Dict           import Ast_Dict
+from osbot_utils.helpers.ast.nodes.Ast_Eq             import Ast_Eq
+from osbot_utils.helpers.ast.nodes.Ast_Except_Handler import Ast_Except_Handler
+from osbot_utils.helpers.ast.nodes.Ast_Expr           import Ast_Expr
+from osbot_utils.helpers.ast.nodes.Ast_For            import Ast_For
+from osbot_utils.helpers.ast.nodes.Ast_Function_Def   import Ast_Function_Def
+from osbot_utils.helpers.ast.nodes.Ast_Generator_Exp  import Ast_Generator_Exp
+from osbot_utils.helpers.ast.nodes.Ast_Gt             import Ast_Gt
+from osbot_utils.helpers.ast.nodes.Ast_GtE            import Ast_GtE
+from osbot_utils.helpers.ast.nodes.Ast_If             import Ast_If
+from osbot_utils.helpers.ast.nodes.Ast_If_Exp         import Ast_If_Exp
+from osbot_utils.helpers.ast.nodes.Ast_Import         import Ast_Import
+from osbot_utils.helpers.ast.nodes.Ast_Import_From    import Ast_Import_From
+from osbot_utils.helpers.ast.nodes.Ast_In             import Ast_In
+from osbot_utils.helpers.ast.nodes.Ast_Is             import Ast_Is
+from osbot_utils.helpers.ast.nodes.Ast_Is_Not         import Ast_Is_Not
+from osbot_utils.helpers.ast.nodes.Ast_Keyword        import Ast_Keyword
+from osbot_utils.helpers.ast.nodes.Ast_Lambda         import Ast_Lambda
+from osbot_utils.helpers.ast.nodes.Ast_List           import Ast_List
+from osbot_utils.helpers.ast.nodes.Ast_List_Comp      import Ast_List_Comp
+from osbot_utils.helpers.ast.nodes.Ast_Load           import Ast_Load
+from osbot_utils.helpers.ast.nodes.Ast_Lt             import Ast_Lt
+from osbot_utils.helpers.ast.nodes.Ast_LtE            import Ast_LtE
+from osbot_utils.helpers.ast.nodes.Ast_Mod            import Ast_Mod
+from osbot_utils.helpers.ast.nodes.Ast_Module         import Ast_Module
+from osbot_utils.helpers.ast.nodes.Ast_Mult           import Ast_Mult
+from osbot_utils.helpers.ast.nodes.Ast_Name           import Ast_Name
+from osbot_utils.helpers.ast.nodes.Ast_Not            import Ast_Not
+from osbot_utils.helpers.ast.nodes.Ast_Not_Eq         import Ast_Not_Eq
+from osbot_utils.helpers.ast.nodes.Ast_Not_In         import Ast_Not_In
+from osbot_utils.helpers.ast.nodes.Ast_Or             import Ast_Or
+from osbot_utils.helpers.ast.nodes.Ast_Pass           import Ast_Pass
+from osbot_utils.helpers.ast.nodes.Ast_Pow            import Ast_Pow
+from osbot_utils.helpers.ast.nodes.Ast_Raise          import Ast_Raise
+from osbot_utils.helpers.ast.nodes.Ast_Return         import Ast_Return
+from osbot_utils.helpers.ast.nodes.Ast_Set            import Ast_Set
+from osbot_utils.helpers.ast.nodes.Ast_Slice          import Ast_Slice
+from osbot_utils.helpers.ast.nodes.Ast_Starred        import Ast_Starred
+from osbot_utils.helpers.ast.nodes.Ast_Store          import Ast_Store
+from osbot_utils.helpers.ast.nodes.Ast_Sub            import Ast_Sub
+from osbot_utils.helpers.ast.nodes.Ast_Subscript      import Ast_Subscript
+from osbot_utils.helpers.ast.nodes.Ast_Try            import Ast_Try
+from osbot_utils.helpers.ast.nodes.Ast_Tuple          import Ast_Tuple
+from osbot_utils.helpers.ast.nodes.Ast_Unary_Op       import Ast_Unary_Op
+from osbot_utils.helpers.ast.nodes.Ast_While          import Ast_While
+from osbot_utils.helpers.ast.nodes.Ast_With           import Ast_With
+from osbot_utils.helpers.ast.nodes.Ast_With_Item      import Ast_With_Item
+from osbot_utils.helpers.ast.nodes.Ast_Yield          import Ast_Yield
+
+ast_types = {
+    ast.Add           : Ast_Add           ,
+    ast.alias         : Ast_Alias         ,
+    ast.And           : Ast_And           ,
+    ast.Assert        : Ast_Assert        ,
+    ast.Assign        : Ast_Assign        ,
+    ast.Attribute     : Ast_Attribute     ,
+    ast.arg           : Ast_Argument      ,
+    ast.arguments     : Ast_Arguments     ,
+    ast.AugAssign     : Ast_Aug_Assign    ,
+    ast.BinOp         : Ast_Bin_Op        ,
+    ast.BoolOp        : Ast_Bool_Op       ,
+    ast.Break         : Ast_Break         ,
+    ast.Call          : Ast_Call          ,
+    ast.ClassDef      : Ast_Class_Def     ,
+    ast.Compare       : Ast_Compare       ,
+    ast.Constant      : Ast_Constant      ,
+    ast.Continue      : Ast_Continue      ,
+    ast.comprehension : Ast_Comprehension ,
+    ast.Dict          : Ast_Dict          ,
+    ast.ExceptHandler : Ast_Except_Handler,
+    ast.Expr          : Ast_Expr          ,
+    ast.Eq            : Ast_Eq            ,
+    ast.Gt            : Ast_Gt            ,
+    ast.GtE           : Ast_GtE           ,
+    ast.Import        : Ast_Import        ,
+    ast.ImportFrom    : Ast_Import_From   ,
+    ast.In            : Ast_In            ,
+    ast.For           : Ast_For           ,
+    ast.FunctionDef   : Ast_Function_Def  ,
+    ast.GeneratorExp  : Ast_Generator_Exp ,
+    ast.If            : Ast_If            ,
+    ast.IfExp         : Ast_If_Exp        ,
+    ast.Is            : Ast_Is            ,
+    ast.IsNot         : Ast_Is_Not        ,
+    ast.keyword       : Ast_Keyword       ,
+    ast.Lambda        : Ast_Lambda        ,
+    ast.List          : Ast_List          ,
+    ast.ListComp      : Ast_List_Comp     ,
+    ast.Lt            : Ast_Lt            ,
+    ast.LtE           : Ast_LtE           ,
+    ast.Load          : Ast_Load          ,
+    ast.Mod           : Ast_Mod           ,
+    ast.Module        : Ast_Module        ,
+    ast.Mult          : Ast_Mult          ,
+    ast.Name          : Ast_Name          ,
+    ast.Not           : Ast_Not           ,
+    ast.NotEq         : Ast_Not_Eq        ,
+    ast.NotIn         : Ast_Not_In        ,
+    ast.Or            : Ast_Or            ,
+    ast.Pass          : Ast_Pass          ,
+    ast.Pow           : Ast_Pow           ,
+    ast.Raise         : Ast_Raise         ,
+    ast.Return        : Ast_Return        ,
+    ast.Slice         : Ast_Slice         ,
+    ast.Starred       : Ast_Starred       ,
+    ast.Store         : Ast_Store         ,
+    ast.Set           : Ast_Set           ,
+    ast.Sub           : Ast_Sub           ,
+    ast.Subscript     : Ast_Subscript     ,
+    ast.Try           : Ast_Try           ,
+    ast.Tuple         : Ast_Tuple         ,
+    ast.UnaryOp       : Ast_Unary_Op      ,
+    ast.While         : Ast_While         ,
+    ast.With          : Ast_With          ,
+    ast.withitem      : Ast_With_Item     ,
+    ast.Yield         : Ast_Yield         ,
+}
+
+for key, value in ast_types.items():
+    type_registry.register(key, value)

osbot_utils/helpers/ast/nodes/Ast_Add.py

@@ -0,0 +1,6 @@
+from osbot_utils.helpers.ast.Ast_Node import Ast_Node
+
+class Ast_Add(Ast_Node):
+
+    def info(self):
+        return {'Ast_Add': {}}

osbot_utils/helpers/ast/nodes/Ast_Alias.py

@@ -0,0 +1,6 @@
+from osbot_utils.helpers.ast.Ast_Node import Ast_Node
+
+class Ast_Alias(Ast_Node):
+
+    def info(self):
+        return {'Ast_Alias': { 'asname'  : self.node.asname , 'name': self.node.name }}