danielutils 1.0.46__tar.gz → 1.0.50__tar.gz

{danielutils-1.0.46/danielutils.egg-info → danielutils-1.0.50}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: danielutils
-Version: 1.0.46
+Version: 1.0.50
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -33,7 +33,6 @@ Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.8.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Dynamic: license-file
 
 [![Python package](https://github.com/danielnachumdev/danielutils/actions/workflows/python-package.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/python-package.yml)
 [![Pylint](https://github.com/danielnachumdev/danielutils/actions/workflows/pylint.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/pylint.yml)
@@ -41,7 +40,7 @@ Dynamic: license-file
 [![gitleaks](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml)
 [![CodeQL](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql)
 
-# danielutils v1.0.46
+# danielutils v1.0.50
 
 A comprehensive Python utilities library designed to enhance your development workflow with powerful tools for type safety, async programming, database operations, and much more.
 

{danielutils-1.0.46 → danielutils-1.0.50}/README.md

@@ -4,7 +4,7 @@
 [![gitleaks](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml)
 [![CodeQL](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql)
 
-# danielutils v1.0.46
+# danielutils v1.0.50
 
 A comprehensive Python utilities library designed to enhance your development workflow with powerful tools for type safety, async programming, database operations, and much more.
 

{danielutils-1.0.46 → danielutils-1.0.50}/danielutils/abstractions/db/database_initializer.py

@@ -238,7 +238,7 @@ class DatabaseInitializer(ABC):
                     await db.create_table(expected_schema)
                 else:
                     logger.info(f"Validating table '{table_name}'")
-                    if not validate_schema(db, table_name, expected_schema):
+                    if not await validate_schema(db, table_name, expected_schema):
                         raise ValueError(
                             f"Schema validation failed for table '{table_name}'. "
                             "Please check the logs for details."

{danielutils-1.0.46 → danielutils-1.0.50}/danielutils/logging_/logger.py

@@ -70,7 +70,7 @@ class _LoggerImpl:
 
 class Logger:
     @classmethod
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs) -> None:
         cls._logger = _LoggerImpl(cls)
         cls._registered_loggers: List[LoggerStrategyImplBase] = []
         cls.init_subscribers()

danielutils-1.0.50/danielutils/reflection/__init__.py

@@ -0,0 +1,6 @@
+from .interpreter import *  # this has to be first, the order matters!
+from .file import *
+from .function import *
+from .info_classes import *
+from .class_ import *
+from .module import *

danielutils-1.0.50/danielutils/reflection/info_classes/__init__.py

@@ -0,0 +1,6 @@
+from .argument_info import *
+from .class_info import *
+from .decoration_info import *
+from .file_info import *
+from .function_info import *
+from .import_info import *

{danielutils-1.0.46/danielutils/reflection → danielutils-1.0.50/danielutils/reflection/info_classes}/argument_info.py

@@ -62,7 +62,7 @@ class ArgumentInfo:
         if self.default is not None:
             res += f", default={self.default}"
         if self.is_parameterized:
-            res+=f", parameters={self.parameters}"
+            res += f", parameters={self.parameters}"
         return res + ")"
 
     def __str__(self) -> str:
@@ -75,8 +75,11 @@ class ArgumentInfo:
             raise ValueError(f"Invalid argument info string: {string}")
 
         kwargs, args, kwarg_only, pname, parameters, name, type, default_value = m.groups()
+        type = None if type is None else type.strip()
+        default_value = None if default_value is None else default_value.strip()
         return ArgumentInfo(
-            name=name or pname,
+            name=name or pname or (args.strip("*") if args else None) or (
+                kwargs.strip("*") if kwargs else None) or (kwarg_only.strip("/") if kwarg_only else None) or None,
             type=type,
             default=default_value,
             is_kwargs=kwargs is not None,
@@ -90,6 +93,9 @@ class ArgumentInfo:
         if string is None:
             return []
         string = string.strip()
+        if not string:
+            return []
+        string = string.strip()
         indices = [-1]
         stack: List[str] = []
         for i, c in enumerate(string):

{danielutils-1.0.46/danielutils/reflection → danielutils-1.0.50/danielutils/reflection/info_classes}/class_info.py

@@ -1,11 +1,11 @@
 import inspect
 import json
 import re
-from typing import Optional, List, Iterable, Type, TypeVar, Generic, get_origin
+from typing import List, Iterable, Type, TypeVar, Generic, get_origin
 from .function_info import FunctionInfo
 from .decoration_info import DecorationInfo
 from .argument_info import ArgumentInfo
-from ..functions import isoftype
+from ...functions import isoftype
 
 T = TypeVar("T")
 
@@ -62,10 +62,14 @@ class ClassInfo:
                 elif inspect.isdatadescriptor(obj):
                     inspect.getsource(obj.fget)  # type:ignore
                 else:
-                    raise Exception()
+                    continue
             except:
                 continue
-            self._functions.append(FunctionInfo(obj, self._cls))
+
+            try:
+                self._functions.append(FunctionInfo(obj, self._cls))  # type: ignore
+            except Exception as e:
+                raise Exception(f"Error parsing function '{attr}' of class '{self._name}': {e}", e) from e
 
     def __str__(self) -> str:
         body = json.dumps({

danielutils-1.0.50/danielutils/reflection/info_classes/file_info.py

@@ -0,0 +1,267 @@
+import ast
+import tokenize
+import io
+import importlib.util
+import inspect
+from collections import Counter
+from pathlib import Path
+from typing import List, Set, Dict, Any
+
+from .import_info import ImportInfo
+from .class_info import ClassInfo
+from .function_info import FunctionInfo
+
+
+class FileInfo:
+    """
+    A class for static analysis of a Python source file.
+
+    Analysis includes:
+      • Tokenization: token count and token frequency distribution.
+      • Extraction of comments.
+      • Listing names of classes and functions.
+      • Identification of import statements, now represented by ImportInfo objects.
+      • Basic import usage analysis (which imports appear to be used).
+      • (Dynamic) loading of the file to create detailed ClassInfo and FunctionInfo objects.
+    """
+
+    def __init__(self, file_path: str) -> None:
+        self.file_path = str(Path(file_path).resolve())
+        self._content: str = self._read_file()
+        self._tree: ast.AST = self._parse_content()
+        self._tokens: List[tokenize.TokenInfo] = None
+
+    def _read_file(self) -> str:
+        """Reads and returns the file content as UTF-8 text."""
+        try:
+            with open(self.file_path, "r", encoding="utf-8") as f:
+                return f.read()
+        except Exception as e:
+            raise Exception(f"Error reading {self.file_path}: {e}")
+
+    def _parse_content(self) -> ast.AST:
+        """Parses the file content into an AST."""
+        try:
+            return ast.parse(self._content, filename=self.file_path)
+        except Exception as e:
+            raise Exception(f"Error parsing {self.file_path}: {e}")
+
+    def _tokenize(self) -> None:
+        """Tokenizes the file content using tokenize.tokenize()."""
+        self._tokens = []
+        stream = io.BytesIO(self._content.encode("utf-8"))
+        try:
+            for tok in tokenize.tokenize(stream.readline):
+                if tok.type == tokenize.ENCODING:
+                    continue
+                self._tokens.append(tok)
+        except tokenize.TokenError as te:
+            print(f"Tokenize error: {te}")
+
+    @property
+    def tokens(self) -> List[tokenize.TokenInfo]:
+        """Returns the list of tokens from the file."""
+        if self._tokens is None:
+            self._tokenize()
+        return self._tokens
+
+    @property
+    def token_count(self) -> int:
+        """Total number of tokens in the file."""
+        return len(self.tokens)
+
+    @property
+    def token_distribution(self) -> Dict[str, int]:
+        """A dictionary mapping token strings to their frequency."""
+        return dict(Counter(tok.string for tok in self.tokens))
+
+    @property
+    def comments(self) -> List[str]:
+        """A list of all comment strings in the file."""
+        return [tok.string for tok in self.tokens if tok.type == tokenize.COMMENT]
+
+    @property
+    def class_names(self) -> List[str]:
+        """Names of all classes defined in the file."""
+        return [node.name for node in ast.walk(self._tree) if isinstance(node, ast.ClassDef)]
+
+    @property
+    def function_names(self) -> List[str]:
+        """Names of all functions (including async) defined in the file."""
+        return [
+            node.name
+            for node in ast.walk(self._tree)
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+        ]
+
+    @property
+    def imports(self) -> List[Any]:
+        """
+        Returns a list of ImportInfo objects representing all import statements.
+        Each AST node of type ast.Import or ast.ImportFrom is transformed via
+        ImportInfo.from_ast().
+        """
+        results = []
+        if ImportInfo is None:
+            return results
+        for node in ast.walk(self._tree):
+            if isinstance(node, (ast.Import, ast.ImportFrom)):
+                results.extend(ImportInfo.from_ast(node))
+        return results
+
+    @property
+    def used_names(self) -> Set[str]:
+        """
+        A set of all names (identifiers) used in the file,
+        based on ast.Name nodes.
+        """
+        names = set()
+        for node in ast.walk(self._tree):
+            if isinstance(node, ast.Name):
+                names.add(node.id)
+        return names
+
+    @property
+    def import_usage(self) -> Dict[str, List[Any]]:
+        """
+        Returns a dictionary with two keys:
+          • 'used' : list of ImportInfo objects for which the alias is found in the file,
+          • 'unused' : list of ImportInfo objects whose alias is never referenced.
+        Wildcard imports (alias "*") are assumed to be used.
+        """
+        used, unused = [], []
+        for imp in self.imports:
+            if imp.alias == "*" or imp.alias is None or imp.alias in self.used_names:
+                used.append(imp)
+            else:
+                unused.append(imp)
+        return {"used": used, "unused": unused}
+
+    def _load_module(self) -> Any:
+        """
+        Dynamically loads the file as a module and returns the module object.
+        Returns None if the loading fails.
+
+        Warning: This executes the file's top-level code.
+        """
+        try:
+            module_name = "_temp_module_" + str(abs(hash(self.file_path)))
+            spec = importlib.util.spec_from_file_location(module_name, self.file_path)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            return module
+        except Exception as e:
+            print(f"Error loading module from {self.file_path}: {e}")
+            return None
+
+    def get_dynamic_class_info(self) -> List[Any]:
+        """
+        Dynamically imports the file as a module and returns a list of ClassInfo objects,
+        one per class defined at module level.
+
+        Warning: This executes the file's top-level code.
+        """
+        if ClassInfo is None:
+            print("ClassInfo unavailable; skipping dynamic class analysis.")
+            return []
+        module = self._load_module()
+        if module is None:
+            return []
+        infos = []
+        for name, obj in inspect.getmembers(module, inspect.isclass):
+            if inspect.getmodule(obj) == module:
+                try:
+                    infos.append(ClassInfo(obj))
+                except Exception as e:
+                    print(f"Error processing class {name}: {e}")
+        return infos
+
+    def get_dynamic_function_info(self) -> List[Any]:
+        """
+        Dynamically imports the file as a module and returns a list of FunctionInfo objects,
+        one per function defined at module level.
+
+        Warning: This executes the file's top-level code.
+        """
+        if FunctionInfo is None:
+            print("FunctionInfo unavailable; skipping dynamic function analysis.")
+            return []
+        module = self._load_module()
+        if module is None:
+            return []
+        infos = []
+        for name, obj in inspect.getmembers(module, inspect.isfunction):
+            if inspect.getmodule(obj) == module:
+                try:
+                    infos.append(FunctionInfo(obj))
+                except Exception as e:
+                    print(f"Error processing function {name}: {e}")
+        return infos
+
+    def print_summary(self) -> None:
+        """Prints a detailed summary of all analyses of the file."""
+        print(f"===== Analysis of {self.file_path} =====")
+
+        print(f"\nToken Count: {self.token_count}")
+        print("\nToken Distribution (Top 10):")
+        for token, count in sorted(self.token_distribution.items(), key=lambda x: -x[1])[:10]:
+            print(f"  {repr(token)}: {count}")
+
+        print("\nComments Found:")
+        if self.comments:
+            for comment in self.comments:
+                print(" ", comment)
+        else:
+            print("  (None)")
+
+        print("\nClasses Defined:")
+        if self.class_names:
+            for cls in self.class_names:
+                print(" ", cls)
+        else:
+            print("  (None)")
+
+        print("\nFunctions Defined:")
+        if self.function_names:
+            for fn in self.function_names:
+                print(" ", fn)
+        else:
+            print("  (None)")
+
+        print("\nImports Found:")
+        for imp in self.imports:
+            print(f"  {imp.alias} from {imp.module} ({imp.kind})")
+
+        usage = self.import_usage
+        print("\nUsed Imports:")
+        for imp in usage["used"]:
+            print(f"  {imp.alias} from {imp.module} ({imp.kind})")
+
+        print("\nUnused Imports:")
+        if usage["unused"]:
+            for imp in usage["unused"]:
+                print(f"  {imp.alias} from {imp.module} ({imp.kind})")
+        else:
+            print("  (None)")
+
+        print("\nDetailed Class Info:")
+        dynamic_class_infos = self.get_dynamic_class_info()
+        if dynamic_class_infos:
+            for info in dynamic_class_infos:
+                print(info)
+        else:
+            print("  (None)")
+
+        print("\nDetailed Function Info:")
+        dynamic_function_infos = self.get_dynamic_function_info()
+        if dynamic_function_infos:
+            for info in dynamic_function_infos:
+                print(info)
+        else:
+            print("  (None)")
+        print("========================================")
+
+
+__all__ = [
+    "FileInfo"
+]

{danielutils-1.0.46/danielutils/reflection → danielutils-1.0.50/danielutils/reflection/info_classes}/function_info.py

@@ -8,7 +8,7 @@ from .argument_info import ArgumentInfo
 
 class FunctionInfo:
     FUNCTION_DEFINITION_REGEX: re.Pattern = re.compile(
-        r"(?P<decorators>[\s\S]+)?\s*def (?P<name>\w[\w\d]*)\s*\((?P<arguments>.+)?\)\s*(?:\s*\-\>\s*(?P<return_type>[\s\S]+?)\s*)?:(?P<body>[\s\S]+)",
+        r"(?P<decorators>(?:@[\s\S]+?)+?)?\s*(?P<async>async )?def (?P<name>\w[\w\d]*)\s*\((?P<arguments>[\s\S]+?)?\)\s*(?:\s*\-\>\s*(?P<return_type>[\s\S]+?)\s*)?:(?P<body>[\s\S]+)",
         re.MULTILINE)
 
     def __init__(self, func: Callable, owner: Type) -> None:
@@ -18,7 +18,7 @@ class FunctionInfo:
                 self._is_property = True
             else:
                 inspect.getsource(func)
-                self._is_property = False
+                self._is_property = False  # type: ignore
         except:
             raise TypeError(f"'{func.__name__}' is not a user defined function")
         self._func = func
@@ -34,10 +34,13 @@ class FunctionInfo:
         m = FunctionInfo.FUNCTION_DEFINITION_REGEX.match(code)
         if m is None:
             raise ValueError("Invalid function source code")
-        decorators, name, arguments, return_type, body = m.groups()
+        decorators, async_, name, arguments, return_type, body = m.groups()
         if decorators is not None:
             for substr in decorators.strip().splitlines():
                 self._decorators.append(DecorationInfo.from_str(substr.strip()))
+
+        self._is_async = async_ is not None
+
         self._name = name
         if arguments is not None:
             self._arguments = ArgumentInfo.from_str(arguments)
@@ -57,6 +60,10 @@ class FunctionInfo:
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(name=\"{self.name}\")"
 
+    @property
+    def is_async(self) -> bool:
+        return self._is_async
+
     @property
     def is_inherited(self) -> bool:
         return self._func in set(self._owner.__dict__.keys())

danielutils-1.0.50/danielutils/reflection/info_classes/import_info.py

@@ -0,0 +1,100 @@
+import ast
+from typing import List, Union
+
+
+class ImportInfo:
+    """
+    A class that encapsulates information about a single import statement element.
+
+    Depending on how the import appears in the source code, this may represent:
+      - a regular import (e.g., "import os" or "import os.path as osp"),
+      - a from-import (e.g., "from sys import version_info"), or
+      - a wildcard import (e.g., "from math import *").
+
+    The exposed properties are:
+      • alias: The accessible name in the file.
+      • module: The imported module or package.
+      • kind: A short string indicating the type. It will be one of:
+          "import", "from_import", or "from_import_all".
+    """
+
+    def __init__(self, alias: str, module: str, kind: str) -> None:
+        """
+        :param alias: The name used in the current file. For example, in
+                      "import os as myos", the alias is 'myos'; if no alias is given,
+                      a default is provided (e.g., the top-level module name).
+        :param module: The full module or package name (e.g., "os", or "os.path").
+        :param kind: A descriptor of the import kind: "import", "from_import", or "from_import_all".
+        """
+        self._alias = alias
+        self._module = module
+        self._kind = kind
+
+    @property
+    def alias(self) -> str:
+        """Returns the alias (or name) used for the import in the file."""
+        return self._alias
+
+    @property
+    def module(self) -> str:
+        """Returns the module or package name as imported."""
+        return self._module
+
+    @property
+    def kind(self) -> str:
+        """
+        Returns the type of import:
+          - "import" for a standard import statement,
+          - "from_import" for a 'from X import Y' statement,
+          - "from_import_all" for a wildcard import (e.g., 'from X import *').
+        """
+        return self._kind
+
+    def to_dict(self) -> dict:
+        """Returns a dictionary representation of the import information."""
+        return {"alias": self.alias, "module": self.module, "kind": self.kind}
+
+    def __str__(self) -> str:
+        return f"ImportInfo(alias={self.alias!r}, module={self.module!r}, kind={self.kind!r})"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    @classmethod
+    def from_ast(cls, node: Union[ast.Import, ast.ImportFrom]) -> List["ImportInfo"]:
+        """
+        Given an AST node of type ast.Import or ast.ImportFrom, returns a list
+        of ImportInfo instances representing each imported alias in that node.
+
+        For an ast.Import node:
+          • Each alias in node.names is processed.
+          • If an alias is not provided (using the as keyword), then the first
+            part of the module name (split by '.') is used as the alias.
+
+        For an ast.ImportFrom node:
+          • The module attribute (which can be None for relative imports) is used.
+          • Each alias is processed. If alias.name equals "*", the import is considered a wildcard.
+
+        :param node: An ast.Import or ast.ImportFrom node.
+        :return: A list of ImportInfo objects.
+        """
+        imports = []
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                # Use asname if available; otherwise use the top-level name.
+                local_alias = alias.asname if alias.asname else alias.name.split(".")[0]
+                imports.append(cls(local_alias, alias.name, "import"))
+        elif isinstance(node, ast.ImportFrom):
+            modname = node.module if node.module is not None else ""
+            for alias in node.names:
+                if alias.name == "*":
+                    imports.append(cls("*", modname, "from_import_all"))
+                else:
+                    local_alias = alias.asname if alias.asname else alias.name
+                    imports.append(cls(local_alias, modname, "from_import"))
+        return imports
+
+
+__all__ = [
+    "ImportInfo"
+]

{danielutils-1.0.46 → danielutils-1.0.50/danielutils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: danielutils
-Version: 1.0.46
+Version: 1.0.50
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -33,7 +33,6 @@ Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.8.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Dynamic: license-file
 
 [![Python package](https://github.com/danielnachumdev/danielutils/actions/workflows/python-package.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/python-package.yml)
 [![Pylint](https://github.com/danielnachumdev/danielutils/actions/workflows/pylint.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/pylint.yml)
@@ -41,7 +40,7 @@ Dynamic: license-file
 [![gitleaks](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml)
 [![CodeQL](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql)
 
-# danielutils v1.0.46
+# danielutils v1.0.50
 
 A comprehensive Python utilities library designed to enhance your development workflow with powerful tools for type safety, async programming, database operations, and much more.
 

{danielutils-1.0.46 → danielutils-1.0.50}/danielutils.egg-info/SOURCES.txt

@@ -168,16 +168,19 @@ danielutils/protocols/dictable.py
 danielutils/protocols/evaluable.py
 danielutils/protocols/serializable.py
 danielutils/reflection/__init__.py
-danielutils/reflection/argument_info.py
-danielutils/reflection/class_info.py
-danielutils/reflection/decoration_info.py
-danielutils/reflection/function_info.py
 danielutils/reflection/class_/__init__.py
 danielutils/reflection/class_/class_reflection.py
 danielutils/reflection/file/__init__.py
 danielutils/reflection/file/file_reflection.py
 danielutils/reflection/function/__init__.py
 danielutils/reflection/function/function_reflections.py
+danielutils/reflection/info_classes/__init__.py
+danielutils/reflection/info_classes/argument_info.py
+danielutils/reflection/info_classes/class_info.py
+danielutils/reflection/info_classes/decoration_info.py
+danielutils/reflection/info_classes/file_info.py
+danielutils/reflection/info_classes/function_info.py
+danielutils/reflection/info_classes/import_info.py
 danielutils/reflection/interpreter/__init__.py
 danielutils/reflection/interpreter/callstack.py
 danielutils/reflection/interpreter/get_traceback.py

{danielutils-1.0.46 → danielutils-1.0.50}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "danielutils"
-version = "1.0.46"
+version = "1.0.50"
 authors = [
     { name = "danielnachumdev", email = "danielnachumdev@gmail.com" },
 ]

danielutils-1.0.46/danielutils/reflection/__init__.py

@@ -1,53 +0,0 @@
-from .interpreter import *  # this has to be first, the order matters!
-from .file import *
-from .function import *
-from .class_ import *
-from .module import *
-from .argument_info import *
-from .decoration_info import *
-from .function_info import *
-from .class_info import *
-# def get_class(module_name: str, class_name: str) -> type:
-#     """dynammically loads the module and returns the class from this file
-
-#     Args:
-#         module_name (str): name of python module, (typically a file name without extention)
-#         class_name (str): the name of the wanted class
-
-#     Returns:
-#         type (type): The class
-#     """
-#     return dynamically_load(module_name, class_name)
-
-
-# def get_function(module_name: str, func_name: str) -> Callable:
-#     """dynammically loads the module and returns the function from this file
-
-#     Args:
-#         module_name (str): name of python module, (typically a file name without extention)
-#         func_name (str): the name of the wanted function
-
-#     Returns:
-#         Callable: the function
-#     """
-#     return dynamically_load(module_name, func_name)
-
-
-# def get_current_function() -> Callable:
-#     """return the function that is calling this file
-
-#     Returns:
-#         Callable: function
-#     """
-#     return get_caller()
-
-
-# def get_caller() -> Callable:
-#     """returns the caller of the function thats using this function
-
-#     Returns:
-#         Callable: caller
-#     """
-#     name = get_caller_name(1)
-#     module = get_caller_filename().removesuffix(".py")
-#     return get_function(module, name)