sibi-dst 0.3.11__tar.gz → 0.3.14__tar.gz

{sibi_dst-0.3.11 → sibi_dst-0.3.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sibi-dst
-Version: 0.3.11
+Version: 0.3.14
 Summary: Data Science Toolkit
 Author: Luis Valverde
 Author-email: lvalverdeb@gmail.com
@@ -9,10 +9,13 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: apache-airflow-client (>=2.10.0,<3.0.0)
+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[complete] (>=2024.11.1,<2025.0.0)
-Requires-Dist: django (==4.1.13)
+Requires-Dist: django (>=5.1.4,<6.0.0)
+Requires-Dist: djangorestframework (>=3.15.2,<4.0.0)
 Requires-Dist: httpx (>=0.27.2,<0.28.0)
 Requires-Dist: ipython (>=8.29.0,<9.0.0)
 Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
@@ -26,9 +29,10 @@ Requires-Dist: pydantic (>=2.9.2,<3.0.0)
 Requires-Dist: pymysql (>=1.1.1,<2.0.0)
 Requires-Dist: pytest (>=8.3.3,<9.0.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
-Requires-Dist: sqlmodel (>=0.0.22,<0.0.23)
+Requires-Dist: sqlalchemy (>=2.0.36,<3.0.0)
 Requires-Dist: tornado (>=6.4.1,<7.0.0)
 Requires-Dist: tqdm (>=4.67.0,<5.0.0)
+Requires-Dist: uvicorn (>=0.32.1,<0.33.0)
 Description-Content-Type: text/markdown
 
 # sibi-dst

{sibi_dst-0.3.11 → sibi_dst-0.3.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sibi-dst"
-version = "0.3.11"
+version = "0.3.14"
 description = "Data Science Toolkit"
 authors = ["Luis Valverde <lvalverdeb@gmail.com>"]
 readme = "README.md"
@@ -13,13 +13,12 @@ dask = {extras = ["complete"], version = "^2024.11.1"}
 pydantic = "^2.9.2"
 tornado = "^6.4.1"
 psutil = "^6.1.0"
-django = "4.1.13"
+django = "^5.1.4"
 pyarrow = "^18.0.0"
 mysqlclient = "^2.2.6"
 pymysql = "^1.1.1"
 httpx = "^0.27.2"
 python-dotenv = "^1.0.1"
-sqlmodel = "^0.0.22"
 tqdm = "^4.67.0"
 openpyxl = "^3.1.5"
 jinja2 = "^3.1.4"
@@ -29,6 +28,11 @@ pytest = "^8.3.3"
 clickhouse-connect = "^0.8.7"
 clickhouse-driver = "^0.2.9"
 paramiko = "^3.5.0"
+chardet = "^5.2.0"
+charset-normalizer = "^3.4.0"
+uvicorn = "^0.32.1"
+sqlalchemy = "^2.0.36"
+djangorestframework = "^3.15.2"
 
 
 [build-system]

{sibi_dst-0.3.11 → sibi_dst-0.3.14}/sibi_dst/df_helper/_df_helper.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, TypeVar
 from typing import Union, Optional
 
 import dask.dataframe as dd
+import dask_expr
 import pandas as pd
 from pydantic import BaseModel
 
@@ -42,6 +43,7 @@ class DfHelper:
         self.dt_field=kwargs.setdefault("dt_field", None)
         self.as_pandas = kwargs.setdefault("as_pandas", False)
         kwargs.setdefault("live", True)
+        kwargs.setdefault("logger", self.logger)
         self.post_init(**kwargs)
 
 
@@ -115,7 +117,7 @@ class DfHelper:
             self._post_process_df()
             self.logger.info("Data successfully loaded from sqlalchemy database.")
         except Exception as e:
-            self.logger.error(f"Failed to load data from sqlqlchemy database: {e}")
+            self.logger.error(f"Failed to load data from sqlalchemy database: {e}: options: {options}")
             self.df = dd.from_pandas(pd.DataFrame(), npartitions=1)
 
         return self.df
@@ -194,10 +196,16 @@ class DfHelper:
         self.logger.info("Post-processing of DataFrame completed.")
 
     def _process_loaded_data(self):
-        if len(self.df.index) > 0:
-            field_map = self.plugin_params.field_map or []
-            if field_map:
+        self.logger.info(f"Type of self.df: {type(self.df)}")
+        if self.df.map_partitions(len).compute().sum() > 0:
+            field_map = self.plugin_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]
+
+                if missing_columns:
+                    self.logger.warning(
+                        f"The following columns in field_map are not in the DataFrame: {missing_columns}")
 
                 def rename_columns(df, mapping):
                     return df.rename(columns=mapping)
@@ -211,21 +219,20 @@ class DfHelper:
     def save_to_parquet(self, parquet_filename: Optional[str] = None):
         ps = ParquetSaver(self.df, self.parquet_storage_path, self.logger)
         ps.save_to_parquet(parquet_filename)
+        self.logger.info(f"Parquet saved to {parquet_filename} in parquet storage: {self.parquet_storage_path}.")
 
-    def save_to_clickhouse(self, database, table, order_by=None, **credentials):
-        click_config ={
-            'database': database,
-            'table': table,
-            'order_by': order_by or 'id',
-        }
-        credentials = {**credentials, **click_config}
-        cs=ClickHouseWriter(**credentials)
+    def save_to_clickhouse(self, **credentials):
+        if self.df.map_partitions(len).compute().sum() == 0:
+            self.logger.info("Cannot write to clickhouse since Dataframe is empty")
+            return
+        cs=ClickHouseWriter(logger=self.logger, **credentials)
         cs.save_to_clickhouse(self.df)
+        self.logger.info("Save to ClickHouse completed.")
 
     def _load_from_parquet(self, **options) -> Union[pd.DataFrame, dd.DataFrame]:
         self.df = self.plugin_parquet.load_files()
         if options:
-            self.df = ParquetFilterHandler().apply_filters_dask(self.df, options)
+            self.df = ParquetFilterHandler(logger=self.logger).apply_filters_dask(self.df, options)
         return self.df
 
     def load_period(self, **kwargs):

{sibi_dst-0.3.11 → sibi_dst-0.3.14}/sibi_dst/df_helper/plugins/django/_io_dask.py

@@ -1,6 +1,7 @@
 import itertools
 
 import dask.dataframe as dd
+import dask_expr
 import django
 import pandas as pd
 from django.core.cache import cache
@@ -239,4 +240,7 @@ class ReadFrameDask:
         if verbose:
             self.update_with_verbose(dask_df, fieldnames, fields)
 
+        if isinstance(dask_df, dask_expr._collection.DataFrame):
+            dask_df = dask_df.to_legacy_dataframe()
+
         return dask_df

{sibi_dst-0.3.11 → sibi_dst-0.3.14}/sibi_dst/df_helper/plugins/http/_http_config.py

@@ -13,11 +13,10 @@ class HttpConfig(BaseModel):
     api_key: Optional[SecretStr] = None
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    def __init__(self, **data):
+    def __init__(self, logger=None, **data):
         super().__init__(**data)
         # Initialize the logger if not provided
-        if not self.logger:
-            self.logger = Logger(log_dir='./logs/', logger_name="HttpDataSource", log_file='http_data_source.log')
+        self.logger = logger or Logger.default_logger(logger_name=self.__class__.__name__)
 
     async def fetch_data(self, **options) -> dd.DataFrame:
         """Asynchronously fetch JSON data from HTTP endpoint, substituting options into the URL path."""

{sibi_dst-0.3.11 → sibi_dst-0.3.14}/sibi_dst/df_helper/plugins/parquet/_parquet_filter_handler.py

@@ -1,7 +1,11 @@
 import pandas as pd
 import dask.dataframe as dd
+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__)
+
     @staticmethod
     def apply_filters_dask(df, filters):
         dt_operators = ['date', 'time']

{sibi_dst-0.3.11 → sibi_dst-0.3.14}/sibi_dst/df_helper/plugins/parquet/_parquet_options.py

@@ -25,6 +25,8 @@ class ParquetConfig(BaseModel):
     @model_validator(mode='after')
     def check_parquet_params(self):
         # 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])
 
         # Validation for parquet path

{sibi_dst-0.3.11 → sibi_dst-0.3.14}/sibi_dst/df_helper/plugins/sql_alchemy/_io_sqlalchemy_dask.py

@@ -1,6 +1,7 @@
 import itertools
 
 import dask.dataframe as dd
+import dask_expr
 import pandas as pd
 from sqlalchemy import create_engine, inspect, select
 from sqlalchemy.orm import sessionmaker
@@ -10,7 +11,7 @@ from sibi_dst.utils import Logger
 
 
 class SQLAlchemyDask:
-    def __init__(self, model, filters, engine_url, chunk_size=1000, logger=None, verbose=True):
+    def __init__(self, model, filters, engine_url, chunk_size=1000, logger=None, debug=False):
         """
         Initialize with an SQLAlchemy query and database engine URL.
 
@@ -19,13 +20,13 @@ class SQLAlchemyDask:
         :param engine_url: Database connection string for SQLAlchemy engine.
         :param chunk_size: Number of records per chunk for Dask partitions.
         :param logger: Logger instance for logging.
-        :param verbose: Whether to print detailed logs.
+        :param debug: Whether to print detailed logs.
         """
         self.query = None
         self.model = model
         self.filters = filters
         self.chunk_size = chunk_size
-        self.verbose = verbose
+        self.debug = debug
         self.engine = create_engine(engine_url)
         self.Session = sessionmaker(bind=self.engine)
         self.logger = logger or Logger.default_logger(logger_name=self.__class__.__name__)
@@ -118,14 +119,17 @@ class SQLAlchemyDask:
                     partitions.append(dd.from_pandas(df, npartitions=1))
 
                 # Concatenate all partitions
-                # print(partitions)
                 if partitions:
                     dask_df = dd.concat(partitions, axis=0, ignore_index=True)
                 else:
                     dask_df = dd.from_pandas(pd.DataFrame(columns=ordered_columns), npartitions=1)
 
-                if self.verbose:
+                if self.debug:
                     self.logger.info(f"Loaded {len(dask_df)} rows into Dask DataFrame.")
+
+                if isinstance(dask_df, dask_expr._collection.DataFrame):
+                    dask_df = dask_df.to_legacy_dataframe()
+
                 return dask_df
 
             except Exception as e:

{sibi_dst-0.3.11 → sibi_dst-0.3.14}/sibi_dst/df_helper/plugins/sql_alchemy/_sqlalchemy_load_from_db.py

@@ -1,22 +1,13 @@
-from typing import Dict
-
 import dask.dataframe as dd
 import pandas as pd
-from sqlalchemy.inspection import inspect
-from sqlalchemy.orm import sessionmaker
-from sqlalchemy import select
-#from sqlmodel import Session, select
 
-from sibi_dst.df_helper.core import ParamsConfig, QueryConfig, sqlalchemy_field_conversion_map_dask, \
-    normalize_sqlalchemy_type
+from sibi_dst.df_helper.core import ParamsConfig, QueryConfig
 from sibi_dst.utils import Logger
 from ._io_sqlalchemy_dask import SQLAlchemyDask
-from ._sqlachemy_filter_handler import SqlAlchemyFilterHandler
 from ._sqlalchemy_db_connection import SqlAlchemyConnectionConfig
 
-
 class SqlAlchemyLoadFromDb:
-    df: dd.DataFrame
+    df: dd.DataFrame = None
 
     def __init__(
             self,
@@ -43,17 +34,25 @@ class SqlAlchemyLoadFromDb:
         """
         Load data into a Dask DataFrame based on the query and parameters.
         """
-        self.df = self._build_and_load()
+        self._build_and_load()
         return self.df
 
     def _build_and_load(self) -> dd.DataFrame:
+
         try:
-            reader = SQLAlchemyDask(model=self.model, filters=self.params_config.filters,engine_url=self.engine.url, logger=self.logger, chunk_size=1000, verbose=self.debug)
-            df = reader.read_frame()
-            if df is None or len(df.index) == 0:
+            # reader = SQLAlchemyDask(model=self.model, filters=self.params_config.filters,engine_url=self.engine.url, logger=self.logger, chunk_size=1000, debug=self.debug)
+            self.df = SQLAlchemyDask(
+                model=self.model,
+                filters=self.params_config.filters,
+                engine_url=self.engine.url,
+                logger=self.logger,
+                chunk_size=1000,
+                debug=self.debug).read_frame()
+            if self.df is None or len(self.df.head().index) == 0:
                 self.logger.warning("Query returned no results.")
                 return dd.from_pandas(pd.DataFrame(), npartitions=1)
-            return df
+
+            return self.df
         except Exception as e:
             self.logger.error(f"Failed to load data into Dask DataFrame.{e}")
             return dd.from_pandas(pd.DataFrame(), npartitions=1)

{sibi_dst-0.3.11 → sibi_dst-0.3.14}/sibi_dst/utils/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from ._credentials import ConfigManager, ConfigLoader
 from ._log_utils import Logger
-from ._date_utils import DateUtils
+from ._date_utils import DateUtils, BusinessDays
 from ._data_utils import DataUtils
 from ._file_utils import FileUtils
 from ._filepath_generator import FilePathGenerator
@@ -17,6 +17,7 @@ __all__=[
     "ConfigLoader",
     "Logger",
     "DateUtils",
+    "BusinessDays",
     "FileUtils",
     "DataWrapper",
     "DataUtils",

{sibi_dst-0.3.11 → sibi_dst-0.3.14}/sibi_dst/utils/_clickhouse_writer.py

@@ -31,9 +31,9 @@ class ClickHouseWriter:
         self.order_by=kwargs.setdefault('order_by','id')
 
     def save_to_clickhouse(self, df, **kwargs):
-        self.df = df
+        self.df = df.copy()
         self.order_by = kwargs.setdefault('order_by',self.order_by)
-        if len(self.df.index) == 0:
+        if len(self.df.head().index) == 0:
             self.logger.info("Dataframe is empty")
             return
         self._handle_missing_values()
@@ -122,7 +122,7 @@ class ClickHouseWriter:
         """
         Writes the Dask DataFrame to a ClickHouse table partition by partition.
         """
-        if len(self.df.index) == 0:
+        if len(self.df.head().index) == 0:
             self.logger.info("No data found. Nothing written.")
             return
 

{sibi_dst-0.3.11 → sibi_dst-0.3.14}/sibi_dst/utils/_data_utils.py

@@ -7,6 +7,27 @@ class DataUtils:
     def __init__(self, logger=None):
         self.logger = logger or Logger.default_logger(logger_name=self.__class__.__name__)
 
+    def transform_numeric_cols(self, df, columns, fill_value=0, dtype=int):
+        if not columns:
+            self.logger.warning('No columns specified')
+
+        columns = [column for column in columns if column in df.columns]
+        for col in columns:
+            if isinstance(df, dd.DataFrame):
+                # Replace NaN with 0, then convert to boolean
+                df[col] = df[col].map_partitions(
+                    lambda s: pd.to_numeric(s, errors='coerce')  # Convert to numeric, invalid to NaN
+                    .fillna(fill_value)  # Replace NaN with 0
+                    .astype(dtype),
+                    meta=(col, dtype)
+                )
+            else:
+                # For Pandas DataFrame, handle mixed types and invalid values
+                df[col] = pd.to_numeric(df[col], errors='coerce')  # Convert to numeric, invalid to NaN
+                df[col] = df[col].fillna(fill_value).astype(dtype)
+
+        return df
+
     @staticmethod
     def transform_numeric_columns(df, columns=None, fill_value=0, transform_func=None):
         """
@@ -14,6 +35,7 @@ class DataUtils:
 
         Parameters:
         - df (pandas.DataFrame or dask.dataframe.DataFrame): The DataFrame.
+        - columns (list of str, optional): Specific columns to transform. If None, all numeric columns are transformed.
         - fill_value (int or float): The value to replace NA values with.
         - transform_func (callable, optional): The transformation function to apply.
           If None, no additional transformation is applied.
@@ -28,31 +50,28 @@ class DataUtils:
         if not columns:
             return df
 
+        columns = [column for column in columns if column in df.columns]
         # Default transformation function (identity) if none is provided
         if transform_func is None:
             transform_func = lambda x: x
 
-        # Apply transformations
-        for col in columns:
-            dtype = df[col].dtype
-            if pd.api.types.is_integer_dtype(dtype):
-                meta_type = 'int64'
-            elif pd.api.types.is_float_dtype(dtype):
-                meta_type = 'float64'
-            else:
-                continue  # Skip non-numeric columns
+        # Batch processing for Dask
+        if isinstance(df, dd.DataFrame):
+            def transform_partition(partition):
+                # Apply transformations for all numeric columns in a single pass
+                partition[columns] = partition[columns].fillna(fill_value).map(transform_func)
+                return partition
+
+            # Apply the transformation function to all specified columns
+            df = df.map_partitions(transform_partition, meta=df)
+        else:
+            # Pandas: Vectorized operations for all specified columns
+            df[columns] = df[columns].fillna(fill_value).map(transform_func)
 
-            df[col] = df[col].fillna(fill_value).astype(meta_type)
-            if isinstance(df, dd.DataFrame):
-                df[col] = df[col].map_partitions(
-                    lambda s: s.apply(transform_func), meta=(col, meta_type)
-                )
-            else:
-                df[col] = df[col].apply(transform_func)
         return df
 
     @staticmethod
-    def transform_boolean_columns(df, columns=None, sample_size=100):
+    def transform_boolean_columns(df, columns=None):
         """
         Detect if the provided columns in a DataFrame (Pandas or Dask) contain only 0 and 1
         and convert them to boolean. Detection is performed using a sample.
@@ -96,73 +115,67 @@ class DataUtils:
         Returns:
         - pandas.DataFrame or dask.dataframe.DataFrame: Updated DataFrame with merged lookup data.
         """
-        # Check if the DataFrame is empty
+        # Return early if the DataFrame is empty
         if self.is_dataframe_empty(df):
             return df
 
-        # Extract required parameters with default values
-        source_col = kwargs.pop('source_col', None)
-        lookup_col = kwargs.pop('lookup_col', None)
-        lookup_description_col = kwargs.pop('lookup_description_col', None)
-        source_description_alias = kwargs.pop('source_description_alias', None)
-        fillna_source_description_alias = kwargs.pop('fillna_source_description_alias', False)
-        fieldnames = kwargs.get('fieldnames', None)
-        column_names = kwargs.get('column_names', None)
+        # Extract and validate required parameters
+        required_params = ['source_col', 'lookup_col', 'lookup_description_col', 'source_description_alias']
+        missing_params = [param for param in required_params if param not in kwargs]
+        if missing_params:
+            raise ValueError(f"Missing required parameters: {', '.join(missing_params)}")
 
-        # Validate required parameters
-        if not all([source_col, lookup_col, lookup_description_col, source_description_alias]):
-            raise ValueError(
-                'source_col, lookup_col, lookup_description_col, and source_description_alias must be specified'
-            )
+        source_col = kwargs.pop('source_col')
+        lookup_col = kwargs.pop('lookup_col')
+        lookup_description_col = kwargs.pop('lookup_description_col')
+        source_description_alias = kwargs.pop('source_description_alias')
+
+        # Optional parameters with default values
+        fillna_source_description_alias = kwargs.pop('fillna_source_description_alias', False)
+        fieldnames = kwargs.pop('fieldnames', (lookup_col, lookup_description_col))
+        column_names = kwargs.pop('column_names', ['temp_join_col', source_description_alias])
 
         if source_col not in df.columns:
-            self.logger.info(f'{source_col} not in DataFrame columns')
+            self.logger.info(f"{source_col} not in DataFrame columns")
             return df
 
         # Get unique IDs from source column
         ids = df[source_col].dropna().unique()
         if isinstance(ids, dd.Series):
             ids = ids.compute()
-        ids = ids.tolist()
-
-        if not ids:
-            self.logger.info(f'No IDs found in the source column: {source_col}')
+        if not len(ids):
+            self.logger.info(f"No IDs found in the source column: {source_col}")
             return df
-
-        # Set default fieldnames and column_names if not provided
-        if fieldnames is None:
-            kwargs['fieldnames'] = (lookup_col, lookup_description_col)
-        if column_names is None:
-            kwargs['column_names'] = ['temp_join_col', source_description_alias]
-
+        ids = sorted(ids.tolist())
         # Prepare kwargs for loading lookup data
         load_kwargs = kwargs.copy()
-        load_kwargs[f'{lookup_col}__in'] = ids
-
+        load_kwargs.update({
+            'fieldnames': fieldnames,
+            'column_names': column_names,
+            f'{lookup_col}__in': ids
+        })
         # Load lookup data
-        lookup_instance = classname()
+        lookup_instance = classname(debug=True, verbose_debug=True)
         result = lookup_instance.load(**load_kwargs)
-
+        if len(result.index) == 0:
+            self.logger.info(f"No IDs found in the source column: {source_col}")
+            return df
         # Determine the join column on the result DataFrame
-        if 'temp_join_col' in kwargs.get("column_names", []):
-            temp_join_col = 'temp_join_col'
-        else:
-            temp_join_col = lookup_col
+        temp_join_col = 'temp_join_col' if 'temp_join_col' in column_names else lookup_col
 
         # Merge DataFrames
         df = df.merge(result, how='left', left_on=source_col, right_on=temp_join_col)
 
         if fillna_source_description_alias and source_description_alias in df.columns:
-            df[source_description_alias] = df[source_description_alias].fillna('')
+            df[source_description_alias]=df[source_description_alias].fillna('')
 
         # Drop temp_join_col if present
-        if 'temp_join_col' in df.columns:
-            df = df.drop(columns='temp_join_col')
+        df = df.drop(columns='temp_join_col', errors='ignore')
 
         return df
 
-    @staticmethod
-    def is_dataframe_empty(df):
+
+    def is_dataframe_empty(self, df):
         """
         Check if a DataFrame (Pandas or Dask) is empty.
 
@@ -173,14 +186,30 @@ class DataUtils:
         - bool: True if the DataFrame is empty, False otherwise.
         """
         if isinstance(df, dd.DataFrame):
-            df_size = df.map_partitions(len).sum().compute()
-            return df_size == 0
-        else:
+            try:
+                return len(df.index) == 0
+            except Exception as e:
+                self.logger.error(f"Error while processing Dask DataFrame: {e}")
+                return False
+        elif isinstance(df, pd.DataFrame):
             return df.empty
+        else:
+            self.logger.error("Input must be a pandas or dask DataFrame.")
+            return False
 
     @staticmethod
-    def convert_to_datetime(df, date_fields):
+    def convert_to_datetime_dask(df, date_fields):
+        """
+        Convert specified columns in a Dask DataFrame to datetime, handling errors gracefully.
+
+        Parameters:
+        - df (dask.dataframe.DataFrame): The Dask DataFrame containing the columns.
+        - date_fields (list of str): List of column names to convert to datetime.
+
+        Returns:
+        - dask.dataframe.DataFrame: Updated DataFrame with specified columns converted to datetime.
+        """
         for col in date_fields:
             if col in df.columns:
-                df[col] = pd.to_datetime(df[col], errors='coerce')
-        return df
+                df[col] = df[col].map_partitions(pd.to_datetime, errors="coerce", meta=(col, "datetime64[ns]"))
+        return df