adaptive-sdk 0.1.0b1__tar.gz

adaptive_sdk-0.1.0b1/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: adaptive-sdk
+Version: 0.1.0b1
+Summary: Python SDK for Adaptive Engine
+Author-email: Vincent Debergue <vincent@adaptive-ml.com>, Joao Moura <joao@adaptive-ml.com>, Yacine Bouraoui <yacine@adaptive-ml.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx >= 0.27.2
+Requires-Dist: gql >= 3.5.0
+Requires-Dist: pydantic[email] >= 2.9.0
+Requires-Dist: pyhumps >= 3.8.0
+Requires-Dist: fastapi >= 0.115.8
+Requires-Dist: uvicorn >= 0.34.0
+Requires-Dist: jsonschema==4.24.0
+Requires-Dist: websockets==15.0.1
+Requires-Dist: types-jsonschema==4.23.0.20241208
+Requires-Dist: loguru >= 0.7.0
+Requires-Dist: ariadne-codegen ; extra == "dev"
+Requires-Dist: datamodel-code-generator == 0.31.2 ; extra == "dev"
+Requires-Dist: astor >= 0.8.1 ; extra == "dev"
+Requires-Dist: pdoc >= 15.0.1 ; extra == "dev"
+Requires-Dist: toml>=0.10.2 ; extra == "dev"
+Requires-Dist: black==25.1.0 ; extra == "dev"
+Requires-Dist: pytest==8.4.1 ; extra == "dev"
+Requires-Dist: pytest-asyncio==0.26.0 ; extra == "dev"
+Requires-Dist: mypy==1.16.0 ; extra == "dev"
+Requires-Dist: tenacity==9.1.2 ; extra == "dev"
+Provides-Extra: dev
+
+# adaptive-sdk
+
+The Python Client SDK for Adaptive Engine
+
+## Installation
+
+```bash
+pip install -e .
+
+```
+
+## Usage 
+
+```python
+from adaptive_sdk import Adaptive, AsyncAdaptive
+
+client = Adaptive("http://localhost:9000", "key-kitt")
+# aclient = AsyncAdaptive("http://localhost:9000", "key-kitt")  # all the same methods as Adaptive, but async
+
+try:
+    use_case = client.create_use_case(name="Open Assistant", key="open_assistant")
+    print(f"Use case created id={use_case.id} key={use_case.key}")
+except:
+    use_case = client.get_use_case("open_assistant")
+
+if use_case is None:
+    raise Exception("Could not get or create a use case")
+
+metrics = client.list_metrics()
+if not any(metric.key == "accepted" for metric in metrics):
+    client.create_metric(name="accepted", key="accepted", kind="BOOL")
+
+client.link_metric(use_case="open_assistant", metric="accepted")
+
+model_attached = any(srv.model.key == "minimal" for srv in use_case.model_services)
+if not model_attached:
+    client.attach_model(model="minimal", use_case="open_assistant", wait=False)
+
+response = client.add_interactions(
+        model="minimal",
+        use_case=str(use_case.id),
+        messages=[{"role":"user", "content":"Prompt here"}],
+        completion="Completion here",
+        feedbacks=[{"metric":"accepted", "value":1, "details":"This was a good completion"}],
+        ab_campaign=None,
+        labels={"country": "Argentina"},
+)
+print(f"Interaction stored completion_id={response.completion_id}")
+
+```
+
+## Development
+
+- Install dev dependencies
+
+```bash
+pip install -e '.[dev]'
+```
+
+- Download new REST/GQL schemas, generate types, and format the resulting files
+
+```bash
+CONCORDE_URL="http://localhost:9000"
+python generate_gql_pt_datamodel.py --base-url $CONCORDE_URL
+python generate_openapi_datamodel.py --base-url $CONCORDE_URL
+black src/adaptive_sdk/graphql_client
+black src/adaptive_sdk/rest
+```
+
+### How to add a new graphql query and/or new SDK methods/resources
+
+1. Add the query or mutation in the file `src/adaptive_sdk/queries.graphql` (if REST schema changed, no need to write queries)
+2. Regenerate graphql or REST types with the scripts above, depending on what has changed
+3. If new REST types have been added or renamed, make sure to export them in `src/adaptive_sdk/rest/__init__.py` for the automatic SDK reference docs generator to pick up on.
+3. Wrap the new queries/types in a nice, user-facing method respecting the existing naming conventions,
+within the appropriate resource in `src/adaptive_sdk/resources` (create a new resource if needed).
+4. If the input types for the new method are too complicated/nested, help the user by creating new TypedDict(s) and using them as input function parameter type hints, which enables nice suggestion for your new method, and self-documenting of methods. You can add these in `src/adaptive_sdk/input_types/typed_dicts.py`. If you add new typed dicts, make sure to export them in `src/adaptive_sdk/input_types/__init__.py`, so the automatic SDK reference docs generator picks up on them.
+5. If you create a new resource, make sure to export it in `src/adaptive_sdk/resources/__init__.py`, and then add it without disrupting the alphabetical order of resources
+in `src/adaptive_sdk/client.py`. Always add a new sync and async resource. 
+

adaptive_sdk-0.1.0b1/README.md

@@ -0,0 +1,79 @@
+# adaptive-sdk
+
+The Python Client SDK for Adaptive Engine
+
+## Installation
+
+```bash
+pip install -e .
+
+```
+
+## Usage 
+
+```python
+from adaptive_sdk import Adaptive, AsyncAdaptive
+
+client = Adaptive("http://localhost:9000", "key-kitt")
+# aclient = AsyncAdaptive("http://localhost:9000", "key-kitt")  # all the same methods as Adaptive, but async
+
+try:
+    use_case = client.create_use_case(name="Open Assistant", key="open_assistant")
+    print(f"Use case created id={use_case.id} key={use_case.key}")
+except:
+    use_case = client.get_use_case("open_assistant")
+
+if use_case is None:
+    raise Exception("Could not get or create a use case")
+
+metrics = client.list_metrics()
+if not any(metric.key == "accepted" for metric in metrics):
+    client.create_metric(name="accepted", key="accepted", kind="BOOL")
+
+client.link_metric(use_case="open_assistant", metric="accepted")
+
+model_attached = any(srv.model.key == "minimal" for srv in use_case.model_services)
+if not model_attached:
+    client.attach_model(model="minimal", use_case="open_assistant", wait=False)
+
+response = client.add_interactions(
+        model="minimal",
+        use_case=str(use_case.id),
+        messages=[{"role":"user", "content":"Prompt here"}],
+        completion="Completion here",
+        feedbacks=[{"metric":"accepted", "value":1, "details":"This was a good completion"}],
+        ab_campaign=None,
+        labels={"country": "Argentina"},
+)
+print(f"Interaction stored completion_id={response.completion_id}")
+
+```
+
+## Development
+
+- Install dev dependencies
+
+```bash
+pip install -e '.[dev]'
+```
+
+- Download new REST/GQL schemas, generate types, and format the resulting files
+
+```bash
+CONCORDE_URL="http://localhost:9000"
+python generate_gql_pt_datamodel.py --base-url $CONCORDE_URL
+python generate_openapi_datamodel.py --base-url $CONCORDE_URL
+black src/adaptive_sdk/graphql_client
+black src/adaptive_sdk/rest
+```
+
+### How to add a new graphql query and/or new SDK methods/resources
+
+1. Add the query or mutation in the file `src/adaptive_sdk/queries.graphql` (if REST schema changed, no need to write queries)
+2. Regenerate graphql or REST types with the scripts above, depending on what has changed
+3. If new REST types have been added or renamed, make sure to export them in `src/adaptive_sdk/rest/__init__.py` for the automatic SDK reference docs generator to pick up on.
+3. Wrap the new queries/types in a nice, user-facing method respecting the existing naming conventions,
+within the appropriate resource in `src/adaptive_sdk/resources` (create a new resource if needed).
+4. If the input types for the new method are too complicated/nested, help the user by creating new TypedDict(s) and using them as input function parameter type hints, which enables nice suggestion for your new method, and self-documenting of methods. You can add these in `src/adaptive_sdk/input_types/typed_dicts.py`. If you add new typed dicts, make sure to export them in `src/adaptive_sdk/input_types/__init__.py`, so the automatic SDK reference docs generator picks up on them.
+5. If you create a new resource, make sure to export it in `src/adaptive_sdk/resources/__init__.py`, and then add it without disrupting the alphabetical order of resources
+in `src/adaptive_sdk/client.py`. Always add a new sync and async resource. 

adaptive_sdk-0.1.0b1/pyproject.toml

@@ -0,0 +1,77 @@
+[build-system]
+requires = ["flit_core>=3.4"]
+build-backend = "flit_core.buildapi"
+
+
+[project]
+name = "adaptive-sdk"
+version = "0.1.0b1"
+description = "Python SDK for Adaptive Engine"
+authors = [
+  { name = "Vincent Debergue", email = "vincent@adaptive-ml.com" },
+  { name = "Joao Moura", email = "joao@adaptive-ml.com" },
+  { name = "Yacine Bouraoui", email = "yacine@adaptive-ml.com" },
+
+]
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "httpx >= 0.27.2",
+  "gql >= 3.5.0",
+  "pydantic[email] >= 2.9.0",
+  "pyhumps >= 3.8.0",
+  "fastapi >= 0.115.8",
+  "uvicorn >= 0.34.0",
+  "jsonschema==4.24.0",
+  "websockets==15.0.1",
+  "types-jsonschema==4.23.0.20241208",
+  "loguru >= 0.7.0",
+]
+
+[project.optional-dependencies]
+dev = [
+  "ariadne-codegen",
+  "datamodel-code-generator == 0.31.2",
+  "astor >= 0.8.1",
+  "pdoc >= 15.0.1",
+  "toml>=0.10.2",
+  "black==25.1.0",
+  "pytest==8.4.1",
+  "pytest-asyncio==0.26.0",
+  "mypy==1.16.0",
+  "tenacity==9.1.2",
+]
+
+[tool.ariadne-codegen]
+schema_path = "schema.graphql"
+queries_path = "queries.graphql"
+target_package_name = "graphql_client"
+target_package_path = "src/adaptive_sdk"
+client_name = "GQLClient"
+async_client = false
+opentelemetry_client = true
+enable_custom_operations = true
+
+[tool.ariadne-codegen.scalars.IdOrKey]
+type = "str"
+[tool.ariadne-codegen.scalars.Timestamp]
+type = "int"
+[tool.ariadne-codegen.scalars.InputDatetime]
+type = "int | str"
+[tool.ariadne-codegen.scalars.TimestampSec]
+type = "int"
+
+[tool.mypy]
+# Ignore missing type hints in imported libraries
+ignore_missing_imports = true
+
+files = "src/adaptive_sdk"
+exclude = "src/adaptive_sdk/graphql_client/|src/adaptive_sdk/rest/"
+allow_redefinition = true
+
+
+[tool.black]
+required-version = '25.1.0'
+
+[tool.uv.sources]
+ariadne-codegen = { git = "https://github.com/adaptive-ml/ariadne-codegen", branch = "stabilise-output" }

adaptive_sdk-0.1.0b1/src/adaptive_sdk/__init__.py

@@ -0,0 +1,15 @@
+from .patch import *
+from .client import Adaptive, AsyncAdaptive
+from adaptive_sdk import resources, input_types, graphql_client, rest, external
+
+
+__version__ = "0.0.1b1"
+__all__ = [
+    "Adaptive",
+    "AsyncAdaptive",
+    "resources",
+    "input_types",
+    "graphql_client",
+    "rest",
+    "external",
+]

adaptive_sdk-0.1.0b1/src/adaptive_sdk/base_client.py

@@ -0,0 +1,133 @@
+from abc import ABC, abstractmethod
+import os
+from enum import Enum
+from typing import Optional, Dict
+import httpx
+from urllib.parse import urlparse
+
+from .graphql_client import GQLClient, AsyncGQLClient
+from .error_handling import graphql_multi_error_handler
+
+
+def get_version():
+    import importlib
+
+    return importlib.import_module("adaptive_sdk").__version__
+
+
+class Routes(Enum):
+    GQL = "/api/graphql"
+    REST = "/api/v1"
+
+
+def _get_api_key(api_key: Optional[str] = None) -> str:
+    if api_key:
+        return api_key
+
+    env_api_key = os.environ.get("ADAPTIVE_API_KEY")
+    if env_api_key:
+        return env_api_key
+
+    raise ValueError("API key not found. Please provide an API KEY or set ADAPTIVE_API_KEY environment variable.")
+
+
+def is_valid_url(url):
+    parsed_url = urlparse(url)
+    return bool(parsed_url.scheme) and bool(parsed_url.netloc)
+
+
+class BaseSyncClient:
+    def __init__(
+        self,
+        base_url: str,
+        api_key: Optional[str] = None,
+        default_headers: Dict[str, str] | None = None,
+        timeout_secs: float = 90.0,
+    ):
+        """
+        Construct a new synchronous client instance.
+        """
+        if not base_url:
+            raise ValueError("base_url must be provided")
+        else:
+            if is_valid_url(base_url):
+                base_url = base_url.rstrip("/")
+            else:
+                raise ValueError(
+                    f"Provided base_url {base_url} is invalid. It should be a well-formed url like https://api-adaptive-ml.com"
+                )
+
+        self.api_key = _get_api_key(api_key)
+        self.base_url = base_url
+        custom_headers = (default_headers or {}).copy()
+        headers = {
+            **custom_headers,
+            "Authorization": f"Bearer {self.api_key}",
+            "User-Agent": f"adaptive_sdk/{get_version()}",
+        }
+        self._gql_client = GQLClient(base_url + Routes.GQL.value, headers=headers)
+        self._gql_client.get_data = graphql_multi_error_handler(self._gql_client.get_data)  # type: ignore[method-assign]
+
+        timeout = httpx.Timeout(timeout=timeout_secs)
+
+        self._gql_client.http_client.timeout = timeout
+        self._rest_client = httpx.Client(headers=headers, base_url=base_url + Routes.REST.value, timeout=timeout)
+
+    def close(self) -> None:
+        self._rest_client.close()
+        self._gql_client.http_client.close()
+
+
+class BaseAsyncClient:
+    def __init__(
+        self,
+        base_url: str,
+        api_key: Optional[str] = None,
+        default_headers: Dict[str, str] | None = None,
+        timeout_secs: float = 90.0,
+    ):
+        """
+        Construct a new asynchronous client instance.
+        """
+        if not base_url:
+            raise ValueError("base_url must be provided")
+        else:
+            if is_valid_url(base_url):
+                base_url = base_url.rstrip("/")
+            else:
+                raise ValueError(
+                    f"Provided base_url {base_url} is invalid. It should be a well-formed url like https://api.adaptive-ml.com"
+                )
+
+        self.api_key = _get_api_key(api_key)
+        self.base_url = base_url
+        custom_headers = (default_headers or {}).copy()
+        headers = {
+            **custom_headers,
+            "Authorization": f"Bearer {self.api_key}",
+            "User-Agent": f"adaptive_sdk/{get_version()}",
+        }
+
+        self._gql_client = AsyncGQLClient(base_url + Routes.GQL.value, headers=headers)
+        self._gql_client.get_data = graphql_multi_error_handler(self._gql_client.get_data)  # type: ignore[method-assign]
+
+        timeout = httpx.Timeout(timeout=timeout_secs)
+        self._gql_client.http_client.timeout = timeout
+        self._rest_client = httpx.AsyncClient(headers=headers, base_url=base_url + Routes.REST.value, timeout=timeout)
+
+    async def close(self) -> None:
+        await self._rest_client.aclose()
+        await self._gql_client.http_client.aclose()
+
+
+class UseCaseClient(ABC):
+    @property
+    @abstractmethod
+    def default_use_case(self) -> str | None:
+        """Get the current default use case key."""
+        pass
+
+    @abstractmethod
+    def set_default_use_case(self, use_case: str) -> None:
+        """Set the default use case key."""
+        pass

adaptive_sdk-0.1.0b1/src/adaptive_sdk/client.py

@@ -0,0 +1,117 @@
+from typing import Dict
+from .base_client import BaseSyncClient, BaseAsyncClient, UseCaseClient
+from . import resources
+
+
+class Adaptive(BaseSyncClient, UseCaseClient):
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str | None = None,
+        default_headers: Dict[str, str] | None = None,
+    ) -> None:
+        """
+        Instantiates a new synchronous Adaptive client bounded to a use case.
+
+        Args:
+            use_case (str): A unique use case key; the client is bounded to this use case.
+            base_url (str): The base URL for the Adaptive API.
+            api_key (str, optional): API key for authentication.
+                Defaults to None, in which case environment variable `ADAPTIVE_API_KEY` needs to be set.
+
+        """
+        super().__init__(base_url, api_key, default_headers)
+        self.__use_case_key = None
+
+        self.ab_tests: resources.ABTests = resources.ABTests(self)
+        self.chat: resources.Chat = resources.Chat(self)
+        self.completions: resources.Completions = resources.Completions(self)
+        self.compute_pools: resources.ComputePools = resources.ComputePools(self)
+        self.custom_recipes: resources.CustomRecipes = resources.CustomRecipes(self)
+        self.datasets: resources.Datasets = resources.Datasets(self)
+        self.embeddings: resources.Embeddings = resources.Embeddings(self)
+        self.evaluation: resources.Evaluation = resources.Evaluation(self)
+        self.judges: resources.Judges = resources.Judges(self)
+        self.feedback: resources.Feedback = resources.Feedback(self)
+        self.interactions: resources.Interactions = resources.Interactions(self)
+        self.models: resources.Models = resources.Models(self)
+        self.permissions: resources.Permissions = resources.Permissions(self)
+        self.reward_servers: resources.RewardServers = resources.RewardServers(self)
+        self.roles: resources.Roles = resources.Roles(self)
+        self.teams: resources.Teams = resources.Teams(self)
+        self.training: resources.Training = resources.Training(self)
+        self.use_cases: resources.UseCase = resources.UseCase(self)
+        self.users: resources.Users = resources.Users(self)
+
+    @property
+    def default_use_case(self) -> str | None:
+        """
+        Get the current default use case key.
+        """
+        return self.__use_case_key
+
+    def set_default_use_case(self, use_case: str) -> None:
+        """
+        Set a default use case key to be used for use case-specific operations.
+        """
+        if not (isinstance(use_case, str) and bool(use_case.strip())):
+            raise ValueError("use_case must be a non-empty string")
+        self.__use_case_key = use_case  # type: ignore[assignment]
+
+
+class AsyncAdaptive(BaseAsyncClient, UseCaseClient):
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str | None = None,
+        default_headers: Dict[str, str] | None = None,
+    ) -> None:
+        """
+        Instantiates a new asynchronous Adaptive client bounded to a use case.
+
+        Args:
+            use_case (str): A unique use case key; the client is bounded to this use case.
+            base_url (str): The base URL for the Adaptive API.
+            api_key (str, optional): API key for authentication.
+                Defaults to None, in which case environment variable `ADAPTIVE_API_KEY` needs to be set.
+
+        """
+        super().__init__(base_url, api_key, default_headers)
+        self.__use_case_key = None
+
+        self.ab_tests: resources.AsyncABTests = resources.AsyncABTests(self)
+        self.chat: resources.AsyncChat = resources.AsyncChat(self)
+        self.completions: resources.AsyncCompletions = resources.AsyncCompletions(self)
+        self.compute_pools: resources.AsyncComputePools = resources.AsyncComputePools(self)
+        self.custom_recipes: resources.AsyncCustomRecipes = resources.AsyncCustomRecipes(self)
+        self.datasets: resources.AsyncDatasets = resources.AsyncDatasets(self)
+        self.embeddings: resources.AsyncEmbeddings = resources.AsyncEmbeddings(self)
+        self.evaluation: resources.AsyncEvaluation = resources.AsyncEvaluation(self)
+        self.judges: resources.AsyncJudges = resources.AsyncJudges(self)
+        self.feedback: resources.AsyncFeedback = resources.AsyncFeedback(self)
+        self.interactions: resources.AsyncInteractions = resources.AsyncInteractions(self)
+        self.models: resources.AsyncModels = resources.AsyncModels(self)
+        self.permissions: resources.AsyncPermissions = resources.AsyncPermissions(self)
+        self.reward_servers: resources.AsyncRewardServers = resources.AsyncRewardServers(self)
+        self.roles: resources.AsyncRoles = resources.AsyncRoles(self)
+        self.teams: resources.AsyncTeams = resources.AsyncTeams(self)
+        self.training: resources.AsyncTraining = resources.AsyncTraining(self)
+        self.use_cases: resources.AsyncUseCase = resources.AsyncUseCase(self)
+        self.users: resources.AsyncUsers = resources.AsyncUsers(self)
+
+    @property
+    def default_use_case(self) -> str | None:
+        """
+        Get the current default use case key.
+        """
+        return self.__use_case_key
+
+    def set_default_use_case(self, use_case: str) -> None:
+        """
+        Set a default use case key to be used for use case-specific operations.
+        """
+        if not isinstance(use_case, str):
+            raise TypeError("use_case must be a string")
+        if not use_case.strip():
+            raise ValueError("use_case cannot be empty or whitespace")
+        self.__use_case_key = use_case  # type: ignore[assignment]

adaptive_sdk-0.1.0b1/src/adaptive_sdk/error_handling.py

@@ -0,0 +1,86 @@
+import httpx
+from typing import Callable
+from pydantic import BaseModel
+from .graphql_client.exceptions import GraphQLClientGraphQLMultiError
+
+
+class EntityNotFoundDescriptor(BaseModel):
+    entity: str
+    error_message: str
+    code_suggestions: list[str]
+
+    def __post_init__(self):
+        if self.error_message.count("{}") != len(self.code_suggestions):
+            raise ValueError("# of code suggestions must match # of placeholders in error message template")
+
+
+class AdaptiveEntityNotFoundError(Exception):
+    def __init__(self, original_error: str):
+        self.entity_descriptors = [
+            EntityNotFoundDescriptor(
+                entity="use_case",
+                error_message="Use case key does not exist. You can create it with `{}`",
+                code_suggestions=["client.use_cases.create"],
+            ),
+            EntityNotFoundDescriptor(
+                entity="metric",
+                error_message="Feedback key does not exist, or is not linked to the target use case. You can create it with `{}` or link it with `{}`",
+                code_suggestions=[
+                    "client.feedback.register_key",
+                    "client.feedback.link",
+                ],
+            ),
+            EntityNotFoundDescriptor(
+                entity="model",
+                error_message="Model key does not exist, or is not attached to the target use case. You can attach it with `{}`",
+                code_suggestions=["client.models.attach"],
+            ),
+            EntityNotFoundDescriptor(entity="user", error_message="User does not exist.", code_suggestions=[]),
+        ]
+
+        new_error_message = None
+        for descriptor in self.entity_descriptors:
+            if descriptor.entity in original_error.lower():
+                new_error_message = descriptor.error_message.format(*descriptor.code_suggestions)
+                break
+
+        super().__init__(new_error_message or original_error)
+
+
+def adaptive_error_message_triage(error_message: str) -> Callable | None:
+    if "EntityNotFound:" in error_message:
+        return AdaptiveEntityNotFoundError
+    else:
+        return None
+
+
+def graphql_multi_error_handler(fn: Callable) -> Callable:
+    def wrapper(*args, **kwargs):
+        try:
+            return fn(*args, **kwargs)
+        except GraphQLClientGraphQLMultiError as e:
+            error_message = str(e.errors[0])
+            exception_type = adaptive_error_message_triage(error_message)
+            if exception_type is not None:
+                raise exception_type(error_message)
+            else:
+                raise
+
+    return wrapper
+
+
+def rest_error_handler(response: httpx.Response):
+    if response.is_client_error:
+        try:
+            response_json = response.json()
+            error_message = response_json.get("error", f"Unknown error: {response.text}")
+            exception_type = adaptive_error_message_triage(error_message)
+            if exception_type is not None:
+                raise exception_type(error_message)
+            else:
+                raise Exception(f"Client error {response.status_code}: {error_message}")
+        except Exception:
+            # Handle any exception when processing the response
+            raise Exception(f"Client error {response.status_code}: {response.text}")
+    else:
+        response.raise_for_status()

adaptive_sdk-0.1.0b1/src/adaptive_sdk/external/__init__.py

@@ -0,0 +1,24 @@
+from .reward_client import RewardClient
+from .reward_server import RewardServer, EmptyMetadata
+from .reward_types import (
+    Request,
+    ValidatedRequest,
+    Response,
+    BatchedRequest,
+    BatchedResponse,
+    ServerInfo,
+    Turn,
+)
+
+__all__ = [
+    "RewardClient",
+    "RewardServer",
+    "EmptyMetadata",
+    "ValidatedRequest",
+    "Request",
+    "Response",
+    "BatchedRequest",
+    "BatchedResponse",
+    "ServerInfo",
+    "Turn",
+]

adaptive_sdk-0.1.0b1/src/adaptive_sdk/external/base_model.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel as PydanticBaseModel, ConfigDict
+
+
+class BaseModel(PydanticBaseModel):
+    """@private"""
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=(),
+    )

adaptive_sdk-0.1.0b1/src/adaptive_sdk/external/constants.py

@@ -0,0 +1,8 @@
+from typing import Final
+
+SCORE_PATH: Final = "/score"
+BATCH_SCORE_PATH: Final = "/batch_score"
+INFO_PATH: Final = "/info"
+VALIDATE_METADATA: Final = "/validate_metadata"
+BATCH_VALIDATE_METADATA: Final = "/batch_validate_metadata"
+METADATA_SCHEMA_PATH: Final = "/metadata_schema"