sibi-dst 0.3.20__py3-none-any.whl → 0.3.22__py3-none-any.whl

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/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/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/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/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/df_helper/backends/django/__init__.py

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

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/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/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/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/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/df_helper/backends/http/__init__.py

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

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/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/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/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/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/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/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/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/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/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/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/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("_"))