Merge pull request #60 from LucasAndradeDias/multi-files-tracing

Multi files tracing

Author: LucasAndradeDias

src/outliner/cli.py renamed to src/outliner/__main__.py

@@ -9,15 +9,13 @@ def parser_arguments():
         "-fp",
         help="Path to the file you want to trace",
         required=True,
-        nargs=1,
     )
     parser.add_argument(
         "--object_invoke",
         "-o",
         help="The invoking statement of the object",
         type=str,
         required=True,
-        nargs=1,
     )
     parser.add_argument(
         "--mode",
@@ -33,11 +31,13 @@ def parser_arguments():
 
 def main():
     args = parser_arguments()
-
     instance_class = Outliner(
         args.file_path,
         args.object_invoke,
         args.mode,
     )
 
     instance_class.run()
+
+if __name__ == "__main__":
+    main()

src/outliner/modules/__init__.py

@@ -0,0 +1,2 @@
+from .trace import Trace
+from .display import Display

src/outliner/modules/display.py

@@ -37,9 +37,11 @@ def tree(self):
             connect_branch = (
                 lines
                 + self.ansi_for_tree[
-                    "CHILD_OBJECT_ANSI"
-                    if not func_With_exception
-                    else "CHILD_WITH_EXECEPTION"
+                    (
+                        "CHILD_OBJECT_ANSI"
+                        if not func_With_exception
+                        else "CHILD_WITH_EXECEPTION"
+                    )
                 ]
                 + f"{position}. "
                 + func

src/outliner/modules/trace.py

@@ -1,11 +1,7 @@
 import sys
-
 import collections
-import importlib.util
 
-from functools import partial
-from pathlib import Path
-from typing import Optional
+from ..views import RunningObject
 
 
 class ExceptionWhileTracing(Exception):
@@ -14,7 +10,10 @@ class ExceptionWhileTracing(Exception):
     pass
 
 
+
+
 class Trace:
+
     def __init__(self):
         self.detailed_data = collections.defaultdict(
             lambda: {"call": 0, "return": 0, "line": 0, "exception": 0}
@@ -32,64 +31,19 @@ def _trace_function(self, frame, event, arg):
 
     def _running_trace(self, obj) -> None:
         try:
+            instance = obj.instance()
             sys.settrace(self._trace_function)
-            obj()
+            instance()
         except ExceptionWhileTracing as error:
             return
-        except Exception as error:
-            raise error
+        except Exception:
+            raise Exception("Erro durante execução")
         finally:
             sys.settrace(None)
 
-    def _get_object_arguments(self, obj: str):
-        parenthesis_1 = obj.index("(")
-        parenthesis_2 = obj.index(")")
-        obj_arguments = obj[parenthesis_1 + 1 : parenthesis_2].split(",")
-
-        return None if not any(obj_arguments) else obj_arguments
-
-    def _create_obj_instance(self, module: any, object_: str):
-        object_name = object_.split("(")[0]
-        object_arguments = self._get_object_arguments(object_)
-
-        obj_instance = getattr(module, object_name, None)
-
-        if object_arguments:
-            obj_instance = partial(obj_instance, *object_arguments)
-
-        return obj_instance
-
-    def run_file(
-        self,
-        module_path: Path,
-        object_to_run: str,
-    ) -> None:
-        """
-        Trace a file
-
-        :param Path-like module_path: The path to the module
-        :param str object_to_run: The object to be traced inside the module
-        """
-        module_name = module_path.stem
-
-        moduleSpec = importlib.util.spec_from_file_location(module_name, module_path)
-        module_obj = importlib.util.module_from_spec(moduleSpec)
-
-        moduleSpec.loader.exec_module(module_obj)
-
-        if len(object_to_run.split(".")) >= 2:
-            obj_class_instance = self._create_obj_instance(
-                module_obj, object_to_run.split(".")[0]
-            )()
-            running_obj = self._create_obj_instance(
-                obj_class_instance, object_to_run.split(".")[1]
-            )
-        else:
-            running_obj = self._create_obj_instance(module_obj, object_to_run)
-
+    def trace_obj(self, running_obj: RunningObject):
         if not callable(running_obj):
-            raise Exception("given object '%s' is not callable." % (module_name))
-
+            raise Exception(f"Given object '{running_obj}' is not callable.")
         self._running_trace(running_obj)
 
     def __str__(self):

src/outliner/outliner.py

@@ -1,38 +1,44 @@
 import re
 
 from pathlib import Path
+
 from .modules.trace import Trace
 from .modules.display import Display
 
+from .views import ModuleObject, RunningObject
+
 
 class Outliner:
-    def __init__(self, file_path, object_name, display_type):
+    def __init__(self, file_path, object_name: str, display_type: str):
         self.file = file_path
         self.obj_name = object_name
         self.display_type = display_type
         self.callable_object_parttern = re.compile(
             r"\w+\((?:'\w+')?(?:\.\w+\('(?:\w+)'\))?\)"
         )
+        self._check_file()
 
     def run(self):
         """
         This method trace an object and prints out a tree with found data
         """
-        self._check_file()
 
         if not re.match(self.callable_object_parttern, self.obj_name):
             raise ValueError("Not valid callable syntax")
 
+        module_obj = ModuleObject(Path(self.file))
+        running_obj = RunningObject(module_obj, self.obj_name)
+
         trace = Trace()
+        trace.trace_obj(running_obj)
 
-        trace.run_file(Path(self.file), self.obj_name)
         display_class = Display(trace.detailed_data, trace.functions_flow)
 
         running_display = getattr(display_class, self.display_type)
         running_display()
 
     def _check_file(self):
         if not Path(self.file).is_file():
-            raise ("Not a valid file")
+            raise Exception(f"Not a valid file\nPath:'{self.file}'")
         if not ".py" in self.file:
-            raise ("Not a python file")
+            raise Exception("Not a python file")

src/outliner/utils/__init__.py

@@ -0,0 +1,16 @@
+import importlib
+import importlib.abc
+from types import ModuleType
+
+
+class CustomLoader(importlib.abc.Loader):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def create_module(spec) -> object:
+        return None
+
+    def exec_module(module: ModuleType) -> None:
+        with open(module.__spec__.origin, "rb") as f:
+            code = compile(f.read(), module.__spec__.origin, "exec")
+            exec(code, module.__dict__)

src/outliner/utils/loader.py

@@ -0,0 +1,2 @@
+from .module_obj import ModuleObject
+from .running_obj import RunningObject

src/outliner/views/__init__.py

@@ -0,0 +1,63 @@
+import sys
+import ast
+import importlib
+
+from importlib import util
+from pathlib import Path
+from ..utils.loader import CustomLoader
+
+
+class ModuleObject:
+    """
+    Run all needed pre-sets to run the trace_object.
+
+    Class create to transforms the script into an better handling object.
+    That way, it is faster to handle with it because will use ast module to get infos about it
+    """
+
+    def __init__(
+        self,
+        module_path: Path,
+    ):
+        self.module_path = module_path
+        self.module_ast = self._load_file_ast()
+        self.found_submodules = self._find_imported_modules()
+
+        sys.path.append(str(module_path.parent))
+
+        for submodule in self.found_submodules:
+            try:
+                importlib.import_module(submodule)
+            except ModuleNotFoundError:
+                raise ModuleNotFoundError(
+                    f"Could not add the submodule '{submodule}' to the namespace.\n check if the module is installed."
+                )
+
+    def _find_imported_modules(self) -> iter:
+        """
+        A generator with all imports the ast object contains in its namespace
+        """
+        for node in ast.walk(self.module_ast):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    yield alias.name
+            elif isinstance(node, ast.ImportFrom):
+                if node.module is not None:
+                    yield node.module
+        return []
+
+    def _load_file_ast(self) -> ast.parse:
+        with open(self.module_path, "r") as file:
+            return ast.parse(file.read())
+
+    def module(self):
+        """
+        Return a the ModuleObj and the ModuleSpec (https://peps.python.org/pep-0451/) of the module
+        """
+        module_name = self.module_path.stem
+        module_spec = util.spec_from_file_location(
+            name=module_name, location=self.module_path, loader=CustomLoader
+        )
+        module_obj = util.module_from_spec(module_spec)
+
+        return module_obj, module_spec

src/outliner/views/module_obj.py

@@ -0,0 +1,56 @@
+from .module_obj import ModuleObject
+from functools import partial
+
+
+class RunningObject:
+    """
+    Create an running object from a module obj
+    """
+
+    def __init__(self, script_obj: ModuleObject, obj_invoking: str):
+        self.obj_invoking = obj_invoking
+        self.script_obj = script_obj
+        self.father_module = self.script_obj.module()
+
+        self.module_obj = self.father_module[0]
+        self.module_spec = self.father_module[1]
+
+        # load the module to the global namespace
+        self.module_spec.loader.exec_module(self.module_obj)
+
+        self.running_obj = None
+        self.instance()
+
+    def _get_object_arguments(self, obj: str):
+        parenthesis_1 = obj.index("(")
+        parenthesis_2 = obj.index(")")
+        obj_arguments = obj[parenthesis_1 + 1 : parenthesis_2].split(",")
+
+        return obj_arguments if any(obj_arguments) else None
+
+    def _create_obj_instance(self, namespace: any, object_: str):
+        object_name = object_.split("(")[0]
+        object_arguments = self._get_object_arguments(object_)
+        obj_instance = getattr(namespace, object_name, None)
+
+        if object_arguments is not None:
+            obj_instance = partial(obj_instance, *object_arguments)
+
+        return obj_instance
+
+    def instance(self):
+        """Creates an instance of the object"""
+        running_obj = None
+        father = self.module_obj
+        objs = self.obj_invoking.split(".") or [self.obj_invoking]
+        for number, _ in enumerate(objs):
+            running_obj = self._create_obj_instance(father, objs[number])
+            if len(objs) == number:
+                break
+            father = running_obj
+
+        self.running_obj = father
+        return running_obj
+
+    def __call__(self):
+        self.instance()

src/outliner/views/running_obj.py

@@ -0,0 +1,18 @@
+from module_2 import final_function
+
+class Dummy:
+
+    def __init__(self):
+        self.method1()
+
+    def method1(self):
+        return self.method2()
+    
+    def method2(self):
+        return self.method_math()
+
+    def method_math(self):
+        return final_function()
+
+def final():
+    Dummy()

tests/data/multifiles/module.py

@@ -0,0 +1,3 @@
+
+def final_function():
+    return 1 + 2

tests/data/multifiles/module_2.py

@@ -0,0 +1,20 @@
+from module import Dummy, final
+
+
+
+def test4():
+    test5()
+
+def test3():
+    return test4()
+
+def test2():
+    test3()
+
+def test1():
+    test2()
+
+def test5():
+    final()
+
+#test = Dummy