ormlambda 1.5.0__tar.gz → 2.0.2__tar.gz

{ormlambda-1.5.0 → ormlambda-2.0.2}/PKG-INFO

@@ -1,16 +1,20 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 1.5.0
+Version: 2.0.2
 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 (>=9.0.0,<10.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.5.0 → ormlambda-2.0.2}/README.md

@@ -1,3 +1,7 @@
+![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. 
 
@@ -6,7 +10,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")
@@ -18,7 +22,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()
 ```
@@ -28,8 +32,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(
@@ -122,13 +126,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.5.0 → ormlambda-2.0.2}/pyproject.toml

@@ -3,19 +3,18 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "1.5.0"
+version = "2.0.2"
 description = "ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions"
 authors = ["p-hzamora <p.hzamora@icloud.com>"]
 readme = "README.md"
 
 [tool.poetry.dependencies]
 python = "^3.12"
-mysql-connector = "^2.2.9"
-ruff = "^0.4.5"
+mysql-connector-python= "^9.0.0"
+fluent-validation = "^3.1.0"
 
 [tool.poetry.group.test.dependencies]
 pandas = "^2.2.2"
-mysql-connector = "^2.2.9"
 ruff = "^0.4.5"
 python-decouple = "^3.8"
 

ormlambda-2.0.2/src/ormlambda/__init__.py

@@ -0,0 +1,11 @@
+# enums
+from .common.enums import (  # noqa: F401
+    JoinType,
+    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
+from .model_base import BaseModel  # noqa: F401  # COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/common/__init__.py

@@ -1,2 +1 @@
 
-

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/common/abstract_classes/__init__.py

@@ -1,3 +1,3 @@
 from .non_query_base import NonQueryBase  # noqa: F401
 from .abstract_model import AbstractSQLStatements  # noqa: F401
-from .query_base import QueryBase  # noqa: F401
+from .query_base import QueryBase  # noqa: F401

ormlambda-2.0.2/src/ormlambda/common/abstract_classes/abstract_model.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+from typing import Any, Type, override, Iterable, Literal, TYPE_CHECKING
+from collections import defaultdict
+
+
+from ormlambda.utils import Table
+from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
+
+if TYPE_CHECKING:
+    from ormlambda.components.select import ISelect
+    from ormlambda.components.select import TableColumn
+
+
+ORDER_QUERIES = Literal["select", "join", "where", "order", "with", "group by", "limit", "offset"]
+
+
+class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
+    __slots__ = ("_model", "_repository", "_query_list")
+    __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._model: T = model
+        self._repository: IRepositoryBase[TRepo] = repository
+        self._query_list: dict[ORDER_QUERIES, list[IQuery]] = defaultdict(list)
+
+        if not issubclass(self._model, Table):
+            # Deben heredar de Table ya que es la forma que tenemos para identificar si estamos pasando una instancia del tipo que corresponde o no cuando llamamos a insert o upsert.
+            # Si no heredase de Table no sabriamos identificar el tipo de dato del que se trata porque al llamar a isinstance, obtendriamos el nombre de la clase que mapea a la tabla, Encargo, Edificio, Presupuesto y no podriamos crear una clase generica
+            raise Exception(f"'{model}' class does not inherit from Table class")
+
+    @staticmethod
+    def __valid_repository(repository: Any) -> bool:
+        if not isinstance(repository, IRepositoryBase):
+            raise ValueError(f"'repository' attribute does not instance of '{IRepositoryBase.__name__}'")
+        return True
+
+    def __repr__(self):
+        return f"<Model: {self.__class__.__name__}>"
+
+    @property
+    @override
+    def repository(self) -> IRepositoryBase[TRepo]: ...
+
+    def _return_flavour[TValue](self, query, flavour: Type[TValue]) -> tuple[TValue]:
+        return self._repository.read_sql(query, flavour=flavour)
+
+    def _return_model(self, select: ISelect, query: str):
+        response_sql = self._repository.read_sql(query, flavour=dict)  # store all columns of the SQL query
+
+        if isinstance(response_sql, Iterable):
+            return ClusterQuery(select, response_sql).clean_response()
+
+        return response_sql
+
+
+class ClusterQuery:
+    def __init__(self, select: ISelect, response_sql: tuple[dict[str, Any]]) -> None:
+        self._select: ISelect = select
+        self._response_sql: tuple[dict[str, Any]] = response_sql
+
+    def loop_foo(self) -> dict[Type[Table], list[Table]]:
+        #  We must ensure to get the valid attributes for each instance
+        table_initialize = defaultdict(list)
+
+        unic_table: dict[Table, list[TableColumn]] = defaultdict(list)
+        for table_col in self._select.select_list:
+            unic_table[table_col._table].append(table_col)
+
+        for table_, table_col in unic_table.items():
+            for dicc_cols in self._response_sql:
+                valid_attr: dict[str, Any] = {}
+                for col in table_col:
+                    valid_attr[col.real_column] = dicc_cols[col.alias]
+                # COMMENT: At this point we are going to instantiate Table class with specific attributes getting directly from database
+                table_initialize[table_].append(table_(**valid_attr))
+        return table_initialize
+
+    def clean_response(self) -> tuple[dict[Type[Table], tuple[Table]]]:
+        tbl_dicc: dict[Type[Table], list[Table]] = self.loop_foo()
+
+        # it not depend of flavour attr
+        for key, val in tbl_dicc.items():
+            tbl_dicc[key] = tuple(val)
+
+        return tuple(tbl_dicc.values())

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/common/abstract_classes/non_query_base.py

@@ -1,13 +1,15 @@
+from __future__ import annotations
 from abc import abstractmethod
-from typing import Any, Optional, override
+from typing import Any, Optional, Type, override, TYPE_CHECKING
 
-from ..interfaces.INonQueryCommand import INonQueryCommand
+from ormlambda.common.interfaces.INonQueryCommand import INonQueryCommand
 
-from ..interfaces import IRepositoryBase
-from ...utils import Table
+if TYPE_CHECKING:
+    from ormlambda import IRepositoryBase
+    from ormlambda import Table
 
 
-class NonQueryBase[T: Table, TRepo: IRepositoryBase](INonQueryCommand):
+class NonQueryBase[T: Type[Table], TRepo: IRepositoryBase](INonQueryCommand):
     __slots__: tuple[str, ...] = ("_model", "_repository", "_values", "_query")
 
     def __init__(self, model: T, repository: TRepo) -> None:

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/common/abstract_classes/query_base.py

@@ -1,7 +1,10 @@
 from abc import abstractmethod
+from typing import TYPE_CHECKING
 
-from ...utils import Table
-from ..interfaces import IQuery
+from ormlambda.common.interfaces import IQuery
+
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 
 class QueryBase[T: Table](IQuery):

ormlambda-2.0.2/src/ormlambda/common/enums/__init__.py

@@ -0,0 +1,2 @@
+from .join_type import JoinType  # noqa: F401
+from .condition_types import ConditionType  # noqa: F401

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/common/enums/join_type.py

@@ -1,5 +1,6 @@
 from enum import Enum
 
+
 class JoinType(Enum):
     RIGHT_INCLUSIVE = "RIGHT JOIN"
     LEFT_INCLUSIVE = "LEFT JOIN"
@@ -7,4 +8,4 @@ class JoinType(Enum):
     LEFT_EXCLUSIVE = "LEFT JOIN"
     FULL_OUTER_INCLUSIVE = "RIGHT JOIN"
     FULL_OUTER_EXCLUSIVE = "RIGHT JOIN"
-    INNER_JOIN = "INNER JOIN"
+    INNER_JOIN = "INNER JOIN"

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/common/interfaces/IQueryCommand.py

@@ -2,7 +2,8 @@ from abc import abstractmethod, ABC
 
 
 class IQuery(ABC):
-    """ Interface to queries that retrieve any element such as select, limit, offset, where, group by, etc..."""
+    """Interface to queries that retrieve any element such as select, limit, offset, where, group by, etc..."""
+
     @property
     @abstractmethod
     def query(self) -> str: ...

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/common/interfaces/IRepositoryBase.py

@@ -1,23 +1,10 @@
 from abc import ABC, abstractmethod
-import functools
-from typing import Any, Callable, Literal, Optional, Type
+from typing import Any, Literal, Optional, Type
 
 TypeExists = Literal["fail", "replace", "append"]
 
 
 class IRepositoryBase[T](ABC):
-    def check_connection(func: Callable[..., Any]):
-        @functools.wraps(func)
-        def wrapper(self: "IRepositoryBase[T]", *args, **kwargs):
-            if not self.is_connected():
-                self.connect()
-
-            foo = func(self, *args, **kwargs)
-            self.close_connection()
-            return foo
-
-        return wrapper
-
     def __repr__(self) -> str:
         return f"{IRepositoryBase.__name__}: {self.__class__.__name__}"
 
@@ -25,7 +12,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: ...
@@ -61,7 +48,6 @@ class IRepositoryBase[T](ABC):
     @abstractmethod
     def connection(self) -> T: ...
 
+    @property
     @abstractmethod
-    def set_config(self, value: dict[str, Any]) -> dict[str, Any]:
-        """Method to update database config"""
-        ...
+    def database(self) -> Optional[str]: ...

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/common/interfaces/IStatements.py

@@ -1,17 +1,23 @@
-from typing import Any, Callable, Iterable, Optional, Literal, Type, overload
+from __future__ import annotations
+from typing import Any, Callable, Iterable, Optional, Literal, Type, overload, TYPE_CHECKING
 from enum import Enum
 from abc import abstractmethod, ABC
 
 from .IRepositoryBase import IRepositoryBase
-from ..enums import JoinType
-from ...utils import Table
+from ormlambda.common.enums import JoinType
+
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 OrderType = Literal["ASC", "DESC"]
 
+# TODOH: This var is duplicated from 'src\ormlambda\databases\my_sql\clauses\create_database.py'
+TypeExists = Literal["fail", "replace", "append"]
+
 
 class IStatements[T: Table](ABC):
     @abstractmethod
-    def create_table(self) -> None: ...
+    def create_table(self, if_exists: TypeExists) -> None: ...
 
     @abstractmethod
     def table_exists(self) -> bool: ...
@@ -38,6 +44,8 @@ class IStatements[T: Table](ABC):
     @abstractmethod
     def insert(self, values: T | list[T]) -> None: ...
 
+    # endregion
+
     # region upsert
     @overload
     def upsert(self, values: T) -> None:
@@ -71,13 +79,19 @@ class IStatements[T: Table](ABC):
 
     # region limit
     @abstractmethod
-    def limit(self, number: int) -> "IStatements[T]": ...
+    def limit(self, number: int) -> IStatements[T]: ...
 
     # endregion
 
     # region offset
     @abstractmethod
-    def offset(self, number: int) -> "IStatements[T]": ...
+    def offset(self, number: int) -> IStatements[T]: ...
+
+    # endregion
+
+    # region count
+    @abstractmethod
+    def count(self) -> int: ...
 
     # endregion
 
@@ -97,13 +111,13 @@ class IStatements[T: Table](ABC):
 
     # region join
     @abstractmethod
-    def join(self, table_left: Table, table_right: Table, *, by: str) -> "IStatements[T]": ...
+    def join(self, table_left: Table, table_right: Table, *, by: str) -> IStatements[T]: ...
 
     # endregion
 
     # region where
     @overload
-    def where(self, lambda_: Callable[[T], bool]) -> "IStatements[T]":
+    def where(self, lambda_: Callable[[T], bool]) -> IStatements[T]:
         """
         This method creates where clause by passing the lambda's condition
 
@@ -115,7 +129,7 @@ class IStatements[T: Table](ABC):
         ...
 
     @overload
-    def where(self, lambda_: Callable[[T], Iterable]) -> "IStatements[T]":
+    def where(self, lambda_: Callable[[T], Iterable]) -> IStatements[T]:
         """
         This method creates where clause by passing the Iterable in lambda function
         EXAMPLE
@@ -126,7 +140,7 @@ class IStatements[T: Table](ABC):
         ...
 
     @overload
-    def where(self, lambda_: Callable[[T], bool], **kwargs) -> "IStatements[T]":
+    def where(self, lambda_: Callable[[T], bool], **kwargs) -> IStatements[T]:
         """
         PARAM
         -
@@ -143,17 +157,17 @@ class IStatements[T: Table](ABC):
         ...
 
     @abstractmethod
-    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> "IStatements[T]": ...
+    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> IStatements[T]: ...
 
     # endregion
 
     # region order
     @overload
-    def order[TValue](self, _lambda_col: Callable[[T], TValue]) -> "IStatements[T]": ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue]) -> IStatements[T]: ...
     @overload
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> "IStatements[T]": ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements[T]: ...
     @abstractmethod
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> "IStatements[T]": ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements[T]: ...
 
     # endregion
 
@@ -203,12 +217,16 @@ class IStatements[T: Table](ABC):
     @overload
     def select_one(self) -> T: ...
     @overload
-    def select_one(self, *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[tuple]) -> tuple: ...
+    def select_one[TFlavour](self, *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[TFlavour]) -> TFlavour: ...
     @overload
     def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> T1: ...
     @overload
     def select_one[*Ts](self, selector: Callable[[T], tuple[*Ts]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[*Ts]: ...
     @overload
+    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type) -> T1: ...
+    @overload
+    def select_one[T1, TFlavour](self, selector: Callable[[T], T1], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[TFlavour]) -> T1: ...
+    @overload
     def select_one[*Ts](self, selector: Callable[[T], tuple[*Ts]], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[tuple]) -> tuple[*Ts]: ...
     @overload
     def select_one[TFlavour](self, selector: Callable[[T], tuple], *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[TFlavour]) -> TFlavour: ...

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/common/interfaces/__init__.py

@@ -1,4 +1,4 @@
 from .IQueryCommand import IQuery  # noqa: F401
 from .INonQueryCommand import INonQueryCommand  # noqa: F401
 from .IRepositoryBase import IRepositoryBase  # noqa: F401
-from .IStatements import IStatements,IStatements_two_generic  # noqa: F401
+from .IStatements import IStatements, IStatements_two_generic  # noqa: F401

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/components/delete/abstract_delete.py

@@ -1,9 +1,12 @@
+from __future__ import annotations
 from abc import abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda import Table, IRepositoryBase
+from ormlambda.common.abstract_classes import NonQueryBase
 
 from .IDelete import IDelete
-from ...utils import Table
-from ...common.interfaces import IRepositoryBase
-from ...common.abstract_classes import NonQueryBase
 
 
 class DeleteQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IDelete[T]):

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/components/insert/IInsert.py

@@ -3,4 +3,4 @@ from abc import ABC, abstractmethod
 
 class IInsert[T](ABC):
     @abstractmethod
-    def insert(self, instances: T | list[T])->None: ...
+    def insert(self, instances: T | list[T]) -> None: ...

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/components/insert/abstract_insert.py

@@ -1,12 +1,16 @@
+from __future__ import annotations
 from abc import abstractmethod
-from ...utils import Table
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from ormlambda import Table
+    from ormlambda import IRepositoryBase
+
+from ormlambda.common.abstract_classes import NonQueryBase
 from .IInsert import IInsert
-from ...common.interfaces import IRepositoryBase
-from ...common.abstract_classes import NonQueryBase
 
 
-class InsertQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, IRepositoryBase], IInsert[T]):
+class InsertQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IInsert[T]):
     def __init__(self, model: T, repository: TRepo) -> None:
         super().__init__(model, repository)
 

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/components/select/ISelect.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 
-from ...common.interfaces import IQuery
+from ormlambda.common.interfaces import IQuery
 from .table_column import TableColumn
 
 

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/components/select/table_column.py

@@ -1,5 +1,9 @@
+from __future__ import annotations
 from typing import Any, Iterator
-from ...utils import Table
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 
 class TableColumn:

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/components/update/IUpdate.py

@@ -4,4 +4,4 @@ from typing import Any
 
 class IUpdate(ABC):
     @abstractmethod
-    def update(self, dicc: dict[str|property, Any]) -> None: ...
+    def update(self, dicc: dict[str | property, Any]) -> None: ...

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/components/update/__init__.py

@@ -1,2 +1,2 @@
 from .abstract_update import UpdateQueryBase  # noqa: F401
-from .IUpdate import IUpdate  # noqa: F401
+from .IUpdate import IUpdate  # noqa: F401

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/components/update/abstract_update.py

@@ -1,11 +1,15 @@
+from __future__ import annotations
 from abc import abstractmethod
-from typing import Any, Optional
+from typing import Any, Optional, TYPE_CHECKING
+
+from ormlambda.components.where import AbstractWhere
+from ormlambda.common.abstract_classes import NonQueryBase
+
+if TYPE_CHECKING:
+    from ormlambda import IRepositoryBase
+    from ormlambda import Table
 
 from .IUpdate import IUpdate
-from ..where import AbstractWhere
-from ...common.interfaces import IRepositoryBase
-from ...common.abstract_classes import NonQueryBase
-from ...utils import Table
 
 
 class UpdateQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IUpdate):

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/components/upsert/__init__.py

@@ -1,2 +1,2 @@
 from .abstract_upsert import UpsertQueryBase  # noqa: F401
-from .IUpsert import IUpsert  # noqa: F401
+from .IUpsert import IUpsert  # noqa: F401

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/components/upsert/abstract_upsert.py

@@ -1,9 +1,13 @@
+from __future__ import annotations
 from abc import abstractmethod
-from .IUpsert import IUpsert
-from ...common.interfaces import IRepositoryBase
-from ...common.abstract_classes import NonQueryBase
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda import IRepositoryBase
+    from ormlambda import Table
 
-from ...utils import Table
+from ormlambda.common.abstract_classes import NonQueryBase
+from .IUpsert import IUpsert
 
 
 class UpsertQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IUpsert[T]):

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/components/where/abstract_where.py

@@ -1,7 +1,11 @@
+from __future__ import annotations
 from abc import abstractmethod
-from ...utils import Table
+from typing import TYPE_CHECKING
 
-from ...common.interfaces import IQuery
+if TYPE_CHECKING:
+    from ormlambda import Table
+
+from ormlambda.common.interfaces import IQuery
 
 
 class AbstractWhere(IQuery):

{ormlambda-1.5.0 → ormlambda-2.0.2}/src/ormlambda/databases/my_sql/clauses/__init__.py

@@ -11,3 +11,4 @@ from .select import SelectQuery  # noqa: F401
 from .update import UpdateQuery  # noqa: F401
 from .upsert import UpsertQuery  # noqa: F401
 from .where_condition import WhereCondition  # noqa: F401
+from .count import CountQuery  # noqa: F401