cirro-api-client 0.1.2__tar.gz → 0.1.4__tar.gz

{cirro_api_client-0.1.2 → cirro_api_client-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirro_api_client
-Version: 0.1.2
+Version: 0.1.4
 Summary: A client library for accessing Cirro
 Home-page: https://github.com/CirroBio/Cirro-client-python
 License: MIT
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: attrs (>=21.3.0)
 Requires-Dist: httpx (>=0.20.0,<0.27.0)
 Requires-Dist: python-dateutil (>=2.8.0,<3.0.0)

cirro_api_client-0.1.4/cirro_api_client/v1/api/compute_environment/get_compute_environments.py

@@ -0,0 +1,168 @@
+from http import HTTPStatus
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...models.compute_environment_configuration import ComputeEnvironmentConfiguration
+from ...types import Response
+
+
+def _get_kwargs(
+    project_id: str,
+) -> Dict[str, Any]:
+    _kwargs: Dict[str, Any] = {
+        "method": "get",
+        "url": f"/projects/{project_id}/compute-environments",
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Optional[List["ComputeEnvironmentConfiguration"]]:
+    if response.status_code == HTTPStatus.OK:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ComputeEnvironmentConfiguration.from_dict(response_200_item_data)
+
+            response_200.append(response_200_item)
+
+        return response_200
+
+    errors.handle_error_response(response, client.raise_on_unexpected_status)
+
+
+def _build_response(*, client: Client, response: httpx.Response) -> Response[List["ComputeEnvironmentConfiguration"]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    project_id: str,
+    *,
+    client: Client,
+) -> Response[List["ComputeEnvironmentConfiguration"]]:
+    """Get compute environments
+
+     Get a list of compute environments for a project
+
+    Args:
+        project_id (str):
+        client (Client): instance of the API client
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[List['ComputeEnvironmentConfiguration']]
+    """
+
+    kwargs = _get_kwargs(
+        project_id=project_id,
+    )
+
+    response = client.get_httpx_client().request(
+        auth=client.get_auth(),
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    project_id: str,
+    *,
+    client: Client,
+) -> Optional[List["ComputeEnvironmentConfiguration"]]:
+    """Get compute environments
+
+     Get a list of compute environments for a project
+
+    Args:
+        project_id (str):
+        client (Client): instance of the API client
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        List['ComputeEnvironmentConfiguration']
+    """
+
+    try:
+        return sync_detailed(
+            project_id=project_id,
+            client=client,
+        ).parsed
+    except errors.NotFoundException:
+        return None
+
+
+async def asyncio_detailed(
+    project_id: str,
+    *,
+    client: Client,
+) -> Response[List["ComputeEnvironmentConfiguration"]]:
+    """Get compute environments
+
+     Get a list of compute environments for a project
+
+    Args:
+        project_id (str):
+        client (Client): instance of the API client
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[List['ComputeEnvironmentConfiguration']]
+    """
+
+    kwargs = _get_kwargs(
+        project_id=project_id,
+    )
+
+    response = await client.get_async_httpx_client().request(auth=client.get_auth(), **kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    project_id: str,
+    *,
+    client: Client,
+) -> Optional[List["ComputeEnvironmentConfiguration"]]:
+    """Get compute environments
+
+     Get a list of compute environments for a project
+
+    Args:
+        project_id (str):
+        client (Client): instance of the API client
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        List['ComputeEnvironmentConfiguration']
+    """
+
+    try:
+        return (
+            await asyncio_detailed(
+                project_id=project_id,
+                client=client,
+            )
+        ).parsed
+    except errors.NotFoundException:
+        return None

cirro_api_client-0.1.4/cirro_api_client/v1/api/projects/archive_project.py

@@ -0,0 +1,98 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    project_id: str,
+) -> Dict[str, Any]:
+    _kwargs: Dict[str, Any] = {
+        "method": "put",
+        "url": f"/projects/{project_id}:archive",
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Optional[Any]:
+    if response.status_code == HTTPStatus.OK:
+        return None
+
+    errors.handle_error_response(response, client.raise_on_unexpected_status)
+
+
+def _build_response(*, client: Client, response: httpx.Response) -> Response[Any]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    project_id: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """Archive project
+
+     Sets the project status to archived
+
+    Args:
+        project_id (str):
+        client (Client): instance of the API client
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        project_id=project_id,
+    )
+
+    response = client.get_httpx_client().request(
+        auth=client.get_auth(),
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    project_id: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """Archive project
+
+     Sets the project status to archived
+
+    Args:
+        project_id (str):
+        client (Client): instance of the API client
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        project_id=project_id,
+    )
+
+    response = await client.get_async_httpx_client().request(auth=client.get_auth(), **kwargs)
+
+    return _build_response(client=client, response=response)

cirro_api_client-0.1.4/cirro_api_client/v1/api/projects/get_project_create_options.py

@@ -0,0 +1,135 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...models.project_create_options import ProjectCreateOptions
+from ...types import Response
+
+
+def _get_kwargs() -> Dict[str, Any]:
+    _kwargs: Dict[str, Any] = {
+        "method": "options",
+        "url": "/projects",
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Optional[ProjectCreateOptions]:
+    if response.status_code == HTTPStatus.OK:
+        response_200 = ProjectCreateOptions.from_dict(response.json())
+
+        return response_200
+
+    errors.handle_error_response(response, client.raise_on_unexpected_status)
+
+
+def _build_response(*, client: Client, response: httpx.Response) -> Response[ProjectCreateOptions]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+) -> Response[ProjectCreateOptions]:
+    """Get project create options
+
+     Get allowed options for creating a project
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[ProjectCreateOptions]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = client.get_httpx_client().request(
+        auth=client.get_auth(),
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Client,
+) -> Optional[ProjectCreateOptions]:
+    """Get project create options
+
+     Get allowed options for creating a project
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        ProjectCreateOptions
+    """
+
+    try:
+        return sync_detailed(
+            client=client,
+        ).parsed
+    except errors.NotFoundException:
+        return None
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+) -> Response[ProjectCreateOptions]:
+    """Get project create options
+
+     Get allowed options for creating a project
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[ProjectCreateOptions]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = await client.get_async_httpx_client().request(auth=client.get_auth(), **kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Client,
+) -> Optional[ProjectCreateOptions]:
+    """Get project create options
+
+     Get allowed options for creating a project
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        ProjectCreateOptions
+    """
+
+    try:
+        return (
+            await asyncio_detailed(
+                client=client,
+            )
+        ).parsed
+    except errors.NotFoundException:
+        return None

cirro_api_client-0.1.4/cirro_api_client/v1/api/projects/unarchive_project.py

@@ -0,0 +1,98 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ... import errors
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    project_id: str,
+) -> Dict[str, Any]:
+    _kwargs: Dict[str, Any] = {
+        "method": "put",
+        "url": f"/projects/{project_id}:unarchive",
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, client: Client, response: httpx.Response) -> Optional[Any]:
+    if response.status_code == HTTPStatus.OK:
+        return None
+
+    errors.handle_error_response(response, client.raise_on_unexpected_status)
+
+
+def _build_response(*, client: Client, response: httpx.Response) -> Response[Any]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    project_id: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """Unarchive project
+
+     Sets the project status to active
+
+    Args:
+        project_id (str):
+        client (Client): instance of the API client
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        project_id=project_id,
+    )
+
+    response = client.get_httpx_client().request(
+        auth=client.get_auth(),
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    project_id: str,
+    *,
+    client: Client,
+) -> Response[Any]:
+    """Unarchive project
+
+     Sets the project status to active
+
+    Args:
+        project_id (str):
+        client (Client): instance of the API client
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        project_id=project_id,
+    )
+
+    response = await client.get_async_httpx_client().request(auth=client.get_auth(), **kwargs)
+
+    return _build_response(client=client, response=response)

{cirro_api_client-0.1.2 → cirro_api_client-0.1.4}/cirro_api_client/v1/models/__init__.py

@@ -1,6 +1,9 @@
 """Contains all the data models used in inputs/outputs"""
 
 from .access_type import AccessType
+from .agent import Agent
+from .agent_status import AgentStatus
+from .agent_tags import AgentTags
 from .allowed_data_type import AllowedDataType
 from .approve_project_access_request import ApproveProjectAccessRequest
 from .audit_event import AuditEvent
@@ -16,6 +19,8 @@ from .calculate_pipeline_cost_request import CalculatePipelineCostRequest
 from .cloud_account import CloudAccount
 from .cloud_account_type import CloudAccountType
 from .column_definition import ColumnDefinition
+from .compute_environment_configuration import ComputeEnvironmentConfiguration
+from .compute_environment_configuration_properties import ComputeEnvironmentConfigurationProperties
 from .contact import Contact
 from .create_notebook_instance_request import CreateNotebookInstanceRequest
 from .create_project_access_request import CreateProjectAccessRequest
@@ -35,8 +40,10 @@ from .dataset_detail import DatasetDetail
 from .dataset_detail_info import DatasetDetailInfo
 from .dataset_detail_params import DatasetDetailParams
 from .dataset_viz import DatasetViz
+from .environment_type import EnvironmentType
 from .error_message import ErrorMessage
 from .executor import Executor
+from .feature_flags import FeatureFlags
 from .file_access_request import FileAccessRequest
 from .file_entry import FileEntry
 from .file_entry_metadata import FileEntryMetadata
@@ -68,6 +75,7 @@ from .process import Process
 from .process_detail import ProcessDetail
 from .project import Project
 from .project_access_request import ProjectAccessRequest
+from .project_create_options import ProjectCreateOptions
 from .project_detail import ProjectDetail
 from .project_metrics import ProjectMetrics
 from .project_request import ProjectRequest
@@ -109,6 +117,9 @@ from .validate_file_requirements_request import ValidateFileRequirementsRequest
 
 __all__ = (
     "AccessType",
+    "Agent",
+    "AgentStatus",
+    "AgentTags",
     "AllowedDataType",
     "ApproveProjectAccessRequest",
     "AuditEvent",
@@ -124,6 +135,8 @@ __all__ = (
     "CloudAccount",
     "CloudAccountType",
     "ColumnDefinition",
+    "ComputeEnvironmentConfiguration",
+    "ComputeEnvironmentConfigurationProperties",
     "Contact",
     "CreateNotebookInstanceRequest",
     "CreateProjectAccessRequest",
@@ -143,8 +156,10 @@ __all__ = (
     "DatasetDetailInfo",
     "DatasetDetailParams",
     "DatasetViz",
+    "EnvironmentType",
     "ErrorMessage",
     "Executor",
+    "FeatureFlags",
     "FileAccessRequest",
     "FileEntry",
     "FileEntryMetadata",
@@ -176,6 +191,7 @@ __all__ = (
     "ProcessDetail",
     "Project",
     "ProjectAccessRequest",
+    "ProjectCreateOptions",
     "ProjectDetail",
     "ProjectMetrics",
     "ProjectRequest",

cirro_api_client-0.1.4/cirro_api_client/v1/models/agent.py

@@ -0,0 +1,90 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.agent_status import AgentStatus
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.agent_tags import AgentTags
+
+
+T = TypeVar("T", bound="Agent")
+
+
+@_attrs_define
+class Agent:
+    """Details of the agent
+
+    Attributes:
+        status (AgentStatus): The status of the agent
+        id (Union[Unset, str]): The unique ID of the agent
+        name (Union[Unset, str]): The display name of the agent
+        tags (Union[Unset, AgentTags]):
+    """
+
+    status: AgentStatus
+    id: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    tags: Union[Unset, "AgentTags"] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        status = self.status.value
+
+        id = self.id
+
+        name = self.name
+
+        tags: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.tags, Unset):
+            tags = self.tags.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+            }
+        )
+        if id is not UNSET:
+            field_dict["id"] = id
+        if name is not UNSET:
+            field_dict["name"] = name
+        if tags is not UNSET:
+            field_dict["tags"] = tags
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.agent_tags import AgentTags
+
+        d = src_dict.copy()
+        status = AgentStatus(d.pop("status"))
+
+        id = d.pop("id", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        _tags = d.pop("tags", UNSET)
+        tags: Union[Unset, AgentTags]
+        if isinstance(_tags, Unset):
+            tags = UNSET
+        else:
+            tags = AgentTags.from_dict(_tags)
+
+        agent = cls(
+            status=status,
+            id=id,
+            name=name,
+            tags=tags,
+        )
+
+        agent.additional_properties = d
+        return agent
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())

cirro_api_client-0.1.4/cirro_api_client/v1/models/agent_status.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class AgentStatus(str, Enum):
+    OFFLINE = "OFFLINE"
+    ONLINE = "ONLINE"
+    UNKNOWN = "UNKNOWN"
+    """ This is a fallback value for when the value is not known, do not use this value when making requests """
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def _missing_(cls, number):
+        return cls(cls.UNKNOWN)