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

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

@@ -0,0 +1,78 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel, model_validator, ConfigDict
+from sqlmodel import create_engine
+from sqlalchemy import text
+from sqlalchemy.exc import OperationalError
+
+from sibi_dst.v2.utils import Logger
+from ._model_builder import SQLModelModelBuilder  # Refactored builder for SQLModel
+
+
+class SQLModelConnectionConfig(BaseModel):
+    """
+    Configuration for establishing an SQLModel database connection and dynamically building
+    an ORM model for a specific table.
+    """
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    connection_url: str
+    table: Optional[str] = None
+    model: Any = None
+    engine: Optional[Any] = 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) -> "SQLModelConnectionConfig":
+        """
+        Validates the configuration, initializes the engine, tests the connection,
+        and builds the ORM model for the specified table.
+        """
+        self.logger = self.logger or Logger.default_logger(logger_name="sqlmodel_connection", debug=self.debug)
+        self.logger.debug("Validating and initializing SQLModel connection configuration.")
+
+        if not self.connection_url:
+            raise ValueError("`connection_url` must be provided.")
+
+        # Initialize the engine using SQLModel's create_engine.
+        self.engine = create_engine(self.connection_url)
+        self.logger.debug("Engine created for connection URL.")
+
+        # Validate the connection.
+        self.validate_connection()
+
+        if not self.table:
+            raise ValueError("`table` must be provided to build the model.")
+
+        try:
+            builder = SQLModelModelBuilder(
+                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:
+        """
+        Tests 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/sqlmodel/_io_dask.py

@@ -0,0 +1,122 @@
+import itertools
+import dask.dataframe as dd
+import pandas as pd
+from sqlmodel import create_engine, Session, select
+from sibi_dst.v2.df_helper.core import FilterHandler
+from sibi_dst.v2.utils import Logger
+
+
+class SQLModelDask:
+    def __init__(self, model, filters, engine_url, chunk_size=1000, logger=None, debug=False):
+        """
+        Initialize with a SQLModel query and a database connection URL.
+
+        :param model: SQLModel ORM model.
+        :param filters: Filters to apply on the query.
+        :param engine_url: Database connection string.
+        :param chunk_size: Number of records per chunk for Dask partitions.
+        :param logger: Logger instance for logging.
+        :param debug: Whether to enable detailed logging.
+        """
+        self.query = None
+        self.model = model
+        self.filters = filters
+        self.chunk_size = chunk_size
+        self.debug = debug
+        # Create the engine using SQLModel's create_engine
+        self.engine = create_engine(engine_url)
+        self.logger = logger or Logger.default_logger(logger_name=self.__class__.__name__, debug=debug)
+        self.logger.set_level(self.logger.DEBUG if debug else self.logger.INFO)
+
+    @staticmethod
+    def infer_dtypes_from_model(model):
+        """
+        Infer Dask DataFrame dtypes based on the SQLModel columns.
+        """
+        # Mapping SQLAlchemy type names to Dask/Pandas dtypes.
+        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 model.__table__.columns:
+            # Get the column type name in uppercase.
+            type_str = str(column.type).upper()
+            dtype = sqlalchemy_to_dask_dtype.get(type_str, 'object')
+            dtypes[column.name] = dtype
+        return dtypes
+
+    def read_frame(self, fillna_value=None):
+        """
+        Load data from a SQLModel query into a Dask DataFrame.
+
+        :param fillna_value: Value to replace NaN/NULL values with, if any.
+        :return: A Dask DataFrame containing the query results.
+        """
+        try:
+            with Session(self.engine) as session:
+                # Build the base query.
+                self.query = select(self.model.__table__)
+                if self.filters:
+                    # Apply filters using FilterHandler (assumed to work for SQLModel as well)
+                    self.query = FilterHandler(backend="sqlmodel", logger=self.logger, debug=self.debug).apply_filters(
+                        self.query, model=self.model, filters=self.filters
+                    )
+                else:
+                    # If no filters provided, limit to a small number of records for safety.
+                    n_records = 100
+                    self.query = self.query.limit(n_records)
+                self.logger.debug(f"query: {self.query}")
+
+                # Infer dtypes from the model.
+                dtypes = self.infer_dtypes_from_model(self.model)
+                # Get the column order from the model's table.
+                ordered_columns = [column.name for column in self.model.__table__.columns]
+
+                # Execute the query and fetch all results.
+                results = session.exec(self.query).all()
+                iterator = iter(results)
+                partitions = []
+
+                while True:
+                    chunk = list(itertools.islice(iterator, self.chunk_size))
+                    if not chunk:
+                        break
+                    # Convert each SQLModel instance to a dictionary using the built-in .dict() method.
+                    df = pd.DataFrame([row.dict() for row in chunk])
+                    # Drop SQLModel/SQLAlchemy internal state if present.
+                    df = df.loc[:, ~df.columns.str.contains('_sa_instance_state')]
+                    # Reorder columns to match the model's column order.
+                    df = df[ordered_columns]
+                    if fillna_value is not None:
+                        df = df.fillna(fillna_value)
+                    # Remove timezone information from datetime columns.
+                    for col in df.columns:
+                        if isinstance(df[col].dtype, pd.DatetimeTZDtype):
+                            df[col] = df[col].dt.tz_localize(None)
+                    df = df.astype(dtypes)
+                    partitions.append(dd.from_pandas(df, npartitions=1))
+
+                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)
+            # In case of error, return an empty Dask DataFrame with the expected columns.
+            return dd.from_pandas(pd.DataFrame(columns=ordered_columns), npartitions=1)

sibi_dst/v2/df_helper/backends/sqlmodel/_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 SQLModelDask
+from ._db_connection import SQLModelConnectionConfig
+
+
+class SQLModelLoadFromDb:
+    """
+    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: SQLModelConnectionConfig,  # 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 = SQLModelDask(
+                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/sqlmodel/_model_builder.py

@@ -0,0 +1,283 @@
+import re
+from collections import defaultdict
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Tuple, Type, get_args, get_origin
+
+from sqlalchemy import and_, inspect, cast, func
+from sqlalchemy.exc import ArgumentError, NoForeignKeysError
+from sqlalchemy.orm import relationship, foreign, configure_mappers, clear_mappers
+from sqlalchemy.sql.sqltypes import Integer, String, Float, DateTime, Boolean, Numeric, Text
+
+from sqlmodel import SQLModel, create_engine
+from sibi_dst.v2.utils import Logger
+
+APPS_LABEL = "datacubes"
+RESERVED_COLUMN_NAMES = {"metadata", "class_", "table"}
+RESERVED_KEYWORDS = {"class", "def", "return", "yield", "global"}
+
+MODEL_REGISTRY: Dict[str, Type] = {}
+
+
+class SQLModelModelBuilder:
+    """
+    Dynamically builds an ORM model for a single table by reflecting its columns
+    and reverse-engineering its relationships from foreign key metadata using SQLModel.
+    The generated model is mapped solely via its reflected __table__ attribute.
+    """
+
+    def __init__(
+        self,
+        engine,
+        table_name: str,
+        add_relationships: bool = False,
+        debug: bool = False,
+        logger: Optional[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="sqlmodel_model_builder", debug=self.debug)
+        # Use SQLModel's shared metadata.
+        self.metadata = SQLModel.metadata
+        self.metadata.bind = self.engine
+
+        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.")
+        self.model_name: str = self.normalize_class_name(table_name)
+        if self.debug:
+            self.logger.debug(f"Reflected table for '{table_name}': {self.table}")
+
+    def build_model(self) -> Optional[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
+
+        # Force registration of the reflected table in the metadata.
+        try:
+            self.metadata._add_table(self.table_name, None, self.table)
+        except Exception as e:
+            self.logger.debug(f"Error forcing table registration: {e}")
+
+        columns, annotations = self.get_columns(self.table)
+        # Build the mapping dictionary using only __table__.
+        attrs: Dict[str, Any] = {
+            "__table__": self.table,
+            "__module__": f"{APPS_LABEL}.models",
+            "__mapper_args__": {"eager_defaults": True},
+            "__annotations__": annotations,
+        }
+        attrs.update(columns)
+        if self.add_relationships:
+            self._add_relationships(attrs, self.table)
+        model = type(self.model_name, (SQLModel,), attrs)
+        MODEL_REGISTRY[self.table_name] = model
+
+        try:
+            configure_mappers()
+            self.logger.debug(f"Configured mappers for model {self.model_name}.")
+        except Exception as e:
+            self.logger.error(f"Mapper configuration error for model {self.model_name}: {e}")
+            raise ValueError(f"Invalid mapping in model {self.model_name}: {e}") from e
+
+        # Register the mapping.
+        SQLModel.metadata.create_all(self.engine)
+        self.logger.debug(f"Created model {self.model_name} for table {self.table_name}.")
+        return model
+
+    def get_columns(self, table: Any) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        cols: Dict[str, Any] = {}
+        annotations: Dict[str, Any] = {}
+        for column in table.columns:
+            norm_name = self.normalize_column_name(column.name)
+            if norm_name in RESERVED_COLUMN_NAMES:
+                continue
+            if norm_name in cols:
+                self.logger.warning(f"Duplicate normalized column name '{norm_name}'; skipping duplicate for column '{column.name}'.")
+                continue
+            cols[norm_name] = column
+            annotations[norm_name] = self._python_type_for_column(column)
+        return cols, annotations
+
+    def _python_type_for_column(self, column: Any) -> Any:
+        col_type = type(column.type)
+        if issubclass(col_type, Integer):
+            return int
+        elif issubclass(col_type, (String, Text)):
+            return str
+        elif issubclass(col_type, (Float, Numeric)):
+            return float
+        elif issubclass(col_type, DateTime):
+            return datetime
+        elif issubclass(col_type, Boolean):
+            return bool
+        else:
+            return Any
+
+    def _add_relationships(self, attrs: Dict[str, Any], table: Any) -> None:
+        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():
+            try:
+                if related_table_name not in MODEL_REGISTRY:
+                    self.logger.debug(f"Building missing model for related table {related_table_name}.")
+                    remote_model = SQLModelModelBuilder(
+                        self.engine,
+                        related_table_name,
+                        add_relationships=False,
+                        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
+
+            remote_table = remote_model.__table__
+            join_conditions = []
+            local_foreign_keys = []
+            remote_side_keys = []
+            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 FK definition for {related_table_name} in {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 {self.table_name}.")
+                    continue
+                try:
+                    remote_col = remote_table.columns[remote_col_name]
+                except KeyError:
+                    self.logger.warning(f"Remote column {remote_col_name} not found in model {remote_model.__name__}.")
+                    continue
+                if not local_col.foreign_keys:
+                    self.logger.warning(f"Column {local_col_name} in {self.table_name} is not defined as a foreign key.")
+                    continue
+                if remote_col.name not in remote_model.__table__.columns.keys():
+                    self.logger.warning(f"Remote column {remote_col.name} not in table for model {remote_model.__name__}.")
+                    continue
+                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
+            try:
+                rel = 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,
+                )
+                attrs[relationship_name] = rel
+                attrs.setdefault("__annotations__", {})[relationship_name] = List[remote_model]
+                self.logger.debug(f"Added relationship '{relationship_name}' referencing {related_table_name}.")
+            except (ArgumentError, NoForeignKeysError) as e:
+                self.logger.error(f"Error creating relationship '{relationship_name}' on model {self.model_name}: {e}")
+                continue
+            try:
+                configure_mappers()
+                self.logger.debug(f"Validated relationship '{relationship_name}' on model {self.model_name}.")
+            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}.")
+                clear_mappers()
+                continue
+
+    @staticmethod
+    def normalize_class_name(table_name: str) -> str:
+        return "".join(word.capitalize() for word in table_name.split("_"))
+
+    def normalize_column_name(self, column_name: Any) -> str:
+        try:
+            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:
+        reserved_attrs = {"metadata", "__tablename__", "__sqlmodel_relationships__", "__name__"}
+        import re
+        import typing
+
+        with open(filename, "w") as f:
+            f.write("from sqlmodel import SQLModel, Field, Relationship, Column\n")
+            f.write("from sqlalchemy import ForeignKey\n")
+            f.write("from sqlalchemy.sql.elements import DefaultClause\n")
+            f.write("from sqlalchemy.sql.sqltypes import INTEGER, DATE, VARCHAR, SMALLINT, FLOAT, CHAR, TEXT, DATETIME\n")
+            f.write("from sqlalchemy.dialects.mysql import TINYINT\n")
+            f.write("from typing import Any, List, Optional, Union\n")
+            f.write("import typing\n")
+            f.write("import sqlalchemy\n\n\n")
+
+            f.write("class Base(SQLModel):\n")
+            f.write("    class Config:\n")
+            f.write("        arbitrary_types_allowed = True\n\n\n")
+
+            for table_name, model in MODEL_REGISTRY.items():
+                f.write(f"class {model.__name__}(SQLModel, table=True):\n")
+                f.write(f"    __tablename__ = '{table_name}'\n")
+                for column in model.__table__.columns:
+                    col_repr = repr(column)
+                    col_repr = re.sub(r", table=<[^>]+>", "", col_repr)
+                    col_repr = re.sub(r",\s*server_default=DefaultClause\([^)]*\)", "", col_repr)
+                    col_repr = re.sub(r",\s*display_width=\d+", "", col_repr)
+                    f.write(f"    {column.name}: Any = Field(sa_column={col_repr})\n")
+                annotations = typing.get_type_hints(model)
+                col_names = {col.name for col in model.__table__.columns}
+                for key, type_hint in annotations.items():
+                    if key in col_names or key in reserved_attrs or key.startswith("__"):
+                        continue
+                    origin = get_origin(type_hint)
+                    if origin in (list, List):
+                        remote_model = get_args(type_hint)[0]
+                        remote_model_name = remote_model.__name__
+                    elif origin is Optional:
+                        args = get_args(type_hint)
+                        non_none = [arg for arg in args if arg is not type(None)]
+                        remote_model_name = non_none[0].__name__ if non_none else "Any"
+                    else:
+                        remote_model_name = type_hint.__name__ if hasattr(type_hint, '__name__') else str(type_hint)
+                    f.write(f"    {key}: {type_hint} = Relationship(\"{remote_model_name}\")\n")
+                f.write("\n\n")
+        print(f"Models exported to {filename}")

sibi_dst/v2/df_helper/core/__init__.py

@@ -0,0 +1,9 @@
+from ._filter_handler import FilterHandler
+from ._params_config import ParamsConfig
+from ._query_config import QueryConfig
+
+__all__ = [
+    "ParamsConfig",
+    "QueryConfig",
+    "FilterHandler",
+]