anyscale 0.26.51__py3-none-any.whl → 0.26.52__py3-none-any.whl

anyscale/project/commands.py

@@ -1,8 +1,14 @@
 from typing import List, Optional
 
+from anyscale._private.models.model_base import ResultIterator
 from anyscale._private.sdk import sdk_command
 from anyscale.project._private.project_sdk import PrivateProjectSDK
-from anyscale.project.models import CreateProjectCollaborator
+from anyscale.project.models import (
+    CreateProjectCollaborator,
+    Project,
+    ProjectSortField,
+    ProjectSortOrder,
+)
 
 
 _PROJECT_SDK_SINGLETON_KEY = "project_sdk"
@@ -54,3 +60,184 @@ def add_collaborators(
     """Batch add collaborators to a project.
     """
     return _private_sdk.add_collaborators(cloud, project, collaborators)  # type: ignore
+
+
+_GET_PROJECT_EXAMPLE = """
+import anyscale
+from anyscale.project.models import Project
+
+project: Project = anyscale.project.get(project_id="my-project-id")
+"""
+
+_GET_PROJECT_DOCSTRINGS = {
+    "project_id": "The ID of the project to get details of.",
+}
+
+
+@sdk_command(
+    _PROJECT_SDK_SINGLETON_KEY,
+    PrivateProjectSDK,
+    doc_py_example=_GET_PROJECT_EXAMPLE,
+    arg_docstrings=_GET_PROJECT_DOCSTRINGS,
+)
+def get(
+    project_id: str, *, _private_sdk: Optional[PrivateProjectSDK] = None
+) -> Project:
+    """Get details of a project.
+    """
+    return _private_sdk.get(project_id)  # type: ignore
+
+
+_LIST_PROJECTS_EXAMPLE = """
+from typing import Iterator
+
+import anyscale
+from anyscale.project.models import Project, ProjectSortField, ProjectSortOrder
+
+projects: Iterator[Project] = anyscale.project.list(
+    name_contains="my-project",
+    creator_id="my-user-id",
+    parent_cloud_id="my-cloud-id",
+    include_defaults=True,
+    max_items=20,
+    page_size=10,
+    sort_field=ProjectSortField.NAME,
+    sort_order=ProjectSortOrder.ASC,
+)
+for project in projects:
+    print(project.name)
+"""
+
+_LIST_PROJECTS_DOCSTRINGS = {
+    "name_contains": "A string to filter projects by name.",
+    "creator_id": "The ID of a creator to filter projects.",
+    "parent_cloud_id": "The ID of a parent cloud to filter projects.",
+    "include_defaults": "Whether to include default projects.",
+    "max_items": "The maximum number of projects to return.",
+    "page_size": "The number of projects to return per page.",
+    "sort_field": "The field to sort projects by.",
+    "sort_order": "The order to sort projects by.",
+}
+
+
+@sdk_command(
+    _PROJECT_SDK_SINGLETON_KEY,
+    PrivateProjectSDK,
+    doc_py_example=_LIST_PROJECTS_EXAMPLE,
+    arg_docstrings=_LIST_PROJECTS_DOCSTRINGS,
+)
+def list(  # noqa: A001
+    *,
+    name_contains: Optional[str] = None,
+    creator_id: Optional[str] = None,
+    parent_cloud_id: Optional[str] = None,
+    include_defaults: bool = True,
+    max_items: Optional[int] = None,
+    page_size: Optional[int] = None,
+    sort_field: Optional[ProjectSortField] = None,
+    sort_order: Optional[ProjectSortOrder] = None,
+    _private_sdk: Optional[PrivateProjectSDK] = None
+) -> ResultIterator[Project]:
+    """List projects.
+    """
+    return _private_sdk.list(  # type: ignore
+        name_contains=name_contains,
+        creator_id=creator_id,
+        parent_cloud_id=parent_cloud_id,
+        include_defaults=include_defaults,
+        max_items=max_items,
+        page_size=page_size,
+        sort_field=sort_field,
+        sort_order=sort_order,
+    )
+
+
+_CREATE_PROJECT_EXAMPLE = """
+import anyscale
+
+project_id: str = anyscale.project.create(
+    name="my-project",
+    parent_cloud_id="my-cloud-id",
+    description="my-project-description",
+)
+"""
+
+_CREATE_PROJECT_DOCSTRINGS = {
+    "name": "The name of the project.",
+    "parent_cloud_id": "The parent cloud that the project belongs to.",
+    "description": "The description of the project.",
+    "initial_cluster_config": "A YAML string containing the initial cluster config for the project.",
+}
+
+
+@sdk_command(
+    _PROJECT_SDK_SINGLETON_KEY,
+    PrivateProjectSDK,
+    doc_py_example=_CREATE_PROJECT_EXAMPLE,
+    arg_docstrings=_CREATE_PROJECT_DOCSTRINGS,
+)
+def create(
+    name: str,
+    parent_cloud_id: str,
+    *,
+    description: Optional[str] = None,
+    initial_cluster_config: Optional[str] = None,
+    _private_sdk: Optional[PrivateProjectSDK] = None
+) -> str:
+    """Create a project.
+    """
+    return _private_sdk.create(  # type: ignore
+        name,
+        description or "",
+        parent_cloud_id,
+        initial_cluster_config=initial_cluster_config,
+    )
+
+
+_DELETE_PROJECT_EXAMPLE = """
+import anyscale
+
+anyscale.project.delete(project_id="my-project-id")
+"""
+
+_DELETE_PROJECT_DOCSTRINGS = {
+    "project_id": "The ID of the project to delete.",
+}
+
+
+@sdk_command(
+    _PROJECT_SDK_SINGLETON_KEY,
+    PrivateProjectSDK,
+    doc_py_example=_DELETE_PROJECT_EXAMPLE,
+    arg_docstrings=_DELETE_PROJECT_DOCSTRINGS,
+)
+def delete(project_id: str, *, _private_sdk: Optional[PrivateProjectSDK] = None):
+    """Delete a project.
+    """
+    _private_sdk.delete(project_id)  # type: ignore
+
+
+_GET_DEFAULT_PROJECT_EXAMPLE = """
+import anyscale
+from anyscale.project.models import Project
+
+project: Project = anyscale.project.get_default(parent_cloud_id="my-cloud-id")
+"""
+
+_GET_DEFAULT_PROJECT_DOCSTRINGS = {
+    "parent_cloud_id": "The ID of the parent cloud to get the default project for.",
+}
+
+
+@sdk_command(
+    _PROJECT_SDK_SINGLETON_KEY,
+    PrivateProjectSDK,
+    doc_py_example=_GET_DEFAULT_PROJECT_EXAMPLE,
+    arg_docstrings=_GET_DEFAULT_PROJECT_DOCSTRINGS,
+)
+def get_default(
+    parent_cloud_id: str, *, _private_sdk: Optional[PrivateProjectSDK] = None
+) -> Project:
+    """Get the default project for a cloud.
+    """
+    return _private_sdk.get_default(parent_cloud_id)  # type: ignore

anyscale/project/models.py

@@ -1,5 +1,8 @@
-from dataclasses import dataclass, field
-from typing import Any, Dict, List
+import contextlib
+from dataclasses import dataclass, field, fields
+from datetime import datetime
+import json
+from typing import Any, Dict, List, Optional, Union
 
 from anyscale._private.models import ModelBase, ModelEnum
 
@@ -89,3 +92,196 @@ create_project_collaborators = CreateProjectCollaborators(
     def _validate_collaborators(self, collaborators: List[Dict[str, Any]]):
         if not isinstance(collaborators, list):
             raise TypeError("Collaborators must be a list.")
+
+
+@dataclass(frozen=True)
+class ProjectMinimal(ModelBase):
+    """Minimal Project object."""
+
+    id: str = field(metadata={"docstring": "ID of the project."},)
+
+    def _validate_id(self, id: str):  # noqa: A002
+        if not isinstance(id, str):
+            raise TypeError("'id' must be a string.")
+
+    name: str = field(metadata={"docstring": "Name of the project."},)
+
+    def _validate_name(self, name: str):
+        if not isinstance(name, str):
+            raise TypeError("'name' must be a string.")
+
+    description: str = field(metadata={"docstring": "Description of the project."},)
+
+    def _validate_description(self, description: str):
+        if not isinstance(description, str):
+            raise TypeError("'description' must be a string.")
+
+    created_at: str = field(
+        metadata={"docstring": "Datetime of the project creation."},
+    )
+
+    def _validate_created_at(self, created_at: str):
+        if not isinstance(created_at, str):
+            raise TypeError("'created_at' must be a string.")
+
+    creator_id: Optional[str] = field(
+        default=None, metadata={"docstring": "ID of the creator of the project."},
+    )
+
+    def _validate_creator_id(self, creator_id: Optional[str]):
+        if creator_id is not None and not isinstance(creator_id, str):
+            raise TypeError("'creator_id' must be a string.")
+
+    parent_cloud_id: Optional[str] = field(
+        default=None, metadata={"docstring": "ID of the parent cloud."},
+    )
+
+    def _validate_parent_cloud_id(self, parent_cloud_id: Optional[str]):
+        if parent_cloud_id is not None and not isinstance(parent_cloud_id, str):
+            raise TypeError("'parent_cloud_id' must be a string.")
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ProjectMinimal":
+        # remove any fields that are not in the dataclass
+        valid_fields = {field_.name for field_ in fields(cls)}
+        filtered_data = {k: v for k, v in data.items() if k in valid_fields}
+        return cls(**filtered_data)
+
+
+@dataclass(frozen=True)
+class Project(ProjectMinimal):
+    """Project object.
+    """
+
+    __doc_py_example__ = """\
+import anyscale
+from anyscale.project.models import Project
+
+project: Project = anyscale.project.get(project_id="my-project-id")
+"""
+
+    is_owner: bool = field(
+        default=False,
+        metadata={"docstring": "Whether the user is the owner of the project."},
+    )
+
+    def _validate_is_owner(self, is_owner: bool):
+        if not isinstance(is_owner, bool):
+            raise TypeError("'is_owner' must be a boolean.")
+
+    is_read_only: bool = field(
+        default=False,
+        metadata={"docstring": "Whether the user has read-only access to the project."},
+    )
+
+    def _validate_is_read_only(self, is_read_only: bool):
+        if not isinstance(is_read_only, bool):
+            raise TypeError("'is_read_only' must be a boolean.")
+
+    directory_name: str = field(
+        default="",
+        metadata={
+            "docstring": "Directory name of project to be used as working directory of clusters."
+        },
+    )
+
+    def _validate_directory_name(self, directory_name: str):
+        if not isinstance(directory_name, str):
+            raise TypeError("'directory_name' must be a string.")
+
+    is_default: bool = field(
+        default=False,
+        metadata={
+            "docstring": "Whether the project is the default project for the organization."
+        },
+    )
+
+    def _validate_is_default(self, is_default: bool):
+        if not isinstance(is_default, bool):
+            raise TypeError("'is_default' must be a boolean.")
+
+    initial_cluster_config: Optional[Union[str, Dict[str, Any]]] = field(
+        default=None,
+        metadata={"docstring": "Initial cluster config associated with the project."},
+    )
+
+    def _validate_initial_cluster_config(
+        self, initial_cluster_config: Union[str, Dict[str, Any], None]
+    ):
+        if initial_cluster_config is not None and not isinstance(
+            initial_cluster_config, (str, dict)
+        ):
+            raise TypeError("'initial_cluster_config' must be a string or dictionary.")
+
+    last_used_cloud_id: Optional[str] = field(
+        default=None,
+        metadata={
+            "docstring": "ID of the last cloud used in this project, or by the user if this is a new project."
+        },
+    )
+
+    def _validate_last_used_cloud_id(self, last_used_cloud_id: Optional[str]):
+        if last_used_cloud_id is not None and not isinstance(last_used_cloud_id, str):
+            raise TypeError("'last_used_cloud_id' must be a string.")
+
+    owners: List[str] = field(
+        default_factory=list,
+        metadata={
+            "docstring": "List of IDs of users who have owner access to the project."
+        },
+    )
+
+    def _validate_owners(self, owners: List[str]):
+        if not isinstance(owners, list):
+            raise TypeError("'owners' must be a list.")
+        for owner in owners:
+            if not isinstance(owner, str):
+                raise TypeError(f"'{owner}' must be a string.")
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "Project":
+        data = d.copy()
+        # convert datetime fields to string
+        for field_ in fields(cls):
+            if field_.name in data and isinstance(data[field_.name], datetime):
+                data[field_.name] = data[field_.name].strftime("%Y-%m-%d %H:%M:%S")
+
+        # convert initial_cluster_config JSON string to dict
+        if "initial_cluster_config" in data and isinstance(
+            data["initial_cluster_config"], str
+        ):
+            with contextlib.suppress(json.JSONDecodeError):
+                data["initial_cluster_config"] = json.loads(
+                    data["initial_cluster_config"]
+                )
+
+        # convert owners list of dicts to list of string IDs
+        if "owners" in data and isinstance(data["owners"], list):
+            data["owners"] = [owner.get("id") for owner in data["owners"]]
+
+        # remove any fields that are not in the dataclass
+        valid_fields = {field_.name for field_ in fields(cls)}
+        filtered_data = {k: v for k, v in data.items() if k in valid_fields}
+        return cls(**filtered_data)
+
+
+class ProjectSortField(ModelEnum):
+    """Field to sort projects by."""
+
+    NAME = "NAME"
+
+    __docstrings__ = {
+        NAME: "Sort by project name.",
+    }
+
+
+class ProjectSortOrder(ModelEnum):
+    """Direction of sorting."""
+
+    ASC = "ASC"
+    DESC = "DESC"
+
+    __docstrings__ = {
+        ASC: "Sort in ascending order.",
+        DESC: "Sort in descending order.",
+    }