ormlambda 1.0.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

ormlambda/databases/my_sql/clauses/upsert.py

@@ -1,8 +1,8 @@
 from typing import override, Any
 
-from ....utils import Table
-from ....components.upsert import UpsertQueryBase
-from ....common.interfaces import IRepositoryBase
+from ormlambda import Table
+from ormlambda.components.upsert import UpsertQueryBase
+from ormlambda import IRepositoryBase
 from mysql.connector import MySQLConnection
 
 from .insert import InsertQuery

ormlambda/databases/my_sql/clauses/where_condition.py

@@ -1,11 +1,11 @@
 from typing import Any, Callable, Optional, override
 import inspect
 
-from ....common.enums import ConditionType
-from ....utils.lambda_disassembler.tree_instruction import TreeInstruction, TupleInstruction
-from ....common.interfaces.IQueryCommand import IQuery
-from ....components.where.abstract_where import AbstractWhere
-from ....utils import Table
+from ormlambda.common.enums import ConditionType
+from ormlambda.utils.lambda_disassembler.tree_instruction import TreeInstruction, TupleInstruction
+from ormlambda.common.interfaces.IQueryCommand import IQuery
+from ormlambda.components.where.abstract_where import AbstractWhere
+from ormlambda import Table
 
 
 class WhereConditionByArg[TProp1, TProp2](IQuery):

ormlambda/databases/my_sql/repository.py

@@ -1,14 +1,14 @@
 # Standard libraries
 from pathlib import Path
-from typing import Any, Type, override
+from typing import Any, Optional, Type, override
 
 
 # from mysql.connector.pooling import MySQLConnectionPool
 from mysql.connector import MySQLConnection, Error  # noqa: F401
 
 # Custom libraries
-from ...common.interfaces import IRepositoryBase
-from ...utils.module_tree.dynamic_module import ModuleTree
+from ormlambda import IRepositoryBase
+from ormlambda.utils.module_tree.dynamic_module import ModuleTree
 
 from .clauses import CreateDatabase, TypeExists
 from .clauses import DropDatabase
@@ -51,10 +51,24 @@ class Response[TFlavour, *Ts]:
         def _tuple() -> list[tuple[*Ts]]:
             return data
 
+        def _set() -> list[set]:
+            for d in data:
+                n = len(d)
+                for i in range(n):
+                    try:
+                        hash(d[i])
+                    except TypeError:
+                        raise TypeError(f"unhashable type '{type(d[i])}' found in '{type(d)}' when attempting to cast the result into a '{set.__name__}' object")
+            return [set(x) for x in data]
+
         def _default() -> list[TFlavour]:
             return [self._flavour(x, **self._kwargs) for x in data]
 
-        selector: dict[Type[object], Any] = {dict: _dict, tuple: _tuple}
+        selector: dict[Type[object], Any] = {
+            dict: _dict,
+            tuple: _tuple,
+            set: _set,
+        }
 
         return selector.get(self._flavour, _default)()
 
@@ -190,3 +204,11 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
     @override
     def set_config(self, value: dict[str, Any]) -> dict[str, Any]:
         return self._data_config.update(value)
+
+    @property
+    def database(self) -> Optional[str]:
+        return self._data_config.get("database", None)
+
+    @database.setter
+    def database(self, value: str) -> None:
+        self._data_config["database"] = value

ormlambda/databases/my_sql/statements.py

@@ -1,10 +1,13 @@
-from typing import override, Type
+from __future__ import annotations
+from typing import override, Type, TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from ormlambda import Table
+    from ormlambda.components.select import ISelect
 
-from ...common.abstract_classes import AbstractSQLStatements
-from ...utils import Table
-from ...common.interfaces import IQuery, IRepositoryBase
-from ...components.select import ISelect
+from ormlambda.common.abstract_classes import AbstractSQLStatements
+
+from ormlambda.common.interfaces import IQuery, IRepositoryBase
 
 from .clauses import DeleteQuery
 from .clauses import InsertQuery
@@ -16,6 +19,7 @@ from .clauses import SelectQuery
 from .clauses import UpsertQuery
 from .clauses import UpdateQuery
 from .clauses import WhereCondition
+from .clauses import CountQuery
 
 from mysql.connector import MySQLConnection
 
@@ -60,6 +64,11 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
     def OFFSET_QUERY(self) -> Type[IQuery]:
         return OffsetQuery
 
+    @property
+    @override
+    def COUNT(self) -> int:
+        return CountQuery
+
     @property
     @override
     def JOIN_QUERY(self) -> Type[IQuery]:

ormlambda/model_base.py

@@ -1,4 +1,3 @@
-# region imports
 from typing import Type
 
 
@@ -8,7 +7,6 @@ from .common.abstract_classes import AbstractSQLStatements
 from .databases.my_sql import MySQLStatements, MySQLRepository
 
 
-
 # endregion
 
 

ormlambda/utils/column.py

@@ -1,5 +1,6 @@
 from typing import Type
 
+
 class Column[T]:
     __slots__ = (
         "dtype",
@@ -13,7 +14,7 @@ class Column[T]:
 
     def __init__(
         self,
-        dtype:Type[T] = None,
+        dtype: Type[T] = None,
         column_name: str = None,
         column_value: T = None,
         *,
@@ -35,9 +36,9 @@ class Column[T]:
 
     def __to_string__(self, name: str, var_name: T, type_: str):
         dicc: dict = {
-            "dtype":type_,
+            "dtype": type_,
             "column_name": f"'{name}'",
-            "column_value": var_name, # must be the same variable name as the instance variable name in Table's __init__ class
+            "column_value": var_name,  # must be the same variable name as the instance variable name in Table's __init__ class
         }
         exec_str: str = f"{Column.__name__}[{type_}]("
         for x in self.__slots__:

ormlambda/utils/dtypes.py

@@ -49,7 +49,7 @@ MySQL 8.0 does not support year in two-digit format.
 
 from decimal import Decimal
 import datetime
-from typing import Any,Literal
+from typing import Any, Literal
 import numpy as np
 
 from .column import Column
@@ -61,10 +61,6 @@ NUMERIC_UNSIGNED = Literal["BIT(size)", "TINYINT(size)", "BOOL", "BOOLEAN", "SMA
 DATE = Literal["DATE", "DATETIME(fsp)", "TIMESTAMP(fsp)", "TIME(fsp)", "YEAR"]
 
 
-
-
-
-
 # FIXME [ ]: this method does not comply with the implemented interface; we need to adjust it in the future to scale it to other databases
 @staticmethod
 def transform_py_dtype_into_query_dtype(dtype: Any) -> str:
@@ -77,15 +73,17 @@ def transform_py_dtype_into_query_dtype(dtype: Any) -> str:
         datetime.datetime: "DATETIME",
         datetime.date: "DATE",
         bytes: "BLOB",
+        bytearray: "BLOB",
         str: "VARCHAR(255)",
-        np.uint64: "BIGINT UNSIGNED"
+        np.uint64: "BIGINT UNSIGNED",
     }
 
+    res = dicc.get(dtype, None)
+    if res is None:
+        raise ValueError(f"datatype '{dtype}' is not expected.")
     return dicc[dtype]
 
 
-
-
 # FIXME [ ]: this method does not comply with the implemented interface; we need to adjust it in the future to scale it to other databases
 def get_query_clausule(column_obj: Column) -> str:
     dtype: str = transform_py_dtype_into_query_dtype(column_obj.dtype)

ormlambda/utils/foreign_key.py

@@ -1,13 +1,51 @@
-from collections import defaultdict
-from typing import Callable, TYPE_CHECKING, Type
+from __future__ import annotations
+from typing import Callable, TYPE_CHECKING, NamedTuple, Type, Optional, overload
 from .lambda_disassembler import Disassembler
 
 if TYPE_CHECKING:
     from .table_constructor import Table
 
 
-class ForeignKey[Tbl1:Table, Tbl2:Table]:
-    MAPPED: dict[Tbl1, dict[Tbl2, Callable[[Tbl1, Tbl2], bool]]] = defaultdict(dict)
+class ReferencedTable[T1: Type[Table], T2: Type[Table]](NamedTuple):
+    obj: T2
+    relationship: Callable[[T1, T2], bool]
+
+
+class TableInfo[T1: Type[Table], T2: Type[Table]]:
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, table_object: T1) -> None: ...
+
+    def __init__(self, table_object: Optional[T1] = None) -> None:
+        self._table_object: Optional[T1] = table_object
+        self._referenced_tables: dict[str, ReferencedTable[T1, T2]] = {}
+
+    def __repr__(self) -> str:
+        return f"<{TableInfo.__name__}> class '{self.table_object}' dependent tables -> [{', '.join(tuple(self.referenced_tables))}]"
+
+    @property
+    def referenced_tables(self) -> dict[str, ReferencedTable[T1, T2]]:
+        return self._referenced_tables
+
+    def update_referenced_tables(self, referenced_table: Type[Table], relationship: Callable[[T1, T2], bool]) -> None:
+        self._referenced_tables.update({referenced_table.__table_name__: ReferencedTable[T1, T2](referenced_table, relationship)})
+
+    @property
+    def table_object(self) -> Optional[Type[Table]]:
+        return self._table_object
+
+    @table_object.setter
+    def table_object(self, value: Type[Table]) -> None:
+        self._table_object = value
+
+    @property
+    def has_relationship(self) -> bool:
+        return len(self._referenced_tables) > 0
+
+
+class ForeignKey[Tbl1: Type[Table], Tbl2: Type[Table]]:
+    MAPPED: dict[str, TableInfo[Tbl1, Tbl2]] = {}
 
     def __new__(
         cls,
@@ -20,17 +58,24 @@ class ForeignKey[Tbl1:Table, Tbl2:Table]:
         return referenced_table
 
     @classmethod
-    def add_foreign_key(cls, orig_table: str, referenced_table: "Table", relationship: Callable[[Tbl1, Tbl2], bool]) -> None:
-        cls.MAPPED[orig_table][referenced_table] = relationship
+    def add_foreign_key(cls, orig_table: str, referenced_table: Table, relationship: Callable[[Tbl1, Tbl2], bool]) -> None:
+        if orig_table not in cls.MAPPED:
+            cls.MAPPED[orig_table] = TableInfo()
+
+        # if referenced_table not in cls.MAPPED[orig_table]:
+        cls.MAPPED[orig_table].update_referenced_tables(referenced_table, relationship)
+
         return None
 
     @classmethod
-    def create_query(cls, orig_table: "Table") -> list[str]:
+    def create_query(cls, orig_table: Table) -> list[str]:
         clauses: list[str] = []
-        for referenced_table, _lambda in ForeignKey[Tbl1, Tbl2].MAPPED[orig_table].items():
-            dissambler: Disassembler = Disassembler(_lambda)
+
+        fk: TableInfo[Tbl1, Tbl2] = ForeignKey[Tbl1, Tbl2].MAPPED[orig_table.__table_name__]
+        for referenced_table_obj in fk.referenced_tables.values():
+            dissambler: Disassembler = Disassembler(referenced_table_obj.relationship)
             orig_col: str = dissambler.cond_1.name
             referenced_col: str = dissambler.cond_2.name
 
-            clauses.append(f"FOREIGN KEY ({orig_col}) REFERENCES {referenced_table.__table_name__}({referenced_col})")
+            clauses.append(f"FOREIGN KEY ({orig_col}) REFERENCES {referenced_table_obj.obj.__table_name__}({referenced_col})")
         return clauses

ormlambda/utils/lambda_disassembler/__init__.py

@@ -1,4 +1,4 @@
 from .disassembler import Disassembler  # noqa: F401
 from .nested_element import NestedElement  # noqa: F401
 from .tree_instruction import TreeInstruction, TupleInstruction  # noqa: F401
-from .name_of import nameof  # noqa: F401
+from .name_of import nameof  # noqa: F401

ormlambda/utils/lambda_disassembler/dis_types.py

@@ -1,9 +1,6 @@
 from enum import Enum
 
 
-
-
-
 class OpName(Enum):
     CACHE = "CACHE"
     POP_TOP = "POP_TOP"
@@ -112,25 +109,25 @@ class OpName(Enum):
     INSTRUMENTED_END_SEND = "INSTRUMENTED_END_SEND"
     INSTRUMENTED_INSTRUCTION = "INSTRUMENTED_INSTRUCTION"
     INSTRUMENTED_LINE = "INSTRUMENTED_LINE"
-    FOR_ITER= 'FOR_ITER'
-    JUMP_FORWARD= 'JUMP_FORWARD'
-    POP_JUMP_IF_FALSE= 'POP_JUMP_IF_FALSE'
-    POP_JUMP_IF_TRUE= 'POP_JUMP_IF_TRUE'
-    SEND= 'SEND'
-    POP_JUMP_IF_NOT_NONE= 'POP_JUMP_IF_NOT_NONE'
-    POP_JUMP_IF_NONE= 'POP_JUMP_IF_NONE'
-    JUMP_BACKWARD_NO_INTERRUPT= 'JUMP_BACKWARD_NO_INTERRUPT'
-    JUMP_BACKWARD= 'JUMP_BACKWARD'
-    STORE_NAME= 'STORE_NAME'
-    DELETE_NAME= 'DELETE_NAME'
-    STORE_ATTR= 'STORE_ATTR'
-    DELETE_ATTR= 'DELETE_ATTR'
-    STORE_GLOBAL= 'STORE_GLOBAL'
-    DELETE_GLOBAL= 'DELETE_GLOBAL'
-    LOAD_NAME= 'LOAD_NAME'
-    LOAD_ATTR= 'LOAD_ATTR'
-    IMPORT_NAME= 'IMPORT_NAME'
-    IMPORT_FROM= 'IMPORT_FROM'
-    LOAD_GLOBAL= 'LOAD_GLOBAL'
-    LOAD_SUPER_ATTR= 'LOAD_SUPER_ATTR'
-    LOAD_FROM_DICT_OR_GLOBALS= 'LOAD_FROM_DICT_OR_GLOBALS'
+    FOR_ITER = "FOR_ITER"
+    JUMP_FORWARD = "JUMP_FORWARD"
+    POP_JUMP_IF_FALSE = "POP_JUMP_IF_FALSE"
+    POP_JUMP_IF_TRUE = "POP_JUMP_IF_TRUE"
+    SEND = "SEND"
+    POP_JUMP_IF_NOT_NONE = "POP_JUMP_IF_NOT_NONE"
+    POP_JUMP_IF_NONE = "POP_JUMP_IF_NONE"
+    JUMP_BACKWARD_NO_INTERRUPT = "JUMP_BACKWARD_NO_INTERRUPT"
+    JUMP_BACKWARD = "JUMP_BACKWARD"
+    STORE_NAME = "STORE_NAME"
+    DELETE_NAME = "DELETE_NAME"
+    STORE_ATTR = "STORE_ATTR"
+    DELETE_ATTR = "DELETE_ATTR"
+    STORE_GLOBAL = "STORE_GLOBAL"
+    DELETE_GLOBAL = "DELETE_GLOBAL"
+    LOAD_NAME = "LOAD_NAME"
+    LOAD_ATTR = "LOAD_ATTR"
+    IMPORT_NAME = "IMPORT_NAME"
+    IMPORT_FROM = "IMPORT_FROM"
+    LOAD_GLOBAL = "LOAD_GLOBAL"
+    LOAD_SUPER_ATTR = "LOAD_SUPER_ATTR"
+    LOAD_FROM_DICT_OR_GLOBALS = "LOAD_FROM_DICT_OR_GLOBALS"

ormlambda/utils/lambda_disassembler/tree_instruction.py

@@ -1,7 +1,7 @@
 from collections import defaultdict
 from typing import Any, Callable, NamedTuple, Self, Optional
 from dis import Instruction, Bytecode
-from ...common.enums.condition_types import ConditionType
+from ormlambda.common.enums.condition_types import ConditionType
 from .dis_types import OpName
 from .nested_element import NestedElement
 

ormlambda/utils/module_tree/dynamic_module.py

@@ -6,7 +6,9 @@ import importlib.util
 import inspect
 import re
 
-from ..table_constructor import Table
+from ormlambda import ForeignKey
+
+from ormlambda import Table
 from .dfs_traversal import DFSTraversal
 
 
@@ -180,12 +182,12 @@ class ModuleTree:
         """
         tables: list[tuple[str, Table]] = self.get_member_table(self.load_module("", self.module_path))
 
-        graph: dict[Type[Table], list[Type[Table]]] = defaultdict(list)
+        graph: dict[str, list[str]] = defaultdict(list)
         for _, tbl in tables:
-            graph[tbl] = tbl.find_dependent_tables()
+            graph[tbl.__table_name__] = [x.__table_name__ for x in tbl.find_dependent_tables()]
 
         sorted_tables = DFSTraversal.sort(graph)
-        res = [x.create_table_query() for x in sorted_tables]
+        res = [ForeignKey.MAPPED[x].table_object.create_table_query() for x in sorted_tables]
         return res
 
     @staticmethod

ormlambda/utils/table_constructor.py

@@ -1,5 +1,4 @@
 import base64
-from collections import defaultdict
 import datetime
 from decimal import Decimal
 from typing import Any, Iterable, Optional, Type, dataclass_transform
@@ -9,7 +8,7 @@ from .dtypes import get_query_clausule
 from .module_tree.dfs_traversal import DFSTraversal
 from .column import Column
 
-from .foreign_key import ForeignKey
+from .foreign_key import ForeignKey, TableInfo
 
 MISSING = Column()
 
@@ -156,7 +155,7 @@ class TableMeta(type):
         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)
+        TableMeta.__add_to_ForeignKey(cls_object)
         self = __init_constructor__(cls_object)
         return self
 
@@ -164,14 +163,17 @@ class TableMeta(type):
         return f"{TableMeta.__name__}: {cls.__table_name__}"
 
     @staticmethod
-    def __add_fk_if_exists__(cls: "Table") -> None:
+    def __add_to_ForeignKey(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.
+        To fix this, we first add the table name as key and then, we add the class itself in the TableInfo class.
         """
-        if data := ForeignKey.MAPPED.get(cls.__table_name__):
-            ForeignKey.MAPPED[cls] = data
-            del ForeignKey.MAPPED[cls.__table_name__]
+        if table_info := ForeignKey.MAPPED.get(cls.__table_name__, None):
+            table_info.table_object = cls
+        else:
+            ForeignKey.MAPPED[cls.__table_name__] = TableInfo()
+            ForeignKey.MAPPED[cls.__table_name__].table_object = cls
+
         return None
 
 
@@ -285,24 +287,39 @@ class Table(metaclass=TableMeta):
 
     @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)
+        # TODOL: Dive into new way to return dependent tables
+        def get_involved_tables(graph: dict[Table, list[Table]], table_name: str) -> None:
+            """
+            Create a graph to be ordered
+            """
+            table = ForeignKey[Table, Table].MAPPED[table_name]
+            for x in table.referenced_tables:
+                if data := ForeignKey.MAPPED.get(x, None):
+                    get_involved_tables(graph, data.table_object.__table_name__)
+
+            graph[table.table_object.__table_name__] = list(table.referenced_tables)
+            return None
+
+        graph: dict[Table, list[Table]] = {}
+        dependent = ForeignKey.MAPPED.get(cls.__table_name__, None)
+        if dependent is None:
+            return tuple([])
+
+        graph[cls.__table_name__] = list(dependent.referenced_tables)
+        get_involved_tables(graph, cls.__table_name__)
 
         dfs = DFSTraversal.sort(graph)
-        return dfs[: dfs.index(cls)]
 
-    def __hash__(self) -> int:
-        return hash(self.to_dict().values())
+        order_table = dfs[: dfs.index(cls.__table_name__)]
+
+        return [ForeignKey.MAPPED[x].table_object for x in order_table]
 
     def __eq__(self, __value: Any) -> bool:
         if isinstance(__value, Table):
-            return hash(self) == hash(__value)
+            return all(
+                (
+                    self.__table_name__ == __value.__table_name__,
+                    tuple(self.to_dict().items()),
+                )
+            )
         return False

{ormlambda-1.0.1.dist-info → ormlambda-1.2.0.dist-info}/METADATA

@@ -1,16 +1,20 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 1.0.1
+Version: 1.2.0
 Summary: ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions
 Author: p-hzamora
 Author-email: p.hzamora@icloud.com
 Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: mysql-connector (>=2.2.9,<3.0.0)
-Requires-Dist: ruff (>=0.4.5,<0.5.0)
+Requires-Dist: fluent-validation (>=3.1.0,<4.0.0)
+Requires-Dist: mysql-connector-python (>=2.2.9,<3.0.0)
 Description-Content-Type: text/markdown
 
+![PyPI version](https://img.shields.io/pypi/v/ormlambda.svg)
+![downloads](https://img.shields.io/pypi/dm/ormlambda?label=downloads)
+![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)
+
 # ormMySQL
 This ORM is designed to connect with a MySQL server, facilitating the management of various database queries. Built with flexibility and efficiency in mind, this ORM empowers developers to interact with the database using lambda functions, allowing for concise and expressive query construction. 
 
@@ -19,7 +23,7 @@ This ORM is designed to connect with a MySQL server, facilitating the management
 ## Initialize MySQLRepository
 ```python
 from decouple import config
-from src.ormmysql.databases.my_sql import MySQLRepository
+from ormlambda.databases.my_sql import MySQLRepository
 
 USERNAME = config("USERNAME")
 PASSWORD = config("PASSWORD")
@@ -31,7 +35,7 @@ database = MySQLRepository(user=USERNAME, password=PASSWORD, database="sakila",
 
 ## Select all columns
 ```python
-from src.test.models.address import AddressModel
+from models.address import AddressModel
 
 result = AddressModel(database).select()
 ```
@@ -41,8 +45,8 @@ The `result` var will be of type `tuple[Address, ...]`
 Once the `AddressModel` class is created, we will not only be able to access all the information in that table, but also all the information in all the tables that have foreign keys related to it."
 
 ```python
-from src.ormmysql.common.enums import ConditionType
-from src.test.models.address import AddressModel
+from ormlambda import ConditionType
+from models.address import AddressModel
 
 
 result = AddressModel(database).where(lambda x: (x.City.Country, ConditionType.REGEXP, r"^[aA]")).select(
@@ -135,13 +139,13 @@ The easiest way to map your tables is:
 ```python
 from datetime import datetime
 
-from src.ormmysql import (
+from ormlambda import (
     Column,
     Table,
     BaseModel,
     ForeignKey,
 )
-from src.ormmysql.common.interfaces import IStatements_two_generic, IRepositoryBase
+from ormlambda.common.interfaces import IStatements_two_generic, IRepositoryBase
 
 
 class Country(Table):

ormlambda-1.2.0.dist-info/RECORD

@@ -0,0 +1,71 @@
+ormlambda/__init__.py,sha256=eAkyO2ZnXFDZfquCiSGmh_kblT-WapEDd4ZnnfS0fOo,465
+ormlambda/common/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+ormlambda/common/abstract_classes/__init__.py,sha256=tk2J4Mn_nD-1ZjtMVBE5FH7KR_8ppN_1Kx1s6c38GjM,167
+ormlambda/common/abstract_classes/abstract_model.py,sha256=5qWXDpgryGuyta0Bv-_W0_KnXtgQE7rVo5HWeFfRz9U,13511
+ormlambda/common/abstract_classes/non_query_base.py,sha256=5jhvyT7OZaJxlGp9XMP3vQ4ei5QQZBn-fFtJnD640mE,980
+ormlambda/common/abstract_classes/query_base.py,sha256=6qUFPwsVx45kUW3b66pHiSyjhcH4mzbdkddlGeUnG7c,266
+ormlambda/common/enums/__init__.py,sha256=4lVKCHi1JalwgNzjsAXqX-C54NJEH83y2v5baMO8fN4,103
+ormlambda/common/enums/condition_types.py,sha256=mDPMrtzZu4IYv3-q5Zw4NNgwUoNAx4lih5SIDFRn1Qo,309
+ormlambda/common/enums/join_type.py,sha256=7LEhE34bzYOwJxe8yxPJo_EjQpGylgClAPX1Wt3z4n4,292
+ormlambda/common/interfaces/INonQueryCommand.py,sha256=7CjLW4sKqkR5zUIGvhRXOtzTs6vypJW1a9EJHlgCw2c,260
+ormlambda/common/interfaces/IQueryCommand.py,sha256=hfzCosK4-n8RJIb2PYs8b0qU3TNmfYluZXBf47KxxKs,331
+ormlambda/common/interfaces/IRepositoryBase.py,sha256=ABdecwq4G_Gg4wvjpj7LWDntdjRmcMMLWOuG2pfAqfg,1939
+ormlambda/common/interfaces/IStatements.py,sha256=h0qgSiWz5rxd9K2FMJPUJau8IKO-ycvQxOSyd74oMq8,9315
+ormlambda/common/interfaces/__init__.py,sha256=4tthR8pNIHGvgu0n7i3ZEQYP_R3wmqh40l34cAZbM2o,244
+ormlambda/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ormlambda/components/delete/IDelete.py,sha256=06ZEdbKBxsHSwsGMBu0E1om4WJjojZAm-L3b95eQrcc,139
+ormlambda/components/delete/__init__.py,sha256=X_at2L4QkxDVK1olXhFHqNemkB8Dxbb7BYqv0EJyu7M,102
+ormlambda/components/delete/abstract_delete.py,sha256=ca-AO3nM9MMhy0hofNLjnCod92meiWzRT2vitj8N-l4,535
+ormlambda/components/insert/IInsert.py,sha256=YIfMPlKu7UGgnVpZuhpr0Mtnefe-O85hqk8-GZrVK7w,139
+ormlambda/components/insert/__init__.py,sha256=TGShCJZwejK3zZCRistBAKoDy2NNDRR_w1LXIbN66Dk,102
+ormlambda/components/insert/abstract_insert.py,sha256=ctaXd6TB8fo3Fl7NHNA-wOmbCpivU-9uUs7O628RUW0,684
+ormlambda/components/select/ISelect.py,sha256=_BkOHbO_ICHDjkzgxbenrauCKIDJ40zeFTIG0FjWRCE,319
+ormlambda/components/select/__init__.py,sha256=BygaFGphVgGT0Zke4WhzdBQMUxevC34Qseok9qutaJE,95
+ormlambda/components/select/table_column.py,sha256=AF4mQvHJnXzE95yP4iNnZCsNDLaYElL16tIo0ZMs7yc,1311
+ormlambda/components/update/IUpdate.py,sha256=U-3Wx8lyCglhxf9gCXWO3MVgydG6gfRpzp00_MHC5cU,168
+ormlambda/components/update/__init__.py,sha256=o1VjlfXgjftZgp64O10rzCGaDZCbdTZRRtjIlojTUWA,102
+ormlambda/components/update/abstract_update.py,sha256=PV6B7FF9nzixmhnZZGG3Xrot8-ycH-oS3IHkHQdabx4,888
+ormlambda/components/upsert/IUpsert.py,sha256=2m6Bcwa0X80IDLnf0QErqr01uYEydOnRta9_T1nxjK4,139
+ormlambda/components/upsert/__init__.py,sha256=2hv7-McdU8Jv1ZJ4J3v94brN2H_fXvVDS8ZEA9CsfPA,102
+ormlambda/components/upsert/abstract_upsert.py,sha256=ES-AicvMYBoLvH77JR6wir4kPkI4ZF9LA1-eQhsjKYI,684
+ormlambda/components/where/__init__.py,sha256=mI-ylB6cTTVf3rtCX54apgZrMP6y9tTD7-X3Ct0RFxw,56
+ormlambda/components/where/abstract_where.py,sha256=93tIJBC81OUUVV6il7mISibBwqJeodQdFFQ9DShDKOQ,344
+ormlambda/databases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ormlambda/databases/my_sql/__init__.py,sha256=3PbOp4WqxJzFOSRwBozqyNtQi25cLLdiJFPDzEnSI70,115
+ormlambda/databases/my_sql/clauses/__init__.py,sha256=xZ4esQfSRHb68M2Bm2B8deJCtDVrUHgpktFAJnakc8s,694
+ormlambda/databases/my_sql/clauses/count.py,sha256=vCQR0jK15t7C31lN0tCwZsmYhqx7fKV8xkSJkStO9vE,1151
+ormlambda/databases/my_sql/clauses/create_database.py,sha256=WnWaAuhxeE71NZKXW37WZ-msRqjum7TFCSRK1IGdSTE,1279
+ormlambda/databases/my_sql/clauses/delete.py,sha256=nUKNQgwF5YUfzk2icWpecYjrGk5DeXpp7eiwtWCf_3c,1924
+ormlambda/databases/my_sql/clauses/drop_database.py,sha256=nMM0YUbcH0D9X3bU70Uc6S_dsIrAZy-IrYuIKrQZNrg,505
+ormlambda/databases/my_sql/clauses/drop_table.py,sha256=meX4e-pVPQ7UwlPSHV5e9HHRblI1BlkLSc7ssl8WUiI,592
+ormlambda/databases/my_sql/clauses/insert.py,sha256=LO9H8VVK3j62dICXqpEUXKxOHPxkD1LGvogmDq2zmho,2805
+ormlambda/databases/my_sql/clauses/joins.py,sha256=U6JnUvQo7AXyEeK-X1jMvckXefgAB7ugSmJCZhH1XQI,3058
+ormlambda/databases/my_sql/clauses/limit.py,sha256=a4lI8FVRKpfXwBQTXdkbVtlQkmzcjE20ymiCy1IaSc4,391
+ormlambda/databases/my_sql/clauses/offset.py,sha256=81170JhsQndjKlDfQj1ll-tiYHQbW8SuU4IE3mhQF7Y,395
+ormlambda/databases/my_sql/clauses/order.py,sha256=AcTD7aeaaz-isyjs1_CkRCb7z8b7o5GhpMxc_2G5IgI,1030
+ormlambda/databases/my_sql/clauses/select.py,sha256=fUeyh2FKud1FOWUGrZCiX-Q2YAcC_EOJ8xCG-SMBDgk,6620
+ormlambda/databases/my_sql/clauses/update.py,sha256=3Htw0_PT3EckEiF214-V2r63lcNoRBroKZI9yg48Ddg,1867
+ormlambda/databases/my_sql/clauses/upsert.py,sha256=eW2pQ4ax-GKuXiaWKoSRSS1GrHuILJBsmj83ADbBQ34,1951
+ormlambda/databases/my_sql/clauses/where_condition.py,sha256=eG514q4Boc2HCZl9MlI5vBKhwQHS9ANpHcTFgLw85vw,8314
+ormlambda/databases/my_sql/repository.py,sha256=2fgejhGcI48XfUMpTAJrT-PPnNHTaaEiOW8Y5wRv3yc,7191
+ormlambda/databases/my_sql/statements.py,sha256=1umK_89JWIfViz1cHfTwqIOvMkYZT2IijDiNRmbUvJ4,2300
+ormlambda/model_base.py,sha256=jH3MTAsVF3V2jXvtKCtpAC-Q102UfBPZ0YiM0nqp-6M,1053
+ormlambda/utils/__init__.py,sha256=ywMdWqmA2jHj19-W-S04yfaYF5hv4IZ1lZDq0B8Jnjs,142
+ormlambda/utils/column.py,sha256=5FAGzCU4yvNS4MhwJJ5i73h7RvHD5UCVox0NdzMsMiE,1945
+ormlambda/utils/dtypes.py,sha256=1kRsT5JggNS1DMWgSUdBb67CefQHnZ-VTN1WI7nN2yQ,7879
+ormlambda/utils/foreign_key.py,sha256=ewGLPtf1MrFogvwGm_jsSnOLAH2G9virXvLcc3co36I,2973
+ormlambda/utils/lambda_disassembler/__init__.py,sha256=q23_F2Vp1_XgVpQSbWQPM5wxzRCZOr7ZMb9X5VG_YxU,229
+ormlambda/utils/lambda_disassembler/dis_types.py,sha256=Myuo9-KSBIJSyr9jfLSDDe1jbrzyOqZNLufv6ODHm98,4824
+ormlambda/utils/lambda_disassembler/disassembler.py,sha256=Zc_hFeEheCiBtFIo39F573uU3jkkB-VyA-wJGICqs44,2019
+ormlambda/utils/lambda_disassembler/dtypes.py,sha256=QtftGMCcb4arAQnXkwGQ1VeV-6x0mZdRTfZmxLkAtFo,6449
+ormlambda/utils/lambda_disassembler/name_of.py,sha256=Cjic_GzqgArxx7kDUMOGYmmNRHj7HcxG-kcDfAhA5yk,1142
+ormlambda/utils/lambda_disassembler/nested_element.py,sha256=nXwytOwBbPYSTMxksQTRMhSeqRIMpIcVWg70loVtQ_k,1234
+ormlambda/utils/lambda_disassembler/tree_instruction.py,sha256=QUnhG89WKJyAlEWAjK5SRZwYgFheHnMw-yUjvVvYhvM,5122
+ormlambda/utils/module_tree/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ormlambda/utils/module_tree/dfs_traversal.py,sha256=lSF03G63XtJFLp03ueAmsHMBvhUkjptDbK3IugXm8iU,1425
+ormlambda/utils/module_tree/dynamic_module.py,sha256=zwvjU3U2cz6H2CDp9Gncs5D5bSAyfITNa2SDqFDl8rw,8551
+ormlambda/utils/table_constructor.py,sha256=I2oFTfa6BPTILY6UDYGZy4fJxZazZMkH89NObkfRemo,11480
+ormlambda-1.2.0.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-1.2.0.dist-info/METADATA,sha256=5uv_JdYZ2gWIL-P4HohMxMvw96jLizPd2aZi77MWGyQ,8427
+ormlambda-1.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ormlambda-1.2.0.dist-info/RECORD,,