ormlambda 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

ormlambda/__init__.py

@@ -4,6 +4,7 @@ from .common.enums import (  # noqa: F401
     ConditionType,
 )
 
+from .common.abstract_classes import AbstractSQLStatements  # noqa: F401
 from .common.interfaces import IRepositoryBase  # noqa: F401
 from .utils import Table, Column, ForeignKey  # noqa: F401
 from .utils.lambda_disassembler import Disassembler, nameof  # noqa: F401

ormlambda/common/abstract_classes/abstract_model.py

@@ -1,37 +1,14 @@
 from __future__ import annotations
-from typing import Any, Callable, Optional, Type, override, Iterable, Literal, TYPE_CHECKING
-from enum import Enum
+from typing import Any, Type, override, Iterable, Literal, TYPE_CHECKING
 from collections import defaultdict
-from abc import abstractmethod
-import inspect
 
-from ormlambda.utils import ForeignKey, Table
 
+from ormlambda.utils import Table
 from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
 
 if TYPE_CHECKING:
-    from ormlambda.common.interfaces.IStatements import OrderType
-
-    from ormlambda.components.update import UpdateQueryBase
     from ormlambda.components.select import ISelect
-    from ormlambda.components.delete import DeleteQueryBase
-    from ormlambda.components.upsert import UpsertQueryBase
     from ormlambda.components.select import TableColumn
-    from ormlambda.components.insert import InsertQueryBase
-    from ormlambda.components.where.abstract_where import AbstractWhere
-
-    from ormlambda.databases.my_sql.clauses.select import SelectQuery
-    from ormlambda.databases.my_sql.clauses.count import CountQuery
-
-
-class JoinType(Enum):
-    RIGHT_INCLUSIVE = "RIGHT JOIN"
-    LEFT_INCLUSIVE = "LEFT JOIN"
-    RIGHT_EXCLUSIVE = "RIGHT JOIN"
-    LEFT_EXCLUSIVE = "LEFT JOIN"
-    FULL_OUTER_INCLUSIVE = "RIGHT JOIN"
-    FULL_OUTER_EXCLUSIVE = "RIGHT JOIN"
-    INNER_JOIN = "INNER JOIN"
 
 
 ORDER_QUERIES = Literal["select", "join", "where", "order", "with", "group by", "limit", "offset"]
@@ -42,7 +19,7 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
     __order__: tuple[str, ...] = ("select", "join", "where", "order", "with", "group by", "limit", "offset")
 
     def __init__(self, model: T, repository: IRepositoryBase[TRepo]) -> None:
-        self.valid_repository(repository)
+        self.__valid_repository(repository)
 
         self._model: T = model
         self._repository: IRepositoryBase[TRepo] = repository
@@ -54,160 +31,17 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
             raise Exception(f"'{model}' class does not inherit from Table class")
 
     @staticmethod
-    def valid_repository(repository: Any) -> bool:
+    def __valid_repository(repository: Any) -> bool:
         if not isinstance(repository, IRepositoryBase):
             raise ValueError(f"'repository' attribute does not instance of '{IRepositoryBase.__name__}'")
         return True
 
-    @property
-    @abstractmethod
-    def INSERT_QUERY(self) -> Type[InsertQueryBase[T, TRepo]]: ...
-    @property
-    @abstractmethod
-    def UPSERT_QUERY(self) -> Type[UpsertQueryBase[T, TRepo]]: ...
-    @property
-    @abstractmethod
-    def UPDATE_QUERY(self) -> Type[UpdateQueryBase[T, TRepo]]: ...
-    @property
-    @abstractmethod
-    def DELETE_QUERY(self) -> Type[DeleteQueryBase[T, TRepo]]: ...
-    @property
-    @abstractmethod
-    def LIMIT_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def OFFSET_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def JOIN_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def WHERE_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def ORDER_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def SELECT_QUERY(self) -> Type[SelectQuery]: ...
+    def __repr__(self):
+        return f"<Model: {self.__class__.__name__}>"
 
     @property
-    @abstractmethod
-    def COUNT(self) -> Type[CountQuery]: ...
-
-    @override
-    def create_table(self) -> None:
-        if not self._repository.table_exists(self._model.__table_name__):
-            self._repository.execute(self._model.create_table_query())
-        return None
-
-    @override
-    def table_exists(self) -> bool:
-        return self._repository.table_exists(self._model.__table_name__)
-
-    @override
-    def insert(self, instances: T | list[T]) -> None:
-        insert = self.INSERT_QUERY(self._model, self._repository)
-        insert.insert(instances)
-        insert.execute()
-        self._query_list.clear()
-        return None
-
-    @override
-    def delete(self, instances: Optional[T | list[T]] = None) -> None:
-        if instances is None:
-            response = self.select()
-            if len(response) == 0:
-                return None
-            # [0] because if we do not select anything, we retrieve all columns of the unic model, stored in tuple[tuple[model]] structure.
-            # We always going to have a tuple of one element
-            return self.delete(response)
-
-        delete = self.DELETE_QUERY(self._model, self._repository)
-        delete.delete(instances)
-        delete.execute()
-        # not necessary to call self._query_list.clear() because select() method already call it
-        return None
-
-    @override
-    def upsert(self, instances: T | list[T]) -> None:
-        upsert = self.UPSERT_QUERY(self._model, self._repository)
-        upsert.upsert(instances)
-        upsert.execute()
-        self._query_list.clear()
-        return None
-
-    @override
-    def update(self, dicc: dict[str, Any] | list[dict[str, Any]]) -> None:
-        update = self.UPDATE_QUERY(self._model, self._repository, self._query_list["where"])
-        update.update(dicc)
-        update.execute()
-        self._query_list.clear()
-        return None
-
     @override
-    def limit(self, number: int) -> "IStatements_two_generic[T,TRepo]":
-        limit = self.LIMIT_QUERY(number)
-        # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
-        limit_list = self._query_list["limit"]
-        if len(limit_list) > 0:
-            self._query_list["limit"] = [limit]
-        else:
-            self._query_list["limit"].append(limit)
-        return self
-
-    @override
-    def offset(self, number: int) -> "IStatements_two_generic[T,TRepo]":
-        offset = self.OFFSET_QUERY(number)
-        self._query_list["offset"].append(offset)
-        return self
-
-    @override
-    def count(self) -> int:
-        count_select: IQuery = self.COUNT(self._model)
-        self._query_list["select"].append(count_select)
-        query = self.build()
-        return self.repository.read_sql(query)[0][0]
-
-    @override
-    def join(self, table_left: Table, table_right: Table, *, by: str) -> "IStatements_two_generic[T,TRepo]":
-        where = ForeignKey.MAPPED[table_left.__table_name__][table_right.__table_name__]
-        join_query = self.JOIN_QUERY[table_left, Table](table_left, table_right, JoinType(by), where=where)
-        self._query_list["join"].append(join_query)
-        return self
-
-    @override
-    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> "IStatements_two_generic[T,TRepo]":
-        # FIXME [x]: I've wrapped self._model into tuple to pass it instance attr. Idk if it's correct
-        where_query = self.WHERE_QUERY[T](function=lambda_, instances=(self._model,), **kwargs)
-        self._query_list["where"].append(where_query)
-        return self
-
-    @override
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> "IStatements_two_generic[T,TRepo]":
-        order = self.ORDER_QUERY[T](self._model, _lambda_col, order_type)
-        self._query_list["order"].append(order)
-        return self
-
-    @override
-    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
-        if len(inspect.signature(selector).parameters) == 0:
-            # COMMENT: if we do not specify any lambda function we assumed the user want to retreive only elements of the Model itself avoiding other models
-            result = self.select(selector=lambda x: (x,), flavour=flavour, by=by)
-            # COMMENT: Always we want to retrieve tuple[tuple[Any]]. That's the reason to return result[0] when we ensure the user want only objects of the first table.
-            # Otherwise, we wil return the result itself
-            if flavour:
-                return result
-            return () if not result else result[0]
-        select: ISelect = self.SELECT_QUERY(self._model, select_lambda=selector, by=by)
-        self._query_list["select"].append(select)
-
-        query: str = self.build()
-        if flavour:
-            result = self._return_flavour(query, flavour)
-            if issubclass(flavour, tuple) and isinstance(selector(self._model), property):
-                return tuple([x[0] for x in result])
-            return result
-        return self._return_model(select, query)
+    def repository(self) -> IRepositoryBase[TRepo]: ...
 
     def _return_flavour[TValue](self, query, flavour: Type[TValue]) -> tuple[TValue]:
         return self._repository.read_sql(query, flavour=flavour)
@@ -220,72 +54,6 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
 
         return response_sql
 
-    @override
-    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
-        self.limit(1)
-        if len(inspect.signature(selector).parameters) == 0:
-            response = self.select(selector=lambda x: (x,), flavour=flavour, by=by)
-        else:
-            response = self.select(selector=selector, flavour=flavour, by=by)
-
-        if flavour:
-            return response[0] if response else None
-
-        # response var could be return more than one element when we work with models an we
-        # select columns from different tables using a join query
-        if len(response) == 1 and len(response[0]) == 1:
-            return response[0][0]
-        return tuple([res[0] for res in response])
-
-    @override
-    def build(self) -> str:
-        query: str = ""
-
-        self._create_necessary_inner_join()
-        for x in self.__order__:
-            if sub_query := self._query_list.get(x, None):
-                if isinstance(sub_query[0], self.WHERE_QUERY):
-                    query_ = self.__build_where_clause(sub_query)
-
-                # we must check if any join already exists on query string
-                elif isinstance(sub_query[0], self.JOIN_QUERY):
-                    select_query: str = self._query_list["select"][0].query
-                    query_ = ""
-                    for join in sub_query:
-                        if join.query not in select_query:
-                            query_ += f"\n{join.query}"
-                else:
-                    query_ = "\n".join([x.query for x in sub_query])
-
-                query += f"\n{query_}" if query != "" else query_
-        self._query_list.clear()
-        return query
-
-    def __build_where_clause(self, where_condition: list[AbstractWhere]) -> str:
-        query: str = where_condition[0].query
-
-        for where in where_condition[1:]:
-            q = where.query.replace(where.WHERE, "AND")
-            and_, clause = q.split(" ", maxsplit=1)
-            query += f" {and_} ({clause})"
-        return query
-
-    def _create_necessary_inner_join(self) -> None:
-        # When we applied filters in any table that we wont select any column, we need to add manually all neccessary joins to achieve positive result.
-        if "where" not in self._query_list:
-            return None
-
-        where: AbstractWhere = self._query_list["where"][0]
-        involved_tables = where.get_involved_tables()
-
-        select: ISelect = self._query_list["select"][0]
-        if not involved_tables or (set(involved_tables) == set(select.tables_heritage)):
-            return None
-
-        for l_tbl, r_tbl in involved_tables:
-            # FIXME [ ]: Checked what function was called by the self.join method before the change
-            self.join(l_tbl, r_tbl, by="INNER JOIN")
-
 
 class ClusterQuery:
     def __init__(self, select: ISelect, response_sql: tuple[dict[str, Any]]) -> None:

ormlambda/common/interfaces/IRepositoryBase.py

@@ -25,7 +25,7 @@ class IRepositoryBase[T](ABC):
     def is_connected(self) -> bool: ...
 
     @abstractmethod
-    def connect(self, **kwargs: Any) -> "IRepositoryBase[T]": ...
+    def connect(self, **kwargs: Any) -> None: ...
 
     @abstractmethod
     def close_connection(self) -> None: ...

ormlambda/databases/my_sql/repository.py

@@ -85,7 +85,7 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         return self._connection.is_connected()
 
     @override
-    def connect(self) -> IRepositoryBase[MySQLConnection]:
+    def connect(self) -> None:
         # return MySQLConnectionPool(pool_name="mypool", pool_size=5, **kwargs)
         self._connection.connect(**self._data_config)
         return None

ormlambda/databases/my_sql/statements.py

@@ -1,14 +1,18 @@
 from __future__ import annotations
-from typing import override, Type, TYPE_CHECKING
+from typing import override, Type, TYPE_CHECKING, Any, Callable, Optional
 
 if TYPE_CHECKING:
     from ormlambda import Table
     from ormlambda.components.select import ISelect
+    from ormlambda.components.where.abstract_where import AbstractWhere
+    from ormlambda.common.interfaces.IStatements import OrderType
+    from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
+    
+    from ormlambda.databases.my_sql.clauses.select import SelectQuery
+    from ormlambda.databases.my_sql.clauses.count import CountQuery
 
-from ormlambda.common.abstract_classes import AbstractSQLStatements
-
-from ormlambda.common.interfaces import IQuery, IRepositoryBase
 
+from ormlambda import AbstractSQLStatements
 from .clauses import DeleteQuery
 from .clauses import InsertQuery
 from .clauses import JoinSelector
@@ -24,72 +28,200 @@ from .clauses import CountQuery
 from mysql.connector import MySQLConnection
 
 
+
+import inspect
+
+from ormlambda.utils import ForeignKey, Table
+from ormlambda.common.enums import JoinType
+
+
+
 class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
     def __init__(self, model: T, repository: IRepositoryBase[MySQLConnection]) -> None:
         super().__init__(model, repository=repository)
 
-    # region Private methods
-    def __repr__(self):
-        return f"<Model: {self.__class__.__name__}>"
+    @property
+    @override
+    def repository(self) -> IRepositoryBase[MySQLConnection]:
+        return self._repository
 
-    # endregion
+    @override
+    def create_table(self) -> None:
+        if not self._repository.table_exists(self._model.__table_name__):
+            self._repository.execute(self._model.create_table_query())
+        return None
 
-    @property
     @override
-    def INSERT_QUERY(self) -> Type[InsertQuery]:
-        return InsertQuery
+    def table_exists(self) -> bool:
+        return self._repository.table_exists(self._model.__table_name__)
 
-    @property
     @override
-    def UPSERT_QUERY(self) -> Type[UpsertQuery]:
-        return UpsertQuery
+    def insert(self, instances: T | list[T]) -> None:
+        insert = InsertQuery(self._model, self._repository)
+        insert.insert(instances)
+        insert.execute()
+        self._query_list.clear()
+        return None
 
-    @property
     @override
-    def UPDATE_QUERY(self) -> Type[UpsertQuery]:
-        return UpdateQuery
+    def delete(self, instances: Optional[T | list[T]] = None) -> None:
+        if instances is None:
+            response = self.select()
+            if len(response) == 0:
+                return None
+            # [0] because if we do not select anything, we retrieve all columns of the unic model, stored in tuple[tuple[model]] structure.
+            # We always going to have a tuple of one element
+            return self.delete(response)
+
+        delete = DeleteQuery(self._model, self._repository)
+        delete.delete(instances)
+        delete.execute()
+        # not necessary to call self._query_list.clear() because select() method already call it
+        return None
 
     @override
-    @property
-    def DELETE_QUERY(self) -> Type[DeleteQuery]:
-        return DeleteQuery
+    def upsert(self, instances: T | list[T]) -> None:
+        upsert = UpsertQuery(self._model, self._repository)
+        upsert.upsert(instances)
+        upsert.execute()
+        self._query_list.clear()
+        return None
 
-    @property
     @override
-    def LIMIT_QUERY(self) -> Type[IQuery]:
-        return LimitQuery
+    def update(self, dicc: dict[str, Any] | list[dict[str, Any]]) -> None:
+        update = UpdateQuery(self._model, self._repository, self._query_list["where"])
+        update.update(dicc)
+        update.execute()
+        self._query_list.clear()
+        return None
 
-    @property
     @override
-    def OFFSET_QUERY(self) -> Type[IQuery]:
-        return OffsetQuery
+    def limit(self, number: int) -> IStatements_two_generic[T, MySQLConnection]:
+        limit = LimitQuery(number)
+        # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
+        limit_list = self._query_list["limit"]
+        if len(limit_list) > 0:
+            self._query_list["limit"] = [limit]
+        else:
+            self._query_list["limit"].append(limit)
+        return self
 
-    @property
     @override
-    def COUNT(self) -> int:
-        return CountQuery
+    def offset(self, number: int) -> IStatements_two_generic[T, MySQLConnection]:
+        offset = OffsetQuery(number)
+        self._query_list["offset"].append(offset)
+        return self
 
-    @property
     @override
-    def JOIN_QUERY(self) -> Type[IQuery]:
-        return JoinSelector
+    def count(self) -> int:
+        count_select: IQuery = CountQuery(self._model)
+        self._query_list["select"].append(count_select)
+        query = self.build()
+        return self.repository.read_sql(query)[0][0]
 
-    @property
     @override
-    def WHERE_QUERY(self) -> Type[IQuery]:
-        return WhereCondition
+    def join(self, table_left: Table, table_right: Table, *, by: str) -> IStatements_two_generic[T, MySQLConnection]:
+        where = ForeignKey.MAPPED[table_left.__table_name__][table_right.__table_name__]
+        join_query = JoinSelector[table_left, Table](table_left, table_right, JoinType(by), where=where)
+        self._query_list["join"].append(join_query)
+        return self
 
-    @property
     @override
-    def ORDER_QUERY(self) -> Type[IQuery]:
-        return OrderQuery
+    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> IStatements_two_generic[T, MySQLConnection]:
+        # FIXME [x]: I've wrapped self._model into tuple to pass it instance attr. Idk if it's correct
+        where_query = WhereCondition[T](function=lambda_, instances=(self._model,), **kwargs)
+        self._query_list["where"].append(where_query)
+        return self
 
-    @property
     @override
-    def SELECT_QUERY(self) -> Type[ISelect]:
-        return SelectQuery
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements_two_generic[T, MySQLConnection]:
+        order = OrderQuery[T](self._model, _lambda_col, order_type)
+        self._query_list["order"].append(order)
+        return self
 
-    @property
     @override
-    def repository(self) -> IRepositoryBase[MySQLConnection]:
-        return self._repository
+    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
+        if len(inspect.signature(selector).parameters) == 0:
+            # COMMENT: if we do not specify any lambda function we assumed the user want to retreive only elements of the Model itself avoiding other models
+            result = self.select(selector=lambda x: (x,), flavour=flavour, by=by)
+            # COMMENT: Always we want to retrieve tuple[tuple[Any]]. That's the reason to return result[0] when we ensure the user want only objects of the first table.
+            # Otherwise, we wil return the result itself
+            if flavour:
+                return result
+            return () if not result else result[0]
+        select: ISelect = SelectQuery(self._model, select_lambda=selector, by=by)
+        self._query_list["select"].append(select)
+
+        query: str = self.build()
+        if flavour:
+            result = self._return_flavour(query, flavour)
+            if issubclass(flavour, tuple) and isinstance(selector(self._model), property):
+                return tuple([x[0] for x in result])
+            return result
+        return self._return_model(select, query)
+
+    @override
+    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
+        self.limit(1)
+        if len(inspect.signature(selector).parameters) == 0:
+            response = self.select(selector=lambda x: (x,), flavour=flavour, by=by)
+        else:
+            response = self.select(selector=selector, flavour=flavour, by=by)
+
+        if flavour:
+            return response[0] if response else None
+
+        # response var could be return more than one element when we work with models an we
+        # select columns from different tables using a join query
+        if len(response) == 1 and len(response[0]) == 1:
+            return response[0][0]
+        return tuple([res[0] for res in response])
+
+    @override
+    def build(self) -> str:
+        query: str = ""
+
+        self.__create_necessary_inner_join()
+        for x in self.__order__:
+            if sub_query := self._query_list.get(x, None):
+                if isinstance(sub_query[0], WhereCondition):
+                    query_ = self.__build_where_clause(sub_query)
+
+                # we must check if any join already exists on query string
+                elif isinstance(sub_query[0], JoinSelector):
+                    select_query: str = self._query_list["select"][0].query
+                    query_ = ""
+                    for join in sub_query:
+                        if join.query not in select_query:
+                            query_ += f"\n{join.query}"
+                else:
+                    query_ = "\n".join([x.query for x in sub_query])
+
+                query += f"\n{query_}" if query != "" else query_
+        self._query_list.clear()
+        return query
+
+    def __build_where_clause(self, where_condition: list[AbstractWhere]) -> str:
+        query: str = where_condition[0].query
+
+        for where in where_condition[1:]:
+            q = where.query.replace(where.WHERE, "AND")
+            and_, clause = q.split(" ", maxsplit=1)
+            query += f" {and_} ({clause})"
+        return query
+
+    def __create_necessary_inner_join(self) -> None:
+        # When we applied filters in any table that we wont select any column, we need to add manually all neccessary joins to achieve positive result.
+        if "where" not in self._query_list:
+            return None
+
+        where: AbstractWhere = self._query_list["where"][0]
+        involved_tables = where.get_involved_tables()
+
+        select: ISelect = self._query_list["select"][0]
+        if not involved_tables or (set(involved_tables) == set(select.tables_heritage)):
+            return None
+
+        for l_tbl, r_tbl in involved_tables:
+            # FIXME [ ]: Checked what function was called by the self.join method before the change
+            self.join(l_tbl, r_tbl, by="INNER JOIN")

ormlambda/model_base.py

@@ -10,7 +10,7 @@ from .databases.my_sql import MySQLStatements, MySQLRepository
 # endregion
 
 
-class BaseModel[T: Table]:
+class BaseModel[T: Type[Table]]:
     """
     Class to select the correct AbstractSQLStatements class depends on the repository.
 
@@ -27,7 +27,7 @@ class BaseModel[T: Table]:
         cls: AbstractSQLStatements[T, TRepo] = cls.statements_dicc.get(type(repository), None)
 
         if not cls:
-            raise Exception(f"Repository selected does not exits '{repository}'")
+            raise Exception(f"The selected repository '{repository}' does not exist.")
 
         self = object().__new__(cls)
         cls.__init__(self, model, repository)

{ormlambda-1.2.2.dist-info → ormlambda-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 1.2.2
+Version: 1.3.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

{ormlambda-1.2.2.dist-info → ormlambda-1.3.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-ormlambda/__init__.py,sha256=eAkyO2ZnXFDZfquCiSGmh_kblT-WapEDd4ZnnfS0fOo,465
+ormlambda/__init__.py,sha256=L-Enc4FPmW3ldBMnWOU3gLn9i4FEc7sQzLWy2mIEti8,538
 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=0ksGlFS2HBoN2ImNod944xBBE3xm2j91pxdHSXh7dVk,13533
+ormlambda/common/abstract_classes/abstract_model.py,sha256=Eguy4jQQdLAKvYZgDqUB1V4driBsYoiDuyPZ-DwPi5A,3867
 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
@@ -9,7 +9,7 @@ ormlambda/common/enums/condition_types.py,sha256=mDPMrtzZu4IYv3-q5Zw4NNgwUoNAx4l
 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/IRepositoryBase.py,sha256=UAnt_ZFwfyx6vDXiWoF69rqbLySirhDlVEghMYzuDJ0,1923
 ormlambda/common/interfaces/IStatements.py,sha256=tDQ7LviuNOCPCblSCvpnwSC5dyygWVpQ_TvxtJ2Jzp4,9628
 ormlambda/common/interfaces/__init__.py,sha256=4tthR8pNIHGvgu0n7i3ZEQYP_R3wmqh40l34cAZbM2o,244
 ormlambda/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -47,9 +47,9 @@ ormlambda/databases/my_sql/clauses/select.py,sha256=fUeyh2FKud1FOWUGrZCiX-Q2YAcC
 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/databases/my_sql/repository.py,sha256=xKbtitr2R7V89La_hL1TE-sexfQqw-s5N51SIuCXH7I,7163
+ormlambda/databases/my_sql/statements.py,sha256=3WKlQrxSksceJQXeGh16DRu-Upr_lsY9JZpt4bB2kwk,9452
+ormlambda/model_base.py,sha256=x7PUPNslRh4hTNsDDUwuh_maKjEFsHIvee4a6rcyNV8,1064
 ormlambda/utils/__init__.py,sha256=ywMdWqmA2jHj19-W-S04yfaYF5hv4IZ1lZDq0B8Jnjs,142
 ormlambda/utils/column.py,sha256=5FAGzCU4yvNS4MhwJJ5i73h7RvHD5UCVox0NdzMsMiE,1945
 ormlambda/utils/dtypes.py,sha256=1kRsT5JggNS1DMWgSUdBb67CefQHnZ-VTN1WI7nN2yQ,7879
@@ -65,7 +65,7 @@ ormlambda/utils/module_tree/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 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.2.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
-ormlambda-1.2.2.dist-info/METADATA,sha256=HkOi6OeDGnCuKDg9FOMaEgYuCvO2iMZrPuVkvw8RBsA,8428
-ormlambda-1.2.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ormlambda-1.2.2.dist-info/RECORD,,
+ormlambda-1.3.0.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-1.3.0.dist-info/METADATA,sha256=npu-nY-qxCZebgn5C1oXA87apBV-z3Vnsv75OEumy3w,8428
+ormlambda-1.3.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ormlambda-1.3.0.dist-info/RECORD,,