hydroserverpy 1.2.1__py3-none-any.whl → 1.3.0b1__py3-none-any.whl

hydroserverpy/api/services/sta/result_qualifier.py

@@ -1,55 +1,52 @@
 from typing import Optional, Union, List, TYPE_CHECKING
 from uuid import UUID
-from ..base import EndpointService
 from hydroserverpy.api.models import ResultQualifier
-
+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 ResultQualifierService(EndpointService):
-    def __init__(self, connection: "HydroServer"):
-        self._model = ResultQualifier
-        self._api_route = "api/data"
-        self._endpoint_route = "result-qualifiers"
-
-        super().__init__(connection)
+class ResultQualifierService(HydroServerBaseService):
+    def __init__(self, client: "HydroServer"):
+        self.model = ResultQualifier
+        super().__init__(client)
 
     def list(
         self,
-        workspace: Optional[Union["Workspace", UUID, str]] = None,
+        page: int = ...,
+        page_size: int = ...,
+        order_by: List[str] = ...,
+        workspace: Optional[Union["Workspace", UUID, str]] = ...,
+        fetch_all: bool = False,
     ) -> List["ResultQualifier"]:
         """Fetch a collection of result qualifiers."""
 
-        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 {},
+        return super().list(
+            page=page,
+            page_size=page_size,
+            order_by=order_by,
+            workspace_id=normalize_uuid(workspace),
+            fetch_all=fetch_all,
         )
 
-    def get(self, uid: Union[UUID, str]) -> "ResultQualifier":
-        """Get a result qualifier by ID."""
-
-        return super()._get(uid=str(uid))
-
     def create(
         self,
-        workspace: Union["Workspace", UUID, str],
         code: str,
-        description: str,
+        description: Optional[str] = None,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
     ) -> "ResultQualifier":
         """Create a new result qualifier."""
 
-        kwargs = {
+        body = {
             "code": code,
             "description": description,
-            "workspaceId": str(getattr(workspace, "uid", workspace)),
+            "workspaceId": normalize_uuid(workspace),
         }
 
-        return super()._create(**kwargs)
+        return super().create(**body)
 
     def update(
         self,
@@ -59,16 +56,9 @@ class ResultQualifierService(EndpointService):
     ) -> "ResultQualifier":
         """Update a result qualifier."""
 
-        kwargs = {
+        body = {
             "code": code,
             "description": description,
         }
 
-        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 result qualifier."""
-
-        super()._delete(uid=str(uid))
+        return super().update(uid=str(uid), **body)

hydroserverpy/api/services/sta/sensor.py

@@ -1,57 +1,49 @@
 from typing import Optional, Union, List, TYPE_CHECKING
 from uuid import UUID
-from ..base import SensorThingsService
 from hydroserverpy.api.models import Sensor
-
+from hydroserverpy.api.utils import normalize_uuid
+from ..base import HydroServerBaseService
 
 if TYPE_CHECKING:
     from hydroserverpy import HydroServer
-    from hydroserverpy.api.models import Workspace
-
+    from hydroserverpy.api.models import Workspace, Thing, Datastream
 
-class SensorService(SensorThingsService):
-    def __init__(self, connection: "HydroServer"):
-        self._model = Sensor
-        self._api_route = "api/data"
-        self._endpoint_route = "sensors"
-        self._sta_route = "api/sensorthings/v1.1/Sensors"
 
-        super().__init__(connection)
+class SensorService(HydroServerBaseService):
+    def __init__(self, client: "HydroServer"):
+        self.model = Sensor
+        super().__init__(client)
 
     def list(
         self,
-        workspace: Optional[Union["Workspace", UUID, str]] = None,
-        page: int = 1,
-        page_size: int = 100,
+        page: int = ...,
+        page_size: int = ...,
+        order_by: List[str] = ...,
+        workspace: Optional[Union["Workspace", UUID, str]] = ...,
+        thing: Optional[Union["Thing", UUID, str]] = ...,
+        datastream: Optional[Union["Datastream", UUID, str]] = ...,
+        encoding_type: str = ...,
+        manufacturer: Optional[str] = ...,
+        method_type: str = ...,
+        fetch_all: bool = False,
     ) -> List["Sensor"]:
         """Fetch a collection of sensors."""
 
-        params = {"$top": page_size, "$skip": page_size * (page - 1)}
-
-        if workspace:
-            params["$filter"] = (
-                f"properties/workspace/id eq '{str(getattr(workspace, 'uid', workspace))}'"
-            )
-
-        return super()._list(params=params)
-
-    def get(
-        self, uid: Union[UUID, str], fetch_by_datastream_uid: bool = False
-    ) -> "Sensor":
-        """Get a sensor by ID."""
-
-        return self._get(
-            uid=str(uid),
-            path=(
-                f"api/sensorthings/v1.1/Datastreams('{str(uid)}')/Sensor"
-                if fetch_by_datastream_uid
-                else None
-            ),
+        return super().list(
+            page=page,
+            page_size=page_size,
+            order_by=order_by,
+            workspace_id=normalize_uuid(workspace),
+            thing_id=normalize_uuid(thing),
+            datastream_id=normalize_uuid(datastream),
+            encoding_type=encoding_type,
+            manufacturer=manufacturer,
+            method_type=method_type,
+            fetch_all=fetch_all,
         )
 
     def create(
         self,
-        workspace: Union["Workspace", UUID, str],
         name: str,
         description: str,
         encoding_type: str,
@@ -61,10 +53,11 @@ class SensorService(SensorThingsService):
         sensor_model_link: Optional[str] = None,
         method_link: Optional[str] = None,
         method_code: Optional[str] = None,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
     ) -> "Sensor":
         """Create a new sensor."""
 
-        kwargs = {
+        body = {
             "name": name,
             "description": description,
             "encodingType": encoding_type,
@@ -74,10 +67,10 @@ class SensorService(SensorThingsService):
             "modelLink": sensor_model_link,
             "methodLink": method_link,
             "methodCode": method_code,
-            "workspaceId": str(getattr(workspace, "uid", workspace)),
+            "workspaceId": normalize_uuid(workspace),
         }
 
-        return super()._create(**kwargs)
+        return super().create(**body)
 
     def update(
         self,
@@ -94,7 +87,7 @@ class SensorService(SensorThingsService):
     ) -> "Sensor":
         """Update a sensor."""
 
-        kwargs = {
+        body = {
             "name": name,
             "description": description,
             "encodingType": encoding_type,
@@ -106,11 +99,4 @@ class SensorService(SensorThingsService):
             "methodCode": method_code,
         }
 
-        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 sensor."""
-
-        super()._delete(uid=str(uid))
+        return super().update(uid=str(uid), **body)

hydroserverpy/api/services/sta/thing.py

@@ -1,59 +1,54 @@
 import json
-from typing import TYPE_CHECKING, Union, IO, List, Dict, Optional
+from typing import TYPE_CHECKING, Union, IO, List, Dict, Optional, Tuple
 from uuid import UUID
-from ..base import SensorThingsService
 from hydroserverpy.api.models import Thing
-
+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 ThingService(SensorThingsService):
-    def __init__(self, connection: "HydroServer"):
-        self._model = Thing
-        self._api_route = "api/data"
-        self._endpoint_route = "things"
-        self._sta_route = "api/sensorthings/v1.1/Things"
-
-        super().__init__(connection)
+class ThingService(HydroServerBaseService):
+    def __init__(self, client: "HydroServer"):
+        self.model = Thing
+        super().__init__(client)
 
     def list(
         self,
-        workspace: Optional[Union["Workspace", UUID, str]] = None,
-        page: int = 1,
-        page_size: int = 100,
+        page: int = ...,
+        page_size: int = ...,
+        order_by: List[str] = ...,
+        workspace: Union["Workspace", UUID, str] = ...,
+        bbox: Tuple[float, float, float, float] = ...,
+        state: str = ...,
+        county: str = ...,
+        country: str = ...,
+        site_type: str = ...,
+        sampling_feature_type: str = ...,
+        sampling_feature_code: str = ...,
+        tag: Tuple[str, str] = ...,
+        is_private: bool = ...,
+        fetch_all: bool = False,
     ) -> List["Thing"]:
         """Fetch a collection of things."""
 
-        params = {
-            "$top": page_size,
-            "$skip": page_size * (page - 1),
-            "$expand": "Locations",
-        }
-
-        if workspace:
-            params["$filter"] = (
-                f"properties/workspace/id eq '{str(getattr(workspace, 'uid', workspace))}'"
-            )
-
-        return super()._list(params=params)
-
-    def get(
-        self, uid: Union[UUID, str], fetch_by_datastream_uid: bool = False
-    ) -> "Thing":
-        """Get a thing by ID."""
-
-        params = {"$expand": "Locations"}
-        return self._get(
-            uid=str(uid),
-            path=(
-                f"api/sensorthings/v1.1/Datastreams('{str(uid)}')/Thing"
-                if fetch_by_datastream_uid
-                else None
-            ),
-            params=params,
+        return super().list(
+            page=page,
+            page_size=page_size,
+            order_by=order_by,
+            workspace_id=normalize_uuid(workspace),
+            bbox=",".join([str(i) for i in bbox]) if bbox is not ... else bbox,
+            state=state,
+            county=county,
+            country=country,
+            site_type=site_type,
+            sampling_feature_type=sampling_feature_type,
+            sampling_feature_code=sampling_feature_code,
+            tag=[f"{tag[0]}:{tag[1]}"] if tag is not ... else tag,
+            is_private=is_private,
+            fetch_all=fetch_all,
         )
 
     def create(
@@ -76,25 +71,27 @@ class ThingService(SensorThingsService):
     ) -> "Thing":
         """Create a new thing."""
 
-        kwargs = {
+        body = {
             "name": name,
             "description": description,
             "samplingFeatureType": sampling_feature_type,
             "samplingFeatureCode": sampling_feature_code,
             "siteType": site_type,
             "isPrivate": is_private,
-            "latitude": latitude,
-            "longitude": longitude,
-            "elevation_m": elevation_m,
-            "elevationDatum": elevation_datum,
-            "state": state,
-            "county": county,
-            "country": country,
             "dataDisclaimer": data_disclaimer,
-            "workspaceId": str(getattr(workspace, "uid", workspace)),
+            "workspaceId": normalize_uuid(workspace),
+            "location": {
+                "latitude": latitude,
+                "longitude": longitude,
+                "elevation_m": elevation_m,
+                "elevationDatum": elevation_datum,
+                "state": state,
+                "county": county,
+                "country": country,
+            }
         }
 
-        return super()._create(**kwargs)
+        return super().create(**body)
 
     def update(
         self,
@@ -104,7 +101,7 @@ class ThingService(SensorThingsService):
         sampling_feature_type: str = ...,
         sampling_feature_code: str = ...,
         site_type: str = ...,
-        is_private: False = ...,
+        is_private: bool = ...,
         latitude: float = ...,
         longitude: float = ...,
         elevation_m: Optional[float] = ...,
@@ -116,73 +113,83 @@ class ThingService(SensorThingsService):
     ) -> "Thing":
         """Update a thing."""
 
-        kwargs = {
+        body = {
             "name": name,
             "description": description,
             "samplingFeatureType": sampling_feature_type,
             "samplingFeatureCode": sampling_feature_code,
             "siteType": site_type,
             "isPrivate": is_private,
-            "latitude": latitude,
-            "longitude": longitude,
-            "elevation_m": elevation_m,
-            "elevationDatum": elevation_datum,
-            "state": state,
-            "county": county,
-            "country": country,
             "dataDisclaimer": data_disclaimer,
+            "location": {
+                "latitude": latitude,
+                "longitude": longitude,
+                "elevation_m": elevation_m,
+                "elevationDatum": elevation_datum,
+                "state": state,
+                "county": county,
+                "country": country,
+            }
         }
 
-        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 thing."""
-
-        super()._delete(uid=str(uid))
+        return super().update(uid=str(uid), **body)
 
     def add_tag(self, uid: Union[UUID, str], key: str, value: str) -> Dict[str, str]:
         """Tag a HydroServer thing."""
 
-        return self._connection.request(
-            "post",
-            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/tags",
-            data=json.dumps({"key": key, "value": value}),
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/tags"
+        headers = {"Content-type": "application/json"}
+        body = {
+            "key": key,
+            "value": value
+        }
+        return self.client.request(
+            "post", path, headers=headers, data=json.dumps(body, default=self.default_serializer)
         ).json()
 
     def update_tag(self, uid: Union[UUID, str], key: str, value: str) -> Dict[str, str]:
         """Update the tag of a HydroServer thing."""
 
-        return self._connection.request(
-            "put",
-            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/tags",
-            data=json.dumps({"key": key, "value": value}),
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/tags"
+        headers = {"Content-type": "application/json"}
+        body = {
+            "key": key,
+            "value": value
+        }
+        return self.client.request(
+            "put", path, headers=headers, data=json.dumps(body, default=self.default_serializer)
         ).json()
 
-    def delete_tag(self, uid: Union[UUID, str], key: str) -> None:
+    def delete_tag(self, uid: Union[UUID, str], key: str, value: str) -> None:
         """Remove a tag from a HydroServer thing."""
 
-        self._connection.request(
-            "delete",
-            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/tags",
-            data=json.dumps({"key": key}),
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/tags"
+        headers = {"Content-type": "application/json"}
+        body = {
+            "key": key,
+            "value": value
+        }
+        self.client.request(
+            "delete", path, headers=headers, data=json.dumps(body, default=self.default_serializer)
         )
 
     def add_photo(self, uid: Union[UUID, str], file: IO[bytes]) -> Dict[str, str]:
         """Add a photo of a HydroServer thing."""
 
-        return self._connection.request(
-            "post",
-            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/photos",
-            files={"file": file},
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/photos"
+
+        return self.client.request(
+            "post", path, files={"file": file}
         ).json()
 
     def delete_photo(self, uid: Union[UUID, str], name: str) -> None:
         """Delete a photo of a HydroServer thing."""
 
-        self._connection.request(
-            "delete",
-            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/photos",
-            data=json.dumps({"name": name}),
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/photos"
+        headers = {"Content-type": "application/json"}
+        body = {
+            "name": name
+        }
+        self.client.request(
+            "delete", path, headers=headers, data=json.dumps(body, default=self.default_serializer)
         )

hydroserverpy/api/services/sta/unit.py

@@ -1,59 +1,62 @@
 from typing import Optional, Union, List, TYPE_CHECKING
 from uuid import UUID
-from ..base import EndpointService
 from hydroserverpy.api.models import Unit
-
+from hydroserverpy.api.utils import normalize_uuid
+from ..base import HydroServerBaseService
 
 if TYPE_CHECKING:
     from hydroserverpy import HydroServer
-    from hydroserverpy.api.models import Workspace
-
+    from hydroserverpy.api.models import Workspace, Thing, Datastream
 
-class UnitService(EndpointService):
-    def __init__(self, connection: "HydroServer"):
-        self._model = Unit
-        self._api_route = "api/data"
-        self._endpoint_route = "units"
 
-        super().__init__(connection)
+class UnitService(HydroServerBaseService):
+    def __init__(self, client: "HydroServer"):
+        self.model = Unit
+        super().__init__(client)
 
     def list(
         self,
-        workspace: Optional[Union["Workspace", UUID, str]] = None,
+        page: int = ...,
+        page_size: int = ...,
+        order_by: List[str] = ...,
+        workspace: Union["Workspace", UUID, str] = ...,
+        thing: Optional[Union["Thing", UUID, str]] = ...,
+        datastream: Optional[Union["Datastream", UUID, str]] = ...,
+        unit_type: str = ...,
+        fetch_all: bool = False,
     ) -> List["Unit"]:
         """Fetch a collection of units."""
 
-        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 {},
+        return super().list(
+            page=page,
+            page_size=page_size,
+            order_by=order_by,
+            workspace_id=normalize_uuid(workspace),
+            thing_id=normalize_uuid(thing),
+            datastream_id=normalize_uuid(datastream),
+            unit_type=unit_type,
+            fetch_all=fetch_all,
         )
 
-    def get(self, uid: Union[UUID, str]) -> "Unit":
-        """Get a unit by ID."""
-
-        return super()._get(uid=str(uid))
-
     def create(
         self,
-        workspace: Union["Workspace", UUID, str],
         name: str,
         symbol: str,
         definition: str,
         unit_type: str,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
     ) -> "Unit":
         """Create a new unit."""
 
-        kwargs = {
+        body = {
             "name": name,
             "symbol": symbol,
             "definition": definition,
             "type": unit_type,
-            "workspaceId": str(getattr(workspace, "uid", workspace)),
+            "workspaceId": normalize_uuid(workspace),
         }
 
-        return super()._create(**kwargs)
+        return super().create(**body)
 
     def update(
         self,
@@ -65,18 +68,11 @@ class UnitService(EndpointService):
     ) -> "Unit":
         """Update a unit."""
 
-        kwargs = {
+        body = {
             "name": name,
             "symbol": symbol,
             "definition": definition,
             "type": unit_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 a unit."""
-
-        super()._delete(uid=str(uid))
+        return super().update(uid=str(uid), **body)

hydroserverpy/api/utils.py

@@ -0,0 +1,22 @@
+from uuid import UUID
+from typing import Union, Optional, Any
+from pydantic.alias_generators import to_camel
+
+
+def normalize_uuid(
+    obj: Optional[Union[str, UUID, Any]],
+    attr: str = "uid"
+):
+    if obj is ...:
+        return ...
+    if obj is None:
+        return None
+    if obj and hasattr(obj, attr):
+        return str(getattr(obj, attr))
+    return str(obj)
+
+
+def order_by_to_camel(s: str) -> str:
+    if s.startswith('-'):
+        return '-' + to_camel(s[1:])
+    return to_camel(s)

hydroserverpy/etl/extractors/base.py

@@ -34,10 +34,8 @@ class Extractor:
                 continue
 
             if isinstance(value, (datetime, pd.Timestamp)):
-                fmt = var.get("timestampFormat", "ISO8601")
-                offset = var.get("timestampOffset", "+0000")
-                parser = TimestampParser(fmt, offset)
-                value = parser.format(value)
+                parser = TimestampParser(var["timestamp"])
+                value = parser.utc_to_string(value)
 
             filled[name] = value
         if not filled:

hydroserverpy/etl/loaders/hydroserver_loader.py

@@ -46,6 +46,7 @@ class HydroServerLoader(HydroServer, Loader):
             logging.info(f"dtypes: {df.dtypes}")
 
             df["value"] = pd.to_numeric(df["value"], errors="raise")
+            df = df.rename(columns={"timestamp": "phenomenon_time", "value": "result"})
             self.datastreams.load_observations(uid=col, observations=df)
 
     def _fetch_earliest_begin(self, mappings: list[dict]) -> pd.Timestamp: