sibi-dst 0.3.63__py3-none-any.whl → 0.3.64__py3-none-any.whl

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

@@ -1,78 +1,357 @@
-from typing import Any, Optional
+from __future__ import annotations
 
-from pydantic import BaseModel, model_validator, ConfigDict
-from sqlmodel import create_engine
-from sqlalchemy import text
-from sqlalchemy.exc import OperationalError
+import threading
+from contextlib import contextmanager
+from typing import Any, Optional, ClassVar, Generator, Type, Dict
 
-from sibi_dst.v2.utils import Logger
-from ._model_builder import SQLModelModelBuilder  # Refactored builder for SQLModel
+from pydantic import (
+    BaseModel,
+    field_validator,
+    model_validator,
+    ConfigDict,
+)
+from sqlalchemy import create_engine, event, text
+from sqlalchemy.engine import url as sqlalchemy_url
+from sqlalchemy.engine import Engine
+from sqlalchemy.exc import OperationalError, SQLAlchemyError
+from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.pool import QueuePool, NullPool, StaticPool
+
+# Restoring the original intended imports
+from sibi_dst.utils import Logger
+from ._model_builder import SQLModelModelBuilder
 
 
 class SQLModelConnectionConfig(BaseModel):
     """
-    Configuration for establishing an SQLModel database connection and dynamically building
-    an ORM model for a specific table.
+    A thread-safe, registry-backed SQLAlchemy connection manager.
+
+    This class encapsulates database connection configuration and provides robust,
+    shared resource management. It is designed to be instantiated multiple times
+    with the same connection parameters, where it will safely share a single
+    underlying database engine and connection pool.
+
+    Key Features:
+      - Shared Engine & Pool: Reuses a single SQLAlchemy Engine for identical
+        database URLs and pool settings, improving application performance.
+      - Reference Counting: Safely manages the lifecycle of the shared engine,
+        disposing of it only when the last user has closed its connection config.
+      - Per-Engine Connection Tracking: Monitors active connections for each
+        engine individually.
+      - Dynamic ORM Model Building: If a table name is provided, it can
+        dynamically generate a SQLAlchemy ORM model for that table.
+      - Integrated Session Management: Provides a pre-configured session factory
+        for convenient database interactions.
+
+    Attributes:
+        connection_url (str): The database URL (e.g., "postgresql://u:p@h/d").
+        table (Optional[str]): If provided, an ORM model will be built for this table.
+        model (Optional[Any]): The dynamically generated ORM model class.
+        engine (Optional[Engine]): The underlying SQLAlchemy engine.
+        logger (Logger): The logger instance.
+        debug (bool): If True, sets logger to DEBUG level.
+        session_factory (Optional[sessionmaker]): A factory for creating Session objects.
     """
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    # --- Public Configuration ---
     connection_url: str
     table: Optional[str] = None
-    model: Any = None
-    engine: Optional[Any] = None
     debug: bool = False
+
+    # --- Pool Configuration ---
+    pool_size: int = 5
+    max_overflow: int = 10
+    pool_timeout: int = 30
+    pool_recycle: int = 300
+    pool_pre_ping: bool = True
+    poolclass: Type[QueuePool] = QueuePool
+
+    # --- Internal & Runtime State ---
+    model: Optional[Type[Any]] = None
+    engine: Optional[Engine] = None
     logger: Optional[Logger] = None
-    add_relationships: bool = False
-    export_models: bool = False
-    export_file_name: str = 'models.py'
+    session_factory: Optional[sessionmaker] = None
+
+    # --- Private State ---
+    _engine_key_instance: tuple = ()
+
+    # --- Class-level Shared Resources ---
+    # Registry stores engine wrappers with metadata like ref_count.
+    # Format: { engine_key: {'engine': Engine, 'ref_count': int, 'active_connections': int} }
+    _engine_registry: ClassVar[Dict[tuple, Dict[str, Any]]] = {}
+    _registry_lock: ClassVar[threading.Lock] = threading.Lock()
+
+    # Pydantic v2 configuration
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+    )
+
+    @field_validator("pool_size", "max_overflow", "pool_timeout", "pool_recycle")
+    @classmethod
+    def _validate_pool_params(cls, v: int) -> int:
+        if v < 0:
+            raise ValueError("Pool parameters must be non-negative")
+        return v
 
     @model_validator(mode="after")
-    def validate_and_initialize(self) -> "SQLModelConnectionConfig":
+    def _init_all(self) -> SQLModelConnectionConfig:
+        """
+        Orchestrates the initialization process after Pydantic validation.
+        This method sets up the logger, engine, validates the connection,
+        builds the ORM model, and creates the session factory.
+        """
+        self._init_logger()
+
+        # The engine key is generated and stored on the instance to ensure
+        # that even if public attributes are changed later, this instance
+        # can always find its original engine in the registry.
+        self._engine_key_instance = self._get_engine_key()
+
+        self._init_engine()
+        self._validate_conn()
+        self._build_model()
+
+        if self.engine:
+            self.session_factory = sessionmaker(bind=self.engine, expire_on_commit=False)
+
+        return self
+
+    def _init_logger(self) -> None:
+        """Initializes the logger for this instance."""
+        if self.logger is None:
+            self.logger = Logger.default_logger(logger_name=self.__class__.__name__)
+        # Assuming the Logger has a set_level method that accepts standard logging levels
+        log_level = Logger.DEBUG if self.debug else Logger.INFO
+        self.logger.set_level(log_level)
+
+    def _get_engine_key(self) -> tuple:
+        """
+        Generates a unique, normalized key for an engine configuration.
+        This key is used as the dictionary key in the shared _engine_registry.
+        It intentionally excludes instance-specific details like `table` to
+        ensure proper engine sharing.
+        """
+        parsed = sqlalchemy_url.make_url(self.connection_url)
+        # Exclude pooling from the query params as they are handled separately
+        query = {k: v for k, v in parsed.query.items() if not k.startswith("pool_")}
+        normalized_url = parsed.set(query=query)
+
+        key_parts = [str(normalized_url)]
+        if self.poolclass not in (NullPool, StaticPool):
+            key_parts += [
+                self.pool_size, self.max_overflow, self.pool_timeout,
+                self.pool_recycle, self.pool_pre_ping
+            ]
+        return tuple(key_parts)
+
+    def _init_engine(self) -> None:
         """
-        Validates the configuration, initializes the engine, tests the connection,
-        and builds the ORM model for the specified table.
+        Initializes the SQLAlchemy Engine.
+        If an identical engine already exists in the registry, it is reused
+        and its reference count is incremented. Otherwise, a new engine
+        is created and added to the registry.
         """
-        self.logger = self.logger or Logger.default_logger(logger_name="sqlmodel_connection", debug=self.debug)
-        self.logger.debug("Validating and initializing SQLModel connection configuration.")
+        with self._registry_lock:
+            engine_wrapper = self._engine_registry.get(self._engine_key_instance)
+
+            if engine_wrapper:
+                # --- Reuse existing engine ---
+                self.engine = engine_wrapper['engine']
+                engine_wrapper['ref_count'] += 1
+                self.logger.debug(
+                    f"Reusing engine. Ref count: {engine_wrapper['ref_count']}. Key: {self._engine_key_instance}")
+            else:
+                # --- Create new engine ---
+                self.logger.debug(f"Creating new engine for key: {self._engine_key_instance}")
+                try:
+                    new_engine = create_engine(
+                        self.connection_url,
+                        pool_size=self.pool_size,
+                        max_overflow=self.max_overflow,
+                        pool_timeout=self.pool_timeout,
+                        pool_recycle=self.pool_recycle,
+                        pool_pre_ping=self.pool_pre_ping,
+                        poolclass=self.poolclass,
+                    )
+                    self.engine = new_engine
+                    self._attach_events()
+
+                    # Store the new engine and its metadata in the registry
+                    self._engine_registry[self._engine_key_instance] = {
+                        'engine': new_engine,
+                        'ref_count': 1,
+                        'active_connections': 0
+                    }
+                except Exception as e:
+                    self.logger.error(f"Failed to create engine: {e}")
+                    raise SQLAlchemyError(f"Engine creation failed: {e}") from e
+
+    def _attach_events(self) -> None:
+        """Attaches checkout/checkin events to the engine for connection tracking."""
+        if self.engine:
+            event.listen(self.engine, "checkout", self._on_checkout)
+            event.listen(self.engine, "checkin", self._on_checkin)
+
+    def _on_checkout(self, *args) -> None:
+        """Event listener for when a connection is checked out from the pool."""
+        with self._registry_lock:
+            wrapper = self._engine_registry.get(self._engine_key_instance)
+            if wrapper:
+                wrapper['active_connections'] += 1
+        self.logger.debug(f"Connection checked out. Active: {self.active_connections}")
+
+    def _on_checkin(self, *args) -> None:
+        """Event listener for when a connection is returned to the pool."""
+        with self._registry_lock:
+            wrapper = self._engine_registry.get(self._engine_key_instance)
+            if wrapper:
+                wrapper['active_connections'] = max(0, wrapper['active_connections'] - 1)
+        self.logger.debug(f"Connection checked in. Active: {self.active_connections}")
 
-        if not self.connection_url:
-            raise ValueError("`connection_url` must be provided.")
+    @property
+    def active_connections(self) -> int:
+        """Returns the number of active connections for this instance's engine."""
+        with self._registry_lock:
+            wrapper = self._engine_registry.get(self._engine_key_instance)
+            return wrapper['active_connections'] if wrapper else 0
 
-        # Initialize the engine using SQLModel's create_engine.
-        self.engine = create_engine(self.connection_url)
-        self.logger.debug("Engine created for connection URL.")
+    def _validate_conn(self) -> None:
+        """Tests the database connection by executing a simple query."""
+        try:
+            with self.managed_connection() as conn:
+                conn.execute(text("SELECT 1"))
+            self.logger.debug("Database connection validated successfully.")
+        except OperationalError as e:
+            self.logger.error(f"Database connection failed: {e}")
+            # This will be caught by Pydantic and raised as a ValidationError
+            raise ValueError(f"DB connection failed: {e}") from e
 
-        # Validate the connection.
-        self.validate_connection()
+    @contextmanager
+    def managed_connection(self) -> Generator[Any, None, None]:
+        """Provides a single database connection from the engine pool."""
+        if not self.engine:
+            raise RuntimeError("Engine not initialized. Cannot get a connection.")
+        conn = self.engine.connect()
+        try:
+            yield conn
+        finally:
+            conn.close()
 
-        if not self.table:
-            raise ValueError("`table` must be provided to build the model.")
+    def get_session(self) -> Session:
+        """Returns a new SQLAlchemy Session from the session factory."""
+        if not self.session_factory:
+            raise RuntimeError("Session factory not initialized. Cannot get a session.")
+        return self.session_factory()
 
+    def _build_model(self) -> None:
+        """
+        Dynamically builds and assigns an ORM model if `self.table` is set.
+        Uses SqlAlchemyModelBuilder to reflect the table schema from the database.
+        """
+        if not self.table or not self.engine:
+            return
         try:
-            builder = SQLModelModelBuilder(
-                self.engine,
-                self.table,
-                self.add_relationships,
-                self.debug,
-                self.logger
-            )
+            builder = SQLModelModelBuilder(self.engine, self.table)
             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}")
+            self.logger.debug(f"Successfully built ORM model for table: {self.table}")
         except Exception as e:
-            raise ValueError(f"Failed to build model for table {self.table}: {e}")
+            self.logger.error(f"Failed to build ORM model for table '{self.table}': {e}")
+            # Propagate as a ValueError to be caught by Pydantic validation
+            raise ValueError(f"Model construction failed for table '{self.table}': {e}") from e
 
-        return self
+    def close(self) -> None:
+        """
+        Decrements the engine's reference count and disposes of the engine
+        if the count reaches zero. This is the primary method for releasing
+        resources managed by this configuration object.
+        """
+        with self._registry_lock:
+            key = self._engine_key_instance
+            engine_wrapper = self._engine_registry.get(key)
+
+            if not engine_wrapper:
+                self.logger.warning("Attempted to close a config whose engine is not in the registry.")
+                return
+
+            engine_wrapper['ref_count'] -= 1
+            self.logger.debug(f"Closing config. Ref count is now {engine_wrapper['ref_count']} for key {key}.")
+
+            if engine_wrapper['ref_count'] <= 0:
+                self.logger.debug(f"Disposing engine as reference count is zero. Key: {key}")
+                engine_wrapper['engine'].dispose()
+                del self._engine_registry[key]
 
-    def validate_connection(self) -> None:
+    def dispose_idle_connections(self) -> int:
         """
-        Tests the database connection by executing a simple query.
-        Raises:
-            ValueError: If the connection cannot be established.
+        Closes and discards idle connections in this engine's connection pool.
+
+        This is a pool-level operation that affects only the connections held
+        by the pool, not those active at the database level.
+
+        Returns:
+            int: The number of connections disposed of.
         """
-        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}")
+        if not self.engine:
+            self.logger.warning("Cannot dispose idle connections: engine not initialized.")
+            return 0
+
+        pool = self.engine.pool
+        if isinstance(pool, QueuePool):
+            # The pool.dispose() method checks in all connections and clears the pool.
+            # The number of checked-in connections is the number of idle connections.
+            count = pool.checkedin()
+            pool.dispose()
+            self.logger.debug(f"Disposed {count} idle connections from the pool.")
+            return count
+
+        self.logger.warning(f"Idle connection disposal not applicable for pool type: {type(pool).__name__}")
+        return 0
+
+    def terminate_idle_connections(self, idle_seconds: int = 300) -> int:
+        """
+        Terminates idle connections at the database server level.
+
+        This is an administrative database operation that forcibly closes
+        backend processes. Use with caution. Support is dialect-specific.
+
+        Args:
+            idle_seconds (int): The minimum idle time in seconds for a
+                                connection to be terminated.
+
+        Returns:
+            int: The number of connections terminated.
+        """
+        if not self.engine:
+            self.logger.warning("Cannot terminate connections: engine not initialized.")
+            return 0
+
+        terminated_count = 0
+        dialect = self.engine.dialect.name
+
+        with self.managed_connection() as conn:
+            try:
+                if dialect == 'postgresql':
+                    query = text(
+                        "SELECT pg_terminate_backend(pid) FROM pg_stat_activity "
+                        "WHERE state = 'idle' "
+                        "AND (now() - query_start) > INTERVAL ':idle_seconds seconds' "
+                        "AND pid <> pg_backend_pid()"
+                    )
+                    res = conn.execute(query, {"idle_seconds": idle_seconds})
+                    terminated_count = res.rowcount if res.rowcount is not None else 0
+
+                elif dialect == 'mysql':
+                    process_list = conn.execute(text("SHOW PROCESSLIST"))
+                    for row in process_list:
+                        # Pylint compatible attribute access
+                        if getattr(row, 'Command', '') == 'Sleep' and getattr(row, 'Time', 0) > idle_seconds:
+                            conn.execute(text(f"KILL {getattr(row, 'Id')}"))
+                            terminated_count += 1
+                else:
+                    self.logger.warning(f"Idle connection termination is not supported for dialect: {dialect}")
+            except SQLAlchemyError as e:
+                self.logger.error(f"Error terminating idle connections for dialect {dialect}: {e}")
+
+        if terminated_count > 0:
+            self.logger.debug(f"Terminated {terminated_count} idle connections on the database server.")
+        return terminated_count
+

sibi_dst/v3/df_helper/_df_helper.py

@@ -0,0 +1,91 @@
+from typing import Union, Optional
+import pandas as pd
+import dask.dataframe as dd
+
+# Refactored DfHelper class
+class DfHelper:
+    """
+    DfHelper is a utility class that orchestrates loading and processing data.
+    It uses a configured BackendStrategy to handle the specifics of data loading.
+    """
+    df: Union[dd.DataFrame, pd.DataFrame] = None
+
+    def __init__(self, backend_strategy: BackendStrategy,
+                 params_config: ParamsConfig,
+                 as_pandas: bool = False,
+                 debug: bool = False,
+                 logger: Optional[Logger] = None):
+
+        self.backend_strategy = backend_strategy
+        self._backend_params = params_config  # Needed for post-processing and field mapping
+        self.as_pandas = as_pandas
+        self.debug = debug
+        self.logger = logger or Logger.default_logger(logger_name=self.__class__.__name__)
+        self.logger.set_level(Logger.DEBUG if self.debug else Logger.INFO)
+
+        # Other attributes like parquet saving paths can be passed in here if needed
+        # self.parquet_storage_path = kwargs.get("parquet_storage_path")
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, traceback):
+        # Cleanup logic for resources that DfHelper itself might manage
+        # The connection cleanup is now the responsibility of the caller who creates the strategy
+        if hasattr(self.backend_strategy, 'connection') and hasattr(self.backend_strategy.connection, 'close'):
+            self.backend_strategy.connection.close()
+        return False
+
+    def load(self, **options):
+        """
+        Loads data using the configured backend strategy, applies transformations,
+        and returns a DataFrame.
+        """
+        try:
+            self.logger.debug(f"Loading data using {self.backend_strategy.__class__.__name__}...")
+            # 1. Delegate loading to the strategy object
+            self.df = self.backend_strategy.load(**options)
+
+            # 2. Perform post-processing (these methods remain in DfHelper)
+            self.__process_loaded_data()
+            self.__post_process_df()
+            self.logger.debug("Data successfully loaded and processed.")
+
+        except Exception as e:
+            self.logger.error(f"Failed to load data using {self.backend_strategy.__class__.__name__}: {e}")
+            self.df = dd.from_pandas(pd.DataFrame(), npartitions=1)
+
+        if self.as_pandas and isinstance(self.df, dd.DataFrame):
+            return self.df.compute()
+        return self.df
+
+    def load_period(self, start: str, end: str, dt_field: str, **kwargs):
+        """
+        Loads data for a specific period by delegating filter creation to the strategy.
+        """
+        if dt_field is None:
+            raise ValueError("dt_field must be provided")
+
+        # Parse and validate dates
+        start_dt = self.parse_date(start)
+        end_dt = self.parse_date(end)
+        if start_dt > end_dt:
+            raise ValueError("The 'start' date cannot be later than the 'end' date.")
+
+        # Delegate the creation of filter logic to the current strategy
+        field_map = getattr(self._backend_params, 'field_map', {}) or {}
+        period_filters = self.backend_strategy.build_period_filter(
+            dt_field, start_dt, end_dt, field_map
+        )
+
+        # Combine with other filters and load
+        all_filters = {**kwargs, **period_filters}
+        self.logger.debug(f"Loading period with combined filters: {all_filters}")
+        return self.load(**all_filters)
+
+    # The methods __process_loaded_data, __post_process_df, save_to_parquet,
+    # save_to_clickhouse, and parse_date remain unchanged as they are
+    # part of the orchestration logic, not the loading strategy itself.
+
+    # ... (paste those methods here without modification) ...
+    # ... __process_loaded_data, __post_process_df, save_to_parquet, etc. ...

{sibi_dst-0.3.63.dist-info → sibi_dst-0.3.64.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sibi-dst
-Version: 0.3.63
+Version: 0.3.64
 Summary: Data Science Toolkit
 Author: Luis Valverde
 Author-email: lvalverdeb@gmail.com

{sibi_dst-0.3.63.dist-info → sibi_dst-0.3.64.dist-info}/RECORD

@@ -1,7 +1,7 @@
 sibi_dst/__init__.py,sha256=3pbriM7Ym5f9gew7n9cO4G_p9n-0bnxdmQ0hwBdJjr4,253
 sibi_dst/df_helper/__init__.py,sha256=McYrw2N0MsMgtawLrONXTGdyHfQWVOBUvIDbklfjb54,342
 sibi_dst/df_helper/_artifact_updater_multi_wrapper.py,sha256=-Y4i5KAxKY2BNkmoVeMEZxjTFD7zaM9oQ0aRsvUbQrs,9340
-sibi_dst/df_helper/_df_helper.py,sha256=uKP6i-7dasZQ5zViD8-VJU0lNHumrdZG6IXvDFijZ18,31214
+sibi_dst/df_helper/_df_helper.py,sha256=tpSX5o7caTq5TnbIZ78OLJFBbT1J4Ukeld_ZTULg4yE,10856
 sibi_dst/df_helper/_parquet_artifact.py,sha256=Nio5GSD6rTYl52nf_TSpQhYIF0hKqRrB3H3A4zYnaG8,14987
 sibi_dst/df_helper/_parquet_reader.py,sha256=L6mr2FeKtTeIn37G9EGpvOx8PwMqXb6qnEECqBaiwxo,3954
 sibi_dst/df_helper/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -15,17 +15,16 @@ sibi_dst/df_helper/backends/http/_http_config.py,sha256=eGPFdqZ5M3Tscqx2P93B6XoB
 sibi_dst/df_helper/backends/parquet/__init__.py,sha256=esWJ9aSuYC26d-T01z9dPrJ1uqJzvdaPNTYRb5qXTlQ,182
 sibi_dst/df_helper/backends/parquet/_filter_handler.py,sha256=TvDf0RXta7mwJv11GNQttYJsXgFf2XDj4oLIjt4xTzA,5219
 sibi_dst/df_helper/backends/parquet/_parquet_options.py,sha256=TaU5_wG1Y3lQC8DVCItVvMnc6ZJmECLu3avssVEMbaM,10591
-sibi_dst/df_helper/backends/sqlalchemy/__init__.py,sha256=TuVp8Ce49dCIIxtyrtFGRblarQUl8QGcS-TDZd515IE,348
-sibi_dst/df_helper/backends/sqlalchemy/_db_connection.py,sha256=JID-urZLbWjMd2dXt7onp6cPxAWQ3jnsY88s_lCscn8,7980
-sibi_dst/df_helper/backends/sqlalchemy/_filter_handler.py,sha256=58RCda1Hg_nsuJw-2V36IstsT8O84IQFgsdE7FnqvMk,4655
-sibi_dst/df_helper/backends/sqlalchemy/_io_dask.py,sha256=BtiRSYA4kFIM-mBCdrwE20vzByfq8_Biv_jPLUCDv58,5466
-sibi_dst/df_helper/backends/sqlalchemy/_load_from_db.py,sha256=ltqB5814PMecxwZgmsJL6nDhQf72V-w71YWFAf7aYZ8,6490
-sibi_dst/df_helper/backends/sqlalchemy/_sql_model_builder.py,sha256=ksvJ0EvktrVsoJ9DTMIQHzHe8ghw2mzDIBD_YgWytgw,8402
+sibi_dst/df_helper/backends/sqlalchemy/__init__.py,sha256=LjWm9B7CweTvlvFOgB90XjSe0lVLILAIYMWKPkFXFm8,265
+sibi_dst/df_helper/backends/sqlalchemy/_db_connection.py,sha256=gppZrXLGK8U8xfkzRQPZCIFoWY-miP04nDNHpV8lXtU,10600
+sibi_dst/df_helper/backends/sqlalchemy/_io_dask.py,sha256=UKLWY3s3l8kMmieg3XZtEol-pj2WMb3ZB3496KbmmiA,6805
+sibi_dst/df_helper/backends/sqlalchemy/_load_from_db.py,sha256=NXVhtYF2mYsrW2fXBkL29VQ5gxAlOYPJkYa8HZKYUyM,2846
+sibi_dst/df_helper/backends/sqlalchemy/_sql_model_builder.py,sha256=Q93O_xqK0SdrS3IrijVcqky_Zf6xKjtPHdI3qnf1g8E,7457
 sibi_dst/df_helper/core/__init__.py,sha256=o4zDwgVmaijde3oix0ezb6KLxI5QFy-SGUhFTDVFLT4,569
 sibi_dst/df_helper/core/_defaults.py,sha256=eNpHD2sZxir-2xO0b3_V16ryw8YP_5FfpIKK0HNuiN4,7011
 sibi_dst/df_helper/core/_filter_handler.py,sha256=Pmbzygry2mpkNPVS7DBMulHpAb1yYZNFqUU0bJTWJF0,11214
 sibi_dst/df_helper/core/_params_config.py,sha256=DYx2drDz3uF-lSPzizPkchhy-kxRrQKE5FQRxcEWsac,6736
-sibi_dst/df_helper/core/_query_config.py,sha256=Y8LVSyaKuVkrPluRDkQoOwuXHQxner1pFWG3HPfnDHM,441
+sibi_dst/df_helper/core/_query_config.py,sha256=1ApqmuSGXTC3CdF-xMsSbCa3V2Z5hOP3Wq5huhzZwqY,439
 sibi_dst/df_helper/data_cleaner.py,sha256=lkxQoXLvGzXCicFUimnA5nen5qkrO1oxgl_p2Be2o8w,5183
 sibi_dst/geopy_helper/__init__.py,sha256=Q1RJiUZIOlV0QNNLjxZ_2IZS5LqIe5jRbeQkfD1Vm60,112
 sibi_dst/geopy_helper/geo_location_service.py,sha256=1ArI980QF_gRw096ZsABHwJt-m55jrfOlB8tPwL1BvY,2959
@@ -49,7 +48,7 @@ sibi_dst/utils/date_utils.py,sha256=T3ij-WOQu3cIfmNAweSVMWWr-hVtuBcTGjEY-cMJIvU,
 sibi_dst/utils/df_utils.py,sha256=TzIAUCLbgOn3bvCFvzkc1S9YU-OlZTImdCj-88dtg8g,11401
 sibi_dst/utils/file_utils.py,sha256=Z99CZ_4nPDIaZqbCfzzUDfAYJjSudWDj-mwEO8grhbc,1253
 sibi_dst/utils/filepath_generator.py,sha256=-HHO0U-PR8fysDDFwnWdHRlgqksh_RkmgBZLWv9hM7s,6669
-sibi_dst/utils/log_utils.py,sha256=77xACRagKU83H9vn7aVeBzkQjxWlbe4dg4KuxPRCgvw,4635
+sibi_dst/utils/log_utils.py,sha256=C2wkbxGC2n6hZIEU-z8rHrunDcq95MHkf3B1zGynHnE,4904
 sibi_dst/utils/manifest_manager.py,sha256=eyk6Dvrn86gUpAaAsnQvNnEJn5-Tno-sDDJsDMfHtTA,18161
 sibi_dst/utils/parquet_saver.py,sha256=O62xwPfphOpKgEiHqnts20CPSU96pxs49Cg7PVetLK0,8193
 sibi_dst/utils/phone_formatter.py,sha256=tsVTDamuthFYgy4-5UwmQkPQ-FGTGH7MjZyH8utAkIY,4945
@@ -62,12 +61,12 @@ sibi_dst/v2/df_helper/__init__.py,sha256=XuH6jKYAPg2DdRbsxxBSxp9X3x-ARyaT0xe27uI
 sibi_dst/v2/df_helper/_df_helper.py,sha256=9pED3bjQ2Z81zqzJrZ9e7SguoO4-hBmNTJK4WOKrr4M,9297
 sibi_dst/v2/df_helper/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sibi_dst/v2/df_helper/backends/sqlalchemy/__init__.py,sha256=MOEedyWqcb1_RiRYKyyWX0uFNCfBgmyYbTjco8-GBxU,262
-sibi_dst/v2/df_helper/backends/sqlalchemy/_db_connection.py,sha256=8u3jdD0sR2fmm2H75GDdygoqiqDI6-N-azOJsLgUWFA,3189
-sibi_dst/v2/df_helper/backends/sqlalchemy/_io_dask.py,sha256=6V9DruwckEsonYW5YvBY93-NzXYHbTA7OsyMKMYIZEs,5472
+sibi_dst/v2/df_helper/backends/sqlalchemy/_db_connection.py,sha256=1xeMxPBpChXDMpmQmTYtta6y43ndU6x6szdon8KIj9g,15443
+sibi_dst/v2/df_helper/backends/sqlalchemy/_io_dask.py,sha256=LmUBK-HRrF-RncnZ2DsZSqxmTrAeQEyD8oqaBDfr518,5449
 sibi_dst/v2/df_helper/backends/sqlalchemy/_load_from_db.py,sha256=jhgN0OO5Sk1zQFHrMUhJn2F_hHB5g3x3EJ8j5PXNb0U,6295
 sibi_dst/v2/df_helper/backends/sqlalchemy/_model_builder.py,sha256=jX_mQAzl_6xdh7CTYw4uvUIX2wMp3NzXMlfbC5alOzs,13632
 sibi_dst/v2/df_helper/backends/sqlmodel/__init__.py,sha256=LcwJjVVxxrnVZalWqnz5m7r77i9tmJR0-U2k8eSQ-m8,249
-sibi_dst/v2/df_helper/backends/sqlmodel/_db_connection.py,sha256=b5xmxQr4a8fhE4qdCGJrNWjjX1NW5hrPNLmlfP20rIg,2897
+sibi_dst/v2/df_helper/backends/sqlmodel/_db_connection.py,sha256=n3CDbda0OY3X7eTeu_PR2KcZ5hYyEJL7Hroo8yQkjG8,15435
 sibi_dst/v2/df_helper/backends/sqlmodel/_io_dask.py,sha256=wVgNPo5V75aLtlZr_SIQ-yteyXq-Rg93eMfR8JCfkSo,5422
 sibi_dst/v2/df_helper/backends/sqlmodel/_load_from_db.py,sha256=FIs6UrNxdJ7eDHDvTv-cJuybIue2-oCRedhW-MNe7CU,6285
 sibi_dst/v2/df_helper/backends/sqlmodel/_model_builder.py,sha256=k0dnMLkLMMvkDYDYWkGFgibW5UD8pJgB3YrEg_R7pj8,13556
@@ -77,6 +76,10 @@ sibi_dst/v2/df_helper/core/_params_config.py,sha256=DYx2drDz3uF-lSPzizPkchhy-kxR
 sibi_dst/v2/df_helper/core/_query_config.py,sha256=Y8LVSyaKuVkrPluRDkQoOwuXHQxner1pFWG3HPfnDHM,441
 sibi_dst/v2/utils/__init__.py,sha256=6H4cvhqTiFufnFPETBF0f8beVVMpfJfvUs6Ne0TQZNY,58
 sibi_dst/v2/utils/log_utils.py,sha256=rfk5VsLAt-FKpv6aPTC1FToIPiyrnHAFFBAkHme24po,4123
-sibi_dst-0.3.63.dist-info/METADATA,sha256=ZsVn8AeFIUeVrb0Ybxmjk393FdUyn2j2fOnGQ8MXM1k,4292
-sibi_dst-0.3.63.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-sibi_dst-0.3.63.dist-info/RECORD,,
+sibi_dst/v3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sibi_dst/v3/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sibi_dst/v3/df_helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sibi_dst/v3/df_helper/_df_helper.py,sha256=NKIQ4Y-Tn-e841sbZxzLh3Q071_Zo9Vu4y3OAXcsO98,3900
+sibi_dst-0.3.64.dist-info/METADATA,sha256=S-GXRa0njyB4k2RB51TboYGXeumRmGunMY9km0UJNUE,4292
+sibi_dst-0.3.64.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+sibi_dst-0.3.64.dist-info/RECORD,,