sibi-dst 0.3.45__py3-none-any.whl → 0.3.46__py3-none-any.whl

sibi_dst/v2/df_helper/backends/sqlalchemy/__init__.py

@@ -0,0 +1,10 @@
+from ._db_connection import SqlAlchemyConnectionConfig
+from ._model_builder import SqlAlchemyModelBuilder
+from ._load_from_db import SqlAlchemyLoadFromDb
+
+__all__ = [
+    'SqlAlchemyConnectionConfig',
+    'SqlAlchemyModelBuilder',
+    'SqlAlchemyLoadFromDb',
+]
+

sibi_dst/v2/df_helper/backends/sqlalchemy/_db_connection.py

@@ -0,0 +1,82 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel, model_validator, ConfigDict
+from sqlalchemy import create_engine, text
+from sqlalchemy.engine import Engine
+from sqlalchemy.exc import OperationalError
+
+from sibi_dst.v2.utils import Logger
+from ._model_builder import SqlAlchemyModelBuilder
+
+
+class SqlAlchemyConnectionConfig(BaseModel):
+    """
+    Configuration for establishing an SQLAlchemy database connection and dynamically building
+    an ORM model for a specific table.
+
+    Attributes:
+        connection_url (str): The URL used to connect to the database.
+        table_name (Optional[str]): The name of the table for which the model will be built.
+        model (Any): The dynamically built SQLAlchemy model.
+        engine (Optional[Engine]): The SQLAlchemy engine instance.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    connection_url: str
+    table: Optional[str] = None
+    model: Any = None
+    engine: Optional[Engine] = None
+    debug: bool = False
+    logger: Optional[Logger] = None
+    add_relationships: bool = False
+    export_models: bool = False
+    export_file_name: str = 'models.py'
+
+    @model_validator(mode="after")
+    def validate_and_initialize(self) -> "SqlAlchemyConnectionConfig":
+        """
+        Validate the configuration, initialize the engine, test the connection, and build the model.
+
+        Raises:
+            ValueError: If `connection_url` or `table_name` is missing, or if the connection or model
+                        building fails.
+        """
+        self.logger = self.logger or Logger.default_logger(logger_name="sqlalchemy_connection", debug=self.debug)
+        self.logger.debug("Validating and initializing SQLAlchemy connection configuration.")
+        if not self.connection_url:
+            raise ValueError("`connection_url` must be provided.")
+
+        # Initialize the engine.
+        self.engine = create_engine(self.connection_url)
+        self.logger.debug(f"Engine created for URL")
+
+        # Validate the connection.
+        self.validate_connection()
+
+        if not self.table:
+            raise ValueError("`table` must be provided to build the model.")
+
+        try:
+            builder = SqlAlchemyModelBuilder(self.engine, self.table, self.add_relationships, self.debug, self.logger)
+            self.model = builder.build_model()
+            if self.export_models:
+                builder.export_models_to_file(self.export_file_name)
+            self.logger.debug(f"Successfully built model for table: {self.table}")
+        except Exception as e:
+            raise ValueError(f"Failed to build model for table {self.table}: {e}")
+
+        return self
+
+    def validate_connection(self) -> None:
+        """
+        Test the database connection by executing a simple query.
+
+        Raises:
+            ValueError: If the connection cannot be established.
+        """
+        try:
+            with self.engine.connect() as connection:
+                connection.execute(text("SELECT 1"))
+            self.logger.debug("Database connection validated.")
+        except OperationalError as e:
+            raise ValueError(f"Failed to connect to the database: {e}")

sibi_dst/v2/df_helper/backends/sqlalchemy/_io_dask.py

@@ -0,0 +1,135 @@
+import itertools
+
+import dask.dataframe as dd
+import pandas as pd
+from sqlalchemy import create_engine, inspect, select
+from sqlalchemy.orm import sessionmaker
+
+from sibi_dst.v2.df_helper.core import FilterHandler
+from sibi_dst.v2.utils import Logger
+
+
+class SQLAlchemyDask:
+    def __init__(self, model, filters, engine_url, chunk_size=1000, logger=None, debug=False):
+        """
+        Initialize with an SQLAlchemy query and database engine URL.
+
+        :param model: SQLAlchemy ORM model.
+        :param filters: Filters to apply on the query.
+        :param engine_url: Database connection string for SQLAlchemy engine.
+        :param chunk_size: Number of records per chunk for Dask partitions.
+        :param logger: Logger instance for logging.
+        :param debug: Whether to print detailed logs.
+        """
+        self.query = None
+        self.model = model
+        self.filters = filters
+        self.chunk_size = chunk_size
+        self.debug = debug
+        self.engine = create_engine(engine_url)
+        self.Session = sessionmaker(bind=self.engine)
+        self.logger = logger or Logger.default_logger(logger_name=self.__class__.__name__)
+        self.logger.set_level(logger.DEBUG if debug else logger.INFO)
+
+    @staticmethod
+    def infer_dtypes_from_model(model):
+        """
+        Infer data types for Dask DataFrame based on SQLAlchemy ORM model columns.
+        """
+        mapper = inspect(model)
+        sqlalchemy_to_dask_dtype = {
+            'INTEGER': 'Int64',
+            'SMALLINT': 'Int64',
+            'BIGINT': 'Int64',
+            'FLOAT': 'float64',
+            'NUMERIC': 'float64',
+            'BOOLEAN': 'bool',
+            'VARCHAR': 'object',
+            'TEXT': 'object',
+            'DATE': 'datetime64[ns]',
+            'DATETIME': 'datetime64[ns]',
+            'TIME': 'object',
+            'UUID': 'object',
+        }
+
+        dtypes = {}
+        for column in mapper.columns:
+            dtype = sqlalchemy_to_dask_dtype.get(str(column.type).upper(), 'object')
+            dtypes[column.name] = dtype
+
+        return dtypes
+
+    def read_frame(self, fillna_value=None):
+        """
+        Load data from an SQLAlchemy query into a Dask DataFrame.
+
+        :param fillna_value: Value to replace NaN or NULL values with, if any.
+        :return: Dask DataFrame.
+        """
+        with self.Session() as session:
+            try:
+                # Build query
+                self.query = select(self.model)
+                if self.filters:
+                    self.query = FilterHandler(backend="sqlalchemy", logger=self.logger, debug=self.debug).apply_filters(self.query,
+                                                                                                       model=self.model,
+                                                                                                       filters=self.filters)
+                else:
+                    n_records = 100
+                    self.query = self.query.limit(n_records)
+                self.logger.debug(f"query:{self.query}")
+                # Infer dtypes
+                dtypes = self.infer_dtypes_from_model(self.model)
+                # Get the column order from the SQLAlchemy model
+                ordered_columns = [column.name for column in self.model.__table__.columns]
+
+                # Execute query and fetch results in chunks
+                result_proxy = session.execute(self.query)
+                results = result_proxy.scalars().all()  # Fetch all rows
+                iterator = iter(results)
+
+                partitions = []
+
+                while True:
+                    chunk = list(itertools.islice(iterator, self.chunk_size))
+                    if not chunk:
+                        break
+
+                    # Convert chunk to Pandas DataFrame
+                    df = pd.DataFrame.from_records(
+                        [row._asdict() if hasattr(row, '_asdict') else row.__dict__ for row in chunk]
+                    )
+                    # Drop internal SQLAlchemy state if it exists
+                    df = df.loc[:, ~df.columns.str.contains('_sa_instance_state')]
+
+                    # Reorder columns to match the model's order
+                    df = df[ordered_columns]
+
+                    # Fill NaN values
+                    if fillna_value is not None:
+                        df = df.fillna(fillna_value)
+
+                    # Convert timezone-aware columns to naive
+                    for col in df.columns:
+                        if isinstance(df[col].dtype, pd.DatetimeTZDtype):
+                            df[col] = df[col].dt.tz_localize(None)
+
+                    # Apply inferred dtypes
+                    df = df.astype(dtypes)
+                    # Create a Dask partition
+                    partitions.append(dd.from_pandas(df, npartitions=1))
+
+                # Concatenate all partitions
+                if partitions:
+                    dask_df = dd.concat(partitions, axis=0, ignore_index=True)
+                else:
+                    dask_df = dd.from_pandas(pd.DataFrame(columns=ordered_columns), npartitions=1)
+
+                self.logger.debug(f"Loaded {len(dask_df)} rows into Dask DataFrame.")
+
+                return dask_df
+
+            except Exception as e:
+                self.logger.error(f"Error executing query: {str(e)}")
+                self.logger.error(self.query)
+                return dd.from_pandas(pd.DataFrame(columns=ordered_columns), npartitions=1)

sibi_dst/v2/df_helper/backends/sqlalchemy/_load_from_db.py

@@ -0,0 +1,142 @@
+import dask.dataframe as dd
+import pandas as pd
+
+from sibi_dst.v2.df_helper.core import ParamsConfig, QueryConfig
+from sibi_dst.v2.utils import Logger
+from ._io_dask import SQLAlchemyDask
+from ._db_connection import SqlAlchemyConnectionConfig
+
+
+class SqlAlchemyLoadFromDb:
+    """
+    The SqlAlchemyLoadFromDb class provides functionality to load data from a
+    database using SQLAlchemy into a Dask DataFrame. It is capable of handling
+    large datasets efficiently by utilizing the Dask framework for parallel
+    computations.
+
+    This class is initialized with a database connection configuration, query
+    configuration, optional parameters, and a logger. It can execute a query
+    using the specified configurations and read the results into a Dask
+    DataFrame. This is useful for processing and analyzing large-scale data.
+
+    :ivar df: Dask DataFrame to store the loaded data.
+    :type df: dd.DataFrame
+    :ivar db_connection: Database connection configuration object, containing details
+        such as the table, model, and engine to be used for the query.
+    :type db_connection: SqlAlchemyConnectionConfig
+    :ivar table_name: Name of the database table being queried.
+    :type table_name: str
+    :ivar model: SQLAlchemy model associated with the database connection.
+    :type model: sqlalchemy.ext.declarative.api.DeclarativeMeta
+    :ivar engine: SQLAlchemy engine used for executing queries.
+    :type engine: sqlalchemy.engine.base.Engine
+    :ivar logger: Logger instance for logging debug and error information.
+    :type logger: Logger
+    :ivar query_config: Query configuration, including query-related details such
+        as the SQL query or query settings.
+    :type query_config: QueryConfig
+    :ivar params_config: Parameters configuration, including filter parameters for
+        the query.
+    :type params_config: ParamsConfig
+    :ivar debug: Debug flag indicating whether debug mode is enabled.
+    :type debug: bool
+    :ivar chunk_size: Size of data chunks to process at a time.
+    :type chunk_size: int
+    """
+    df: dd.DataFrame = None
+
+    def __init__(
+            self,
+            plugin_sqlalchemy: SqlAlchemyConnectionConfig,  # Expected to be an instance of SqlAlchemyConnection
+            plugin_query: QueryConfig = None,
+            plugin_params: ParamsConfig = None,
+            debug: bool = False,
+            logger: Logger = None,
+            **kwargs,
+    ):
+        """
+        Initializes an instance of the class, setting up a database connection,
+        query configuration, parameter configuration, and other optional settings
+        like debugging and logging. The class aims to manage the integration and
+        interaction with SQLAlchemy-based database operations.
+
+        :param plugin_sqlalchemy:
+            The SQLAlchemy connection configuration object, which provides
+            the connection details like engine, table name, and model
+            associated with the database operations.
+        :param plugin_query:
+            The query configuration object, used to define specific query
+            options or rules. Defaults to None.
+        :param plugin_params:
+            The parameters configuration object, used for any additional
+            parameterized settings or configurations. Defaults to None.
+        :param logger:
+            Optional logger instance for logging purposes. If not provided,
+            a default logger is instantiated using the standard logging system.
+        :param kwargs:
+            Optional additional keyword arguments for customization. Can
+            include optional settings like `debug` mode or `chunk_size`
+            for batch operations.
+        """
+        self.db_connection = plugin_sqlalchemy
+        self.table_name = self.db_connection.table
+        self.model = self.db_connection.model
+        self.engine = self.db_connection.engine
+        self.debug = debug
+        self.logger = logger or Logger.default_logger(logger_name=self.__class__.__name__, debug=self.debug)
+        self.query_config = plugin_query
+        self.params_config = plugin_params
+        self.chunk_size = kwargs.pop("chunk_size", 1000)
+
+    def build_and_load(self) -> dd.DataFrame:
+        """
+        Builds and returns the resulting dataframe after calling the internal
+        build and load function. This method triggers the `_build_and_load`
+        function to process and prepare the data before returning it as
+        a dask dataframe.
+
+        :raises RuntimeError: If any error occurs during the build or load process.
+
+        :return: The processed data in a dask dataframe.
+        :rtype: dd.DataFrame
+        """
+        self._build_and_load()
+        return self.df
+
+    def _build_and_load(self) -> dd.DataFrame:
+        """
+        Builds and loads a Dask DataFrame from a SQLAlchemy-compatible source.
+
+        This method initializes a SQLAlchemyDask object with the provided model,
+        filters, engine URL, logger, chunk size, and debug configuration.
+        It attempts to load the data using the ``read_frame`` method of
+        SQLAlchemyDask. If the data cannot be loaded or the query returns
+        no rows, it creates and returns an empty Dask DataFrame.
+
+        :raises Exception: On failure to load data or to create a DataFrame.
+
+        :return: A Dask DataFrame object containing the queried data or an
+                 empty DataFrame if the query returns no results or fails.
+        :rtype: dask.dataframe.DataFrame
+        """
+        try:
+            self.df = SQLAlchemyDask(
+                model=self.model,
+                filters=self.params_config.filters,
+                engine_url=self.engine.url,
+                logger=self.logger,
+                chunk_size=self.chunk_size,
+                debug=self.debug
+            ).read_frame()
+
+            if self.df is None or len(self.df.head().index) == 0:
+                self.logger.debug("Query returned no results.")
+                dask_df = dd.from_pandas(pd.DataFrame(), npartitions=1)
+
+                return dask_df
+            return self.df
+        except Exception as e:
+            self.logger.debug(f"Failed to load data into Dask DataFrame.{e}")
+            dask_df = dd.from_pandas(pd.DataFrame(), npartitions=1)
+
+            return dask_df

sibi_dst/v2/df_helper/backends/sqlalchemy/_model_builder.py

@@ -0,0 +1,297 @@
+import re
+from collections import defaultdict
+from typing import Dict, Any, Type
+
+from sqlalchemy import MetaData, Table, and_
+from sqlalchemy import inspect
+from sqlalchemy.engine import Engine
+from sqlalchemy.exc import ArgumentError, NoForeignKeysError
+from sqlalchemy.orm import declarative_base, relationship, foreign, configure_mappers, clear_mappers
+
+from sibi_dst.v2.utils import Logger
+
+# Base class for dynamically created models.
+Base = declarative_base()
+
+# Constants.
+APPS_LABEL = "datacubes"
+RESERVED_COLUMN_NAMES = {"metadata", "class_", "table"}
+RESERVED_KEYWORDS = {"class", "def", "return", "yield", "global"}
+
+# Global registry keyed by the original table name (snake_case).
+MODEL_REGISTRY: Dict[str, Type] = {}
+
+
+class SqlAlchemyModelBuilder:
+    """
+    Dynamically builds an ORM model for a single table by reflecting its columns
+    and reverse-engineering its relationships from foreign key metadata.
+
+    In add_relationships(), the builder groups FKs by related table, then uses SQLAlchemy's
+    inspect() to retrieve the remote model's mapped columns (instead of accessing __table__ directly).
+    This ensures that the columns used in the join condition are actually present on the mapped models.
+    """
+
+    def __init__(self, engine: Engine, table_name: str, add_relationships: bool = False, debug: bool = False,
+                 logger: Logger = None) -> None:
+        self.engine = engine
+        self.table_name = table_name
+        self.add_relationships = add_relationships
+        self.debug = debug
+        self.logger = logger or Logger.default_logger(logger_name="sqlalchemy_model_builder", debug=self.debug)
+        self.metadata = MetaData()
+        # Try to reflect the specified table.
+        try:
+            self.metadata.reflect(only=[table_name], bind=self.engine)
+        except Exception as e:
+            self.logger.warning(f"Could not reflect table '{table_name}': {e}. Skipping model build.")
+            self.table = None
+        else:
+            self.table = self.metadata.tables.get(table_name)
+            if self.table is None:
+                self.logger.warning(f"Table '{table_name}' not found in the database. Skipping model build.")
+        # Generate a CamelCase model name.
+
+        self.model_name: str = self.normalize_class_name(table_name)
+
+    def build_model(self) -> Type:
+        try:
+            self.metadata.reflect(only=[self.table_name], bind=self.engine)
+        except Exception as e:
+            self.logger.warning(
+                f"Could not reflect table '{self.table_name}': {e}. Skipping model build."
+            )
+            return None
+
+        self.table = self.metadata.tables.get(self.table_name)
+        if self.table is None:
+            self.logger.warning(
+                f"Table '{self.table_name}' not found in the database. Skipping model build."
+            )
+            return None
+        columns = self.get_columns(self.table)
+        attrs: Dict[str, Any] = {
+            "__tablename__": self.table_name,
+            "__table__": self.table,
+            "__module__": f"{APPS_LABEL}.models",
+            "__mapper_args__": {"eager_defaults": True},
+        }
+        attrs.update(columns)
+        if self.add_relationships:
+            self._add_relationships(attrs, self.table)
+        model = type(self.model_name, (Base,), attrs)
+        MODEL_REGISTRY[self.table_name] = model
+        # Validate relationships by forcing SQLAlchemy to configure all mappers.
+        try:
+            configure_mappers()
+            self.logger.debug(f"Successfully configured mappers for model {self.model_name}.")
+        except Exception as e:
+            self.logger.error(f"Mapper configuration error for model {self.model_name}: {e}")
+            # Optionally, you could remove or adjust relationships here before proceeding.
+            raise ValueError(f"Invalid relationship configuration in model {self.model_name}: {e}") from e
+
+        self.logger.debug(f"Created model {self.model_name} for table {self.table_name} with relationships.")
+        return model
+
+    def get_columns(self, table: Table) -> Dict[str, Any]:
+        cols: Dict[str, Any] = {}
+        for column in table.columns:
+            norm_name = self.normalize_column_name(column.name)
+            if norm_name not in RESERVED_COLUMN_NAMES:
+                cols[norm_name] = column
+        return cols
+
+    def _add_relationships(self, attrs: Dict[str, Any], table: Table) -> None:
+        """
+        Groups foreign keys by related table name and builds explicit join conditions.
+        For each group, it uses the first FK to define foreign_keys and remote_side.
+        Uses SQLAlchemy’s inspect() to obtain the remote model's mapped columns.
+        Temporarily adds the relationship, forces mapper configuration, and if the relationship
+        fails configuration (for example, if the FK column is not marked as a foreign key on either side),
+        the relationship is removed.
+        """
+        inspector = inspect(self.engine)
+        fk_info_list = inspector.get_foreign_keys(self.table.name)
+
+        fk_groups = defaultdict(list)
+        for fk_info in fk_info_list:
+            referred_table = fk_info.get("referred_table")
+            if referred_table:
+                fk_groups[referred_table].append(fk_info)
+
+        for related_table_name, fk_dicts in fk_groups.items():
+            # Ensure the remote model is built.
+            try:
+                if related_table_name not in MODEL_REGISTRY:
+                    self.logger.debug(f"Building missing model for related table {related_table_name}.")
+                    remote_model = SqlAlchemyModelBuilder(
+                        self.engine,
+                        related_table_name,
+                        add_relationships=False,  # Skip recursive relationship building.
+                        debug=self.debug,
+                        logger=self.logger
+                    ).build_model()
+                    if related_table_name not in MODEL_REGISTRY or remote_model is None:
+                        raise ValueError(f"Failed to build model for table {related_table_name}.")
+                else:
+                    remote_model = MODEL_REGISTRY[related_table_name]
+            except Exception as e:
+                self.logger.warning(f"Could not build model for table {related_table_name}: {e}")
+                continue
+
+            # Get the mapper directly.
+            remote_mapper = remote_model.__mapper__
+            join_conditions = []
+            local_foreign_keys = []
+            remote_side_keys = []
+
+            # Build join conditions from FK dictionaries.
+            for fk_info in fk_dicts:
+                local_cols = fk_info.get("constrained_columns", [])
+                remote_cols = fk_info.get("referred_columns", [])
+                if not local_cols or not remote_cols:
+                    self.logger.warning(
+                        f"Incomplete foreign key definition for table {related_table_name} in table {self.table_name}."
+                    )
+                    continue
+
+                local_col_name = local_cols[0]
+                remote_col_name = remote_cols[0]
+
+                try:
+                    local_col = self.table.c[local_col_name]
+                except KeyError:
+                    self.logger.warning(
+                        f"Local column {local_col_name} not found in table {self.table_name}. Skipping FK."
+                    )
+                    continue
+
+                try:
+                    remote_col = remote_mapper.columns[remote_col_name]
+                except KeyError:
+                    self.logger.warning(
+                        f"Remote column {remote_col_name} not found in model {remote_model.__name__}. Skipping FK."
+                    )
+                    continue
+
+                # --- Extra Validation Step ---
+                # Ensure the local column is actually defined as a foreign key.
+                if not local_col.foreign_keys:
+                    self.logger.warning(
+                        f"Local column {local_col_name} in table {self.table_name} is not defined as a foreign key. Skipping relationship."
+                    )
+                    continue
+                # Optionally, check that the remote column is part of the remote table.
+                if remote_col.name not in remote_model.__table__.columns.keys():
+                    self.logger.warning(
+                        f"Remote column {remote_col_name} is not present in table for model {remote_model.__name__}. Skipping relationship."
+                    )
+                    continue
+
+                # Annotate the local column as foreign.
+                join_conditions.append(foreign(local_col) == remote_col)
+                local_foreign_keys.append(local_col)
+                remote_side_keys.append(remote_col)
+
+            if not join_conditions:
+                self.logger.warning(
+                    f"No valid join conditions for relationship from {self.table_name} to {related_table_name}."
+                )
+                continue
+
+            primaryjoin_expr = join_conditions[0] if len(join_conditions) == 1 else and_(*join_conditions)
+            relationship_name = self.normalize_column_name(related_table_name)
+            if relationship_name in attrs:
+                continue
+
+            # --- Temporarily add the relationship with the fixed lambda ---
+            try:
+                attrs[relationship_name] = relationship(
+                    lambda rt=related_table_name: MODEL_REGISTRY[rt],
+                    primaryjoin=primaryjoin_expr,
+                    foreign_keys=local_foreign_keys,
+                    remote_side=remote_side_keys,
+                    lazy="joined",
+                    viewonly=True  # Use viewonly=True if persistence is not needed.
+                )
+                self.logger.debug(
+                    f"Temporarily added relationship {relationship_name} on model {self.model_name} for testing."
+                )
+            except (ArgumentError, NoForeignKeysError) as e:
+                self.logger.error(
+                    f"Error creating relationship '{relationship_name}' on model {self.model_name} referencing {related_table_name}: {e}"
+                )
+                continue
+
+            # --- Validate the relationship by forcing mapper configuration ---
+            try:
+                configure_mappers()
+                self.logger.debug(
+                    f"Relationship {relationship_name} on model {self.model_name} validated successfully."
+                )
+            except Exception as e:
+                self.logger.error(
+                    f"Relationship '{relationship_name}' on model {self.model_name} failed configuration: {e}"
+                )
+                del attrs[relationship_name]
+                self.logger.debug(
+                    f"Removed relationship '{relationship_name}' from model {self.model_name} due to configuration error."
+                )
+                clear_mappers()
+                continue
+
+    @staticmethod
+    def normalize_class_name(table_name: str) -> str:
+        table_name = str(table_name)
+        return "".join(word.capitalize() for word in table_name.split("_"))
+
+    def normalize_column_name(self, column_name: Any) -> str:
+        try:
+            # Force the column name into a string.
+            s = str(column_name)
+        except Exception as e:
+            self.logger.debug(f"Failed to convert column name {column_name} to string: {e}")
+            s = ""
+        norm_name = re.sub(r"\W|^(?=\d)", "_", s)
+        if norm_name in RESERVED_KEYWORDS:
+            norm_name += "_field"
+        return norm_name
+
+    @staticmethod
+    def export_models_to_file(filename: str) -> None:
+        """
+        Export dynamically built models (from MODEL_REGISTRY) to a Python file.
+        This function writes out a simplified version of each model definition.
+        """
+        with open(filename, "w") as f:
+            # Write header imports.
+            f.write("from sqlalchemy import Column, Integer, String, Float, DateTime, Boolean, ForeignKey\n")
+            f.write("from sqlalchemy.orm import relationship\n")
+            f.write("from sqlalchemy.ext.declarative import declarative_base\n\n")
+            f.write("Base = declarative_base()\n\n\n")
+
+            for table_name, model in MODEL_REGISTRY.items():
+                print(f"Exporting model for table {table_name} as {model.__name__}...")
+                # Write the class header.
+                f.write(f"class {model.__name__}(Base):\n")
+                f.write(f"    __tablename__ = '{table_name}'\n")
+
+                # Write column definitions.
+                for column in model.__table__.columns:
+                    # Get the column type name (this is a simple conversion).
+                    col_type = column.type.__class__.__name__
+                    col_def = f"    {column.name} = Column({col_type}"
+                    if column.primary_key:
+                        col_def += ", primary_key=True"
+                    # If needed, you can add more column attributes here.
+                    col_def += ")\n"
+                    f.write(col_def)
+
+                # Write relationship definitions.
+                # This simple example prints relationships with just the target class name.
+                for rel in model.__mapper__.relationships:
+                    f.write(f"    {rel.key} = relationship('{rel.mapper.class_.__name__}')\n")
+
+                f.write("\n\n")
+
+        print(f"Models exported to {filename}")

sibi_dst/v2/df_helper/backends/sqlmodel/__init__.py

@@ -0,0 +1,9 @@
+from ._db_connection import SQLModelConnectionConfig
+from ._model_builder import SQLModelModelBuilder
+from ._load_from_db import SQLModelLoadFromDb
+
+__all__ = [
+    'SQLModelConnectionConfig',
+    'SQLModelModelBuilder',
+    'SQLModelLoadFromDb',
+]