sibi-dst 2025.1.6__tar.gz → 2025.1.8__tar.gz

{sibi_dst-2025.1.6 → sibi_dst-2025.1.8}/PKG-INFO

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

{sibi_dst-2025.1.6 → sibi_dst-2025.1.8}/pyproject.toml

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

{sibi_dst-2025.1.6 → sibi_dst-2025.1.8}/sibi_dst/df_helper/__init__.py

@@ -3,11 +3,12 @@ from __future__ import annotations
 from ._df_helper import DfHelper
 from ._parquet_artifact import ParquetArtifact
 from ._parquet_reader import ParquetReader
-from ._artifact_updater_multi_wrapper import ArtifactUpdaterMultiWrapperThreaded
+from ._artifact_updater_multi_wrapper import ArtifactUpdaterMultiWrapperThreaded, ArtifactUpdaterMultiWrapperAsync
 
 __all__ = [
     'DfHelper',
     'ParquetArtifact',
     'ParquetReader',
     'ArtifactUpdaterMultiWrapperThreaded',
+    'ArtifactUpdaterMultiWrapperAsync',
 ]

sibi_dst-2025.1.8/sibi_dst/df_helper/_artifact_updater_multi_wrapper.py

@@ -0,0 +1,420 @@
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any, Callable, Dict, List, Optional, Type
+
+from sibi_dst.utils import ManagedResource
+
+class ArtifactUpdaterMultiWrapperThreaded(ManagedResource):
+    """
+    Updates artifacts concurrently using a ThreadPoolExecutor.
+
+    This version is refactored for a pure multi-threaded environment, aligning
+    the orchestration model with the underlying threaded workers (DataWrapper).
+    """
+    wrapped_classes: Dict[str, List[Type]]
+    def __init__(
+            self,
+            wrapped_classes: Dict[str, List[Type]],
+            *,
+            max_workers: int = 4,
+            retry_attempts: int = 3,
+            backoff_base: int = 2,
+            backoff_max: int = 60,
+            backoff_jitter: float = 0.1,
+            priority_fn: Optional[Callable[[Type], int]] = None,
+            artifact_class_kwargs: Optional[Dict[str, Any]] = None,
+            **kwargs: Dict[str, Any]
+    ) -> None:
+        super().__init__(**kwargs)
+        self.wrapped_classes = wrapped_classes
+        self.max_workers = max_workers
+        self.retry_attempts = retry_attempts
+        self.backoff_base = backoff_base
+        self.backoff_max = backoff_max
+        self.backoff_jitter = backoff_jitter
+        self.priority_fn = priority_fn
+        # Default artifact init kwargs
+        today = datetime.datetime.today() + datetime.timedelta(days=1)
+        default_kwargs = {
+            'parquet_start_date': today.strftime('%Y-%m-%d'),
+            'parquet_end_date':   today.strftime('%Y-%m-%d'),
+            'logger':             self.logger,
+            'debug':              self.debug,
+            'fs':                self.fs,
+            'verbose':            self.verbose,
+        }
+        self.artifact_class_kwargs = artifact_class_kwargs or default_kwargs.copy()
+
+        # State tracking
+        self.completion_times: Dict[str, float] = {}
+        self.failed: List[str] = []
+        self.original_classes: List[Type] = []
+
+    def get_artifact_classes(self, data_type: str) -> List[Type]:
+        """Retrieve artifact classes by data type."""
+        self.logger.info(f"Fetching artifact classes for '{data_type}'")
+        classes = self.wrapped_classes.get(data_type)
+        if not classes:
+            raise ValueError(f"Unsupported data type: {data_type}")
+        self.logger.info(f"Found {len(classes)} artifact classes for '{data_type}'")
+        return classes
+
+    def estimate_priority(self, artifact_cls: Type) -> int:
+        """
+        Determines task priority. Lower values run first.
+        Note: This is a blocking call and will run sequentially before updates start.
+        """
+        name = artifact_cls.__name__
+        # Custom priority function takes precedence
+        if self.priority_fn:
+            try:
+                return self.priority_fn(artifact_cls)
+            except Exception as e:
+                self.logger.warning(f"priority_fn error for {name}: {e}")
+
+        # # Fallback to size estimate if available
+        # if hasattr(artifact_cls, 'get_size_estimate'):
+        #     try:
+        #         # This performs blocking I/O
+        #         return artifact_cls(**self.artifact_class_kwargs).get_size_estimate()
+        #
+        #     except Exception as e:
+        #         self.logger.warning(f"get_size_estimate failed for {name}: {e}")
+
+        # Default priority
+        return 999
+
+    def _update_artifact_with_retry(self, artifact_cls: Type, update_kwargs: Dict[str, Any]) -> str:
+        """
+        A blocking worker function that handles instantiation, update, and retries for a single artifact.
+        This function is designed to be run in a ThreadPoolExecutor.
+        """
+        name = artifact_cls.__name__
+        self.logger.debug(f"Worker thread starting update for {name}")
+
+        for attempt in range(1, self.retry_attempts + 1):
+            try:
+                # Instantiate and update directly within the worker thread
+                artifact_instance = artifact_cls(**self.artifact_class_kwargs)
+                artifact_instance.update_parquet(**update_kwargs)
+
+                self.logger.info(f"✅ {name} updated successfully on attempt {attempt}")
+                return name  # Return the name on success
+
+            except Exception as e:
+                self.logger.error(f"Error on {name} attempt {attempt}/{self.retry_attempts}: {e}", exc_info=self.debug)
+                if attempt < self.retry_attempts:
+                    delay = min(self.backoff_base ** (attempt - 1), self.backoff_max)
+                    delay *= 1 + random.uniform(0, self.backoff_jitter)
+                    self.logger.info(f"Sleeping {delay:.1f}s before retrying {name}")
+                    time.sleep(delay)
+
+        # If all retries fail, raise an exception to be caught by the main loop
+        raise RuntimeError(f"{name} failed after {self.retry_attempts} attempts.")
+
+    async def update_data(self, data_type: str, **kwargs: Any) -> None:
+        """
+        Entry point to update all artifacts of a given type using a ThreadPoolExecutor.
+        """
+        self.logger.debug(f"Starting multi-threaded update for '{data_type}' with kwargs={kwargs}")
+
+        # Reset state for this run
+        self.completion_times.clear()
+        self.failed.clear()
+        self.original_classes = self.get_artifact_classes(data_type)
+
+        # Sequentially estimate priorities and sort classes before execution
+        self.logger.debug("Estimating priorities to order tasks...")
+        ordered_classes = sorted(self.original_classes, key=self.estimate_priority)
+        self.logger.debug("Priority estimation complete. Submitting tasks to thread pool.")
+
+        start_time = time.monotonic()
+
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            future_to_class_name = {
+                executor.submit(self._update_artifact_with_retry, cls, kwargs): cls.__name__
+                for cls in ordered_classes
+            }
+
+            for future in as_completed(future_to_class_name):
+                name = future_to_class_name[future]
+                try:
+                    # result() will re-raise the exception from the worker if one occurred
+                    future.result()
+                    # If no exception, the task succeeded
+                    self.completion_times[name] = time.monotonic() - start_time
+                except Exception as e:
+                    self.logger.error(f"✖️ {name} permanently failed. See error log above.")
+                    self.failed.append(name)
+
+        # Log final status
+        total = len(self.original_classes)
+        completed = len(self.completion_times)
+        failed_count = len(self.failed)
+        self.logger.info(f"All artifacts processed: total={total}, completed={completed}, failed={failed_count}")
+
+    def get_update_status(self) -> Dict[str, Any]:
+        """Returns a summary status including completion times."""
+        completed_set = set(self.completion_times.keys())
+        failed_set = set(self.failed)
+        pending_set = {cls.__name__ for cls in self.original_classes} - completed_set - failed_set
+
+        return {
+            'total': len(self.original_classes),
+            'completed': list(completed_set),
+            'failed': list(failed_set),
+            'pending': list(pending_set),
+            'completion_times': self.completion_times,
+        }
+
+    @staticmethod
+    def format_status_table(status: Dict[str, Any]) -> str:
+        """Formats the status dictionary into a readable table."""
+        lines = [
+            f"Total: {status['total']}",
+            f"Completed: {len(status['completed'])}",
+            f"Failed:    {len(status['failed'])}",
+            f"Pending:   {len(status['pending'])}",
+            "\nPer-artifact completion times (seconds):"
+        ]
+        sorted_times = sorted(status['completion_times'].items(), key=lambda item: item[1], reverse=True)
+        for name, duration in sorted_times:
+            lines.append(f"  - {name:<30}: {duration:.2f}s")
+        if status['failed']:
+            lines.append("\nFailed artifacts:")
+            for name in status['failed']:
+                lines.append(f"  - {name}")
+        return "\n".join(lines)
+
+
+import asyncio
+import datetime
+import random
+from typing import Any, Callable, Dict, List, Optional, Type
+
+class ArtifactUpdaterMultiWrapperAsync(ManagedResource):
+    """
+    Simplified wrapper that updates artifacts concurrently using an asyncio.Semaphore.
+
+    Features:
+    - Caps concurrency at max_workers via semaphore
+    - Optionally prioritises tasks via a priority function or static method on artifact classes
+    - Tracks per-artifact completion times
+    - Configurable retry/backoff strategy
+    - Optional metrics integration
+    - Thread-safe within a single asyncio loop
+
+    Usage:
+        wrapper = ArtifactUpdaterMultiWrapper(
+            wrapped_classes={
+                'mydata': [DataArtifactA, DataArtifactB],
+            },
+            max_workers=4,
+            retry_attempts=3,
+            update_timeout_seconds=600,
+            backoff_base=2,
+            backoff_max=60,
+            backoff_jitter=0.1,
+            priority_fn=None,  # or custom
+            metrics_client=None,
+            debug=True,
+            logger=None,
+            artifact_class_kwargs={
+                'fs': my_fs,
+                'parquet_storage_path': 's3://bucket/data',
+                'logger': my_logger,
+                'debug': True,
+            }
+        )
+        await wrapper.update_data('mydata', period='ytd', overwrite=True)
+    """
+    def __init__(
+        self,
+        wrapped_classes: Dict[str, List[Type]],
+        *,
+        max_workers: int = 3,
+        retry_attempts: int = 3,
+        update_timeout_seconds: int = 600,
+        backoff_base: int = 2,
+        backoff_max: Optional[int] = 60,
+        backoff_jitter: float = 0.1,
+        priority_fn: Optional[Callable[[Type], int]] = None,
+        metrics_client: Any = None,
+        artifact_class_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs: Dict[str, Any]
+    ) -> None:
+        super().__init__(**kwargs)
+        self.wrapped_classes = wrapped_classes
+        self.max_workers = max_workers
+        self.retry_attempts = retry_attempts
+        self.update_timeout_seconds = update_timeout_seconds
+        self.backoff_base = backoff_base
+        self.backoff_max = backoff_max
+        self.backoff_jitter = backoff_jitter
+        self.priority_fn = priority_fn
+        self.metrics_client = metrics_client
+
+        # Default artifact init kwargs
+        today = datetime.datetime.today() + datetime.timedelta(days=1)
+        default_kwargs = {
+            'parquet_start_date': today.strftime('%Y-%m-%d'),
+            'parquet_end_date': today.strftime('%Y-%m-%d'),
+            'logger': self.logger,
+            'debug': self.debug,
+            'fs': self.fs,
+            'verbose': self.verbose,
+        }
+        self.artifact_class_kwargs = artifact_class_kwargs or default_kwargs.copy()
+
+        # State
+        self.completion_times: Dict[str, float] = {}
+        self.failed: List[str] = []
+        self.original_classes: List[Type] = []
+
+    def get_artifact_classes(self, data_type: str) -> List[Type]:
+        """
+        Retrieve artifact classes by data type.
+        """
+        self.logger.info(f"Fetching artifact classes for '{data_type}'")
+        if data_type not in self.wrapped_classes:
+            raise ValueError(f"Unsupported data type: {data_type}")
+        classes = self.wrapped_classes[data_type]
+        self.logger.info(f"Found {len(classes)} artifact classes for '{data_type}'")
+        return classes
+
+    def estimate_priority(self, artifact_cls: Type) -> int:
+        """
+        Determine task priority for ordering. Lower values run first.
+        """
+        name = artifact_cls.__name__
+        if self.priority_fn:
+            try:
+                pr = self.priority_fn(artifact_cls)
+                self.logger.debug(f"priority_fn for {name}: {pr}")
+                return pr
+            except Exception as e:
+                self.logger.warning(f"priority_fn error for {name}: {e}")
+        try:
+            fs = self.artifact_class_kwargs.get('fs')
+            path = self.artifact_class_kwargs.get('parquet_storage_path')
+            pr=1
+            if hasattr(artifact_cls, 'get_size_estimate'):
+                pr = artifact_cls.get_size_estimate(fs, path)
+            self.logger.debug(f"Estimated priority for {name}: {pr}")
+            return pr
+        except Exception:
+            return 1
+
+    async def _bounded_update(self, artifact_cls: Type, sem: asyncio.Semaphore, **update_kwargs) -> None:
+        """
+        Wrap update_artifact in a semaphore slot to limit concurrency.
+        """
+        async with sem:
+            name = artifact_cls.__name__
+            start = asyncio.get_event_loop().time()
+            self.logger.info(f"Starting update for {name}")
+            try:
+                for attempt in range(1, self.retry_attempts + 1):
+                    try:
+                        artifact = await asyncio.to_thread(
+                            artifact_cls, **self.artifact_class_kwargs
+                        )
+                        await asyncio.wait_for(
+                            asyncio.to_thread(
+                                artifact.update_parquet, **update_kwargs
+                            ),
+                            timeout=self.update_timeout_seconds
+                        )
+                        duration = asyncio.get_event_loop().time() - start
+                        self.completion_times[name] = duration
+                        self.logger.info(f"✅ {name} updated in {duration:.2f}s (attempt {attempt})")
+                        if self.metrics_client:
+                            self.metrics_client.increment('task_succeeded')
+                        return
+                    except asyncio.TimeoutError:
+                        self.logger.warning(f"Timeout on {name}, attempt {attempt}")
+                    except Exception as e:
+                        self.logger.error(f"Error on {name} attempt {attempt}: {e}")
+
+                    delay = min(self.backoff_base ** (attempt - 1), self.backoff_max)
+                    delay *= 1 + random.uniform(0, self.backoff_jitter)
+                    self.logger.info(f"Sleeping {delay:.1f}s before retrying {name}")
+                    await asyncio.sleep(delay)
+
+            except asyncio.CancelledError:
+                self.logger.warning(f"{name} update cancelled")
+                raise
+
+            # permanent failure
+            self.logger.error(f"✖️  {name} permanently failed after {self.retry_attempts} attempts")
+            if self.metrics_client:
+                self.metrics_client.increment('task_failed')
+            self.failed.append(name)
+
+    async def update_data(self, data_type: str, **kwargs: Any) -> None:
+        """
+        Entry point to update all artifacts of a given type concurrently.
+        """
+        self.logger.info(f"Starting update_data for '{data_type}' with kwargs={kwargs}")
+
+        # RESET STATE
+        self.completion_times.clear()
+        self.failed.clear()
+        self.original_classes = self.get_artifact_classes(data_type)
+
+        # NON-DESTRUCTIVE SORTING
+        ordered = sorted(self.original_classes, key=self.estimate_priority)
+
+        sem = asyncio.Semaphore(self.max_workers)
+        tasks = [
+            asyncio.create_task(self._bounded_update(cls, sem, **kwargs))
+            for cls in ordered
+        ]
+
+        try:
+            for coro in asyncio.as_completed(tasks):
+                await coro
+        except asyncio.CancelledError:
+            self.logger.warning("update_data was cancelled—aborting remaining retries")
+            for t in tasks:
+                t.cancel()
+            raise
+        finally:
+            total = len(self.original_classes)
+            completed = len(self.completion_times)
+            failed = len(self.failed)
+            self.logger.info(f"All artifacts processed: total={total}, completed={completed}, failed={failed}")
+
+    def get_update_status(self) -> Dict[str, Any]:
+        """
+        Returns summary status including completion times.
+        """
+        total = len(self.original_classes)
+        completed = set(self.completion_times.keys())
+        failed = set(self.failed)
+        pending = {cls.__name__ for cls in self.original_classes} - completed - failed
+
+        return {
+            'total': total,
+            'completed': list(completed),
+            'failed':    list(failed),
+            'pending':   list(pending),
+            'completion_times': self.completion_times,
+        }
+
+    @staticmethod
+    def format_status_table(status: Dict[str, Any]) -> str:
+        """
+        Formats the status dict into a readable table.
+        """
+        lines = [
+            f"Total: {status['total']}",
+            f"Completed: {len(status['completed'])}  {status['completed']}",
+            f"Failed:    {len(status['failed'])}  {status['failed']}",
+            f"Pending:   {len(status['pending'])}  {status['pending']}",
+            "",
+            "Per-artifact timings:"
+        ]
+        for name, dur in status['completion_times'].items():
+            lines.append(f"  {name}: {dur:.2f}s")
+        return "\n".join(lines)

{sibi_dst-2025.1.6 → sibi_dst-2025.1.8}/sibi_dst/df_helper/_parquet_reader.py

@@ -1,4 +1,3 @@
-import logging
 from typing import Optional, ClassVar, Dict
 
 import dask.dataframe as dd
@@ -47,15 +46,13 @@ class ParquetReader(DfHelper):
         'backend': 'parquet'
     }
 
-    def __init__(self, filesystem_type="file", filesystem_options=None, **kwargs):
+    def __init__(self,  **kwargs):
         self.config = {
             **self.DEFAULT_CONFIG,
             **kwargs,
         }
-        self.df: Optional[dd.DataFrame] = None
-        #self.debug = self.config.setdefault('debug', False)
-        #self.logger = self.config.setdefault('logger', Logger.default_logger(logger_name=self.__class__.__name__))
-        #self.logger.set_level(logging.DEBUG if self.debug else logging.INFO)
+        super().__init__(**self.config)
+
         self.parquet_storage_path = self.config.setdefault('parquet_storage_path', None)
         if self.parquet_storage_path is None:
             raise ValueError('parquet_storage_path must be set')
@@ -67,19 +64,9 @@ class ParquetReader(DfHelper):
         if self.parquet_end_date is None:
             raise ValueError('parquet_end_date must be set')
 
-        # Filesystem setup
-        #self.filesystem_type = filesystem_type
-        #self.filesystem_options = filesystem_options or {}
-        #self.fs = self.config.setdefault('fs', None)
-        #if self.fs is None:
-        #    self.fs = fsspec.filesystem(self.filesystem_type, **self.filesystem_options)
-        #self.config.setdefault('fs', self.fs)
-
         if not self.directory_exists():
             raise ValueError(f"{self.parquet_storage_path} does not exist")
 
-        super().__init__(**self.config)
-
     def load(self, **kwargs):
         self.df = super().load(**kwargs)
         return self.df
@@ -89,5 +76,4 @@ class ParquetReader(DfHelper):
             info = self.fs.info(self.parquet_storage_path)
             return info['type'] == 'directory'
         except FileNotFoundError:
-            return False
-
+            return False

{sibi_dst-2025.1.6 → sibi_dst-2025.1.8}/sibi_dst/utils/data_wrapper.py

@@ -1,16 +1,13 @@
 import datetime
-import logging
 import threading
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import Type, Any, Dict, Optional, Union, List, ClassVar
 
-import fsspec
 import pandas as pd
 from tqdm import tqdm
 
 from . import ManagedResource
-from .log_utils import Logger
 from .parquet_saver import ParquetSaver
 
 
@@ -60,8 +57,7 @@ class DataWrapper(ManagedResource):
         self.processed_dates: List[datetime.date] = []
         self.benchmarks: Dict[datetime.date, Dict[str, float]] = {}
         self.mmanifest = kwargs.get("mmanifest", None)
-        self.update_planner=kwargs.get("update_planner", None)
-
+        self.update_planner = kwargs.get("update_planner", None)
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """Context manager exit"""
@@ -104,7 +100,6 @@ class DataWrapper(ManagedResource):
             if self.update_planner.show_progress:
                 self.show_benchmark_summary()
 
-
     def _execute_task_batch(self, priority: int, dates: List[datetime.date], max_retries: int):
         """Executes a single batch of tasks (dates) using a thread pool."""
         desc = f"Processing {self.dataclass.__name__}, priority: {priority}"
@@ -135,7 +130,7 @@ class DataWrapper(ManagedResource):
                     time.sleep(2 ** attempt)  # Exponential backoff
                 else:
                     self.logger.error(f"Failed processing {date} after {max_retries} attempts.")
-                    #raise
+                    # raise
 
     def _process_single_date(self, date: datetime.date):
         """Core date processing logic with load/save timing and thread reporting"""
@@ -146,8 +141,8 @@ class DataWrapper(ManagedResource):
             return
         full_path = f"{path}{self.parquet_filename}"
 
-        #thread_name = threading.current_thread().name
-        #self.logger.debug(f"[{thread_name}] Executing date: {date} -> saving to: {full_path}")
+        # thread_name = threading.current_thread().name
+        # self.logger.debug(f"[{thread_name}] Executing date: {date} -> saving to: {full_path}")
 
         overall_start = time.perf_counter()
         try:
@@ -159,35 +154,43 @@ class DataWrapper(ManagedResource):
             local_load_params = self.load_params.copy()
             local_load_params.update(date_filter)
             local_class_instance = self.dataclass(**self.class_params)
-            df=local_class_instance.load(**local_load_params)
+            df = local_class_instance.load(**local_load_params)
             load_time = time.perf_counter() - load_start
 
             if hasattr(local_class_instance, "total_records"):
-                self.logger.debug(f"Total records loaded by {local_class_instance.__class__.__name__}: {local_class_instance.total_records}")
+                self.logger.debug(
+                    f"Total records loaded by {local_class_instance.__class__.__name__}: {local_class_instance.total_records}")
                 if int(local_class_instance.total_records) == 0:  # If no records were loaded but not due to an error
                     if self.mmanifest:
                         self.mmanifest.record(
                             full_path=path
                         )
-                    self.logger.info(f"No data found for {date}. Logged to missing manifest.")
-                    return
-            save_start = time.perf_counter()
-            with ParquetSaver(
-                df_result=df,
-                parquet_storage_path=path,
-                fs=self.fs,
-                logger=self.logger
-            ) as ps:
-                ps.save_to_parquet(self.parquet_filename, overwrite=True)
-            save_time = time.perf_counter() - save_start
-
-            total_time = time.perf_counter() - overall_start
-            self.benchmarks[date] = {
-                "load_duration": load_time,
-                "save_duration": save_time,
-                "total_duration": total_time
-            }
-            self._log_success(date, total_time, full_path)
+                    self.logger.info(f"No data found for {full_path}. Logged to missing manifest.")
+                elif int(local_class_instance.total_records) < 0:
+                    self.logger.warning(
+                        f"Negative record count ({local_class_instance.total_records}) for {full_path}. "
+                        "This may indicate an error in the data loading process."
+                    )
+                else:
+                    save_start = time.perf_counter()
+                    parquet_params ={
+                        "df_result": df,
+                        "parquet_storage_path": path,
+                        "fs": self.fs,
+                        "logger": self.logger,
+                        "debug": self.debug,
+                    }
+                    with ParquetSaver(**parquet_params) as ps:
+                        ps.save_to_parquet(self.parquet_filename, overwrite=True)
+                    save_time = time.perf_counter() - save_start
+
+                    total_time = time.perf_counter() - overall_start
+                    self.benchmarks[date] = {
+                        "load_duration": load_time,
+                        "save_duration": save_time,
+                        "total_duration": total_time
+                    }
+                    self._log_success(date, total_time, full_path)
         except Exception as e:
             self._log_failure(date, e)
             raise

{sibi_dst-2025.1.6 → sibi_dst-2025.1.8}/sibi_dst/utils/parquet_saver.py

@@ -26,10 +26,6 @@ class ParquetSaver(ManagedResource):
         super().__init__(**kwargs)
         self.df_result = df_result
         self.parquet_storage_path = parquet_storage_path.rstrip("/")
-        #self.debug = debug
-        #self.logger = logger or Logger.default_logger(self.__class__.__name__)
-        #self.logger.set_level(logging.DEBUG if self.debug else logging.INFO)
-        #self.fs = fs
         # Determine protocol for special handling (e.g., 's3')
         if not self.fs:
             raise ValueError("File system (fs) must be provided to ParquetSaver.")