ormlambda 3.11.1__tar.gz → 3.12.2__tar.gz

ormlambda-3.11.1/README.md → ormlambda-3.12.2/PKG-INFO

@@ -1,3 +1,17 @@
+Metadata-Version: 2.3
+Name: ormlambda
+Version: 3.12.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
+
 ![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)
@@ -56,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 = MySQLRepository(**config_dict)
+db = create_engine('mysql://root:1234@localhost:3306/sakila')
 
-AddressModel = ORM(Address,db)
+
+AddressModel = ORM(Address, db)
 
 result = AddressModel.where(Address.City.Country.country.regex(r"^[aA]")).select(
     lambda address: (
@@ -300,7 +316,7 @@ res = AddressModel.count(Address.address_id, execute=True)
 
 The `concat` method allows you to concatenate multiple columns or values into a single string. This is particularly useful for creating derived fields in your queries.
 
-#### Usage
+### Usage
 
 ```python
 response = ORM(Address, db).where(Address.City.Country.country.regex(r"^Spain")).first(
@@ -331,6 +347,60 @@ As you can see in the response, the result is a dictionary where the keys are a
 
 Another elegant approach to adjust the response and obtain an object is by using the `flavour` attribute. You can pass a callable object, which will be used to instantiate it with the returned data.
 
+
+## 2. Group by
+
+The `groupby` method is used to filter results based on aggregate functions.
+
+### Usage
+```python
+from ormlambda import Column, ORM, create_engine
+from test.config import DATABASE_URL
+
+
+class Response(BaseModel):
+    district: str
+    count: int
+
+engine= create_engine(DATABASE_URL)
+model = ORM(Address,engine)
+
+count_name = Column(column_name="count")
+
+res = (
+    self.model
+    .groupby(Address.district)
+    .select(
+        (
+            Address.district,
+            self.model.count(Address.address),
+        ),
+        flavour=Response,
+    )
+)
+```
+
+## 3. Having
+
+The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
+
+### Usage
+```python
+res = (
+    model
+    .groupby(Address.district)
+    .having(count_name > 4)
+    .select(
+        (
+            Address.district,
+            model.count(Address.address),
+        ),
+        flavour=Response,
+    )
+)
+```
+
+
 ## Using BaseModel for Custom Responses (Pydantic)
 
 You can utilize `BaseModel` from Pydantic to create structured response models. This allows you to define the expected structure of your data, ensuring type safety and validation.
@@ -347,10 +417,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(
@@ -374,14 +445,6 @@ print(select.city)
 print(select.country)
 ```
 
-
-<!-- ### 2. Having
-
-The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
-
-#### Usage -->
-
-
 ## Combine aggregation method
 As shown in the previous examples, setting the `execute` attribute to `True` allows us to perform the corresponding query in a single line. However, if you're looking to improve efficiency, you can combine all of them into one query.
 ```python
@@ -420,4 +483,4 @@ AddressModel.select_one(
 #     "custom-max": 605,
 #     "count": 603,
 # }
-```
+```

ormlambda-3.11.1/PKG-INFO → ormlambda-3.12.2/README.md

@@ -1,16 +1,3 @@
-Metadata-Version: 2.1
-Name: ormlambda
-Version: 3.11.1
-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-python (>=9.0.0,<10.0.0)
-Requires-Dist: shapely (>=2.0.6,<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)
@@ -69,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 = MySQLRepository(**config_dict)
+db = create_engine('mysql://root:1234@localhost:3306/sakila')
 
-AddressModel = ORM(Address,db)
+
+AddressModel = ORM(Address, db)
 
 result = AddressModel.where(Address.City.Country.country.regex(r"^[aA]")).select(
     lambda address: (
@@ -313,7 +302,7 @@ res = AddressModel.count(Address.address_id, execute=True)
 
 The `concat` method allows you to concatenate multiple columns or values into a single string. This is particularly useful for creating derived fields in your queries.
 
-#### Usage
+### Usage
 
 ```python
 response = ORM(Address, db).where(Address.City.Country.country.regex(r"^Spain")).first(
@@ -344,6 +333,60 @@ As you can see in the response, the result is a dictionary where the keys are a
 
 Another elegant approach to adjust the response and obtain an object is by using the `flavour` attribute. You can pass a callable object, which will be used to instantiate it with the returned data.
 
+
+## 2. Group by
+
+The `groupby` method is used to filter results based on aggregate functions.
+
+### Usage
+```python
+from ormlambda import Column, ORM, create_engine
+from test.config import DATABASE_URL
+
+
+class Response(BaseModel):
+    district: str
+    count: int
+
+engine= create_engine(DATABASE_URL)
+model = ORM(Address,engine)
+
+count_name = Column(column_name="count")
+
+res = (
+    self.model
+    .groupby(Address.district)
+    .select(
+        (
+            Address.district,
+            self.model.count(Address.address),
+        ),
+        flavour=Response,
+    )
+)
+```
+
+## 3. Having
+
+The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
+
+### Usage
+```python
+res = (
+    model
+    .groupby(Address.district)
+    .having(count_name > 4)
+    .select(
+        (
+            Address.district,
+            model.count(Address.address),
+        ),
+        flavour=Response,
+    )
+)
+```
+
+
 ## Using BaseModel for Custom Responses (Pydantic)
 
 You can utilize `BaseModel` from Pydantic to create structured response models. This allows you to define the expected structure of your data, ensuring type safety and validation.
@@ -360,10 +403,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(
@@ -387,14 +431,6 @@ print(select.city)
 print(select.country)
 ```
 
-
-<!-- ### 2. Having
-
-The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
-
-#### Usage -->
-
-
 ## Combine aggregation method
 As shown in the previous examples, setting the `execute` attribute to `True` allows us to perform the corresponding query in a single line. However, if you're looking to improve efficiency, you can combine all of them into one query.
 ```python
@@ -433,4 +469,4 @@ AddressModel.select_one(
 #     "custom-max": 605,
 #     "count": 603,
 # }
-```
+```

{ormlambda-3.11.1 → ormlambda-3.12.2}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.11.1"
+version = "3.12.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.1 → ormlambda-3.12.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.1 → ormlambda-3.12.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.12.2/src/ormlambda/common/abstract_classes/clause_info_converter.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+import typing as tp
+from ormlambda import Table
+
+from ormlambda.sql.clause_info import ClauseInfo, AggregateFunctionBase
+from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+from ormlambda import ForeignKey
+
+from ormlambda.sql.types import AliasType, TableType, ColumnType
+
+
+class ClauseInfoConverter[T, TProp](tp.Protocol):
+    @classmethod
+    def convert(cls, data: T, alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[T]]: ...
+
+
+class ConvertFromAnyType(ClauseInfoConverter[None, None]):
+    @classmethod
+    def convert(cls, data: tp.Any, alias_table: AliasType = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
+        return [
+            ClauseInfo[None](
+                table=None,
+                column=data,
+                alias_table=alias_table,
+                alias_clause=kwargs.get("alias", None),
+                context=context,
+            )
+        ]
+
+
+class ConvertFromForeignKey[LT: Table, RT: Table](ClauseInfoConverter[RT, None]):
+    @classmethod
+    def convert(cls, data: ForeignKey[LT, RT], alias_table=None, context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[RT]]:
+        return ConvertFromTable[RT].convert(data.tright, data.alias, context, **kwargs)
+
+
+class ConvertFromColumn[TProp](ClauseInfoConverter[None, TProp]):
+    @classmethod
+    def convert(cls, data: ColumnType[TProp], alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
+        # COMMENT: if the property belongs to the main class, the columnn name in not prefixed. This only done if the property comes from any join.
+        attributes = {
+            "table": data.table,
+            "column": data,
+            "alias_table": alias_table,
+            "alias_clause": "{table}_{column}",
+            "context": context,
+            **kwargs,
+        }
+        clause_info = ClauseInfo[None](**attributes)
+        return [clause_info]
+
+
+class ConvertFromIAggregate(ClauseInfoConverter[None, None]):
+    @classmethod
+    def convert(cls, data: AggregateFunctionBase, alias_table=None, context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
+        return [data]
+
+
+class ConvertFromTable[T: Table](ClauseInfoConverter[T, None]):
+    @classmethod
+    def convert(cls, data: T, alias_table: AliasType[ColumnType] = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[T]]:
+        """
+        if the data is Table, means that we want to retrieve all columns
+        """
+        return cls._extract_all_clauses(data, alias_table, context, **kwargs)
+
+    @staticmethod
+    def _extract_all_clauses(table: TableType[T], alias_table: AliasType[ColumnType], context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[TableType[T]]]:
+        # all columns
+        column_clauses = []
+        for column in table.get_columns():
+            column_clauses.extend(ConvertFromColumn.convert(column, alias_table=alias_table, context=context, **kwargs))
+        return column_clauses

{ormlambda-3.11.1 → ormlambda-3.12.2}/src/ormlambda/common/abstract_classes/decomposition_query.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 import typing as tp
-import abc
 from ormlambda import Table, Column
 
 from ormlambda.common.interfaces import IDecompositionQuery, ICustomAlias
@@ -10,8 +9,15 @@ from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, Cla
 from ormlambda import ForeignKey
 from ormlambda.common.global_checker import GlobalChecker
 
-from ormlambda.sql.types import AliasType, TableType, ColumnType
-
+from ormlambda.sql.types import TableType, ColumnType
+from .clause_info_converter import (
+    ClauseInfoConverter,
+    ConvertFromAnyType,
+    ConvertFromForeignKey,
+    ConvertFromColumn,
+    ConvertFromIAggregate,
+    ConvertFromTable,
+)
 
 type TableTupleType[T, *Ts] = tuple[T:TableType, *Ts]
 type ValueType = tp.Union[
@@ -22,69 +28,6 @@ type ValueType = tp.Union[
 ]
 
 
-class ClauseInfoConverter[T, TProp](abc.ABC):
-    @classmethod
-    @abc.abstractmethod
-    def convert(cls, data: T, alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None) -> list[ClauseInfo[T]]: ...
-
-
-class ConvertFromAnyType(ClauseInfoConverter[None, None]):
-    @classmethod
-    def convert(cls, data: tp.Any, alias_table: AliasType = "{table}", context: ClauseContextType = None) -> list[ClauseInfo[None]]:
-        return [
-            ClauseInfo[None](
-                table=None,
-                column=data,
-                alias_table=alias_table,
-                alias_clause=None,
-                context=context,
-            )
-        ]
-
-
-class ConvertFromForeignKey[LT: Table, RT: Table](ClauseInfoConverter[RT, None]):
-    @classmethod
-    def convert(cls, data: ForeignKey[LT, RT], alias_table=None, context: ClauseContextType = None) -> list[ClauseInfo[RT]]:
-        return ConvertFromTable[RT].convert(data.tright, data.alias, context)
-
-
-class ConvertFromColumn[TProp](ClauseInfoConverter[None, TProp]):
-    @classmethod
-    def convert(cls, data: ColumnType[TProp], alias_table: AliasType[ColumnType[TProp]] = "{table}", context: ClauseContextType = None) -> list[ClauseInfo[None]]:
-        # COMMENT: if the property belongs to the main class, the columnn name in not prefixed. This only done if the property comes from any join.
-        clause_info = ClauseInfo[None](
-            table=data.table,
-            column=data,
-            alias_table=alias_table,
-            alias_clause="{table}_{column}",
-            context=context,
-        )
-        return [clause_info]
-
-
-class ConvertFromIAggregate(ClauseInfoConverter[None, None]):
-    @classmethod
-    def convert(cls, data: AggregateFunctionBase, alias_table=None, context: ClauseContextType = None) -> list[ClauseInfo[None]]:
-        return [data]
-
-
-class ConvertFromTable[T: Table](ClauseInfoConverter[T, None]):
-    @classmethod
-    def convert(cls, data: T, alias_table: AliasType[ColumnType] = "{table}", context: ClauseContextType = None) -> list[ClauseInfo[T]]:
-        """
-        if the data is Table, means that we want to retrieve all columns
-        """
-        return cls._extract_all_clauses(data, alias_table, context)
-
-    @staticmethod
-    def _extract_all_clauses(table: TableType[T], alias_table: AliasType[ColumnType], context: ClauseContextType = None) -> list[ClauseInfo[TableType[T]]]:
-        # all columns
-        column_clauses = []
-        for column in table.get_columns():
-            column_clauses.extend(ConvertFromColumn.convert(column, alias_table=alias_table, context=context))
-        return column_clauses
-
-
 class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
     @tp.overload
     def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType]) -> None: ...
@@ -93,7 +36,8 @@ class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
     @tp.overload
     def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], alias_table: str, context: ClauseContextType = ...) -> None: ...
 
-    def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], alias_table: str = "{table}", *, context: ClauseContextType = ClauseInfoContext()) -> None:
+    def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], alias_table: str = "{table}", *, context: ClauseContextType = ClauseInfoContext(), **kwargs) -> None:
+        self.kwargs = kwargs
         self._tables: tuple[TableType[T]] = tables if isinstance(tables, tp.Iterable) else (tables,)
 
         self._columns: tp.Callable[[T], tuple] = columns
@@ -145,7 +89,7 @@ class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
         }
         classConverter = next((converter for obj, converter in VALUE_TYPE_MAPPED.items() if validation(data, obj)), ConvertFromAnyType)
 
-        return classConverter.convert(data, alias_table=self._alias_table, context=self._context)
+        return classConverter.convert(data, alias_table=self._alias_table, context=self._context, **self.kwargs)
 
     def __add_clause[TTable: TableType](self, clauses: list[ClauseInfo[TTable]] | ClauseInfo[TTable]) -> None:
         if not isinstance(clauses, tp.Iterable):

{ormlambda-3.11.1 → ormlambda-3.12.2}/src/ormlambda/common/abstract_classes/non_query_base.py

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

{ormlambda-3.11.1 → ormlambda-3.12.2}/src/ormlambda/common/interfaces/ICustomAlias.py

@@ -1,4 +1,4 @@
-from ormlambda.common.interfaces import IDecompositionQuery
+# from ormlambda.common.interfaces import IDecompositionQuery
 
 
 class ICustomAlias[T, *Ts]: ...

{ormlambda-3.11.1 → ormlambda-3.12.2}/src/ormlambda/components/delete/abstract_delete.py

@@ -3,13 +3,13 @@ from abc import abstractmethod
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from ormlambda import Table, IRepositoryBase
+    from ormlambda import Table, BaseRepository
 from ormlambda.common.abstract_classes import NonQueryBase
 
 from .IDelete import IDelete
 
 
-class DeleteQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IDelete[T]):
+class DeleteQueryBase[T: Table, TRepo: BaseRepository](NonQueryBase[T, TRepo], IDelete[T]):
     def __init__(self, model: T, repository: TRepo) -> None:
         super().__init__(model, repository)
 

ormlambda-3.12.2/src/ormlambda/components/join/__init__.py

@@ -0,0 +1 @@
+from .join_context import JoinContext, TupleJoinType  # noqa: F401

{ormlambda-3.11.1 → ormlambda-3.12.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.12.2/src/ormlambda/databases/my_sql/clauses/drop_table.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from typing import Literal, override, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mysql.connector import MySQLConnection
+
+from ormlambda.repository import BaseRepository
+
+
+TypeExists = Literal["fail", "replace", "append"]
+
+
+class DropTable:
+    def __init__(self, repository: BaseRepository[MySQLConnection]) -> None:
+        self._repository: BaseRepository[MySQLConnection] = repository
+
+    @override
+    def execute(self, name: str = None) -> None:
+        query = rf"{self.CLAUSE} {name}"
+        self._repository.execute(query)
+        return None
+
+    @property
+    @override
+    def CLAUSE(self) -> str:
+        return "DROP TABLE"

{ormlambda-3.11.1 → ormlambda-3.12.2}/src/ormlambda/databases/my_sql/clauses/group_by.py

@@ -1,7 +1,6 @@
 import typing as tp
 from ormlambda import Table
-from ormlambda.sql.clause_info.clause_info import AggregateFunctionBase
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
+from ormlambda.sql.clause_info import AggregateFunctionBase, ClauseInfoContext
 from ormlambda.sql.types import ColumnType
 
 

{ormlambda-3.11.1 → ormlambda-3.12.2}/src/ormlambda/databases/my_sql/clauses/select.py

@@ -21,11 +21,13 @@ class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ISelect):
         *,
         alias_table: AliasType[ClauseInfo] = "{table}",
         context: Optional[ClauseInfoContext] = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             tables,
             columns,
             context=context,
+            **kwargs,
         )
         self._alias_table = alias_table
         # We always need to add the self alias of the Select

{ormlambda-3.11.1 → ormlambda-3.12.2}/src/ormlambda/databases/my_sql/clauses/upsert.py

@@ -1,15 +1,19 @@
-from typing import override, Any
+from __future__ import annotations
+from typing import override, TYPE_CHECKING
 
 from ormlambda import Table
 from ormlambda.components.upsert import UpsertQueryBase
-from ormlambda.repository import IRepositoryBase
-from mysql.connector import MySQLConnection
+from ormlambda.repository import IRepositoryBase, BaseRepository
+
 
 from .insert import InsertQuery
 
+if TYPE_CHECKING:
+    from mysql.connector import MySQLConnection
+
 
 class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase]):
-    def __init__(self, model: T, repository: Any) -> None:
+    def __init__(self, model: T, repository: BaseRepository[MySQLConnection]) -> None:
         super().__init__(model, repository)
 
     @override