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

hydroserverpy/api/models/sta/processing_level.py

@@ -0,0 +1,50 @@
+from typing import Union, Optional, TYPE_CHECKING
+from uuid import UUID
+from pydantic import BaseModel, Field
+from ..base import HydroServerModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class ProcessingLevelFields(BaseModel):
+    code: str = Field(..., max_length=255)
+    definition: Optional[str] = None
+    explanation: Optional[str] = None
+
+
+class ProcessingLevel(HydroServerModel, ProcessingLevelFields):
+    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
+        super().__init__(
+            _connection=_connection, _model_ref="processinglevels", _uid=_uid, **data
+        )
+
+        self._workspace_id = str(data.get("workspace_id") or data["workspaceId"])
+
+        self._workspace = None
+
+    @property
+    def workspace(self) -> "Workspace":
+        """The workspace this processing level belongs to."""
+
+        if self._workspace is None and self._workspace_id:
+            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+
+        return self._workspace
+
+    def refresh(self):
+        """Refresh this processing level from HydroServer."""
+
+        super()._refresh()
+        self._workspace = None
+
+    def save(self):
+        """Save changes to this processing level to HydroServer."""
+
+        super()._save()
+
+    def delete(self):
+        """Delete this processing level from HydroServer."""
+
+        super()._delete()

hydroserverpy/api/models/sta/result_qualifier.py

@@ -0,0 +1,49 @@
+from typing import Union, Optional, TYPE_CHECKING
+from uuid import UUID
+from pydantic import BaseModel, Field
+from ..base import HydroServerModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class ResultQualifierFields(BaseModel):
+    code: str = Field(..., max_length=255)
+    description: str
+
+
+class ResultQualifier(HydroServerModel, ResultQualifierFields):
+    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
+        super().__init__(
+            _connection=_connection, _model_ref="resultqualifiers", _uid=_uid, **data
+        )
+
+        self._workspace_id = str(data.get("workspace_id") or data["workspaceId"])
+
+        self._workspace = None
+
+    @property
+    def workspace(self) -> "Workspace":
+        """The workspace this result qualifier belongs to."""
+
+        if self._workspace is None and self._workspace_id:
+            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+
+        return self._workspace
+
+    def refresh(self):
+        """Refresh this result qualifier from HydroServer."""
+
+        super()._refresh()
+        self._workspace = None
+
+    def save(self):
+        """Save changes to this result qualifier to HydroServer."""
+
+        super()._save()
+
+    def delete(self):
+        """Delete this result qualifier from HydroServer."""
+
+        super()._delete()

hydroserverpy/api/models/sta/sensor.py

@@ -0,0 +1,105 @@
+from typing import Union, Optional, TYPE_CHECKING
+from uuid import UUID
+from pydantic import BaseModel, Field, AliasChoices, AliasPath
+from ..base import HydroServerModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class SensorFields(BaseModel):
+    name: str = Field(..., max_length=255)
+    description: str
+    encoding_type: str = Field(..., max_length=255)
+    manufacturer: Optional[str] = Field(
+        None,
+        max_length=255,
+        validation_alias=AliasChoices(
+            "manufacturer", AliasPath("metadata", "sensorModel", "sensorManufacturer")
+        ),
+    )
+    sensor_model: Optional[str] = Field(
+        None,
+        max_length=255,
+        alias="model",
+        validation_alias=AliasChoices(
+            "model", AliasPath("metadata", "sensorModel", "sensorModelName")
+        ),
+    )
+    sensor_model_link: Optional[str] = Field(
+        None,
+        max_length=500,
+        alias="modelLink",
+        validation_alias=AliasChoices(
+            "modelLink", AliasPath("metadata", "sensorModel", "sensorModelUrl")
+        ),
+    )
+    method_type: str = Field(
+        ...,
+        max_length=100,
+        validation_alias=AliasChoices(
+            "methodType", AliasPath("metadata", "methodType")
+        ),
+    )
+    method_link: Optional[str] = Field(
+        None,
+        max_length=500,
+        validation_alias=AliasChoices(
+            "methodLink", AliasPath("metadata", "methodLink")
+        ),
+    )
+    method_code: Optional[str] = Field(
+        None,
+        max_length=50,
+        validation_alias=AliasChoices(
+            "methodCode", AliasPath("metadata", "methodCode")
+        ),
+    )
+
+
+class Sensor(HydroServerModel, SensorFields):
+    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
+        super().__init__(
+            _connection=_connection, _model_ref="sensors", _uid=_uid, **data
+        )
+
+        self._workspace_id = (
+            data.get("workspace_id")
+            or data.get("workspaceId")
+            or (
+                None
+                if data.get("properties", {}).get("workspace") is None
+                else data.get("properties", {}).get("workspace", {}).get("id")
+            )
+        )
+        self._workspace_id = (
+            str(self._workspace_id) if self._workspace_id is not None else None
+        )
+
+        self._workspace = None
+
+    @property
+    def workspace(self) -> "Workspace":
+        """The workspace this sensor belongs to."""
+
+        if self._workspace is None and self._workspace_id:
+            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+
+        return self._workspace
+
+    def refresh(self):
+        """Refresh this sensor from HydroServer."""
+
+        super()._refresh()
+        self._workspace = None
+
+    def save(self):
+        """Save changes to this sensor to HydroServer."""
+
+        super()._save()
+
+    def delete(self):
+        """Delete this sensor from HydroServer."""
+
+        super()._delete()

hydroserverpy/api/models/sta/thing.py

@@ -0,0 +1,217 @@
+from typing import Optional, Union, List, Dict, IO, TYPE_CHECKING
+from uuid import UUID
+from pydantic import (
+    BaseModel,
+    Field,
+    AliasChoices,
+    AliasPath,
+    AnyHttpUrl,
+    field_validator,
+)
+from ..base import HydroServerModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace, Datastream
+
+
+class ThingFields(BaseModel):
+    name: str = Field(..., max_length=200)
+    description: str
+    sampling_feature_type: str = Field(
+        ...,
+        max_length=200,
+        validation_alias=AliasChoices(
+            "samplingFeatureType", AliasPath("properties", "samplingFeatureType")
+        ),
+    )
+    sampling_feature_code: str = Field(
+        ...,
+        max_length=200,
+        validation_alias=AliasChoices(
+            "samplingFeatureCode", AliasPath("properties", "samplingFeatureCode")
+        ),
+    )
+    site_type: str = Field(
+        ...,
+        max_length=200,
+        validation_alias=AliasChoices("siteType", AliasPath("properties", "siteType")),
+    )
+    tags: Dict[str, str] = Field(
+        ...,
+        json_schema_extra={"editable": False, "read_only": True},
+        validation_alias=AliasChoices("tags", AliasPath("properties", "tags")),
+    )
+    photos: Dict[str, AnyHttpUrl] = Field(
+        ...,
+        json_schema_extra={"editable": False, "read_only": True},
+        validation_alias=AliasChoices("photos", AliasPath("properties", "photos")),
+    )
+    data_disclaimer: Optional[str] = Field(
+        None,
+        validation_alias=AliasChoices(
+            "dataDisclaimer", AliasPath("properties", "dataDisclaimer")
+        ),
+    )
+    is_private: bool = Field(
+        ...,
+        validation_alias=AliasChoices(
+            "isPrivate", AliasPath("properties", "isPrivate")
+        ),
+    )
+
+    @field_validator("tags", mode="before")
+    def convert_tags(
+        cls, value: Union[List[Dict[str, str]], Dict[str, str]]
+    ) -> Dict[str, str]:
+        if isinstance(value, list):
+            return {item["key"]: item["value"] for item in value}
+        return value
+
+    @field_validator("photos", mode="before")
+    def convert_photos(
+        cls, value: Union[List[Dict[str, str]], Dict[str, str]]
+    ) -> Dict[str, str]:
+        if isinstance(value, list):
+            return {item["name"]: item["link"] for item in value}
+        return value
+
+
+class LocationFields(BaseModel):
+    latitude: float = Field(
+        ...,
+        ge=-90,
+        le=90,
+        validation_alias=AliasChoices(
+            "latitude",
+            AliasPath("Locations", 0, "location", "geometry", "coordinates", 0),
+        ),
+    )
+    longitude: float = Field(
+        ...,
+        ge=-180,
+        le=180,
+        validation_alias=AliasChoices(
+            "longitude",
+            AliasPath("Locations", 0, "location", "geometry", "coordinates", 1),
+        ),
+    )
+    elevation_m: Optional[float] = Field(
+        None,
+        ge=-99999,
+        le=99999,
+        validation_alias=AliasChoices(
+            "elevation_m", AliasPath("Locations", 0, "properties", "elevation_m")
+        ),
+    )
+    elevation_datum: Optional[str] = Field(
+        None,
+        max_length=255,
+        validation_alias=AliasChoices(
+            "elevationDatum", AliasPath("Locations", 0, "properties", "elevationDatum")
+        ),
+    )
+    state: Optional[str] = Field(
+        None,
+        max_length=200,
+        validation_alias=AliasChoices(
+            "state", AliasPath("Locations", 0, "properties", "state")
+        ),
+    )
+    county: Optional[str] = Field(
+        None,
+        max_length=200,
+        validation_alias=AliasChoices(
+            "county", AliasPath("Locations", 0, "properties", "county")
+        ),
+    )
+    country: Optional[str] = Field(
+        None,
+        max_length=2,
+        validation_alias=AliasChoices(
+            "country", AliasPath("Locations", 0, "properties", "country")
+        ),
+    )
+
+
+class Thing(HydroServerModel, ThingFields, LocationFields):
+    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
+        super().__init__(
+            _connection=_connection, _model_ref="things", _uid=_uid, **data
+        )
+
+        self._workspace_id = str(
+            data.get("workspace_id")
+            or data.get("workspaceId")
+            or data["properties"]["workspace"]["id"]
+        )
+
+        self._workspace = None
+        self._datastreams = None
+        self._photos = None
+        self._tags = None
+
+    @property
+    def workspace(self) -> "Workspace":
+        """The workspace this thing belongs to."""
+
+        if self._workspace is None:
+            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+
+        return self._workspace
+
+    @property
+    def datastreams(self) -> List["Datastream"]:
+        """The datastreams collected at this thing."""
+
+        if self._datastreams is None:
+            self._datastreams = self._connection.datastreams.list(thing=self.uid)
+
+        return self._datastreams
+
+    def refresh(self):
+        """Refresh this thing from HydroServer."""
+
+        super()._refresh()
+        self._workspace = None
+        self._datastreams = None
+
+    def save(self):
+        """Save changes to this thing to HydroServer."""
+
+        super()._save()
+
+    def delete(self):
+        """Delete this thing from HydroServer."""
+
+        super()._delete()
+
+    def add_tag(self, key: str, value: str):
+        """Add a tag to this thing."""
+
+        self._connection.things.add_tag(uid=self.uid, key=key, value=value)
+        self.tags[key] = value
+
+    def update_tag(self, key: str, value: str):
+        """Edit a tag of this thing."""
+
+        self._connection.things.update_tag(uid=self.uid, key=key, value=value)
+        self.tags[key] = value
+
+    def delete_tag(self, key: str):
+        """Delete a tag of this thing."""
+
+        self._connection.things.delete_tag(uid=self.uid, key=key)
+        del self.tags[key]
+
+    def add_photo(self, file: IO[bytes]):
+        """Add a photo of this thing."""
+
+        photo = self._connection.things.add_photo(uid=self.uid, file=file)
+        self.photos[photo["name"]] = photo["link"]
+
+    def delete_photo(self, name: str):
+        """Delete a photo of this thing."""
+
+        self._connection.things.delete_photo(uid=self.uid, name=name)
+        del self.photos[name]

hydroserverpy/api/models/sta/unit.py

@@ -0,0 +1,49 @@
+from typing import Union, TYPE_CHECKING
+from uuid import UUID
+from pydantic import BaseModel, Field
+from ..base import HydroServerModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class UnitFields(BaseModel):
+    name: str = Field(..., max_length=255)
+    symbol: str = Field(..., max_length=255)
+    definition: str
+    unit_type: str = Field(..., max_length=255, alias="type")
+
+
+class Unit(HydroServerModel, UnitFields):
+    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
+        super().__init__(_connection=_connection, _model_ref="units", _uid=_uid, **data)
+
+        self._workspace_id = str(data.get("workspace_id") or data["workspaceId"])
+
+        self._workspace = None
+
+    @property
+    def workspace(self) -> "Workspace":
+        """The workspace this unit belongs to."""
+
+        if self._workspace is None and self._workspace_id:
+            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+
+        return self._workspace
+
+    def refresh(self):
+        """Refresh this unit from HydroServer."""
+
+        super()._refresh()
+        self._workspace = None
+
+    def save(self):
+        """Save changes to this unit to HydroServer."""
+
+        super()._save()
+
+    def delete(self):
+        """Delete this unit from HydroServer."""
+
+        super()._delete()

hydroserverpy/api/services/__init__.py

@@ -0,0 +1,11 @@
+from .iam.workspace import WorkspaceService
+from .sta.thing import ThingService
+from .sta.observed_property import ObservedPropertyService
+from .sta.unit import UnitService
+from .sta.processing_level import ProcessingLevelService
+from .sta.result_qualifier import ResultQualifierService
+from .sta.sensor import SensorService
+from .sta.datastream import DatastreamService
+from .etl.orchestration_system import OrchestrationSystemService
+from .etl.data_source import DataSourceService
+from .etl.data_archive import DataArchiveService

hydroserverpy/api/services/base.py

@@ -0,0 +1,102 @@
+from typing import TYPE_CHECKING, Type, Union, Optional
+from datetime import datetime
+from uuid import UUID
+
+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
+
+    def __init__(self, connection: "HydroServer") -> None:
+        self._connection = connection
+
+    def _list(self, params: Optional[dict] = None):
+        path = f"/{self._api_route}/{self._endpoint_route}"
+
+        response = self._connection.request("get", path, params=params).json()
+
+        return [
+            self._model(
+                _connection=self._connection, _uid=UUID(str(obj.pop("id"))), **obj
+            )
+            for obj in response
+        ]
+
+    def _get(self, uid: Union[UUID, str]):
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}"
+        response = self._connection.request("get", path).json()
+
+        return self._model(
+            _connection=self._connection, _uid=UUID(str(response.pop("id"))), **response
+        )
+
+    def _create(self, **kwargs):
+        path = f"/{self._api_route}/{self._endpoint_route}"
+        headers = {"Content-type": "application/json"}
+        response = self._connection.request(
+            "post", path, headers=headers, json=self._to_iso_time(kwargs)
+        ).json()
+
+        return self._model(
+            _connection=self._connection, _uid=UUID(str(response.pop("id"))), **response
+        )
+
+    def _update(self, uid: Union[UUID, str], **kwargs):
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}"
+        headers = {"Content-type": "application/json"}
+        response = self._connection.request(
+            "patch", path, headers=headers, json=self._to_iso_time(kwargs)
+        ).json()
+
+        return self._model(
+            _connection=self._connection, _uid=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 _to_iso_time(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()
+        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
+        )