datamasque-python 1.0.5__tar.gz → 1.1.1__tar.gz

datamasque_python-1.1.1/.github/workflows/release-testpypi.yml

@@ -0,0 +1,99 @@
+name: Release (TestPyPI)
+
+on:
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: 'Branch, tag, or commit SHA to build from'
+        required: true
+        default: 'main'
+      dev_version:
+        description: >-
+          Optional PEP 440 pre/dev version override (e.g. 1.1.0.dev1, 1.1.0a2, 1.1.0rc1).
+          Leave blank to use the version in pyproject.toml as-is.
+        required: false
+        default: ''
+
+jobs:
+  build:
+    name: Build sdist and wheel
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref }}
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Apply dev_version override
+        if: inputs.dev_version != ''
+        # Pass the input through the environment, never interpolated into the script body:
+        # `${{ }}` is expanded into the script text before the shell runs, so splicing it inline
+        # would let a crafted dev_version inject shell commands before the validation below could reject it.
+        env:
+          DEV_VERSION: ${{ inputs.dev_version }}
+        run: |
+          # Reject anything that isn't a pre-release / dev version — final releases must go through release.yml.
+          if ! printf '%s' "${DEV_VERSION}" | grep -Eq '^[0-9]+\.[0-9]+\.[0-9]+(a|b|rc|\.dev)[0-9]+$'; then
+            echo "::error::dev_version '${DEV_VERSION}' is not a PEP 440 pre/dev version (must end in aN, bN, rcN, or .devN)"
+            exit 1
+          fi
+          uv run python -c "
+          import os, re, pathlib
+          version = os.environ['DEV_VERSION']
+          path = pathlib.Path('pyproject.toml')
+          text = path.read_text()
+          new = re.sub(r'^version\s*=\s*\".*\"', f'version = \"{version}\"', text, count=1, flags=re.M)
+          if new == text:
+              raise SystemExit('Failed to locate version line in pyproject.toml')
+          path.write_text(new)
+          "
+
+      - name: Show package version
+        env:
+          REF: ${{ inputs.ref }}
+        run: |
+          VERSION="$(uv run python -c 'import tomllib; print(tomllib.loads(open("pyproject.toml","rb").read().decode())["project"]["version"])')"
+          echo "Publishing version: ${VERSION} (from ref ${REF})"
+          echo "::notice title=TestPyPI version::${VERSION} from ${REF}"
+
+      - name: Build
+        run: uv build
+
+      - name: Validate distributions
+        run: uvx twine check dist/*
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-testpypi
+          path: dist/
+          retention-days: 7
+
+  publish:
+    name: Publish to TestPyPI
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/datamasque-python
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - name: Download distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: dist-testpypi
+          path: dist/
+
+      - name: Publish to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/

{datamasque_python-1.0.5 → datamasque_python-1.1.1}/HISTORY.rst

@@ -2,6 +2,38 @@
 History
 =======
 
+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)
+------------------
+
+* Added discovery configuration models and management APIs.
+* Added schema-discovery and file-data-discovery APIs that take a saved discovery configuration
+  (``start_schema_discovery_run_from_config`` / ``start_file_data_discovery_run_from_config``).
+  Adoption is recommended; the older APIs that take individual options will be deprecated in a future release.
+* Corrected the file-data-discovery ``include``/``skip`` filter syntax and added ``ignore_rules`` support.
+* Added ``InvalidDiscoveryConfigError`` and ``DiscoveryConfigNotFoundError``,
+  raised when a discovery run can't start due to an unusable or missing discovery config.
+* Added ``get_discovery_run_config_snapshot_yaml`` to retrieve the discovery-config YAML
+  that was effective at the start of a given discovery run.
+* Added ``is_user_subscribed`` to ``MaskingRunRequest`` to subscribe the requesting user to a run's email notifications.
+* Added ``auto_pull`` / ``auto_pull_branch`` to ``MaskingRunOptions``
+  to refresh the run's ruleset from git before starting.
+* Added ``validation_error`` (and ``validation_error_type`` for rulesets) to ``Ruleset`` and ``RulesetLibrary``.
+* Exposed git provenance on ``Ruleset`` and ``RulesetLibrary`` as a nested ``git`` field (``GitSnapshot``).
+* Read-only fields (``id``, ``is_valid``, ``validation_error``, etc.)
+  are no longer echoed back in ``Ruleset`` / ``RulesetLibrary`` create/update request bodies.
+* Fixed ``SslZipFile`` uploads to send the required ``database_type=mysql`` form field.
+* **Breaking:** ``delete_ruleset_by_name_if_exists`` now requires a ``ruleset_type`` argument,
+  since ruleset names are unique only per type.
+
 1.0.5 (2026-06-18)
 ------------------
 

{datamasque_python-1.0.5 → datamasque_python-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamasque-python
-Version: 1.0.5
+Version: 1.1.1
 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.0.5 → datamasque_python-1.1.1}/datamasque/client/__init__.py

@@ -17,8 +17,10 @@ from datamasque.client.exceptions import (
     DataMasqueNotReadyError,
     DataMasqueTransportError,
     DataMasqueUserError,
+    DiscoveryConfigNotFoundError,
     FailedToStartError,
     IfmAuthError,
+    InvalidDiscoveryConfigError,
     InvalidLibraryError,
     InvalidRulesetError,
     RunNotCancellableError,
@@ -54,10 +56,15 @@ from datamasque.client.models.data_selection import (
 from datamasque.client.models.discovery import (
     ConstraintColumns,
     DiscoveryMatch,
+    FileDataDiscoveryFromConfigRequest,
+    FileDataDiscoveryOptions,
+    FileDataDiscoveryRequest,
     FileDiscoveryFile,
     FileDiscoveryLocatorResult,
     FileDiscoveryMatch,
     FileDiscoveryResult,
+    FileFilter,
+    FileFilterMatchAgainst,
     FileRulesetGenerationRequest,
     ForeignKeyRef,
     InDataDiscoveryConfig,
@@ -65,11 +72,13 @@ from datamasque.client.models.discovery import (
     ReferencingForeignKey,
     RulesetGenerationRequest,
     SchemaDiscoveryColumn,
+    SchemaDiscoveryFromConfigRequest,
     SchemaDiscoveryPage,
     SchemaDiscoveryRequest,
     SchemaDiscoveryResult,
     TableConstraints,
 )
+from datamasque.client.models.discovery_config import DiscoveryConfig, DiscoveryConfigId, DiscoveryConfigType
 from datamasque.client.models.dm_instance import DataMasqueInstanceConfig
 from datamasque.client.models.files import (
     DataMasqueFile,
@@ -79,6 +88,7 @@ from datamasque.client.models.files import (
     SnowflakeKeyFile,
     SslZipFile,
 )
+from datamasque.client.models.git import GitSnapshot
 from datamasque.client.models.ifm import (
     DataMasqueIfmInstanceConfig,
     IfmLog,
@@ -104,7 +114,12 @@ from datamasque.client.models.runs import (
     RunInfo,
     UnfinishedRun,
 )
-from datamasque.client.models.status import AsyncRulesetGenerationTaskStatus, MaskingRunStatus, ValidationStatus
+from datamasque.client.models.status import (
+    AsyncRulesetGenerationTaskStatus,
+    MaskingRunStatus,
+    ValidationErrorType,
+    ValidationStatus,
+)
 from datamasque.client.models.user import User, UserId, UserRole
 
 __version__ = version("datamasque-python")
@@ -130,18 +145,28 @@ __all__ = [
     "DatabaseConnectionConfig",
     "DatabaseType",
     "DatabricksConnectionConfig",
+    "DiscoveryConfig",
+    "DiscoveryConfigId",
+    "DiscoveryConfigNotFoundError",
+    "DiscoveryConfigType",
     "DiscoveryMatch",
     "DynamoConnectionConfig",
     "FailedToStartError",
     "FileConnectionConfig",
+    "FileDataDiscoveryFromConfigRequest",
+    "FileDataDiscoveryOptions",
+    "FileDataDiscoveryRequest",
     "FileDiscoveryFile",
     "FileDiscoveryLocatorResult",
     "FileDiscoveryMatch",
     "FileDiscoveryResult",
+    "FileFilter",
+    "FileFilterMatchAgainst",
     "FileId",
     "FileOrContent",
     "FileRulesetGenerationRequest",
     "ForeignKeyRef",
+    "GitSnapshot",
     "HashColumnsTableConfig",
     "IfmAuthError",
     "IfmLog",
@@ -151,6 +176,7 @@ __all__ = [
     "IfmTokenInfo",
     "InDataDiscoveryConfig",
     "InDataDiscoveryRule",
+    "InvalidDiscoveryConfigError",
     "InvalidLibraryError",
     "InvalidRulesetError",
     "JsonPath",
@@ -182,6 +208,7 @@ __all__ = [
     "RunNotCancellableError",
     "S3ConnectionConfig",
     "SchemaDiscoveryColumn",
+    "SchemaDiscoveryFromConfigRequest",
     "SchemaDiscoveryPage",
     "SchemaDiscoveryRequest",
     "SchemaDiscoveryResult",
@@ -202,5 +229,6 @@ __all__ = [
     "UserId",
     "UserRole",
     "UserSelection",
+    "ValidationErrorType",
     "ValidationStatus",
 ]

{datamasque_python-1.0.5 → datamasque_python-1.1.1}/datamasque/client/discovery.py

@@ -4,11 +4,15 @@ from io import BufferedIOBase, BytesIO, TextIOBase
 from pathlib import Path
 from typing import Iterator, Optional, Union
 
+from requests import Response
+
 from datamasque.client.base import BaseClient, UploadFile
 from datamasque.client.exceptions import (
     AsyncRulesetGenerationInProgressError,
     DataMasqueException,
+    DiscoveryConfigNotFoundError,
     FailedToStartError,
+    InvalidDiscoveryConfigError,
 )
 from datamasque.client.models.connection import ConnectionId
 from datamasque.client.models.data_selection import (
@@ -17,9 +21,12 @@ from datamasque.client.models.data_selection import (
     SelectedFileData,
 )
 from datamasque.client.models.discovery import (
+    FileDataDiscoveryFromConfigRequest,
+    FileDataDiscoveryRequest,
     FileDiscoveryResult,
     FileRulesetGenerationRequest,
     RulesetGenerationRequest,
+    SchemaDiscoveryFromConfigRequest,
     SchemaDiscoveryPage,
     SchemaDiscoveryRequest,
     SchemaDiscoveryResult,
@@ -91,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`,
@@ -107,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/",
@@ -185,6 +204,13 @@ class DiscoveryClient(BaseClient):
                         with zip_file.open(file_info) as file:
                             yaml_content = file.read().decode("utf-8")
                             rulesets.append(Ruleset(name=Path(file_info.filename).stem, yaml=yaml_content))
+
+            if not rulesets:
+                raise DataMasqueException(
+                    f"Ruleset generation for connection {connection_id} reported `finished` "
+                    f"but the downloaded archive contained no rulesets."
+                )
+
             return rulesets
 
         generated = response.json().get("generated_ruleset")
@@ -230,6 +256,148 @@ class DiscoveryClient(BaseClient):
             response=response,
         )
 
+    def start_file_data_discovery_run(self, request: FileDataDiscoveryRequest) -> RunId:
+        """
+        Starts a file data discovery run with the given configuration.
+
+        Args:
+            request: A `FileDataDiscoveryRequest` with connection and optional settings.
+
+        Returns:
+            RunId: The ID of the started discovery run
+
+        Raises:
+            FailedToStartError: If run fails to start
+        """
+
+        data = request.model_dump(exclude_none=True, mode="json")
+        response = self.make_request(
+            "POST",
+            "/api/run-file-data-discovery/",
+            data=data,
+            require_status_check=False,
+        )
+        run_data = response.json()
+
+        if response.status_code == 201:
+            logger.info("File data discovery run %s started successfully", run_data["id"])
+            return RunId(run_data["id"])
+
+        logger.error("File data discovery run failed to start: %s", run_data)
+        raise FailedToStartError(
+            f"File data discovery run failed to start "
+            f"(server responded with status {response.status_code}: {response.text}).",
+            response=response,
+        )
+
+    def start_schema_discovery_run_from_config(self, request: SchemaDiscoveryFromConfigRequest) -> RunId:
+        """
+        Starts a schema discovery run from a saved discovery config.
+
+        Args:
+            request: A `SchemaDiscoveryFromConfigRequest` with the `connection` and a required `discovery_config`
+                (a saved config, or `None` for the server's defaults).
+
+        Returns:
+            RunId: The ID of the started discovery run
+
+        Raises:
+            DiscoveryConfigNotFoundError: the referenced discovery config cannot be found
+                (it does not exist or is the wrong type for the run).
+            InvalidDiscoveryConfigError: the config is present but not in a `valid` validation state,
+                or its YAML is rejected when the run starts.
+            FailedToStartError: the run failed to start for any other reason.
+        """
+
+        return self._start_discovery_run_from_config(request, "/api/schema-discovery/v2/", "Schema discovery")
+
+    def start_file_data_discovery_run_from_config(self, request: FileDataDiscoveryFromConfigRequest) -> RunId:
+        """
+        Starts a file data discovery run from a saved discovery config.
+
+        Args:
+            request: A `FileDataDiscoveryFromConfigRequest` with the `connection`,
+                a required `discovery_config` (a saved config, or `None` for the server's defaults),
+                and optional run `options`.
+
+        Returns:
+            RunId: The ID of the started discovery run
+
+        Raises:
+            DiscoveryConfigNotFoundError: the referenced discovery config cannot be found
+                (it does not exist or is the wrong type for the run).
+            InvalidDiscoveryConfigError: the config is present but not in a `valid` validation state,
+                or its YAML is rejected when the run starts.
+            FailedToStartError: the run failed to start for any other reason.
+        """
+
+        return self._start_discovery_run_from_config(request, "/api/run-file-data-discovery/v2/", "File data discovery")
+
+    def _start_discovery_run_from_config(
+        self,
+        request: Union[SchemaDiscoveryFromConfigRequest, FileDataDiscoveryFromConfigRequest],
+        path: str,
+        run_kind: str,
+    ) -> RunId:
+        """Post a saved-config discovery request and return its run id, classifying config errors on failure."""
+
+        data = request.model_dump(exclude_none=True, mode="json")
+        # The server requires `discovery_config` to be present; a null selects its built-in defaults,
+        # so send it explicitly rather than letting `exclude_none` drop a None.
+        data.setdefault("discovery_config", None)
+        response = self.make_request("POST", path, data=data, require_status_check=False)
+        run_data = response.json() if response.content else {}
+
+        if response.status_code == 201:
+            logger.info("%s run %s started successfully", run_kind, run_data["id"])
+            return RunId(run_data["id"])
+
+        logger.error("%s run failed to start: %s", run_kind, run_data)
+        self._maybe_raise_discovery_config_error(run_data, response, run_kind)
+        raise FailedToStartError(
+            f"{run_kind} run failed to start (server responded with status {response.status_code}: {response.text}).",
+            response=response,
+        )
+
+    # Server key for a 400 that means the discovery config itself is unusable:
+    # a missing or wrong-type config, or one not in a `valid` validation state (string messages),
+    # or re-validation of broken saved-config YAML when the run starts
+    # (a `{"message", "line_number", "column_number"}` dict).
+    DISCOVERY_CONFIG_ERROR_FIELD = "discovery_config"
+
+    # The phrase the server uses when the config id cannot be resolved (a missing or wrong-type config).
+    MISSING_DISCOVERY_CONFIG_SIGNATURE = "object does not exist"
+
+    @classmethod
+    def _maybe_raise_discovery_config_error(cls, run_data: object, response: Response, run_kind: str) -> None:
+        """Raise a discovery-config error if the server's 400 body cites the discovery config."""
+        if not isinstance(run_data, dict):
+            return
+
+        if not (errors := run_data.get(cls.DISCOVERY_CONFIG_ERROR_FIELD)):
+            return
+
+        detail = cls._format_discovery_config_error(errors)
+        if cls.MISSING_DISCOVERY_CONFIG_SIGNATURE in detail:
+            raise DiscoveryConfigNotFoundError(
+                f"{run_kind} run failed to start: the referenced discovery config could not be found: {detail}",
+                response=response,
+            )
+
+        raise InvalidDiscoveryConfigError(
+            f"{run_kind} run failed to start due to discovery config error: {detail}",
+            response=response,
+        )
+
+    @staticmethod
+    def _format_discovery_config_error(errors: object) -> str:
+        """Render the first server error, handling both string and `{message, ...}` dict items."""
+        first = errors[0] if isinstance(errors, list) and errors else errors
+        if isinstance(first, dict) and "message" in first:
+            return str(first["message"])
+
+        return str(first)
+
     def iter_schema_discovery_results(self, run_id: RunId) -> Iterator[SchemaDiscoveryResult]:
         """Lazily iterate all schema discovery results for a run via the paginated v2 endpoint."""
 
@@ -284,3 +452,22 @@ class DiscoveryClient(BaseClient):
 
         response = self.make_request("GET", f"api/runs/{run_id}/file-discovery-results/")
         return [FileDiscoveryResult.model_validate(d) for d in response.json()]
+
+    def get_discovery_run_config_snapshot_yaml(self, run_id: RunId, *, timezone: Optional[str] = None) -> str:
+        """
+        Returns the discovery-config YAML that was effective at the start of the given discovery run.
+
+        The YAML is prefixed with a commented provenance header naming the saved config
+        (or the built-in defaults) the run used, and whether it has since been modified or deleted.
+        `timezone`, a `±HH:MM` UTC offset, sets the timezone of the header timestamp; the server defaults to UTC.
+        """
+
+        params = {"timezone": timezone} if timezone is not None else None
+        response = self.make_request("GET", f"/api/discovery/runs/{run_id}/config-snapshot/", params=params)
+        with zipfile.ZipFile(BytesIO(response.content)) as zip_file:
+            names = zip_file.namelist()
+            if not names:
+                raise DataMasqueException(f"Discovery run {run_id} config snapshot archive contained no files.")
+
+            with zip_file.open(names[0]) as snapshot_file:
+                return snapshot_file.read().decode("utf-8")

datamasque_python-1.1.1/datamasque/client/discovery_configs.py

@@ -0,0 +1,158 @@
+import logging
+from typing import Iterator, Optional
+
+from datamasque.client.base import BaseClient
+from datamasque.client.exceptions import DataMasqueApiError, DataMasqueException
+from datamasque.client.models.discovery_config import DiscoveryConfig, DiscoveryConfigId, DiscoveryConfigType
+from datamasque.client.models.pagination import Page
+
+logger = logging.getLogger(__name__)
+
+
+class DiscoveryConfigClient(BaseClient):
+    """Discovery config CRUD API methods. Mixed into `DataMasqueClient`."""
+
+    def iter_discovery_configs(self) -> Iterator[DiscoveryConfig]:
+        """Lazily iterate all discovery configs via the paginated endpoint."""
+
+        return self._iter_paginated("/api/discovery/configs/", model=DiscoveryConfig)
+
+    def list_discovery_configs(self) -> list[DiscoveryConfig]:
+        """
+        Lists all discovery configs.
+
+        Note: the YAML content is not included in the list response for performance.
+        Use `get_discovery_config` to retrieve the full config with its YAML body.
+        """
+
+        return list(self.iter_discovery_configs())
+
+    def get_discovery_config(self, config_id: DiscoveryConfigId) -> DiscoveryConfig:
+        """Retrieves a single discovery config by ID."""
+
+        response = self.make_request("GET", f"/api/discovery/configs/{config_id}/")
+        return DiscoveryConfig.model_validate(response.json())
+
+    def _get_discovery_config_id_by_name(
+        self, name: str, config_type: DiscoveryConfigType
+    ) -> Optional[DiscoveryConfigId]:
+        """Return the id of the config matching name and type via a single list request, or `None`."""
+
+        response = self.make_request(
+            "GET",
+            "/api/discovery/configs/",
+            params={"name_exact": name, "config_type": config_type.value, "limit": 1},
+        )
+        page = Page[DiscoveryConfig].model_validate(response.json())
+        if not page.results:
+            return None
+
+        config_id = page.results[0].id
+        if config_id is None:
+            raise DataMasqueApiError(
+                "Server returned a discovery config list entry without an `id`.",
+                response=response,
+            )
+
+        return config_id
+
+    def get_discovery_config_by_name(self, name: str, config_type: DiscoveryConfigType) -> Optional[DiscoveryConfig]:
+        """
+        Looks for a discovery config matching the given name and type (case-sensitive, exact match).
+
+        Config names are unique per type, so a type is required to identify a single config.
+        Returns it if found, otherwise `None`.
+        """
+
+        config_id = self._get_discovery_config_id_by_name(name, config_type)
+        if config_id is None:
+            return None
+
+        return self.get_discovery_config(config_id)
+
+    def create_discovery_config(self, config: DiscoveryConfig) -> DiscoveryConfig:
+        """
+        Creates a new discovery config on the server.
+
+        Sets the config's server-assigned fields
+        (`id`, `is_valid`, `validation_error`, `created`, `modified`) and returns the config.
+        """
+
+        data = config.model_dump(exclude_none=True, by_alias=True, mode="json")
+        response = self.make_request("POST", "/api/discovery/configs/", data=data)
+        created = DiscoveryConfig.model_validate(response.json())
+        config.id = created.id
+        config.is_valid = created.is_valid
+        config.validation_error = created.validation_error
+        config.created = created.created
+        config.modified = created.modified
+        logger.info('Creation of discovery config "%s" successful', config.name)
+        return config
+
+    def update_discovery_config(self, config: DiscoveryConfig) -> DiscoveryConfig:
+        """
+        Performs a full update of the discovery config.
+
+        The config must have its `id` set
+        (i.e., it must have been previously created or retrieved from the server).
+        """
+
+        if config.id is None:
+            raise ValueError("Cannot update a discovery config that has not been created yet (id is None)")
+
+        data = config.model_dump(exclude_none=True, by_alias=True, mode="json")
+        response = self.make_request("PUT", f"/api/discovery/configs/{config.id}/", data=data)
+        updated = DiscoveryConfig.model_validate(response.json())
+        config.is_valid = updated.is_valid
+        config.validation_error = updated.validation_error
+        config.modified = updated.modified
+        logger.debug('Update of discovery config "%s" successful', config.name)
+        return config
+
+    def create_or_update_discovery_config(self, config: DiscoveryConfig) -> DiscoveryConfig:
+        """
+        Creates the config if it doesn't exist, or updates it if one with the same name already exists.
+
+        Sets the config's `id` property.
+        """
+
+        existing_id = self._get_discovery_config_id_by_name(config.name, config.config_type)
+        if existing_id is not None:
+            config.id = existing_id
+            return self.update_discovery_config(config)
+
+        return self.create_discovery_config(config)
+
+    def delete_discovery_config_by_id_if_exists(self, config_id: DiscoveryConfigId) -> None:
+        """
+        Deletes the discovery config with the given ID.
+
+        No-op if the config does not exist.
+        """
+
+        self._delete_if_exists(f"/api/discovery/configs/{config_id}/")
+
+    def delete_discovery_config_by_name_if_exists(self, name: str, config_type: DiscoveryConfigType) -> None:
+        """
+        Deletes the discovery config with the given name and type.
+
+        Config names are unique per type, so a type is required to identify a single config.
+        No-op if no such config exists.
+        """
+
+        matching = [
+            config
+            for config in self.list_discovery_configs()
+            if config.name == name and config.config_type is config_type
+        ]
+        for config in matching:
+            if config.id is None:
+                raise DataMasqueException(f'Server returned a discovery config named "{config.name}" without an `id`.')
+
+            self.delete_discovery_config_by_id_if_exists(config.id)
+
+    def get_default_discovery_config_yaml(self) -> str:
+        """Returns the server's built-in default discovery configuration as a YAML string."""
+
+        response = self.make_request("GET", "/api/discovery/configs/defaults/")
+        return response.content.decode("utf-8")

{datamasque_python-1.0.5 → datamasque_python-1.1.1}/datamasque/client/dmclient.py

@@ -1,6 +1,7 @@
 from datamasque.client.base import FileOrContent, UploadFile
 from datamasque.client.connections import ConnectionClient
 from datamasque.client.discovery import DiscoveryClient
+from datamasque.client.discovery_configs import DiscoveryConfigClient
 from datamasque.client.files import FileClient
 from datamasque.client.license import LicenseClient
 from datamasque.client.ruleset_libraries import RulesetLibraryClient
@@ -20,6 +21,7 @@ class DataMasqueClient(
     FileClient,
     RunClient,
     DiscoveryClient,
+    DiscoveryConfigClient,
     UserClient,
     SettingsClient,
 ):