dcs-sdk 1.5.5__py3-none-any.whl → 1.5.7__py3-none-any.whl

data_diff/abcs/database_types.py

@@ -326,6 +326,12 @@ class String_Alphanum(ColType_Alphanum, StringType):
         except ValueError:
             return False
 
+    def make_value(self, value) -> ArithAlphanumeric:
+        if isinstance(value, ArithAlphanumeric):
+            return value
+        # Coerce non-string primitives (e.g., integers) to string for alphanumeric representation
+        return ArithAlphanumeric(str(value))
+
 
 @attrs.define(frozen=True)
 class String_VaryingAlphanum(String_Alphanum):

data_diff/databases/sybase.py

@@ -475,7 +475,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 * 30  # 30 minutes
+        max_query_timeout = 60 * 5  # 5 minutes
 
         if self.dialect.sybase_driver_type.is_freetds:
             conn_dict = {

data_diff/diff_tables.py

@@ -28,7 +28,7 @@ import attrs
 # logger = getLogger(__name__)
 from loguru import logger
 
-from data_diff.abcs.database_types import IKey
+from data_diff.abcs.database_types import IKey, Integer, StringType
 from data_diff.errors import DataDiffMismatchingKeyTypesError
 from data_diff.info_tree import InfoTree, SegmentInfo
 from data_diff.table_segment import TableSegment, create_mesh_from_points
@@ -340,13 +340,22 @@ class TableDiffer(ThreadBase, ABC):
             if not isinstance(kt, IKey):
                 raise NotImplementedError(f"Cannot use a column of type {kt} as a key")
 
+        mismatched_key_types = False
         for i, (kt1, kt2) in enumerate(safezip(key_types1, key_types2)):
             if kt1.python_type is not kt2.python_type:
-                k1 = table1.key_columns[i]
-                k2 = table2.key_columns[i]
-                raise DataDiffMismatchingKeyTypesError(
-                    f"Key columns {k1} type: {kt1.python_type} and {k2} type: {kt2.python_type} can't be compared due to different types."
-                )
+                # Allow integer vs string, and string vs string variants for diffing, but mark as mismatched
+                if (isinstance(kt1, Integer) and isinstance(kt2, StringType)) or (
+                    isinstance(kt2, Integer) and isinstance(kt1, StringType)
+                ):
+                    mismatched_key_types = True
+                elif isinstance(kt1, StringType) and isinstance(kt2, StringType):
+                    mismatched_key_types = True
+                else:
+                    k1 = table1.key_columns[i]
+                    k2 = table2.key_columns[i]
+                    raise DataDiffMismatchingKeyTypesError(
+                        f"Key columns {k1} type: {kt1.python_type} and {k2} type: {kt2.python_type} can't be compared due to different types."
+                    )
 
         # Query min/max values
         key_ranges = self._threaded_call_as_completed("query_key_range", [table1, table2])
@@ -380,24 +389,27 @@ class TableDiffer(ThreadBase, ABC):
         # Overall, the max number of new regions in this 2nd pass is 3^|k| - 1
 
         # Note: python types can be the same, but the rendering parameters (e.g. casing) can differ.
-        min_key2, max_key2 = self._parse_key_range_result(key_types2, next(key_ranges))
-
-        points = [list(sorted(p)) for p in safezip(min_key1, min_key2, max_key1, max_key2)]
-        box_mesh = create_mesh_from_points(*points)
-
-        new_regions = [(p1, p2) for p1, p2 in box_mesh if p1 < p2 and not (p1 >= min_key1 and p2 <= max_key1)]
-
-        for p1, p2 in new_regions:
-            extra_table1 = table1.new_key_bounds(min_key=p1, max_key=p2, key_types=key_types1)
-            extra_table2 = table2.new_key_bounds(min_key=p1, max_key=p2, key_types=key_types2)
-            ti.submit(
-                self._bisect_and_diff_segments,
-                ti,
-                extra_table1,
-                extra_table2,
-                info_tree,
-                priority=999,
-            )
+        # If key types mismatched (e.g., int vs string), skip the second meshing pass to avoid
+        # attempting to sort mixed-type tuples (e.g., ArithAlphanumeric vs int).
+        if not mismatched_key_types:
+            min_key2, max_key2 = self._parse_key_range_result(key_types2, next(key_ranges))
+
+            points = [list(sorted(p)) for p in safezip(min_key1, min_key2, max_key1, max_key2)]
+            box_mesh = create_mesh_from_points(*points)
+
+            new_regions = [(p1, p2) for p1, p2 in box_mesh if p1 < p2 and not (p1 >= min_key1 and p2 <= max_key1)]
+
+            for p1, p2 in new_regions:
+                extra_table1 = table1.new_key_bounds(min_key=p1, max_key=p2, key_types=key_types1)
+                extra_table2 = table2.new_key_bounds(min_key=p1, max_key=p2, key_types=key_types2)
+                ti.submit(
+                    self._bisect_and_diff_segments,
+                    ti,
+                    extra_table1,
+                    extra_table2,
+                    info_tree,
+                    priority=999,
+                )
 
         return ti
 

data_diff/hashdiff_tables.py

@@ -448,7 +448,39 @@ class HashDiffer(TableDiffer):
     ):
         # Check if level exceeds maximum allowed recursion depth
         if level > 15:
-            raise RecursionError(f"Maximum recursion level exceeded: {level} > 15")
+            logger.warning(
+                ". " * level
+                + f"Maximum recursion level reached ({level}); switching to direct row comparison for segment {table1.min_key}..{table1.max_key}"
+            )
+            # Fallback: download rows and diff locally to prevent excessive recursion
+            rows1, rows2 = self._threaded_call("get_values", [table1, table2])
+            json_cols = {
+                i: colname
+                for i, colname in enumerate(table1.extra_columns)
+                if isinstance(table1._schema[colname], JSON)
+            }
+            diff = list(
+                diff_sets(
+                    rows1,
+                    rows2,
+                    json_cols=json_cols,
+                    columns1=table1.relevant_columns,
+                    columns2=table2.relevant_columns,
+                    key_columns1=table1.key_columns,
+                    key_columns2=table2.key_columns,
+                    ignored_columns1=self.ignored_columns1,
+                    ignored_columns2=self.ignored_columns2,
+                    diff_tracker=self._diff_tracker,
+                )
+            )
+            info_tree.info.set_diff(diff)
+            info_tree.info.rowcounts = {1: len(rows1), 2: len(rows2)}
+            self.stats["rows_downloaded"] = self.stats.get("rows_downloaded", 0) + max(len(rows1), len(rows2))
+            logger.info(
+                ". " * level
+                + f"Diff found {len(diff)} different rows, {self.stats['rows_downloaded']} total rows downloaded."
+            )
+            return diff
 
         # Initialize diff tracker if not already done
         self._initialize_diff_tracker(table1, table2)
@@ -553,7 +585,39 @@ class HashDiffer(TableDiffer):
     ):
         # Check if level exceeds maximum allowed recursion depth
         if level > 15:
-            raise RecursionError(f"Maximum recursion level exceeded: {level} > 15")
+            logger.warning(
+                ". " * level
+                + f"Maximum recursion level reached ({level}); switching to direct row comparison for segment {table1.min_key}..{table1.max_key}"
+            )
+            # Fallback: download rows and diff locally to prevent excessive recursion
+            rows1, rows2 = self._threaded_call("get_values", [table1, table2])
+            json_cols = {
+                i: colname
+                for i, colname in enumerate(table1.extra_columns)
+                if isinstance(table1._schema[colname], JSON)
+            }
+            diff = list(
+                diff_sets(
+                    rows1,
+                    rows2,
+                    json_cols=json_cols,
+                    columns1=table1.relevant_columns,
+                    columns2=table2.relevant_columns,
+                    key_columns1=table1.key_columns,
+                    key_columns2=table2.key_columns,
+                    ignored_columns1=self.ignored_columns1,
+                    ignored_columns2=self.ignored_columns2,
+                    diff_tracker=self._diff_tracker,
+                )
+            )
+            info_tree.info.set_diff(diff)
+            info_tree.info.rowcounts = {1: len(rows1), 2: len(rows2)}
+            self.stats["rows_downloaded"] = self.stats.get("rows_downloaded", 0) + max(len(rows1), len(rows2))
+            logger.info(
+                ". " * level
+                + f"Diff found {len(diff)} different rows, {self.stats['rows_downloaded']} total rows downloaded."
+            )
+            return diff
 
         assert table1.is_bounded and table2.is_bounded
 

data_diff/table_segment.py

@@ -252,6 +252,15 @@ class TableSegment:
     def _where(self) -> Optional[str]:
         return f"({self.where})" if self.where else None
 
+    def _column_expr(self, column_name: str) -> Expr:
+        """Return expression for a column, applying configured SQL transform if present."""
+        quoted_column_name = self.database.quote(s=column_name)
+        if self.transform_columns and column_name in self.transform_columns:
+            transform_expr = self.transform_columns[column_name]
+            quoted_expr = transform_expr.format(column=quoted_column_name)
+            return Code(quoted_expr)
+        return this[column_name]
+
     def _with_raw_schema(self, raw_schema: Dict[str, RawColumnInfo]) -> Self:
         schema = self.database._process_table_schema(self.table_path, raw_schema, self.relevant_columns, self._where())
         # return self.new(schema=create_schema(self.database.name, self.table_path, schema, self.case_sensitive))
@@ -277,10 +286,24 @@ class TableSegment:
     def _make_key_range(self):
         if self.min_key is not None:
             for mn, k in safezip(self.min_key, self.key_columns):
-                yield mn <= this[k]
+                quoted = self.database.dialect.quote(k)
+                base_expr_sql = (
+                    self.transform_columns[k].format(column=quoted)
+                    if self.transform_columns and k in self.transform_columns
+                    else quoted
+                )
+                constant_val = self.database.dialect._constant_value(mn)
+                yield Code(f"{base_expr_sql} >= {constant_val}")
         if self.max_key is not None:
             for k, mx in safezip(self.key_columns, self.max_key):
-                yield this[k] < mx
+                quoted = self.database.dialect.quote(k)
+                base_expr_sql = (
+                    self.transform_columns[k].format(column=quoted)
+                    if self.transform_columns and k in self.transform_columns
+                    else quoted
+                )
+                constant_val = self.database.dialect._constant_value(mx)
+                yield Code(f"{base_expr_sql} < {constant_val}")
 
     def _make_update_range(self):
         if self.min_update is not None:
@@ -353,9 +376,14 @@ class TableSegment:
                 and_exprs = []
                 for col, val in safezip(self.key_columns, key_values):
                     quoted = self.database.dialect.quote(col)
+                    base_expr_sql = (
+                        self.transform_columns[col].format(column=quoted)
+                        if self.transform_columns and col in self.transform_columns
+                        else quoted
+                    )
                     schema = self._schema[col]
                     if val is None:
-                        and_exprs.append(Code(quoted + " IS NULL"))
+                        and_exprs.append(Code(base_expr_sql + " IS NULL"))
                         continue
                     mk_v = schema.make_value(val)
                     constant_val = self.database.dialect._constant_value(mk_v)
@@ -364,9 +392,9 @@ class TableSegment:
                     if hasattr(self.database.dialect, "timestamp_equality_condition") and hasattr(
                         mk_v, "_dt"
                     ):  # Check if it's a datetime-like object
-                        where_expr = self.database.dialect.timestamp_equality_condition(quoted, constant_val)
+                        where_expr = self.database.dialect.timestamp_equality_condition(base_expr_sql, constant_val)
                     else:
-                        where_expr = f"{quoted} = {constant_val}"
+                        where_expr = f"{base_expr_sql} = {constant_val}"
 
                     and_exprs.append(Code(where_expr))
                 if and_exprs:
@@ -437,14 +465,8 @@ class TableSegment:
         # return [NormalizeAsString(this[c]) for c in self.relevant_columns]
         expressions = []
         for c in self.relevant_columns:
-            quoted_column_name = self.database.quote(s=c)
             schema = self._schema[c]
-            if self.transform_columns and c in self.transform_columns:
-                transform_expr = self.transform_columns[c]
-                quoted_expr = transform_expr.format(column=quoted_column_name)
-                expressions.append(NormalizeAsString(Code(quoted_expr), schema))
-            else:
-                expressions.append(NormalizeAsString(this[c], schema))
+            expressions.append(NormalizeAsString(self._column_expr(c), schema))
         return expressions
 
     def count(self) -> int:
@@ -460,10 +482,13 @@ class TableSegment:
         """Count and checksum the rows in the segment, in one pass."""
 
         checked_columns = [c for c in self.relevant_columns if c not in self.ignored_columns]
-        # cols = [NormalizeAsString(this[c]) for c in checked_columns]
+        # Build transformed expressions for checksum, honoring transforms and normalization
+        checksum_exprs: List[Expr] = []
+        for c in checked_columns:
+            schema = self._schema[c]
+            checksum_exprs.append(NormalizeAsString(self._column_expr(c), schema))
 
-        # q = self.make_select().select(Count(), Checksum(cols))
-        q = self.make_select().select(Count(), Checksum(self._relevant_columns_repr))
+        q = self.make_select().select(Count(), Checksum(checksum_exprs))
         start_time = time.monotonic()
         count, checksum = self.database.query(q, tuple)
         query_time_ms = (time.monotonic() - start_time) * 1000
@@ -486,7 +511,7 @@ class TableSegment:
         """Query database for minimum and maximum key. This is used for setting the initial bounds."""
         # Normalizes the result (needed for UUIDs) after the min/max computation
         select = self.make_select().select(
-            ApplyFuncAndNormalizeAsString(this[k], f) for k in self.key_columns for f in (min_, max_)
+            ApplyFuncAndNormalizeAsString(self._column_expr(k), f) for k in self.key_columns for f in (min_, max_)
         )
         result = tuple(self.database.query(select, tuple))
 

data_diff/utils.py

@@ -171,6 +171,10 @@ def _any_to_uuid(v: Union[str, int, UUID, "ArithUUID"]) -> UUID:
         return v.uuid
     elif isinstance(v, UUID):
         return v
+    # Accept unicode/arithmetic strings that wrap a UUID
+    elif "ArithUnicodeString" in globals() and isinstance(v, ArithUnicodeString):
+        s = getattr(v, "_str", str(v))
+        return UUID(s)
     elif isinstance(v, str):
         return UUID(v)
     elif isinstance(v, int):
@@ -625,6 +629,19 @@ def alphanums_to_numbers(s1: str, s2: str):
     return n1, n2
 
 
+def _alphanum_as_int_for_cmp(s: str) -> Optional[int]:
+    """Interpret an alphanum string as base-10 int if it's purely numeric (optional leading minus).
+
+    Returns None if not purely numeric, in which case callers should fallback to alphanum base ordering.
+    """
+    if re.fullmatch(r"-?\d+", s):
+        try:
+            return int(s)
+        except ValueError:
+            return None
+    return None
+
+
 @attrs.define(frozen=True, eq=False, order=False, repr=False)
 class ArithAlphanumeric(ArithString):
     _str: str
@@ -678,20 +695,53 @@ class ArithAlphanumeric(ArithString):
 
         return NotImplemented
 
-    def __ge__(self, other) -> bool:
-        if not isinstance(other, type(self)):
-            return NotImplemented
-        return self._str >= other._str
-
     def __lt__(self, other) -> bool:
-        if not isinstance(other, type(self)):
-            return NotImplemented
-        return self._str < other._str
+        if isinstance(other, ArithAlphanumeric):
+            return self._str < other._str
+        if isinstance(other, int):
+            v = _alphanum_as_int_for_cmp(self._str)
+            return (v if v is not None else alphanumToNumber(self._str)) < other
+        return NotImplemented
+
+    def __le__(self, other) -> bool:
+        if isinstance(other, ArithAlphanumeric):
+            return self._str <= other._str
+        if isinstance(other, int):
+            v = _alphanum_as_int_for_cmp(self._str)
+            return (v if v is not None else alphanumToNumber(self._str)) <= other
+        return NotImplemented
+
+    def __gt__(self, other) -> bool:
+        if isinstance(other, ArithAlphanumeric):
+            return self._str > other._str
+        if isinstance(other, int):
+            v = _alphanum_as_int_for_cmp(self._str)
+            return (v if v is not None else alphanumToNumber(self._str)) > other
+        return NotImplemented
+
+    def __ge__(self, other) -> bool:
+        if isinstance(other, ArithAlphanumeric):
+            return self._str >= other._str
+        if isinstance(other, int):
+            v = _alphanum_as_int_for_cmp(self._str)
+            return (v if v is not None else alphanumToNumber(self._str)) >= other
+        return NotImplemented
 
     def __eq__(self, other) -> bool:
-        if not isinstance(other, type(self)):
-            return NotImplemented
-        return self._str == other._str
+        if isinstance(other, ArithAlphanumeric):
+            return self._str == other._str
+        if isinstance(other, int):
+            v = _alphanum_as_int_for_cmp(self._str)
+            return (v if v is not None else alphanumToNumber(self._str)) == other
+        return NotImplemented
+
+    def __ne__(self, other) -> bool:
+        if isinstance(other, ArithAlphanumeric):
+            return self._str != other._str
+        if isinstance(other, int):
+            v = _alphanum_as_int_for_cmp(self._str)
+            return (v if v is not None else alphanumToNumber(self._str)) != other
+        return NotImplemented
 
     def new(self, *args, **kw) -> Self:
         return type(self)(*args, **kw, max_len=self._max_len)

dcs_sdk/__version__.py

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

{dcs_sdk-1.5.5.dist-info → dcs_sdk-1.5.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: dcs-sdk
-Version: 1.5.5
+Version: 1.5.7
 Summary: SDK for DataChecks
 Author: Waterdip Labs
 Author-email: hello@waterdip.ai
@@ -61,7 +61,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.5.5
+  DCS SDK v1.5.7
 </h1>
 
 > SDK for DataChecks

{dcs_sdk-1.5.5.dist-info → dcs_sdk-1.5.7.dist-info}/RECORD

@@ -2,7 +2,7 @@ data_diff/__init__.py,sha256=TGNvifF-dIbitACA6PS4sORtHEcTUukcrZz2NEIsL9U,10336
 data_diff/__main__.py,sha256=UvFvBKU74202bfRcIO_Wk-SU8WmnNuDK_1YVJpueMlc,16969
 data_diff/abcs/__init__.py,sha256=RkfhRKLXEForLCs4rZkTf0qc_b0TokSggSAcKI4yfZg,610
 data_diff/abcs/compiler.py,sha256=RuGhGlLTQuCzOJfYxa4gjcADsyvbZ9yZPuDuY6XH8Rk,785
-data_diff/abcs/database_types.py,sha256=OTx6GSUQnuQYkRN7yN0Di8mF-Wt7rTtyzjAQPenHzzw,11054
+data_diff/abcs/database_types.py,sha256=MKnWM9QBgeo-hjhgHhHWezd5i7HjozZ4ujsnzQ7ALOs,11326
 data_diff/config.py,sha256=uRcoVVhPjVZqgQNwr18v6sPq06cGXDLemTUyitU57zA,4998
 data_diff/databases/__init__.py,sha256=NrBm1Paj7jkHZ_hQCD-4-Q1eeDdh3v9_bz1DkPDOv9g,1680
 data_diff/databases/_connect.py,sha256=nGsmtzDSKN8CK8zMkdcGZz0iExzkJDYw-PGebIkmQgc,11151
@@ -18,13 +18,13 @@ data_diff/databases/postgresql.py,sha256=QrvYDsMSECQiPfsl85UQxY9ivxTRXnEwjAfRjd-
 data_diff/databases/presto.py,sha256=1Z8iDV2pc35Bu7DuUerFuFLbrwgSHSkBYmJ72JlZSZ8,7116
 data_diff/databases/redshift.py,sha256=-gFWs3NCcevO4s6c4zV3_LYihK24fUd5BADTKahubjw,8122
 data_diff/databases/snowflake.py,sha256=7G6fvVJXOtTvXmSfWCxTslF4WohoscQoiqcmJIN684A,7910
-data_diff/databases/sybase.py,sha256=QUGol1uLZ2KfvcYZIBUNfkfEJ8JxPUnvaT9QJBS70FU,31250
+data_diff/databases/sybase.py,sha256=ap_FWJk39ZM68y9c5B-luxlo-IgOXCi862HBh7MZutU,31248
 data_diff/databases/trino.py,sha256=VIN3gMJvT4oSYuXCJ1QnngVL2gjjEYMFw87QTHgjs8c,2328
 data_diff/databases/vertica.py,sha256=2dSDZp6qOEvUVPldI5Tgn7Sm3dCpC3vNXJL3qb3FDvQ,5529
-data_diff/diff_tables.py,sha256=Ey88gUr9Wh8UVsgRlBCY3CACIYfHL52PxJSrd821aqg,20060
+data_diff/diff_tables.py,sha256=AyFJF6oaam06AH4ZPI8pj63BiYojHoZTykjrdJCX2fI,20899
 data_diff/errors.py,sha256=4Yru8yOwyuDuBlTABnGCvJMSpe6-rbLJpNnVHeTTyHU,745
 data_diff/format.py,sha256=QFDjdZaBVf_N-jfKiX4ppOUdpXTPZXmv1j0pc1RiOoc,10245
-data_diff/hashdiff_tables.py,sha256=nbE3mfILWUYT9Z38P0lKskD_DrNOV4G_752EfmwGBxg,28339
+data_diff/hashdiff_tables.py,sha256=EBhEAZz-2a-qNs3OlFArInAV1KszBdZPotZmX7Z_lwo,31315
 data_diff/info_tree.py,sha256=yHtFSoXuu6oBafLYOYQjUSKlB-DnAAd08U9HOEAdTPI,2799
 data_diff/joindiff_tables.py,sha256=fyrEYjyh2BX1vGibwVZLYM1V6JJTOY-uGXY-KInvMkw,17612
 data_diff/lexicographic_space.py,sha256=bBoCbbH1Mla9jNOq1b5RuwjAxSVU7gWkra673tPBwXQ,8305
@@ -37,13 +37,13 @@ data_diff/queries/base.py,sha256=pT-iaII7Nlu-w-Cuq9fhoNKX7-GSxkQ3Fk8K-tMkk60,964
 data_diff/queries/extras.py,sha256=aUm-ifj3BMlz4o4bbuHtmnvHZuptYAKGS5yWTHmNpvc,1270
 data_diff/query_utils.py,sha256=R7ZfRwcvv9Zf4zWXNln4tr_OxLmDI7CPmmCahYfHxlo,2101
 data_diff/schema.py,sha256=QoYSSB3k-svLXz680uRgsI4qjii8BFKOOQvheqtgEbs,2413
-data_diff/table_segment.py,sha256=3UYy7FkNq4FjxPbmE7KH7OJ15ZRhH7Db5N_HSOnQ-dA,22014
+data_diff/table_segment.py,sha256=SdBVHLndDWMuLLM9zuUbfyTXZtNQgXarVLOmQTUWCCY,23356
 data_diff/thread_utils.py,sha256=_692ERjnWfHKaZsLdg7CNfkKiRd66y7_kpgDwzntp44,3831
-data_diff/utils.py,sha256=8vbVbJvBSqtRfrzvQsz79qIAF2bHn1dnufijstDxddU,31345
+data_diff/utils.py,sha256=ZSgK6utdYDWvnsYgl7sJQa6J3XK3T6xSB_BGdQVeK24,33457
 data_diff/version.py,sha256=Wk0ovyBlLEF2UaWLWEcVBLFElREtIxi7TU1hD3CuTFI,634
 dcs_sdk/__init__.py,sha256=RkfhRKLXEForLCs4rZkTf0qc_b0TokSggSAcKI4yfZg,610
 dcs_sdk/__main__.py,sha256=Qn8stIaQGrdLjHQ-H7xO0T-brtq5RWZoWU9QvqoarV8,683
-dcs_sdk/__version__.py,sha256=fqWzJu20sEpDvhUjXI3BeFEqxF9XIgaEIB1_s293hkY,633
+dcs_sdk/__version__.py,sha256=xvnvu6wSe7otkNeAkcLgPV0ELqT7G6RGaYllHIVN2Ts,633
 dcs_sdk/cli/__init__.py,sha256=RkfhRKLXEForLCs4rZkTf0qc_b0TokSggSAcKI4yfZg,610
 dcs_sdk/cli/cli.py,sha256=LyrRk972OL9pTqrvBeXWBu5rUDAN17lQ1g8FdSRW_8M,4299
 dcs_sdk/sdk/__init__.py,sha256=skrZcgWWJBL6NXTUERywJ3qRJRemgpDXyW7lPg1FJk8,2107
@@ -65,7 +65,7 @@ dcs_sdk/sdk/utils/similarity_score/levenshtein_distance_provider.py,sha256=puAWP
 dcs_sdk/sdk/utils/table.py,sha256=X8HxdYTWyx_oVrBWPsXlmA-xJKXXDBW9RrhlWNqA1As,18224
 dcs_sdk/sdk/utils/themes.py,sha256=Meo2Yldv4uyPpEqI7qdA28Aa6sxtwUU1dLKKm4QavjM,1403
 dcs_sdk/sdk/utils/utils.py,sha256=vF2zAvgt__Y8limicWTEWRyn41SBVJN81ZCTBRy6hQg,11907
-dcs_sdk-1.5.5.dist-info/METADATA,sha256=h9oMoKsk13VWjNG6yNIjza_46aG6kVS9BKVps9KwBQA,6275
-dcs_sdk-1.5.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-dcs_sdk-1.5.5.dist-info/entry_points.txt,sha256=zQtrZL7YuaKtt6WPwihCTV1BRXnqBkaY6zUGdYJbBSg,49
-dcs_sdk-1.5.5.dist-info/RECORD,,
+dcs_sdk-1.5.7.dist-info/METADATA,sha256=eQ1wuGbpB6gmbCWfC5yrPLWWCJXRZYASpWt4IaBl97Q,6275
+dcs_sdk-1.5.7.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+dcs_sdk-1.5.7.dist-info/entry_points.txt,sha256=zQtrZL7YuaKtt6WPwihCTV1BRXnqBkaY6zUGdYJbBSg,49
+dcs_sdk-1.5.7.dist-info/RECORD,,

{dcs_sdk-1.5.5.dist-info → dcs_sdk-1.5.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any