hydroserverpy 0.4.0__py3-none-any.whl → 0.5.0b2__py3-none-any.whl

hydroserverpy/api/services/etl/data_archive.py

@@ -0,0 +1,196 @@
+from datetime import datetime
+from typing import Optional, Literal, Union, List, TYPE_CHECKING
+from uuid import UUID
+from ..base import EndpointService
+from hydroserverpy.api.models import DataArchive, Datastream
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace, OrchestrationSystem
+
+
+class DataArchiveService(EndpointService):
+    def __init__(self, connection: "HydroServer"):
+        self._model = DataArchive
+        self._api_route = "api/data"
+        self._endpoint_route = "data-archives"
+
+        super().__init__(connection)
+
+    def list(
+        self,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+        orchestration_system: Optional[Union["OrchestrationSystem", UUID, str]] = None,
+    ) -> List["DataArchive"]:
+        """Fetch a collection of data archives."""
+
+        params = {}
+
+        workspace_id = getattr(workspace, "uid", workspace)
+        workspace_id = str(workspace_id) if workspace_id else None
+
+        orchestration_system_id = getattr(
+            orchestration_system, "uid", orchestration_system
+        )
+        orchestration_system_id = (
+            str(orchestration_system_id) if orchestration_system_id else None
+        )
+
+        if workspace_id:
+            params["workspace_id"] = workspace_id
+
+        if orchestration_system_id:
+            params["orchestration_system_id"] = orchestration_system_id
+
+        return super()._list(
+            params=params,
+        )
+
+    def get(self, uid: Union[UUID, str]) -> "DataArchive":
+        """Get a data archive by ID."""
+
+        return super()._get(uid=str(uid))
+
+    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,
+    ) -> "DataArchive":
+        """Create a new data archive."""
+
+        kwargs = {
+            "name": name,
+            "workspaceId": str(getattr(workspace, "uid", workspace)),
+            "orchestrationSystemId": getattr(
+                orchestration_system, "uid", 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": (
+                [
+                    str(getattr(datastream, "uid", datastream))
+                    for datastream in datastreams
+                ]
+                if datastreams
+                else []
+            ),
+        }
+
+        return super()._create(**kwargs)
+
+    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 = ...,
+    ) -> "DataArchive":
+        """Update a data archive."""
+
+        status_kwargs = {
+            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_kwargs = status_kwargs if status_kwargs else ...
+
+        schedule_kwargs = {
+            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_kwargs = schedule_kwargs if schedule_kwargs else ...
+
+        kwargs = {
+            k: v
+            for k, v in {
+                "name": name,
+                "orchestrationSystemId": getattr(
+                    orchestration_system, "uid", orchestration_system
+                ),
+                "settings": settings,
+                "schedule": schedule_kwargs,
+                "status": status_kwargs,
+            }.items()
+            if v is not ...
+        }
+
+        return super()._update(uid=str(uid), **kwargs)
+
+    def delete(self, uid: Union[UUID, str]) -> None:
+        """Delete a data archive."""
+
+        super()._delete(uid=str(uid))
+
+    def add_datastream(
+        self, uid: Union[UUID, str], datastream: Union["Datastream", UUID, str]
+    ) -> None:
+        """Add a datastream to this data archive."""
+
+        datastream_id = str(getattr(datastream, "uid", datastream))
+
+        self._connection.request(
+            "post",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/datastreams/{datastream_id}",
+        )
+
+    def remove_datastream(
+        self, uid: Union[UUID, str], datastream: Union["Datastream", UUID, str]
+    ) -> None:
+        """Remove a datastream from this data archive."""
+
+        datastream_id = str(getattr(datastream, "uid", datastream))
+
+        self._connection.request(
+            "delete",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/datastreams/{datastream_id}",
+        )

hydroserverpy/api/services/etl/data_source.py

@@ -0,0 +1,196 @@
+from datetime import datetime
+from typing import Optional, Literal, Union, List, TYPE_CHECKING
+from uuid import UUID
+from ..base import EndpointService
+from hydroserverpy.api.models import DataSource, Datastream
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace, OrchestrationSystem
+
+
+class DataSourceService(EndpointService):
+    def __init__(self, connection: "HydroServer"):
+        self._model = DataSource
+        self._api_route = "api/data"
+        self._endpoint_route = "data-sources"
+
+        super().__init__(connection)
+
+    def list(
+        self,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+        orchestration_system: Optional[Union["OrchestrationSystem", UUID, str]] = None,
+    ) -> List["DataSource"]:
+        """Fetch a collection of data sources."""
+
+        params = {}
+
+        workspace_id = getattr(workspace, "uid", workspace)
+        workspace_id = str(workspace_id) if workspace_id else None
+
+        orchestration_system_id = getattr(
+            orchestration_system, "uid", orchestration_system
+        )
+        orchestration_system_id = (
+            str(orchestration_system_id) if orchestration_system_id else None
+        )
+
+        if workspace_id:
+            params["workspace_id"] = workspace_id
+
+        if orchestration_system_id:
+            params["orchestration_system_id"] = orchestration_system_id
+
+        return super()._list(
+            params=params,
+        )
+
+    def get(self, uid: Union[UUID, str]) -> "DataSource":
+        """Get a data source by ID."""
+
+        return super()._get(uid=str(uid))
+
+    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."""
+
+        kwargs = {
+            "name": name,
+            "workspaceId": str(getattr(workspace, "uid", workspace)),
+            "orchestrationSystemId": getattr(
+                orchestration_system, "uid", 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": (
+                [
+                    str(getattr(datastream, "uid", datastream))
+                    for datastream in datastreams
+                ]
+                if datastreams
+                else []
+            ),
+        }
+
+        return super()._create(**kwargs)
+
+    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_kwargs = {
+            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_kwargs = status_kwargs if status_kwargs else ...
+
+        schedule_kwargs = {
+            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_kwargs = schedule_kwargs if schedule_kwargs else ...
+
+        kwargs = {
+            k: v
+            for k, v in {
+                "name": name,
+                "orchestrationSystemId": getattr(
+                    orchestration_system, "uid", orchestration_system
+                ),
+                "settings": settings,
+                "schedule": schedule_kwargs,
+                "status": status_kwargs,
+            }.items()
+            if v is not ...
+        }
+
+        return super()._update(uid=str(uid), **kwargs)
+
+    def delete(self, uid: Union[UUID, str]) -> None:
+        """Delete a data source."""
+
+        super()._delete(uid=str(uid))
+
+    def add_datastream(
+        self, uid: Union[UUID, str], datastream: Union["Datastream", UUID, str]
+    ) -> None:
+        """Add a datastream to this data source."""
+
+        datastream_id = str(getattr(datastream, "uid", datastream))
+
+        self._connection.request(
+            "post",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/datastreams/{datastream_id}",
+        )
+
+    def remove_datastream(
+        self, uid: Union[UUID, str], datastream: Union["Datastream", UUID, str]
+    ) -> None:
+        """Remove a datastream from this data source."""
+
+        datastream_id = str(getattr(datastream, "uid", datastream))
+
+        self._connection.request(
+            "delete",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/datastreams/{datastream_id}",
+        )

hydroserverpy/api/services/etl/orchestration_system.py

@@ -0,0 +1,74 @@
+from typing import Optional, Union, List, TYPE_CHECKING
+from uuid import UUID
+from ..base import EndpointService
+from hydroserverpy.api.models import OrchestrationSystem
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class OrchestrationSystemService(EndpointService):
+    def __init__(self, connection: "HydroServer"):
+        self._model = OrchestrationSystem
+        self._api_route = "api/data"
+        self._endpoint_route = "orchestration-systems"
+
+        super().__init__(connection)
+
+    def list(
+        self,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+    ) -> List["OrchestrationSystem"]:
+        """Fetch a collection of orchestration systems."""
+
+        workspace_id = getattr(workspace, "uid", workspace)
+        workspace_id = str(workspace_id) if workspace_id else None
+
+        return super()._list(
+            params={"workspace_id": workspace_id} if workspace_id else {},
+        )
+
+    def get(self, uid: Union[UUID, str]) -> "OrchestrationSystem":
+        """Get an orchestration system by ID."""
+
+        return super()._get(uid=str(uid))
+
+    def create(
+        self,
+        workspace: Union["Workspace", UUID, str],
+        name: str,
+        orchestration_system_type: str,
+    ) -> "OrchestrationSystem":
+        """Create a new orchestration system."""
+
+        kwargs = {
+            "name": name,
+            "type": orchestration_system_type,
+            "workspaceId": str(getattr(workspace, "uid", workspace)),
+        }
+
+        return super()._create(**kwargs)
+
+    def update(
+        self,
+        uid: Union[UUID, str],
+        name: str = ...,
+        orchestration_system_type: str = ...,
+    ) -> "OrchestrationSystem":
+        """Update an orchestration system."""
+
+        kwargs = {
+            "name": name,
+            "type": orchestration_system_type,
+        }
+
+        return super()._update(
+            uid=str(uid), **{k: v for k, v in kwargs.items() if v is not ...}
+        )
+
+    def delete(self, uid: Union[UUID, str]) -> None:
+        """Delete an orchestration system."""
+
+        super()._delete(uid=str(uid))

hydroserverpy/api/services/iam/workspace.py

@@ -0,0 +1,126 @@
+from typing import TYPE_CHECKING, Union, List
+from pydantic import EmailStr
+from uuid import UUID
+from hydroserverpy.api.models import Workspace, Role, Collaborator
+from ..base import EndpointService
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+
+
+class WorkspaceService(EndpointService):
+    def __init__(self, connection: "HydroServer"):
+        self._model = Workspace
+        self._api_route = "api/auth"
+        self._endpoint_route = "workspaces"
+
+        super().__init__(connection)
+
+    def list(self, associated_only: bool = False) -> List["Workspace"]:
+        """Fetch a collection of HydroServer resources."""
+
+        return super()._list(params={"associated_only": associated_only})
+
+    def get(self, uid: Union[UUID, str]) -> "Workspace":
+        """Get a workspace by ID."""
+
+        return super()._get(uid=str(uid))
+
+    def create(self, name: str, is_private: bool, **_) -> "Workspace":
+        """Create a new workspace."""
+
+        kwargs = {"name": name, "isPrivate": is_private}
+
+        return super()._create(**kwargs)
+
+    def update(
+        self, uid: Union[UUID, str], name: str = ..., is_private: bool = ..., **_
+    ) -> "Workspace":
+        """Update a workspace."""
+
+        kwargs = {"name": name, "isPrivate": is_private}
+
+        return super()._update(
+            uid=str(uid), **{k: v for k, v in kwargs.items() if v is not ...}
+        )
+
+    def delete(self, uid: Union[UUID, str]) -> None:
+        """Delete a workspace."""
+
+        super()._delete(uid=str(uid))
+
+    def list_roles(self, uid: Union[UUID, str]) -> List["Role"]:
+        """Get all roles that can be assigned within a workspace."""
+
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}/roles"
+        response = self._connection.request("get", path)
+
+        return [Role(**obj) for obj in response.json()]
+
+    def list_collaborators(self, uid: Union[UUID, str]) -> List["Collaborator"]:
+        """Get all collaborators associated with a workspace."""
+
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}/collaborators"
+        response = self._connection.request("get", path)
+
+        return [
+            Collaborator(_connection=self._connection, 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._api_route}/{self._endpoint_route}/{str(uid)}/collaborators"
+        response = self._connection.request(
+            "post",
+            path,
+            json={"email": email, "roleId": str(getattr(role, "uid", role))},
+        )
+
+        return Collaborator(
+            _connection=self._connection, workspace_id=uid, **response.json()
+        )
+
+    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._api_route}/{self._endpoint_route}/{str(uid)}/collaborators"
+        response = self._connection.request(
+            "put",
+            path,
+            json={"email": email, "roleId": str(getattr(role, "uid", role))},
+        )
+
+        return Collaborator(
+            _connection=self._connection, 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._api_route}/{self._endpoint_route}/{str(uid)}/collaborators"
+        self._connection.request("delete", path, json={"email": email})
+
+    def transfer_ownership(self, uid: Union[UUID, str], email: str) -> None:
+        """Transfer ownership of a workspace to another HydroServer user."""
+
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}/transfer"
+        self._connection.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._api_route}/{self._endpoint_route}/{str(uid)}/transfer"
+        self._connection.request("put", path)
+
+    def cancel_ownership_transfer(self, uid: Union[UUID, str]) -> None:
+        """Cancel ownership transfer of a workspace."""
+
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}/transfer"
+        self._connection.request("delete", path)