casedev 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

casedev/resources/applications/v1/v1.py

@@ -0,0 +1,166 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .projects import (
+    ProjectsResource,
+    AsyncProjectsResource,
+    ProjectsResourceWithRawResponse,
+    AsyncProjectsResourceWithRawResponse,
+    ProjectsResourceWithStreamingResponse,
+    AsyncProjectsResourceWithStreamingResponse,
+)
+from .workflows import (
+    WorkflowsResource,
+    AsyncWorkflowsResource,
+    WorkflowsResourceWithRawResponse,
+    AsyncWorkflowsResourceWithRawResponse,
+    WorkflowsResourceWithStreamingResponse,
+    AsyncWorkflowsResourceWithStreamingResponse,
+)
+from ...._compat import cached_property
+from .deployments import (
+    DeploymentsResource,
+    AsyncDeploymentsResource,
+    DeploymentsResourceWithRawResponse,
+    AsyncDeploymentsResourceWithRawResponse,
+    DeploymentsResourceWithStreamingResponse,
+    AsyncDeploymentsResourceWithStreamingResponse,
+)
+from ...._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["V1Resource", "AsyncV1Resource"]
+
+
+class V1Resource(SyncAPIResource):
+    @cached_property
+    def deployments(self) -> DeploymentsResource:
+        return DeploymentsResource(self._client)
+
+    @cached_property
+    def projects(self) -> ProjectsResource:
+        return ProjectsResource(self._client)
+
+    @cached_property
+    def workflows(self) -> WorkflowsResource:
+        return WorkflowsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> V1ResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return V1ResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> V1ResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return V1ResourceWithStreamingResponse(self)
+
+
+class AsyncV1Resource(AsyncAPIResource):
+    @cached_property
+    def deployments(self) -> AsyncDeploymentsResource:
+        return AsyncDeploymentsResource(self._client)
+
+    @cached_property
+    def projects(self) -> AsyncProjectsResource:
+        return AsyncProjectsResource(self._client)
+
+    @cached_property
+    def workflows(self) -> AsyncWorkflowsResource:
+        return AsyncWorkflowsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncV1ResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncV1ResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncV1ResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return AsyncV1ResourceWithStreamingResponse(self)
+
+
+class V1ResourceWithRawResponse:
+    def __init__(self, v1: V1Resource) -> None:
+        self._v1 = v1
+
+    @cached_property
+    def deployments(self) -> DeploymentsResourceWithRawResponse:
+        return DeploymentsResourceWithRawResponse(self._v1.deployments)
+
+    @cached_property
+    def projects(self) -> ProjectsResourceWithRawResponse:
+        return ProjectsResourceWithRawResponse(self._v1.projects)
+
+    @cached_property
+    def workflows(self) -> WorkflowsResourceWithRawResponse:
+        return WorkflowsResourceWithRawResponse(self._v1.workflows)
+
+
+class AsyncV1ResourceWithRawResponse:
+    def __init__(self, v1: AsyncV1Resource) -> None:
+        self._v1 = v1
+
+    @cached_property
+    def deployments(self) -> AsyncDeploymentsResourceWithRawResponse:
+        return AsyncDeploymentsResourceWithRawResponse(self._v1.deployments)
+
+    @cached_property
+    def projects(self) -> AsyncProjectsResourceWithRawResponse:
+        return AsyncProjectsResourceWithRawResponse(self._v1.projects)
+
+    @cached_property
+    def workflows(self) -> AsyncWorkflowsResourceWithRawResponse:
+        return AsyncWorkflowsResourceWithRawResponse(self._v1.workflows)
+
+
+class V1ResourceWithStreamingResponse:
+    def __init__(self, v1: V1Resource) -> None:
+        self._v1 = v1
+
+    @cached_property
+    def deployments(self) -> DeploymentsResourceWithStreamingResponse:
+        return DeploymentsResourceWithStreamingResponse(self._v1.deployments)
+
+    @cached_property
+    def projects(self) -> ProjectsResourceWithStreamingResponse:
+        return ProjectsResourceWithStreamingResponse(self._v1.projects)
+
+    @cached_property
+    def workflows(self) -> WorkflowsResourceWithStreamingResponse:
+        return WorkflowsResourceWithStreamingResponse(self._v1.workflows)
+
+
+class AsyncV1ResourceWithStreamingResponse:
+    def __init__(self, v1: AsyncV1Resource) -> None:
+        self._v1 = v1
+
+    @cached_property
+    def deployments(self) -> AsyncDeploymentsResourceWithStreamingResponse:
+        return AsyncDeploymentsResourceWithStreamingResponse(self._v1.deployments)
+
+    @cached_property
+    def projects(self) -> AsyncProjectsResourceWithStreamingResponse:
+        return AsyncProjectsResourceWithStreamingResponse(self._v1.projects)
+
+    @cached_property
+    def workflows(self) -> AsyncWorkflowsResourceWithStreamingResponse:
+        return AsyncWorkflowsResourceWithStreamingResponse(self._v1.workflows)

casedev/resources/applications/v1/workflows.py

@@ -0,0 +1,182 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ...._types import Body, Query, Headers, NoneType, NotGiven, not_given
+from ...._utils import maybe_transform, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ...._base_client import make_request_options
+from ....types.applications.v1 import workflow_get_status_params
+
+__all__ = ["WorkflowsResource", "AsyncWorkflowsResource"]
+
+
+class WorkflowsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> WorkflowsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return WorkflowsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> WorkflowsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return WorkflowsResourceWithStreamingResponse(self)
+
+    def get_status(
+        self,
+        id: str,
+        *,
+        project_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        Get current deployment workflow status and accumulated events
+
+        Args:
+          project_id: Project ID (for authorization)
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._get(
+            f"/applications/v1/workflows/{id}/status",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"project_id": project_id}, workflow_get_status_params.WorkflowGetStatusParams),
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncWorkflowsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncWorkflowsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncWorkflowsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncWorkflowsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return AsyncWorkflowsResourceWithStreamingResponse(self)
+
+    async def get_status(
+        self,
+        id: str,
+        *,
+        project_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        Get current deployment workflow status and accumulated events
+
+        Args:
+          project_id: Project ID (for authorization)
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._get(
+            f"/applications/v1/workflows/{id}/status",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"project_id": project_id}, workflow_get_status_params.WorkflowGetStatusParams
+                ),
+            ),
+            cast_to=NoneType,
+        )
+
+
+class WorkflowsResourceWithRawResponse:
+    def __init__(self, workflows: WorkflowsResource) -> None:
+        self._workflows = workflows
+
+        self.get_status = to_raw_response_wrapper(
+            workflows.get_status,
+        )
+
+
+class AsyncWorkflowsResourceWithRawResponse:
+    def __init__(self, workflows: AsyncWorkflowsResource) -> None:
+        self._workflows = workflows
+
+        self.get_status = async_to_raw_response_wrapper(
+            workflows.get_status,
+        )
+
+
+class WorkflowsResourceWithStreamingResponse:
+    def __init__(self, workflows: WorkflowsResource) -> None:
+        self._workflows = workflows
+
+        self.get_status = to_streamed_response_wrapper(
+            workflows.get_status,
+        )
+
+
+class AsyncWorkflowsResourceWithStreamingResponse:
+    def __init__(self, workflows: AsyncWorkflowsResource) -> None:
+        self._workflows = workflows
+
+        self.get_status = async_to_streamed_response_wrapper(
+            workflows.get_status,
+        )

casedev/resources/compute/v1/__init__.py

@@ -16,6 +16,14 @@ from .secrets import (
     SecretsResourceWithStreamingResponse,
     AsyncSecretsResourceWithStreamingResponse,
 )
+from .instances import (
+    InstancesResource,
+    AsyncInstancesResource,
+    InstancesResourceWithRawResponse,
+    AsyncInstancesResourceWithRawResponse,
+    InstancesResourceWithStreamingResponse,
+    AsyncInstancesResourceWithStreamingResponse,
+)
 from .environments import (
     EnvironmentsResource,
     AsyncEnvironmentsResource,
@@ -24,6 +32,14 @@ from .environments import (
     EnvironmentsResourceWithStreamingResponse,
     AsyncEnvironmentsResourceWithStreamingResponse,
 )
+from .instance_types import (
+    InstanceTypesResource,
+    AsyncInstanceTypesResource,
+    InstanceTypesResourceWithRawResponse,
+    AsyncInstanceTypesResourceWithRawResponse,
+    InstanceTypesResourceWithStreamingResponse,
+    AsyncInstanceTypesResourceWithStreamingResponse,
+)
 
 __all__ = [
     "EnvironmentsResource",
@@ -32,6 +48,18 @@ __all__ = [
     "AsyncEnvironmentsResourceWithRawResponse",
     "EnvironmentsResourceWithStreamingResponse",
     "AsyncEnvironmentsResourceWithStreamingResponse",
+    "InstanceTypesResource",
+    "AsyncInstanceTypesResource",
+    "InstanceTypesResourceWithRawResponse",
+    "AsyncInstanceTypesResourceWithRawResponse",
+    "InstanceTypesResourceWithStreamingResponse",
+    "AsyncInstanceTypesResourceWithStreamingResponse",
+    "InstancesResource",
+    "AsyncInstancesResource",
+    "InstancesResourceWithRawResponse",
+    "AsyncInstancesResourceWithRawResponse",
+    "InstancesResourceWithStreamingResponse",
+    "AsyncInstancesResourceWithStreamingResponse",
     "SecretsResource",
     "AsyncSecretsResource",
     "SecretsResourceWithRawResponse",

casedev/resources/compute/v1/instance_types.py

@@ -0,0 +1,145 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ...._types import Body, Query, Headers, NotGiven, not_given
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ...._base_client import make_request_options
+from ....types.compute.v1.instance_type_list_response import InstanceTypeListResponse
+
+__all__ = ["InstanceTypesResource", "AsyncInstanceTypesResource"]
+
+
+class InstanceTypesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> InstanceTypesResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return InstanceTypesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> InstanceTypesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return InstanceTypesResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> InstanceTypeListResponse:
+        """
+        Retrieves all available GPU instance types with pricing, specifications, and
+        regional availability. Includes T4, A10, A100, H100, and H200 GPUs powered by
+        Lambda Labs. Perfect for AI model training, inference workloads, and legal
+        document OCR processing at scale.
+        """
+        return self._get(
+            "/compute/v1/instance-types",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InstanceTypeListResponse,
+        )
+
+
+class AsyncInstanceTypesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncInstanceTypesResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncInstanceTypesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncInstanceTypesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return AsyncInstanceTypesResourceWithStreamingResponse(self)
+
+    async def list(
+        self,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> InstanceTypeListResponse:
+        """
+        Retrieves all available GPU instance types with pricing, specifications, and
+        regional availability. Includes T4, A10, A100, H100, and H200 GPUs powered by
+        Lambda Labs. Perfect for AI model training, inference workloads, and legal
+        document OCR processing at scale.
+        """
+        return await self._get(
+            "/compute/v1/instance-types",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InstanceTypeListResponse,
+        )
+
+
+class InstanceTypesResourceWithRawResponse:
+    def __init__(self, instance_types: InstanceTypesResource) -> None:
+        self._instance_types = instance_types
+
+        self.list = to_raw_response_wrapper(
+            instance_types.list,
+        )
+
+
+class AsyncInstanceTypesResourceWithRawResponse:
+    def __init__(self, instance_types: AsyncInstanceTypesResource) -> None:
+        self._instance_types = instance_types
+
+        self.list = async_to_raw_response_wrapper(
+            instance_types.list,
+        )
+
+
+class InstanceTypesResourceWithStreamingResponse:
+    def __init__(self, instance_types: InstanceTypesResource) -> None:
+        self._instance_types = instance_types
+
+        self.list = to_streamed_response_wrapper(
+            instance_types.list,
+        )
+
+
+class AsyncInstanceTypesResourceWithStreamingResponse:
+    def __init__(self, instance_types: AsyncInstanceTypesResource) -> None:
+        self._instance_types = instance_types
+
+        self.list = async_to_streamed_response_wrapper(
+            instance_types.list,
+        )