add terminology substitutions: full CRUD against /terminology-substitutions

src/gradient_labs/__init__.py

@@ -14,3 +14,4 @@
 from .secret import *
 from .tool import *
 from .topic import *
+from .terminology_substitution import *

src/gradient_labs/_terminology_substitution_create.py

@@ -0,0 +1,35 @@
+from typing import Optional, Dict, Any
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json
+
+from ._http_client import HttpClient
+from .terminology_substitution import TerminologySubstitution
+
+
+@dataclass_json
+@dataclass(frozen=True)
+class TerminologySubstitutionCreateParams:
+    blocked: str
+    blocked_description: str
+    replacement: str
+    resource_type_id: Optional[str] = None
+    resource_attribute_json_path: Optional[str] = None
+    resource_value_to_match: Optional[str] = None
+
+
+def create_terminology_substitution(
+    *, client: HttpClient, params: TerminologySubstitutionCreateParams
+) -> TerminologySubstitution:
+    body: Dict[str, Any] = {
+        "blocked": params.blocked,
+        "blocked_description": params.blocked_description,
+        "replacement": params.replacement,
+    }
+    if params.resource_type_id is not None:
+        body["resource_type_id"] = params.resource_type_id
+    if params.resource_attribute_json_path is not None:
+        body["resource_attribute_json_path"] = params.resource_attribute_json_path
+    if params.resource_value_to_match is not None:
+        body["resource_value_to_match"] = params.resource_value_to_match
+    rsp = client.post(path="terminology-substitutions", body=body)
+    return TerminologySubstitution.from_dict(rsp)

src/gradient_labs/_terminology_substitution_delete.py

@@ -0,0 +1,7 @@
+from ._http_client import HttpClient
+
+
+def delete_terminology_substitution(
+    *, client: HttpClient, substitution_id: str
+) -> None:
+    client.delete(path=f"terminology-substitutions/{substitution_id}", body={})

src/gradient_labs/_terminology_substitution_read.py

@@ -0,0 +1,9 @@
+from ._http_client import HttpClient
+from .terminology_substitution import TerminologySubstitution
+
+
+def read_terminology_substitution(
+    *, client: HttpClient, substitution_id: str
+) -> TerminologySubstitution:
+    rsp = client.get(path=f"terminology-substitutions/{substitution_id}", body={})
+    return TerminologySubstitution.from_dict(rsp)

src/gradient_labs/_terminology_substitution_update.py

@@ -0,0 +1,38 @@
+from typing import Optional, Dict, Any
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json
+
+from ._http_client import HttpClient
+from .terminology_substitution import TerminologySubstitution
+
+
+@dataclass_json
+@dataclass(frozen=True)
+class TerminologySubstitutionUpdateParams:
+    blocked: str
+    blocked_description: str
+    replacement: str
+    resource_type_id: Optional[str] = None
+    resource_attribute_json_path: Optional[str] = None
+    resource_value_to_match: Optional[str] = None
+
+
+def update_terminology_substitution(
+    *,
+    client: HttpClient,
+    substitution_id: str,
+    params: TerminologySubstitutionUpdateParams,
+) -> TerminologySubstitution:
+    body: Dict[str, Any] = {
+        "blocked": params.blocked,
+        "blocked_description": params.blocked_description,
+        "replacement": params.replacement,
+    }
+    if params.resource_type_id is not None:
+        body["resource_type_id"] = params.resource_type_id
+    if params.resource_attribute_json_path is not None:
+        body["resource_attribute_json_path"] = params.resource_attribute_json_path
+    if params.resource_value_to_match is not None:
+        body["resource_value_to_match"] = params.resource_value_to_match
+    rsp = client.put(path=f"terminology-substitutions/{substitution_id}", body=body)
+    return TerminologySubstitution.from_dict(rsp)

src/gradient_labs/_terminology_substitutions_list.py

@@ -0,0 +1,11 @@
+from typing import List
+
+from ._http_client import HttpClient
+from .terminology_substitution import TerminologySubstitution
+
+
+def list_terminology_substitutions(
+    *, client: HttpClient
+) -> List[TerminologySubstitution]:
+    rsp = client.get(path="terminology-substitutions", body={})
+    return [TerminologySubstitution.from_dict(item) for item in rsp]

src/gradient_labs/client.py

@@ -117,6 +117,19 @@
 )
 from ._back_office_task_read import read_back_office_task
 
+from .terminology_substitution import TerminologySubstitution
+from ._terminology_substitution_create import (
+    create_terminology_substitution,
+    TerminologySubstitutionCreateParams,
+)
+from ._terminology_substitutions_list import list_terminology_substitutions
+from ._terminology_substitution_read import read_terminology_substitution
+from ._terminology_substitution_update import (
+    update_terminology_substitution,
+    TerminologySubstitutionUpdateParams,
+)
+from ._terminology_substitution_delete import delete_terminology_substitution
+
 from ._http_client import HttpClient, API_BASE_URL
 from .tool import *
 from .note import Note
@@ -836,3 +849,54 @@ def read_back_office_task(self, *, task_id: str) -> BackOfficeTask:
             client=self.http_client,
             task_id=task_id,
         )
+
+    # ==================== Terminology Substitution Operations ====================
+
+    def create_terminology_substitution(
+        self, *, params: TerminologySubstitutionCreateParams
+    ) -> TerminologySubstitution:
+        """create_terminology_substitution creates a new terminology substitution.
+
+        Note: requires a `Management` API key."""
+        return create_terminology_substitution(
+            client=self.http_client,
+            params=params,
+        )
+
+    def list_terminology_substitutions(self) -> List[TerminologySubstitution]:
+        """list_terminology_substitutions returns all terminology substitutions.
+
+        Note: requires a `Management` API key."""
+        return list_terminology_substitutions(client=self.http_client)
+
+    def read_terminology_substitution(
+        self, *, substitution_id: str
+    ) -> TerminologySubstitution:
+        """read_terminology_substitution retrieves a terminology substitution by ID.
+
+        Note: requires a `Management` API key."""
+        return read_terminology_substitution(
+            client=self.http_client,
+            substitution_id=substitution_id,
+        )
+
+    def update_terminology_substitution(
+        self, *, substitution_id: str, params: TerminologySubstitutionUpdateParams
+    ) -> TerminologySubstitution:
+        """update_terminology_substitution updates an existing terminology substitution.
+
+        Note: requires a `Management` API key."""
+        return update_terminology_substitution(
+            client=self.http_client,
+            substitution_id=substitution_id,
+            params=params,
+        )
+
+    def delete_terminology_substitution(self, *, substitution_id: str) -> None:
+        """delete_terminology_substitution permanently deletes a terminology substitution.
+
+        Note: requires a `Management` API key."""
+        delete_terminology_substitution(
+            client=self.http_client,
+            substitution_id=substitution_id,
+        )

src/gradient_labs/terminology_substitution.py

@@ -0,0 +1,31 @@
+from typing import Optional
+from datetime import datetime
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json, config
+from marshmallow import fields
+
+
+@dataclass_json
+@dataclass(frozen=True)
+class TerminologySubstitution:
+    id: str
+    blocked: str
+    blocked_description: str
+    replacement: str
+    created: datetime = field(
+        metadata=config(
+            encoder=datetime.isoformat,
+            decoder=datetime.fromisoformat,
+            mm_field=fields.DateTime(format="iso"),
+        )
+    )
+    updated: datetime = field(
+        metadata=config(
+            encoder=datetime.isoformat,
+            decoder=datetime.fromisoformat,
+            mm_field=fields.DateTime(format="iso"),
+        )
+    )
+    resource_type_id: Optional[str] = None
+    resource_attribute_json_path: Optional[str] = None
+    resource_value_to_match: Optional[str] = None