datamasque-python 1.1.0__tar.gz → 1.1.2__tar.gz

{datamasque_python-1.1.0 → datamasque_python-1.1.2}/HISTORY.rst

@@ -2,6 +2,21 @@
 History
 =======
 
+1.1.2 (2026-06-26)
+------------------
+
+* Completed wiring of the ``finished_with_warnings`` status for ``AsyncRulesetGenerationTaskStatus``.
+* Added the ``cancelled`` status to ``AsyncRulesetGenerationTaskStatus``.
+
+1.1.1 (2026-06-25)
+------------------
+
+* Made ``DiscoveryMatch.label`` optional (it is absent for non-sensitive/ignore matches).
+* Added the ``finished_with_warnings`` status to ``AsyncRulesetGenerationTaskStatus``.
+* ``get_db_discovery_result_report`` may now return ``bytes`` (a zip)
+  when the server splits a large DB-discovery report,
+  and ruleset generation from CSV now detects and forwards zip uploads.
+
 1.1.0 (2026-06-24)
 ------------------
 

{datamasque_python-1.1.0 → datamasque_python-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamasque-python
-Version: 1.1.0
+Version: 1.1.2
 Summary: Official Python client for the DataMasque data-masking API.
 Project-URL: Homepage, https://datamasque.com/
 Project-URL: Documentation, https://datamasque-python.readthedocs.io/

{datamasque_python-1.1.0 → datamasque_python-1.1.2}/datamasque/client/discovery.py

@@ -98,6 +98,10 @@ class DiscoveryClient(BaseClient):
         - A text file handle (e.g. `open(path)`)
         - A binary file handle (e.g. `open(path, 'rb')`)
 
+        If the content is a zip (for example a split report from `get_db_discovery_result_report()`),
+        it is detected by its magic bytes and uploaded as a zip;
+        otherwise it is uploaded as CSV.
+
         Generation runs asynchronously on the server.
         Poll `get_async_ruleset_generation_task_status` until it returns
         `AsyncRulesetGenerationTaskStatus.finished`,
@@ -114,14 +118,22 @@ class DiscoveryClient(BaseClient):
         else:
             content = csv_content
 
+        is_zip = False
+        if content.seekable():
+            is_zip = content.read(4) == b"PK\x03\x04"
+            content.seek(0)
+        filename = "ruleset.zip" if is_zip else "ruleset.csv"
+        content_type = "application/zip" if is_zip else "text/csv"
+
         files = [
             UploadFile(
                 field_name="csv_or_zip_file",
-                filename="ruleset.csv",
+                filename=filename,
                 content=content,
-                content_type="text/csv",
+                content_type=content_type,
             ),
         ]
+
         self.make_request(
             method="POST",
             path=f"/api/async-generate-ruleset/{connection_id}/from-csv/",
@@ -154,7 +166,7 @@ class DiscoveryClient(BaseClient):
             returns a list containing one ruleset
 
         Raises `AsyncRulesetGenerationInProgressError` if the task hasn't finished yet,
-        and `DataMasqueException` if it failed.
+        and `DataMasqueException` if it failed or was cancelled.
 
         Note that the ruleset(s) have autogenerated names, which you may want to customize before uploading.
         """
@@ -164,7 +176,11 @@ class DiscoveryClient(BaseClient):
             logger.error("Ruleset generation failed for connection: %s", connection_id)
             raise DataMasqueException(f"Ruleset generation failed for connection: {connection_id}")
 
-        if status is not AsyncRulesetGenerationTaskStatus.finished:
+        if status is AsyncRulesetGenerationTaskStatus.cancelled:
+            logger.error("Ruleset generation was cancelled for connection: %s", connection_id)
+            raise DataMasqueException(f"Ruleset generation was cancelled for connection: {connection_id}")
+
+        if not status.is_finished:
             logger.error(
                 "Ruleset generation is still in progress for connection: %s. Status: `%s`",
                 connection_id,

{datamasque_python-1.1.0 → datamasque_python-1.1.2}/datamasque/client/models/discovery.py

@@ -252,7 +252,7 @@ class DiscoveryMatch(BaseModel):
 
     model_config = ConfigDict(extra="allow")
 
-    label: str
+    label: Optional[str] = None
     categories: list[str]
     flagged_by: str
     description: str
@@ -343,8 +343,8 @@ class FileDiscoveryMatch(BaseModel):
 
     flagged_by: str
     description: str
-    label: Optional[str] = None  # Omitted for non-sensitive and ignored matches.
-    categories: Optional[list[str]] = None  # Omitted for ignored matches.
+    label: Optional[str] = None  # Omitted for non-sensitive matches.
+    categories: Optional[list[str]] = None
     hit_ratio: Optional[int] = None  # None for metadata matches, percentage 0-100 for IDD matches.
 
 

{datamasque_python-1.1.0 → datamasque_python-1.1.2}/datamasque/client/models/status.py

@@ -60,18 +60,32 @@ class AsyncRulesetGenerationTaskStatus(enum.Enum):
     """List of statuses of async ruleset generation tasks."""
 
     finished = "finished"
+    finished_with_warnings = "finished_with_warnings"
     failed = "failed"
     running = "running"
     queued = "queued"
+    cancelled = "cancelled"
 
     @classmethod
     def get_final_states(cls) -> set["AsyncRulesetGenerationTaskStatus"]:
         """Returns the list of final statuses, i.e. the ruleset generation has completed, successfully or otherwise."""
 
-        return {cls.finished, cls.failed}
+        return {cls.finished, cls.finished_with_warnings, cls.failed, cls.cancelled}
+
+    @classmethod
+    def get_finished_states(cls) -> set["AsyncRulesetGenerationTaskStatus"]:
+        """Returns the list of statuses that indicate the ruleset generation completed successfully."""
+
+        return {cls.finished, cls.finished_with_warnings}
 
     @property
     def is_in_final_state(self) -> bool:
         """Returns True if this status is a final status."""
 
         return self in self.get_final_states()
+
+    @property
+    def is_finished(self) -> bool:
+        """Returns True if this status is a finished status."""
+
+        return self in self.get_finished_states()

{datamasque_python-1.1.0 → datamasque_python-1.1.2}/datamasque/client/runs.py

@@ -1,5 +1,6 @@
 import logging
 import re
+from typing import Union
 
 from datamasque.client.base import BaseClient
 from datamasque.client.exceptions import (
@@ -43,9 +44,12 @@ class RunClient(BaseClient):
         response = self.make_request("GET", f"api/runs/{run_id}/run-report/")
         return response.text
 
-    def get_db_discovery_result_report(self, run_id: RunId, include_selection_column: bool = True) -> str:
+    def get_db_discovery_result_report(self, run_id: RunId, include_selection_column: bool = True) -> Union[str, bytes]:
         """
-        Returns the database-discovery result report for the specified run as CSV.
+        Returns the database-discovery result report for the specified run.
+
+        Returns CSV text (`str`),
+        or a zip of numbered CSV parts as `bytes` when the server splits a large report.
 
         When `include_selection_column` is true (the default),
         the CSV includes a `selected` column suitable for feeding back into ruleset generation.
@@ -54,6 +58,9 @@ class RunClient(BaseClient):
         url = f"api/runs/{run_id}/db-discovery-results/report/"
         params = None if include_selection_column else {"include_selection_column": "false"}
         response = self.make_request("GET", url, params=params)
+
+        if response.headers.get("Content-Type", "").startswith("application/zip"):
+            return response.content
         return response.text
 
     def get_unfinished_runs(self) -> dict[str, UnfinishedRun]:

{datamasque_python-1.1.0 → datamasque_python-1.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "datamasque-python"
-version = "1.1.0"
+version = "1.1.2"
 description = "Official Python client for the DataMasque data-masking API."
 authors = [
     { name = "DataMasque Ltd" },

{datamasque_python-1.1.0 → datamasque_python-1.1.2}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.1.0
+current_version = 1.1.2
 commit = True
 tag = True
 

{datamasque_python-1.1.0 → datamasque_python-1.1.2}/tests/test_discovery.py

@@ -108,6 +108,17 @@ def test_get_db_discovery_result_report(client):
         assert result == "db discovery report without selection column"
 
 
+def test_get_db_discovery_result_report_returns_zip_bytes_when_split(client):
+    run_id = RunId(1)
+    zip_bytes = b"PK\x03\x04 split report zip bytes"
+    with requests_mock.Mocker() as m:
+        url = f"http://test-server/api/runs/{run_id}/db-discovery-results/report/"
+        m.get(url, content=zip_bytes, headers={"Content-Type": "application/zip"}, status_code=200)
+        result = client.get_db_discovery_result_report(run_id)
+        assert result == zip_bytes
+        assert isinstance(result, bytes)
+
+
 def test_poll_async_ruleset_generation(client):
     connection_id = ConnectionId("1")
     with requests_mock.Mocker() as m:
@@ -193,6 +204,47 @@ def test_get_generated_rulesets_success(client):
         assert rulesets[1].yaml == yaml_content_2.decode("utf-8")
 
 
+def test_get_generated_rulesets_finished_with_warnings_success(client):
+    """A task that finishes with warnings is still successful: its rulesets are returned, not treated as in-progress."""
+    connection_id = ConnectionId("1")
+    yaml_content = b"""
+    version: "1.0"
+    tasks:
+    - type: mask_table
+      table: table1
+      key: id
+      rules:
+      - column: col1
+        masks:
+        - type: do_nothing
+    """
+
+    with requests_mock.Mocker() as m:
+        m.get(
+            f"http://test-server/api/async-generate-ruleset/{connection_id}/",
+            json={"status": "finished_with_warnings"},
+            status_code=200,
+        )
+
+        zip_buffer = BytesIO()
+        with zipfile.ZipFile(zip_buffer, "w") as zip_file:
+            zip_file.writestr("ruleset1.yml", yaml_content.decode("utf-8"))
+        zip_buffer.seek(0)
+
+        m.get(
+            f"http://test-server/api/async-generate-ruleset/{connection_id}/download-rulesets/",
+            content=zip_buffer.getvalue(),
+            headers={"Content-Disposition": 'attachment; filename="rulesets.zip"'},
+            status_code=200,
+        )
+
+        rulesets = client.get_generated_rulesets(connection_id)
+
+        assert len(rulesets) == 1
+        assert rulesets[0].name == "ruleset1"
+        assert rulesets[0].yaml == yaml_content.decode("utf-8")
+
+
 def test_get_generated_rulesets_empty_archive_raises(client):
     """A finished task whose download archive contains no ruleset files raises a clear error."""
     connection_id = ConnectionId("1")
@@ -279,6 +331,21 @@ def test_get_generated_rulesets_failed(client):
             client.get_generated_rulesets(connection_id)
 
 
+def test_get_generated_rulesets_cancelled(client):
+    """A cancelled task is terminal, so it raises a non-retryable DataMasqueException, not the in-progress error."""
+    connection_id = ConnectionId("1")
+
+    with requests_mock.Mocker() as m:
+        m.get(
+            f"http://test-server/api/async-generate-ruleset/{connection_id}/",
+            json={"status": "cancelled"},
+            status_code=200,
+        )
+
+        with pytest.raises(DataMasqueException, match="Ruleset generation was cancelled for connection"):
+            client.get_generated_rulesets(connection_id)
+
+
 def test_get_generated_rulesets_in_progress(client):
     connection_id = ConnectionId("1")
 
@@ -463,6 +530,31 @@ def test_start_async_ruleset_generation_from_csv_success(client, csv_content):
         assert form_data["csv_or_zip_file"]["content"] == b"schema,table,column,selected\npublic,users,email,true"
 
 
+@pytest.mark.parametrize(
+    "zip_content",
+    [
+        b"PK\x03\x04 zipped discovery report",
+        BytesIO(b"PK\x03\x04 zipped discovery report"),
+    ],
+    ids=["bytes", "BytesIO"],
+)
+def test_start_async_ruleset_generation_from_csv_uploads_zip_as_zip(client, zip_content):
+    """A split report is uploaded with a .zip filename and zip content-type, whether passed as bytes or a binary stream."""
+    connection_id = ConnectionId("1")
+
+    with requests_mock.Mocker() as m:
+        m.post(
+            f"http://test-server/api/async-generate-ruleset/{connection_id}/from-csv/",
+            status_code=201,
+        )
+        client.start_async_ruleset_generation_from_csv(connection_id, zip_content)
+
+        form_data = parse_multipart_form(m.last_request)
+        assert form_data["csv_or_zip_file"]["filename"] == "ruleset.zip"
+        assert form_data["csv_or_zip_file"]["content_type"] == "application/zip"
+        assert form_data["csv_or_zip_file"]["content"] == b"PK\x03\x04 zipped discovery report"
+
+
 def test_start_async_ruleset_generation_from_csv_with_target_size(client):
     """Test async ruleset generation from CSV with target_size_bytes parameter."""
     connection_id = ConnectionId("1")

{datamasque_python-1.1.0 → datamasque_python-1.1.2}/uv.lock

@@ -428,7 +428,7 @@ toml = [
 
 [[package]]
 name = "datamasque-python"
-version = "1.1.0"
+version = "1.1.2"
 source = { editable = "." }
 dependencies = [
     { name = "pydantic" },