xoverrr 1.1.5__tar.gz → 1.1.6__tar.gz

{xoverrr-1.1.5/src/xoverrr.egg-info → xoverrr-1.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xoverrr
-Version: 1.1.5
+Version: 1.1.6
 Summary: A tool for cross-database and intra-source data comparison with detailed discrepancy analysis and reporting.
 Author-email: Dmitry Ischenko <hotmori@gmail.com>
 License: MIT
@@ -21,7 +21,7 @@ Requires-Dist: clickhouse-sqlalchemy>=0.2.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
-Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.15.0; extra == "dev"
 Requires-Dist: isort>=5.12.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: pre-commit>=3.0.0; extra == "dev"
@@ -31,7 +31,7 @@ Requires-Dist: pytest>=7.0.0; extra == "test"
 Requires-Dist: pytest-cov>=4.0.0; extra == "test"
 Requires-Dist: tenacity>=8.2.0; extra == "test"
 Provides-Extra: lint
-Requires-Dist: black>=23.0.0; extra == "lint"
+Requires-Dist: ruff>=0.15.0; extra == "lint"
 Requires-Dist: isort>=5.12.0; extra == "lint"
 Requires-Dist: flake8>=6.0.0; extra == "lint"
 Dynamic: license-file

{xoverrr-1.1.5 → xoverrr-1.1.6}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "xoverrr"
-version = "1.1.5"
+version = "1.1.6"
 description = "A tool for cross-database and intra-source data comparison with detailed discrepancy analysis and reporting."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -36,7 +36,7 @@ Homepage = "https://github.com/dima-ischenko/xoverrr"
 dev = [
     "pytest>=7.0.0",
     "pytest-cov>=4.0.0",
-    "black>=23.0.0",
+    "ruff>=0.15.0",
     "isort>=5.12.0",
     "mypy>=1.0.0",
     "pre-commit>=3.0.0",
@@ -48,7 +48,7 @@ test = [
     "tenacity>=8.2.0"
 ]
 lint = [
-    "black>=23.0.0",
+    "ruff>=0.15.0",
     "isort>=5.12.0",
     "flake8>=6.0.0",
 ]
@@ -59,4 +59,10 @@ where = ["src"]
 [tool.pytest.ini_options]
 pythonpath = ["src"]
 testpaths = ["tests"]
-addopts = "-v"
+addopts = "-v"
+
+[tool.ruff]
+target-version = "py39"
+
+[tool.ruff.format]
+quote-style = "single"

xoverrr-1.1.6/src/xoverrr/__init__.py

@@ -0,0 +1,13 @@
+from .constants import (COMPARISON_FAILED, COMPARISON_SKIPPED,
+                        COMPARISON_SUCCESS)
+from .core import DataQualityComparator, DataReference
+
+__all__ = [
+    'DataQualityComparator',
+    'DataReference',
+    'COMPARISON_SUCCESS',
+    'COMPARISON_FAILED',
+    'COMPARISON_SKIPPED',
+]
+
+__version__ = '1.1.6'

{xoverrr-1.1.5 → xoverrr-1.1.6}/src/xoverrr/adapters/__init__.py

@@ -1,6 +1,11 @@
 from .base import BaseDatabaseAdapter
+from .clickhouse import ClickHouseAdapter
 from .oracle import OracleAdapter
 from .postgres import PostgresAdapter
-from .clickhouse import ClickHouseAdapter
 
-__all__ = ['BaseDatabaseAdapter', 'OracleAdapter', 'PostgresAdapter', 'ClickHouseAdapter']
+__all__ = [
+    'BaseDatabaseAdapter',
+    'OracleAdapter',
+    'PostgresAdapter',
+    'ClickHouseAdapter',
+]

{xoverrr-1.1.5 → xoverrr-1.1.6}/src/xoverrr/adapters/base.py

@@ -1,18 +1,23 @@
-from abc import ABC, abstractmethod
-import pandas as pd
-from typing import Dict, Callable, List, Tuple, Optional, Union
 import re
+from abc import ABC, abstractmethod
 from datetime import datetime, timedelta
-from ..models import DataReference, ObjectType
-from ..constants import RESERVED_WORDS
+from typing import Callable, Dict, List, Optional, Tuple, Union
+
+import pandas as pd
 from sqlalchemy.engine import Engine
+
+from ..constants import RESERVED_WORDS
 from ..logger import app_logger
-from ..logger import app_logger
+from ..models import DataReference, ObjectType
+
 
 class BaseDatabaseAdapter(ABC):
     """Abstract base class with updated method signatures for parameterized queries"""
+
     @abstractmethod
-    def _execute_query(self, query: Union[str, Tuple[str, Dict]], engine: Engine, timezone:str) -> pd.DataFrame:
+    def _execute_query(
+        self, query: Union[str, Tuple[str, Dict]], engine: Engine, timezone: str
+    ) -> pd.DataFrame:
         """Execute query with DBMS-specific optimizations"""
         pass
 
@@ -30,42 +35,66 @@ class BaseDatabaseAdapter(ABC):
         pass
 
     @abstractmethod
-    def build_count_query(self, data_ref: DataReference, date_column: str,
-                         start_date: Optional[str], end_date: Optional[str]
-                         ) -> Tuple[str, Dict]:
+    def build_count_query(
+        self,
+        data_ref: DataReference,
+        date_column: str,
+        start_date: Optional[str],
+        end_date: Optional[str],
+    ) -> Tuple[str, Dict]:
         """Returns tuple of (query, params) with recent data exclusion"""
         pass
 
-    def build_data_query_common(self, data_ref: DataReference, columns: List[str],
-                        date_column: Optional[str], update_column: Optional[str],
-                        start_date: Optional[str], end_date: Optional[str],
-                        exclude_recent_hours: Optional[int] = None) -> Tuple[str, Dict]:
+    def build_data_query_common(
+        self,
+        data_ref: DataReference,
+        columns: List[str],
+        date_column: Optional[str],
+        update_column: Optional[str],
+        start_date: Optional[str],
+        end_date: Optional[str],
+        exclude_recent_hours: Optional[int] = None,
+    ) -> Tuple[str, Dict]:
         """Build data query for the DBMS with recent data exclusion"""
         # Handle reserved words
         cols_select = [
-            f'"{col}"' if col.lower() in RESERVED_WORDS
-            else col
-            for col in columns
+            f'"{col}"' if col.lower() in RESERVED_WORDS else col for col in columns
         ]
 
-        result = self.build_data_query(data_ref, cols_select, date_column, update_column,
-                                     start_date, end_date, exclude_recent_hours)
+        result = self.build_data_query(
+            data_ref,
+            cols_select,
+            date_column,
+            update_column,
+            start_date,
+            end_date,
+            exclude_recent_hours,
+        )
         return result
 
     @abstractmethod
-    def build_data_query(self, data_ref: DataReference, columns: List[str],
-                        date_column: Optional[str], update_column: Optional[str],
-                        start_date: Optional[str], end_date: Optional[str],
-                        exclude_recent_hours: Optional[int] = None) -> Tuple[str, Dict]:
+    def build_data_query(
+        self,
+        data_ref: DataReference,
+        columns: List[str],
+        date_column: Optional[str],
+        update_column: Optional[str],
+        start_date: Optional[str],
+        end_date: Optional[str],
+        exclude_recent_hours: Optional[int] = None,
+    ) -> Tuple[str, Dict]:
         pass
 
     @abstractmethod
-    def _build_exclusion_condition(self, update_column: str,
-                                 exclude_recent_hours: int) -> Tuple[str, Dict]:
+    def _build_exclusion_condition(
+        self, update_column: str, exclude_recent_hours: int
+    ) -> Tuple[str, Dict]:
         """DBMS-specific implementation for recent data exclusion"""
         pass
 
-    def convert_types(self, df: pd.DataFrame, metadata: pd.DataFrame, timezone: str) -> pd.DataFrame:
+    def convert_types(
+        self, df: pd.DataFrame, metadata: pd.DataFrame, timezone: str
+    ) -> pd.DataFrame:
         """Convert DBMS-specific types to standardized formats"""
         # there is need to specify timezone for covnersion as
         #   pandas implicitly converts to UTC tz aware cols
@@ -78,8 +107,9 @@ class BaseDatabaseAdapter(ABC):
         """Get type conversion rules for specific DBMS"""
         pass
 
-    def _apply_type_conversion(self, df: pd.DataFrame, metadata: pd.DataFrame,
-                             type_rules: Dict[str, Callable]) -> pd.DataFrame:
+    def _apply_type_conversion(
+        self, df: pd.DataFrame, metadata: pd.DataFrame, type_rules: Dict[str, Callable]
+    ) -> pd.DataFrame:
         """Apply type conversion rules to DataFrame"""
         if df.empty:
             return df
@@ -94,7 +124,6 @@ class BaseDatabaseAdapter(ABC):
             if col_name not in df.columns:
                 continue
 
-
             col_type = col_info['data_type'].lower()
             # Find matching conversion rule
             converter = None
@@ -105,15 +134,15 @@ class BaseDatabaseAdapter(ABC):
                     break
 
             if converter is None:
-                continue # Skip columns without converters
+                continue  # Skip columns without converters
 
             try:
                 df[col_name] = converter(df[col_name])
             except Exception as e:
-                app_logger.warning(f"Type conversion failed for {col_name}: {str(e)}")
+                app_logger.warning(f'Type conversion failed for {col_name}: {str(e)}')
                 df[col_name] = df[col_name].astype(str)
 
             new_type = df[col_name].dtype
             app_logger.debug(f'old: {col_type}, new: {new_type}')
 
-        return df
+        return df

{xoverrr-1.1.5 → xoverrr-1.1.6}/src/xoverrr/adapters/clickhouse.py

@@ -1,15 +1,21 @@
+import time
+from typing import Callable, Dict, List, Optional, Tuple, Union
+
 import pandas as pd
-from typing import Optional, Dict, Callable, List, Tuple, Union
+
 from ..constants import DATE_FORMAT, DATETIME_FORMAT
-from .base import BaseDatabaseAdapter, Engine
-from ..models import DataReference, ObjectType
 from ..exceptions import QueryExecutionError
-import time
 from ..logger import app_logger
+from ..models import DataReference, ObjectType
+from .base import BaseDatabaseAdapter, Engine
+
 
 class ClickHouseAdapter(BaseDatabaseAdapter):
     """ClickHouse adapter with parameterized queries"""
-    def _execute_query(self, query: Union[str, Tuple[str, Dict]], engine: Engine, timezone: str) -> pd.DataFrame:
+
+    def _execute_query(
+        self, query: Union[str, Tuple[str, Dict]], engine: Engine, timezone: str
+    ) -> pd.DataFrame:
         df = None
         tz_set = None
         start_time = time.time()
@@ -32,14 +38,16 @@ class ClickHouseAdapter(BaseDatabaseAdapter):
                 df = pd.read_sql(query, engine)
 
             execution_time = time.time() - start_time
-            app_logger.info(f"Query executed in {execution_time:.2f}s")
+            app_logger.info(f'Query executed in {execution_time:.2f}s')
             return df
 
         except Exception as e:
             execution_time = time.time() - start_time
-            app_logger.error(f"Query execution failed after {execution_time:.2f}s: {str(e)}")
+            app_logger.error(
+                f'Query execution failed after {execution_time:.2f}s: {str(e)}'
+            )
 
-            raise QueryExecutionError(f"Query failed: {str(e)}")
+            raise QueryExecutionError(f'Query failed: {str(e)}')
 
     def get_object_type(self, data_ref: DataReference, engine: Engine) -> ObjectType:
         """Determine if object is table or view in ClickHouse"""
@@ -67,7 +75,9 @@ class ClickHouseAdapter(BaseDatabaseAdapter):
                 else:
                     return ObjectType.TABLE
         except Exception as e:
-            app_logger.warning(f"Could not determine object type for {data_ref.full_name}: {str(e)}")
+            app_logger.warning(
+                f'Could not determine object type for {data_ref.full_name}: {str(e)}'
+            )
 
         return ObjectType.UNKNOWN
 
@@ -97,8 +107,13 @@ class ClickHouseAdapter(BaseDatabaseAdapter):
         params = {'schema': data_ref.schema, 'table': data_ref.name}
         return query, params
 
-    def build_count_query(self, data_ref: DataReference, date_column: str,
-                         start_date: Optional[str], end_date: Optional[str]) -> Tuple[str, Dict]:
+    def build_count_query(
+        self,
+        data_ref: DataReference,
+        date_column: str,
+        start_date: Optional[str],
+        end_date: Optional[str],
+    ) -> Tuple[str, Dict]:
         query = f"""
             SELECT
                 formatDateTime(toDate({date_column}), '%%Y-%%m-%%d') as dt,
@@ -108,24 +123,29 @@ class ClickHouseAdapter(BaseDatabaseAdapter):
         """
         params = {}
 
-
         if start_date:
-            query += f" AND {date_column} >= toDate(%(start_date)s)"
+            query += f' AND {date_column} >= toDate(%(start_date)s)'
             params['start_date'] = start_date
         if end_date:
-            query += f" AND {date_column} < toDate(%(end_date)s) + INTERVAL 1 day"
+            query += f' AND {date_column} < toDate(%(end_date)s) + INTERVAL 1 day'
             params['end_date'] = end_date
 
-        query += " GROUP BY dt ORDER BY dt DESC"
+        query += ' GROUP BY dt ORDER BY dt DESC'
         return query, params
 
-    def build_data_query(self, data_ref: DataReference, columns: List[str],
-                        date_column: Optional[str], update_column: str,
-                        start_date: Optional[str], end_date: Optional[str],
-                        exclude_recent_hours: Optional[int] = None) -> Tuple[str, Dict]:
+    def build_data_query(
+        self,
+        data_ref: DataReference,
+        columns: List[str],
+        date_column: Optional[str],
+        update_column: str,
+        start_date: Optional[str],
+        end_date: Optional[str],
+        exclude_recent_hours: Optional[int] = None,
+    ) -> Tuple[str, Dict]:
         params = {}
         # Add recent data exclusion flag
-        exclusion_condition,  exclusion_params = self._build_exclusion_condition(
+        exclusion_condition, exclusion_params = self._build_exclusion_condition(
             update_column, exclude_recent_hours
         )
 
@@ -139,36 +159,41 @@ class ClickHouseAdapter(BaseDatabaseAdapter):
         WHERE 1=1\n"""
 
         if start_date and date_column:
-            query += f"            AND {date_column} >= toDate(%(start_date)s)\n"
+            query += f'            AND {date_column} >= toDate(%(start_date)s)\n'
             params['start_date'] = start_date
         if end_date and date_column:
-            query += f"            AND {date_column} < toDate(%(end_date)s) + INTERVAL 1 day\n"
+            query += f'            AND {date_column} < toDate(%(end_date)s) + INTERVAL 1 day\n'
             params['end_date'] = end_date
 
         return query, params
 
-    def _build_exclusion_condition(self, update_column: str,
-                                    exclude_recent_hours: int) -> Tuple[str, Dict]:
+    def _build_exclusion_condition(
+        self, update_column: str, exclude_recent_hours: int
+    ) -> Tuple[str, Dict]:
         """ClickHouse-specific implementation for recent data exclusion"""
-        if  update_column and exclude_recent_hours:
-
-
+        if update_column and exclude_recent_hours:
             exclude_recent_hours = exclude_recent_hours
 
             condition = f"""case when {update_column} > (now() - INTERVAL %(exclude_recent_hours)s HOUR) then 'y' end as xrecently_changed"""
-            params = {'exclude_recent_hours':  exclude_recent_hours}
+            params = {'exclude_recent_hours': exclude_recent_hours}
             return condition, params
 
         return None, None
 
     def _get_type_conversion_rules(self, timezone: str) -> Dict[str, Callable]:
         return {
-                r'datetime64|datetime': lambda x: pd.to_datetime(x, utc=True, errors='coerce')
-                                                .dt.tz_convert(timezone)
-                                                .dt.strftime(DATETIME_FORMAT)
-                                                .str.replace(r'\s00:00:00$', '', regex=True),
-                r'date': lambda x: pd.to_datetime(x, errors='coerce')
-                                    .dt.strftime(DATE_FORMAT)
-                                    .str.replace(r'\s00:00:00$', '', regex=True),
-                r'uint64|uint8|float|decimal|int32': lambda x: x.astype(str).str.replace(r'\.0+$', '', regex=True),
-        } 
+            r'datetime64|datetime': lambda x: (
+                pd.to_datetime(x, utc=True, errors='coerce')
+                .dt.tz_convert(timezone)
+                .dt.strftime(DATETIME_FORMAT)
+                .str.replace(r'\s00:00:00$', '', regex=True)
+            ),
+            r'date': lambda x: (
+                pd.to_datetime(x, errors='coerce')
+                .dt.strftime(DATE_FORMAT)
+                .str.replace(r'\s00:00:00$', '', regex=True)
+            ),
+            r'uint64|uint8|float|decimal|int32': lambda x: x.astype(str).str.replace(
+                r'\.0+$', '', regex=True
+            ),
+        }

{xoverrr-1.1.5 → xoverrr-1.1.6}/src/xoverrr/adapters/oracle.py

@@ -1,16 +1,19 @@
+import time
+from typing import Callable, Dict, List, Optional, Tuple, Union
+
 import pandas as pd
-from typing import Optional, Dict, Callable, List, Tuple, Union
 
 from ..constants import DATETIME_FORMAT
-from .base import BaseDatabaseAdapter, Engine
-from ..models import DataReference, ObjectType
 from ..exceptions import QueryExecutionError
 from ..logger import app_logger
-import time
+from ..models import DataReference, ObjectType
+from .base import BaseDatabaseAdapter, Engine
 
-class OracleAdapter(BaseDatabaseAdapter):
 
-    def _execute_query(self, query: Union[str, Tuple[str, Dict]], engine: Engine, timezone: str) -> pd.DataFrame:
+class OracleAdapter(BaseDatabaseAdapter):
+    def _execute_query(
+        self, query: Union[str, Tuple[str, Dict]], engine: Engine, timezone: str
+    ) -> pd.DataFrame:
         tz_set = None
         raw_conn = None
         cursor = None
@@ -40,12 +43,11 @@ class OracleAdapter(BaseDatabaseAdapter):
                 app_logger.info(f'query\n {query}')
                 cursor.execute(query)
 
-
             columns = [col[0].lower() for col in cursor.description]
             data = cursor.fetchall()
 
             execution_time = time.time() - start_time
-            app_logger.info(f"Query executed in {execution_time:.2f}s")
+            app_logger.info(f'Query executed in {execution_time:.2f}s')
 
             app_logger.info('complete')
 
@@ -57,20 +59,22 @@ class OracleAdapter(BaseDatabaseAdapter):
 
         except Exception as e:
             execution_time = time.time() - start_time
-            app_logger.error(f"Query execution failed after {execution_time:.2f}s: {str(e)}")
+            app_logger.error(
+                f'Query execution failed after {execution_time:.2f}s: {str(e)}'
+            )
 
             if raw_conn:
                 try:
                     raw_conn.rollback()
                 except Exception as rollback_error:
-                    app_logger.warning(f"Rollback failed: {rollback_error}")
+                    app_logger.warning(f'Rollback failed: {rollback_error}')
                 try:
                     if cursor:
                         cursor.close()
                 except Exception as close_error:
-                    app_logger.warning(f"Cursor close failed: {close_error}")
+                    app_logger.warning(f'Cursor close failed: {close_error}')
 
-            raise QueryExecutionError(f"Query failed: {str(e)}")
+            raise QueryExecutionError(f'Query failed: {str(e)}')
 
     def get_object_type(self, data_ref: DataReference, engine: Engine) -> ObjectType:
         """Determine if object is table or view in Oracle"""
@@ -95,10 +99,12 @@ class OracleAdapter(BaseDatabaseAdapter):
                 return {
                     'table': ObjectType.TABLE,
                     'view': ObjectType.VIEW,
-                    'materialized_view': ObjectType.MATERIALIZED_VIEW
+                    'materialized_view': ObjectType.MATERIALIZED_VIEW,
                 }.get(type_str, ObjectType.UNKNOWN)
         except Exception as e:
-            app_logger.warning(f"Could not determine object type for {data_ref.full_name}: {str(e)}")
+            app_logger.warning(
+                f'Could not determine object type for {data_ref.full_name}: {str(e)}'
+            )
 
         return ObjectType.UNKNOWN
 
@@ -121,7 +127,7 @@ class OracleAdapter(BaseDatabaseAdapter):
 
     def build_primary_key_query(self, data_ref: DataReference) -> pd.DataFrame:
 
-        #todo add suport of unique indexes when no pk?
+        # todo add suport of unique indexes when no pk?
         query = """
             SELECT lower(cols.column_name) as pk_column_name
             FROM all_constraints cons
@@ -139,9 +145,13 @@ class OracleAdapter(BaseDatabaseAdapter):
         params['table_name'] = data_ref.name
         return query, params
 
-
-    def build_count_query(self, data_ref: DataReference, date_column: str,
-                            start_date: Optional[str], end_date: Optional[str]) -> Tuple[str, Dict]:
+    def build_count_query(
+        self,
+        data_ref: DataReference,
+        date_column: str,
+        start_date: Optional[str],
+        end_date: Optional[str],
+    ) -> Tuple[str, Dict]:
         query = f"""
             SELECT
                 to_char(trunc({date_column}, 'dd'),'YYYY-MM-DD') as dt,
@@ -150,7 +160,6 @@ class OracleAdapter(BaseDatabaseAdapter):
             WHERE 1=1\n"""
         params = {}
 
-
         if start_date:
             query += f" AND {date_column} >= trunc(to_date(:start_date, 'YYYY-MM-DD'), 'dd')\n"
             params['start_date'] = start_date
@@ -161,14 +170,20 @@ class OracleAdapter(BaseDatabaseAdapter):
         query += f" GROUP BY to_char(trunc({date_column}, 'dd'),'YYYY-MM-DD') ORDER BY dt DESC"
         return query, params
 
-    def build_data_query(self, data_ref: DataReference, columns: List[str],
-                        date_column: Optional[str], update_column: str,
-                        start_date: Optional[str], end_date: Optional[str],
-                        exclude_recent_hours: Optional[int] = None) -> Tuple[str, Dict]:
+    def build_data_query(
+        self,
+        data_ref: DataReference,
+        columns: List[str],
+        date_column: Optional[str],
+        update_column: str,
+        start_date: Optional[str],
+        end_date: Optional[str],
+        exclude_recent_hours: Optional[int] = None,
+    ) -> Tuple[str, Dict]:
 
         params = {}
         # Add recent data exclusion flag
-        exclusion_condition,  exclusion_params = self._build_exclusion_condition(
+        exclusion_condition, exclusion_params = self._build_exclusion_condition(
             update_column, exclude_recent_hours
         )
 
@@ -191,25 +206,39 @@ class OracleAdapter(BaseDatabaseAdapter):
 
         return query, params
 
-    def _build_exclusion_condition(self, update_column: str,
-                                    exclude_recent_hours: int) -> Tuple[str, Dict]:
+    def _build_exclusion_condition(
+        self, update_column: str, exclude_recent_hours: int
+    ) -> Tuple[str, Dict]:
         """Oracle-specific implementation for recent data exclusion"""
-        if  update_column and exclude_recent_hours:
-
-
-
+        if update_column and exclude_recent_hours:
             condition = f"""case when {update_column} > (sysdate - :exclude_recent_hours/24) then 'y' end as xrecently_changed"""
-            params = {'exclude_recent_hours':  exclude_recent_hours}
+            params = {'exclude_recent_hours': exclude_recent_hours}
             return condition, params
 
         return None, None
 
     def _get_type_conversion_rules(self, timezone: str) -> Dict[str, Callable]:
         return {
-            #errors='coerce' is needed as workaround for >= 2262 year: Out of bounds nanosecond timestamp (3023-04-04 00:00:00)
+            # errors='coerce' is needed as workaround for >= 2262 year: Out of bounds nanosecond timestamp (3023-04-04 00:00:00)
             #  todo need specify explicit dateformat (nls params) in sessions, for the correct string conversion to datetime
-            r'date': lambda x: pd.to_datetime(x, errors='coerce').dt.strftime(DATETIME_FORMAT).str.replace(r'\s00:00:00$', '', regex=True),
-            r'timestamp.*\bwith\b.*time\szone': lambda x: pd.to_datetime(x, utc=True, errors='coerce').dt.tz_convert(timezone).dt.tz_localize(None).dt.strftime(DATETIME_FORMAT).str.replace(r'\s00:00:00$', '', regex=True),
-            r'timestamp': lambda x: pd.to_datetime(x, errors='coerce').dt.strftime(DATETIME_FORMAT).str.replace(r'\s00:00:00$', '', regex=True),
-            r'number|float|double': lambda x: x.astype(str).str.replace(r'\.0+$', '', regex=True).str.lower(), #lower case for exponential form compare
+            r'date': lambda x: (
+                pd.to_datetime(x, errors='coerce')
+                .dt.strftime(DATETIME_FORMAT)
+                .str.replace(r'\s00:00:00$', '', regex=True)
+            ),
+            r'timestamp.*\bwith\b.*time\szone': lambda x: (
+                pd.to_datetime(x, utc=True, errors='coerce')
+                .dt.tz_convert(timezone)
+                .dt.tz_localize(None)
+                .dt.strftime(DATETIME_FORMAT)
+                .str.replace(r'\s00:00:00$', '', regex=True)
+            ),
+            r'timestamp': lambda x: (
+                pd.to_datetime(x, errors='coerce')
+                .dt.strftime(DATETIME_FORMAT)
+                .str.replace(r'\s00:00:00$', '', regex=True)
+            ),
+            r'number|float|double': lambda x: (
+                x.astype(str).str.replace(r'\.0+$', '', regex=True).str.lower()
+            ),  # lower case for exponential form compare
         }