datamasque-python 1.0.5__py3-none-any.whl → 1.1.0__py3-none-any.whl

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/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,
@@ -185,6 +192,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 +244,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 +440,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/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/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,
 ):

datamasque/client/exceptions.py

@@ -41,6 +41,23 @@ class InvalidLibraryError(FailedToStartError):
     """Specific error for when runs fail to start due to having an invalid ruleset library."""
 
 
+class InvalidDiscoveryConfigError(FailedToStartError):
+    """
+    Raised when a discovery run fails to start because the referenced config is present but unusable.
+
+    The config exists but is not in a `valid` validation state, or its YAML is rejected when the run starts.
+    A config that cannot be found raises `DiscoveryConfigNotFoundError` instead.
+    """
+
+
+class DiscoveryConfigNotFoundError(FailedToStartError):
+    """
+    Raised when a discovery run references a discovery config that cannot be found.
+
+    The config does not exist or is the wrong type for the run.
+    """
+
+
 class DataMasqueTransportError(DataMasqueException):
     """
     Raised when a request to the DataMasque server fails before any response is received.

datamasque/client/files.py

@@ -30,7 +30,7 @@ class FileClient(BaseClient):
         response = self.make_request(
             "POST",
             file_type.get_url(),
-            data={"name": file_name},
+            data={"name": file_name, **file_type.get_extra_form_data()},
             files=[
                 UploadFile(
                     field_name=file_type.get_content_param_name(),

datamasque/client/models/discovery.py

@@ -1,12 +1,15 @@
 """Typed request and response shapes for schema-discovery and ruleset-generation endpoints."""
 
+from enum import Enum
 from typing import Any, Optional, Union
 
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from datamasque.client.models.connection import ConnectionConfig, ConnectionId, unwrap_connection_id
 from datamasque.client.models.data_selection import HashColumnsTableConfig, Locator, UserSelection
+from datamasque.client.models.discovery_config import DiscoveryConfig, DiscoveryConfigId, unwrap_discovery_config_id
 from datamasque.client.models.pagination import Page
+from datamasque.client.models.runs import RunConnectionRef
 
 
 class InDataDiscoveryRule(BaseModel):
@@ -27,15 +30,17 @@ class InDataDiscoveryConfig(BaseModel):
     row_sample_size: Optional[int] = None
     custom_rules: Optional[list[InDataDiscoveryRule]] = None
     non_sensitive_rules: Optional[list[InDataDiscoveryRule]] = None
+    ignore_rules: Optional[list[InDataDiscoveryRule]] = None
     force: Optional[bool] = None
 
 
 class SchemaDiscoveryRequest(BaseModel):
     """
-    Request body for `POST /api/schema-discovery/`.
+    Request body for `POST /api/schema-discovery/` (the keyword-driven schema-discovery trigger).
 
-    `connection` accepts either a `ConnectionId` or a full `ConnectionConfig` returned by an earlier client call.
-    Every other field uses the server's default value when omitted.
+    `connection` accepts either a `ConnectionId` or a full `ConnectionConfig`
+    returned by an earlier client call.
+    This request does not accept a `discovery_config`.
     """
 
     model_config = ConfigDict(extra="forbid")
@@ -54,6 +59,45 @@ class SchemaDiscoveryRequest(BaseModel):
     def _unwrap_connection(cls, value: Any) -> Any:
         return unwrap_connection_id(value)
 
+    @model_validator(mode="before")
+    @classmethod
+    def _reject_discovery_config(cls, data: Any) -> Any:
+        if isinstance(data, dict) and "discovery_config" in data:
+            raise ValueError(
+                "`discovery_config` is not accepted by the keyword-driven schema-discovery request; "
+                "use `start_schema_discovery_run_from_config` with a `SchemaDiscoveryFromConfigRequest` "
+                "to run from a saved discovery config."
+            )
+        return data
+
+
+class SchemaDiscoveryFromConfigRequest(BaseModel):
+    """
+    Request body for `POST /api/schema-discovery/v2/` (start a run from a saved discovery config).
+
+    `connection` accepts either a `ConnectionId` or a full `ConnectionConfig`
+    returned by an earlier client call.
+    `discovery_config` is required: pass a `DiscoveryConfigId`, a full `DiscoveryConfig`,
+    or `None` to run with the default discovery options.
+    `schemas` optionally scopes the run to specific schemas; omit it to scan the connection's default schema.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    connection: Union[ConnectionId, ConnectionConfig]
+    discovery_config: Optional[Union[DiscoveryConfigId, DiscoveryConfig]]
+    schemas: Optional[list[str]] = None
+
+    @field_validator("connection", mode="before")
+    @classmethod
+    def _unwrap_connection(cls, value: Any) -> Any:
+        return unwrap_connection_id(value)
+
+    @field_validator("discovery_config", mode="before")
+    @classmethod
+    def _unwrap_discovery_config(cls, value: Any) -> Any:
+        return unwrap_discovery_config_id(value)
+
 
 class RulesetGenerationRequest(BaseModel):
     """
@@ -77,6 +121,114 @@ class RulesetGenerationRequest(BaseModel):
         return unwrap_connection_id(value)
 
 
+class FileFilterMatchAgainst(Enum):
+    """Which part of a file's path an `include`/`skip` filter is matched against."""
+
+    path = "path"
+    filename = "filename"
+
+
+class FileFilter(BaseModel):
+    """
+    A single `include` or `skip` filter for file data discovery.
+
+    Exactly one of `glob` or `regex` must be set.
+    `match_against` selects whether the pattern is applied to the full path or just the filename
+    (defaults to the full path when omitted).
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    glob: Optional[str] = Field(default=None, min_length=1)
+    regex: Optional[str] = Field(default=None, min_length=1)
+    match_against: Optional[FileFilterMatchAgainst] = None
+
+    @model_validator(mode="after")
+    def _check_glob_xor_regex(self) -> "FileFilter":
+        if (self.glob is None) == (self.regex is None):
+            raise ValueError("A `FileFilter` must set exactly one of `glob` or `regex`.")
+        return self
+
+
+class FileDataDiscoveryOptions(BaseModel):
+    """Run options nested under `FileDataDiscoveryRequest.options`."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    diagnostic_logging: Optional[bool] = None
+
+
+class FileDataDiscoveryRequest(BaseModel):
+    """
+    Request body for `POST /api/run-file-data-discovery/` (the keyword-driven file-data-discovery trigger).
+
+    `connection` accepts either a `ConnectionId` or a full `ConnectionConfig`
+    returned by an earlier client call.
+    This request does not accept a `discovery_config`.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    connection: Union[ConnectionId, ConnectionConfig]
+    options: Optional[FileDataDiscoveryOptions] = None
+    custom_keywords: list[str] = Field(default_factory=list)
+    ignored_keywords: list[str] = Field(default_factory=list)
+    disable_built_in_keywords: bool = False
+    disable_global_custom_keywords: Optional[bool] = None
+    disable_global_ignored_keywords: Optional[bool] = None
+    in_data_discovery: Optional[InDataDiscoveryConfig] = None
+    recurse: Optional[bool] = None
+    include: Optional[list[FileFilter]] = None
+    skip: Optional[list[FileFilter]] = None
+    encoding: Optional[str] = None
+    workers: Optional[int] = None
+
+    @field_validator("connection", mode="before")
+    @classmethod
+    def _unwrap_connection(cls, value: Any) -> Any:
+        return unwrap_connection_id(value)
+
+    @model_validator(mode="before")
+    @classmethod
+    def _reject_discovery_config(cls, data: Any) -> Any:
+        if isinstance(data, dict) and "discovery_config" in data:
+            raise ValueError(
+                "`discovery_config` is not accepted by the keyword-driven file-data-discovery request; "
+                "use `start_file_data_discovery_run_from_config` with a `FileDataDiscoveryFromConfigRequest` "
+                "to run from a saved discovery config."
+            )
+        return data
+
+
+class FileDataDiscoveryFromConfigRequest(BaseModel):
+    """
+    Request body for `POST /api/run-file-data-discovery/v2/` (start a run from a saved discovery config).
+
+    `connection` accepts either a `ConnectionId` or a full `ConnectionConfig`
+    returned by an earlier client call.
+    `discovery_config` is required: pass a `DiscoveryConfigId`, a full `DiscoveryConfig`,
+    or `None` to run with the server's default discovery options.
+    `options` carries the `diagnostic_logging` run-time toggle;
+    detection and file-handling settings come from the discovery config, not the request.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    connection: Union[ConnectionId, ConnectionConfig]
+    discovery_config: Optional[Union[DiscoveryConfigId, DiscoveryConfig]]
+    options: Optional[FileDataDiscoveryOptions] = None
+
+    @field_validator("connection", mode="before")
+    @classmethod
+    def _unwrap_connection(cls, value: Any) -> Any:
+        return unwrap_connection_id(value)
+
+    @field_validator("discovery_config", mode="before")
+    @classmethod
+    def _unwrap_discovery_config(cls, value: Any) -> Any:
+        return unwrap_discovery_config_id(value)
+
+
 class FileRulesetGenerationRequest(BaseModel):
     """
     Request body for `POST /api/generate-file-ruleset/`.
@@ -189,11 +341,11 @@ class FileDiscoveryMatch(BaseModel):
 
     model_config = ConfigDict(extra="allow")
 
-    categories: Optional[list[str]] = None
-    flagged_by: Optional[str] = None
-    description: Optional[str] = None
-    label: Optional[str] = None
-    hit_ratio: Optional[int] = None
+    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.
+    hit_ratio: Optional[int] = None  # None for metadata matches, percentage 0-100 for IDD matches.
 
 
 class FileDiscoveryLocatorResult(BaseModel):
@@ -201,9 +353,9 @@ class FileDiscoveryLocatorResult(BaseModel):
 
     model_config = ConfigDict(extra="allow")
 
-    locator: Optional[Locator] = None
-    matches: Optional[list[FileDiscoveryMatch]] = None
-    data_types: Optional[list[str]] = None
+    locator: Locator
+    matches: list[FileDiscoveryMatch]
+    data_types: list[str]
 
 
 class FileDiscoveryFile(BaseModel):
@@ -211,8 +363,8 @@ class FileDiscoveryFile(BaseModel):
 
     model_config = ConfigDict(extra="allow")
 
-    path: Optional[str] = None
-    file_type: Optional[str] = None
+    path: str
+    file_type: str
     delimiter: Optional[str] = None
     encoding: Optional[str] = None
 
@@ -222,8 +374,8 @@ class FileDiscoveryResult(BaseModel):
 
     model_config = ConfigDict(extra="allow")
 
-    id: Optional[int] = None
-    connection: Optional[Any] = None
-    file_type: Optional[str] = None
-    files: Optional[list[FileDiscoveryFile]] = None
-    results: Optional[list[FileDiscoveryLocatorResult]] = None
+    id: int
+    connection: RunConnectionRef
+    file_type: str
+    files: list[FileDiscoveryFile]
+    results: list[FileDiscoveryLocatorResult]

datamasque/client/models/discovery_config.py

@@ -0,0 +1,53 @@
+import enum
+from datetime import datetime
+from typing import Any, NewType, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from datamasque.client.models.status import ValidationStatus
+
+DiscoveryConfigId = NewType("DiscoveryConfigId", str)
+
+
+class DiscoveryConfigType(enum.Enum):
+    """Which discovery config variant a config targets: database (qualified columns) or file (locators)."""
+
+    database = "database"
+    file = "file"
+
+
+def unwrap_discovery_config_id(value: Any) -> Any:
+    """
+    Coerce a `DiscoveryConfig` to its `id`; pass other values through unchanged.
+
+    Used by request-model validators that accept either a `DiscoveryConfigId`
+    or a full `DiscoveryConfig` for user convenience.
+    Raises `ValueError` if the config has no `id`
+    (i.e. the caller hasn't yet created it on the server).
+    """
+
+    if isinstance(value, DiscoveryConfig):
+        if value.id is None:
+            raise ValueError("Discovery config has not been created yet (id is None)")
+        return value.id
+
+    return value
+
+
+class DiscoveryConfig(BaseModel):
+    """Represents a named, persisted YAML discovery configuration."""
+
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    name: str
+    yaml: Optional[str] = Field(default=None, alias="config_yaml")
+    config_type: DiscoveryConfigType
+
+    # Server-populated read-only fields, excluded from request bodies.
+    id: Optional[DiscoveryConfigId] = Field(default=None, exclude=True)
+    is_valid: Optional[ValidationStatus] = Field(default=None, exclude=True)
+    """Validation status; may be `in_progress` briefly after creating a large config."""
+    validation_error: Optional[str] = Field(default=None, exclude=True)
+    """Human-readable validation error, or `None` when valid."""
+    created: Optional[datetime] = Field(default=None, exclude=True)
+    modified: Optional[datetime] = Field(default=None, exclude=True)

datamasque/client/models/files.py

@@ -40,6 +40,12 @@ class DataMasqueFile(BaseModel):
 
         raise NotImplementedError  # pragma: no cover
 
+    @classmethod
+    def get_extra_form_data(cls) -> dict[str, str]:
+        """Extra multipart form fields to send alongside the file on upload. Empty by default."""
+
+        return {}
+
 
 class SeedFile(DataMasqueFile):
     """Represents a seed file (CSV file)."""
@@ -76,6 +82,11 @@ class SslZipFile(DataMasqueFile):
     def get_content_param_name(cls) -> str:
         return "zip_archive"
 
+    @classmethod
+    def get_extra_form_data(cls) -> dict[str, str]:
+        # The connection-filesets endpoint requires a database_type; SSL filesets are MySQL-only today.
+        return {"database_type": "mysql"}
+
 
 class SnowflakeKeyFile(DataMasqueFile):
     """Represents a private SSH key file for Snowflake connections."""

datamasque/client/models/git.py

@@ -0,0 +1,60 @@
+from collections.abc import Mapping
+from datetime import datetime
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class GitSnapshot(BaseModel):
+    """
+    Git provenance for a ruleset or ruleset library.
+
+    Identifies the commit the entity's contents came from —
+    `commit_sha` on `branch` in `repo_url`, as of `synced_at`.
+    """
+
+    branch: str
+    commit_sha: str
+    repo_url: str
+    synced_at: datetime
+
+
+GIT_RESPONSE_FIELDS = ("git_branch", "git_commit_sha", "git_repo_url", "git_synced_at")
+
+
+def git_snapshot_from_response(data: Mapping[str, Any]) -> Optional[GitSnapshot]:
+    """Build a `GitSnapshot` from the server's flat `git_*` fields, or `None` when not git-synced."""
+    if data.get("git_branch") is None:
+        return None
+
+    return GitSnapshot(
+        branch=data["git_branch"],
+        commit_sha=data["git_commit_sha"],
+        repo_url=data["git_repo_url"],
+        synced_at=data["git_synced_at"],
+    )
+
+
+class GitTrackedEntity(BaseModel):
+    """Base class for rulesets and ruleset libraries that carry git provenance."""
+
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    git: Optional[GitSnapshot] = Field(default=None, exclude=True)
+    """Git provenance, or `None` when the entity is not currently in sync with a git commit."""
+
+    @model_validator(mode="before")
+    @classmethod
+    def _collapse_git_fields(cls, data: Any) -> Any:
+        if not isinstance(data, dict) or "git" in data:
+            return data
+
+        data = dict(data)
+        snapshot = git_snapshot_from_response(data)
+        for field in GIT_RESPONSE_FIELDS:
+            data.pop(field, None)
+
+        if snapshot is not None:
+            data["git"] = snapshot
+
+        return data

datamasque/client/models/ruleset.py

@@ -1,9 +1,10 @@
 import enum
 from typing import Any, NewType, Optional
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import Field
 
-from datamasque.client.models.status import ValidationStatus
+from datamasque.client.models.git import GitTrackedEntity
+from datamasque.client.models.status import ValidationErrorType, ValidationStatus
 
 RulesetId = NewType("RulesetId", str)
 
@@ -33,13 +34,17 @@ class RulesetType(enum.Enum):
     database = "database"
 
 
-class Ruleset(BaseModel):
+class Ruleset(GitTrackedEntity):
     """Represents a ruleset."""
 
-    model_config = ConfigDict(extra="allow", populate_by_name=True)
-
     name: str
     yaml: str = Field(default="", alias="config_yaml")
     ruleset_type: RulesetType = Field(default=RulesetType.database, alias="mask_type")
-    id: Optional[RulesetId] = None
-    is_valid: Optional[ValidationStatus] = None
+
+    # Server-populated read-only fields, excluded from request bodies.
+    id: Optional[RulesetId] = Field(default=None, exclude=True)
+    is_valid: Optional[ValidationStatus] = Field(default=None, exclude=True)
+    validation_error: Optional[str] = Field(default=None, exclude=True)
+    """Human-readable validation error, or `None` when valid."""
+    validation_error_type: Optional[ValidationErrorType] = Field(default=None, exclude=True)
+    """Category of the validation failure, or `None` when valid."""

datamasque/client/models/ruleset_library.py

@@ -1,22 +1,25 @@
 from datetime import datetime
 from typing import NewType, Optional
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import Field
 
+from datamasque.client.models.git import GitTrackedEntity
 from datamasque.client.models.status import ValidationStatus
 
 RulesetLibraryId = NewType("RulesetLibraryId", str)
 
 
-class RulesetLibrary(BaseModel):
+class RulesetLibrary(GitTrackedEntity):
     """Represents a ruleset library."""
 
-    model_config = ConfigDict(extra="allow", populate_by_name=True)
-
     name: str
     namespace: str = ""
     yaml: Optional[str] = Field(default=None, alias="config_yaml")
-    id: Optional[RulesetLibraryId] = None
-    is_valid: Optional[ValidationStatus] = None
-    created: Optional[datetime] = None
-    modified: Optional[datetime] = None
+
+    # Server-populated read-only fields, excluded from request bodies.
+    id: Optional[RulesetLibraryId] = Field(default=None, exclude=True)
+    is_valid: Optional[ValidationStatus] = Field(default=None, exclude=True)
+    validation_error: Optional[str] = Field(default=None, exclude=True)
+    """Human-readable validation error, or `None` when valid."""
+    created: Optional[datetime] = Field(default=None, exclude=True)
+    modified: Optional[datetime] = Field(default=None, exclude=True)

datamasque/client/models/runs.py

@@ -30,6 +30,7 @@ class MaskingRunOptions(BaseModel):
     if supplied,
     must be 16–256 characters and is used as the per-run encryption key;
     the server auto-generates one when omitted.
+    Set `auto_pull` to refresh the run's ruleset from git before the run starts.
     """
 
     model_config = ConfigDict(extra="forbid")
@@ -41,6 +42,10 @@ class MaskingRunOptions(BaseModel):
     diagnostic_logging: Optional[bool] = None
     run_secret: Optional[str] = Field(default=None, min_length=16, max_length=256)
     disable_instance_secret: Optional[bool] = None
+    auto_pull: Optional[bool] = None
+    """When `True`, pull the run's ruleset from git before starting."""
+    auto_pull_branch: Optional[str] = None
+    """Branch to auto-pull from; omitted or empty uses the instance's configured branch."""
 
 
 class MaskingRunRequest(BaseModel):
@@ -50,6 +55,9 @@ class MaskingRunRequest(BaseModel):
     `connection`, `destination_connection`, and `ruleset` accept either the server-assigned ID
     or the corresponding object returned by an earlier client call (e.g. a `ConnectionConfig`
     or `Ruleset`); the object's `id` is extracted at construction time.
+
+    Set `is_user_subscribed=True` to subscribe the requesting user to the run's email notifications;
+    when omitted the server applies its default (no subscription).
     """
 
     model_config = ConfigDict(extra="forbid")
@@ -60,6 +68,7 @@ class MaskingRunRequest(BaseModel):
     destination_connection: Optional[Union[ConnectionId, ConnectionConfig]] = None
     options: MaskingRunOptions = Field(default_factory=MaskingRunOptions)
     name: Optional[str] = None
+    is_user_subscribed: Optional[bool] = None
 
     @field_validator("connection", "destination_connection", mode="before")
     @classmethod

datamasque/client/models/status.py

@@ -10,6 +10,15 @@ class ValidationStatus(enum.Enum):
     unknown = "unknown"
 
 
+class ValidationErrorType(enum.Enum):
+    """Categorises why a ruleset failed validation (see `Ruleset.validation_error_type`)."""
+
+    ruleset = "ruleset"
+    library_missing = "library_missing"
+    library_invalid = "library_invalid"
+    expansion = "expansion"  # The ruleset is not valid once its library references are expanded.
+
+
 class MaskingRunStatus(enum.Enum):
     """List of valid masking run statuses."""
 

datamasque/client/ruleset_libraries.py

@@ -63,7 +63,8 @@ class RulesetLibraryClient(BaseClient):
         """
         Creates a new ruleset library on the server.
 
-        Sets the library's server-assigned fields (`id`, `is_valid`, `created`, `modified`) and returns the library.
+        Sets the library's server-assigned fields
+        (`id`, `is_valid`, `validation_error`, `git`, `created`, `modified`) and returns the library.
         """
 
         data = library.model_dump(exclude_none=True, by_alias=True, mode="json")
@@ -71,6 +72,8 @@ class RulesetLibraryClient(BaseClient):
         created_library = RulesetLibrary.model_validate(response.json())
         library.id = created_library.id
         library.is_valid = created_library.is_valid
+        library.validation_error = created_library.validation_error
+        library.git = created_library.git
         library.created = created_library.created
         library.modified = created_library.modified
         logger.info('Creation of ruleset library "%s" successful', library.name)
@@ -90,6 +93,8 @@ class RulesetLibraryClient(BaseClient):
         response = self.make_request("PUT", f"/api/ruleset-libraries/{library.id}/", data=data)
         updated_library = RulesetLibrary.model_validate(response.json())
         library.is_valid = updated_library.is_valid
+        library.validation_error = updated_library.validation_error
+        library.git = updated_library.git
         library.modified = updated_library.modified
         logger.debug('Update of ruleset library "%s" successful', library.name)
         return library
@@ -110,7 +115,7 @@ class RulesetLibraryClient(BaseClient):
 
     def delete_ruleset_library_by_id_if_exists(self, library_id: RulesetLibraryId, *, force: bool = False) -> None:
         """
-        Deletes (archives) the ruleset library with the given ID.
+        Deletes the ruleset library with the given ID.
 
         No-op if the library does not exist.
 
@@ -139,13 +144,13 @@ class RulesetLibraryClient(BaseClient):
             self.delete_ruleset_library_by_id_if_exists(lib.id, force=force)
 
     def iter_rulesets_using_library(self, library_id: RulesetLibraryId) -> Iterator[Ruleset]:
-        """Lazily iterate non-archived rulesets that import the given library."""
+        """Lazily iterate rulesets that import the given library."""
 
         return self._iter_paginated(f"/api/ruleset-libraries/{library_id}/rulesets/", model=Ruleset)
 
     def list_rulesets_using_library(self, library_id: RulesetLibraryId) -> list[Ruleset]:
         """
-        Lists non-archived rulesets that import the given library.
+        Lists rulesets that import the given library.
 
         Note: The YAML content is not included in the response for performance.
         Each returned Ruleset will have an empty string for `yaml`.

datamasque/client/rulesets.py

@@ -2,8 +2,7 @@ import logging
 
 from datamasque.client.base import BaseClient
 from datamasque.client.exceptions import DataMasqueException
-from datamasque.client.models.ruleset import Ruleset, RulesetId
-from datamasque.client.models.status import ValidationStatus
+from datamasque.client.models.ruleset import Ruleset, RulesetId, RulesetType
 
 logger = logging.getLogger(__name__)
 
@@ -21,17 +20,18 @@ class RulesetClient(BaseClient):
         """
         Creates or updates a ruleset.
 
-        Populates the given ruleset's `id` and `is_valid` fields from the server response,
-        and returns the same ruleset instance for convenience.
+        Populates the given ruleset's `id`, `is_valid`, `validation_error`, `validation_error_type`,
+        and `git` fields from the server response, and returns the same ruleset instance for convenience.
         """
 
         data = ruleset.model_dump(exclude_none=True, by_alias=True, mode="json")
         response = self.make_request("POST", "/api/rulesets/", data=data, params={"upsert": "true"})
-        response_data = response.json()
-        ruleset.id = RulesetId(response_data["id"])
-        is_valid = response_data.get("is_valid")
-        if is_valid is not None:
-            ruleset.is_valid = ValidationStatus(is_valid)
+        created = Ruleset.model_validate(response.json())
+        ruleset.id = created.id
+        ruleset.is_valid = created.is_valid
+        ruleset.validation_error = created.validation_error
+        ruleset.validation_error_type = created.validation_error_type
+        ruleset.git = created.git
 
         if response.status_code == 201:
             logger.info('Creation of ruleset "%s" successful', ruleset.name)
@@ -45,12 +45,20 @@ class RulesetClient(BaseClient):
 
         self._delete_if_exists(f"/api/rulesets/{ruleset_id}/")
 
-    def delete_ruleset_by_name_if_exists(self, ruleset_name: str) -> None:
-        """Deletes the ruleset with the given name. No-op if the ruleset does not exist."""
+    def delete_ruleset_by_name_if_exists(self, ruleset_name: str, ruleset_type: RulesetType) -> None:
+        """
+        Deletes the ruleset with the given name and type.
+
+        Ruleset names are unique per type, so a type is required to identify a single ruleset.
+        No-op if no such ruleset exists.
+        """
 
-        all_rulesets = self.list_rulesets()
-        rulesets_matching_name = [ruleset for ruleset in all_rulesets if ruleset.name == ruleset_name]
-        for ruleset in rulesets_matching_name:
+        matching = [
+            ruleset
+            for ruleset in self.list_rulesets()
+            if ruleset.name == ruleset_name and ruleset.ruleset_type is ruleset_type
+        ]
+        for ruleset in matching:
             if ruleset.id is None:
                 raise DataMasqueException(f'Server returned a ruleset named "{ruleset.name}" without an `id`.')
 

{datamasque_python-1.0.5.dist-info → datamasque_python-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamasque-python
-Version: 1.0.5
+Version: 1.1.0
 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.dist-info/RECORD

@@ -0,0 +1,36 @@
+datamasque/client/__init__.py,sha256=GmpVFNWZPu6jyadhY6SOZp4hLR1wUc4cgzwLcqoEA5o,6312
+datamasque/client/base.py,sha256=vP1LuYbqq6U8NAEJWnwNrdt_Fa2wjQTJXHf0gSFO79c,14115
+datamasque/client/connections.py,sha256=EFinx8fJRme0mTxuWY3d29UnmUFbsQhMaUQT0Ma2PK4,2885
+datamasque/client/discovery.py,sha256=NluzWjC-QGzxWEHr6zMjKDkhx-Z9w5M0IBcR258OEhY,20536
+datamasque/client/discovery_configs.py,sha256=G-W-X_KizjjQLa-Rb6ixLjlkxbkCe4WGCOfYZrGtxIk,6420
+datamasque/client/dmclient.py,sha256=tA7V8GEQmnsalTHUZch8YmIUynYw2ldK-mmUGbofFL4,1650
+datamasque/client/exceptions.py,sha256=Tx7tE6i1X_oemR3EOJC97_sihZiToHqGuOQmWWxs_BE,3131
+datamasque/client/files.py,sha256=vc2tZgT8RdwuCObIQ7H-Qjb80H1PBFqD0nG5Y1tOA_o,3503
+datamasque/client/ifm.py,sha256=uIMxpLIPvDiDO1m4bxezixNIUFIFY0MXWRMQNvTbpTA,11858
+datamasque/client/license.py,sha256=pluYaSU168OC6_laB9bM9H3Vuuxs8wa9gujCJvtoJCk,1392
+datamasque/client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamasque/client/ruleset_libraries.py,sha256=bMUMBHdxjDyFOziw9LMRy5xChPvHvCjpjAUoVeTm1e0,7086
+datamasque/client/rulesets.py,sha256=Fsnsv-uAhF1DBnLI-pRpOrWJ7aCSZspcuU1r0RYTzUc,2655
+datamasque/client/runs.py,sha256=ZPSkkuyqMiwy7dLbWZ1PAEKaesKLeNRX7xEJGfzieVg,7427
+datamasque/client/settings.py,sha256=Ui8AyR2XdoW8MZ9FIrGn2jm8DLzUGWIL8i2DOTvu7hc,2898
+datamasque/client/users.py,sha256=VCUo2CJyOw4-aO_3mp_w_0BcSoa6-h1HcReMcAMyumw,3701
+datamasque/client/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamasque/client/models/connection.py,sha256=TSv-bbOFlYCRBZHJiRgiwNuN0es_GdJd-_L3LUsQ-dI,15773
+datamasque/client/models/data_selection.py,sha256=406yyUZ5NmLBSql2lYM1gsTWY5GWmnutmF-DjznAoLc,1904
+datamasque/client/models/discovery.py,sha256=wEveTc8vh6dOJx6K2rkbdbU_e1EbI8jSRhZ5SgDF2wY,13225
+datamasque/client/models/discovery_config.py,sha256=1CHMgSxMXuarPGfRcz9wX7jeZLn1SDw0UEe-L5naE54,1917
+datamasque/client/models/dm_instance.py,sha256=yjjpHZJTFhJp3lAinTEffgKrxnadrJys1EuhO77wQcA,1561
+datamasque/client/models/files.py,sha256=7hG3Q1-XYb1PF88l3ppsmBp2tjNtvQvv-RNTrOa7Nts,2784
+datamasque/client/models/git.py,sha256=F0KdMFe2vMyL-9tp3SGKGeOlbD1gbcjQn0jpOzNzybc,1782
+datamasque/client/models/ifm.py,sha256=j0Ef2BZYTk6MNZO6HS6mW0qWs1_wWD9PlUP_Y6WyBQI,5563
+datamasque/client/models/license.py,sha256=OqIn4Sx3ATBStgt5KNiCOBChTTFYLBsyGj7inAl8oB4,2113
+datamasque/client/models/pagination.py,sha256=egg9aO2cf6KUDwDANPu5RxpJbdRKdwUdCQAtusnuf1c,651
+datamasque/client/models/ruleset.py,sha256=ZYv6SmcrONV5rLK0tKjhlKCwZiCU1dMYtH7olxI4l5A,1678
+datamasque/client/models/ruleset_library.py,sha256=5UbL_M47mgPedo8xt4q5crUh4aeOVoEMAEKbGO8CfiY,950
+datamasque/client/models/runs.py,sha256=UtPMGCJFLFP1f2nyVGAbl3A5_wAONrRNJ63y43Hbpi0,6213
+datamasque/client/models/status.py,sha256=LuTpgocedVqeU0zxuoyJ7LsxMgHtSkrwHVMYaX_7QGg,2320
+datamasque/client/models/user.py,sha256=UGAUzgJkf78m24_zFXXoA99zdut48BXkX_ivV8yq1Vc,2043
+datamasque_python-1.1.0.dist-info/METADATA,sha256=xZqEPFC-2faxpi_P_8wKBIRWNqKpZuEQdFWjvhWj26Q,4187
+datamasque_python-1.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+datamasque_python-1.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+datamasque_python-1.1.0.dist-info/RECORD,,

datamasque_python-1.0.5.dist-info/RECORD

@@ -1,33 +0,0 @@
-datamasque/client/__init__.py,sha256=rH7hQyA_nFVkv8eV_C1Ds_40v9xzCK__uXIJtWMLfuQ,5472
-datamasque/client/base.py,sha256=vP1LuYbqq6U8NAEJWnwNrdt_Fa2wjQTJXHf0gSFO79c,14115
-datamasque/client/connections.py,sha256=EFinx8fJRme0mTxuWY3d29UnmUFbsQhMaUQT0Ma2PK4,2885
-datamasque/client/discovery.py,sha256=uA8h6vRqsxSAzSAV9bebJwU47XINlaVy7V1nTYDiaCM,12634
-datamasque/client/dmclient.py,sha256=OPYMzc57gUHPs6iL_J2DYp06MfOaabpTlISmnNCpqS4,1553
-datamasque/client/exceptions.py,sha256=F9FYCxP-ERXkVD1L3yh_rWqcW3IsPL-c-Ic4qMYoGnw,2542
-datamasque/client/files.py,sha256=5Gzel4aLby8T7ncOIV6wtgVbFEk0eaEy7wxohh9u0zE,3468
-datamasque/client/ifm.py,sha256=uIMxpLIPvDiDO1m4bxezixNIUFIFY0MXWRMQNvTbpTA,11858
-datamasque/client/license.py,sha256=pluYaSU168OC6_laB9bM9H3Vuuxs8wa9gujCJvtoJCk,1392
-datamasque/client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datamasque/client/ruleset_libraries.py,sha256=tyN--cndzG0gwFnHY9fDtObTLzGsK0wrV5lxxjRP72g,6868
-datamasque/client/rulesets.py,sha256=2Zh6QUihZ8p3dNT6QbaWuxvMk-Whp67JUj8UxqeRYUY,2407
-datamasque/client/runs.py,sha256=ZPSkkuyqMiwy7dLbWZ1PAEKaesKLeNRX7xEJGfzieVg,7427
-datamasque/client/settings.py,sha256=Ui8AyR2XdoW8MZ9FIrGn2jm8DLzUGWIL8i2DOTvu7hc,2898
-datamasque/client/users.py,sha256=VCUo2CJyOw4-aO_3mp_w_0BcSoa6-h1HcReMcAMyumw,3701
-datamasque/client/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datamasque/client/models/connection.py,sha256=TSv-bbOFlYCRBZHJiRgiwNuN0es_GdJd-_L3LUsQ-dI,15773
-datamasque/client/models/data_selection.py,sha256=406yyUZ5NmLBSql2lYM1gsTWY5GWmnutmF-DjznAoLc,1904
-datamasque/client/models/discovery.py,sha256=BawKusPuhyt0gRRnWKYf-ZKF7V54GxkhgYIrEQ6XkOs,7283
-datamasque/client/models/dm_instance.py,sha256=yjjpHZJTFhJp3lAinTEffgKrxnadrJys1EuhO77wQcA,1561
-datamasque/client/models/files.py,sha256=OaWVD-AX77vvaN_qxB6Uzn2HRasb7wNo-6QAvRzV3og,2381
-datamasque/client/models/ifm.py,sha256=j0Ef2BZYTk6MNZO6HS6mW0qWs1_wWD9PlUP_Y6WyBQI,5563
-datamasque/client/models/license.py,sha256=OqIn4Sx3ATBStgt5KNiCOBChTTFYLBsyGj7inAl8oB4,2113
-datamasque/client/models/pagination.py,sha256=egg9aO2cf6KUDwDANPu5RxpJbdRKdwUdCQAtusnuf1c,651
-datamasque/client/models/ruleset.py,sha256=tf5j9ih3B0uEF4yPTnyCsLblFWzH-t9KnvJWuyJaiCs,1256
-datamasque/client/models/ruleset_library.py,sha256=gIqb6yn4-f9i2OydOLk1cd0zId9nGv5l_yUZwFHZ1aA,652
-datamasque/client/models/runs.py,sha256=oVYo9jp9s5LjWts0LKsYpX3HUBmrVwuuzDqFtQmTjvo,5673
-datamasque/client/models/status.py,sha256=rjH6YSwAHoOUaUCADwvMhuKd0ygT0c2w2Ek5SV8PWD8,1984
-datamasque/client/models/user.py,sha256=UGAUzgJkf78m24_zFXXoA99zdut48BXkX_ivV8yq1Vc,2043
-datamasque_python-1.0.5.dist-info/METADATA,sha256=U0jpV668Y8w1fBtPcx4Rh5ZwzT1cbptYAepZkJFhBAA,4187
-datamasque_python-1.0.5.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-datamasque_python-1.0.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-datamasque_python-1.0.5.dist-info/RECORD,,