datamasque-python 1.2.5__tar.gz → 1.3.1__tar.gz

{datamasque_python-1.2.5 → datamasque_python-1.3.1}/.github/workflows/release.yml

@@ -60,3 +60,27 @@ jobs:
 
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    name: Publish GitHub Release
+    needs: publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Download distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create "${GITHUB_REF_NAME}" \
+            --repo "${GITHUB_REPOSITORY}" \
+            --title "${GITHUB_REF_NAME}" \
+            --verify-tag \
+            --notes "See [HISTORY.rst](https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_REF_NAME}/HISTORY.rst) for changelog." \
+            dist/*

{datamasque_python-1.2.5 → datamasque_python-1.3.1}/HISTORY.rst

@@ -2,6 +2,32 @@
 History
 =======
 
+1.3.1 (2026-09-09)
+------------------
+
+* Added ``max_length_unit`` to ``SchemaDiscoveryColumn``, typed by the new ``LengthUnit`` enum
+  (``chars`` or ``bytes``), reporting the unit a column's ``max_length`` is counted in.
+  It is ``None`` for results from older servers that do not report a unit.
+
+Requires server version 3.26.17
+
+1.3.0 (2026-09-04)
+------------------
+
+* Added ``CosmosDbConnectionConfig`` and the ``cosmosdb`` ``DatabaseType``, for Azure Cosmos DB.
+  It differs from ``MongoConnectionConfig`` by ``db_type`` and three defaults: ``port`` 10255,
+  ``tls`` on, because Cosmos DB only accepts TLS connections, and ``retry_writes`` off, because
+  Cosmos DB rejects retryable inserts.
+
+* ``DatabaseConnectionConfig`` now rejects the ``documentdb`` and ``cosmosdb`` database types with a
+  message naming the class to use, as it already did for MongoDB, DynamoDB, Snowflake and Databricks.
+
+* The MongoDB serializer prunes ``tls`` and ``retry_writes`` against the concrete class's default
+  rather than MongoDB's, so a Cosmos DB config that sets either the other way now sends it instead
+  of leaving the server to apply its own default.
+
+Requires server version 3.26.17
+
 1.2.5 (2026-08-17)
 ------------------
 

{datamasque_python-1.2.5 → datamasque_python-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: datamasque-python
-Version: 1.2.5
+Version: 1.3.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.2.5 → datamasque_python-1.3.1}/RELEASING.rst

@@ -68,31 +68,10 @@ Releasing to PyPI
    You can verify that the release appears at https://pypi.org/project/datamasque-python/,
    and Read the Docs has built the new tag
    at https://datamasque-python.readthedocs.io/.
-5. Create the GitHub Release (see below).
-
-Creating the GitHub Release
-===========================
-
-Do this after the PyPI publish has succeeded,
-so the release never points at a version nobody can install.
-
-1. On the repository home page,
-   find **Releases** in the right-hand sidebar under the *About* box,
-   and click it,
-   then **Draft a new release**.
-2. **Choose a tag** — pick the existing tag you pushed as part of releasing to PyPI.
-   Don't let GitHub create a new one; the tag should already exist from the release flow.
-3. Set the target to ``main``.
-4. Title it the same as the tag, e.g. ``v1.2.2``.
-5. Paste the ``HISTORY.rst`` entry for this version into the body, converted to Markdown.
-   **Generate release notes** is a reasonable starting point for the commit list,
-   but the hand-written changelog is what users read.
-6. Leave *Set as a pre-release* unticked for a normal release.
-7. Click **Publish release**.
-
-Creating releases can also be done from the ``gh`` CLI::
-
-    gh release create v1.2.2 --title v1.2.2 --notes-file notes.md
+5. The GitHub Release is created automatically once the PyPI publish succeeds.
+   ``release.yml`` runs a ``github-release`` job that creates the release for the pushed tag,
+   attaches the built distributions, and links to ``HISTORY.rst`` at that tag for the changelog.
+   Nothing to do by hand; just confirm it appears under **Releases** on the repository home page.
 
 Releasing a dev build to TestPyPI
 =================================

{datamasque_python-1.2.5 → datamasque_python-1.3.1}/datamasque/client/__init__.py

@@ -31,6 +31,7 @@ from datamasque.client.models.connection import (
     AzureConnectionConfig,
     ConnectionConfig,
     ConnectionId,
+    CosmosDbConnectionConfig,
     DatabaseConnectionConfig,
     DatabaseType,
     DatabricksConnectionConfig,
@@ -72,6 +73,7 @@ from datamasque.client.models.discovery import (
     ForeignKeyRef,
     InDataDiscoveryConfig,
     InDataDiscoveryRule,
+    LengthUnit,
     ReferencingForeignKey,
     RulesetGenerationRequest,
     RulesetGenerationWithRGConfigRequest,
@@ -203,6 +205,7 @@ __all__ = [
     "DiscoveryConfigNotFoundError",
     "DiscoveryConfigType",
     "DiscoveryMatch",
+    "CosmosDbConnectionConfig",
     "DocumentDbConnectionConfig",
     "DynamoConnectionConfig",
     "FailedToStartError",
@@ -237,6 +240,7 @@ __all__ = [
     "InvalidRulesetError",
     "JsonPath",
     "LengthEntry",
+    "LengthUnit",
     "LengthsStatistics",
     "LicenseInfo",
     "Locator",

{datamasque_python-1.2.5 → datamasque_python-1.3.1}/datamasque/client/models/connection.py

@@ -45,6 +45,7 @@ class DatabaseType(Enum):
     snowflake = "snowflake"
     mongodb = "mongodb"
     documentdb = "documentdb"
+    cosmosdb = "cosmosdb"
     databricks_lakebase = "databricks_lakebase"
     databricks = "databricks"
     informix = "informix"
@@ -184,8 +185,11 @@ class MongoConnectionConfig(ConnectionConfig):
         password = d.pop("password", None)
         if password:
             d["dbpassword"] = password
+        # `tls` and `retry_writes` are pruned against this class's own default, not MongoDB's:
+        # the subclasses invert them, so a hardcoded comparison would drop the very value the
+        # caller set and let the server apply its default instead.
+        defaults = type(self).model_fields
         if not d.get("tls"):
-            d.pop("tls", None)
             d.pop("tls_ca_file", None)
             d.pop("tls_allow_invalid_certificates", None)
         else:
@@ -193,9 +197,11 @@ class MongoConnectionConfig(ConnectionConfig):
                 d.pop("tls_ca_file", None)
             if not d.get("tls_allow_invalid_certificates"):
                 d.pop("tls_allow_invalid_certificates", None)
+        if d.get("tls") == defaults["tls"].default:
+            d.pop("tls", None)
         if not d.get("direct_connection"):
             d.pop("direct_connection", None)
-        if d.get("retry_writes", True):
+        if d.get("retry_writes") == defaults["retry_writes"].default:
             d.pop("retry_writes", None)
         if not d.get("replica_set"):
             d.pop("replica_set", None)
@@ -229,6 +235,29 @@ class DocumentDbConnectionConfig(MongoConnectionConfig):
         return DatabaseType.documentdb
 
 
+class CosmosDbConnectionConfig(MongoConnectionConfig):
+    """
+    Connection configuration for an Azure Cosmos DB account.
+
+    Cosmos DB listens on 10255, only accepts TLS connections and rejects retryable inserts, so it
+    differs from `MongoConnectionConfig` by `db_type`/`database_type` and those three defaults.
+
+    They are defaults, not constraints. Setting one the other way sends it to the server: with
+    retryable writes on, masking still runs (it only updates) but the run-history insert is
+    rejected, so the run is not recorded.
+    """
+
+    # Narrowing the inherited Literal is a deliberate Pydantic discriminator override.
+    db_type: Literal["cosmosdb"] = "cosmosdb"  # type: ignore[assignment]
+    port: int = 10255
+    tls: bool = True
+    retry_writes: bool = False
+
+    @property
+    def database_type(self) -> DatabaseType:
+        return DatabaseType.cosmosdb
+
+
 class SnowflakeConnectionConfig(ConnectionConfig):
     """
     Connection configuration for a Snowflake database.
@@ -339,6 +368,10 @@ class DatabaseConnectionConfig(ConnectionConfig):
             raise ValueError("For Snowflake, use the SnowflakeConnectionConfig class instead")
         if self.database_type is DatabaseType.mongodb:
             raise ValueError("For MongoDB, use the MongoConnectionConfig class instead")
+        if self.database_type is DatabaseType.documentdb:
+            raise ValueError("For AWS DocumentDB, use the DocumentDbConnectionConfig class instead")
+        if self.database_type is DatabaseType.cosmosdb:
+            raise ValueError("For Azure Cosmos DB, use the CosmosDbConnectionConfig class instead")
         if self.database_type is DatabaseType.databricks:
             raise ValueError("For Databricks SQL Warehouse, use the DatabricksConnectionConfig class instead")
         return self
@@ -490,6 +523,7 @@ DB_TYPE_MAP: dict[str, type[ConnectionConfig]] = {
     DatabaseType.dynamodb.value: DynamoConnectionConfig,
     DatabaseType.mongodb.value: MongoConnectionConfig,
     DatabaseType.documentdb.value: DocumentDbConnectionConfig,
+    DatabaseType.cosmosdb.value: CosmosDbConnectionConfig,
     DatabaseType.snowflake.value: SnowflakeConnectionConfig,
     DatabaseType.mssql_linked.value: MssqlLinkedServerConnectionConfig,
     DatabaseType.databricks.value: DatabricksConnectionConfig,

{datamasque_python-1.2.5 → datamasque_python-1.3.1}/datamasque/client/models/discovery.py

@@ -367,6 +367,13 @@ class ReferencingForeignKey(BaseModel):
     referencing_column: str  # Dotted path: "schema.table.column".
 
 
+class LengthUnit(Enum):
+    """The unit a column's declared width (`max_length`) is counted in."""
+
+    chars = "chars"
+    bytes = "bytes"
+
+
 class SchemaDiscoveryColumn(BaseModel):
     """Column-level data in a schema discovery result."""
 
@@ -374,6 +381,8 @@ class SchemaDiscoveryColumn(BaseModel):
 
     data_type: Optional[str] = None
     max_length: Optional[int] = None
+    # None when the server does not report a unit (older runs count chars).
+    max_length_unit: Optional[LengthUnit] = None
     foreign_keys: list[ForeignKeyRef]
     discovery_matches: list[DiscoveryMatch]
     numeric_precision: Optional[int] = None

{datamasque_python-1.2.5 → datamasque_python-1.3.1}/pyproject.toml

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

{datamasque_python-1.2.5 → datamasque_python-1.3.1}/tests/test_connections.py

@@ -7,6 +7,7 @@ from datamasque.client.exceptions import DataMasqueApiError, DataMasqueException
 from datamasque.client.models.connection import (
     AzureConnectionConfig,
     ConnectionId,
+    CosmosDbConnectionConfig,
     DatabaseConnectionConfig,
     DatabaseType,
     DatabricksConnectionConfig,
@@ -1360,17 +1361,85 @@ def test_connection_config_dispatch_picks_documentdb_subclass():
     assert conn.database_type is DatabaseType.documentdb
 
 
-def test_database_connection_config_rejects_mongodb_database_type():
-    """`DatabaseConnectionConfig` is for SQL engines; MongoDB users must use `MongoConnectionConfig`."""
-    with pytest.raises(ValueError, match="For MongoDB"):
+def _cosmosdb_connection(**overrides) -> CosmosDbConnectionConfig:
+    """Build a Cosmos DB config, leaving the port to the connection type's own default."""
+    return CosmosDbConnectionConfig(
+        name="cosmos",
+        host="dtq-cosmos.mongo.cosmos.azure.com",
+        database="people",
+        user="dtq-cosmos",
+        password="hunter2",
+        **overrides,
+    )
+
+
+def test_cosmosdb_connection_defaults_port_tls_and_retry_writes():
+    """
+    Cosmos DB listens on 10255, only accepts TLS connections and rejects retryable writes.
+
+    The config carries all three as defaults. `tls` and `retry_writes` are omitted from the payload
+    because the server defaults the same way for this connection type; the port is always sent.
+    """
+    conn = _cosmosdb_connection()
+    d = conn.model_dump(exclude_none=True, by_alias=True, mode="json")
+    assert d["db_type"] == "cosmosdb"
+    assert d["mask_type"] == "database"
+    assert conn.port == 10255
+    assert d["port"] == 10255
+    assert conn.tls is True
+    assert conn.retry_writes is False
+    assert "tls" not in d
+    assert "retry_writes" not in d
+    assert conn.database_type is DatabaseType.cosmosdb
+
+
+def test_cosmosdb_connection_sends_values_that_differ_from_its_own_defaults():
+    """
+    The Mongo serializer prunes a field whose value matches the default the server would apply.
+
+    Cosmos DB inverts two of MongoDB's defaults, so pruning against MongoDB's would drop exactly
+    the value the caller set and leave the server applying the opposite.
+    """
+    d = _cosmosdb_connection(tls=False, retry_writes=True).model_dump(exclude_none=True, by_alias=True, mode="json")
+    assert d["tls"] is False
+    assert d["retry_writes"] is True
+
+
+def test_connection_config_dispatch_picks_cosmosdb_subclass():
+    payload = {
+        "id": "cosmos-id-1",
+        "name": "cosmos",
+        "mask_type": "database",
+        "db_type": "cosmosdb",
+        "host": "dtq-cosmos.mongo.cosmos.azure.com",
+        "database": "people",
+    }
+    conn = validate_connection(payload)
+    assert isinstance(conn, CosmosDbConnectionConfig)
+    assert conn.database_type is DatabaseType.cosmosdb
+
+
+@pytest.mark.parametrize(
+    ("database_type", "message"),
+    [
+        (DatabaseType.mongodb, "For MongoDB"),
+        (DatabaseType.documentdb, "For AWS DocumentDB"),
+        (DatabaseType.cosmosdb, "For Azure Cosmos DB"),
+    ],
+)
+def test_database_connection_config_rejects_document_store_database_types(
+    database_type: DatabaseType, message: str
+) -> None:
+    """`DatabaseConnectionConfig` is for SQL engines; each document store has its own class."""
+    with pytest.raises(ValueError, match=message):
         DatabaseConnectionConfig(
-            name="mongo",
-            host="mongo.example",
+            name="doc-store",
+            host="doc-store.example",
             port=27017,
             database="people",
             user="alice",
             password="hunter2",
-            database_type=DatabaseType.mongodb,
+            database_type=database_type,
         )
 
 

{datamasque_python-1.2.5 → datamasque_python-1.3.1}/tests/test_discovery.py

@@ -21,6 +21,7 @@ from datamasque.client import (
     FileRulesetGenerationRequest,
     FileRulesetGenerationWithRGConfigRequest,
     InDataDiscoveryConfig,
+    LengthUnit,
     RGConfig,
     RGConfigId,
     RulesetGenerationRequest,
@@ -795,6 +796,22 @@ def test_schema_discovery_result_parses_safe_data_preview():
     assert preview.statistics_common.count_distinct == 988
 
 
+def test_schema_discovery_result_parses_max_length_unit() -> None:
+    row = _schema_discovery_row(1, "name")
+    row["data"]["max_length"] = 10
+    row["data"]["max_length_unit"] = "bytes"
+    result = SchemaDiscoveryResult.model_validate(row)
+    assert result.data.max_length == 10
+    assert result.data.max_length_unit is LengthUnit.bytes
+
+
+def test_schema_discovery_result_without_max_length_unit_is_none() -> None:
+    row = _schema_discovery_row(1, "name")
+    assert "max_length_unit" not in row["data"]
+    result = SchemaDiscoveryResult.model_validate(row)
+    assert result.data.max_length_unit is None
+
+
 def test_list_schema_discovery_results_follows_pagination(client):
     run_id = RunId(42)
     page1 = {

{datamasque_python-1.2.5 → datamasque_python-1.3.1}/uv.lock

@@ -419,7 +419,7 @@ toml = [
 
 [[package]]
 name = "datamasque-python"
-version = "1.2.5"
+version = "1.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "pydantic" },