hydroserverpy 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

hydroserverpy/api/services/base.py

@@ -1,102 +1,118 @@
-from typing import TYPE_CHECKING, Type, Union, Optional
+import json
+import uuid
+from typing import TYPE_CHECKING, Type, List, Union
 from datetime import datetime
-from uuid import UUID
+from hydroserverpy.api.models.base import HydroServerBaseModel, HydroServerCollection
+from hydroserverpy.api.utils import order_by_to_camel
 
 if TYPE_CHECKING:
     from hydroserverpy import HydroServer
-    from hydroserverpy.api.models.base import HydroServerModel
 
 
-class EndpointService:
-    _model: Type["HydroServerModel"]
-    _api_route: str
-    _endpoint_route: str
+class HydroServerBaseService:
+    model: Type[HydroServerBaseModel]
 
-    def __init__(self, connection: "HydroServer") -> None:
-        self._connection = connection
+    def __init__(self, client: "HydroServer") -> None:
+        self.client = client
 
-    def _list(self, params: Optional[dict] = None):
-        path = f"/{self._api_route}/{self._endpoint_route}"
-
-        response = self._connection.request("get", path, params=params).json()
+    def list(
+        self,
+        page: int = ...,
+        page_size: int = ...,
+        order_by: List[str] = ...,
+        fetch_all: bool = False,
+        **kwargs
+    ):
+        kwargs = {
+            k: v for k, v in kwargs.items() if v is not ...
+        }
+        params = kwargs.copy()
+        params.update({
+            "page": page,
+            "page_size": page_size,
+            "order_by": [order_by_to_camel(order) for order in order_by] if order_by is not ... else order_by
+        })
+        params = {
+            k: ("null" if v is None else v)
+            for k, v in params.items()
+            if v is not ...
+        }
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}"
+        response = self.client.request("get", path, params=params)
+        collection = HydroServerCollection(
+            model=self.model,
+            client=self.client,
+            service=self,
+            response=response,
+            order_by=params.get("order_by"),
+            filters={
+                (k[:-3] if k.endswith("_id") else k): v
+                for k, v in kwargs.items()
+            }
+        )
+        if fetch_all is True:
+            collection = collection.fetch_all()
 
-        return [
-            self._model(
-                _connection=self._connection, _uid=UUID(str(obj.pop("id"))), **obj
-            )
-            for obj in response
-        ]
+        return collection
 
-    def _get(self, uid: Union[UUID, str]):
-        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}"
-        response = self._connection.request("get", path).json()
+    def get(
+        self,
+        uid: Union[uuid.UUID, str]
+    ):
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}"
+        response = self.client.request("get", path).json()
 
-        return self._model(
-            _connection=self._connection, _uid=UUID(str(response.pop("id"))), **response
+        return self.model(
+            client=self.client, uid=uuid.UUID(str(response.pop("id"))), **response
         )
 
-    def _create(self, **kwargs):
-        path = f"/{self._api_route}/{self._endpoint_route}"
+    def create(self, **kwargs):
+        path = f"/{self.client.base_route}/{self.model.get_route()}"
         headers = {"Content-type": "application/json"}
-        response = self._connection.request(
-            "post", path, headers=headers, json=self._to_iso_time(kwargs)
+        response = self.client.request(
+            "post", path, headers=headers, data=json.dumps(kwargs, default=self.default_serializer)
         ).json()
 
-        return self._model(
-            _connection=self._connection, _uid=UUID(str(response.pop("id"))), **response
+        return self.model(
+            client=self.client, uid=uuid.UUID(str(response.pop("id"))), **response
         )
 
-    def _update(self, uid: Union[UUID, str], **kwargs):
-        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}"
+    def update(
+        self,
+        uid: Union[uuid.UUID, str],
+        **kwargs
+    ):
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}"
         headers = {"Content-type": "application/json"}
-        response = self._connection.request(
-            "patch", path, headers=headers, json=self._to_iso_time(kwargs)
+        body = self.prune_unset(kwargs) or {}
+        response = self.client.request(
+            "patch", path, headers=headers, data=json.dumps(body, default=self.default_serializer)
         ).json()
 
-        return self._model(
-            _connection=self._connection, _uid=UUID(str(response.pop("id"))), **response
+        return self.model(
+            client=self.client, uid=uuid.UUID(str(response.pop("id"))), **response
         )
 
-    def _delete(self, uid: Union[UUID, str]):
-        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}"
-        response = self._connection.request("delete", path)
-
-        return response
+    def delete(
+        self,
+        uid: Union[uuid.UUID, str]
+    ) -> None:
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}"
+        self.client.request("delete", path)
+
+    @staticmethod
+    def default_serializer(obj):
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        raise TypeError(f"Type {type(obj)} not serializable")
 
-    def _to_iso_time(self, obj):
+    def prune_unset(self, obj):
         if isinstance(obj, dict):
-            return {k: self._to_iso_time(v) for k, v in obj.items()}
-        elif isinstance(obj, list):
-            return [self._to_iso_time(i) for i in obj]
-        elif isinstance(obj, datetime):
-            return obj.isoformat()
+            cleaned = {
+                k: self.prune_unset(v)
+                for k, v in obj.items()
+                if v is not ... and self.prune_unset(v) is not None
+            }
+            return cleaned if cleaned else None
         return obj
-
-
-class SensorThingsService(EndpointService):
-    _sta_route: str
-
-    def __init__(self, connection) -> None:
-        super().__init__(connection)
-
-    def _list(self, path: Optional[str] = None, params: Optional[dict] = None):
-        path = path or f"/{self._sta_route}"
-        response = self._connection.request("get", path, params=params)
-
-        return [
-            self._model(_connection=self._connection, _uid=obj.pop("@iot.id"), **obj)
-            for obj in response.json()["value"]
-        ]
-
-    def _get(
-        self,
-        uid: Union[UUID, str],
-        path: Optional[str] = None,
-        params: Optional[dict] = None,
-    ):
-        path = path or f"/{self._sta_route}('{str(uid)}')"
-        response = self._connection.request("get", path, params=params).json()
-
-        return self._model(
-            _connection=self._connection, _uid=response.pop("@iot.id"), **response
-        )

hydroserverpy/api/services/etl/data_archive.py

@@ -1,57 +1,42 @@
-from datetime import datetime
-from typing import Optional, Literal, Union, List, TYPE_CHECKING
+from typing import Optional, Union, List, Literal, TYPE_CHECKING
 from uuid import UUID
-from ..base import EndpointService
-from hydroserverpy.api.models import DataArchive, Datastream
-
+from datetime import datetime
+from hydroserverpy.api.models import DataArchive
+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
+    from hydroserverpy.api.models import Workspace, OrchestrationSystem, Datastream
 
 
-class DataArchiveService(EndpointService):
-    def __init__(self, connection: "HydroServer"):
-        self._model = DataArchive
-        self._api_route = "api/data"
-        self._endpoint_route = "data-archives"
-
-        super().__init__(connection)
+class DataArchiveService(HydroServerBaseService):
+    def __init__(self, client: "HydroServer"):
+        self.model = DataArchive
+        super().__init__(client)
 
     def list(
         self,
-        workspace: Optional[Union["Workspace", UUID, str]] = None,
-        orchestration_system: Optional[Union["OrchestrationSystem", UUID, str]] = None,
+        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["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,
+        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 get(self, uid: Union[UUID, str]) -> "DataArchive":
-        """Get a data archive by ID."""
-
-        return super()._get(uid=str(uid))
-
     def create(
         self,
         name: str,
@@ -72,12 +57,10 @@ class DataArchiveService(EndpointService):
     ) -> "DataArchive":
         """Create a new data archive."""
 
-        kwargs = {
+        body = {
             "name": name,
-            "workspaceId": str(getattr(workspace, "uid", workspace)),
-            "orchestrationSystemId": getattr(
-                orchestration_system, "uid", orchestration_system
-            ),
+            "workspaceId": normalize_uuid(workspace),
+            "orchestrationSystemId": normalize_uuid(orchestration_system),
             "settings": settings,
             "schedule": {
                 "interval": interval,
@@ -95,7 +78,7 @@ class DataArchiveService(EndpointService):
             },
             "datastreamIds": (
                 [
-                    str(getattr(datastream, "uid", datastream))
+                    normalize_uuid(datastream)
                     for datastream in datastreams
                 ]
                 if datastreams
@@ -103,7 +86,7 @@ class DataArchiveService(EndpointService):
             ),
         }
 
-        return super()._create(**kwargs)
+        return super().create(**body)
 
     def update(
         self,
@@ -124,7 +107,7 @@ class DataArchiveService(EndpointService):
     ) -> "DataArchive":
         """Update a data archive."""
 
-        status_kwargs = {
+        status_body = {
             k: v
             for k, v in {
                 "lastRunSuccessful": last_run_successful,
@@ -135,9 +118,9 @@ class DataArchiveService(EndpointService):
             }.items()
             if v is not ...
         }
-        status_kwargs = status_kwargs if status_kwargs else ...
+        status_body = status_body if status_body else ...
 
-        schedule_kwargs = {
+        schedule_body = {
             k: v
             for k, v in {
                 "interval": interval,
@@ -148,9 +131,9 @@ class DataArchiveService(EndpointService):
             }.items()
             if v is not ...
         }
-        schedule_kwargs = schedule_kwargs if schedule_kwargs else ...
+        schedule_body = schedule_body if schedule_body else ...
 
-        kwargs = {
+        body = {
             k: v
             for k, v in {
                 "name": name,
@@ -158,39 +141,26 @@ class DataArchiveService(EndpointService):
                     orchestration_system, "uid", orchestration_system
                 ),
                 "settings": settings,
-                "schedule": schedule_kwargs,
-                "status": status_kwargs,
+                "schedule": schedule_body,
+                "status": status_body,
             }.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))
+        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 archive."""
 
-        datastream_id = str(getattr(datastream, "uid", datastream))
-
-        self._connection.request(
-            "post",
-            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/datastreams/{datastream_id}",
-        )
+        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 archive."""
 
-        datastream_id = str(getattr(datastream, "uid", datastream))
-
-        self._connection.request(
-            "delete",
-            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/datastreams/{datastream_id}",
-        )
+        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/data_source.py

@@ -1,57 +1,42 @@
-from datetime import datetime
-from typing import Optional, Literal, Union, List, TYPE_CHECKING
+from typing import Optional, Union, List, Literal, TYPE_CHECKING
 from uuid import UUID
-from ..base import EndpointService
-from hydroserverpy.api.models import DataSource, Datastream
-
+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
+    from hydroserverpy.api.models import Workspace, OrchestrationSystem, Datastream
 
 
-class DataSourceService(EndpointService):
-    def __init__(self, connection: "HydroServer"):
-        self._model = DataSource
-        self._api_route = "api/data"
-        self._endpoint_route = "data-sources"
-
-        super().__init__(connection)
+class DataSourceService(HydroServerBaseService):
+    def __init__(self, client: "HydroServer"):
+        self.model = DataSource
+        super().__init__(client)
 
     def list(
         self,
-        workspace: Optional[Union["Workspace", UUID, str]] = None,
-        orchestration_system: Optional[Union["OrchestrationSystem", UUID, str]] = None,
+        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."""
 
-        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,
+        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 get(self, uid: Union[UUID, str]) -> "DataSource":
-        """Get a data source by ID."""
-
-        return super()._get(uid=str(uid))
-
     def create(
         self,
         name: str,
@@ -72,12 +57,10 @@ class DataSourceService(EndpointService):
     ) -> "DataSource":
         """Create a new data source."""
 
-        kwargs = {
+        body = {
             "name": name,
-            "workspaceId": str(getattr(workspace, "uid", workspace)),
-            "orchestrationSystemId": getattr(
-                orchestration_system, "uid", orchestration_system
-            ),
+            "workspaceId": normalize_uuid(workspace),
+            "orchestrationSystemId": normalize_uuid(orchestration_system),
             "settings": settings,
             "schedule": {
                 "interval": interval,
@@ -95,7 +78,7 @@ class DataSourceService(EndpointService):
             },
             "datastreamIds": (
                 [
-                    str(getattr(datastream, "uid", datastream))
+                    normalize_uuid(datastream)
                     for datastream in datastreams
                 ]
                 if datastreams
@@ -103,7 +86,7 @@ class DataSourceService(EndpointService):
             ),
         }
 
-        return super()._create(**kwargs)
+        return super().create(**body)
 
     def update(
         self,
@@ -124,7 +107,7 @@ class DataSourceService(EndpointService):
     ) -> "DataSource":
         """Update a data source."""
 
-        status_kwargs = {
+        status_body = {
             k: v
             for k, v in {
                 "lastRunSuccessful": last_run_successful,
@@ -135,9 +118,9 @@ class DataSourceService(EndpointService):
             }.items()
             if v is not ...
         }
-        status_kwargs = status_kwargs if status_kwargs else ...
+        status_body = status_body if status_body else ...
 
-        schedule_kwargs = {
+        schedule_body = {
             k: v
             for k, v in {
                 "interval": interval,
@@ -148,9 +131,9 @@ class DataSourceService(EndpointService):
             }.items()
             if v is not ...
         }
-        schedule_kwargs = schedule_kwargs if schedule_kwargs else ...
+        schedule_body = schedule_body if schedule_body else ...
 
-        kwargs = {
+        body = {
             k: v
             for k, v in {
                 "name": name,
@@ -158,39 +141,26 @@ class DataSourceService(EndpointService):
                     orchestration_system, "uid", orchestration_system
                 ),
                 "settings": settings,
-                "schedule": schedule_kwargs,
-                "status": status_kwargs,
+                "schedule": schedule_body,
+                "status": status_body,
             }.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))
+        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."""
 
-        datastream_id = str(getattr(datastream, "uid", datastream))
-
-        self._connection.request(
-            "post",
-            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/datastreams/{datastream_id}",
-        )
+        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."""
 
-        datastream_id = str(getattr(datastream, "uid", datastream))
-
-        self._connection.request(
-            "delete",
-            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/datastreams/{datastream_id}",
-        )
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/datastreams/{normalize_uuid(datastream)}"
+        self.client.request("delete", path)