sibi-dst 2025.9.13__py3-none-any.whl → 2025.9.15__py3-none-any.whl

sibi_dst/df_helper/_df_helper.py

@@ -137,7 +137,7 @@ class DfHelper(ManagedResource):
     def __init__(self, backend="sqlalchemy", **kwargs):
         self.default_config = self.default_config or {}
         kwargs = {**self.default_config.copy(), **kwargs}
-        kwargs.setdefault("auto_sse", True)
+        kwargs.setdefault("auto_sse", False)
         super().__init__(**kwargs)
         self.backend = backend
 

sibi_dst/utils/base.py

@@ -14,7 +14,18 @@ from sibi_dst.utils import Logger
 
 # --------- Minimal built-in SSE sink (used when auto_sse=True) ----------
 class _QueueSSE:
-    """Async queue–backed SSE sink: async send/put, async iterator, graceful close."""
+    """
+    Handles asynchronous streaming of events with structured data.
+
+    This class provides the ability to manage an asynchronous queue for handling
+    streamed Server-Sent Events (SSE). It supports operations like sending events
+    with associated data, manually enqueuing items, and iterating over items in an
+    asynchronous loop. The class also includes mechanisms for clean closure of the
+    stream.
+
+    :ivar q: An asynchronous queue used to store events and data.
+    :type q: asyncio.Queue
+    """
     __slots__ = ("q", "_closed")
 
     def __init__(self) -> None:
@@ -46,11 +57,31 @@ class _QueueSSE:
 # ------------------------------ Base class ------------------------------
 class ManagedResource(abc.ABC):
     """
-    Owns a logger and optional fsspec filesystem. Can emit SSE events via:
-    - an async emitter callable:  await emitter(event, data)
-    - a sink exposing async send(event, data) or async put(item)
-    If neither is provided and auto_sse=True, a queue-backed sink is created eagerly.
-    Thread-safe lifecycle, CM support, GC finalizer.
+    Management of shared resources with configurable verbosity, logging,
+    and support for external file systems and server-sent events (SSE).
+
+    This class is designed to assist in managing resources such as logging,
+    file systems, and SSE within an asynchronous or synchronous environment.
+    It provides facilities for handling resource lifecycle, introspection,
+    and cleanup while ensuring resources are appropriately managed. The class
+    also supports lazy initialization of external dependencies via factories.
+
+    :ivar verbose: Controls verbosity of logging or operations. If set to True,
+        more detailed logging/output will be generated.
+    :type verbose: bool
+    :ivar debug: Enables debug-level logging and internal diagnostics when True.
+        Typically used for troubleshooting purposes.
+    :type debug: bool
+    :ivar logger: The logger instance used for this resource. If left unset,
+        a default logger will be created.
+    :type logger: Optional[Logger]
+    :ivar fs: The file system interface being used. Typically an instance of
+        `fsspec.AbstractFileSystem`. If not provided, it may be created lazily
+        using a supplied factory function.
+    :type fs: Optional[fsspec.AbstractFileSystem]
+    :ivar emitter: A callable, potentially asynchronous, function for emitting
+        events. Events are sent as a combination of event names and payload data.
+    :type emitter: Optional[Callable[[str, Dict[str, Any]], Awaitable[None]]]
     """
 
     __slots__ = (
@@ -74,28 +105,23 @@ class ManagedResource(abc.ABC):
         debug: bool = False,
         log_cleanup_errors: bool = True,
         logger: Optional[Logger] = None,
-        # filesystem
         fs: Optional[fsspec.AbstractFileSystem] = None,
         fs_factory: Optional[Callable[[], fsspec.AbstractFileSystem]] = None,
-        # SSE
         emitter: Optional[Callable[[str, Dict[str, Any]], Awaitable[None]]] = None,
         emitter_factory: Optional[Callable[[], Callable[[str, Dict[str, Any]], Awaitable[None]]]] = None,
         sse: Optional[object] = None,
         sse_factory: Optional[Callable[[], object]] = None,
-        auto_sse: bool = False,           # eager auto-create if no emitter/sink is supplied
+        auto_sse: bool = False,
         **_: object,
     ) -> None:
-        # flags
         self.verbose = verbose
         self.debug = debug
         self._log_cleanup_errors = log_cleanup_errors
 
-        # lifecycle
         self._is_closed = False
         self._closing = False
         self._close_lock = threading.RLock()
 
-        # logger
         if logger is None:
             self.logger = Logger.default_logger(logger_name=self.__class__.__name__)
             self._owns_logger = True
@@ -105,7 +131,6 @@ class ManagedResource(abc.ABC):
             self.logger = logger
             self._owns_logger = False
 
-        # fs
         self.fs: Optional[fsspec.AbstractFileSystem] = None
         self._fs_factory = None
         self._owns_fs = False
@@ -119,7 +144,6 @@ class ManagedResource(abc.ABC):
             self._fs_factory = fs_factory
             self._owns_fs = True
 
-        # sse / emitter
         self._sse: Optional[object] = None
         self._sse_factory: Optional[Callable[[], object]] = None
         self._owns_sse = False
@@ -140,16 +164,15 @@ class ManagedResource(abc.ABC):
             self._sse_factory = sse_factory
             self._owns_sse = True
 
-        # EAGER auto-SSE: create sink+emitter now if none supplied
         if self._auto_sse and self._sse is None and self._emitter is None and self._sse_factory is None:
             self._create_auto_sse()
 
-        # GC finalizer
+        # Garbage Collector finaliser
         self._finalizer = weakref.finalize(self, self._finalize_static, weakref.ref(self))
 
         if self.debug:
             with contextlib.suppress(Exception):
-                self.logger.debug("Initialized %s %s", self.__class__.__name__, repr(self))
+                self.logger.debug("Initialised %s %s", self.__class__.__name__, repr(self))
 
     # ---------- Introspection ----------
     @property
@@ -222,7 +245,6 @@ class ManagedResource(abc.ABC):
 
     # ---------- SSE ----------
     def _create_auto_sse(self) -> None:
-        # internal helper: create queue sink + emitter, mark as owned
         sink = _QueueSSE()
         self._sse = sink
         self._owns_sse = True

sibi_dst/utils/dask_utils.py

@@ -5,7 +5,6 @@ import logging
 from typing import List, Any, Dict
 
 import dask
-# dask.config.set({"distributed.worker.daemon": False})
 import dask.dataframe as dd
 
 def _to_int_safe(x) -> int:
@@ -64,52 +63,158 @@ class UniqueValuesExtractor:
         pairs = await asyncio.gather(*(one(c) for c in columns))
         return dict(pairs)
 
-from contextlib import suppress, asynccontextmanager
-from dask.distributed import Client, LocalCluster, get_client
+import asyncio
+import json
+import logging
 import os
+import tempfile
+from contextlib import suppress, asynccontextmanager, contextmanager
+from typing import Optional
+from dask.distributed import Client, LocalCluster, get_client
+from filelock import FileLock
+
 
 class DaskClientMixin:
     """
-    Provides shared Dask client lifecycle management.
-    Ensures reuse of an existing client if available,
-    or creates a local in-process Dask cluster for fallback.
+    Provides shared Dask client lifecycle management with:
+    - Shared registry (JSON + file lock)
+    - Automatic refcounting across processes
+    - Auto-cleanup of stale clusters
+    - Optional background watchdog to monitor cluster health
     """
 
+    REGISTRY_PATH = os.path.join(tempfile.gettempdir(), "shared_dask_cluster.json")
+    REGISTRY_LOCK = FileLock(REGISTRY_PATH + ".lock")
+    WATCHDOG_INTERVAL = 60  # seconds between health checks
+
+    def __init__(self, **kwargs):
+        self.dask_client: Optional[Client] = None
+        self.own_dask_client: bool = False
+        self.logger = kwargs.get("logger") or logging.getLogger(__name__)
+        self._watchdog_task: Optional[asyncio.Task] = None
+        self._watchdog_stop = asyncio.Event()
+
+    # ----------------------------------------------------------------------
+    # Registry management
+    # ----------------------------------------------------------------------
+    @classmethod
+    def _read_registry(cls) -> Optional[dict]:
+        """Read registry JSON if it exists and is valid."""
+        if not os.path.exists(cls.REGISTRY_PATH):
+            return None
+        try:
+            with open(cls.REGISTRY_PATH, "r") as f:
+                data = json.load(f)
+            if "address" not in data or not isinstance(data["address"], str):
+                return None
+            return data
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    @classmethod
+    def _write_registry(cls, data: dict) -> None:
+        """Write updated registry JSON atomically."""
+        tmp_path = cls.REGISTRY_PATH + ".tmp"
+        with open(tmp_path, "w") as f:
+            json.dump(data, f)
+        os.replace(tmp_path, cls.REGISTRY_PATH)
+
+    @classmethod
+    def _remove_registry(cls) -> None:
+        """Delete the registry file if present."""
+        with suppress(FileNotFoundError):
+            os.remove(cls.REGISTRY_PATH)
+
+    @classmethod
+    def _cleanup_stale_registry(cls, logger=None):
+        """Detect and remove stale registry entries if cluster is unreachable."""
+        registry = cls._read_registry()
+        if not registry:
+            return
+        try:
+            client = Client(address=registry["address"], timeout=5)
+            client.close()
+        except Exception:
+            if logger:
+                logger.warning(
+                    f"Detected stale Dask cluster registry at {registry.get('address')}. Cleaning up."
+                )
+            cls._remove_registry()
+
+    # ----------------------------------------------------------------------
+    # Dask client initialization
+    # ----------------------------------------------------------------------
     def _init_dask_client(
         self,
-        dask_client=None,
-        logger=None,
+        dask_client: Optional[Client] = None,
         *,
-        n_workers: int = 1,
+        logger=None,
+        scheduler_address: Optional[str] = None,
+        use_remote_cluster: bool = False,
+        n_workers: int = 2,
         threads_per_worker: int = 1,
         processes: bool = False,
         asynchronous: bool = False,
         memory_limit: str = "auto",
-        #dashboard_address: str | None = None,
-        local_directory: str | None = None,
+        local_directory: Optional[str] = None,
         silence_logs: str = "info",
-        resources: dict | None = None,
+        resources: Optional[dict] = None,
         timeout: int = 30,
+        watchdog: bool = True,
     ):
+        """Initialize or attach to a shared Dask client."""
+        self.logger = logger or self.logger
         self.dask_client = dask_client
         self.own_dask_client = False
-        self.logger = logger
-        # Apply log filters globally
-        logging.getLogger("distributed.shuffle._scheduler_plugin").setLevel(
-            logging.ERROR
-        )
+
+        # Silence excessive logging
         logging.getLogger("distributed.scheduler").setLevel(logging.WARNING)
         logging.getLogger("distributed.worker").setLevel(logging.WARNING)
+        logging.getLogger("distributed.shuffle._scheduler_plugin").setLevel(logging.ERROR)
 
+        # 1️⃣ Try reusing existing client
         if self.dask_client is None:
             with suppress(ValueError, RuntimeError):
-                # Try to attach to an existing client (common in shared Dask setups)
                 self.dask_client = get_client()
 
-        if self.dask_client is None:
-            # Default to half of logical cores if not specified
-            n_workers = n_workers or max(2, os.cpu_count() // 2)
+        # 2️⃣ Try remote cluster connection
+        if self.dask_client is None and use_remote_cluster and scheduler_address:
+            try:
+                self.dask_client = Client(address=scheduler_address, timeout=timeout)
+                self.own_dask_client = True
+                self.logger.info(
+                    f"Connected to external Dask scheduler at {scheduler_address}. "
+                    f"Dashboard: {self.dask_client.dashboard_link}"
+                )
+                if watchdog:
+                    self._start_watchdog()
+                return
+            except Exception as e:
+                self.logger.warning(
+                    f"Failed to connect to remote Dask scheduler: {e}. Falling back to local cluster."
+                )
 
+        # 3️⃣ Shared local cluster via registry
+        with self.REGISTRY_LOCK:
+            self._cleanup_stale_registry(self.logger)
+            registry = self._read_registry()
+
+            if registry:
+                try:
+                    self.dask_client = Client(address=registry["address"], timeout=timeout)
+                    registry["refcount"] = registry.get("refcount", 0) + 1
+                    self._write_registry(registry)
+                    self.logger.info(
+                        f"Reusing existing LocalCluster at {registry['address']} (refcount={registry['refcount']})."
+                    )
+                    if watchdog:
+                        self._start_watchdog()
+                    return
+                except Exception:
+                    self.logger.warning("Existing cluster unreachable. Recreating.")
+                    self._remove_registry()
+
+            # Create a new local cluster
             cluster = LocalCluster(
                 n_workers=n_workers,
                 threads_per_worker=threads_per_worker,
@@ -124,77 +229,208 @@ class DaskClientMixin:
 
             self.dask_client = Client(cluster)
             self.own_dask_client = True
+            registry = {"address": cluster.scheduler_address, "refcount": 1}
+            self._write_registry(registry)
+            self.logger.info(
+                f"Started new LocalCluster ({n_workers} workers × {threads_per_worker} threads). "
+                f"Dashboard: {self.dask_client.dashboard_link}"
+            )
 
-            if self.logger:
-                self.logger.info(
-                    f"Started local Dask cluster with {n_workers} workers × {threads_per_worker} threads "
-                    f"({memory_limit} memory per worker). Dashboard: {self.dask_client.dashboard_link}"
-                )
-        else:
-            if self.logger:
-                self.logger.debug(
-                    f"Using existing Dask client: {self.dask_client.dashboard_link}"
-                )
+        if watchdog:
+            self._start_watchdog()
+
+    # ----------------------------------------------------------------------
+    # Watchdog logic
+    # ----------------------------------------------------------------------
+    def _start_watchdog(self):
+        """Spawn a background watchdog that monitors registry health."""
+        async def watchdog_loop():
+            while not self._watchdog_stop.is_set():
+                await asyncio.sleep(self.WATCHDOG_INTERVAL)
+                try:
+                    self._cleanup_stale_registry(self.logger)
+                except Exception as e:
+                    self.logger.warning(f"Dask watchdog encountered an error: {e}")
+
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                self._watchdog_task = loop.create_task(watchdog_loop())
+                self.logger.debug("Started Dask registry watchdog (async).")
+        except RuntimeError:
+            # Fallback for synchronous usage
+            self.logger.debug("Watchdog skipped (no active event loop).")
+
+    async def _stop_watchdog(self):
+        """Stop the watchdog loop gracefully."""
+        self._watchdog_stop.set()
+        if self._watchdog_task:
+            await asyncio.wait([self._watchdog_task], timeout=5)
+            self._watchdog_task = None
 
+    # ----------------------------------------------------------------------
+    # Client cleanup
+    # ----------------------------------------------------------------------
     def _close_dask_client(self):
-        """Close the Dask client if this instance created it."""
-        if getattr(self, "own_dask_client", False) and self.dask_client is not None:
-            try:
-                cluster = getattr(self.dask_client, "cluster", None)
-                self.dask_client.close()
-                if cluster is not None:
-                    cluster.close()
-                if self.logger:
-                    self.logger.info("Closed local Dask client and cluster.")
-            except Exception as e:
-                if self.logger:
-                    self.logger.warning(f"Error while closing Dask client: {e}")
+        """Safely close client and update registry reference count."""
+        if not self.dask_client:
+            return
+
+        with self.REGISTRY_LOCK:
+            registry = self._read_registry()
+
+            if registry and "refcount" in registry:
+                registry["refcount"] = max(0, registry["refcount"] - 1)
+                if registry["refcount"] == 0:
+                    self.logger.info("Reference count 0 — closing LocalCluster.")
+                    try:
+                        cluster = getattr(self.dask_client, "cluster", None)
+                        self.dask_client.close()
+                        if cluster:
+                            cluster.close()
+                    except Exception as e:
+                        self.logger.warning(f"Error closing Dask cluster: {e}")
+                    self._remove_registry()
+                else:
+                    self._write_registry(registry)
+                    self.logger.debug(
+                        f"Decremented LocalCluster refcount to {registry['refcount']}."
+                    )
+            else:
+                with suppress(Exception):
+                    self.dask_client.close()
+                self.logger.debug("Closed Dask client without registry tracking.")
+
+        # Stop watchdog if active
+        if self._watchdog_task:
+            asyncio.create_task(self._stop_watchdog())
+
 
-@asynccontextmanager
-async def shared_dask_session(**kwargs):
+# ----------------------------------------------------------------------
+# Shared Dask session (sync + async)
+# ----------------------------------------------------------------------
+def shared_dask_session(*, async_mode: bool = True, **kwargs):
+    """
+    Context manager for a shared Dask session (supports async + sync).
+
+    Example:
+        async with shared_dask_session(logger=logger) as client:
+            ...
+
+        with shared_dask_session(async_mode=False) as client:
+            ...
+    """
     mixin = DaskClientMixin()
     mixin._init_dask_client(**kwargs)
-    try:
-        yield mixin.dask_client
-    finally:
-        mixin._close_dask_client()
 
-# from contextlib import suppress
-# from dask.distributed import Client, get_client
+    if async_mode:
+        @asynccontextmanager
+        async def _async_manager():
+            try:
+                yield mixin.dask_client
+            finally:
+                mixin._close_dask_client()
+        return _async_manager()
+    else:
+        @contextmanager
+        def _sync_manager():
+            try:
+                yield mixin.dask_client
+            finally:
+                mixin._close_dask_client()
+        return _sync_manager()
+
+# from contextlib import suppress, asynccontextmanager
+# from dask.distributed import Client, LocalCluster, get_client
+# import os
 #
 # class DaskClientMixin:
 #     """
 #     Provides shared Dask client lifecycle management.
-#     Ensures reuse of existing client when available, otherwise creates a lightweight local one.
+#     Ensures reuse of an existing client if available,
+#     or creates a local in-process Dask cluster for fallback.
 #     """
 #
-#     def _init_dask_client(self, dask_client=None, logger=None):
+#     def _init_dask_client(
+#         self,
+#         dask_client=None,
+#         logger=None,
+#         *,
+#         n_workers: int = 1,
+#         threads_per_worker: int = 1,
+#         processes: bool = False,
+#         asynchronous: bool = False,
+#         memory_limit: str = "auto",
+#         #dashboard_address: str | None = None,
+#         local_directory: str | None = None,
+#         silence_logs: str = "info",
+#         resources: dict | None = None,
+#         timeout: int = 30,
+#     ):
 #         self.dask_client = dask_client
 #         self.own_dask_client = False
 #         self.logger = logger
+#         # Apply log filters globally
+#         logging.getLogger("distributed.shuffle._scheduler_plugin").setLevel(
+#             logging.ERROR
+#         )
+#         logging.getLogger("distributed.scheduler").setLevel(logging.WARNING)
+#         logging.getLogger("distributed.worker").setLevel(logging.WARNING)
 #
 #         if self.dask_client is None:
 #             with suppress(ValueError, RuntimeError):
-#                 # Try to attach to an existing active client if running inside a Dask context
+#                 # Try to attach to an existing client (common in shared Dask setups)
 #                 self.dask_client = get_client()
 #
 #         if self.dask_client is None:
-#             # Start a local in-process scheduler for fallback
-#             self.dask_client = Client(processes=False)
+#             # Default to half of logical cores if not specified
+#             n_workers = n_workers or max(2, os.cpu_count() // 2)
+#
+#             cluster = LocalCluster(
+#                 n_workers=n_workers,
+#                 threads_per_worker=threads_per_worker,
+#                 processes=processes,
+#                 asynchronous=asynchronous,
+#                 memory_limit=memory_limit,
+#                 local_directory=local_directory,
+#                 silence_logs=silence_logs,
+#                 resources=resources,
+#                 timeout=timeout,
+#             )
+#
+#             self.dask_client = Client(cluster)
 #             self.own_dask_client = True
+#
 #             if self.logger:
-#                 self.logger.info(f"Started local Dask client: {self.dask_client.dashboard_link}")
+#                 self.logger.info(
+#                     f"Started local Dask cluster with {n_workers} workers × {threads_per_worker} threads "
+#                     f"({memory_limit} memory per worker). Dashboard: {self.dask_client.dashboard_link}"
+#                 )
 #         else:
 #             if self.logger:
-#                 self.logger.debug(f"Using existing Dask client: {self.dask_client.dashboard_link}")
+#                 self.logger.debug(
+#                     f"Using existing Dask client: {self.dask_client.dashboard_link}"
+#                 )
 #
 #     def _close_dask_client(self):
-#         """Close client only if this instance created it."""
+#         """Close the Dask client if this instance created it."""
 #         if getattr(self, "own_dask_client", False) and self.dask_client is not None:
 #             try:
+#                 cluster = getattr(self.dask_client, "cluster", None)
 #                 self.dask_client.close()
+#                 if cluster is not None:
+#                     cluster.close()
 #                 if self.logger:
-#                     self.logger.info("Closed local Dask client.")
+#                     self.logger.info("Closed local Dask client and cluster.")
 #             except Exception as e:
 #                 if self.logger:
 #                     self.logger.warning(f"Error while closing Dask client: {e}")
+#
+# @asynccontextmanager
+# async def shared_dask_session(**kwargs):
+#     mixin = DaskClientMixin()
+#     mixin._init_dask_client(**kwargs)
+#     try:
+#         yield mixin.dask_client
+#     finally:
+#         mixin._close_dask_client()

{sibi_dst-2025.9.13.dist-info → sibi_dst-2025.9.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sibi-dst
-Version: 2025.9.13
+Version: 2025.9.15
 Summary: A data science toolkit for scalable data processing and analysis.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -9,6 +9,7 @@ Requires-Dist: clickhouse-driver>=0.2.9
 Requires-Dist: dask>=2025.9.1
 Requires-Dist: distributed>=2025.9.1
 Requires-Dist: fastapi>=0.118.0
+Requires-Dist: filelock>=3.20.0
 Requires-Dist: folium>=0.20.0
 Requires-Dist: mysqlclient>=2.2.7
 Requires-Dist: opentelemetry-api>=1.37.0

{sibi_dst-2025.9.13.dist-info → sibi_dst-2025.9.15.dist-info}/RECORD

@@ -2,7 +2,7 @@ sibi_dst/__init__.py,sha256=QQVT3Xlj8iZN17sSMfRQFSb_DHr8A7giJP8hn02K2Oo,585
 sibi_dst/df_helper/__init__.py,sha256=7rUdMybgCNZhQL_J7IFTTHz_xtFin81xavi5-PUExkA,463
 sibi_dst/df_helper/_artifact_updater_async.py,sha256=AZp0vM3vji0tjiaScr8a9SUMH15NjPIKYPdRQ7SJe3Y,11372
 sibi_dst/df_helper/_artifact_updater_threaded.py,sha256=M5GNZismOqMmBrcyfolP1DPv87VILQf_P18is_epn50,7238
-sibi_dst/df_helper/_df_helper.py,sha256=rgVP4ggiCW6tTHmUz2UqUvLznwOtY5IyoVS3WSlg73U,17005
+sibi_dst/df_helper/_df_helper.py,sha256=30J6f7TwfOkCXAUbk3QS-K_5ouYx2tc8BGXrcvNwvC8,17006
 sibi_dst/df_helper/_parquet_artifact.py,sha256=UXkhDSAVRNKp9DykVhJd3agnryCZT0Sj2qhdhUZomuM,19421
 sibi_dst/df_helper/_parquet_reader.py,sha256=RI1e7S7u5RLqkdOD5apcuXel7KtefglS9bhzCO_TB_k,3259
 sibi_dst/df_helper/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -38,11 +38,11 @@ sibi_dst/tests/test_baseclass.py,sha256=5huAwjWo_SOEZR2_0y5w9qUmw5G7pVdm8X1OTG87
 sibi_dst/tests/test_data_wrapper_class.py,sha256=6uFmZR2DxnxQz49L5jT2ehlKvlLnpUHMLFB_PqqUq7k,3336
 sibi_dst/utils/__init__.py,sha256=eoW7iROrCUVYjNT1owMgGvW6U7lolbNy3FrBb_wInPs,1304
 sibi_dst/utils/async_utils.py,sha256=53aywfgq1Q6-0OVr9qR1Sf6g7Qv3I9qunAAR4fjFXBE,351
-sibi_dst/utils/base.py,sha256=sFngliI7Ku8bZMz0YdVhppuaPNZ0dvqRwCsPe9XdF1A,16256
+sibi_dst/utils/base.py,sha256=ycaaXlXTH4tn3fM954jGx8-zKWEmdjJkJKArQ2rfAH0,17527
 sibi_dst/utils/business_days.py,sha256=DPZExTXTt7n3IbAaEuVacm-vZgbR_Ug2bJTPBUaoP3g,6694
 sibi_dst/utils/clickhouse_writer.py,sha256=8W_dTEOKQp4pXANznVSxRqFA2H5oD8UJifiBAONpXWY,17001
 sibi_dst/utils/credentials.py,sha256=cHJPPsmVyijqbUQIq7WWPe-lIallA-mI5RAy3YUuRME,1724
-sibi_dst/utils/dask_utils.py,sha256=FT85GPvHxaR7BDhxgeQT4mgQ_lFmNT5CVmiyhRv9Fns,7251
+sibi_dst/utils/dask_utils.py,sha256=F78smHtuJfZwCvCCBmPTofa0DPcm9oaNDH8YMOioweY,16383
 sibi_dst/utils/data_from_http_source.py,sha256=AcpKNsqTgN2ClNwuhgUpuNCx62r5_DdsAiKY8vcHEBA,1867
 sibi_dst/utils/data_utils.py,sha256=7bLidEjppieNoozDFb6OuRY0W995cxg4tiGAlkGfePI,7768
 sibi_dst/utils/data_wrapper.py,sha256=9HTuDXgvfhmFAOyNG_GEOaHuojxE3639yyzOoBt7Unc,18000
@@ -94,7 +94,7 @@ sibi_dst/v2/df_helper/core/_params_config.py,sha256=DYx2drDz3uF-lSPzizPkchhy-kxR
 sibi_dst/v2/df_helper/core/_query_config.py,sha256=Y8LVSyaKuVkrPluRDkQoOwuXHQxner1pFWG3HPfnDHM,441
 sibi_dst/v2/utils/__init__.py,sha256=6H4cvhqTiFufnFPETBF0f8beVVMpfJfvUs6Ne0TQZNY,58
 sibi_dst/v2/utils/log_utils.py,sha256=rfk5VsLAt-FKpv6aPTC1FToIPiyrnHAFFBAkHme24po,4123
-sibi_dst-2025.9.13.dist-info/METADATA,sha256=v8QE7j-yP0-1s6i4UcOhHIjsDpvSJGtBvzSkLy3f-v8,2413
-sibi_dst-2025.9.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sibi_dst-2025.9.13.dist-info/top_level.txt,sha256=g3Cj4R-rciuNyJgcxuxNgw5nhN0n4TCB0ujcTEjZNiU,9
-sibi_dst-2025.9.13.dist-info/RECORD,,
+sibi_dst-2025.9.15.dist-info/METADATA,sha256=UGjP-M2r9_h6jksc5bY-ltd-NA6G34N0Y3TH7OTvGCs,2445
+sibi_dst-2025.9.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sibi_dst-2025.9.15.dist-info/top_level.txt,sha256=g3Cj4R-rciuNyJgcxuxNgw5nhN0n4TCB0ujcTEjZNiU,9
+sibi_dst-2025.9.15.dist-info/RECORD,,