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

data_diff/__init__.py

@@ -114,6 +114,7 @@ def diff_tables(
     # Timeout limit in minutes
     # (used for diffing large tables, to avoid long-running queries)
     timeout_limit: int = DEAFULT_TIMEOUT,
+    in_memory_diff: bool = False,
 ) -> Iterator:
     """Finds the diff between table1 and table2.
 
@@ -198,6 +199,7 @@ def diff_tables(
             per_column_diff_limit=per_column_diff_limit,
             egress_limit=egress_limit,
             timeout_limit=timeout_limit,
+            in_memory_diff=in_memory_diff,
         )
     elif algorithm == Algorithm.JOINDIFF:
         if isinstance(materialize_to_table, str):

data_diff/databases/postgresql.py

@@ -185,7 +185,13 @@ class PostgresqlDialect(BaseDialect):
             return padded
 
     def normalize_number(self, value: str, coltype: FractionalType) -> str:
-        return self.to_string(f"{value}::decimal(38, {coltype.precision})")
+        precision = coltype.precision
+        if precision:
+            if precision >= 1000:
+                precision = 1000
+            elif precision <= -1000:
+                precision = -1000
+        return self.to_string(f"{value}::decimal(38, {precision})")
 
     def normalize_boolean(self, value: str, _coltype: Boolean) -> str:
         return self.to_string(f"{value}::int")

data_diff/databases/sybase.py

@@ -299,8 +299,9 @@ class Dialect(BaseDialect):
             return timestamp_str
 
     def normalize_number(self, value: str, coltype: FractionalType) -> str:
-        scale = getattr(coltype, "scale", 0) or 0
-        return self.to_string(f"CAST({value} AS DECIMAL(38, {scale}))")
+        # scale = getattr(coltype, "scale", 0) or 0
+        precision = getattr(coltype, "precision", 0) or 0
+        return self.to_string(f"CAST({value} AS DECIMAL(38, {precision}))")
 
     # def md5_as_int(self, s: str) -> str:
     #     """Returns an MD5 hash of the input string as an integer for Sybase IQ."""

data_diff/hashdiff_tables.py

@@ -18,7 +18,7 @@ import time
 from collections import defaultdict
 from numbers import Number
 from threading import Lock
-from typing import Any, Collection, Dict, Iterator, List, Sequence, Set, Tuple
+from typing import Any, Collection, Dict, Iterator, List, Optional, Sequence, Set, Tuple
 
 import attrs
 from loguru import logger
@@ -711,3 +711,315 @@ class HashDiffer(TableDiffer):
             return diff
 
         return super()._bisect_and_diff_segments(ti, table1, table2, info_tree, level, max_rows)
+
+
+@attrs.define(frozen=False)
+class HashDiffer(HashDiffer):
+    """
+    Enhanced HashDiffer with in-memory mode support.
+
+    Additional Parameters:
+        in_memory_diff (bool): If True, skip checksums and download segments directly for in-memory comparison.
+                               If False, use standard checksum-based bisection (default behavior).
+        memory_segment_size (int): When in_memory_diff=True, target number of rows per segment before downloading.
+    """
+
+    in_memory_diff: bool = False
+    memory_segment_size: int = 10000
+
+    def __attrs_post_init__(self) -> None:
+        super().__attrs_post_init__()
+
+        if self.in_memory_diff:
+            logger.info("=" * 70)
+            logger.info("IN-MEMORY DIFF MODE ENABLED")
+            logger.info("  - Checksum queries: DISABLED")
+            logger.info(f"  - Segment size: {self.memory_segment_size} rows")
+            logger.info(f"  - Threading: {'ENABLED' if self.threaded else 'DISABLED'}")
+            logger.info(f"  - Egress limit: {self.egress_limit} rows")
+            logger.info("=" * 70)
+
+            # Adjust bisection threshold for in-memory mode
+            if self.memory_segment_size > 0:
+                self.bisection_threshold = self.memory_segment_size
+
+    def _should_skip_checksum_and_download(self, max_rows: int) -> bool:
+        """
+        Determine if we should skip checksum and directly download segment data.
+
+        Returns True if:
+        1. in_memory_diff flag is enabled, OR
+        2. Traditional conditions: segment is below bisection threshold
+        """
+        return self.in_memory_diff
+        # if self.in_memory_diff:
+        #     # In memory mode: download if segment is at or below target size
+        #     return max_rows <= self.memory_segment_size
+        # else:
+        #     # Traditional mode: use bisection threshold
+        #     return self.bisection_disabled or max_rows < self.bisection_threshold
+
+    def _diff_segments(
+        self,
+        ti,
+        table1: TableSegment,
+        table2: TableSegment,
+        info_tree: InfoTree,
+        max_rows: int,
+        level=0,
+        segment_index=None,
+        segment_count=None,
+    ):
+        """
+        Enhanced segment diffing with in-memory mode support.
+        """
+        # Check recursion depth limit
+        if level > 15:
+            logger.warning(
+                ". " * level + f"Maximum recursion level ({level}) reached; "
+                f"downloading segment {table1.min_key}..{table1.max_key}"
+            )
+            return self._download_and_diff_locally(table1, table2, info_tree, level)
+
+        # Initialize diff tracker
+        self._initialize_diff_tracker(table1, table2)
+
+        logger.info(
+            ". " * level + f"Diffing segment {segment_index}/{segment_count}, "
+            f"key-range: {table1.min_key}..{table2.max_key}, "
+            f"size <= {max_rows}"
+        )
+
+        # Check all stop conditions
+        if not self._check_continuation_conditions(table1, info_tree, level):
+            return
+
+        # IN-MEMORY MODE: Skip checksum if flag is set or segment is small enough
+        if self._should_skip_checksum_and_download(max_rows):
+            if self.in_memory_diff:
+                logger.info(". " * level + f"[IN-MEMORY MODE] Downloading segment directly " f"(size: {max_rows} rows)")
+
+            return self._download_and_diff_locally(table1, table2, info_tree, level)
+
+        # STANDARD MODE: Perform checksum-based comparison
+        return self._checksum_and_bisect_if_needed(
+            ti, table1, table2, info_tree, level, max_rows, segment_index, segment_count
+        )
+
+    def _check_continuation_conditions(self, table1: TableSegment, info_tree: InfoTree, level: int) -> bool:
+        """Check if we should continue diffing (respects limits)."""
+
+        # Check per-column diff limit
+        elapsed = time.monotonic() - self.start_time
+        if (
+            len(self._diff_tracker.get_stopped_columns()) > 0
+            and not self.stats.get("rows_downloaded", 0) >= self.egress_limit
+            and not elapsed > self.timeout_limit * 60
+        ):
+            self.update_comparison_tracker(
+                reason_type="per_column_diff_limit",
+                segment=f"{table1.min_key}..{table1.max_key}",
+            )
+
+        if not self._diff_tracker.has_active_targets(len(table1.relevant_columns)):
+            logger.info(
+                "Diffing stopped because columns with potential differences "
+                "have reached their configured diff limits."
+            )
+            info_tree.info.is_diff = False
+            self.update_comparison_tracker(
+                reason_type="per_column_diff_limit",
+                segment=f"{table1.min_key}..{table1.max_key}",
+            )
+            return False
+
+        # Check egress limit
+        if self.stats.get("rows_downloaded", 0) >= self.egress_limit:
+            info_tree.info.is_diff = False
+            logger.info(
+                ". " * level + f"Row download limit reached "
+                f"{self.stats.get('rows_downloaded')}, stopping bisection for "
+                f"segment {table1.min_key}..{table1.max_key}"
+            )
+            self.update_comparison_tracker(
+                reason_type="egress_limit",
+                segment=f"{table1.min_key}..{table1.max_key}",
+            )
+            return False
+
+        # Check timeout
+        elapsed = time.monotonic() - self.start_time
+        if elapsed > self.timeout_limit * 60:
+            info_tree.info.is_diff = False
+            logger.info(
+                ". " * level + f"Timeout limit reached ({self.timeout_limit} min); "
+                f"stopping bisection for segment {table1.min_key}..{table1.max_key}"
+            )
+            self.update_comparison_tracker(
+                reason_type="timeout",
+                segment=f"{table1.min_key}..{table1.max_key}",
+            )
+            return False
+
+        return True
+
+    def _download_and_diff_locally(
+        self,
+        table1: TableSegment,
+        table2: TableSegment,
+        info_tree: InfoTree,
+        level: int,
+    ) -> List:
+        """Download segment rows and perform in-memory diff."""
+
+        mode_label = "[IN-MEMORY]" if self.in_memory_diff else "[STANDARD]"
+        logger.info(
+            ". " * level + f"{mode_label} Downloading rows for comparison: " f"{table1.min_key}..{table1.max_key}"
+        )
+
+        # Download rows from both tables
+        rows1, rows2 = self._threaded_call("get_values", [table1, table2])
+
+        # Update statistics
+        downloaded = max(len(rows1), len(rows2))
+        self.stats["rows_downloaded"] = self.stats.get("rows_downloaded", 0) + downloaded
+
+        logger.info(
+            ". " * level + f"{mode_label} Downloaded {len(rows1)} and {len(rows2)} rows. "
+            f"Total downloaded: {self.stats['rows_downloaded']}"
+        )
+
+        # Perform in-memory diff
+        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,
+            )
+        )
+
+        # Update info tree
+        info_tree.info.set_diff(diff)
+        info_tree.info.rowcounts = {1: len(rows1), 2: len(rows2)}
+
+        logger.info(". " * level + f"{mode_label} Found {len(diff)} different rows in this segment")
+
+        return diff
+
+    def _checksum_and_bisect_if_needed(
+        self,
+        ti,
+        table1: TableSegment,
+        table2: TableSegment,
+        info_tree: InfoTree,
+        level: int,
+        max_rows: int,
+        segment_index: Optional[int],
+        segment_count: Optional[int],
+    ):
+        """Perform checksum comparison and bisect if differences found (standard mode)."""
+
+        logger.info(". " * level + "[CHECKSUM MODE] Comparing segment checksums")
+
+        # Get active columns for checksum (excluding stopped columns)
+        active_cols1, active_cols2 = self._get_checksum_columns(table1, table2)
+
+        # Create segments with updated columns for checksum
+        checksum_table1 = self._create_segment_with_updated_columns(table1, active_cols1)
+        checksum_table2 = self._create_segment_with_updated_columns(table2, active_cols2)
+
+        # Perform checksum
+        (count1, checksum1), (count2, checksum2) = self._threaded_call(
+            "count_and_checksum", [checksum_table1, checksum_table2]
+        )
+
+        assert not info_tree.info.rowcounts
+        info_tree.info.rowcounts = {1: count1, 2: count2}
+
+        # Handle empty segments
+        if count1 == 0 and count2 == 0:
+            logger.debug(
+                "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,
+            )
+            assert checksum1 is None and checksum2 is None
+            info_tree.info.is_diff = False
+            return
+
+        # Compare checksums
+        if checksum1 == checksum2:
+            logger.info(". " * level + "[CHECKSUM MODE] Checksums match - no differences")
+            info_tree.info.is_diff = False
+            return
+
+        logger.info(". " * level + "[CHECKSUM MODE] Checksums differ - bisecting segment")
+        info_tree.info.is_diff = True
+
+        # Bisect and continue
+        return self._bisect_and_diff_segments(ti, table1, table2, info_tree, level=level, max_rows=max(count1, count2))
+
+    def _bisect_and_diff_segments(
+        self,
+        ti,
+        table1: TableSegment,
+        table2: TableSegment,
+        info_tree: InfoTree,
+        level=0,
+        max_rows=None,
+    ):
+        """
+        Enhanced bisection with in-memory mode support.
+        """
+        # Check recursion limit
+        if level > 15:
+            logger.warning(
+                ". " * level + f"Maximum recursion level ({level}) reached; "
+                f"downloading segment {table1.min_key}..{table1.max_key}"
+            )
+            return self._download_and_diff_locally(table1, table2, info_tree, level)
+
+        assert table1.is_bounded and table2.is_bounded
+
+        # Initialize diff tracker
+        self._initialize_diff_tracker(table1, table2)
+
+        # Check continuation conditions
+        if not self._check_continuation_conditions(table1, info_tree, level):
+            return
+
+        # Calculate max space size
+        max_space_size = max(table1.approximate_size(self.t1_row_count), table2.approximate_size(self.t2_row_count))
+
+        if max_rows is None:
+            max_rows = max_space_size
+
+        info_tree.info.max_rows = max_rows
+
+        # Check if we should download directly
+        should_download = (
+            self.bisection_disabled or max_rows < self.bisection_threshold or max_space_size < self.bisection_factor * 2
+        )
+
+        # In-memory mode: also download if at target segment size
+        if self.in_memory_diff and max_rows <= self.memory_segment_size:
+            should_download = True
+
+        if should_download:
+            return self._download_and_diff_locally(table1, table2, info_tree, level)
+
+        # Otherwise, continue with standard bisection
+        return super()._bisect_and_diff_segments(ti, table1, table2, info_tree, level, max_rows)

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.7"
+__version__ = "1.5.9"

dcs_sdk/sdk/config/config_loader.py

@@ -81,6 +81,7 @@ class DiffAdvancedConfig(BaseModel):
     egress_limit: int = 5_00_000
     per_column_diff_limit: int = 100
     timeout_limit: int = 60 * 5  # minutes
+    in_memory_diff: bool = False  # Whether to perform diff in memory (may use more RAM)
 
 
 class Comparison(BaseModel):
@@ -424,6 +425,7 @@ class DataDiffConfig:
                 egress_limit=advanced_diff_config.get("egress_limit", 5_00_000),
                 per_column_diff_limit=advanced_diff_config.get("per_column_diff_limit", 100),
                 timeout_limit=advanced_diff_config.get("timeout_limit", 60 * 5),
+                in_memory_diff=advanced_diff_config.get("in_memory_diff", False),
             )
             new_comparison = {
                 "comparison_name": comparison_name,

dcs_sdk/sdk/data_diff/data_differ.py

@@ -399,6 +399,8 @@ class DBTableDiffer:
                 table_1_sample_data = self.table1.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)
+                if self.config.advanced_configuration.in_memory_diff:
+                    self.config.advanced_configuration.egress_limit = min(max_row_count, 50_00_000)
                 self.diff_iter = diff_tables(
                     self.table1,
                     self.table2,
@@ -410,6 +412,7 @@ class DBTableDiffer:
                     per_column_diff_limit=self.config.advanced_configuration.per_column_diff_limit,
                     egress_limit=self.config.advanced_configuration.egress_limit,
                     timeout_limit=self.config.advanced_configuration.timeout_limit,
+                    in_memory_diff=self.config.advanced_configuration.in_memory_diff,
                 )
 
             columns_mappings = [

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcs-sdk
-Version: 1.5.7
+Version: 1.5.9
 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.7
+  DCS SDK v1.5.9
 </h1>
 
 > SDK for DataChecks

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

@@ -1,4 +1,4 @@
-data_diff/__init__.py,sha256=TGNvifF-dIbitACA6PS4sORtHEcTUukcrZz2NEIsL9U,10336
+data_diff/__init__.py,sha256=QrrQt6GxG5gzVRlvFjJmfOzhR14fqKLrQs186KBWryY,10413
 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
@@ -14,17 +14,17 @@ data_diff/databases/duckdb.py,sha256=7r1PwPUpp61QN_ZorsBTyn6NTB1LcBKQofYl_wovm1U
 data_diff/databases/mssql.py,sha256=mA6myRemhad-q9yyRSt6VRj6na_i4joD0HI7IgGt8zQ,11987
 data_diff/databases/mysql.py,sha256=LTuLTkxac16y7w5_q1nEuKy6ZefqQUBQqV_tdnzjNT4,6148
 data_diff/databases/oracle.py,sha256=GIczARg96lOlmgUpHd-hOFl8etFJmxWMy-KkA2COG74,8031
-data_diff/databases/postgresql.py,sha256=QrvYDsMSECQiPfsl85UQxY9ivxTRXnEwjAfRjd-Qnk4,10748
+data_diff/databases/postgresql.py,sha256=E8VtuHDGlULegb42KXzls0agEhEAJ2O9h-Mwr5ViHZU,10938
 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=ap_FWJk39ZM68y9c5B-luxlo-IgOXCi862HBh7MZutU,31248
+data_diff/databases/sybase.py,sha256=DIai691f1PrPORWb9EjdoQWFMLEKtXFoHQ9vJvEHnPU,31312
 data_diff/databases/trino.py,sha256=VIN3gMJvT4oSYuXCJ1QnngVL2gjjEYMFw87QTHgjs8c,2328
 data_diff/databases/vertica.py,sha256=2dSDZp6qOEvUVPldI5Tgn7Sm3dCpC3vNXJL3qb3FDvQ,5529
 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=EBhEAZz-2a-qNs3OlFArInAV1KszBdZPotZmX7Z_lwo,31315
+data_diff/hashdiff_tables.py,sha256=oElu0rFAFaRGVZpiIl546yUVYQm02J6HFjVkpuHHFIQ,43134
 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
@@ -43,14 +43,14 @@ 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=xvnvu6wSe7otkNeAkcLgPV0ELqT7G6RGaYllHIVN2Ts,633
+dcs_sdk/__version__.py,sha256=Syic9kjTewAbYYhDKKRgMcp-NZeosWsa7uGfE_JlLHs,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
 dcs_sdk/sdk/config/__init__.py,sha256=RkfhRKLXEForLCs4rZkTf0qc_b0TokSggSAcKI4yfZg,610
-dcs_sdk/sdk/config/config_loader.py,sha256=Sg0gvleGrOcDaX41amgw6Uj6c_s4Zel6gQalIp9CltI,21416
+dcs_sdk/sdk/config/config_loader.py,sha256=hVdGidcm6ibqJ0yt7fZcL_0kFcorBfM7vHGhUiBH9Ww,21587
 dcs_sdk/sdk/data_diff/__init__.py,sha256=RkfhRKLXEForLCs4rZkTf0qc_b0TokSggSAcKI4yfZg,610
-dcs_sdk/sdk/data_diff/data_differ.py,sha256=RH9C9OthahU8eeJzmUgQe24UZGGuBu7X2a_DrhTCa-U,35590
+dcs_sdk/sdk/data_diff/data_differ.py,sha256=d8hwXs0zG5AuaRjsNlpFShpTxA1_YPgH2aCRsJQfDMU,35846
 dcs_sdk/sdk/rules/__init__.py,sha256=_BkKcE_jfdDQI_ECdOamJaefMKEXrKpYjPpnBQXl_Xs,657
 dcs_sdk/sdk/rules/rules_mappping.py,sha256=fxakVkf7B2cVkYSO946LTim_HmMsl6lBDBqZjTTsSPI,1292
 dcs_sdk/sdk/rules/rules_repository.py,sha256=x0Rli-wdnHAmXm5526go_qC3P-eFRt-4L7fs4hNqC-g,7564
@@ -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.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.9.dist-info/METADATA,sha256=sKgAYCQgujtdlWQZNWJnlY2XSKvti7YdAyrOAIOaH6o,6275
+dcs_sdk-1.5.9.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+dcs_sdk-1.5.9.dist-info/entry_points.txt,sha256=zQtrZL7YuaKtt6WPwihCTV1BRXnqBkaY6zUGdYJbBSg,49
+dcs_sdk-1.5.9.dist-info/RECORD,,