ormlambda 0.1.0__py3-none-any.whl

ormlambda/utils/module_tree/dynamic_module.py

@@ -0,0 +1,237 @@
+import sys
+from pathlib import Path
+from typing import Optional, Type
+from collections import defaultdict
+import importlib.util
+import inspect
+import re
+
+from ..table_constructor import Table
+from .dfs_traversal import DFSTraversal
+
+
+class Node:
+    pattern: str = r"from \.(\w+) import (\w+)"
+
+    def __init__(
+        self,
+        file: str | Path,
+        relative_path: str | Path,
+        class_name: str = None,
+        fks: list[str, str] = None,
+    ):
+        self._file: Path = self._set_paths(file)
+        self._relative_path: Path = self._set_paths(relative_path)
+        self._class_name: str = class_name
+        self._fks: list[str, str] = fks
+
+        self._relative_modules: list["Node"] = self.extract_modules()
+
+    def __repr__(self) -> str:
+        return f"Module: {self.module_name}, class: {self.class_name} ->({Node.__name__})"
+
+    def __eq__(self, __value: "Node") -> bool:
+        return hash(__value) == hash(self)
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.class_name,
+                self.code,
+            )
+        )
+
+    def _validate_paths(self, path: Path | str) -> bool:
+        if isinstance(path, str):
+            return Path(path).exists()
+        return path.exists()
+
+    def _set_paths(self, path: str | Path):
+        if not self._validate_paths(path):
+            raise OSError(path)
+        return Path(path).resolve()
+
+    def extract_modules(self) -> list["Node"]:
+        if self._fks:
+            rel_modules: list[tuple[str, str]] = self._fks
+        else:
+            rel_modules: list[tuple[str, str]] = re.findall(self.pattern, self.code) if self._file is not None else []
+
+        if not rel_modules:
+            return []
+        return [
+            Node(
+                file=self._relative_path.joinpath(module_).with_suffix(".py"),
+                relative_path=self._relative_path,
+                class_name=class_,
+            )
+            for module_, class_ in rel_modules
+        ]
+
+    @property
+    def code(self) -> str:
+        if not self._file:
+            return None
+        return self._file.read_text()
+
+    @property
+    def file(self) -> Path:
+        return self._file
+
+    @property
+    def class_name(self) -> str:
+        if not self._class_name:
+            pattern = re.compile(r"class\s(\w+)\(.*Table.*\):")
+
+            condition = pattern.search(self.code)
+            if condition:
+                self._class_name = condition.group(1)
+                return self.class_name
+            return None
+        return self._class_name
+
+    @property
+    def module_name(self) -> str:
+        return self._file.stem
+
+    @property
+    def relative_modules(self) -> list["Node"]:
+        return self._relative_modules
+
+    @relative_modules.setter
+    def relative_modules(self, value: list):
+        self._relative_modules = value
+
+    @property
+    def is_dependent(self) -> bool:
+        return len(self.relative_modules) > 0
+
+
+class ModuleTree:
+    def __init__(self, module_path: Path) -> None:
+        if isinstance(module_path, str):
+            module_path = Path(module_path)
+
+        self.module_path: Path = module_path
+        self.order_module_tuple: tuple[Node | str] = self.get_order_module_tuple_from_path()
+
+    def get_order_module_tuple_from_path(self) -> tuple[Node | str]:
+        if self.module_path.is_dir():
+            return self.order_modules_from_folder()
+        return self.order_modules_from_file()
+
+    def order_modules_from_folder(self) -> tuple[Node]:
+        """
+        Method whose main used is sorting all .py inside of folder to avoid import errors and overall for the creation of tables in SQL, comply with foreign key referenced table
+        This method's main purpose is to sort all .py inside a folder to avoid import errors and to ensure that tables referenced by foreign key in other tables are created first
+        """
+        order_list: list[Node] = []
+        unorder_module_list: list[Node] = []
+
+        for p in self.module_path.iterdir():
+            if not p.is_dir():
+                unorder_module_list.append(Node(file=p, relative_path=self.module_path))
+
+        self.sort_dicc(unorder_module_list, order_list)
+        return tuple(order_list)
+
+    @staticmethod
+    def sort_dicc(list_nodes: list[Node], new_list: list[Node]) -> None:
+        """
+        Iterated throughout list_nodes var and feed 'new_list' mutable var
+
+        Must create a mutable object such as list, to fill it with ordered items
+        """
+
+        def add_children(list_nodes: list[Node], new_list: list[Node], node: Node):
+            """
+            Recursive method called when try to sort all Nodes
+
+            ARGUMENT
+            -
+
+                - list_nodes: list[Node]
+                - new_list:list[Node]
+            """
+            all_children_added = all(x in new_list for x in node.relative_modules)
+
+            if node not in new_list and node._file is not None and ((node.is_dependent and all_children_added) or not node.is_dependent):
+                new_list.append(node)
+                return None
+
+            if node in new_list and not node.is_dependent:
+                return None
+
+            for child_node in node.relative_modules:
+                add_children(list_nodes, new_list, child_node)
+
+        for node in list_nodes:
+            add_children(list_nodes, new_list, node)
+
+            if node not in new_list and all([child_node in new_list for child_node in node.relative_modules]):
+                new_list.append(node)
+
+        return None
+
+    def order_modules_from_file(self) -> tuple[str]:
+        """
+        Method whose main used is sorting all .py inside of folder to avoid import errors and overall for the creation of tables in SQL, comply with foreign key referenced table
+        This method's main purpose is to sort all .py inside a folder to avoid import errors and to ensure that tables referenced by foreign key in other tables are created first
+        """
+        tables: list[tuple[str, Table]] = self.get_member_table(self.load_module("", self.module_path))
+
+        graph: dict[Type[Table], list[Type[Table]]] = defaultdict(list)
+        for _, tbl in tables:
+            graph[tbl] = tbl.find_dependent_tables()
+
+        sorted_tables = DFSTraversal.sort(graph)
+        res = [x.create_table_query() for x in sorted_tables]
+        return res
+
+    @staticmethod
+    def find_module(module_name: str, nodes: list["Node"]) -> Optional["Node"]:
+        for node in nodes:
+            if module_name == node.class_name:
+                return node
+        return None
+
+    @staticmethod
+    def load_module(module_name: str, module_path: Path):
+        """
+        Method whose main purpose is the dynamic addtion of modules using the importlib module.
+        Both the module name and its path must be specified.
+
+        !important: we need to add the dynamic modules to sys.modules for the loading to be successful
+        """
+        spec = importlib.util.spec_from_file_location(module_name, module_path)
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[spec.name] = module
+        spec.loader.exec_module(module)
+        return module
+
+    def get_queries(self) -> tuple[str, ...]:
+        table_list: list[Table] = []
+        if isinstance(self.order_module_tuple[0], str):
+            return self.order_module_tuple
+
+        for node in self.order_module_tuple:
+            if node.class_name is None:
+                continue
+            # avoid __init__ because we can get relative import not found error
+            if node.file.is_dir() or node.class_name == "__init__":
+                continue
+
+            # loop over order modules tuple to load it into sys.modules
+            # COMMENT!: Checked why changing 'class_name' by 'module_name' the method works
+            submodule = self.load_module(f"{self.module_path.stem}.{node.module_name}", node.file)
+            table_class = self.get_member_table(submodule)
+
+            # we need to ensure that the object we going to add in table_list is the same
+            for name, obj in table_class:
+                if name == node.class_name:
+                    table_list.append(obj.create_table_query())
+        return tuple(table_list)
+
+    @staticmethod
+    def get_member_table(module) -> list[tuple[str, Type[Table]]]:
+        return inspect.getmembers(module, lambda x: inspect.isclass(x) and issubclass(x, Table) and x is not Table)

ormlambda/utils/table_constructor.py

@@ -0,0 +1,308 @@
+import base64
+from collections import defaultdict
+import datetime
+from decimal import Decimal
+from typing import Any, Iterable, Optional, Type, dataclass_transform
+import json
+
+from .dtypes import get_query_clausule
+from .module_tree.dfs_traversal import DFSTraversal
+from .column import Column
+
+from .foreign_key import ForeignKey
+
+MISSING = Column()
+
+
+class Field:
+    def __init__(self, name: str, type_: type, default: object) -> None:
+        self.name: str = name
+        self.type_: type = type_
+        self.default: Column = default
+
+    def __repr__(self) -> str:
+        return f"{Field.__name__}(name = {self.name}, type_ = {self.type_}, default = {self.default})"
+
+    @property
+    def has_default(self) -> bool:
+        return self.default is not MISSING
+
+    @property
+    def init_arg(self) -> str:
+        # default = f"={self.default_name if self.has_default else None}"
+        default = f"={None}"
+
+        return f"{self.name}: {self.type_name}{default}"
+
+    @property
+    def default_name(self) -> str:
+        return f"_dflt_{self.name}"
+
+    @property
+    def type_name(self) -> str:
+        return f"_type_{self.name}"
+
+    @property
+    def assginment(self) -> str:
+        return f"self._{self.name} = {self.default.__to_string__(self.name,self.name,self.type_name)}"
+
+
+def delete_special_variables(dicc: dict[str, object]) -> None:
+    keys = tuple(dicc.keys())
+    for key in keys:
+        if key.startswith("__"):
+            del dicc[key]
+
+
+def get_fields[T](cls: Type[T]) -> Iterable[Field]:
+    annotations = getattr(cls, "__annotations__", {})
+
+    # delete_special_variables(annotations)
+    fields = []
+    for name, type_ in annotations.items():
+        # type_ must by Column object
+        field_type = type_
+        if hasattr(type_, "__origin__") and type_.__origin__ is Column:  # __origin__ to get type of Generic value
+            field_type = type_.__args__[0]
+        default: Column = getattr(cls, name, MISSING)
+        fields.append(Field(name, field_type, default))
+
+        # Update __annotations__ to create Columns
+        cls.__annotations__[name] = Column[field_type]
+    return fields
+
+
+@dataclass_transform()
+def __init_constructor__[T](cls: Type[T]) -> Type[T]:
+    # create '__properties_mapped__' dictionary for each Table to avoid shared information
+    # TODOL: I don't know if it's better to create a global dictionary like in commit '7de69443d7a8e7264b8d5d604c95da0e5d7e9cc0'
+    setattr(cls, "__properties_mapped__", {})
+    fields = get_fields(cls)
+    locals_ = {}
+    init_args = []
+
+    for field in fields:
+        if not field.name.startswith("__"):
+            locals_[field.type_name] = field.type_
+
+            init_args.append(field.init_arg)
+            locals_[field.default_name] = None  # field.default.column_value
+            __create_properties(cls, field)
+
+    wrapper_fn = "\n".join(
+        [
+            f"def wrapper({', '.join(locals_.keys())}):",
+            f" def __init__(self, {', '.join(init_args)}):",
+            "\n".join([f"  {f.assginment}" for f in fields]) or "  pass",
+            " return __init__",
+        ]
+    )
+
+    namespace = {}
+
+    exec(wrapper_fn, None, namespace)
+    init_fn = namespace["wrapper"](**locals_)
+
+    setattr(cls, "__init__", init_fn)
+    return cls
+
+
+def __create_properties(cls: Type["Table"], field: Field) -> property:
+    _name: str = f"_{field.name}"
+    type_ = field.type_
+    # we need to get Table attributes (Column class) and then called __getattribute__ or __setattr__ to make changes inside of Column
+    prop = property(
+        fget=lambda self: __transform_getter(getattr(self, _name), type_),
+        fset=lambda self, value: __transform_setter(getattr(self, _name), value, type_),
+    )
+
+    # set property in public name
+    setattr(cls, field.name, prop)
+    cls.__properties_mapped__[prop] = field.name
+    return None
+
+
+def __transform_getter[T](obj: object, type_: T) -> T:
+    return obj.__getattribute__("column_value")
+
+    # if type_ is str and isinstance(eval(obj), Iterable):
+    #     getter = eval(obj)
+    # return getter
+
+
+def __transform_setter[T](obj: object, value: Any, type_: T) -> None:
+    return obj.__setattr__("column_value", value)
+
+    # if type_ is list:
+    #     setter = str(setter)
+    # return None
+
+
+class TableMeta(type):
+    def __new__[T](cls: "Table", name: str, bases: tuple, dct: dict[str, Any]) -> Type[T]:
+        """
+        That's the class we use to recreate the table's metadata.
+        It's useful because we can dynamically create the __init__ method just by using the type hints of the variables we want to use as column names.
+        We simply call '__init_constructor__' to create all the necessary variables and the method.
+        """
+        cls_object: Table = super().__new__(cls, name, bases, dct)
+
+        if name == "Table":
+            return cls_object
+
+        if cls_object.__table_name__ is Ellipsis:
+            raise Exception(f"class variable '__table_name__' must be declared in '{cls_object.__name__}' class")
+
+        if not isinstance(cls_object.__table_name__, str):
+            raise Exception(f"class variable '__table_name__' of '{cls_object.__name__}' class must be 'str'")
+
+        TableMeta.__add_fk_if_exists__(cls_object)
+        self = __init_constructor__(cls_object)
+        return self
+
+    def __repr__(cls: "Table") -> str:
+        return f"{TableMeta.__name__}: {cls.__table_name__}"
+
+    @staticmethod
+    def __add_fk_if_exists__(cls: "Table") -> None:
+        """
+        When creating a Table class, we cannot pass the class itself as a parameter in a function that initializes a class variable.
+        To fix this, we first add the table name and then, when instantiating the object, we replace the table name with the class itself.
+        """
+        if data := ForeignKey.MAPPED.get(cls.__table_name__):
+            ForeignKey.MAPPED[cls] = data
+            del ForeignKey.MAPPED[cls.__table_name__]
+        return None
+
+
+@dataclass_transform(eq_default=False)
+class Table(metaclass=TableMeta):
+    """
+    Class to mapped database tables with Python classes.
+
+    It uses __annotations__ special var to store all table columns. If you do not type class var it means this var is not store as table column
+    and it do not going to appear when you instantiate the object itself.
+
+    This principle it so powerful due to we can create Foreign Key references without break __init__ class method.
+
+    >>> class Address(Table):
+    >>>     __table_name__ = "address"
+
+    >>>     address_id: int = Column[int](is_primary_key=True)
+    >>>     address: str
+    >>>     address2: str
+    >>>     district: str
+    >>>     city_id: int
+    >>>     postal_code: datetime
+    >>>     phone: str
+    >>>     location: datetime
+    >>>     last_update: datetime = Column[datetime](is_auto_generated=True)
+
+    >>>     city = ForeignKey["Address", City](__table_name__, City, lambda a, c: a.city_id == c.city_id)
+    """
+
+    __table_name__: str = ...
+    __properties_mapped__: dict[property, str] = ...
+
+    def __str__(self) -> str:
+        params = self.to_dict()
+        return json.dumps(params, ensure_ascii=False, indent=2)
+
+    def __getattr__[T](self, __name: str) -> Column[T]:
+        return self.__dict__.get(__name, None)
+
+    def __repr__(self: "Table") -> str:
+        def __cast_long_variables(value: Any):
+            if not isinstance(value, str):
+                value = str(value)
+            if len(value) > 20:
+                return value[:20] + "..."
+            return value
+
+        dicc: dict[str, str] = {x: str(getattr(self, x)) for x in self.__annotations__}
+        equal_loop = ["=".join((x, __cast_long_variables(y))) for x, y in dicc.items()]
+        return f'{self.__class__.__name__}({", ".join(equal_loop)})'
+
+    def to_dict(self) -> dict[str, str | int]:
+        dicc: dict[str, Any] = {}
+        for x in self.__annotations__:
+            transform_data = self.__transform_data__(getattr(self, x))
+            dicc[x] = transform_data
+        return dicc
+
+    @staticmethod
+    def __transform_data__[T](_value: T) -> T:
+        def byte_to_string(value: bytes):
+            return base64.b64encode(value).decode("utf-8")
+
+        transform_map: dict = {
+            datetime.datetime: datetime.datetime.isoformat,
+            datetime.date: datetime.date.isoformat,
+            Decimal: str,
+            bytes: byte_to_string,
+            set: list,
+        }
+
+        if (dtype := type(_value)) in transform_map:
+            return transform_map[dtype](_value)
+        return _value
+
+    def get_pk(self) -> Optional[Column]:
+        for col_name in self.__annotations__.keys():
+            private_col = f"_{col_name}"
+            col_obj = getattr(self, private_col)
+            if isinstance(col_obj, Column) and col_obj.is_primary_key:
+                return col_obj
+        return None
+
+    @classmethod
+    def get_columns(cls) -> tuple[str, ...]:
+        return tuple(cls.__annotations__.keys())
+
+    @classmethod
+    def create_table_query(cls) -> str:
+        """It's classmethod because of it does not matter the columns values to create the table"""
+        all_clauses: list[str] = []
+
+        all_clauses.extend(cls._create_sql_column_query())
+        all_clauses.extend(ForeignKey.create_query(cls))
+
+        return f"CREATE TABLE {cls.__table_name__} ({', '.join(all_clauses)});"
+
+    @classmethod
+    def _create_sql_column_query(cls) -> list[str]:
+        """
+        It's imperative to instantiate cls() to initialize the 'Table' object and create private variables that will be Column objects.
+        Otherwise, we only can access to property method
+        """
+        table_init_ = cls()
+        annotations: dict[str, Column] = table_init_.__annotations__
+        all_columns: list = []
+        for col_name in annotations.keys():
+            col_object: Column = getattr(table_init_, f"_{col_name}")
+            all_columns.append(get_query_clausule(col_object))
+        return all_columns
+
+    @classmethod
+    def find_dependent_tables(cls) -> tuple["Table", ...]:
+        def get_involved_tables(graph: dict[Table, list[Table]], table: Table) -> None:
+            for tbl in ForeignKey[Table, Table].MAPPED[table].keys():
+                if ForeignKey.MAPPED[tbl]:
+                    get_involved_tables(graph, tbl)
+                graph[tbl] = list(ForeignKey.MAPPED[tbl].keys())
+                return None
+
+        graph: dict[Table, list[Table]] = defaultdict(list)
+        graph[cls] = list(ForeignKey.MAPPED[cls].keys())
+        get_involved_tables(graph, cls)
+
+        dfs = DFSTraversal.sort(graph)
+        return dfs[: dfs.index(cls)]
+
+    def __hash__(self) -> int:
+        return hash(self.to_dict().values())
+
+    def __eq__(self, __value: Any) -> bool:
+        if isinstance(__value, Table):
+            return hash(self) == hash(__value)
+        return False

ormlambda-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Pablo Hernández Zamora
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.