dcs-sdk 1.4.8__tar.gz → 1.5.0__tar.gz

{dcs_sdk-1.4.8 → dcs_sdk-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dcs-sdk
-Version: 1.4.8
+Version: 1.5.0
 Summary: SDK for DataChecks
 Author: Waterdip Labs
 Author-email: hello@waterdip.ai
@@ -60,7 +60,7 @@ Requires-Dist: vertica-python (>=1.4.0) ; extra == "vertica" or extra == "all-db
 Description-Content-Type: text/markdown
 
 <h1 align="center">
-  DCS SDK v1.4.8
+  DCS SDK v1.5.0
 </h1>
 
 > SDK for DataChecks

{dcs_sdk-1.4.8 → dcs_sdk-1.5.0}/README.md

@@ -1,5 +1,5 @@
 <h1 align="center">
-  DCS SDK v1.4.8
+  DCS SDK v1.5.0
 </h1>
 
 > SDK for DataChecks

{dcs_sdk-1.4.8 → dcs_sdk-1.5.0}/data_diff/abcs/database_types.py

@@ -14,15 +14,35 @@
 
 import decimal
 from abc import ABC, abstractmethod
-from datetime import datetime
+from datetime import date, datetime
 from typing import Collection, List, Optional, Tuple, Type, TypeVar, Union
 
 import attrs
 
-from data_diff.utils import ArithAlphanumeric, ArithUnicodeString, ArithUUID, Unknown
+from data_diff.utils import (
+    ArithAlphanumeric,
+    ArithDate,
+    ArithDateTime,
+    ArithTimestamp,
+    ArithTimestampTZ,
+    ArithUnicodeString,
+    ArithUUID,
+    Unknown,
+)
 
 DbPath = Tuple[str, ...]
-DbKey = Union[int, str, bytes, ArithUUID, ArithAlphanumeric, ArithUnicodeString]
+DbKey = Union[
+    int,
+    str,
+    bytes,
+    ArithUUID,
+    ArithAlphanumeric,
+    ArithUnicodeString,
+    ArithDateTime,
+    ArithDate,
+    ArithTimestamp,
+    ArithTimestampTZ,
+]
 DbTime = datetime
 
 N = TypeVar("N")
@@ -150,23 +170,66 @@ class TemporalType(PrecisionType):
 
 
 @attrs.define(frozen=True)
-class Timestamp(TemporalType):
-    pass
+class IKey(ABC):
+    "Interface for ColType, for using a column as a key in table."
+
+    @property
+    @abstractmethod
+    def python_type(self) -> type:
+        "Return the equivalent Python type of the key"
+
+    def make_value(self, value):
+        if isinstance(value, self.python_type):
+            return value
+        return self.python_type(value)
 
 
 @attrs.define(frozen=True)
-class TimestampTZ(TemporalType):
-    pass
+class Timestamp(TemporalType, IKey):
+    @property
+    def python_type(self) -> type:
+        return ArithTimestamp
+
+    def make_value(self, value):
+        if isinstance(value, ArithTimestamp):
+            return value
+        return ArithTimestamp(value)
 
 
 @attrs.define(frozen=True)
-class Datetime(TemporalType):
-    pass
+class TimestampTZ(TemporalType, IKey):
+    @property
+    def python_type(self) -> type:
+        return ArithTimestampTZ
+
+    def make_value(self, value):
+        if isinstance(value, ArithTimestampTZ):
+            return value
+        return ArithTimestampTZ(value)
 
 
 @attrs.define(frozen=True)
-class Date(TemporalType):
-    pass
+class Datetime(TemporalType, IKey):
+    @property
+    def python_type(self) -> type:
+        return ArithDateTime
+
+    def make_value(self, value):
+        if isinstance(value, ArithDateTime):
+            return value
+        return ArithDateTime(value)
+
+
+@attrs.define(frozen=True)
+class Date(TemporalType, IKey):
+    @property
+    def python_type(self) -> type:
+        return ArithDate
+
+    def make_value(self, value):
+        if isinstance(value, ArithDate):
+            return value
+        return ArithDate(value)
 
 
 @attrs.define(frozen=True)
@@ -190,21 +253,6 @@ class Float(FractionalType):
     python_type = float
 
 
-@attrs.define(frozen=True)
-class IKey(ABC):
-    "Interface for ColType, for using a column as a key in table."
-
-    @property
-    @abstractmethod
-    def python_type(self) -> type:
-        "Return the equivalent Python type of the key"
-
-    def make_value(self, value):
-        if isinstance(value, self.python_type):
-            return value
-        return self.python_type(value)
-
-
 @attrs.define(frozen=True)
 class Decimal(FractionalType, IKey):  # Snowflake may use Decimal as a key
     @property
@@ -243,7 +291,7 @@ class ColType_UUID(ColType, IKey):
 
 @attrs.define(frozen=True)
 class ColType_Alphanum(ColType, IKey):
-    python_type = ArithAlphanumeric
+    python_type = ArithUnicodeString
 
 
 @attrs.define(frozen=True)
@@ -273,7 +321,7 @@ class String_Alphanum(ColType_Alphanum, StringType):
     @staticmethod
     def test_value(value: str) -> bool:
         try:
-            ArithAlphanumeric(value)
+            ArithUnicodeString(value)
             return True
         except ValueError:
             return False

{dcs_sdk-1.4.8 → dcs_sdk-1.5.0}/data_diff/databases/base.py

@@ -54,6 +54,8 @@ from typing_extensions import Self
 from data_diff.abcs.compiler import AbstractCompiler, Compilable
 from data_diff.abcs.database_types import (
     JSON,
+    ArithAlphanumeric,
+    ArithUnicodeString,
     Array,
     Boolean,
     ColType,
@@ -114,7 +116,11 @@ from data_diff.queries.extras import (
 )
 from data_diff.schema import RawColumnInfo
 from data_diff.utils import (
+    ArithDate,
+    ArithDateTime,
     ArithString,
+    ArithTimestamp,
+    ArithTimestampTZ,
     ArithUUID,
     SybaseDriverTypes,
     is_uuid,
@@ -753,6 +759,18 @@ class BaseDialect(abc.ABC):
             return f"'{v.decode()}'"
         elif isinstance(v, Code):
             return v.code
+        elif isinstance(v, ArithAlphanumeric):
+            return f"'{v._str}'"
+        elif isinstance(v, ArithUnicodeString):
+            return f"'{v._str}'"
+        elif isinstance(v, ArithDate):
+            return f"'{str(v)}'"
+        elif isinstance(v, ArithTimestamp):
+            return f"'{str(v)}'"
+        elif isinstance(v, ArithTimestampTZ):
+            return f"'{str(v)}'"
+        elif isinstance(v, ArithDateTime):
+            return f"'{str(v)}'"
         return repr(v)
 
     def constant_values(self, rows) -> str:

{dcs_sdk-1.4.8 → dcs_sdk-1.5.0}/data_diff/databases/sybase.py

@@ -389,7 +389,7 @@ class Sybase(ThreadedDatabase):
         username = self._args.get("user", None)
         password = self._args.get("password", None)
         driver = self._args.get("driver", None)
-        max_query_timeout = 60 * 60  # 3600 seconds
+        max_query_timeout = 60 * 5  # 300 seconds
 
         if self.dialect.sybase_driver_type.is_freetds:
             conn_dict = {
@@ -583,7 +583,13 @@ class Sybase(ThreadedDatabase):
                     self.dialect.query_config_for_free_tds["ase_query_chosen"] = True
                     return ase_query
                 else:
+                    max_temp_space_usage_query = "SET TEMPORARY OPTION MAX_TEMP_SPACE_PER_CONNECTION = 5120"
+                    if self._query_cursor(self._conn.cursor(), max_temp_space_usage_query, test_query=True):
+                        logger.info("Max temporary space usage set successfully.")
+                    else:
+                        logger.warning("Failed to set max temporary space usage, continuing with default settings.")
                     logger.info("Sybase IQ Detected")
+
                     self.dialect.query_config_for_free_tds["freetds_query_chosen"] = True
                     return iq_query
             except Exception as e:

{dcs_sdk-1.4.8 → dcs_sdk-1.5.0}/data_diff/hashdiff_tables.py

@@ -522,7 +522,7 @@ class HashDiffer(TableDiffer):
 
         if count1 == 0 and count2 == 0:
             logger.debug(
-                "Uneven distribution of keys detected in segment %s..%s (big gaps in the key column). "
+                "Uneven distribution of keys detected in segment {}..{} (big gaps in the key column). "
                 "For better performance, we recommend to increase the bisection-threshold.",
                 table1.min_key,
                 table1.max_key,

{dcs_sdk-1.4.8 → dcs_sdk-1.5.0}/data_diff/table_segment.py

@@ -14,6 +14,7 @@
 
 import logging
 import time
+from decimal import Decimal
 from itertools import product
 from typing import Container, Dict, List, Optional, Sequence, Tuple
 
@@ -24,7 +25,18 @@ from typing_extensions import Self
 
 from data_diff.abcs.database_types import DbKey, DbPath, DbTime, IKey, NumericType
 from data_diff.databases.base import Database
-from data_diff.queries.api import SKIP, Code, Count, Expr, max_, min_, table, this
+from data_diff.queries.api import (
+    SKIP,
+    Code,
+    Count,
+    Expr,
+    and_,
+    max_,
+    min_,
+    or_,
+    table,
+    this,
+)
 from data_diff.queries.extras import (
     ApplyFuncAndNormalizeAsString,
     Checksum,
@@ -32,7 +44,11 @@ from data_diff.queries.extras import (
 )
 from data_diff.schema import RawColumnInfo, Schema, create_schema
 from data_diff.utils import (
+    ArithDate,
+    ArithDateTime,
     ArithString,
+    ArithTimestamp,
+    ArithTimestampTZ,
     ArithUnicodeString,
     Vector,
     safezip,
@@ -50,10 +66,18 @@ def split_key_space(min_key: DbKey, max_key: DbKey, count: int) -> List[DbKey]:
     if max_key - min_key <= count:
         count = 1
 
-    if isinstance(min_key, ArithString) or isinstance(min_key, ArithUnicodeString):
+    # Handle arithmetic string types (including temporal types)
+    if isinstance(
+        min_key, (ArithString, ArithUnicodeString, ArithDateTime, ArithDate, ArithTimestamp, ArithTimestampTZ)
+    ):
         assert type(min_key) is type(max_key)
         checkpoints = min_key.range(max_key, count)
     else:
+        # Handle numeric types
+        if isinstance(min_key, Decimal):
+            min_key = float(min_key)
+        if isinstance(max_key, Decimal):
+            max_key = float(max_key)
         checkpoints = split_space(min_key, max_key, count)
 
     assert all(min_key < x < max_key for x in checkpoints)
@@ -288,17 +312,65 @@ class TableSegment:
 
         return result
 
-    def get_sample_data(self, limit: int = 100) -> list:
-        "Download all the relevant values of the segment from the database"
+    # def get_sample_data(self, limit: int = 100) -> list:
+    #     "Download all the relevant values of the segment from the database"
+
+    #     exprs = []
+    #     for c in self.key_columns:
+    #         quoted = self.database.dialect.quote(c)
+    #         exprs.append(NormalizeAsString(Code(quoted), self._schema[c]))
+    #     if self.where:
+    #         select = self.source_table.select(*self._relevant_columns_repr).where(Code(self._where())).limit(limit)
+    #         self.key_columns
+    #     else:
+    #         select = self.source_table.select(*self._relevant_columns_repr).limit(limit)
+
+    #     start_time = time.monotonic()
+    #     result = self.database.query(select, List[Tuple])
+    #     query_time_ms = (time.monotonic() - start_time) * 1000
+    #     self._update_stats("row_fetch_queries_stats", query_time_ms)
+
+    def get_sample_data(self, limit: int = 100, sample_keys: Optional[List[List[DbKey]]] = None) -> list:
+        """
+        Download relevant values of the segment from the database.
+        If `sample_keys` is provided, it filters rows matching those composite keys.
+
+        Parameters:
+            limit (int): Maximum number of rows to return (default: 100).
+            sample_keys (Optional[List[List[DbKey]]]): List of composite keys to filter rows.
+                Each inner list must match the number of key_columns.
+
+        Returns:
+            list: List of tuples containing the queried row data.
+        """
+        select = self.make_select().select(*self._relevant_columns_repr)
 
-        exprs = []
-        for c in self.key_columns:
-            quoted = self.database.dialect.quote(c)
-            exprs.append(NormalizeAsString(Code(quoted), self._schema[c]))
-        if self.where:
-            select = self.source_table.select(*self._relevant_columns_repr).where(Code(self._where())).limit(limit)
+        filters = []
+
+        if sample_keys:
+            key_exprs = []
+            for key_values in sample_keys:
+                and_exprs = []
+                for col, val in safezip(self.key_columns, key_values):
+                    quoted = self.database.dialect.quote(col)
+                    schema = self._schema[col]
+                    if val is None:
+                        and_exprs.append(Code(quoted + " IS NULL"))
+                        continue
+                    mk_v = schema.make_value(val)
+                    constant_val = self.database.dialect._constant_value(mk_v)
+                    where_expr = f"{quoted} = {constant_val}"
+                    and_exprs.append(Code(where_expr))
+                if and_exprs:
+                    key_exprs.append(and_(*and_exprs))
+            if key_exprs:
+                filters.append(or_(*key_exprs))
+        if filters or self.where:
+            select = select.where(*filters)
         else:
-            select = self.source_table.select(*self._relevant_columns_repr).limit(limit)
+            logger.warning("No filters applied; fetching up to {} rows without key restrictions", limit)
+
+        select = select.limit(limit)
 
         start_time = time.monotonic()
         result = self.database.query(select, List[Tuple])

{dcs_sdk-1.4.8 → dcs_sdk-1.5.0}/data_diff/utils.py

@@ -21,7 +21,7 @@ import string
 import threading
 from abc import abstractmethod
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import date, datetime, time
 from typing import (
     Any,
     Dict,
@@ -179,11 +179,224 @@ def _any_to_uuid(v: Union[str, int, UUID, "ArithUUID"]) -> UUID:
         raise ValueError(f"Cannot convert a value to UUID: {v!r}")
 
 
+def _any_to_datetime(v: Union[str, datetime, date, "ArithDateTime"]) -> datetime:
+    """Convert various types to datetime object."""
+    if isinstance(v, ArithDateTime):
+        return v._dt
+    elif isinstance(v, datetime):
+        return v
+    elif isinstance(v, date):
+        return datetime.combine(v, time.min)
+    elif isinstance(v, str):
+        # Try to parse ISO format strings
+        try:
+            return datetime.fromisoformat(v.replace("Z", "+00:00"))
+        except ValueError:
+            # Fallback parsing for other common formats
+            try:
+                return datetime.strptime(v, "%Y-%m-%d %H:%M:%S")
+            except ValueError:
+                try:
+                    return datetime.strptime(v, "%Y-%m-%d")
+                except ValueError:
+                    raise ValueError(f"Cannot parse datetime string: {v!r}")
+    else:
+        raise ValueError(f"Cannot convert value to datetime: {v!r}")
+
+
+def _any_to_date(v: Union[str, datetime, date, "ArithDate"]) -> date:
+    """Convert various types to date object."""
+    if isinstance(v, ArithDate):
+        return v._date
+    elif isinstance(v, date):
+        return v
+    elif isinstance(v, datetime):
+        return v.date()
+    elif isinstance(v, str):
+        try:
+            return datetime.fromisoformat(v.replace("Z", "+00:00")).date()
+        except ValueError:
+            try:
+                return datetime.strptime(v, "%Y-%m-%d").date()
+            except ValueError:
+                raise ValueError(f"Cannot parse date string: {v!r}")
+    else:
+        raise ValueError(f"Cannot convert value to date: {v!r}")
+
+
+@attrs.define(frozen=True, eq=False, order=False)
+class ArithDateTime(ArithString):
+    """A datetime that supports basic arithmetic and range operations for database diffing."""
+
+    _dt: datetime = attrs.field(converter=_any_to_datetime)
+
+    def range(self, other: "ArithDateTime", count: int) -> List[Self]:
+        """Generate evenly spaced datetime checkpoints between self and other."""
+        assert isinstance(other, ArithDateTime)
+
+        start_ts = self._dt.timestamp()
+        end_ts = other._dt.timestamp()
+
+        checkpoints = split_space(start_ts, end_ts, count)
+        return [self.new(datetime.fromtimestamp(ts)) for ts in checkpoints]
+
+    def __int__(self) -> int:
+        """Convert to timestamp for arithmetic operations."""
+        return int(self._dt.timestamp())
+
+    def __add__(self, other: Union[int, float]) -> Self:
+        """Add seconds to the datetime."""
+        if isinstance(other, (int, float)):
+            new_ts = self._dt.timestamp() + other
+            return self.new(datetime.fromtimestamp(new_ts))
+        return NotImplemented
+
+    def __sub__(self, other: Union["ArithDateTime", int, float]):
+        """Subtract seconds or another datetime."""
+        if isinstance(other, (int, float)):
+            new_ts = self._dt.timestamp() - other
+            return self.new(datetime.fromtimestamp(new_ts))
+        elif isinstance(other, ArithDateTime):
+            return self._dt.timestamp() - other._dt.timestamp()
+        return NotImplemented
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, ArithDateTime):
+            return self._dt == other._dt
+        return NotImplemented
+
+    def __ne__(self, other: object) -> bool:
+        if isinstance(other, ArithDateTime):
+            return self._dt != other._dt
+        return NotImplemented
+
+    def __gt__(self, other: object) -> bool:
+        if isinstance(other, ArithDateTime):
+            return self._dt > other._dt
+        return NotImplemented
+
+    def __lt__(self, other: object) -> bool:
+        if isinstance(other, ArithDateTime):
+            return self._dt < other._dt
+        return NotImplemented
+
+    def __ge__(self, other: object) -> bool:
+        if isinstance(other, ArithDateTime):
+            return self._dt >= other._dt
+        return NotImplemented
+
+    def __le__(self, other: object) -> bool:
+        if isinstance(other, ArithDateTime):
+            return self._dt <= other._dt
+        return NotImplemented
+
+    def __str__(self) -> str:
+        """Return ISO format string."""
+        return self._dt.isoformat()
+
+    def __repr__(self) -> str:
+        return f"ArithDateTime({self._dt!r})"
+
+
+@attrs.define(frozen=True, eq=False, order=False)
+class ArithDate(ArithString):
+    """A date that supports basic arithmetic and range operations for database diffing."""
+
+    _date: date = attrs.field(converter=_any_to_date)
+
+    def range(self, other: "ArithDate", count: int) -> List[Self]:
+        """Generate evenly spaced date checkpoints between self and other."""
+        assert isinstance(other, ArithDate)
+
+        start_ordinal = self._date.toordinal()
+        end_ordinal = other._date.toordinal()
+
+        checkpoints = split_space(start_ordinal, end_ordinal, count)
+        return [self.new(date.fromordinal(int(ordinal))) for ordinal in checkpoints]
+
+    def __int__(self) -> int:
+        """Convert to ordinal for arithmetic operations."""
+        return self._date.toordinal()
+
+    def __add__(self, other: int) -> Self:
+        """Add days to the date."""
+        if isinstance(other, int):
+            new_ordinal = self._date.toordinal() + other
+            return self.new(date.fromordinal(new_ordinal))
+        return NotImplemented
+
+    def __sub__(self, other: Union["ArithDate", int]):
+        """Subtract days or another date."""
+        if isinstance(other, int):
+            new_ordinal = self._date.toordinal() - other
+            return self.new(date.fromordinal(new_ordinal))
+        elif isinstance(other, ArithDate):
+            return self._date.toordinal() - other._date.toordinal()
+        return NotImplemented
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, ArithDate):
+            return self._date == other._date
+        return NotImplemented
+
+    def __ne__(self, other: object) -> bool:
+        if isinstance(other, ArithDate):
+            return self._date != other._date
+        return NotImplemented
+
+    def __gt__(self, other: object) -> bool:
+        if isinstance(other, ArithDate):
+            return self._date > other._date
+        return NotImplemented
+
+    def __lt__(self, other: object) -> bool:
+        if isinstance(other, ArithDate):
+            return self._date < other._date
+        return NotImplemented
+
+    def __ge__(self, other: object) -> bool:
+        if isinstance(other, ArithDate):
+            return self._date >= other._date
+        return NotImplemented
+
+    def __le__(self, other: object) -> bool:
+        if isinstance(other, ArithDate):
+            return self._date <= other._date
+        return NotImplemented
+
+    def __str__(self) -> str:
+        """Return ISO format date string."""
+        return self._date.isoformat()
+
+    def __repr__(self) -> str:
+        return f"ArithDate({self._date!r})"
+
+
+@attrs.define(frozen=True, eq=False, order=False)
+class ArithTimestamp(ArithDateTime):
+    """A timestamp that inherits from ArithDateTime but with explicit timestamp semantics."""
+
+    def __repr__(self) -> str:
+        return f"ArithTimestamp({self._dt!r})"
+
+
+@attrs.define(frozen=True, eq=False, order=False)
+class ArithTimestampTZ(ArithDateTime):
+    """A timezone-aware timestamp that extends ArithDateTime."""
+
+    def __repr__(self) -> str:
+        return f"ArithTimestampTZ({self._dt!r})"
+
+    def __str__(self) -> str:
+        """Return ISO format string with timezone info."""
+        return self._dt.isoformat()
+
+
 @attrs.define(frozen=True, eq=False, order=False)
 class ArithUnicodeString(ArithString):
     """A Unicode string for arbitrary text keys, supporting lexicographical ordering and checkpoint generation across databases."""
 
-    string: str = attrs.field(converter=str)
+    _str: str = attrs.field(converter=str)
 
     @staticmethod
     def split_space(start: int, end: int, count: int) -> List[int]:
@@ -197,10 +410,10 @@ class ArithUnicodeString(ArithString):
 
     def _str_to_int(self) -> int:
         """Convert string to an integer for interpolation, handling empty strings and Unicode."""
-        if not self.string:
+        if not self._str:
             return 0  # Handle empty string
         result = 0
-        for char in self.string:
+        for char in self._str:
             result = result * 256 + ord(char)
         return result
 
@@ -220,9 +433,9 @@ class ArithUnicodeString(ArithString):
         assert isinstance(other, ArithUnicodeString), "Other must be an ArithUnicodeString"
 
         # Handle edge case: same or empty strings
-        if self.string == other.string or count <= 0:
+        if self._str == other._str or count <= 0:
             return []
-        if not self.string or not other.string:
+        if not self._str or not other._str:
             return [self.new("a") for _ in range(count)] if count > 0 else []
 
         # Ensure min_key < max_key
@@ -233,17 +446,25 @@ class ArithUnicodeString(ArithString):
         start_int = min_key._str_to_int()
         end_int = max_key._str_to_int()
 
+        # If the range is too small, return empty list
+        if end_int - start_int <= count:
+            return []
+
         # Generate checkpoints
         checkpoints_int = self.split_space(start_int, end_int, count)
 
         # Convert back to strings and create instances
-        checkpoints = [self.new(self._int_to_str(i)) for i in checkpoints_int]
-
-        # Filter to ensure min_key < x < max_key
-        filtered_checkpoints = [cp for cp in checkpoints if min_key < cp < max_key]
-
-        # Fallback to ensure non-empty list for close keys
-        return filtered_checkpoints or checkpoints[:count] or [self.new(self._int_to_str(start_int + 1))]
+        checkpoints = []
+        for i in checkpoints_int:
+            # Ensure checkpoint is valid and within bounds
+            if start_int < i < end_int:
+                checkpoint_str = self._int_to_str(i)
+                checkpoint = self.new(checkpoint_str)
+                # Double-check the string comparison bounds
+                if min_key < checkpoint < max_key:
+                    checkpoints.append(checkpoint)
+
+        return checkpoints
 
     def __int__(self) -> int:
         """Convert to integer representation for arithmetic."""
@@ -268,46 +489,46 @@ class ArithUnicodeString(ArithString):
     def __eq__(self, other: object) -> bool:
         """Check equality with another ArithUnicodeString."""
         if isinstance(other, ArithUnicodeString):
-            return self.string == other.string
+            return self._str == other._str
         return NotImplemented
 
     def __ne__(self, other: object) -> bool:
         """Check inequality with another ArithUnicodeString."""
         if isinstance(other, ArithUnicodeString):
-            return self.string != other.string
+            return self._str != other._str
         return NotImplemented
 
     def __gt__(self, other: object) -> bool:
         """Check if greater than another ArithUnicodeString."""
         if isinstance(other, ArithUnicodeString):
-            return self.string > other.string
+            return self._str > other._str
         return NotImplemented
 
     def __lt__(self, other: object) -> bool:
         """Check if less than another ArithUnicodeString."""
         if isinstance(other, ArithUnicodeString):
-            return self.string < other.string
+            return self._str < other._str
         return NotImplemented
 
     def __ge__(self, other: object) -> bool:
         """Check if greater than or equal to another ArithUnicodeString."""
         if isinstance(other, ArithUnicodeString):
-            return self.string >= other.string
+            return self._str >= other._str
         return NotImplemented
 
     def __le__(self, other: object) -> bool:
         """Check if less than or equal to another ArithUnicodeString."""
         if isinstance(other, ArithUnicodeString):
-            return self.string <= other.string
+            return self._str <= other._str
         return NotImplemented
 
     def __str__(self) -> str:
         """Return the string representation, escaped for SQL."""
-        return self.string.replace("'", "''")
+        return self._str.replace("'", "''")
 
     def __repr__(self) -> str:
         """Return a detailed representation."""
-        return f"ArithUnicodeString(string={self.string!r})"
+        return f"ArithUnicodeString(string={self._str!r})"
 
 
 @attrs.define(frozen=True, eq=False, order=False)
@@ -482,6 +703,9 @@ def number_to_human(n):
 
 
 def split_space(start, end, count) -> List[int]:
+    if isinstance(start, float) or isinstance(end, float):
+        step = (end - start) / (count + 1)
+        return [start + step * i for i in range(1, count + 1)]
     size = end - start
     assert count <= size, (count, size)
     return list(range(start, end, (size + 1) // (count + 1)))[1 : count + 1]

{dcs_sdk-1.4.8 → dcs_sdk-1.5.0}/dcs_sdk/__version__.py

@@ -12,4 +12,4 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-__version__ = "1.4.8"
+__version__ = "1.5.0"

{dcs_sdk-1.4.8 → dcs_sdk-1.5.0}/dcs_sdk/sdk/data_diff/data_differ.py

@@ -395,8 +395,10 @@ class DBTableDiffer:
                     error_message = f"Target table '{target_dataset.get('table_name')}' is empty"
                 is_table_empty = True
             if not is_table_empty and not self.config.schema_diff:
+                pks_len = len(self.table1.key_columns)
                 table_1_sample_data = self.table1.with_schema().get_sample_data(limit=100)
-                table_2_sample_data = self.table2.with_schema().get_sample_data(limit=100)
+                sample_keys = [list(row[:pks_len]) for row in table_1_sample_data]
+                table_2_sample_data = self.table2.with_schema().get_sample_data(limit=100, sample_keys=sample_keys)
                 self.diff_iter = diff_tables(
                     self.table1,
                     self.table2,
@@ -598,9 +600,14 @@ class DBTableDiffer:
                     columns_order_wise=columns_order_wise_target if columns_order_wise_target else [],
                 )
 
-                sample_value_column_names = list(self.table1.key_columns) + list(self.table1.extra_columns)
-                sample_value_source_dicts = [dict(zip(sample_value_column_names, row)) for row in table_1_sample_data]
-                sample_value_target_dicts = [dict(zip(sample_value_column_names, row)) for row in table_2_sample_data]
+                sample_value_column_names_src = list(self.table1.key_columns) + list(self.table1.extra_columns)
+                sample_value_column_names_tgt = list(self.table2.key_columns) + list(self.table2.extra_columns)
+                sample_value_source_dicts = [
+                    dict(zip(sample_value_column_names_src, row)) for row in table_1_sample_data
+                ]
+                sample_value_target_dicts = [
+                    dict(zip(sample_value_column_names_tgt, row)) for row in table_2_sample_data
+                ]
 
                 def get_pk(row, key_columns):
                     return tuple(row[k] for k in key_columns)
@@ -621,9 +628,9 @@ class DBTableDiffer:
                         key = []
                         for val in tup:
                             if isinstance(val, str) and val.isdigit():
-                                key.append(int(val))
+                                key.append((0, int(val)))
                             else:
-                                key.append(val)
+                                key.append((1, str(val)))
                         return tuple(key)
 
                     return sorted(keys, key=sort_key)

{dcs_sdk-1.4.8 → dcs_sdk-1.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dcs-sdk"
-version = "1.4.8"
+version = "1.5.0"
 description = "SDK for DataChecks"
 authors = ["Waterdip Labs <hello@waterdip.ai>"]
 readme = "README.md"