hydroserverpy 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

hydroserverpy/core/endpoints/sensors.py

@@ -16,7 +16,7 @@ class SensorEndpoint(HydroServerEndpoint):
     :ivar _endpoint_route: The specific route of the endpoint, set to `'sensors'`.
     """
 
-    def __init__(self, service: 'HydroServer'):
+    def __init__(self, service: "HydroServer"):
         """
         Initialize the SensorEndpoint.
 
@@ -27,13 +27,13 @@ class SensorEndpoint(HydroServerEndpoint):
         super().__init__(service)
         self._model = Sensor
         self._api_route = self._service.api_route
-        self._endpoint_route = 'sensors'
+        self._endpoint_route = "sensors"
 
     def list(
-            self,
-            include_owned: bool = True,
-            include_unowned: bool = True,
-            include_templates: bool = True
+        self,
+        include_owned: bool = True,
+        include_unowned: bool = True,
+        include_templates: bool = True,
     ) -> List[Sensor]:
         """
         Retrieve a collection of sensors.
@@ -43,22 +43,40 @@ class SensorEndpoint(HydroServerEndpoint):
         :param include_templates: Whether to include template observed properties.
         """
 
-        if include_owned is True and include_unowned is True and include_templates is True:
-            owner = 'anyUserOrNoUser'
-        elif include_owned is True and include_unowned is True and include_templates is False:
-            owner = 'anyUser'
-        elif include_owned is True and include_unowned is False and include_templates is True:
-            owner = 'currentUserOrNoUser'
-        elif include_owned is True and include_unowned is False and include_templates is False:
-            owner = 'currentUser'
-        elif include_owned is False and include_unowned is False and include_templates is True:
-            owner = 'noUser'
+        if (
+            include_owned is True
+            and include_unowned is True
+            and include_templates is True
+        ):
+            owner = "anyUserOrNoUser"
+        elif (
+            include_owned is True
+            and include_unowned is True
+            and include_templates is False
+        ):
+            owner = "anyUser"
+        elif (
+            include_owned is True
+            and include_unowned is False
+            and include_templates is True
+        ):
+            owner = "currentUserOrNoUser"
+        elif (
+            include_owned is True
+            and include_unowned is False
+            and include_templates is False
+        ):
+            owner = "currentUser"
+        elif (
+            include_owned is False
+            and include_unowned is False
+            and include_templates is True
+        ):
+            owner = "noUser"
         else:
             return []
 
-        return super()._get(params={
-            'owner': owner
-        })
+        return super()._get(params={"owner": owner})
 
     @expand_docstring(include_uid=True)
     def get(self, uid: Union[UUID, str]) -> Sensor:

hydroserverpy/core/endpoints/things.py

@@ -18,7 +18,7 @@ class ThingEndpoint(HydroServerEndpoint):
     :ivar _endpoint_route: The specific route of the endpoint, set to `'things'`.
     """
 
-    def __init__(self, service: 'HydroServer'):
+    def __init__(self, service: "HydroServer"):
         """
         Initialize the ThingEndpoint.
 
@@ -29,9 +29,11 @@ class ThingEndpoint(HydroServerEndpoint):
         super().__init__(service)
         self._model = Thing
         self._api_route = self._service.api_route
-        self._endpoint_route = 'things'
+        self._endpoint_route = "things"
 
-    def list(self, owned_only: bool = False, primary_owned_only: bool = False) -> List[Thing]:
+    def list(
+        self, owned_only: bool = False, primary_owned_only: bool = False
+    ) -> List[Thing]:
         """
         Retrieve a collection of things owned by the logged-in user.
 
@@ -39,10 +41,12 @@ class ThingEndpoint(HydroServerEndpoint):
         :param primary_owned_only: Only list things primary owned by the logged-in user.
         """
 
-        return super()._get(params={
-            'owned_only': owned_only,
-            'primary_owned_only': primary_owned_only,
-        })
+        return super()._get(
+            params={
+                "owned_only": owned_only,
+                "primary_owned_only": primary_owned_only,
+            }
+        )
 
     @expand_docstring(include_uid=True)
     def get(self, uid: Union[UUID, str]) -> Thing:
@@ -86,14 +90,15 @@ class ThingEndpoint(HydroServerEndpoint):
         :rtype: List[Datastream]
         """
 
-        response = getattr(self._service, '_request')(
-            'get', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/datastreams'
+        response = getattr(self._service, "_request")(
+            "get",
+            f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}/datastreams",
         )
 
         endpoint = DatastreamEndpoint(self._service)
 
         return [
-            Datastream(_endpoint=endpoint, _uid=UUID(str(entity.pop('id'))), **entity)
+            Datastream(_endpoint=endpoint, _uid=UUID(str(entity.pop("id"))), **entity)
             for entity in json.loads(response.content)
         ]
 
@@ -107,11 +112,14 @@ class ThingEndpoint(HydroServerEndpoint):
         :rtype: List[Tag]
         """
 
-        response = getattr(self._service, '_request')(
-            'get', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/tags'
+        response = getattr(self._service, "_request")(
+            "get", f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}/tags"
         )
 
-        return [Tag(_uid=UUID(str(entity.pop('id'))), **entity) for entity in json.loads(response.content)]
+        return [
+            Tag(_uid=UUID(str(entity.pop("id"))), **entity)
+            for entity in json.loads(response.content)
+        ]
 
     def create_tag(self, uid: Union[UUID, str], key: str, value: str) -> Tag:
         """
@@ -127,16 +135,19 @@ class ThingEndpoint(HydroServerEndpoint):
         :rtype: Tag
         """
 
-        response = getattr(self._service, '_request')(
-            'post', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/tags',
-            headers={'Content-type': 'application/json'},
+        response = getattr(self._service, "_request")(
+            "post",
+            f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}/tags",
+            headers={"Content-type": "application/json"},
             data=Tag(key=key, value=value).json(exclude_unset=True, by_alias=True),
         )
         entity = json.loads(response.content)
 
-        return Tag(_uid=UUID(str(entity.pop('id'))), **entity)
+        return Tag(_uid=UUID(str(entity.pop("id"))), **entity)
 
-    def update_tag(self, uid: Union[UUID, str], tag_uid: Union[UUID, str], value: str) -> Tag:
+    def update_tag(
+        self, uid: Union[UUID, str], tag_uid: Union[UUID, str], value: str
+    ) -> Tag:
         """
         Update an existing tag for a specific thing.
 
@@ -150,14 +161,15 @@ class ThingEndpoint(HydroServerEndpoint):
         :rtype: Tag
         """
 
-        response = getattr(self._service, '_request')(
-            'patch', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/tags/{str(tag_uid)}',
-            headers={'Content-type': 'application/json'},
-            data=json.dumps({'value': str(value)}),
+        response = getattr(self._service, "_request")(
+            "patch",
+            f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}/tags/{str(tag_uid)}",
+            headers={"Content-type": "application/json"},
+            data=json.dumps({"value": str(value)}),
         )
         entity = json.loads(response.content)
 
-        return Tag(_uid=UUID(str(entity.pop('id'))), **entity)
+        return Tag(_uid=UUID(str(entity.pop("id"))), **entity)
 
     def delete_tag(self, uid: Union[UUID, str], tag_uid: Union[UUID, str]) -> None:
         """
@@ -169,8 +181,9 @@ class ThingEndpoint(HydroServerEndpoint):
         :type tag_uid: UUID or str
         """
 
-        getattr(self._service, '_request')(
-            'delete', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/tags/{str(tag_uid)}'
+        getattr(self._service, "_request")(
+            "delete",
+            f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}/tags/{str(tag_uid)}",
         )
 
     def list_photos(self, uid: Union[UUID, str]) -> List[Photo]:
@@ -183,11 +196,14 @@ class ThingEndpoint(HydroServerEndpoint):
         :rtype: List[Photo]
         """
 
-        response = getattr(self._service, '_request')(
-            'get', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/photos'
+        response = getattr(self._service, "_request")(
+            "get", f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}/photos"
         )
 
-        return [Photo(_uid=UUID(str(entity.pop('id'))), **entity) for entity in json.loads(response.content)]
+        return [
+            Photo(_uid=UUID(str(entity.pop("id"))), **entity)
+            for entity in json.loads(response.content)
+        ]
 
     def upload_photo(self, uid: Union[UUID, str], file: IO) -> List[Photo]:
         """
@@ -201,12 +217,16 @@ class ThingEndpoint(HydroServerEndpoint):
         :rtype: List[Photo]
         """
 
-        response = getattr(self._service, '_request')(
-            'post', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/photos',
-            files={'files': file}
+        response = getattr(self._service, "_request")(
+            "post",
+            f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}/photos",
+            files={"files": file},
         )
 
-        return [Photo(_uid=UUID(str(entity.pop('id'))), **entity) for entity in json.loads(response.content)]
+        return [
+            Photo(_uid=UUID(str(entity.pop("id"))), **entity)
+            for entity in json.loads(response.content)
+        ]
 
     def delete_photo(self, uid: Union[UUID, str], photo_uid: Union[UUID, str]) -> None:
         """
@@ -218,8 +238,9 @@ class ThingEndpoint(HydroServerEndpoint):
         :type photo_uid: UUID or str
         """
 
-        getattr(self._service, '_request')(
-            'delete', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/photos/{str(photo_uid)}'
+        getattr(self._service, "_request")(
+            "delete",
+            f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}/photos/{str(photo_uid)}",
         )
 
     def get_archive(self, uid: Union[UUID, str]) -> Archive:
@@ -232,9 +253,9 @@ class ThingEndpoint(HydroServerEndpoint):
         :rtype: Archive
         """
 
-        response = getattr(self._service, '_request')(
-            'get', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/archive'
+        response = getattr(self._service, "_request")(
+            "get", f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}/archive"
         )
         entity = json.loads(response.content)
 
-        return Archive(_uid=UUID(str(entity.pop('id'))), **entity)
+        return Archive(_uid=UUID(str(entity.pop("id"))), **entity)

hydroserverpy/core/endpoints/units.py

@@ -16,7 +16,7 @@ class UnitEndpoint(HydroServerEndpoint):
     :ivar _endpoint_route: The specific route of the endpoint, set to `'units'`.
     """
 
-    def __init__(self, service: 'HydroServer'):
+    def __init__(self, service: "HydroServer"):
         """
         Initialize the UnitEndpoint.
 
@@ -27,13 +27,13 @@ class UnitEndpoint(HydroServerEndpoint):
         super().__init__(service)
         self._model = Unit
         self._api_route = self._service.api_route
-        self._endpoint_route = 'units'
+        self._endpoint_route = "units"
 
     def list(
-            self,
-            include_owned: bool = True,
-            include_unowned: bool = True,
-            include_templates: bool = True
+        self,
+        include_owned: bool = True,
+        include_unowned: bool = True,
+        include_templates: bool = True,
     ) -> List[Unit]:
         """
         Retrieve a collection of units.
@@ -43,22 +43,40 @@ class UnitEndpoint(HydroServerEndpoint):
         :param include_templates: Whether to include template observed properties.
         """
 
-        if include_owned is True and include_unowned is True and include_templates is True:
-            owner = 'anyUserOrNoUser'
-        elif include_owned is True and include_unowned is True and include_templates is False:
-            owner = 'anyUser'
-        elif include_owned is True and include_unowned is False and include_templates is True:
-            owner = 'currentUserOrNoUser'
-        elif include_owned is True and include_unowned is False and include_templates is False:
-            owner = 'currentUser'
-        elif include_owned is False and include_unowned is False and include_templates is True:
-            owner = 'noUser'
+        if (
+            include_owned is True
+            and include_unowned is True
+            and include_templates is True
+        ):
+            owner = "anyUserOrNoUser"
+        elif (
+            include_owned is True
+            and include_unowned is True
+            and include_templates is False
+        ):
+            owner = "anyUser"
+        elif (
+            include_owned is True
+            and include_unowned is False
+            and include_templates is True
+        ):
+            owner = "currentUserOrNoUser"
+        elif (
+            include_owned is True
+            and include_unowned is False
+            and include_templates is False
+        ):
+            owner = "currentUser"
+        elif (
+            include_owned is False
+            and include_unowned is False
+            and include_templates is True
+        ):
+            owner = "noUser"
         else:
             return []
 
-        return super()._get(params={
-            'owner': owner
-        })
+        return super()._get(params={"owner": owner})
 
     @expand_docstring(include_uid=True)
     def get(self, uid: Union[UUID, str]) -> Unit:

hydroserverpy/core/schemas/base.py

@@ -1,4 +1,10 @@
-from pydantic import BaseModel, PrivateAttr, AliasGenerator, AliasChoices, computed_field
+from pydantic import (
+    BaseModel,
+    PrivateAttr,
+    AliasGenerator,
+    AliasChoices,
+    computed_field,
+)
 from pydantic.alias_generators import to_camel
 from uuid import UUID
 from typing import Optional
@@ -81,7 +87,8 @@ class HydroServerCoreModel(HydroServerBaseModel):
         """
 
         return {
-            key: getattr(self, key) for key, value in self._original_data.items()
+            key: getattr(self, key)
+            for key, value in self._original_data.items()
             if hasattr(self, key) and getattr(self, key) != value
         }
 
@@ -90,8 +97,8 @@ class HydroServerCoreModel(HydroServerBaseModel):
         Refresh the model with the latest data from the server.
         """
 
-        entity = self._endpoint.get(uid=self.uid).model_dump(exclude=['uid'])
-        self._original_data = entity.dict(by_alias=False, exclude=['uid'])
+        entity = self._endpoint.get(uid=self.uid).model_dump(exclude=["uid"])
+        self._original_data = entity.dict(by_alias=False, exclude=["uid"])
         self.__dict__.update(self._original_data)
 
     def save(self) -> None:
@@ -101,7 +108,7 @@ class HydroServerCoreModel(HydroServerBaseModel):
 
         if self._patch_data:
             entity = self._endpoint.update(uid=self.uid, **self._patch_data)
-            self._original_data = entity.dict(by_alias=False, exclude=['uid'])
+            self._original_data = entity.dict(by_alias=False, exclude=["uid"])
             self.__dict__.update(self._original_data)
 
     def delete(self) -> None:
@@ -112,6 +119,6 @@ class HydroServerCoreModel(HydroServerBaseModel):
         """
 
         if not self._uid:
-            raise AttributeError('This resource cannot be deleted: UID is not set.')
+            raise AttributeError("This resource cannot be deleted: UID is not set.")
         self._endpoint.delete(uid=self._uid)
         self._uid = None

hydroserverpy/core/schemas/data_loaders.py

@@ -9,8 +9,10 @@ if TYPE_CHECKING:
 
 class DataLoaderFields(BaseModel):
     name: str = Field(
-        ..., strip_whitespace=True, max_length=255,
-        description='The name of the data loader.'
+        ...,
+        strip_whitespace=True,
+        max_length=255,
+        description="The name of the data loader.",
     )
 
 
@@ -37,7 +39,7 @@ class DataLoader(HydroServerCoreModel, DataLoaderFields):
         self._data_sources = None
 
     @property
-    def data_sources(self) -> List['DataSource']:
+    def data_sources(self) -> List["DataSource"]:
         """
         The data sources associated with the data loader. If not already cached, fetch the data sources from the server.
 
@@ -55,7 +57,7 @@ class DataLoader(HydroServerCoreModel, DataLoaderFields):
         Refresh the data loader with the latest data from the server and update cached data sources.
         """
 
-        entity = self._endpoint.get(uid=self.uid).model_dump(exclude=['uid'])
+        entity = self._endpoint.get(uid=self.uid).model_dump(exclude=["uid"])
         self._original_data = entity
         self.__dict__.update(entity)
         if self._data_sources is not None: