ormlambda 3.11.0__tar.gz → 3.11.2__tar.gz

{ormlambda-3.11.0 → ormlambda-3.11.2}/PKG-INFO

@@ -1,12 +1,13 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: ormlambda
-Version: 3.11.0
+Version: 3.11.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
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: mysql-connector-python (>=9.0.0,<10.0.0)
 Requires-Dist: shapely (>=2.0.6,<3.0.0)
 Description-Content-Type: text/markdown
@@ -69,10 +70,12 @@ Once the `AddressModel` class is created, we will not only be able to access all
 
 ```python
 from models.address import Address
+from ormlambda import create_engine, ORM
+
+db = create_engine('mysql://root:1234@localhost:3306/sakila')
 
-db = MySQLRepository(**config_dict)
 
-AddressModel = ORM(Address,db)
+AddressModel = ORM(Address, db)
 
 result = AddressModel.where(Address.City.Country.country.regex(r"^[aA]")).select(
     lambda address: (
@@ -360,10 +363,11 @@ class AddressCombine(BaseModel):
 
     model_config: ConfigDict = {"extra": "forbid"}
 
-ddbb = MySQLRepository(**config_dict)
-model = ORM(Address, ddbb)
+db = create_engine('mysql://root:1234@localhost:3306/sakila')
+
 select = (
-    model.order(lambda x: x.City.Country.country, "DESC")
+    ORM(Address, db)
+    .order(lambda x: x.City.Country.country, "DESC")
     .limit(10)
     .where(Address.City.Country.country == "Spain")
     .first(

{ormlambda-3.11.0 → ormlambda-3.11.2}/README.md

@@ -56,10 +56,12 @@ Once the `AddressModel` class is created, we will not only be able to access all
 
 ```python
 from models.address import Address
+from ormlambda import create_engine, ORM
+
+db = create_engine('mysql://root:1234@localhost:3306/sakila')
 
-db = MySQLRepository(**config_dict)
 
-AddressModel = ORM(Address,db)
+AddressModel = ORM(Address, db)
 
 result = AddressModel.where(Address.City.Country.country.regex(r"^[aA]")).select(
     lambda address: (
@@ -347,10 +349,11 @@ class AddressCombine(BaseModel):
 
     model_config: ConfigDict = {"extra": "forbid"}
 
-ddbb = MySQLRepository(**config_dict)
-model = ORM(Address, ddbb)
+db = create_engine('mysql://root:1234@localhost:3306/sakila')
+
 select = (
-    model.order(lambda x: x.City.Country.country, "DESC")
+    ORM(Address, db)
+    .order(lambda x: x.City.Country.country, "DESC")
     .limit(10)
     .where(Address.City.Country.country == "Spain")
     .first(

{ormlambda-3.11.0 → ormlambda-3.11.2}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.11.0"
+version = "3.11.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"

{ormlambda-3.11.0 → ormlambda-3.11.2}/src/ormlambda/__init__.py

@@ -21,4 +21,4 @@ from .model.base_model import (
     ORM as ORM,
 )  # COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler
 
-from .engine import create_engine, URL  # noqa: F401
+from .engine import create_engine, URL, make_url # noqa: F401

{ormlambda-3.11.0 → ormlambda-3.11.2}/src/ormlambda/caster/caster.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 PLACEHOLDER: str = "%s"
 
 
-class Caster[TRepo]:
+class Caster:
     def __init__(self, repository: IRepositoryBase):
         self._repository: IRepositoryBase = repository
         self._caster = RepositoryTemplateDict().get(repository).caster

{ormlambda-3.11.0 → ormlambda-3.11.2}/src/ormlambda/databases/my_sql/clauses/delete.py

@@ -6,7 +6,6 @@ if TYPE_CHECKING:
 from ormlambda import Table
 from ormlambda.repository import IRepositoryBase
 from ormlambda.components.delete import DeleteQueryBase
-from mysql.connector import MySQLConnection
 
 
 class DeleteQuery[T: Table](DeleteQueryBase[T, IRepositoryBase]):

{ormlambda-3.11.0 → ormlambda-3.11.2}/src/ormlambda/databases/my_sql/functions/max.py

@@ -14,7 +14,7 @@ class Max(AggregateFunctionBase[None]):
 
     def __init__[TProp](
         self,
-        elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
+        elements: ColumnType[TProp],
         alias_clause: AliasType[ColumnType[TProp]] = "max",
         context: ClauseContextType = None,
     ):

{ormlambda-3.11.0 → ormlambda-3.11.2}/src/ormlambda/databases/my_sql/statements.py

@@ -11,9 +11,11 @@ from mysql.connector import MySQLConnection
 
 
 if TYPE_CHECKING:
+    from ormlambda.sql.types import AliasType
     from ormlambda import Table
     from ormlambda.statements.types import OrderTypes
     from ormlambda.sql.types import ColumnType
+    from ormlambda.statements.types import SelectCols
     from ormlambda.repository.interfaces import IRepositoryBase
     from ormlambda.statements.interfaces import IStatements_two_generic
     from ormlambda.repository.interfaces.IRepositoryBase import TypeExists
@@ -289,25 +291,23 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         return self
 
     @override
-    def count(
+    def count[TProp](
         self,
-        selection: None | Iterable[Table] | Callable[[T], tuple] = lambda x: "*",
-        alias_clause="count",
+        selection: None | SelectCols[T,TProp] = lambda x: "*",
+        alias="count",
         execute: bool = False,
     ) -> Optional[int]:
         if execute is True:
-            return self.select_one(self.count(selection, alias_clause, False), flavour=dict)[alias_clause]
+            return self.select_one(self.count(selection, alias, False), flavour=dict)[alias]
 
-        if GlobalChecker.is_lambda_function(selection):
-            selection = selection(*self.models)
-        return Count(element=selection, alias_clause=alias_clause, context=self._query_builder._context)
+        selection = GlobalChecker.resolved_callback_object(selection, self.models)
+        return Count(element=selection, alias_clause=alias, context=self._query_builder._context)
 
     @override
     def where(self, conditions: WhereTypes) -> IStatements_two_generic[T, MySQLConnection]:
         # FIXME [x]: I've wrapped self._model into tuple to pass it instance attr. Idk if it's correct
 
-        if GlobalChecker.is_lambda_function(conditions):
-            conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
+        conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
         if not isinstance(conditions, Iterable):
             conditions = (conditions,)
         self._query_builder.add_statement(Where(*conditions))
@@ -315,8 +315,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
 
     @override
     def having(self, conditions: WhereTypes) -> IStatements_two_generic[T, MySQLConnection]:
-        if GlobalChecker.is_lambda_function(conditions):
-            conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
+        conditions = GlobalChecker.resolved_callback_object(conditions, self._models)
         if not isinstance(conditions, Iterable):
             conditions = (conditions,)
         self._query_builder.add_statement(Having(*conditions))
@@ -324,13 +323,13 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
 
     @override
     def order[TValue](self, columns: Callable[[T], TValue], order_type: OrderTypes) -> IStatements_two_generic[T, MySQLConnection]:
-        query = GlobalChecker.resolved_callback_object(columns, self._models) if GlobalChecker.is_lambda_function(columns) else columns
+        query = GlobalChecker.resolved_callback_object(columns, self._models)
         order = Order(query, order_type)
         self._query_builder.add_statement(order)
         return self
 
     @override
-    def concat(self, selector: str | Callable[[T], str], alias: str = "CONCAT") -> IAggregate:
+    def concat(self, selector: SelectCols[T, str], alias: str = "concat") -> IAggregate:
         return func.Concat[T](
             values=selector,
             alias_clause=alias,
@@ -340,10 +339,11 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
     @override
     def max[TProp](
         self,
-        column: Callable[[T], TProp],
+        column: SelectCols[T, TProp],
         alias: str = "max",
         execute: bool = False,
-    ) -> TProp:
+    ) -> int:
+        column = GlobalChecker.resolved_callback_object(column, self.models)
         if execute is True:
             return self.select_one(self.max(column, alias, execute=False), flavour=dict)[alias]
         return func.Max(elements=column, alias_clause=alias, context=self._query_builder._context)
@@ -351,10 +351,11 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
     @override
     def min[TProp](
         self,
-        column: Callable[[T], TProp],
+        column: SelectCols[T, TProp],
         alias: str = "min",
         execute: bool = False,
-    ) -> TProp:
+    ) -> int:
+        column = GlobalChecker.resolved_callback_object(column, self.models)
         if execute is True:
             return self.select_one(self.min(column, alias, execute=False), flavour=dict)[alias]
         return func.Min(elements=column, alias_clause=alias, context=self._query_builder._context)
@@ -362,10 +363,11 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
     @override
     def sum[TProp](
         self,
-        column: Callable[[T], TProp],
+        column: SelectCols[T, TProp],
         alias: str = "sum",
         execute: bool = False,
-    ) -> TProp:
+    ) -> int:
+        column = GlobalChecker.resolved_callback_object(column, self.models)
         if execute is True:
             return self.select_one(self.sum(column, alias, execute=False), flavour=dict)[alias]
         return func.Sum(elements=column, alias_clause=alias, context=self._query_builder._context)
@@ -384,7 +386,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         by: JoinType = JoinType.INNER_JOIN,
         **kwargs,
     ):
-        select_clause = GlobalChecker.resolved_callback_object(selector, self._models) if GlobalChecker.is_lambda_function(selector) else selector
+        select_clause = GlobalChecker.resolved_callback_object(selector, self._models)
 
         if selector is None:
             # 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
@@ -463,7 +465,7 @@ class MySQLStatements[T: Table, *Ts](BaseStatement[T, MySQLConnection]):
         return self
 
     @override
-    def alias[TProp](self, column: ColumnType[TProp], alias: str) -> ClauseInfo[T, TProp]:
+    def alias[TProp](self, column: ColumnType[TProp], alias: AliasType[ClauseInfo[T]]) -> ClauseInfo[T]:
         return Alias(
             table=column.table,
             column=column,

{ormlambda-3.11.0 → ormlambda-3.11.2}/src/ormlambda/engine/__init__.py

@@ -1,2 +1,2 @@
 from .create import create_engine  # noqa: F401
-from .url import URL  # noqa: F401
+from .url import URL, make_url  # noqa: F401

{ormlambda-3.11.0 → ormlambda-3.11.2}/src/ormlambda/statements/interfaces/IStatements.py

@@ -4,7 +4,6 @@ from enum import Enum
 from abc import abstractmethod, ABC
 
 
-from ormlambda.common.enums import JoinType
 
 if TYPE_CHECKING:
     from ormlambda.repository import BaseRepository
@@ -12,6 +11,10 @@ if TYPE_CHECKING:
     from ormlambda.sql.clause_info import IAggregate
     from ormlambda.sql.types import TupleJoinType, ColumnType
     from ormlambda.databases.my_sql.join_context import JoinContext
+    from ormlambda.common.enums import JoinType
+    from ormlambda.sql.clause_info import ClauseInfo
+    from ormlambda.sql.types import AliasType
+
 
 from ..types import (
     OrderTypes,
@@ -27,10 +30,9 @@ from ..types import (
     Select10,
     TypeExists,
     WhereTypes,
+    SelectCols,
 )
 
-type SelectCols[T, TProp] = Callable[[T], ColumnType[TProp]] | ColumnType[TProp]
-
 
 class IStatements[T: Table](ABC):
     @abstractmethod
@@ -132,12 +134,12 @@ class IStatements[T: Table](ABC):
     # endregion
     # region count
     @abstractmethod
-    def count(
+    def count[TProp](
         self,
-        selection: Callable[[T], tuple] = ...,
-        alias_clause="count",
+        selection: None | SelectCols[T, TProp] = ...,
+        alias: str = ...,
         execute: bool = False,
-    ) -> Optional[IStatements[T]]: ...
+    ) -> Optional[int]: ...
 
     # endregion
     # region delete
@@ -174,45 +176,41 @@ class IStatements[T: Table](ABC):
 
     # endregion
     # region order
-    @overload
-    def order[TValue](self, _lambda_col: Callable[[T], TValue]) -> IStatements[T]: ...
-    @overload
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderTypes) -> IStatements[T]: ...
     @abstractmethod
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderTypes) -> IStatements[T]: ...
+    def order[TValue](self, columns: SelectCols[T, TValue], order_type: OrderTypes) -> IStatements[T]: ...
 
     # endregion
     # region concat
     @overload
-    def concat(self, selector: Callable[[T], str], alias: str = "CONCAT") -> IAggregate: ...
+    def concat(self, selector: SelectCols[T, str], alias: str = "concat") -> IAggregate: ...
 
     # endregion
     # region max
-    @overload
+    @abstractmethod
     def max[TProp](
         self,
         column: SelectCols[T, TProp],
         alias: Optional[str] = ...,
-        execute: bool = ...,
-    ) -> TProp: ...
+        execute: bool = False,
+    ) -> int: ...
     # endregion
     # region min
-    @overload
+    @abstractmethod
     def min[TProp](
         self,
         column: SelectCols[T, TProp],
         alias: Optional[str] = ...,
-        execute: bool = ...,
-    ) -> TProp: ...
+        execute: bool = False,
+    ) -> int: ...
     # endregion
     # region sum
-    @overload
+    @abstractmethod
     def sum[TProp](
         self,
         column: SelectCols[T, TProp],
         alias: Optional[str] = ...,
-        execute: bool = ...,
-    ) -> TProp: ...
+        execute: bool = False,
+    ) -> int: ...
 
     @overload
     def join[FKTable](self, joins: TupleJoinType[FKTable] | tuple[*TupleJoinType[FKTable]]) -> JoinContext[tuple[*TupleJoinType[FKTable]]]: ...
@@ -324,7 +322,7 @@ class IStatements[T: Table](ABC):
     # endregion
 
     @abstractmethod
-    def alias(self, column: Callable[[T], Any], alias: str) -> IStatements[T]: ...
+    def alias[TProp](self, column: ColumnType[TProp], alias: AliasType[ClauseInfo[T]]) -> ClauseInfo[T]: ...
 
 
 class IStatements_two_generic[T, TPool](IStatements[T]):

{ormlambda-3.11.0 → ormlambda-3.11.2}/src/ormlambda/statements/types.py

@@ -10,10 +10,10 @@ from typing import (
 import enum
 
 
-from ormlambda.common.enums import JoinType
-
 if TYPE_CHECKING:
+    from ormlambda.common.enums import JoinType
     from ormlambda.sql.comparer import Comparer
+    from ormlambda.sql.types import ColumnType
 
 type OrderTypes = Literal["ASC", "DESC"] | OrderType | Iterable[OrderType]
 
@@ -52,3 +52,6 @@ type WhereTypes[LTable, LProp, RTable, RProp] = Union[
     tuple[Comparer[LTable, LProp, RTable, RProp], ...],
     Callable[[LTable], WhereTypes[LTable, LProp, RTable, RProp]],
 ]
+
+
+type SelectCols[T, TProp] = Callable[[T], ColumnType[TProp]] | ColumnType[TProp]

ormlambda-3.11.0/src/ormlambda/databases/my_sql/caster/read.py

@@ -1,39 +0,0 @@
-from datetime import datetime
-from typing import Optional
-from shapely import Point
-from types import NoneType
-from ormlambda.common.abstract_classes.caster.cast_base import ReadCastBase
-
-
-from .types.datetime import MySQLReadDatetime
-from .types.string import MySQLReadString
-from .types.int import MySQLReadInt
-from .types.float import MySQLReadFloat
-from .types.point import MySQLReadPoint
-from .types.none import MySQLReadNoneType
-
-
-class MySQLReadCastBase(ReadCastBase):
-    @staticmethod
-    def cast_str(value: str) -> str:
-        return MySQLReadString.cast(value)
-
-    @staticmethod
-    def cast_int(value: str) -> int:
-        return MySQLReadInt.cast(value)
-
-    @staticmethod
-    def cast_float(value: str) -> float:
-        return MySQLReadFloat.cast(value)
-
-    @staticmethod
-    def cast_Point(value: str) -> Point:
-        return MySQLReadPoint.cast(value)
-
-    @staticmethod
-    def cast_NoneType(value: str) -> NoneType:
-        return MySQLReadNoneType.cast(value)
-
-    @staticmethod
-    def cast_datetime(value: str) -> datetime:
-        return MySQLReadDatetime.cast(value)

ormlambda-3.11.0/src/ormlambda/databases/my_sql/caster/write.py

@@ -1,37 +0,0 @@
-from datetime import datetime
-from shapely import Point
-from types import NoneType
-from ormlambda.common.abstract_classes.caster.cast_base import WriteCastBase
-
-from .types.datetime import MySQLWriteDatetime
-from .types.string import MySQLWriteString
-from .types.int import MySQLWriteInt
-from .types.float import MySQLWriteFloat
-from .types.point import MySQLWritePoint
-from .types.none import MySQLWriteNoneType
-
-
-class MySQLWriteCastBase(WriteCastBase):
-    @staticmethod
-    def cast_str(value: str, insert_data: bool = False) -> str:
-        return MySQLWriteString.cast(value, insert_data)
-
-    @staticmethod
-    def cast_int(value: int, insert_data: bool = False) -> str:
-        return MySQLWriteInt.cast(value, insert_data)
-
-    @staticmethod
-    def cast_float(value: float, insert_data: bool = False) -> str:
-        return MySQLWriteFloat.cast(value, insert_data)
-
-    @staticmethod
-    def cast_Point(value: Point, insert_data: bool = False) -> str:
-        return MySQLWritePoint.cast(value, insert_data)
-
-    @staticmethod
-    def cast_NoneType(value: NoneType, insert_data: bool = False) -> str:
-        return MySQLWriteNoneType.cast(value, insert_data)
-
-    @staticmethod
-    def cast_datetime(value: datetime, insert_data: bool = False) -> str:
-        return MySQLWriteDatetime.cast(value, insert_data)