datamaker-py 0.7.0__tar.gz → 0.9.0__tar.gz

{datamaker_py-0.7.0 → datamaker_py-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamaker-py
-Version: 0.7.0
+Version: 0.9.0
 Summary: The official Python library for the Automators DataMaker API.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{datamaker_py-0.7.0 → datamaker_py-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "datamaker-py"
-version = "0.7.0"
+version = "0.9.0"
 description = "The official Python library for the Automators DataMaker API."
 readme = "README.md"
 requires-python = ">=3.11"

{datamaker_py-0.7.0 → datamaker_py-0.9.0}/src/datamaker/main.py

@@ -1,6 +1,6 @@
 import os
 from dotenv import load_dotenv
-from typing import Optional, Dict
+from typing import Optional, Dict, List
 from .routes.base import BaseClient
 from .routes.generation import GenerationClient
 from .routes.templates import TemplatesClient
@@ -22,6 +22,9 @@ from .routes.folders_and_utils import (
 from .routes.export_and_validation import ExportClient, ValidationClient
 from .routes.scenario_files import ScenarioFilesClient
 from .routes.sets import SetsClient
+from .routes.plans import PlansClient
+from .routes.masking_policies import MaskingPoliciesClient
+from .routes.keymaps import KeyMapsClient
 
 load_dotenv()
 
@@ -70,6 +73,11 @@ class DataMaker:
             api_key, default_headers, base_url, verify
         )
         self._sets = SetsClient(api_key, default_headers, base_url, verify)
+        self._keymaps = KeyMapsClient(api_key, default_headers, base_url, verify)
+        self._plans = PlansClient(api_key, default_headers, base_url, verify)
+        self._masking_policies = MaskingPoliciesClient(
+            api_key, default_headers, base_url, verify
+        )
 
         # Maintain backward compatibility
         self.api_key = self._generation.api_key
@@ -793,8 +801,272 @@ class DataMaker:
             project_id=project_id,
         )
 
+    def get_keymaps(self, project_id: Optional[str] = None):
+        """List key maps for a project: one row per (mapName, object).
+
+        Args:
+            project_id: Optional project ID. Falls back to DATAMAKER_PROJECT_ID.
+
+        Returns:
+            A list of dictionaries with mapName, object, entryCount, updatedAt.
+        """
+        return self._keymaps.get_keymaps(project_id)
+
+    def keymap_put(
+        self,
+        map_name: str,
+        object: str,
+        entries: Dict[str, str],
+        run_id: Optional[str] = None,
+        project_id: Optional[str] = None,
+    ):
+        """Record old-to-new key mappings in a named key map (batch upsert).
+
+        Use after creating records in a target system to remember which source
+        key became which target key. Writing the same old key again overwrites
+        its new key. Batches are capped at 5000 entries per call.
+
+        Args:
+            map_name: Logical map name, e.g. "sap-material-migration".
+            object: The domain object type, e.g. "Material".
+            entries: Mapping of old key to new key.
+            run_id: Optional run/job id that minted these keys.
+            project_id: Optional project ID. Falls back to DATAMAKER_PROJECT_ID.
+
+        Returns:
+            A dictionary with mapName, object and upserted (count).
+
+        Example:
+            >>> dm = DataMaker()
+            >>> dm.keymap_put(
+            ...     "sap-material-migration",
+            ...     "Material",
+            ...     {"MAT-001": "700001", "MAT-002": "700002"},
+            ... )
+        """
+        return self._keymaps.keymap_put(
+            map_name=map_name,
+            object=object,
+            entries=entries,
+            run_id=run_id,
+            project_id=project_id,
+        )
+
+    def keymap_lookup(
+        self,
+        map_name: str,
+        object: str,
+        old_keys: List[str],
+        project_id: Optional[str] = None,
+    ):
+        """Translate source-system keys to target-system keys (batch lookup).
+
+        Use when generating or migrating data that references records migrated
+        earlier. Lookups are capped at 5000 keys per call.
+
+        Args:
+            map_name: The key map to look up in.
+            object: The domain object type, e.g. "Material".
+            old_keys: Source-system keys to translate.
+            project_id: Optional project ID. Falls back to DATAMAKER_PROJECT_ID.
+
+        Returns:
+            A dictionary with mappings (found) and missing (no mapping yet).
+
+        Example:
+            >>> dm = DataMaker()
+            >>> result = dm.keymap_lookup(
+            ...     "sap-material-migration", "Material", ["MAT-001", "MAT-999"]
+            ... )
+        """
+        return self._keymaps.keymap_lookup(
+            map_name=map_name,
+            object=object,
+            old_keys=old_keys,
+            project_id=project_id,
+        )
+
+    def get_keymap_entries(
+        self,
+        map_name: str,
+        object: Optional[str] = None,
+        page: int = 1,
+        page_size: int = 100,
+        project_id: Optional[str] = None,
+    ):
+        """Fetch a page of a key map's entries for inspection.
+
+        Args:
+            map_name: The key map to read.
+            object: Optional domain object type filter.
+            page: 1-based page number.
+            page_size: Entries per page (server-capped at 500).
+            project_id: Optional project ID. Falls back to DATAMAKER_PROJECT_ID.
+
+        Returns:
+            A dictionary with entries, total, page and pageSize.
+        """
+        return self._keymaps.get_keymap_entries(
+            map_name=map_name,
+            object=object,
+            page=page,
+            page_size=page_size,
+            project_id=project_id,
+        )
+
+    def delete_keymap(
+        self,
+        map_name: str,
+        object: Optional[str] = None,
+        project_id: Optional[str] = None,
+    ):
+        """Drop a key map (all its entries), optionally one object type only.
+
+        Args:
+            map_name: The key map to delete.
+            object: Optional domain object type to scope the delete to.
+            project_id: Optional project ID. Falls back to DATAMAKER_PROJECT_ID.
+
+        Returns:
+            Confirmation response with the deleted entry count.
+        """
+        return self._keymaps.delete_keymap(
+            map_name=map_name,
+            object=object,
+            project_id=project_id,
+        )
+
     # =================== PROPERTY ACCESS TO CLIENTS ===================
     # For advanced users who want direct access to specific clients
+
+    # =================== PLAN METHODS ===================
+    def get_plans(self):
+        """List the plans in the caller's active project.
+
+        Returns:
+            A list of plan dictionaries.
+        """
+        return self._plans.get_plans()
+
+    def get_plan(self, plan_id: str):
+        """Get a single plan by ID, including its full spec and history.
+
+        Args:
+            plan_id: The unique identifier of the plan.
+
+        Returns:
+            The plan dictionary.
+        """
+        return self._plans.get_plan(plan_id)
+
+    def update_plan(self, plan_id: str, **fields):
+        """Update a plan.
+
+        Args:
+            plan_id: The unique identifier of the plan.
+            **fields: Fields to change, e.g. title, summary, status.
+
+        Returns:
+            The updated plan dictionary.
+        """
+        return self._plans.update_plan(plan_id, **fields)
+
+    def delete_plan(self, plan_id: str):
+        """Delete a plan.
+
+        Args:
+            plan_id: The unique identifier of the plan.
+
+        Returns:
+            ``{"success": True}``. Note this differs from the other resources,
+            which answer ``{"message": ...}``.
+        """
+        return self._plans.delete_plan(plan_id)
+
+    # =================== MASKING POLICY METHODS ===================
+    def get_masking_policies(self, project_id: Optional[str] = None):
+        """Get the masking policies in the caller's project/team scope.
+
+        Args:
+            project_id: Optional project ID to scope the listing to. Falls back
+                to the DATAMAKER_PROJECT_ID env var.
+
+        Returns:
+            A list of masking policy dictionaries.
+        """
+        return self._masking_policies.get_masking_policies(project_id)
+
+    def get_masking_policy(self, policy_id: str):
+        """Get a single masking policy by ID.
+
+        Args:
+            policy_id: The unique identifier of the policy.
+
+        Returns:
+            The masking policy dictionary.
+        """
+        return self._masking_policies.get_masking_policy(policy_id)
+
+    def create_masking_policy(
+        self,
+        name: str,
+        fields,
+        description: Optional[str] = None,
+        consistent: Optional[bool] = None,
+        reversible: Optional[bool] = None,
+        key_map_name: Optional[str] = None,
+        project_id: Optional[str] = None,
+    ):
+        """Create a masking policy.
+
+        Args:
+            name: The policy name.
+            fields: The field rule list.
+            description: Optional description.
+            consistent: Same input masks to the same output. Omit to take the
+                API's default.
+            reversible: Record the mapping so masking can be reversed. Needs
+                key_map_name to be useful.
+            key_map_name: The KeyMap a reversible policy mints mappings into.
+            project_id: Project to create it in. Falls back to
+                DATAMAKER_PROJECT_ID.
+
+        Returns:
+            The created masking policy dictionary.
+        """
+        return self._masking_policies.create_masking_policy(
+            name=name,
+            fields=fields,
+            description=description,
+            consistent=consistent,
+            reversible=reversible,
+            key_map_name=key_map_name,
+            project_id=project_id,
+        )
+
+    def update_masking_policy(self, policy_id: str, **fields):
+        """Update a masking policy.
+
+        Args:
+            policy_id: The unique identifier of the policy.
+            **fields: Fields to change. Use API spellings, e.g. keyMapName.
+
+        Returns:
+            The updated masking policy dictionary.
+        """
+        return self._masking_policies.update_masking_policy(policy_id, **fields)
+
+    def delete_masking_policy(self, policy_id: str):
+        """Delete a masking policy.
+
+        Args:
+            policy_id: The unique identifier of the policy.
+
+        Returns:
+            ``{"message": "Masking policy deleted"}``.
+        """
+        return self._masking_policies.delete_masking_policy(policy_id)
+
     @property
     def generation(self):
         """Access to generation client."""
@@ -884,3 +1156,18 @@ class DataMaker:
     def sets(self):
         """Access to sets client."""
         return self._sets
+
+    @property
+    def keymaps(self):
+        """Access to key maps client."""
+        return self._keymaps
+
+    @property
+    def plans(self):
+        """Access to plans client."""
+        return self._plans
+
+    @property
+    def masking_policies(self):
+        """Access to masking policies client."""
+        return self._masking_policies

{datamaker_py-0.7.0 → datamaker_py-0.9.0}/src/datamaker/routes/__init__.py

@@ -13,6 +13,7 @@ from .folders_and_utils import TemplateFoldersClient, ShortcutsClient, FeedbackC
 from .export_and_validation import ExportClient, ValidationClient
 from .scenario_files import ScenarioFilesClient
 from .sets import SetsClient
+from .keymaps import KeyMapsClient
 
 __all__ = [
     "BaseClient",
@@ -34,4 +35,5 @@ __all__ = [
     "ValidationClient",
     "ScenarioFilesClient",
     "SetsClient",
+    "KeyMapsClient",
 ]

datamaker_py-0.9.0/src/datamaker/routes/keymaps.py

@@ -0,0 +1,221 @@
+"""Client for key map operations - old-to-new key mappings for migrations.
+
+A "key map" records which source-system key became which target-system key
+during a migration (e.g. legacy material number to new material number).
+Unlike a set (one JSON blob), every mapping is its own row on the server, so
+lookups are indexed and batch writes from parallel load workers are
+concurrency-safe. Entries are unique per (project, map name, object, old key)
+and the last write wins for the new key.
+"""
+
+import os
+from typing import Dict, List, Optional
+from .base import BaseClient
+from ..error import DataMakerError
+
+
+class KeyMapsClient(BaseClient):
+    """Client for key map operations (old-to-new key mappings)."""
+
+    def get_keymaps(self, project_id: Optional[str] = None) -> List[Dict]:
+        """List key maps for a project: one row per (mapName, object).
+
+        Args:
+            project_id: Optional project ID to scope the listing to. Falls back
+                to the DATAMAKER_PROJECT_ID env var.
+
+        Returns:
+            A list of dictionaries with ``mapName``, ``object``, ``entryCount``
+            and ``updatedAt``.
+        """
+        project_id = project_id or os.environ.get("DATAMAKER_PROJECT_ID")
+
+        endpoint = "/keymaps"
+        if project_id:
+            endpoint += f"?projectId={project_id}"
+
+        response = self._make_request("GET", endpoint)
+        return response.json()
+
+    def keymap_put(
+        self,
+        map_name: str,
+        object: str,
+        entries: Dict[str, str],
+        run_id: Optional[str] = None,
+        project_id: Optional[str] = None,
+    ) -> Dict:
+        """Record old-to-new key mappings in a named key map (batch upsert).
+
+        Use after creating records in a target system to remember which source
+        key became which target key, so dependent data can reference the right
+        keys later. Writing the same old key again overwrites its new key.
+        Batches are capped at 5000 entries per call - page larger writes.
+
+        Args:
+            map_name: Logical map name grouping the entries, e.g.
+                "sap-material-migration".
+            object: The domain object type the keys belong to, e.g. "Material"
+                or "BusinessPartner".
+            entries: Mapping of old key to new key.
+            run_id: Optional run/job id that minted these keys.
+            project_id: Optional project ID. Falls back to DATAMAKER_PROJECT_ID.
+
+        Returns:
+            A dictionary with ``mapName``, ``object`` and ``upserted`` (count).
+
+        Raises:
+            DataMakerError: If ``map_name``, ``object`` or ``entries`` is empty.
+
+        Example:
+            >>> dm = DataMaker()
+            >>> dm.keymap_put(
+            ...     "sap-material-migration",
+            ...     "Material",
+            ...     {"MAT-001": "700001", "MAT-002": "700002"},
+            ... )
+        """
+        if not map_name:
+            raise DataMakerError("map_name is required to put key map entries.")
+        if not object:
+            raise DataMakerError("object is required to put key map entries.")
+        if not entries:
+            raise DataMakerError("entries must not be empty.")
+
+        project_id = project_id or os.environ.get("DATAMAKER_PROJECT_ID")
+
+        payload: Dict = {
+            "mapName": map_name,
+            "object": object,
+            "entries": [
+                {"oldKey": old_key, "newKey": new_key}
+                for old_key, new_key in entries.items()
+            ],
+        }
+        if run_id is not None:
+            payload["runId"] = run_id
+        if project_id:
+            payload["projectId"] = project_id
+
+        response = self._make_request("POST", "/keymaps/entries", json=payload)
+        return response.json()
+
+    def keymap_lookup(
+        self,
+        map_name: str,
+        object: str,
+        old_keys: List[str],
+        project_id: Optional[str] = None,
+    ) -> Dict:
+        """Translate source-system keys to target-system keys (batch lookup).
+
+        Use when generating or migrating data that references records migrated
+        earlier (e.g. orders that need the NEW material numbers for OLD ones).
+        Lookups are capped at 5000 keys per call - page larger reads.
+
+        Args:
+            map_name: The key map to look up in.
+            object: The domain object type, e.g. "Material".
+            old_keys: Source-system keys to translate.
+            project_id: Optional project ID. Falls back to DATAMAKER_PROJECT_ID.
+
+        Returns:
+            A dictionary with ``mappings`` (old key to new key for the keys
+            that were found) and ``missing`` (keys with no mapping yet).
+
+        Raises:
+            DataMakerError: If ``map_name``, ``object`` or ``old_keys`` is empty.
+
+        Example:
+            >>> dm = DataMaker()
+            >>> result = dm.keymap_lookup(
+            ...     "sap-material-migration", "Material", ["MAT-001", "MAT-999"]
+            ... )
+            >>> result["mappings"]
+            {'MAT-001': '700001'}
+            >>> result["missing"]
+            ['MAT-999']
+        """
+        if not map_name:
+            raise DataMakerError("map_name is required to look up key mappings.")
+        if not object:
+            raise DataMakerError("object is required to look up key mappings.")
+        if not old_keys:
+            raise DataMakerError("old_keys must not be empty.")
+
+        project_id = project_id or os.environ.get("DATAMAKER_PROJECT_ID")
+
+        payload: Dict = {
+            "mapName": map_name,
+            "object": object,
+            "oldKeys": old_keys,
+        }
+        if project_id:
+            payload["projectId"] = project_id
+
+        response = self._make_request("POST", "/keymaps/lookup", json=payload)
+        return response.json()
+
+    def get_keymap_entries(
+        self,
+        map_name: str,
+        object: Optional[str] = None,
+        page: int = 1,
+        page_size: int = 100,
+        project_id: Optional[str] = None,
+    ) -> Dict:
+        """Fetch a page of a key map's entries for inspection.
+
+        Args:
+            map_name: The key map to read.
+            object: Optional domain object type filter.
+            page: 1-based page number.
+            page_size: Entries per page (server-capped at 500).
+            project_id: Optional project ID. Falls back to DATAMAKER_PROJECT_ID.
+
+        Returns:
+            A dictionary with ``entries``, ``total``, ``page`` and ``pageSize``.
+        """
+        project_id = project_id or os.environ.get("DATAMAKER_PROJECT_ID")
+
+        params = [f"page={page}", f"pageSize={page_size}"]
+        if object:
+            params.append(f"object={object}")
+        if project_id:
+            params.append(f"projectId={project_id}")
+
+        endpoint = f"/keymaps/{map_name}/entries?" + "&".join(params)
+        response = self._make_request("GET", endpoint)
+        return response.json()
+
+    def delete_keymap(
+        self,
+        map_name: str,
+        object: Optional[str] = None,
+        project_id: Optional[str] = None,
+    ) -> Dict:
+        """Drop a key map (all its entries).
+
+        Args:
+            map_name: The key map to delete.
+            object: Optional domain object type - when given, only that
+                object's entries are dropped.
+            project_id: Optional project ID. Falls back to DATAMAKER_PROJECT_ID.
+
+        Returns:
+            Confirmation response with the deleted entry count.
+        """
+        project_id = project_id or os.environ.get("DATAMAKER_PROJECT_ID")
+
+        params = []
+        if object:
+            params.append(f"object={object}")
+        if project_id:
+            params.append(f"projectId={project_id}")
+
+        endpoint = f"/keymaps/{map_name}"
+        if params:
+            endpoint += "?" + "&".join(params)
+
+        response = self._make_request("DELETE", endpoint)
+        return response.json()

datamaker_py-0.9.0/src/datamaker/routes/masking_policies.py

@@ -0,0 +1,130 @@
+"""Client for masking policy operations.
+
+A masking policy is the set of field rules a masked generation or export
+applies. Two flags decide how it behaves, and they are easy to confuse:
+
+``consistent``
+    The same input masks to the same output within the policy, so joins across
+    masked tables still line up.
+
+``reversible``
+    The mapping is recorded so it can be reversed later. A reversible policy
+    mints its mappings into the KeyMap named by ``key_map_name``, which is why
+    that argument only means anything alongside it.
+"""
+
+import os
+from typing import Any, Dict, List, Optional
+
+from .base import BaseClient
+
+
+class MaskingPoliciesClient(BaseClient):
+    """Client for masking policy operations."""
+
+    def get_masking_policies(
+        self, project_id: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """Fetch the masking policies in the caller's project/team scope.
+
+        Args:
+            project_id: Optional project ID to scope the listing to. Falls back
+                to the DATAMAKER_PROJECT_ID env var.
+
+        Returns:
+            A list of masking policy dictionaries.
+        """
+        project_id = project_id or os.environ.get("DATAMAKER_PROJECT_ID")
+
+        endpoint = "/masking-policies"
+        if project_id:
+            endpoint += f"?projectId={project_id}"
+
+        response = self._make_request("GET", endpoint)
+        return response.json()
+
+    def get_masking_policy(self, policy_id: str) -> Dict[str, Any]:
+        """Get a single masking policy by ID.
+
+        Args:
+            policy_id: The policy's ID.
+
+        Returns:
+            The masking policy dictionary.
+        """
+        response = self._make_request("GET", f"/masking-policies/{policy_id}")
+        return response.json()
+
+    def create_masking_policy(
+        self,
+        name: str,
+        fields: Any,
+        description: Optional[str] = None,
+        consistent: Optional[bool] = None,
+        reversible: Optional[bool] = None,
+        key_map_name: Optional[str] = None,
+        project_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a masking policy.
+
+        Args:
+            name: The policy name.
+            fields: The field rule list. Shape varies by rule type.
+            description: Optional description.
+            consistent: Same input masks to the same output. Defaults to the
+                API's own default (True) when omitted.
+            reversible: Record the mapping so masking can be reversed. Requires
+                ``key_map_name`` to be useful.
+            key_map_name: The KeyMap a reversible policy mints mappings into.
+            project_id: Project to create it in. Falls back to
+                DATAMAKER_PROJECT_ID.
+
+        Returns:
+            The created masking policy dictionary.
+        """
+        project_id = project_id or os.environ.get("DATAMAKER_PROJECT_ID")
+
+        # Only send what the caller set: omitting a key lets the API apply its
+        # own default, whereas sending null would override it.
+        payload: Dict[str, Any] = {"name": name, "fields": fields}
+        if description is not None:
+            payload["description"] = description
+        if consistent is not None:
+            payload["consistent"] = consistent
+        if reversible is not None:
+            payload["reversible"] = reversible
+        if key_map_name is not None:
+            payload["keyMapName"] = key_map_name
+        if project_id:
+            payload["projectId"] = project_id
+
+        response = self._make_request("POST", "/masking-policies", json=payload)
+        return response.json()
+
+    def update_masking_policy(self, policy_id: str, **fields: Any) -> Dict[str, Any]:
+        """Update a masking policy.
+
+        Args:
+            policy_id: The policy's ID.
+            **fields: Fields to change. Use API spellings for multi-word keys,
+                e.g. ``keyMapName``.
+
+        Returns:
+            The updated masking policy dictionary.
+        """
+        response = self._make_request(
+            "PATCH", f"/masking-policies/{policy_id}", json=fields
+        )
+        return response.json()
+
+    def delete_masking_policy(self, policy_id: str) -> Dict[str, Any]:
+        """Delete a masking policy.
+
+        Args:
+            policy_id: The policy's ID.
+
+        Returns:
+            ``{"message": "Masking policy deleted"}``.
+        """
+        response = self._make_request("DELETE", f"/masking-policies/{policy_id}")
+        return response.json()

datamaker_py-0.9.0/src/datamaker/routes/plans.py

@@ -0,0 +1,72 @@
+"""Client for Plan operations.
+
+A Plan is a reviewable description of work the agent (or a person) intends to
+carry out: which entities, which targets, how many rows, and against which
+environment. Plans are the governed path - they are authored, reviewed and only
+then run - which is why this client covers authoring and inspection rather than
+execution.
+
+The plan RUN endpoints (`/plans/{id}/run`, `/runs`, `/signoffs`) are not wrapped
+yet: they carry artifacts, logs and multi-step state, and their response shapes
+are not described in the API's OpenAPI document at the time of writing. Use
+``client.plans._make_request`` or add them here once the API types them.
+"""
+
+from typing import Any, Dict, List
+
+from .base import BaseClient
+
+
+class PlansClient(BaseClient):
+    """Client for plan operations."""
+
+    def get_plans(self) -> List[Dict[str, Any]]:
+        """List the plans in the caller's active project.
+
+        Returns:
+            A list of plan dictionaries, newest first.
+        """
+        response = self._make_request("GET", "/plans")
+        return response.json()
+
+    def get_plan(self, plan_id: str) -> Dict[str, Any]:
+        """Get a single plan by ID, including its full ``spec`` and ``history``.
+
+        Args:
+            plan_id: The plan's ID.
+
+        Returns:
+            The plan dictionary.
+        """
+        response = self._make_request("GET", f"/plans/{plan_id}")
+        return response.json()
+
+    def update_plan(self, plan_id: str, **fields: Any) -> Dict[str, Any]:
+        """Update a plan.
+
+        Args:
+            plan_id: The plan's ID.
+            **fields: Fields to change, e.g. ``title``, ``summary``, ``status``.
+
+        Returns:
+            The updated plan dictionary.
+        """
+        response = self._make_request("PATCH", f"/plans/{plan_id}", json=fields)
+        return response.json()
+
+    def delete_plan(self, plan_id: str) -> Dict[str, Any]:
+        """Delete a plan.
+
+        Note:
+            This endpoint answers ``{"success": true}``, unlike the other
+            resources, which answer ``{"message": ...}``. Returned as-is rather
+            than normalised, so the SDK reports what the API actually sent.
+
+        Args:
+            plan_id: The plan's ID.
+
+        Returns:
+            ``{"success": True}``.
+        """
+        response = self._make_request("DELETE", f"/plans/{plan_id}")
+        return response.json()

{datamaker_py-0.7.0 → datamaker_py-0.9.0}/src/datamaker_py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamaker-py
-Version: 0.7.0
+Version: 0.9.0
 Summary: The official Python library for the Automators DataMaker API.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{datamaker_py-0.7.0 → datamaker_py-0.9.0}/src/datamaker_py.egg-info/SOURCES.txt

@@ -14,6 +14,9 @@ src/datamaker/routes/custom_types.py
 src/datamaker/routes/export_and_validation.py
 src/datamaker/routes/folders_and_utils.py
 src/datamaker/routes/generation.py
+src/datamaker/routes/keymaps.py
+src/datamaker/routes/masking_policies.py
+src/datamaker/routes/plans.py
 src/datamaker/routes/projects.py
 src/datamaker/routes/scenario_files.py
 src/datamaker/routes/sets.py

{datamaker_py-0.7.0 → datamaker_py-0.9.0}/tests/test_routes.py

@@ -12,6 +12,7 @@ from src.datamaker.routes.projects import ProjectsClient
 from src.datamaker.routes.users import UsersClient
 from src.datamaker.routes.teams import TeamsClient, TeamMembersClient
 from src.datamaker.routes.sets import SetsClient
+from src.datamaker.routes.keymaps import KeyMapsClient
 from src.datamaker.routes.custom_types import EndpointsClient
 from src.datamaker.error import DataMakerError
 
@@ -690,3 +691,134 @@ class TestEndpointsClient:
         )
         assert result["authType"] == "Basic"
         assert result["basic"]["username"] == "user"
+
+class TestKeyMapsClient:
+    """Test cases for the KeyMapsClient class."""
+
+    @patch("src.datamaker.routes.base.BaseClient._make_request")
+    def test_get_keymaps_with_project_id(self, mock_make_request, api_key):
+        """Test listing key maps scoped to a project id."""
+        mock_response = Mock()
+        mock_response.json.return_value = [
+            {"mapName": "m1", "object": "Material", "entryCount": 2}
+        ]
+        mock_make_request.return_value = mock_response
+
+        client = KeyMapsClient(api_key=api_key)
+        result = client.get_keymaps(project_id="proj-1")
+
+        mock_make_request.assert_called_once_with("GET", "/keymaps?projectId=proj-1")
+        assert result == [{"mapName": "m1", "object": "Material", "entryCount": 2}]
+
+    @patch("src.datamaker.routes.base.BaseClient._make_request")
+    def test_keymap_put(self, mock_make_request, api_key):
+        """Test batch-upserting key map entries."""
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "mapName": "sap-material-migration",
+            "object": "Material",
+            "upserted": 2,
+        }
+        mock_make_request.return_value = mock_response
+
+        client = KeyMapsClient(api_key=api_key)
+        result = client.keymap_put(
+            "sap-material-migration",
+            "Material",
+            {"MAT-001": "700001", "MAT-002": "700002"},
+            run_id="run-1",
+            project_id="proj-1",
+        )
+
+        mock_make_request.assert_called_once_with(
+            "POST",
+            "/keymaps/entries",
+            json={
+                "mapName": "sap-material-migration",
+                "object": "Material",
+                "entries": [
+                    {"oldKey": "MAT-001", "newKey": "700001"},
+                    {"oldKey": "MAT-002", "newKey": "700002"},
+                ],
+                "runId": "run-1",
+                "projectId": "proj-1",
+            },
+        )
+        assert result["upserted"] == 2
+
+    @patch("src.datamaker.routes.base.BaseClient._make_request")
+    def test_keymap_put_requires_entries(self, mock_make_request, api_key):
+        """Test that an empty entries dict raises."""
+        client = KeyMapsClient(api_key=api_key)
+        with pytest.raises(DataMakerError):
+            client.keymap_put("m1", "Material", {})
+        mock_make_request.assert_not_called()
+
+    @patch("src.datamaker.routes.base.BaseClient._make_request")
+    def test_keymap_lookup(self, mock_make_request, api_key):
+        """Test batch key lookup returns mappings and missing keys."""
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "mapName": "m1",
+            "object": "Material",
+            "mappings": {"MAT-001": "700001"},
+            "missing": ["MAT-999"],
+        }
+        mock_make_request.return_value = mock_response
+
+        client = KeyMapsClient(api_key=api_key)
+        result = client.keymap_lookup(
+            "m1", "Material", ["MAT-001", "MAT-999"], project_id="proj-1"
+        )
+
+        mock_make_request.assert_called_once_with(
+            "POST",
+            "/keymaps/lookup",
+            json={
+                "mapName": "m1",
+                "object": "Material",
+                "oldKeys": ["MAT-001", "MAT-999"],
+                "projectId": "proj-1",
+            },
+        )
+        assert result["mappings"] == {"MAT-001": "700001"}
+        assert result["missing"] == ["MAT-999"]
+
+    @patch("src.datamaker.routes.base.BaseClient._make_request")
+    def test_get_keymap_entries(self, mock_make_request, api_key):
+        """Test paginated entry inspection with an object filter."""
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "mapName": "m1",
+            "page": 1,
+            "pageSize": 50,
+            "total": 1,
+            "entries": [{"object": "Material", "oldKey": "a", "newKey": "b"}],
+        }
+        mock_make_request.return_value = mock_response
+
+        client = KeyMapsClient(api_key=api_key)
+        result = client.get_keymap_entries(
+            "m1", object="Material", page=1, page_size=50, project_id="proj-1"
+        )
+
+        mock_make_request.assert_called_once_with(
+            "GET",
+            "/keymaps/m1/entries?page=1&pageSize=50&object=Material&projectId=proj-1",
+        )
+        assert result["total"] == 1
+
+    @patch("src.datamaker.routes.base.BaseClient._make_request")
+    def test_delete_keymap(self, mock_make_request, api_key):
+        """Test dropping a key map scoped to one object type."""
+        mock_response = Mock()
+        mock_response.json.return_value = {"message": "Key map deleted", "deleted": 5}
+        mock_make_request.return_value = mock_response
+
+        client = KeyMapsClient(api_key=api_key)
+        result = client.delete_keymap("m1", object="Material", project_id="proj-1")
+
+        mock_make_request.assert_called_once_with(
+            "DELETE", "/keymaps/m1?object=Material&projectId=proj-1"
+        )
+        assert result["deleted"] == 5