hydroserverpy 1.5.1__py3-none-any.whl

hydroserverpy/api/services/etl/data_source.py

@@ -0,0 +1,163 @@
+from typing import Optional, Union, List, Literal, TYPE_CHECKING
+from uuid import UUID
+from datetime import datetime
+from hydroserverpy.api.models import DataSource
+from hydroserverpy.api.utils import normalize_uuid
+from ..base import HydroServerBaseService
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace, OrchestrationSystem, Datastream
+
+
+class DataSourceService(HydroServerBaseService):
+    def __init__(self, client: "HydroServer"):
+        self.model = DataSource
+        super().__init__(client)
+
+    def list(
+        self,
+        page: int = ...,
+        page_size: int = ...,
+        order_by: List[str] = ...,
+        workspace: Optional[Union["Workspace", UUID, str]] = ...,
+        datastream: Optional[Union["Datastream", UUID, str]] = ...,
+        orchestration_system: Optional[Union["OrchestrationSystem", UUID, str]] = ...,
+        fetch_all: bool = False,
+    ) -> List["DataSource"]:
+        """Fetch a collection of data sources."""
+
+        return super().list(
+            page=page,
+            page_size=page_size,
+            order_by=order_by,
+            workspace_id=normalize_uuid(workspace),
+            datastream_id=normalize_uuid(datastream),
+            orchestration_system_id=normalize_uuid(orchestration_system),
+            fetch_all=fetch_all,
+        )
+
+    def create(
+        self,
+        name: str,
+        workspace: Union["Workspace", UUID, str],
+        orchestration_system: Union["OrchestrationSystem", UUID, str],
+        settings: Optional[dict] = None,
+        interval: Optional[int] = None,
+        interval_units: Optional[Literal["minutes", "hours", "days"]] = None,
+        crontab: Optional[str] = None,
+        start_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
+        last_run_successful: Optional[bool] = None,
+        last_run_message: Optional[str] = None,
+        last_run: Optional[datetime] = None,
+        next_run: Optional[datetime] = None,
+        paused: bool = False,
+        datastreams: Optional[List[Union["Datastream", UUID, str]]] = None,
+    ) -> "DataSource":
+        """Create a new data source."""
+
+        body = {
+            "name": name,
+            "workspaceId": normalize_uuid(workspace),
+            "orchestrationSystemId": normalize_uuid(orchestration_system),
+            "settings": settings,
+            "schedule": {
+                "interval": interval,
+                "intervalUnits": interval_units,
+                "crontab": crontab,
+                "startTime": start_time,
+                "endTime": end_time,
+            },
+            "status": {
+                "lastRunSuccessful": last_run_successful,
+                "lastRunMessage": last_run_message,
+                "lastRun": last_run,
+                "nextRun": next_run,
+                "paused": paused,
+            },
+            "datastreamIds": (
+                [normalize_uuid(datastream) for datastream in datastreams]
+                if datastreams
+                else []
+            ),
+        }
+
+        return super().create(**body)
+
+    def update(
+        self,
+        uid: Union[UUID, str],
+        name: str = ...,
+        orchestration_system: Union["OrchestrationSystem", UUID, str] = ...,
+        settings: Optional[dict] = ...,
+        interval: Optional[int] = ...,
+        interval_units: Optional[Literal["minutes", "hours", "days"]] = ...,
+        crontab: Optional[str] = ...,
+        start_time: Optional[datetime] = ...,
+        end_time: Optional[datetime] = ...,
+        last_run_successful: Optional[bool] = ...,
+        last_run_message: Optional[str] = ...,
+        last_run: Optional[datetime] = ...,
+        next_run: Optional[datetime] = ...,
+        paused: bool = ...,
+    ) -> "DataSource":
+        """Update a data source."""
+
+        status_body = {
+            k: v
+            for k, v in {
+                "lastRunSuccessful": last_run_successful,
+                "lastRunMessage": last_run_message,
+                "lastRun": last_run,
+                "nextRun": next_run,
+                "paused": paused,
+            }.items()
+            if v is not ...
+        }
+        status_body = status_body if status_body else ...
+
+        schedule_body = {
+            k: v
+            for k, v in {
+                "interval": interval,
+                "intervalUnits": interval_units,
+                "crontab": crontab,
+                "startTime": start_time,
+                "endTime": end_time,
+            }.items()
+            if v is not ...
+        }
+        schedule_body = schedule_body if schedule_body else ...
+
+        body = {
+            k: v
+            for k, v in {
+                "name": name,
+                "orchestrationSystemId": getattr(
+                    orchestration_system, "uid", orchestration_system
+                ),
+                "settings": settings,
+                "schedule": schedule_body,
+                "status": status_body,
+            }.items()
+            if v is not ...
+        }
+
+        return super().update(uid=str(uid), **body)
+
+    def add_datastream(
+        self, uid: Union[UUID, str], datastream: Union["Datastream", UUID, str]
+    ) -> None:
+        """Add a datastream to this data source."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/datastreams/{normalize_uuid(datastream)}"
+        self.client.request("put", path)
+
+    def remove_datastream(
+        self, uid: Union[UUID, str], datastream: Union["Datastream", UUID, str]
+    ) -> None:
+        """Remove a datastream from this data source."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/datastreams/{normalize_uuid(datastream)}"
+        self.client.request("delete", path)

hydroserverpy/api/services/etl/orchestration_system.py

@@ -0,0 +1,66 @@
+from typing import Optional, Union, List, TYPE_CHECKING
+from uuid import UUID
+from hydroserverpy.api.models import OrchestrationSystem
+from hydroserverpy.api.utils import normalize_uuid
+from ..base import HydroServerBaseService
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class OrchestrationSystemService(HydroServerBaseService):
+    def __init__(self, client: "HydroServer"):
+        self.model = OrchestrationSystem
+        super().__init__(client)
+
+    def list(
+        self,
+        page: int = ...,
+        page_size: int = ...,
+        order_by: List[str] = ...,
+        workspace: Optional[Union["Workspace", UUID, str]] = ...,
+        orchestration_system_type: str = ...,
+        fetch_all: bool = False,
+    ) -> List["OrchestrationSystem"]:
+        """Fetch a collection of orchestration systems."""
+
+        return super().list(
+            page=page,
+            page_size=page_size,
+            order_by=order_by,
+            workspace_id=normalize_uuid(workspace),
+            type=orchestration_system_type,
+            fetch_all=fetch_all,
+        )
+
+    def create(
+        self,
+        name: str,
+        orchestration_system_type: str,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+    ) -> "OrchestrationSystem":
+        """Create a new orchestration system."""
+
+        body = {
+            "name": name,
+            "type": orchestration_system_type,
+            "workspaceId": normalize_uuid(workspace),
+        }
+
+        return super().create(**body)
+
+    def update(
+        self,
+        uid: Union[UUID, str],
+        name: str = ...,
+        orchestration_system_type: str = ...,
+    ) -> "OrchestrationSystem":
+        """Update an orchestration system."""
+
+        body = {
+            "name": name,
+            "type": orchestration_system_type,
+        }
+
+        return super().update(uid=str(uid), **body)

hydroserverpy/api/services/iam/role.py

@@ -0,0 +1,38 @@
+from typing import TYPE_CHECKING, Union, List, Optional
+from uuid import UUID
+from hydroserverpy.api.models import Role
+from hydroserverpy.api.utils import normalize_uuid
+from ..base import HydroServerBaseService
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class RoleService(HydroServerBaseService):
+    def __init__(self, client: "HydroServer"):
+        self.model = Role
+        super().__init__(client)
+
+    def list(
+        self,
+        page: int = ...,
+        page_size: int = ...,
+        order_by: List[str] = ...,
+        workspace: Optional[Union["Workspace", UUID, str]] = ...,
+        is_user_role: bool = ...,
+        is_apikey_role: bool = ...,
+        fetch_all: bool = False,
+    ) -> List["Role"]:
+        """Fetch a collection of HydroServer roles."""
+
+        return super().list(
+            page=page,
+            page_size=page_size,
+            order_by=order_by,
+            fetch_all=fetch_all,
+            workspace_id=normalize_uuid(workspace),
+            is_user_role=is_user_role,
+            is_apikey_role=is_apikey_role,
+        )

hydroserverpy/api/services/iam/workspace.py

@@ -0,0 +1,232 @@
+import json
+from typing import TYPE_CHECKING, Union, List, Tuple, Optional
+from pydantic import EmailStr
+from uuid import UUID
+from datetime import datetime
+from hydroserverpy.api.models import Workspace, Role, Collaborator, APIKey
+from hydroserverpy.api.utils import normalize_uuid
+from ..base import HydroServerBaseService
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+
+
+class WorkspaceService(HydroServerBaseService):
+    def __init__(self, client: "HydroServer"):
+        self.model = Workspace
+        super().__init__(client)
+
+    def list(
+        self,
+        page: int = ...,
+        page_size: int = ...,
+        order_by: List[str] = ...,
+        is_private: bool = ...,
+        is_associated: bool = ...,
+        fetch_all: bool = False,
+    ) -> List["Workspace"]:
+        """Fetch a collection of HydroServer workspaces."""
+
+        return super().list(
+            page=page,
+            page_size=page_size,
+            order_by=order_by,
+            fetch_all=fetch_all,
+            is_private=is_private,
+            is_associated=is_associated,
+        )
+
+    def create(self, name: str, is_private: bool, **_) -> "Workspace":
+        """Create a new workspace."""
+
+        return super().create(
+            name=name,
+            is_private=is_private,
+        )
+
+    def update(
+        self, uid: Union[UUID, str], name: str = ..., is_private: bool = ..., **_
+    ) -> "Workspace":
+        """Update a workspace."""
+
+        return super().update(
+            uid=uid,
+            name=name,
+            is_private=is_private,
+        )
+
+    def list_collaborators(self, uid: Union[UUID, str]) -> List["Collaborator"]:
+        """Get all collaborators associated with a workspace."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/collaborators"
+        response = self.client.request("get", path)
+
+        return [
+            Collaborator(client=self.client, uid=None, workspace_id=uid, **obj)
+            for obj in response.json()
+        ]
+
+    def add_collaborator(
+        self, uid: Union[UUID, str], email: EmailStr, role: Union["Role", UUID, str]
+    ) -> "Collaborator":
+        """Add a collaborator to a workspace."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/collaborators"
+        headers = {"Content-type": "application/json"}
+        body = {
+            "email": email,
+            "roleId": normalize_uuid(role)
+        }
+        response = self.client.request(
+            "post", path, headers=headers, data=json.dumps(body, default=self.default_serializer)
+        ).json()
+
+        return Collaborator(
+            client=self.client, uid=None, workspace_id=uid, **response
+        )
+
+    def edit_collaborator_role(
+        self, uid: Union[UUID, str], email: EmailStr, role: Union["Role", UUID, str]
+    ) -> "Collaborator":
+        """Edit the role of a collaborator in a workspace."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/collaborators"
+        headers = {"Content-type": "application/json"}
+        body = {
+            "email": email,
+            "roleId": normalize_uuid(role)
+        }
+
+        response = self.client.request(
+            "put", path, headers=headers, data=json.dumps(body, default=self.default_serializer)
+        )
+
+        return Collaborator(
+            client=self.client, uid=None, workspace_id=uid, **response.json()
+        )
+
+    def remove_collaborator(self, uid: Union[UUID, str], email: EmailStr) -> None:
+        """Remove a collaborator from a workspace."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/collaborators"
+        self.client.request("delete", path, json={"email": email})
+
+    def list_api_keys(self, uid: Union[UUID, str]) -> List["APIKey"]:
+        """Get all API keys associated with a workspace."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/api-keys"
+        response = self.client.request("get", path)
+
+        return [
+            APIKey(client=self.client, **obj)
+            for obj in response.json()
+        ]
+
+    def get_api_key(self, uid: Union[UUID, str], api_key_id: Union[UUID, str]) -> "APIKey":
+        """Get an API key associated with a workspace."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/api-keys/{api_key_id}"
+        response = self.client.request("get", path)
+
+        return APIKey(client=self.client, **response.json())
+
+    def create_api_key(
+        self,
+        uid: Union[UUID, str],
+        name: str,
+        role: Union["Role", UUID, str],
+        description: Optional[str] = None,
+        is_active: bool = True,
+        expires_at: Optional[datetime] = None
+    ) -> Tuple["APIKey", str]:
+        """Create an API key for a workspace."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/api-keys"
+        headers = {"Content-type": "application/json"}
+        body = {
+            "roleId": normalize_uuid(role),
+            "name": name,
+            "description": description,
+            "isActive": is_active,
+            "expiresAt": expires_at
+        }
+
+        response = self.client.request(
+            "post", path, headers=headers, data=json.dumps(body, default=self.default_serializer),
+        ).json()
+
+        return APIKey(
+            client=self.client, **response
+        ), response["key"]
+
+    def update_api_key(
+        self,
+        uid: Union[UUID, str],
+        api_key_id: Union[UUID, str],
+        role: Union["Role", UUID, str] = ...,
+        name: str = ...,
+        description: Optional[str] = ...,
+        is_active: bool = ...,
+        expires_at: Optional[datetime] = ...
+    ) -> "APIKey":
+        """Update an existing API key."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/api-keys/{api_key_id}"
+        headers = {"Content-type": "application/json"}
+        body = {
+            "roleId": normalize_uuid(role),
+            "name": name,
+            "description": description,
+            "isActive": is_active,
+            "expiresAt": expires_at
+        }
+        body = {k: v for k, v in body.items() if v is not ...}
+
+        response = self.client.request(
+            "patch", path, headers=headers, data=json.dumps(body, default=self.default_serializer),
+        ).json()
+
+        return APIKey(client=self.client, **response)
+
+    def delete_api_key(
+        self,
+        uid: Union[UUID, str],
+        api_key_id: Union[UUID, str]
+    ):
+        """Delete an existing API key."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/api-keys/{api_key_id}"
+        self.client.request("delete", path)
+
+    def regenerate_api_key(
+        self,
+        uid: Union[UUID, str],
+        api_key_id: Union[UUID, str]
+    ):
+        """Regenerate an existing API key."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/api-keys/{api_key_id}/regenerate"
+        response = self.client.request("put", path).json()
+
+        return APIKey(
+            client=self.client, **response
+        ), response["key"]
+
+    def transfer_ownership(self, uid: Union[UUID, str], email: str) -> None:
+        """Transfer ownership of a workspace to another HydroServer user."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/transfer"
+        self.client.request("post", path, json={"newOwner": email})
+
+    def accept_ownership_transfer(self, uid: Union[UUID, str]) -> None:
+        """Accept ownership transfer of a workspace."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/transfer"
+        self.client.request("put", path)
+
+    def cancel_ownership_transfer(self, uid: Union[UUID, str]) -> None:
+        """Cancel ownership transfer of a workspace."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/transfer"
+        self.client.request("delete", path)