sibi-dst 0.3.19__tar.gz → 0.3.21__tar.gz

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/PKG-INFO

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

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sibi-dst"
-version = "0.3.19"
+version = "0.3.21"
 description = "Data Science Toolkit"
 authors = ["Luis Valverde <lvalverdeb@gmail.com>"]
 readme = "README.md"

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/__init__.py

@@ -6,4 +6,4 @@ except ImportError:
 try:
     __version__ = version_reader.version("sibi-dst")
 except version_reader.PackageNotFoundError:
-    __version__ = "unknown"
+    __version__ = "unknown"

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/__init__.py

@@ -4,8 +4,8 @@ from ._df_helper import DfHelper
 from ._parquet_artifact import ParquetArtifact
 from ._parquet_reader import ParquetReader
 
-__all__=[
+__all__ = [
     'DfHelper',
     'ParquetArtifact',
     'ParquetReader',
-]
+]

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/_df_helper.py

@@ -27,11 +27,12 @@ warnings.filterwarnings(
     category=UserWarning,
 )
 
+
 class DfHelper:
     df: Union[dd.DataFrame, pd.DataFrame] = None
     backend_django: Optional[DjangoConnectionConfig] = None
-    backend_query: Optional[QueryConfig] = None
-    backend_params: Optional[ParamsConfig] = None
+    _backend_query: Optional[QueryConfig] = None
+    _backend_params: Optional[ParamsConfig] = None
     backend_parquet: Optional[ParquetConfig] = None
     backend_http: Optional[HttpConfig] = None
     backend_sqlalchemy: Optional[SqlAlchemyConnectionConfig] = None
@@ -45,7 +46,7 @@ class DfHelper:
         kwargs = {**self.default_config.copy(), **kwargs}
         self.backend = backend
         self.debug = kwargs.setdefault("debug", False)
-        self.logger = kwargs.get("logger",Logger.default_logger(logger_name=self.__class__.__name__))
+        self.logger = kwargs.get("logger", Logger.default_logger(logger_name=self.__class__.__name__))
         # Configure logger level
         self.logger.setLevel(logging.DEBUG if self.debug else logging.INFO)
         self.logger.debug("Logger initialized in DEBUG mode.")
@@ -54,15 +55,15 @@ class DfHelper:
         self.as_pandas = kwargs.setdefault("as_pandas", False)
         kwargs.setdefault("live", True)
         kwargs.setdefault("logger", self.logger)
-        self.post_init(**kwargs)
+        self.__post_init(**kwargs)
 
     def __str__(self):
         return self.__class__.__name__
 
-    def post_init(self, **kwargs):
+    def __post_init(self, **kwargs):
         self.logger.debug(f"backend used: {self.backend}")
-        self.backend_query = self.__get_config(QueryConfig, kwargs)
-        self.backend_params = self.__get_config(ParamsConfig, kwargs)
+        self._backend_query = self.__get_config(QueryConfig, kwargs)
+        self._backend_params = self.__get_config(ParamsConfig, kwargs)
         if self.backend == 'django_db':
             self.backend_django = self.__get_config(DjangoConnectionConfig, kwargs)
         elif self.backend == 'parquet':
@@ -89,42 +90,42 @@ class DfHelper:
 
     def load(self, **options):
         # this will be the universal method to load data from a df irrespective of the backend
-        df = self._load(**options)
+        df = self.__load(**options)
         if self.as_pandas:
             return df.compute()
         return df
 
-    def _load(self, **options):
+    def __load(self, **options):
 
         if self.backend == 'django_db':
-            self.backend_params.parse_params(options)
-            return self._load_from_db(**options)
+            self._backend_params.parse_params(options)
+            return self.__load_from_db(**options)
         elif self.backend == 'sqlalchemy':
-            self.backend_params.parse_params(options)
-            return self._load_from_sqlalchemy(**options)
+            self._backend_params.parse_params(options)
+            return self.__load_from_sqlalchemy(**options)
         elif self.backend == 'parquet':
-            return self._load_from_parquet(**options)
+            return self.__load_from_parquet(**options)
         elif self.backend == 'http':
             if asyncio.get_event_loop().is_running():
                 self.logger.debug("Running as a task from an event loop")
-                return asyncio.create_task(self._load_from_http(**options))
+                return asyncio.create_task(self.__load_from_http(**options))
             else:
                 self.logger.debug("Regular asyncio run...")
-                return asyncio.run(self._load_from_http(**options))
+                return asyncio.run(self.__load_from_http(**options))
 
-    def _load_from_sqlalchemy(self, **options):
+    def __load_from_sqlalchemy(self, **options):
         try:
             options.setdefault("debug", self.debug)
             db_loader = SqlAlchemyLoadFromDb(
                 self.backend_sqlalchemy,
-                self.backend_query,
-                self.backend_params,
+                self._backend_query,
+                self._backend_params,
                 self.logger,
                 **options
             )
             self.df = db_loader.build_and_load()
-            self._process_loaded_data()
-            self._post_process_df()
+            self.__process_loaded_data()
+            self.__post_process_df()
             self.logger.debug("Data successfully loaded from sqlalchemy database.")
         except Exception as e:
             self.logger.debug(f"Failed to load data from sqlalchemy database: {e}: options: {options}")
@@ -132,19 +133,19 @@ class DfHelper:
 
         return self.df
 
-    def _load_from_db(self, **options) -> Union[pd.DataFrame, dd.DataFrame]:
+    def __load_from_db(self, **options) -> Union[pd.DataFrame, dd.DataFrame]:
         try:
             options.setdefault("debug", self.debug)
             db_loader = DjangoLoadFromDb(
                 self.backend_django,
-                self.backend_query,
-                self.backend_params,
+                self._backend_query,
+                self._backend_params,
                 self.logger,
                 **options
             )
             self.df = db_loader.build_and_load()
-            self._process_loaded_data()
-            self._post_process_df()
+            self.__process_loaded_data()
+            self.__post_process_df()
             self.logger.debug("Data successfully loaded from django database.")
         except Exception as e:
             self.logger.debug(f"Failed to load data from django database: {e}")
@@ -152,7 +153,7 @@ class DfHelper:
 
         return self.df
 
-    async def _load_from_http(self, **options) -> Union[pd.DataFrame, dd.DataFrame]:
+    async def __load_from_http(self, **options) -> Union[pd.DataFrame, dd.DataFrame]:
         """Delegate asynchronous HTTP data loading to HttpDatabackend plugin."""
         if not self.backend_http:
             self.logger.debug("HTTP plugin not configured properly.")
@@ -164,12 +165,12 @@ class DfHelper:
             self.df = dd.from_pandas(pd.DataFrame(), npartitions=1)
         return self.df
 
-    def _post_process_df(self):
+    def __post_process_df(self):
         """
         Efficiently process the DataFrame by filtering, renaming, and setting indices.
         Optimized for large datasets with Dask compatibility.
         """
-        df_params = self.backend_params.df_params
+        df_params = self._backend_params.df_params
         fieldnames = df_params.get("fieldnames", None)
         index_col = df_params.get("index_col", None)
         datetime_index = df_params.get("datetime_index", False)
@@ -203,10 +204,10 @@ class DfHelper:
 
         self.logger.debug("Post-processing of DataFrame completed.")
 
-    def _process_loaded_data(self):
+    def __process_loaded_data(self):
         self.logger.debug(f"Type of self.df: {type(self.df)}")
         if self.df.map_partitions(len).compute().sum() > 0:
-            field_map = self.backend_params.field_map or {}
+            field_map = self._backend_params.field_map or {}
             if isinstance(field_map, dict):
                 rename_mapping = {k: v for k, v in field_map.items() if k in self.df.columns}
                 missing_columns = [k for k in field_map.keys() if k not in self.df.columns]
@@ -237,7 +238,7 @@ class DfHelper:
         cs.save_to_clickhouse(self.df)
         self.logger.debug("Save to ClickHouse completed.")
 
-    def _load_from_parquet(self, **options) -> Union[pd.DataFrame, dd.DataFrame]:
+    def __load_from_parquet(self, **options) -> Union[pd.DataFrame, dd.DataFrame]:
         self.df = self.backend_parquet.load_files()
         if options:
             """
@@ -274,7 +275,7 @@ class DfHelper:
             raise ValueError("The 'start' date cannot be later than the 'end' date.")
 
         # Reverse map to original field name
-        field_map = getattr(self.backend_params, 'field_map', {}) or {}
+        field_map = getattr(self._backend_params, 'field_map', {}) or {}
         reverse_map = {v: k for k, v in field_map.items()}
         mapped_field = reverse_map.get(dt_field, dt_field)
 

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/_parquet_artifact.py

@@ -1,6 +1,8 @@
 from typing import Optional, Any, Dict
+
 import dask.dataframe as dd
 import fsspec
+
 from sibi_dst.df_helper import DfHelper
 from sibi_dst.utils import DataWrapper
 from sibi_dst.utils import DateUtils
@@ -106,9 +108,10 @@ class ParquetArtifact(DfHelper):
             'parquet_start_date': start_date.strftime('%Y-%m-%d'),
             'parquet_end_date': end_date.strftime('%Y-%m-%d'),
         }
+
     def ensure_directory_exists(self, path: str) -> None:
         """Ensure the directory exists in the specified filesystem."""
         try:
             self.fs.makedirs(path, exist_ok=True)
         except Exception as e:
-            raise ValueError(f"Error creating directory {path} in filesystem {self.filesystem_type}: {e}")
+            raise ValueError(f"Error creating directory {path} in filesystem {self.filesystem_type}: {e}")

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/_parquet_reader.py

@@ -5,6 +5,7 @@ import fsspec
 
 from sibi_dst.df_helper import DfHelper
 
+
 class ParquetReader(DfHelper):
     DEFAULT_CONFIG = {
         'backend': 'parquet'
@@ -46,4 +47,4 @@ class ParquetReader(DfHelper):
             info = self.fs.info(self.parquet_storage_path)
             return info['type'] == 'directory'
         except FileNotFoundError:
-            return False
+            return False

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/django/__init__.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
 from ._django_db_connection import DjangoConnectionConfig
-from ._io_dask import ReadFrameDask
-#from ._io_dask_alt import ReadFrameDask
 from ._django_load_from_db import DjangoLoadFromDb
+from ._io_dask import ReadFrameDask
 
 __all__ = [
     "DjangoConnectionConfig",

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/django/_django_db_connection.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Any
 
 from pydantic import BaseModel, model_validator
 

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/django/_django_load_from_db.py

@@ -2,12 +2,12 @@ import warnings
 
 import dask.dataframe as dd
 import pandas as pd
-from IPython.core.hooks import deprecated
 from django.db.models import Q
 
 from sibi_dst.df_helper.backends.django import ReadFrameDask
-from sibi_dst.utils import Logger
 from sibi_dst.df_helper.core import django_field_conversion_map_dask
+from sibi_dst.utils import Logger
+
 
 class DjangoLoadFromDb:
     df: dd.DataFrame
@@ -28,17 +28,16 @@ class DjangoLoadFromDb:
 
     def build_and_load(self):
         self.df = self._build_and_load()
-        #self.df = self._convert_columns(self.df)
+        # self.df = self._convert_columns(self.df)
         return self.df
 
-
     def _build_and_load(self) -> dd.DataFrame:
         query = self.connection_config.model.objects.using(self.connection_config.connection_name)
         if not self.params_config.filters:
             # IMPORTANT: if no filters are provided show only the first n_records
             # this is to prevent loading the entire table by mistake
             n_records = self.query_config.n_records if self.query_config.n_records else 100
-            queryset=query.all()[:n_records]
+            queryset = query.all()[:n_records]
         else:
             q_objects = self.__build_query_objects(self.params_config.filters, self.query_config.use_exclude)
             queryset = query.filter(q_objects)
@@ -99,13 +98,12 @@ class DjangoLoadFromDb:
         # Simplified loop to apply conversions partition-wise
         for field_name, field_type in field_type_map.items():
             if field_name not in df.columns:
-
                 self.logger.debug(f"Column '{field_name}' not found in DataFrame columns.")
                 continue
 
             conversion_func = django_field_conversion_map_dask.get(field_type)
             if not conversion_func:
-                message=f"Field type '{field_type}' not found in conversion_map."
+                message = f"Field type '{field_type}' not found in conversion_map."
                 self.logger.debug(message)
                 continue
 
@@ -130,4 +128,4 @@ class DjangoLoadFromDb:
             except Exception as e:
                 self.logger.debug(f"Failed to queue conversion for column '{field_name}': {str(e)}")
 
-        return df
+        return df

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/django/_django_sql_model_builder.py

@@ -219,9 +219,9 @@ class DjangoSqlModelBuilder:
                         if field_type == "AutoField(":
                             continue
                         elif (
-                            field_type
-                            == connection.features.introspected_field_types["AutoField"]
-                            + "("
+                                field_type
+                                == connection.features.introspected_field_types["AutoField"]
+                                + "("
                         ):
                             comment_notes.append("AutoField?")
 
@@ -240,8 +240,8 @@ class DjangoSqlModelBuilder:
 
                     # Add comment.
                     if (
-                        hasattr(connection.features, "supports_comments")
-                        and row.comment
+                            hasattr(connection.features, "supports_comments")
+                            and row.comment
                     ):
                         extra_params["db_comment"] = row.comment
                     # if connection.features.supports_comments and row.comment:

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/django/_io_dask.py

@@ -1,7 +1,6 @@
 import itertools
 
 import dask.dataframe as dd
-import dask_expr
 import django
 import pandas as pd
 from django.core.cache import cache

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/django/_io_dask_alt.py

@@ -1,13 +1,14 @@
 import itertools
+
 import dask.dataframe as dd
+import django
 import pandas as pd
-
 from django.core.cache import cache
+from django.core.exceptions import FieldDoesNotExist
 from django.db import models
 from django.db.models import Field
 from django.utils.encoding import force_str as force_text
-import django
-from django.core.exceptions import FieldDoesNotExist
+
 
 class ReadFrameDask:
     FieldDoesNotExist = (
@@ -185,4 +186,4 @@ class ReadFrameDask:
         if verbose:
             self.update_with_verbose(dask_df, fieldnames, qs.model._meta.fields)
 
-        return dask_df
+        return dask_df

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/http/__init__.py

@@ -2,6 +2,6 @@ from __future__ import annotations
 
 from ._http_config import HttpConfig
 
-__all__=[
+__all__ = [
     'HttpConfig'
-]
+]

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/http/_http_config.py

@@ -1,10 +1,13 @@
-from pydantic import BaseModel, HttpUrl, Field, ConfigDict, SecretStr
 from typing import Dict, Optional, Any
-import httpx
+
 import dask.dataframe as dd
+import httpx
 import pandas as pd
+from pydantic import BaseModel, HttpUrl, Field, ConfigDict, SecretStr
+
 from sibi_dst.utils import Logger
 
+
 class HttpConfig(BaseModel):
     base_url: HttpUrl
     params: Optional[Dict[str, Any]] = Field(default_factory=dict)
@@ -44,4 +47,4 @@ class HttpConfig(BaseModel):
             raise
         except ValueError as e:
             self.logger.debug(f"Error parsing JSON data: {e}")
-            raise
+            raise

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/parquet/__init__.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from ._parquet_options import *
 from ._parquet_filter_handler import ParquetFilterHandler
+from ._parquet_options import *
 
-__all__=[
+__all__ = [
     "ParquetConfig",
     "ParquetFilterHandler",
-]
+]

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/parquet/_parquet_filter_handler.py

@@ -1,7 +1,9 @@
-import pandas as pd
 import dask.dataframe as dd
+import pandas as pd
+
 from sibi_dst.utils import Logger
 
+
 class ParquetFilterHandler(object):
     def __init__(self, logger=None):
         self.logger = logger or Logger.default_logger(logger_name=self.__class__.__name__)
@@ -92,4 +94,4 @@ class ParquetFilterHandler(object):
             else:
                 raise ValueError(f"Unsupported operation: {operation}")
 
-        return df
+        return df

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/parquet/_parquet_options.py

@@ -1,12 +1,15 @@
+import datetime
 from pathlib import Path
 from typing import Optional, List
+
 import dask.dataframe as dd
-from pydantic import BaseModel, model_validator, DirectoryPath, FilePath, ConfigDict
 import fsspec
-import datetime
+from pydantic import BaseModel, model_validator, DirectoryPath, FilePath, ConfigDict
+
 from sibi_dst.utils import FilePathGenerator
 from sibi_dst.utils import Logger
 
+
 class ParquetConfig(BaseModel):
     load_parquet: bool = False
     parquet_filename: Optional[str] = None
@@ -27,7 +30,8 @@ class ParquetConfig(BaseModel):
         # Configure paths based on fsspec
         if self.logger is None:
             self.logger = Logger.default_logger(logger_name=self.__class__.__name__)
-        self.fs = fsspec.filesystem("file") if "://" not in str(self.parquet_storage_path) else fsspec.filesystem(str(self.parquet_storage_path).split("://")[0])
+        self.fs = fsspec.filesystem("file") if "://" not in str(self.parquet_storage_path) else fsspec.filesystem(
+            str(self.parquet_storage_path).split("://")[0])
 
         # Validation for parquet path
         if self.parquet_storage_path is None:
@@ -37,7 +41,8 @@ class ParquetConfig(BaseModel):
         self.load_parquet = False
         if self.parquet_filename is not None:
             self.parquet_full_path = self.ensure_file_extension(
-                filepath=self.fs.sep.join([str(self.parquet_storage_path), str(self.parquet_filename)]), extension='parquet'
+                filepath=self.fs.sep.join([str(self.parquet_storage_path), str(self.parquet_filename)]),
+                extension='parquet'
             )
             self.parquet_is_recent = self.is_file_recent()
             self.load_parquet = self.parquet_is_recent and self.fs.exists(self.parquet_full_path)
@@ -52,10 +57,11 @@ class ParquetConfig(BaseModel):
                 raise ValueError('Parquet end date must be greater than start date')
 
             # Saving to parquet is disabled when start and end dates are provided, as we will load parquet files
-            self.parquet_folder_list = FilePathGenerator(str(self.parquet_storage_path), logger=self.logger).generate_file_paths(start_date, end_date)
+            self.parquet_folder_list = FilePathGenerator(str(self.parquet_storage_path),
+                                                         logger=self.logger).generate_file_paths(start_date, end_date)
             self.parquet_size_bytes = self.get_parquet_size_bytes()
             self.load_parquet = True
-            #self.load_parquet = all([self.fs.exists(folder) for folder in self.parquet_folder_list]) and self.parquet_size_bytes > 0
+            # self.load_parquet = all([self.fs.exists(folder) for folder in self.parquet_folder_list]) and self.parquet_size_bytes > 0
         elif self.parquet_end_date is not None:
             raise ValueError('Parquet start date must be specified if end date is provided')
 
@@ -88,4 +94,3 @@ class ParquetConfig(BaseModel):
     def ensure_file_extension(filepath: str, extension: str) -> str:
         path = Path(filepath)
         return str(path.with_suffix(f".{extension}")) if path.suffix != f".{extension}" else filepath
-

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/sql_alchemy/_io_sqlalchemy_dask.py

@@ -74,7 +74,9 @@ class SQLAlchemyDask:
                     deprecated specific filter handling to a generic one
                     #self.query = SqlAlchemyFilterHandler.apply_filters_sqlalchemy(self.query, self.model, self.filters)
                     """
-                    self.query = FilterHandler(backend="sqlalchemy", logger=self.logger).apply_filters(self.query, model=self.model, filters=self.filters)
+                    self.query = FilterHandler(backend="sqlalchemy", logger=self.logger).apply_filters(self.query,
+                                                                                                       model=self.model,
+                                                                                                       filters=self.filters)
                 else:
                     n_records = 100
                     self.query = self.query.limit(n_records)

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/sql_alchemy/_sqlachemy_filter_handler.py

@@ -52,7 +52,6 @@ class SqlAlchemyFilterHandler:
                     return [datetime.date.fromisoformat(v) for v in value]
             return value
 
-
         def handle_date_operator(column, date_op):
             """
             Handle filtering on specific datetime parts (e.g., year, month).
@@ -93,7 +92,7 @@ class SqlAlchemyFilterHandler:
 
             # Get the column from the model
             column = getattr(model, field_name, None)
-            #column = model.__table__.columns.get(field_name)
+            # column = model.__table__.columns.get(field_name)
             if not column:
                 raise AttributeError(f"Field '{field_name}' not found in model '{model.__name__}'")
 
@@ -117,4 +116,4 @@ class SqlAlchemyFilterHandler:
             else:
                 raise ValueError(f"Unsupported operation: {operation}")
 
-        return query
+        return query

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/sql_alchemy/_sqlalchemy_load_from_db.py

@@ -1,5 +1,4 @@
 import dask.dataframe as dd
-import dask_expr
 import pandas as pd
 
 from sibi_dst.df_helper.core import ParamsConfig, QueryConfig
@@ -7,6 +6,7 @@ from sibi_dst.utils import Logger
 from ._io_sqlalchemy_dask import SQLAlchemyDask
 from ._sqlalchemy_db_connection import SqlAlchemyConnectionConfig
 
+
 class SqlAlchemyLoadFromDb:
     df: dd.DataFrame = None
 
@@ -52,7 +52,7 @@ class SqlAlchemyLoadFromDb:
 
             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)
+                dask_df = dd.from_pandas(pd.DataFrame(), npartitions=1)
 
                 return dask_df
             return self.df

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/sql_alchemy/_sqlalchemy_model_builder.py

@@ -1,15 +1,17 @@
 import re
+
 from sqlalchemy import MetaData, Table
 from sqlalchemy.orm import declarative_base, relationship
 
 # Base class for dynamically created models
 Base = declarative_base()
 
-
 apps_label = "datacubes"
 
+
 class SqlAlchemyModelBuilder:
     _model_cache = {}  # Local cache for model classes
+
     def __init__(self, engine, table_name):
         """
         Initialize the model builder with a database engine and specific table.
@@ -58,7 +60,7 @@ class SqlAlchemyModelBuilder:
 
         # Add columns and relationships to the model
         attrs.update(columns)
-        #self.add_relationships(attrs, self.table)
+        # self.add_relationships(attrs, self.table)
         model = Base.registry._class_registry.get(self.class_name)
         if not model:
             model = type(self.class_name, (Base,), attrs)
@@ -126,4 +128,4 @@ class SqlAlchemyModelBuilder:
         column_name = re.sub(r"\W|^(?=\d)", "_", column_name)
         if column_name in {"class", "def", "return", "yield", "global"}:
             column_name += "_field"
-        return column_name
+        return column_name

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/sql_model/_sqlmodel_db_connection.py

@@ -1,9 +1,10 @@
+import datetime
 from typing import Any, Optional, Dict, Type
+
 from pydantic import BaseModel, model_validator
-from sqlmodel import SQLModel, Field, create_engine
 from sqlalchemy import inspect
-from sqlalchemy.sql import text
 from sqlalchemy.exc import OperationalError
+from sqlalchemy.sql import text
 from sqlalchemy.sql.sqltypes import (
     Integer,
     String,
@@ -14,7 +15,7 @@ from sqlalchemy.sql.sqltypes import (
     Time,
     Numeric,
 )
-import datetime
+from sqlmodel import SQLModel, Field, create_engine
 
 
 class SQLModelConnectionConfig(BaseModel):
@@ -130,4 +131,4 @@ class SQLModelConnectionConfig(BaseModel):
     @staticmethod
     def _table2model(table_name: str) -> str:
         """Convert table name to PascalCase model name."""
-        return "".join(word.capitalize() for word in table_name.split("_"))
+        return "".join(word.capitalize() for word in table_name.split("_"))

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/sql_model/_sqlmodel_load_from_db.py

@@ -1,19 +1,21 @@
-import dask.dataframe as dd
-from sqlmodel import Session, select, text
-from typing import Any, Dict, Optional
 import logging
+from typing import Any, Dict, Optional
+
+import dask.dataframe as dd
 import pandas as pd
+from sqlmodel import Session, select, text
+
 
 class SQLModelLoadFromDb:
     df: dd.DataFrame
 
     def __init__(
-        self,
-        db_connection,
-        db_query: Optional[Dict[str, Any]] = None,
-        db_params: Optional[Dict[str, Any]] = None,
-        logger=None,
-        **kwargs,
+            self,
+            db_connection,
+            db_query: Optional[Dict[str, Any]] = None,
+            db_params: Optional[Dict[str, Any]] = None,
+            logger=None,
+            **kwargs,
     ):
         """
         Initialize the loader with database connection, query, and parameters.
@@ -74,7 +76,7 @@ class SQLModelLoadFromDb:
                 results = session.exec(query).fetchall()
 
                 # Convert query results to a Dask DataFrame
-                print("results:",results)
+                print("results:", results)
                 if results:
                     df = dd.from_pandas(pd.DataFrame([r.dict() for r in results]), npartitions=1)
                 else:
@@ -96,4 +98,4 @@ class SQLModelLoadFromDb:
         if field_map:
             rename_mapping = {k: v for k, v in field_map.items() if k in self.df.columns}
             if rename_mapping:
-                self.df = self.df.rename(columns=rename_mapping, meta={v: "object" for v in rename_mapping.values()})
+                self.df = self.df.rename(columns=rename_mapping, meta={v: "object" for v in rename_mapping.values()})

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/core/_defaults.py

@@ -54,8 +54,10 @@ django_field_conversion_map_dask: Dict[str, callable] = {
     "BooleanField": lambda x: x.astype(bool),
     "NullBooleanField": lambda x: x.astype(bool),
     "DateTimeField": lambda x: pd.to_datetime(x, errors="coerce"),
-    "DateField": lambda x: pd.to_datetime(x, errors="coerce").map_partitions(lambda x: x.dt.date, meta=("date", "object")),
-    "TimeField": lambda x: pd.to_datetime(x, errors="coerce").map_partitions(lambda x: x.dt.time, meta=("time", "object")),
+    "DateField": lambda x: pd.to_datetime(x, errors="coerce").map_partitions(lambda x: x.dt.date,
+                                                                             meta=("date", "object")),
+    "TimeField": lambda x: pd.to_datetime(x, errors="coerce").map_partitions(lambda x: x.dt.time,
+                                                                             meta=("time", "object")),
     "DurationField": lambda x: pd.to_timedelta(x, errors="coerce"),
     "JSONField": lambda x: x.map_partitions(lambda s: s.apply(json.loads), meta=("json", "object")),
     "ArrayField": lambda x: x.map_partitions(lambda s: s.apply(eval), meta=("array", "object")),
@@ -72,12 +74,15 @@ sqlalchemy_field_conversion_map_dask: Dict[str, callable] = {
     Numeric.__name__: lambda x: pd.to_numeric(x, errors="coerce"),
     Boolean.__name__: lambda x: x.astype(bool),
     DateTime.__name__: lambda x: pd.to_datetime(x, errors="coerce"),
-    Date.__name__: lambda x: pd.to_datetime(x, errors="coerce").map_partitions(lambda x: x.dt.date, meta=("date", "object")),
-    Time.__name__: lambda x: pd.to_datetime(x, errors="coerce").map_partitions(lambda x: x.dt.time, meta=("time", "object")),
+    Date.__name__: lambda x: pd.to_datetime(x, errors="coerce").map_partitions(lambda x: x.dt.date,
+                                                                               meta=("date", "object")),
+    Time.__name__: lambda x: pd.to_datetime(x, errors="coerce").map_partitions(lambda x: x.dt.time,
+                                                                               meta=("time", "object")),
     JSON.__name__: lambda x: x.map_partitions(lambda s: s.apply(json.loads), meta=("json", "object")),
     UUID.__name__: lambda x: x.astype(str),
 }
 
+
 # Conversion map with normalized SQLAlchemy field types
 # sqlalchemy_field_conversion_map_dask: Dict[str, callable] = {
 #     "String": lambda x: x.map_partitions(lambda s: s.astype(str), meta=("string", "string")),
@@ -129,5 +134,3 @@ def normalize_sqlalchemy_type(field_type):
 
     # Fallback to raw class name
     return field_type.__class__.__name__
-
-

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/core/_filter_handler.py

@@ -1,10 +1,13 @@
 import datetime
+
 import dask.dataframe as dd
 import pandas as pd
 from sqlalchemy import func, cast
 from sqlalchemy.sql.sqltypes import Date, Time
+
 from sibi_dst.utils import Logger
 
+
 class FilterHandler:
     def __init__(self, backend, logger=None):
         """
@@ -15,7 +18,8 @@ class FilterHandler:
             logger: Optional logger for debugging purposes.
         """
         self.backend = backend
-        self.logger = logger or Logger.default_logger(logger_name=self.__class__.__name__)  # No-op logger if none provided
+        self.logger = logger or Logger.default_logger(
+            logger_name=self.__class__.__name__)  # No-op logger if none provided
         self.backend_methods = self._get_backend_methods(backend)
 
     def apply_filters(self, query_or_df, model=None, filters=None):
@@ -34,7 +38,7 @@ class FilterHandler:
         for key, value in filters.items():
             field_name, casting, operation = self._parse_filter_key(key)
             parsed_value = self._parse_filter_value(casting, value)
-            #print(field_name, casting, operation, parsed_value)
+            # print(field_name, casting, operation, parsed_value)
             # Get the column and apply backend-specific transformations
             if self.backend == "sqlalchemy":
                 column = self.backend_methods["get_column"](field_name, model, casting)
@@ -67,7 +71,6 @@ class FilterHandler:
 
         return field_name, casting, operation
 
-
     def _parse_filter_value(self, casting, value):
         """
         Convert filter value to appropriate type based on the casting (e.g., date).
@@ -213,4 +216,4 @@ class FilterHandler:
         return [
             "gte", "lte", "gt", "lt", "exact", "in", "range",
             "contains", "startswith", "endswith", "isnull",
-        ]
+        ]

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/core/_params_config.py

@@ -1,7 +1,7 @@
+from typing import Optional, Dict, Union, List
 
 from pydantic import BaseModel, model_validator, Field
 
-from typing import Optional, Dict, Union, List
 dataframe_params: Dict[str, Union[None, str, bool, int, None]] = {
     "fieldnames": None,
     "index_col": None,
@@ -25,6 +25,7 @@ dataframe_options: Dict[str, Union[bool, str, int, None]] = {
 
 LOOKUP_SEP = "__"
 
+
 class ParamsConfig(BaseModel):
     field_map: Optional[Dict] = Field(default_factory=dict)
     legacy_filters: bool = False
@@ -76,4 +77,4 @@ class ParamsConfig(BaseModel):
             new_filter_field = LOOKUP_SEP.join(new_parts)
             new_filters[new_filter_field] = value
 
-        self.filters = new_filters
+        self.filters = new_filters

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/core/_query_config.py

@@ -1,7 +1,5 @@
 from typing import Optional
 
-import dask.dataframe as dd
-import pandas as pd
 from pydantic import BaseModel, model_validator
 
 

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/utils/__init__.py

@@ -1,18 +1,19 @@
 from __future__ import annotations
+
+from ._airflow_manager import AirflowDAGManager
+from ._clickhouse_writer import ClickHouseWriter
 from ._credentials import *
-from ._log_utils import Logger
-from ._date_utils import *
 from ._data_utils import DataUtils
+from ._data_wrapper import DataWrapper
+from ._date_utils import *
+from ._df_utils import DfUtils
 from ._file_utils import FileUtils
 from ._filepath_generator import FilePathGenerator
-from ._df_utils import DfUtils
-from ._storage_manager import StorageManager
+from ._log_utils import Logger
 from ._parquet_saver import ParquetSaver
-from ._clickhouse_writer import ClickHouseWriter
-from ._data_wrapper import DataWrapper
-from ._airflow_manager import AirflowDAGManager
+from ._storage_manager import StorageManager
 
-__all__=[
+__all__ = [
     "ConfigManager",
     "ConfigLoader",
     "Logger",
@@ -27,4 +28,4 @@ __all__=[
     "DfUtils",
     "ClickHouseWriter",
     "AirflowDAGManager",
-]
+]

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/utils/_airflow_manager.py

@@ -1,8 +1,9 @@
 import os
-from jinja2 import Template
 from datetime import datetime
+
 import fsspec
 import httpx
+from jinja2 import Template
 
 """
     A manager to dynamically generate, save, and upload Airflow DAGs via SSH using fsspec.
@@ -54,8 +55,8 @@ with DAG(
     {% endfor %}
 """
 
-class AirflowDAGManager:
 
+class AirflowDAGManager:
 
     def __init__(self, output_dir, remote_dags_path, ssh_host, ssh_user, ssh_password, url, auth, wrapper_module_path):
         """
@@ -208,4 +209,4 @@ class AirflowDAGManager:
             return response.json()
         except httpx.RequestError as e:
             print(f"Failed to trigger DAG {dag_id}: {e}")
-            raise
+            raise

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/utils/_clickhouse_writer.py

@@ -1,9 +1,12 @@
+from concurrent.futures import ThreadPoolExecutor
+
 import clickhouse_connect
+import pandas as pd
 from clickhouse_driver import Client
 from dask.dataframe import dd
-import pandas as pd
+
 from sibi_dst.utils import Logger
-from concurrent.futures import ThreadPoolExecutor
+
 
 class ClickHouseWriter:
     dtype_to_clickhouse = {
@@ -19,20 +22,20 @@ class ClickHouseWriter:
     df: dd.DataFrame
 
     def __init__(self, logger=None, **kwargs):
-        self.clickhouse_host = kwargs.setdefault('host',"localhost")
-        self.clickhouse_port = kwargs.setdefault('port',8123)
-        self.clickhouse_dbname = kwargs.setdefault('database','sibi_data')
-        self.clickhouse_user = kwargs.setdefault('user','default')
-        self.clickhouse_password = kwargs.setdefault('password','')
-        self.clickhouse_table = kwargs.setdefault('table','test_sibi_table')
+        self.clickhouse_host = kwargs.setdefault('host', "localhost")
+        self.clickhouse_port = kwargs.setdefault('port', 8123)
+        self.clickhouse_dbname = kwargs.setdefault('database', 'sibi_data')
+        self.clickhouse_user = kwargs.setdefault('user', 'default')
+        self.clickhouse_password = kwargs.setdefault('password', '')
+        self.clickhouse_table = kwargs.setdefault('table', 'test_sibi_table')
 
         self.logger = logger or Logger.default_logger(logger_name=self.__class__.__name__)
         self.client = None
-        self.order_by=kwargs.setdefault('order_by','id')
+        self.order_by = kwargs.setdefault('order_by', 'id')
 
     def save_to_clickhouse(self, df, **kwargs):
         self.df = df.copy()
-        self.order_by = kwargs.setdefault('order_by',self.order_by)
+        self.order_by = kwargs.setdefault('order_by', self.order_by)
         if len(self.df.head().index) == 0:
             self.logger.debug("Dataframe is empty")
             return
@@ -86,8 +89,8 @@ class ClickHouseWriter:
         if engine is None:
             engine = f"ENGINE = MergeTree() order by {self.order_by}"
         dtypes = self.df.dtypes
-        clickhouse_schema = self._generate_clickhouse_schema(dtypes,self.dtype_to_clickhouse)
-        create_table_sql= f"CREATE TABLE IF NOT EXISTS {self.clickhouse_table} ({clickhouse_schema}) {engine};"
+        clickhouse_schema = self._generate_clickhouse_schema(dtypes, self.dtype_to_clickhouse)
+        create_table_sql = f"CREATE TABLE IF NOT EXISTS {self.clickhouse_table} ({clickhouse_schema}) {engine};"
         self.logger.debug(f"Creating table SQL:{create_table_sql}")
         if self.client:
             self.client.command(create_table_sql)
@@ -200,4 +203,4 @@ class ClickHouseWriter:
             with ThreadPoolExecutor() as executor:
                 executor.map(write_partition, partitions, range(len(partitions)))
         except Exception as e:
-            self.logger.error(f"Error during multi-partition write: {e}")
+            self.logger.error(f"Error during multi-partition write: {e}")

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/utils/_data_wrapper.py

@@ -1,12 +1,15 @@
 import datetime
 from typing import Type, Any, Dict, Optional
+
 import fsspec
 import pandas as pd
 from IPython.display import display
-from sibi_dst.utils import Logger
 from tqdm import tqdm
+
+from sibi_dst.utils import Logger
 from sibi_dst.utils import ParquetSaver
 
+
 class DataWrapper:
     DEFAULT_MAX_AGE_MINUTES = 1440
     DEFAULT_HISTORY_DAYS_THRESHOLD = 30
@@ -89,7 +92,7 @@ class DataWrapper:
             # Filter dates in the category where `update_required` is True
             dates_to_process = update_plan_table[
                 (update_plan_table["update_category"] == category) & (update_plan_table["update_required"])
-            ]["date"].tolist()
+                ]["date"].tolist()
 
             date_iterator = dates_to_process
             if self.show_progress:
@@ -130,7 +133,7 @@ class DataWrapper:
         data_object = self.dataclass(**self.class_params)
         df = data_object.load_period(dt_field=self.date_field, start=date, end=date)
 
-        if len(df.index)==0:
+        if len(df.index) == 0:
             self.logger.error("No data found for the specified date.")
             return
 
@@ -194,7 +197,7 @@ class DataWrapper:
                 "missing_file": missing_file,
                 "update_required": update_required,
                 "update_category": category,
-                "datawrapper class":self.dataclass.__name__
+                "datawrapper class": self.dataclass.__name__
             })
 
         update_plan_table = pd.DataFrame(rows)

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/utils/_date_utils.py

@@ -1,8 +1,9 @@
 import datetime
-from typing import Union, Tuple, Callable, Dict, Any
+from typing import Union, Tuple, Callable, Dict
 
 import numpy as np
 import pandas as pd
+
 from sibi_dst.utils import Logger
 
 
@@ -32,7 +33,8 @@ class DateUtils:
         raise ValueError(f"Unsupported date format: {value}")
 
     @classmethod
-    def calc_week_range(cls, reference_date: Union[str, datetime.date, datetime.datetime, pd.Timestamp]) -> Tuple[datetime.date, datetime.date]:
+    def calc_week_range(cls, reference_date: Union[str, datetime.date, datetime.datetime, pd.Timestamp]) -> Tuple[
+        datetime.date, datetime.date]:
         """
         Calculate the start and end of the week for a given reference date.
         """
@@ -49,7 +51,8 @@ class DateUtils:
         return datetime.date(year, 1, 1), datetime.date(year, 12, 31)
 
     @classmethod
-    def get_first_day_of_the_quarter(cls, reference_date: Union[str, datetime.date, datetime.datetime, pd.Timestamp]) -> datetime.date:
+    def get_first_day_of_the_quarter(cls, reference_date: Union[
+        str, datetime.date, datetime.datetime, pd.Timestamp]) -> datetime.date:
         """
         Get the first day of the quarter for a given date.
         """
@@ -58,7 +61,8 @@ class DateUtils:
         return datetime.date(reference_date.year, 3 * quarter - 2, 1)
 
     @classmethod
-    def get_last_day_of_the_quarter(cls, reference_date: Union[str, datetime.date, datetime.datetime, pd.Timestamp]) -> datetime.date:
+    def get_last_day_of_the_quarter(cls, reference_date: Union[
+        str, datetime.date, datetime.datetime, pd.Timestamp]) -> datetime.date:
         """
         Get the last day of the quarter for a given date.
         """
@@ -116,10 +120,12 @@ class DateUtils:
             'current_month': lambda: cls.get_month_range(n=0),
             'last_month': lambda: cls.get_month_range(n=-1),
             'current_year': lambda: cls.get_year_timerange(today().year),
-            'current_quarter': lambda: (cls.get_first_day_of_the_quarter(today()), cls.get_last_day_of_the_quarter(today())),
+            'current_quarter': lambda: (
+            cls.get_first_day_of_the_quarter(today()), cls.get_last_day_of_the_quarter(today())),
             'ytd': lambda: (datetime.date(today().year, 1, 1), today()),
         }
 
+
 class BusinessDays:
     def __init__(self, holiday_list, logger):
         """

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/utils/_df_utils.py

@@ -1,7 +1,9 @@
-import pandas as pd
 import dask.dataframe as dd
+import pandas as pd
+
 from ._log_utils import Logger
 
+
 class DfUtils:
     def __init__(self, logger=None):
         """
@@ -210,7 +212,7 @@ class DfUtils:
             df['Total'] = df.sum(axis=1, numeric_only=True)
         return df
 
-    def summarise_data(self,df, summary_column, values_column, rule='D', agg_func='count'):
+    def summarise_data(self, df, summary_column, values_column, rule='D', agg_func='count'):
         """
         Summarizes data by creating a pivot table and resampling.
 
@@ -233,10 +235,12 @@ class DfUtils:
                 df = df.set_index(dd.to_datetime(df.index))
 
             # Group by index and summary columns
-            df_grouped = df.groupby([dd.to_datetime(df.index)] + [summary_column])[values_column].agg(agg_func).reset_index()
+            df_grouped = df.groupby([dd.to_datetime(df.index)] + [summary_column])[values_column].agg(
+                agg_func).reset_index()
 
             # Pivot the table
-            df_pivot = df_grouped.pivot_table(index='index', columns=summary_column, values=values_column, aggfunc='sum').fillna(0)
+            df_pivot = df_grouped.pivot_table(index='index', columns=summary_column, values=values_column,
+                                              aggfunc='sum').fillna(0)
 
             # Resample
             df_pivot.index = dd.to_datetime(df_pivot.index)
@@ -269,4 +273,4 @@ class DfUtils:
         Returns:
             DataFrame: Resampled pivot table.
         """
-        return DfUtils.summarise_data(df, summary_columns, value_columns, rule=rule, agg_func=agg_func)
+        return DfUtils.summarise_data(df, summary_columns, value_columns, rule=rule, agg_func=agg_func)

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/utils/_file_utils.py

@@ -1,10 +1,12 @@
 import shutil
 from pathlib import Path
 from typing import Optional
+
 import fsspec
 
 from sibi_dst.utils import Logger
 
+
 class FileUtils:
     def __init__(self, logger=None):
         self.logger = logger or Logger.default_logger(logger_name=self.__class__.__name__)
@@ -27,7 +29,7 @@ class FileUtils:
             fs.mkdirs(path)
 
     @staticmethod
-    def construct_full_path(storage_path:str, parquet_filename: Optional[str]) -> Path:
+    def construct_full_path(storage_path: str, parquet_filename: Optional[str]) -> Path:
         """Construct and return the full path for the parquet file."""
         fs, base_path = fsspec.core.url_to_fs(storage_path)
         parquet_filename = parquet_filename or "default.parquet"

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/utils/_filepath_generator.py

@@ -1,7 +1,8 @@
 import datetime
-import fsspec
 import re
 
+import fsspec
+
 from sibi_dst.utils import Logger
 
 
@@ -150,6 +151,7 @@ class FilePathGenerator:
             return datetime.datetime.strptime(date, '%Y-%m-%d')
         return date
 
+
 """
 Usage:
 # Initialize the generator
@@ -182,4 +184,4 @@ for fp in file_paths:
 
 df_pandas = pd.concat(dataframes, ignore_index=True)
 print(df_pandas.head())
-"""
+"""

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/utils/_log_utils.py

@@ -71,4 +71,4 @@ class Logger:
         self.logger.error(msg)
 
     def critical(self, msg):
-        self.logger.critical(msg)
+        self.logger.critical(msg)

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/utils/_parquet_saver.py

@@ -1,7 +1,6 @@
 from pathlib import Path
 from typing import Optional
 
-import dask_expr
 import fsspec
 import pyarrow as pa
 
@@ -103,4 +102,3 @@ class ParquetSaver:
         self.df_result.to_parquet(
             str(full_path), engine="pyarrow", schema=schema, write_index=False
         )
-

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/sql_alchemy/__init__.py

@@ -1,6 +1,6 @@
+from ._sqlachemy_filter_handler import SqlAlchemyFilterHandler
 from ._sqlalchemy_db_connection import SqlAlchemyConnectionConfig
-from ._sqlalchemy_model_builder import SqlAlchemyModelBuilder
 from ._sqlalchemy_load_from_db import SqlAlchemyLoadFromDb
-from ._sqlachemy_filter_handler import SqlAlchemyFilterHandler
+from ._sqlalchemy_model_builder import SqlAlchemyModelBuilder
 
 __all__ = ['SqlAlchemyConnectionConfig', 'SqlAlchemyModelBuilder', 'SqlAlchemyLoadFromDb', 'SqlAlchemyFilterHandler']

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/sql_alchemy/_sqlalchemy_db_connection.py

@@ -1,18 +1,19 @@
 from typing import Any, Optional
 
 from pydantic import BaseModel, model_validator
+from sqlalchemy import create_engine
 from sqlalchemy.exc import OperationalError
 from sqlalchemy.sql import text
-from sqlalchemy import create_engine
+
 from ._sqlalchemy_model_builder import SqlAlchemyModelBuilder
 
+
 class SqlAlchemyConnectionConfig(BaseModel):
     connection_url: str
     table: Optional[str] = None
     model: Any = None
     engine: Optional[Any] = None  # Save engine to reuse it
 
-
     @model_validator(mode="after")
     def validate_and_initialize(self):
         """
@@ -45,4 +46,3 @@ class SqlAlchemyConnectionConfig(BaseModel):
                 connection.execute(text("SELECT 1"))
         except OperationalError as e:
             raise ValueError(f"Failed to connect to the database: {e}")
-

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/df_helper/backends/sql_model/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from ._sqlmodel_load_from_db import SQLModelLoadFromDb
 from ._sqlmodel_db_connection import SQLModelConnectionConfig
+from ._sqlmodel_load_from_db import SQLModelLoadFromDb
 
 __all__ = [
     "SQLModelLoadFromDb",

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/utils/_credentials.py

@@ -1,5 +1,6 @@
 import os
 
+
 class ConfigLoader:
     def __init__(self, prefix, keys, defaults=None):
         """
@@ -54,4 +55,3 @@ class ConfigManager:
         :return: The configuration dictionary.
         """
         return self.configurations.get(name, {})
-

{sibi_dst-0.3.19 → sibi_dst-0.3.21}/sibi_dst/utils/_storage_manager.py

@@ -1,4 +1,5 @@
 from types import SimpleNamespace
+
 import fsspec
 
 
@@ -86,4 +87,3 @@ class StorageManager:
         print("Rebuilding depot structure...")
         self.rebuild_depot_paths(depots, clear_existing=clear_existing)
         print("Rebuild complete.")
-