ormlambda 3.34.0__tar.gz → 3.34.1__tar.gz

{ormlambda-3.34.0 → ormlambda-3.34.1}/PKG-INFO

@@ -1,13 +1,12 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: ormlambda
-Version: 3.34.0
+Version: 3.34.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
-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

{ormlambda-3.34.0 → ormlambda-3.34.1}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.34.0"
+version = "3.34.1"
 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.34.1/src/ormlambda/databases/__init__.py

@@ -0,0 +1,4 @@
+from .my_sql import (
+    MySQLCaster as MySQLCaster,
+    MySQLRepository as MySQLRepository,
+)

ormlambda-3.34.1/src/ormlambda/databases/my_sql/__init__.py

@@ -0,0 +1,3 @@
+from mysql.connector import MySQLConnection  # noqa: F401
+from .repository import MySQLRepository  # noqa: F401
+from .caster import MySQLCaster  # noqa: F401

{ormlambda-3.34.0/src/ormlambda/dialects/mysql → ormlambda-3.34.1/src/ormlambda/databases/my_sql}/caster/caster.py

@@ -12,11 +12,13 @@ from .types import (
     BytesCaster,
     IterableCaster,
     BooleanCaster,
+    DecimalCaster,
 )
 
 from shapely import Point
 from types import NoneType
-from datetime import datetime
+from datetime import datetime, date
+from decimal import Decimal
 
 
 class MySQLCaster(Caster):
@@ -31,9 +33,11 @@ class MySQLCaster(Caster):
             Point: PointCaster,
             NoneType: NoneTypeCaster,
             datetime: DatetimeCaster,
+            date: DatetimeCaster,
             bytes: BytesCaster,
             bytearray: BytesCaster,
             tuple: IterableCaster,
             list: IterableCaster,
             bool: BooleanCaster,
+            Decimal: DecimalCaster,
         }

{ormlambda-3.34.0/src/ormlambda/dialects/mysql → ormlambda-3.34.1/src/ormlambda/databases/my_sql}/caster/types/__init__.py

@@ -7,3 +7,5 @@ from .datetime import DatetimeCaster as DatetimeCaster
 from .bytes import BytesCaster as BytesCaster
 from .iterable import IterableCaster as IterableCaster
 from .boolean import BooleanCaster as BooleanCaster
+from .date import DateCaster as DateCaster
+from .decimal import DecimalCaster as DecimalCaster

ormlambda-3.34.1/src/ormlambda/databases/my_sql/caster/types/date.py

@@ -0,0 +1,34 @@
+from typing import Optional
+from ormlambda.caster import BaseCaster, Caster
+from datetime import datetime
+from .string import StringCaster
+
+
+class DateCaster[TType](BaseCaster[datetime, TType]):
+    def __init__(self, value: datetime, type_value: TType):
+        super().__init__(value, type_value)
+
+    def wildcard_to_select(self, value: Optional[str] = None) -> str:
+        return Caster.PLACEHOLDER if value is None else value
+
+    def wildcard_to_where(self, value: Optional[str] = None) -> str:
+        return Caster.PLACEHOLDER if value is None else value
+
+    def wildcard_to_insert(self, value: Optional[str] = None) -> str:
+        return Caster.PLACEHOLDER if value is None else value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def to_database(self) -> Optional[datetime]:
+        return self.value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def from_database(self) -> Optional[datetime]:
+        return self.value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def string_data(self) -> Optional[str]:
+        datetime_string = self.value.strftime(r"%Y-%m-%d")
+        return StringCaster(datetime_string, str).string_data

ormlambda-3.34.1/src/ormlambda/databases/my_sql/caster/types/decimal.py

@@ -0,0 +1,32 @@
+from typing import Optional
+from ormlambda.caster import BaseCaster, Caster
+from decimal import Decimal
+
+
+class DecimalCaster[TType](BaseCaster[Decimal, TType]):
+    def __init__(self, value: Decimal, type_value: TType):
+        super().__init__(value, type_value)
+
+    def wildcard_to_select(self, value: Optional[str] = None) -> str:
+        return Caster.PLACEHOLDER if value is None else value
+
+    def wildcard_to_where(self, value: Optional[str] = None) -> str:
+        return Caster.PLACEHOLDER if value is None else value
+
+    def wildcard_to_insert(self, value: Optional[str] = None) -> str:
+        return Caster.PLACEHOLDER if value is None else value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def to_database(self) -> Optional[Decimal]:
+        return Decimal(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def from_database(self) -> Optional[Decimal]:
+        return Decimal(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def string_data(self) -> Optional[str]:
+        return str(self.value)

{ormlambda-3.34.0/src/ormlambda/dialects/mysql → ormlambda-3.34.1/src/ormlambda/databases/my_sql}/clauses/__init__.py

@@ -1,4 +1,5 @@
 from .delete import DeleteQuery as Delete
+from .drop_table import DropTable as DropTable
 from .insert import InsertQuery as Insert
 from .joins import JoinSelector as JoinSelector
 from .limit import Limit as Limit

ormlambda-3.34.1/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.34.0/src/ormlambda/dialects/mysql/repository → ormlambda-3.34.1/src/ormlambda/databases/my_sql}/repository.py

@@ -10,6 +10,7 @@ from mysql.connector.pooling import MySQLConnectionPool  # noqa: F401
 from ormlambda.repository import BaseRepository
 
 # Custom libraries
+from .clauses import DropTable
 from ormlambda.repository.response import Response
 from ormlambda.caster import Caster
 
@@ -166,6 +167,10 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
                 cursor.execute(query)
         return None
 
+    @override
+    def drop_table(self, name: str) -> None:
+        return DropTable(self).execute(name)
+
     @override
     def database_exists(self, name: str) -> bool:
         temp_config = self._pool._cnx_config

ormlambda-3.34.1/src/ormlambda/dialects/mysql/__init__.py

@@ -0,0 +1,8 @@
+from . import base
+from . import mysqlconnector
+
+# default dialect
+base.dialect = dialect = mysqlconnector.dialect
+
+
+from .types import *  # noqa: F403

{ormlambda-3.34.0 → ormlambda-3.34.1}/src/ormlambda/dialects/mysql/base.py

@@ -38,8 +38,7 @@ from .types import (
 )
 from ormlambda.sql.sqltypes import BLOB
 
-from .caster import MySQLCaster
-from .repository import MySQLRepository
+from ormlambda.databases.my_sql import MySQLRepository, MySQLCaster
 
 
 if TYPE_CHECKING:

{ormlambda-3.34.0 → ormlambda-3.34.1}/src/ormlambda/engine/base.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
-from pathlib import Path
-from typing import TYPE_CHECKING, BinaryIO, Literal, Optional, TextIO
+from typing import TYPE_CHECKING, Literal
 from ormlambda.engine import url
-from ormlambda.sql.ddl import CreateSchema, DropSchema, CreateBackup
+from ormlambda.sql.ddl import CreateSchema, DropSchema
+
 
 if TYPE_CHECKING:
     from ormlambda.dialects import Dialect
@@ -20,7 +20,7 @@ class Engine:
         if if_exists == "replace":
             self.drop_schema(schema_name, if_exists)
 
-        sql = CreateSchema(schema=schema_name, if_not_exists=if_exists == "append").compile(self.dialect).string
+        sql = CreateSchema(schema=schema_name, if_not_exists=if_exists== 'append').compile(self.dialect).string
         try:
             self.repository.execute(sql)
         except Exception:
@@ -56,22 +56,3 @@ class Engine:
     def set_database(self, name: str) -> None:
         self.repository.database = name
         return None
-
-    def create_backup(
-        self,
-        output: Optional[str | BinaryIO | TextIO] = None,
-        compress: bool = False,
-        backup_dir: str = "backups",
-        **kw,
-    ) -> Optional[str | BinaryIO | Path]:
-        return (
-            CreateBackup(self.url)
-            .compile(
-                self.dialect,
-                output=output,
-                compress=compress,
-                backup_dir=backup_dir,
-                **kw,
-            )
-            .string
-        )

{ormlambda-3.34.0 → ormlambda-3.34.1}/src/ormlambda/repository/interfaces/IRepositoryBase.py

@@ -9,8 +9,12 @@ from typing import (
     Sequence,
     Type,
     Iterable,
+    TYPE_CHECKING,
 )
 
+if TYPE_CHECKING:
+    from ormlambda.statements.types import TypeExists
+
 
 type _DBAPICursorDescription = Sequence[
     tuple[
@@ -138,6 +142,9 @@ class IRepositoryBase(ABC):
     @abstractmethod
     def execute(self, query: str) -> None: ...
 
+    @abstractmethod
+    def drop_table(self, name: str) -> None: ...
+
     @abstractmethod
     def table_exists(self, name: str) -> bool: ...
 

{ormlambda-3.34.0 → ormlambda-3.34.1}/src/ormlambda/sql/compiler.py

@@ -1,13 +1,6 @@
 from __future__ import annotations
 import abc
-import datetime
-import io
-import logging
-import os
-from pathlib import Path
-import subprocess
-import sys
-from typing import Any, BinaryIO, ClassVar, Optional, TYPE_CHECKING, TextIO, Union
+from typing import Any, ClassVar, Optional, TYPE_CHECKING
 
 from ormlambda.sql.ddl import CreateColumn
 from ormlambda.sql.foreign_key import ForeignKey
@@ -22,13 +15,7 @@ if TYPE_CHECKING:
     from .visitors import Element
     from .elements import ClauseElement
     from ormlambda.dialects import Dialect
-    from ormlambda.sql.ddl import (
-        CreateTable,
-        CreateSchema,
-        DropSchema,
-        DropTable,
-        CreateBackup,
-    )
+    from ormlambda.sql.ddl import CreateTable, CreateSchema, DropSchema
     from .sqltypes import (
         INTEGER,
         SMALLINTEGER,
@@ -75,12 +62,6 @@ if TYPE_CHECKING:
     )
 
 
-type customString = Union[str | Path]
-
-logging.basicConfig(stream=sys.stdout, level=logging.INFO)
-log = logging.getLogger(__name__)
-
-
 class Compiled:
     """Represent a compiled SQL or DDL expression.
 
@@ -268,9 +249,6 @@ class DDLCompiler(Compiled):
         sql += f"\n){table_options};"
         return sql
 
-    def visit_drop_table(self, drop: DropTable, **kw) -> str:
-        return "DROP TABLE " + drop.element.__table_name__
-
     def visit_create_column(self, create: CreateColumn, first_pk=False, **kw):  # noqa: F821
         column = create.element
         return self.get_column_specification(column)
@@ -295,225 +273,6 @@ class DDLCompiler(Compiled):
             return None
         return None
 
-    #TODOH []: refactor in order to improve clarity
-    def visit_create_backup(
-        self,
-        backup: CreateBackup,
-        output: Optional[Union[Path | str, BinaryIO, TextIO]] = None,
-        compress: bool = False,
-        backup_dir: customString = ".",
-        **kw,
-    ) -> Optional[str | BinaryIO | Path]:
-        """
-        Create MySQL backup with flexible output options
-
-        Args:
-            backup: An object containing database connection details (host, user, password, database, port).
-            output: Output destination:
-                - None: Auto-generate file path
-                - str: Custom file path (treated as a path-like object)
-                - Stream object: Write to stream (io.StringIO, io.BytesIO, sys.stdout, etc.)
-            compress: Whether to compress the output using gzip.
-            backup_dir: Directory for auto-generated files if 'output' is None.
-
-        Returns:
-            - File path (str) if output to file.
-            - Backup data as bytes (if output to binary stream) or string (if output to text stream).
-            - None if an error occurs.
-        """
-
-        host = backup.url.host
-        user = backup.url.username
-        password = backup.url.password
-        database = backup.url.database
-        port = backup.url.port
-
-        if not database:
-            log.error("Error: Database name is required for backup.")
-            return None
-
-        # Build mysqldump command
-        command = [
-            "mysqldump",
-            f"--host={host}",
-            f"--port={port}",
-            f"--user={user}",
-            f"--password={password}",
-            "--single-transaction",
-            "--routines",
-            "--triggers",
-            "--events",
-            "--lock-tables=false",  # Often used to avoid locking during backup
-            "--add-drop-table",
-            "--extended-insert",
-            database,
-        ]
-
-        def export_to_stream_internal() -> Optional[io.BytesIO]:
-            nonlocal command, compress, database
-            # If streaming, execute mysqldump and capture stdout
-            log.info(f"Backing up database '{database}' to BytesIO...")
-
-            try:
-                if compress:
-                    # Start mysqldump process
-                    mysqldump_process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-
-                    # Start gzip process, taking input from mysqldump
-                    gzip_process = subprocess.Popen(["gzip", "-c"], stdin=mysqldump_process.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-
-                    # Close mysqldump stdout in parent process - gzip will handle it
-                    mysqldump_process.stdout.close()
-
-                    # Wait for gzip to complete (which will also wait for mysqldump)
-                    gzip_stdout, gzip_stderr = gzip_process.communicate()
-
-                    # Wait for mysqldump to finish and get its stderr
-                    mysqldump_stderr = mysqldump_process.communicate()[1]
-
-                    if mysqldump_process.returncode != 0:
-                        log.error(f"mysqldump error: {mysqldump_stderr.decode().strip()}")
-                        return None
-                    if gzip_process.returncode != 0:
-                        log.error(f"gzip error: {gzip_stderr.decode().strip()}")
-                        return None
-
-                    log.info("Backup successful and compressed to BytesIO.")
-                    return io.BytesIO(gzip_stdout)
-                else:
-                    # Directly capture mysqldump output
-                    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                    stdout, stderr = process.communicate()
-
-                    if process.returncode != 0:
-                        log.error(f"mysqldump error: {stderr.decode().strip()}")
-                        return None
-
-                    log.info("Backup successful to BytesIO.")
-                    return io.BytesIO(stdout)
-
-            except FileNotFoundError as e:
-                log.error(f"Error: '{e.filename}' command not found. Please ensure mysqldump (and gzip if compressing) is installed and in your system's PATH.")
-                return None
-            except Exception as e:
-                log.error(f"An unexpected error occurred during streaming backup: {e}")
-                return None
-
-        def export_to_file_internal(file_path: customString) -> Optional[Path]:
-            nonlocal command, compress, database
-
-            if isinstance(file_path, str):
-                file_path = Path(file_path)
-
-            if not file_path.exists():
-                file_path.parent.mkdir(parents=True, exist_ok=True)
-                file_path.touch()
-
-            try:
-                if compress:
-                    # Pipe mysqldump output through gzip to file
-                    with open(file_path, "wb") as output_file:
-                        # Start mysqldump process
-                        mysqldump_process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-
-                        # Start gzip process, taking input from mysqldump and writing to file
-                        gzip_process = subprocess.Popen(["gzip", "-c"], stdin=mysqldump_process.stdout, stdout=output_file, stderr=subprocess.PIPE)
-
-                        # Close mysqldump stdout in parent process - gzip will handle it
-                        mysqldump_process.stdout.close()
-
-                        # Wait for gzip to complete (which will also wait for mysqldump)
-                        gzip_stdout, gzip_stderr = gzip_process.communicate()
-
-                        # Wait for mysqldump to finish and get its stderr
-                        mysqldump_stderr = mysqldump_process.communicate()[1]
-
-                        if mysqldump_process.returncode != 0:
-                            log.error(f"mysqldump error: {mysqldump_stderr.decode().strip()}")
-                            return None
-                        if gzip_process.returncode != 0:
-                            log.error(f"gzip error: {gzip_stderr.decode().strip()}")
-                            return None
-                else:
-                    # Directly redirect mysqldump output to file
-                    with open(file_path, "wb") as output_file:
-                        process = subprocess.Popen(command, stdout=output_file, stderr=subprocess.PIPE)
-                        stdout, stderr = process.communicate()
-
-                        if process.returncode != 0:
-                            log.error(f"mysqldump error: {stderr.decode().strip()}")
-                            return None
-
-                log.info(f"Backup completed successfully: {file_path}")
-                return file_path
-
-            except FileNotFoundError as e:
-                log.error(f"Error: '{e.filename}' command not found. Please ensure mysqldump (and gzip if compressing) is installed and in your system's PATH.")
-                return None
-            except Exception as e:
-                log.error(f"An unexpected error occurred during file backup: {e}")
-                return None
-
-        try:
-            if output is None:
-                # Auto-generate file path
-
-                backup_dir = Path(backup_dir)
-                backup_dir.mkdir(exist_ok=True)
-
-                timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-                file_extension = "sql.gz" if compress else "sql"
-                output_filename = f"{database}_backup_{timestamp}.{file_extension}"
-                output_filepath = os.path.join(backup_dir, output_filename)
-                return export_to_file_internal(output_filepath)
-
-            elif isinstance(output, (io.BytesIO, io.StringIO)):
-                # Output to a stream object
-                stream_result = export_to_stream_internal()
-                if stream_result:
-                    # Write the content from the internal BytesIO to the provided output stream
-                    if isinstance(output, io.BytesIO):
-                        output.write(stream_result.getvalue())
-                        return stream_result.getvalue()  # Return bytes if it was a BytesIO internally
-                    elif isinstance(output, io.StringIO):
-                        # Attempt to decode bytes to string if target is StringIO
-                        try:
-                            decoded_content = stream_result.getvalue().decode("utf-8")
-                            output.write(decoded_content)
-                            return decoded_content
-                        except UnicodeDecodeError:
-                            log.error("Error: Cannot decode byte stream to UTF-8 for StringIO output. Consider setting compress=False or ensuring database encoding is compatible.")
-                            return None
-                return None
-
-            elif isinstance(output, str | Path):
-                # Output to a custom file path
-                return export_to_file_internal(output)
-
-            elif isinstance(output, (BinaryIO, TextIO)):  # Handles sys.stdout, open file objects
-                stream_result = export_to_stream_internal()
-                if stream_result:
-                    if "b" in getattr(output, "mode", "") or isinstance(output, BinaryIO):  # Check if it's a binary stream
-                        output.write(stream_result.getvalue())
-                        return stream_result.getvalue()
-                    else:  # Assume text stream
-                        try:
-                            decoded_content = stream_result.getvalue().decode("utf-8")
-                            output.write(decoded_content)
-                            return decoded_content
-                        except UnicodeDecodeError:
-                            log.error("Error: Cannot decode byte stream to UTF-8 for text stream output. Consider setting compress=False or ensuring database encoding is compatible.")
-                            return None
-                return None
-
-            else:
-                log.error(f"Unsupported output type: {type(output)}")
-                return None
-
-        except Exception as e:
-            log.error(f"An unexpected error occurred: {e}")
-            return None
-
 
 class GenericTypeCompiler(TypeCompiler):
     """Generic type compiler

{ormlambda-3.34.0 → ormlambda-3.34.1}/src/ormlambda/sql/ddl.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING
 from .elements import ClauseElement
 
 if TYPE_CHECKING:
-    from ormlambda import URL
     from ormlambda.dialects.interface.dialect import Dialect
     from ormlambda import Column
     from ormlambda import Table
@@ -23,22 +22,16 @@ class BaseDDLElement(ClauseElement):
         return dialect.ddl_compiler(dialect, self, **kw)
 
 
-class CreateDropTable:
-    def __init__(self, element: Table):
-        self.element = element
-        self.columns = [CreateColumn(c) for c in element.get_columns()]
-
-
-class CreateTable(CreateDropTable, BaseDDLElement):
+class CreateTable(BaseDDLElement):
     """
     Class representing a CREATE TABLE statement.
     """
 
     __visit_name__ = "create_table"
 
-
-class DropTable(CreateDropTable, BaseDDLElement):
-    __visit_name__ = "drop_table"
+    def __init__(self, element: Table):
+        self.element = element
+        self.columns = [CreateColumn(c) for c in element.get_columns()]
 
 
 class CreateColumn[T](BaseDDLElement):
@@ -73,10 +66,3 @@ class SchemaExists(BaseDDLElement):
 
     def __init__(self, schema: str):
         self.schema = schema
-
-
-class CreateBackup(BaseDDLElement):
-    __visit_name__ = "create_backup"
-
-    def __init__(self, url: URL):
-        self.url = url

{ormlambda-3.34.0 → ormlambda-3.34.1}/src/ormlambda/sql/foreign_key.py

@@ -36,14 +36,6 @@ class ForeignKeyContext(set["ForeignKey"]):
 class ForeignKey[TLeft: Table, TRight: Table](Element, IQuery):
     __visit_name__ = "foreign_key"
 
-    __slots__ = (
-        "_tright",
-        "_relationship",
-        "_comparer",
-        "_clause_name",
-        "_keep_alive",
-    )
-
     stored_calls: ClassVar[ForeignKeyContext] = ForeignKeyContext()
 
     @overload
@@ -157,13 +149,3 @@ class ForeignKey[TLeft: Table, TRight: Table](Element, IQuery):
         comparer.set_context(context)
         comparer._dialect = dialect
         return comparer
-
-    def __hash__(self):
-        return hash((
-            self._tleft,
-            self._tright,
-            self._clause_name,
-        ))
-
-    def __eq__(self, other: ForeignKey):
-        return hash(other) == hash(self)

{ormlambda-3.34.0 → ormlambda-3.34.1}/src/ormlambda/sql/table/table.py

@@ -5,9 +5,10 @@ import json
 from ormlambda.sql import Column
 from ormlambda.sql import ForeignKey
 from ormlambda.util.module_tree.dfs_traversal import DFSTraversal
-from ormlambda.sql.ddl import CreateTable, DropTable
+from ormlambda.sql.ddl import CreateTable
 
 if TYPE_CHECKING:
+    from ormlambda.statements import BaseStatement
     from ormlambda.dialects import Dialect
 
 from .table_constructor import __init_constructor__
@@ -114,14 +115,17 @@ class Table(metaclass=TableMeta):
             if name == key:
                 return value
 
+    @classmethod
+    def create_table_query(cls, statement: BaseStatement) -> str:
+        """It's classmethod because of it does not matter the columns values to create the table"""
+        from ormlambda.sql.schema_generator import SchemaGeneratorFactory
+
+        return SchemaGeneratorFactory.get_generator(statement._dialect).create_table(cls)
+
     @classmethod
     def create_table(cls, dialect: Dialect) -> str:
         return CreateTable(cls).compile(dialect).string
 
-    @classmethod
-    def drop_table(cls, dialect:Dialect)->str:
-        return DropTable(cls).compile(dialect).string
-    
     @classmethod
     def find_dependent_tables(cls) -> tuple["Table", ...]:
         """Work in progress"""

{ormlambda-3.34.0 → ormlambda-3.34.1}/src/ormlambda/statements/interfaces/IStatements.py

@@ -37,9 +37,6 @@ class IStatements[T: Table](Element):
     @abstractmethod
     def create_table(self, if_exists: TypeExists = "fail") -> None: ...
 
-    @abstractmethod
-    def drop_table(self) -> None: ...
-
     # #TODOL [ ]: We must to implement this mehtod
     # @abstractmethod
     # def drop_table(self)->None: ...