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

sibi_dst/v2/df_helper/core/_filter_handler.py

@@ -0,0 +1,236 @@
+import datetime
+import itertools
+import dask.dataframe as dd
+import pandas as pd
+from sqlalchemy import func, cast
+from sqlalchemy.sql.sqltypes import Date, Time
+from sibi_dst.v2.utils import Logger
+import typing
+
+
+class FilterHandler:
+    """
+    Handles the application of filters to data sources with support for SQLAlchemy, SQLModel, and Dask backends.
+
+    This class abstracts the process of applying filters to various backends, specifically
+    SQLAlchemy/SQLModel queries and Dask DataFrames. It supports multiple filtering operations,
+    including exact matches, comparisons, and string-related operations such as contains and regex.
+    """
+
+    def __init__(self, backend, logger=None, debug=False):
+        """
+        Initialize the FilterHandler.
+
+        Args:
+            backend: The backend to use ('sqlalchemy', 'sqlmodel', or 'dask').
+            logger: Optional logger for debugging purposes.
+        """
+        self.backend = backend
+        self.logger = logger or Logger.default_logger(logger_name=self.__class__.__name__)
+        self.logger.set_level(Logger.DEBUG if debug else Logger.INFO)
+        self.backend_methods = self._get_backend_methods(backend)
+
+    def apply_filters(self, query_or_df, model=None, filters=None):
+        """
+        Apply filters to the data source based on the backend.
+
+        Args:
+            query_or_df: A SQLAlchemy/SQLModel query or Dask DataFrame.
+            model: SQLAlchemy/SQLModel model (required for SQLAlchemy/SQLModel backend).
+            filters: Dictionary of filters.
+
+        Returns:
+            Filtered query or DataFrame.
+        """
+        filters = filters or {}
+        for key, value in filters.items():
+            field_name, casting, operation = self._parse_filter_key(key)
+            parsed_value = self._parse_filter_value(casting, value)
+            # For both SQLAlchemy and SQLModel, use the same backend methods.
+            if self.backend in ("sqlalchemy", "sqlmodel"):
+                column = self.backend_methods["get_column"](field_name, model, casting)
+                condition = self.backend_methods["apply_operation"](column, operation, parsed_value)
+                query_or_df = self.backend_methods["apply_condition"](query_or_df, condition)
+            elif self.backend == "dask":
+                column = self.backend_methods["get_column"](query_or_df, field_name, casting)
+                condition = self.backend_methods["apply_operation"](column, operation, parsed_value)
+                query_or_df = self.backend_methods["apply_condition"](query_or_df, condition)
+            else:
+                raise ValueError(f"Unsupported backend: {self.backend}")
+
+        return query_or_df
+
+    @staticmethod
+    def _parse_filter_key(key):
+        parts = key.split("__")
+        field_name = parts[0]
+        casting = None
+        operation = "exact"
+
+        if len(parts) == 3:
+            _, casting, operation = parts
+        elif len(parts) == 2:
+            if parts[1] in FilterHandler._comparison_operators():
+                operation = parts[1]
+            elif parts[1] in FilterHandler._dt_operators() + FilterHandler._date_operators():
+                casting = parts[1]
+
+        return field_name, casting, operation
+
+    def _parse_filter_value(self, casting, value):
+        """
+        Convert filter value to an appropriate type based on the casting (e.g., date).
+        """
+        if casting == "date":
+            if isinstance(value, str):
+                return pd.Timestamp(value)  # Convert to datetime64[ns]
+            if isinstance(value, list):
+                return [pd.Timestamp(v) for v in value]
+        elif casting == "time" and isinstance(value, str):
+            parsed = datetime.time.fromisoformat(value)
+            self.logger.debug(f"Parsed value (time): {parsed}")
+            return parsed
+        return value
+
+    @staticmethod
+    def _get_backend_methods(backend):
+        if backend in ("sqlalchemy", "sqlmodel"):
+            return {
+                "get_column": FilterHandler._get_sqlalchemy_column,
+                "apply_operation": FilterHandler._apply_operation_sqlalchemy,
+                "apply_condition": lambda query, condition: query.filter(condition),
+            }
+        elif backend == "dask":
+            return {
+                "get_column": FilterHandler._get_dask_column,
+                "apply_operation": FilterHandler._apply_operation_dask,
+                "apply_condition": lambda df, condition: df[condition],
+            }
+        else:
+            raise ValueError(f"Unsupported backend: {backend}")
+
+    @staticmethod
+    def _get_sqlalchemy_column(field_name, model, casting):
+        """
+        Retrieve and cast a column for SQLAlchemy/SQLModel based on the field name and casting.
+
+        Args:
+            field_name: The name of the field/column.
+            model: The SQLAlchemy/SQLModel model.
+            casting: The casting type ('date', 'time', etc.).
+
+        Returns:
+            The SQLAlchemy column object, optionally cast or transformed.
+        """
+        column = getattr(model, field_name, None)
+        if not column:
+            raise AttributeError(f"Field '{field_name}' not found in model '{model.__name__}'")
+        if casting == "date":
+            column = cast(column, Date)
+        elif casting == "time":
+            column = cast(column, Time)
+        elif casting in FilterHandler._date_operators():
+            column = func.extract(casting, column)
+        return column
+
+    @staticmethod
+    def _get_dask_column(df, field_name, casting):
+        """
+        Retrieve and optionally cast a column for Dask based on the field name and casting.
+
+        Args:
+            df: The Dask DataFrame.
+            field_name: The name of the field/column.
+            casting: The casting type ('date', 'time', etc.).
+
+        Returns:
+            The Dask Series, optionally cast or transformed.
+        """
+        column = dd.to_datetime(df[field_name], errors="coerce") if casting in FilterHandler._dt_operators() else df[field_name]
+        if casting == "date":
+            column = column.dt.floor("D")
+        elif casting in FilterHandler._date_operators():
+            column = getattr(column.dt, casting)
+        return column
+
+    @staticmethod
+    def _apply_operation_sqlalchemy(column, operation, value):
+        operation_map = FilterHandler._operation_map_sqlalchemy()
+        if operation not in operation_map:
+            raise ValueError(f"Unsupported operation: {operation}")
+        return operation_map[operation](column, value)
+
+    @staticmethod
+    def _apply_operation_dask(column, operation, value):
+        operation_map = FilterHandler._operation_map_dask()
+        if operation not in operation_map:
+            raise ValueError(f"Unsupported operation: {operation}")
+        return operation_map[operation](column, value)
+
+    @staticmethod
+    def _operation_map_sqlalchemy():
+        return {
+            "exact": lambda col, val: col == val,
+            "gt": lambda col, val: col > val,
+            "gte": lambda col, val: col >= val,
+            "lt": lambda col, val: col < val,
+            "lte": lambda col, val: col <= val,
+            "in": lambda col, val: col.in_(val),
+            "range": lambda col, val: col.between(val[0], val[1]),
+            "contains": lambda col, val: col.like(f"%{val}%"),
+            "startswith": lambda col, val: col.like(f"{val}%"),
+            "endswith": lambda col, val: col.like(f"%{val}"),
+            "isnull": lambda col, val: col.is_(None) if val else col.isnot(None),
+            "not_exact": lambda col, val: col != val,
+            "not_contains": lambda col, val: ~col.like(f"%{val}%"),
+            "not_in": lambda col, val: ~col.in_(val),
+            "regex": lambda col, val: col.op("~")(val),
+            "icontains": lambda col, val: col.ilike(f"%{val}%"),
+            "istartswith": lambda col, val: col.ilike(f"{val}%"),
+            "iendswith": lambda col, val: col.ilike(f"%{val}"),
+            "iexact": lambda col, val: col.ilike(val),
+            "iregex": lambda col, val: col.op("~*")(val),
+        }
+
+    @staticmethod
+    def _operation_map_dask():
+        return {
+            "exact": lambda col, val: col == val,
+            "gt": lambda col, val: col > val,
+            "gte": lambda col, val: col >= val,
+            "lt": lambda col, val: col < val,
+            "lte": lambda col, val: col <= val,
+            "in": lambda col, val: col.isin(val),
+            "range": lambda col, val: (col >= val[0]) & (col <= val[1]),
+            "contains": lambda col, val: col.str.contains(val, regex=True),
+            "startswith": lambda col, val: col.str.startswith(val),
+            "endswith": lambda col, val: col.str.endswith(val),
+            "isnull": lambda col, val: col.isnull() if val else col.notnull(),
+            "not_exact": lambda col, val: col != val,
+            "not_contains": lambda col, val: ~col.str.contains(val, regex=True),
+            "not_in": lambda col, val: ~col.isin(val),
+            "regex": lambda col, val: col.str.contains(val, regex=True),
+            "icontains": lambda col, val: col.str.contains(val, case=False, regex=True),
+            "istartswith": lambda col, val: col.str.startswith(val, case=False),
+            "iendswith": lambda col, val: col.str.endswith(val, case=False),
+            "iexact": lambda col, val: col.str.contains(f"^{val}$", case=False, regex=True),
+            "iregex": lambda col, val: col.str.contains(val, case=False, regex=True),
+        }
+
+    @staticmethod
+    def _dt_operators():
+        return ["date", "time"]
+
+    @staticmethod
+    def _date_operators():
+        return ["year", "month", "day", "hour", "minute", "second", "week_day"]
+
+    @staticmethod
+    def _comparison_operators():
+        return [
+            "gte", "lte", "gt", "lt", "exact", "in", "range",
+            "contains", "startswith", "endswith", "isnull",
+            "not_exact", "not_contains", "not_in",
+            "regex", "icontains", "istartswith", "iendswith",
+            "iexact", "iregex"
+        ]

sibi_dst/v2/df_helper/core/_params_config.py

@@ -0,0 +1,139 @@
+from typing import Optional, Dict, Union, List
+
+from pydantic import BaseModel, model_validator, Field
+
+dataframe_params: Dict[str, Union[None, str, bool, int, None]] = {
+    "fieldnames": None,
+    "index_col": None,
+    "coerce_float": False,
+    "verbose": True,
+    "datetime_index": False,
+    "column_names": None,
+    "chunk_size": 1000,
+}
+# dataframe_options is a dictionary that provides additional options for modifying a pandas DataFrame.
+# These options include parameters for handling duplicate values, sorting, grouping, and other DataFrame operations.
+
+dataframe_options: Dict[str, Union[bool, str, int, None]] = {
+    "debug": False,  # Whether to print debug information
+    "duplicate_expr": None,  # Expression for identifying duplicate values
+    "duplicate_keep": 'last',  # How to handle duplicate values ('first', 'last', or False)
+    "sort_field": None,  # Field to use for sorting the DataFrame
+    "group_by_expr": None,  # Expression for grouping the DataFrame
+    "group_expr": None  # Expression for aggregating functions to the grouped DataFrame
+}
+
+LOOKUP_SEP = "__"
+
+
+class ParamsConfig(BaseModel):
+    """
+    Defines a configuration model for parameters with functionality for parsing,
+    validation, and conversion of legacy filters.
+
+    This class extends BaseModel from Pydantic and is designed to handle multiple
+    sets of configurations, including field mappings, filters, dataframe parameters,
+    and dataframe options. It allows for flexible parsing of parameters across a
+    variety of supported structures and ensures that legacy filters can be
+    appropriately converted for compatibility.
+
+    :ivar field_map: Maps field names to their equivalent legacy field names.
+    :type field_map: Optional[Dict]
+    :ivar legacy_filters: Indicates whether legacy filters should be processed.
+    :type legacy_filters: bool
+    :ivar sticky_filters: Stores additional filters as key-value pairs that persist
+        across parameter parsing.
+    :type sticky_filters: Dict[str, Union[str, bool, int, float, list, tuple]]
+    :ivar filters: Holds all the current filters including sticky and dynamically
+        parsed filters.
+    :type filters: Dict[str, Union[str, Dict, bool, int, float, list, tuple]]
+    :ivar df_params: Contains parameters related to dataframe configurations in a
+        structured format.
+    :type df_params: Dict[str, Union[tuple, str, bool, None]]
+    :ivar df_options: Stores optional configurations for a dataframe, allowing for
+        additional behavior customization.
+    :type df_options: Dict[str, Union[bool, str, None]]
+    :ivar params: Dictionary of parameters provided for configuration, supporting
+        both basic and nested structures.
+    :type params: Dict[str, Union[str, bool, int, float, List[Union[str, int, bool, float]]]]
+    """
+    field_map: Optional[Dict] = Field(default_factory=dict)
+    legacy_filters: bool = False
+    sticky_filters: Dict[str, Union[str, bool, int, float, list, tuple]] = Field(default_factory=dict)
+    filters: Dict[str, Union[str, Dict, bool, int, float, list, tuple]] = Field(default_factory=dict)
+    df_params: Dict[str, Union[tuple, str, bool, None]] = Field(default_factory=dict)
+    df_options: Dict[str, Union[bool, str, None]] = Field(default_factory=dict)
+    params: Dict[str, Union[str, bool, int, float, List[Union[str, int, bool, float]]]] = Field(default_factory=dict)
+
+    @model_validator(mode='after')
+    def check_params(self):
+        if self.params is not None:
+            self.parse_params(self.params)
+        return self
+
+    def parse_params(self, params):
+        """
+        Parses and separates the given parameters into specific categories such as dataframe parameters,
+        dataframe options, and filters. Updates existing class attributes with the parsed values,
+        retaining any sticky filters. Also handles the legacy filters if provided.
+
+        :param params: Dictionary containing parameters to process. These parameters can include specific
+            keys relevant for dataframe configuration (e.g., dataframe parameters, dataframe options)
+            as well as arbitrary filter settings.
+        :type params: dict
+        :return: None
+        """
+        self.legacy_filters = params.pop('legacy_filters', self.legacy_filters)
+        self.field_map = params.pop('field_map', self.field_map)
+        self.sticky_filters = params.pop('params', self.sticky_filters)
+        df_params, df_options, filters = {}, {}, {}
+        for k, v in params.items():
+            if k in dataframe_params.keys():
+                df_params.update({k: v})
+            elif k in dataframe_options.keys():
+                df_options.update({k: v})
+            else:
+                filters.update({k: v})
+        self.filters = {**self.sticky_filters, **filters}
+        self.df_params = {**self.df_params, **df_params}
+        self.df_options = {**self.df_options, **df_options}
+        if self.legacy_filters:
+            self.convert_legacy_filters()
+
+    def convert_legacy_filters(self):
+        """
+            Converts legacy filter fields in the `self.filters` dictionary to their
+            modern equivalents using the mappings provided in `self.field_map`.
+            This method ensures backward compatibility for filters by automatically
+            translating the old field names into the current system.
+
+            The function first verifies that the required dictionaries (`legacy_filters`,
+            `field_map`, `filters`) are valid. It creates a reverse map of `field_map` for
+            efficient lookup, processes the key names within `self.filters`, and updates
+            them to reflect the legacy mapping.
+
+            :raises KeyError: If any required dictionary key is missing during processing.
+
+            :param self.legacy_filters: A boolean flag indicating whether legacy filters
+                are being used.
+            :type self.legacy_filters: bool
+
+        """
+        if not self.legacy_filters or not self.field_map or not self.filters:
+            return
+        # create a reverse map of the field_map
+        reverse_map = {v: k for k, v in self.field_map.items()}
+
+        new_filters = {}
+        for filter_field, value in self.filters.items():
+            # split the filter_field if LOOKUP_SEP exists
+            parts = filter_field.split(LOOKUP_SEP, 1)
+
+            # replace each part with its legacy equivalent if it exists
+            new_parts = [reverse_map.get(part, part) for part in parts]
+
+            # join the parts back together and add to the new filters
+            new_filter_field = LOOKUP_SEP.join(new_parts)
+            new_filters[new_filter_field] = value
+
+        self.filters = new_filters

sibi_dst/v2/df_helper/core/_query_config.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+from pydantic import BaseModel, model_validator
+
+
+class QueryConfig(BaseModel):
+    use_exclude: bool = False
+    n_records: int = 100
+    dt_field: Optional[str] = None
+    use_dask: bool = False
+    as_dask: bool = False
+
+    @model_validator(mode='after')
+    def check_n_records(self):
+        if self.n_records < 0:
+            raise ValueError('Number of records must be non-negative')
+        return self

sibi_dst/v2/utils/__init__.py

@@ -0,0 +1,5 @@
+from .log_utils import Logger
+
+__all__ = [
+    "Logger",
+]

sibi_dst/v2/utils/log_utils.py

@@ -0,0 +1,120 @@
+import logging
+import os
+import sys
+import time
+from typing import Optional
+
+class Logger:
+    """
+    Handles the creation, setup, and management of logging functionalities.
+    """
+    DEBUG = logging.DEBUG
+    INFO = logging.INFO
+    WARNING = logging.WARNING
+    ERROR = logging.ERROR
+    CRITICAL = logging.CRITICAL
+
+    def __init__(self, log_dir: str, logger_name: str, log_file: str, debug: bool = False):
+        """
+        Initialize the Logger instance.
+        :param log_dir: Directory where logs are stored.
+        :param logger_name: Name of the logger instance.
+        :param log_file: Base name of the log file.
+        :param debug: Whether to enable debug mode (defaults to False).
+        """
+        self.log_dir = log_dir
+        self.logger_name = logger_name
+        self.log_file = log_file
+        self.debug_mode = debug  # Add a debug flag
+        self.logger = None
+        self._setup()
+
+    def _setup(self):
+        """Set up the logger with file and console handlers."""
+        # Ensure the log directory exists
+        os.makedirs(self.log_dir, exist_ok=True)
+
+        # Get the name of the calling script
+        calling_script = os.path.splitext(os.path.basename(sys.argv[0]))[0]
+
+        # Create a log file path
+        log_file_path = os.path.join(self.log_dir, f"{self.log_file}_{calling_script}.log")
+
+        # Delete the existing log file if it exists
+        if os.path.exists(log_file_path):
+            os.remove(log_file_path)
+
+        # Create a logger
+        self.logger = logging.getLogger(self.logger_name)
+        self.logger.setLevel(self._get_log_level())  # Dynamically set the log level
+
+        # Create a formatter
+        formatter = logging.Formatter(
+            '[%(asctime)s] [%(levelname)s] [%(name)s] %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        formatter.converter = time.localtime  # Set local time explicitly
+
+        # Create a file handler
+        file_handler = logging.FileHandler(log_file_path)
+        file_handler.setFormatter(formatter)
+        self.logger.addHandler(file_handler)
+
+        # Create a console handler (optional)
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(formatter)
+        self.logger.addHandler(console_handler)
+
+    def _get_log_level(self) -> int:
+        """
+        Determine the logging level based on the debug flag.
+        :return: Logging level (DEBUG if debug is True, otherwise INFO).
+        """
+        return logging.DEBUG if self.debug_mode else logging.INFO
+
+    @classmethod
+    def default_logger(
+            cls,
+            log_dir: str = './logs/',
+            logger_name: Optional[str] = None,
+            log_file: Optional[str] = None,
+            debug: bool = False
+    ) -> 'Logger':
+        """
+        Class-level method to create a default logger with generic parameters.
+        :param log_dir: Directory where logs are stored (defaults to './logs/').
+        :param logger_name: Name of the logger (defaults to __name__).
+        :param log_file: Name of the log file (defaults to logger_name).
+        :param debug: Whether to enable debug mode (defaults to False).
+        :return: Instance of Logger.
+        """
+        logger_name = logger_name or __name__
+        log_file = log_file or logger_name
+        return cls(log_dir=log_dir, logger_name=logger_name, log_file=log_file, debug=debug)
+
+    def set_level(self, level: int):
+        """
+        Set the logging level for the logger.
+        :param level: Logging level (e.g., logging.DEBUG, logging.INFO).
+        """
+        self.logger.setLevel(level)
+
+    def debug(self, msg: str):
+        """Log a debug message."""
+        self.logger.debug(msg)
+
+    def info(self, msg: str):
+        """Log an info message."""
+        self.logger.info(msg)
+
+    def warning(self, msg: str):
+        """Log a warning message."""
+        self.logger.warning(msg)
+
+    def error(self, msg: str):
+        """Log an error message."""
+        self.logger.error(msg)
+
+    def critical(self, msg: str):
+        """Log a critical message."""
+        self.logger.critical(msg)

{sibi_dst-0.3.45.dist-info → sibi_dst-0.3.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sibi-dst
-Version: 0.3.45
+Version: 0.3.46
 Summary: Data Science Toolkit
 Author: Luis Valverde
 Author-email: lvalverdeb@gmail.com
@@ -14,12 +14,12 @@ Requires-Dist: chardet (>=5.2.0,<6.0.0)
 Requires-Dist: charset-normalizer (>=3.4.0,<4.0.0)
 Requires-Dist: clickhouse-connect (>=0.8.7,<0.9.0)
 Requires-Dist: clickhouse-driver (>=0.2.9,<0.3.0)
-Requires-Dist: dask-expr (>=1.1.20,<2.0.0)
 Requires-Dist: dask[complete] (>=2024.11.1,<2025.0.0)
 Requires-Dist: django (>=5.1.4,<6.0.0)
 Requires-Dist: djangorestframework (>=3.15.2,<4.0.0)
 Requires-Dist: folium (>=0.19.4,<0.20.0)
 Requires-Dist: geopandas (>=1.0.1,<2.0.0)
+Requires-Dist: geopy (>=2.4.1,<3.0.0)
 Requires-Dist: gunicorn (>=23.0.0,<24.0.0)
 Requires-Dist: httpx (>=0.27.2,<0.28.0)
 Requires-Dist: ipython (>=8.29.0,<9.0.0)
@@ -40,6 +40,7 @@ Requires-Dist: pytest-mock (>=3.14.0,<4.0.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: s3fs (>=2024.12.0,<2025.0.0)
 Requires-Dist: sqlalchemy (>=2.0.36,<3.0.0)
+Requires-Dist: sqlmodel (>=0.0.22,<0.0.23)
 Requires-Dist: tornado (>=6.4.1,<7.0.0)
 Requires-Dist: tqdm (>=4.67.0,<5.0.0)
 Requires-Dist: uvicorn (>=0.34.0,<0.35.0)

sibi_dst-0.3.46.dist-info/RECORD

@@ -0,0 +1,80 @@
+sibi_dst/__init__.py,sha256=uwF7KQ9TjongYh3qIA36hSSjR85TVJKuZI0WUPqLYJg,1576
+sibi_dst/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sibi_dst/v1/df_helper/__init__.py,sha256=A-f5cCBy949HHxgiPt0T4MG3qdLAnDpGOpRvP-2dXWc,400
+sibi_dst/v1/df_helper/_artifact_updater_multi_wrapper.py,sha256=Ghfee9dELU8CGUMdWeZxyThSFZMd6jTGKednLrRKh4U,11649
+sibi_dst/v1/df_helper/_df_helper.py,sha256=veist8sExgeOT3Xpjp5L9n3djQdQoG435oPQx-NluF8,29780
+sibi_dst/v1/df_helper/_parquet_artifact.py,sha256=HOgfANd3ivGBCHf63q8UN-75NWyo0Tr7fzRqfeVKB3I,10202
+sibi_dst/v1/df_helper/_parquet_reader.py,sha256=fmSepQmxjWp59gbecAd_ThMC68gDnKMaAUeciVRVpQY,3960
+sibi_dst/v1/df_helper/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sibi_dst/v1/df_helper/backends/django/__init__.py,sha256=uWHi-DtQX5re7b2HcqoXUH3_FZWOw1VTmDf552FAkNs,256
+sibi_dst/v1/df_helper/backends/django/_db_connection.py,sha256=AGbqCnmiX4toMaFPE5ne5h7QCkImjnBKvzGtUD6Ge8Q,3698
+sibi_dst/v1/df_helper/backends/django/_io_dask.py,sha256=NjvJg6y9qKKCRiNrJL4f_A03iKDKEcjCi7LGbr9DgtM,19555
+sibi_dst/v1/df_helper/backends/django/_load_from_db.py,sha256=Htr4jDYB6MQQqQyJKOiqv9AfheUXlL4XzOlL3-wFBeY,10646
+sibi_dst/v1/df_helper/backends/django/_sql_model_builder.py,sha256=at9J7ecGkZbOOYba85uofe9C-ic4wwOqVgJcHpQNiYQ,21449
+sibi_dst/v1/df_helper/backends/http/__init__.py,sha256=d1pfgYxbiYg7E0Iw8RbJ7xfqIfJShqqTBQQGU_S6OOo,105
+sibi_dst/v1/df_helper/backends/http/_http_config.py,sha256=YFpduRY-00dNwGJwFuHleGyp5mP56IfPdhSY_kTJ6O0,4729
+sibi_dst/v1/df_helper/backends/parquet/__init__.py,sha256=esWJ9aSuYC26d-T01z9dPrJ1uqJzvdaPNTYRb5qXTlQ,182
+sibi_dst/v1/df_helper/backends/parquet/_filter_handler.py,sha256=hBhrMLHFIOoVWEVyc6Jyp_XTopg6u7i3s0FhmVpISyI,5222
+sibi_dst/v1/df_helper/backends/parquet/_parquet_options.py,sha256=yueBidL07wYr6EMZCERHqX0FPTZCGBHaZD6AXFcclCo,10597
+sibi_dst/v1/df_helper/backends/sqlalchemy/__init__.py,sha256=TuVp8Ce49dCIIxtyrtFGRblarQUl8QGcS-TDZd515IE,348
+sibi_dst/v1/df_helper/backends/sqlalchemy/_db_connection.py,sha256=Kli83IEg5SFVqkhsK4w45cV6PbZnfdGanfsyiW6Xw00,2502
+sibi_dst/v1/df_helper/backends/sqlalchemy/_filter_handler.py,sha256=58RCda1Hg_nsuJw-2V36IstsT8O84IQFgsdE7FnqvMk,4655
+sibi_dst/v1/df_helper/backends/sqlalchemy/_io_dask.py,sha256=FvsNYb__wmT-D8pZYEwfrq6uPJihi77AfEAinkuGiwo,5472
+sibi_dst/v1/df_helper/backends/sqlalchemy/_load_from_db.py,sha256=PFA22DF3avh2jPEt6uqN16jpxRwPZIzs_E5qMjcdw9M,6265
+sibi_dst/v1/df_helper/backends/sqlalchemy/_sql_model_builder.py,sha256=ksvJ0EvktrVsoJ9DTMIQHzHe8ghw2mzDIBD_YgWytgw,8402
+sibi_dst/v1/df_helper/core/__init__.py,sha256=o4zDwgVmaijde3oix0ezb6KLxI5QFy-SGUhFTDVFLT4,569
+sibi_dst/v1/df_helper/core/_defaults.py,sha256=eNpHD2sZxir-2xO0b3_V16ryw8YP_5FfpIKK0HNuiN4,7011
+sibi_dst/v1/df_helper/core/_filter_handler.py,sha256=TLUSEiGudCTmOv5htAFi-RQtXXU367Wk6cqLKVSbT-U,11217
+sibi_dst/v1/df_helper/core/_params_config.py,sha256=DYx2drDz3uF-lSPzizPkchhy-kxRrQKE5FQRxcEWsac,6736
+sibi_dst/v1/df_helper/core/_query_config.py,sha256=Y8LVSyaKuVkrPluRDkQoOwuXHQxner1pFWG3HPfnDHM,441
+sibi_dst/v1/df_helper/data_cleaner.py,sha256=lkxQoXLvGzXCicFUimnA5nen5qkrO1oxgl_p2Be2o8w,5183
+sibi_dst/v1/geopy_helper/__init__.py,sha256=Q1RJiUZIOlV0QNNLjxZ_2IZS5LqIe5jRbeQkfD1Vm60,112
+sibi_dst/v1/geopy_helper/geo_location_service.py,sha256=1ArI980QF_gRw096ZsABHwJt-m55jrfOlB8tPwL1BvY,2959
+sibi_dst/v1/geopy_helper/utils.py,sha256=Sb7qfSqIyWh-AZ4GBdB9-z5FrQPWtrdtQLLcNjph0yw,3351
+sibi_dst/v1/osmnx_helper/__init__.py,sha256=eHM2XenOdI-Rc1deeUCVoT_OidtPJRMcveKenqxzCJM,116
+sibi_dst/v1/osmnx_helper/base_osm_map.py,sha256=L7g3VBiayHX41BcCBTOCS0iJOKzp2ZZYcrp8N-mnU90,19392
+sibi_dst/v1/osmnx_helper/basemaps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sibi_dst/v1/osmnx_helper/basemaps/calendar_html.py,sha256=UArt6FDgoCgoRte45Xo3IHqd-RNzW0YgitgZYfOFasY,4031
+sibi_dst/v1/osmnx_helper/basemaps/router_plotter.py,sha256=SWdDz5XGDSHT6Iyr-EIatSNTvGPR3AVDJ5TTcWm0w4g,10947
+sibi_dst/v1/osmnx_helper/utils.py,sha256=BzuY8CtYnBAAO8UAr_M7EOk6CP1zcifNLs8pkdFZEFg,20577
+sibi_dst/v1/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sibi_dst/v1/tests/test_data_wrapper_class.py,sha256=hCSZ0aubhWNlu2pBV8jG56UsSHhnjQ6hHLdN4Q4YLTw,3342
+sibi_dst/v1/utils/__init__.py,sha256=QE4ZRfLWdsjMYJIxznjJlPoLneK8RPPf9gIh6aEhxkY,938
+sibi_dst/v1/utils/airflow_manager.py,sha256=-d44EKUZNYJyp4wuNwRvilRQktunArPOB5fZuWdQv10,7526
+sibi_dst/v1/utils/clickhouse_writer.py,sha256=JE_WMsnLTlxoABIDLuvrDUVHkTidlev8gSC4krDag3M,9879
+sibi_dst/v1/utils/credentials.py,sha256=cHJPPsmVyijqbUQIq7WWPe-lIallA-mI5RAy3YUuRME,1724
+sibi_dst/v1/utils/data_from_http_source.py,sha256=AcpKNsqTgN2ClNwuhgUpuNCx62r5_DdsAiKY8vcHEBA,1867
+sibi_dst/v1/utils/data_utils.py,sha256=MqbwXk33BuANWeKKmsabHouhb8GZswSmbM-VetWWE-M,10357
+sibi_dst/v1/utils/data_wrapper.py,sha256=pIIQxeHknUeQd0YbISkAhL-xYBK4OdijoATBY-oBznw,12114
+sibi_dst/v1/utils/date_utils.py,sha256=7cqgC6WEcfkh6BKTgq-kyig4H9rf_0VzpySPYElSo_0,18359
+sibi_dst/v1/utils/df_utils.py,sha256=GAX0lthULTmGaDvYzuLmo0op7YKaCM5uot403QpztoM,11278
+sibi_dst/v1/utils/file_utils.py,sha256=Z99CZ_4nPDIaZqbCfzzUDfAYJjSudWDj-mwEO8grhbc,1253
+sibi_dst/v1/utils/filepath_generator.py,sha256=-HHO0U-PR8fysDDFwnWdHRlgqksh_RkmgBZLWv9hM7s,6669
+sibi_dst/v1/utils/log_utils.py,sha256=eSAbi_jmMpJ8RpycakzT4S4zNkqVZDj3FY8WwnxpdXc,4623
+sibi_dst/v1/utils/parquet_saver.py,sha256=Tucxv9jRX66VuLQZn0dPQBN7JOttBou6SF8FxqufeGE,8169
+sibi_dst/v1/utils/phone_formatter.py,sha256=tsVTDamuthFYgy4-5UwmQkPQ-FGTGH7MjZyH8utAkIY,4945
+sibi_dst/v1/utils/storage_config.py,sha256=ugM70OHo63dN7LPukl0FZTWwXKBuoCILFh3RdNEeMgY,1239
+sibi_dst/v1/utils/storage_manager.py,sha256=H_itUFJv9nP0BfXYYQDsw4RzB0YWfgVOAHNWAiMpZ_w,4443
+sibi_dst/v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sibi_dst/v2/df_helper/__init__.py,sha256=XuH6jKYAPg2DdRbsxxBSxp9X3x-ARyaT0xe27uILrVo,99
+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/_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/_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
+sibi_dst/v2/df_helper/core/__init__.py,sha256=rZhBh32Rgcxj4MBii-KsYVJQmrT9egiWKXk68gWKblo,197
+sibi_dst/v2/df_helper/core/_filter_handler.py,sha256=54jyz7OUigUqwlyl5gzy1d7aJ_oXV3aMORCoqZIf6sY,10100
+sibi_dst/v2/df_helper/core/_params_config.py,sha256=DYx2drDz3uF-lSPzizPkchhy-kxRrQKE5FQRxcEWsac,6736
+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.46.dist-info/METADATA,sha256=Z9QXdfU6JmUrcR45dFKItdGtHrcR7UBlC37adJWrz-A,6552
+sibi_dst-0.3.46.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+sibi_dst-0.3.46.dist-info/RECORD,,

sibi_dst/osmnx_helper/__init__.py

@@ -1,9 +0,0 @@
-from __future__ import annotations
-
-from .v1.base_osm_map import BaseOsmMap
-from .v1.utils import PBFHandler
-
-__all__ = [
-    "BaseOsmMap",
-    "PBFHandler",
-]