feat(xyz): dasdasd

Author: Datata1

examples/teams/domains/update_workspace_connections.py

@@ -11,13 +11,11 @@ async def main():
         domainBuilder = DomainRouting()
 
         routing = (
-            domainBuilder.add_route("/", [74861])
-            .add_route("/api", [74868])
-            .add_route("/test", [74868])
+            domainBuilder.add("/", [74861]).add("/api", [74868]).add("/test", [74868])
         )
 
         domain = await team.domains.update_workspace_connections(
-            domain_name="test.com", connections=routing
+            name="test.com", connections=routing
         )
         print(f"Current routing: {domain.workspaces}")
 

src/codesphere/__init__.py

@@ -29,7 +29,6 @@
     TeamBase,
     Domain,
     CustomDomainConfig,
-    WorkspaceConnectionItem,
     DomainVerificationStatus,
     DomainBase,
     DomainRouting,
@@ -63,7 +62,6 @@
     "Image",
     "Domain",
     "CustomDomainConfig",
-    "WorkspaceConnectionItem",
     "DomainVerificationStatus",
     "DomainBase",
     "DomainsResource",

src/codesphere/client.py

@@ -1,49 +1,13 @@
-"""
-Codesphere SDK Client
-
-This module provides the main client class, CodesphereSDK.
-"""
-
 from .http_client import APIHttpClient
 from .resources.metadata import MetadataResource
 from .resources.team import TeamsResource
 from .resources.workspace import WorkspacesResource
 
 
 class CodesphereSDK:
-    """The main entrypoint for interacting with the `Codesphere Public API <https://codesphere.com/api/swagger-ui/?ref=codesphere.ghost.io#/>`_.
-
-    This class manages the HTTP client, its lifecycle,
-    and provides access to the various API resources.
-
-    Primary usage is via an asynchronous context manager:
-
-    Usage:
-        >>> import asyncio
-        >>> from codesphere import CodesphereSDK
-        >>>
-        >>> async def main():
-        >>>     async with CodesphereSDK() as sdk:
-        >>>         teams = await sdk.teams.list()
-        >>>         print(teams)
-        >>>
-        >>> asyncio.run(main())
-
-    Attributes:
-        teams (TeamsResource): Access to Team API operations.
-        workspaces (WorkspacesResource): Access to Workspace API operations.
-        metadata (MetadataResource): Access to Metadata API operations.
-        domains (DomainResource): Access to Domain API operations.
-    """
-
     teams: TeamsResource
-    """Access to the Team API. (e.g., `sdk.teams.list()`)"""
-
     workspaces: WorkspacesResource
-    """Access to the Workspace API. (e.g., `sdk.workspaces.list()`)"""
-
     metadata: MetadataResource
-    """Access to the Metadata API. (e.g., `sdk.metadata.list_plans()`)"""
 
     def __init__(self):
         self._http_client = APIHttpClient()
@@ -52,20 +16,9 @@ def __init__(self):
         self.metadata = MetadataResource(self._http_client)
 
     async def open(self):
-        """Manually opens the underlying HTTP client session.
-
-        Required for manual lifecycle control when not using `async with`.
-
-        Usage:
-            >>> sdk = CodesphereSDK()
-            >>> await sdk.open()
-            >>> # ... API calls ...
-            >>> await sdk.close()
-        """
         await self._http_client.open()
 
     async def close(self):
-        """Manually closes the underlying HTTP client session."""
         await self._http_client.close()
 
     async def __aenter__(self):

src/codesphere/config.py

@@ -3,10 +3,6 @@
 
 
 class Settings(BaseSettings):
-    """
-    API Client Settings
-    """
-
     model_config = SettingsConfigDict(
         env_file=".env", env_file_encoding="utf-8", env_prefix="CS_"
     )

src/codesphere/core/base.py

@@ -1,7 +1,33 @@
+from typing import Generic, List, TypeVar
+from pydantic import BaseModel, ConfigDict, RootModel
+from pydantic.alias_generators import to_camel
+
 from ..http_client import APIHttpClient
 from .handler import _APIOperationExecutor
 
+ModelT = TypeVar("ModelT")
+
 
 class ResourceBase(_APIOperationExecutor):
     def __init__(self, http_client: APIHttpClient):
         self._http_client = http_client
+
+
+class CamelModel(BaseModel):
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+    )
+
+
+class ResourceList(RootModel[List[ModelT]], Generic[ModelT]):
+    root: List[ModelT]
+
+    def __iter__(self):
+        return iter(self.root)
+
+    def __getitem__(self, item):
+        return self.root[item]
+
+    def __len__(self):
+        return len(self.root)

src/codesphere/core/operations.py

@@ -1,22 +1,17 @@
-from typing import Callable, Awaitable, List, Optional, Type, TypeAlias, TypeVar
+from typing import Callable, Awaitable, Generic, Optional, Type, TypeAlias, TypeVar
 
 from pydantic import BaseModel
 
 
 _T = TypeVar("_T")
+ResponseT = TypeVar("ResponseT")
+InputT = TypeVar("InputT")
 
 AsyncCallable: TypeAlias = Callable[[], Awaitable[_T]]
 
 
-class APIOperation:
-    def __init__(
-        self,
-        method: str,
-        endpoint_template: str,
-        response_model: Type[BaseModel] | Type[List[BaseModel]],
-        input_model: Optional[Type[BaseModel]] = None,
-    ):
-        self.method = method
-        self.endpoint_template = endpoint_template
-        self.response_model = response_model
-        self.input_model = input_model
+class APIOperation(BaseModel, Generic[ResponseT, InputT]):
+    method: str
+    endpoint_template: str
+    response_model: Type[ResponseT]
+    input_model: Optional[Type[InputT]] = None

src/codesphere/resources/metadata/__init__.py

@@ -1,6 +1,6 @@
 """Metadata Resource & Models"""
 
-from .models import Datacenter, Characteristic, WsPlan, Image
+from .schemas import Datacenter, Characteristic, WsPlan, Image
 from .resources import MetadataResource
 
 __all__ = ["Datacenter", "Characteristic", "WsPlan", "Image", "MetadataResource"]

src/codesphere/resources/metadata/operations.py

@@ -0,0 +1,24 @@
+from ...core.base import ResourceList
+from ...core.operations import APIOperation
+from .schemas import Datacenter, Image, WsPlan
+
+_LIST_DC_OP = APIOperation(
+    method="GET",
+    endpoint_template="/metadata/datacenters",
+    input_model=type(None),
+    response_model=ResourceList[Datacenter],
+)
+
+_LIST_PLANS_OP = APIOperation(
+    method="GET",
+    endpoint_template="/metadata/workspace-plans",
+    input_model=type(None),
+    response_model=ResourceList[WsPlan],
+)
+
+_LIST_IMAGES_OP = APIOperation(
+    method="GET",
+    endpoint_template="/metadata/workspace-base-images",
+    input_model=type(None),
+    response_model=ResourceList[Image],
+)

src/codesphere/resources/metadata/resources.py

@@ -1,37 +1,31 @@
-"""
-Defines the resource class for the Metadata API endpoints.
-"""
-
 from typing import List
-from ...core import APIOperation, AsyncCallable
+from pydantic import Field
+from ...core.base import ResourceList
+from ...core import AsyncCallable
 from ...core import ResourceBase
-from .models import Datacenter, WsPlan, Image
+from .operations import _LIST_DC_OP, _LIST_IMAGES_OP, _LIST_PLANS_OP
+from .schemas import Datacenter, WsPlan, Image
 
 
 class MetadataResource(ResourceBase):
-    list_datacenters: AsyncCallable[List[Datacenter]]
-    """Fetches a list of all available data centers."""
-    list_datacenters = APIOperation(
-        method="GET",
-        endpoint_template="/metadata/datacenters",
-        input_model=None,
-        response_model=List[Datacenter],
+    list_datacenters_op: AsyncCallable[ResourceList[Datacenter]] = Field(
+        default=_LIST_DC_OP, exclude=True
     )
-
-    list_plans: AsyncCallable[List[WsPlan]]
-    """Fetches a list of all available workspace plans."""
-    list_plans = APIOperation(
-        method="GET",
-        endpoint_template="/metadata/workspace-plans",
-        input_model=None,
-        response_model=List[WsPlan],
+    list_plans_op: AsyncCallable[ResourceList[WsPlan]] = Field(
+        default=_LIST_PLANS_OP, exclude=True
     )
-
-    list_images: AsyncCallable[List[Image]]
-    """Fetches a list of all available workspace base images."""
-    list_images = APIOperation(
-        method="GET",
-        endpoint_template="/metadata/workspace-base-images",
-        input_model=None,
-        response_model=List[Image],
+    list_images_op: AsyncCallable[ResourceList[Image]] = Field(
+        default=_LIST_IMAGES_OP, exclude=True
     )
+
+    async def list_datacenters(self) -> List[Datacenter]:
+        result = await self.list_datacenters_op()
+        return result.root
+
+    async def list_plans(self) -> List[WsPlan]:
+        result = await self.list_plans_op()
+        return result.root
+
+    async def list_images(self) -> List[Image]:
+        result = await self.list_images_op()
+        return result.root

…/codesphere/resources/metadata/models.py …codesphere/resources/metadata/schemas.pysrc/codesphere/resources/metadata/models.py renamed to src/codesphere/resources/metadata/schemas.py src/codesphere/resources/metadata/models.py renamed to src/codesphere/resources/metadata/schemas.py

@@ -1,45 +1,46 @@
 from __future__ import annotations
-from pydantic import BaseModel
 import datetime
 
+from ...core.base import CamelModel
 
-class Datacenter(BaseModel):
+
+class Datacenter(CamelModel):
     """Represents a physical data center location."""
 
     id: int
     name: str
     city: str
-    countryCode: str
+    country_code: str
 
 
-class Characteristic(BaseModel):
+class Characteristic(CamelModel):
     """Defines the resource specifications for a WsPlan."""
 
     id: int
-    CPU: float
-    GPU: int
-    RAM: int
-    SSD: int
-    TempStorage: int
-    onDemand: bool
+    cpu: float
+    gpu: int
+    ram: int
+    ssd: int
+    temp_storage: int
+    on_demand: bool
 
 
-class WsPlan(BaseModel):
+class WsPlan(CamelModel):
     """
     Represents a purchasable workspace plan.
     """
 
     id: int
-    priceUsd: int
+    price_usd: int
     title: str
     deprecated: bool
     characteristics: Characteristic
-    maxReplicas: int
+    max_replicas: int
 
 
-class Image(BaseModel):
+class Image(CamelModel):
     """Represents a runnable workspace base image."""
 
     id: str
     name: str
-    supportedUntil: datetime.datetime
+    supported_until: datetime.datetime