hydroserverpy 1.5.1__py3-none-any.whl

hydroserverpy/api/models/sta/processing_level.py

@@ -0,0 +1,35 @@
+import uuid
+from typing import Optional, ClassVar, TYPE_CHECKING
+from pydantic import Field
+from ..base import HydroServerBaseModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class ProcessingLevel(HydroServerBaseModel):
+    code: str = Field(..., max_length=255)
+    definition: Optional[str] = None
+    explanation: Optional[str] = None
+    workspace_id: Optional[uuid.UUID] = None
+
+    _editable_fields: ClassVar[set[str]] = {"code", "definition", "explanation"}
+
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.processinglevels, **data)
+
+        self._workspace = None
+
+    @classmethod
+    def get_route(cls):
+        return "processing-levels"
+
+    @property
+    def workspace(self) -> Optional["Workspace"]:
+        """The workspace this processing level belongs to."""
+
+        if self._workspace is None and self.workspace_id:
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
+
+        return self._workspace

hydroserverpy/api/models/sta/result_qualifier.py

@@ -0,0 +1,34 @@
+import uuid
+from typing import Optional, ClassVar, TYPE_CHECKING
+from pydantic import Field
+from ..base import HydroServerBaseModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class ResultQualifier(HydroServerBaseModel):
+    code: str = Field(..., max_length=255)
+    description: str
+    workspace_id: Optional[uuid.UUID] = None
+
+    _editable_fields: ClassVar[set[str]] = {"code", "description"}
+
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.resultqualifiers, **data)
+
+        self._workspace = None
+
+    @classmethod
+    def get_route(cls):
+        return "result-qualifiers"
+
+    @property
+    def workspace(self) -> Optional["Workspace"]:
+        """The workspace this result qualifier belongs to."""
+
+        if self._workspace is None and self.workspace_id:
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
+
+        return self._workspace

hydroserverpy/api/models/sta/sensor.py

@@ -0,0 +1,44 @@
+import uuid
+from typing import Optional, ClassVar, TYPE_CHECKING
+from pydantic import Field
+from ..base import HydroServerBaseModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class Sensor(HydroServerBaseModel):
+    name: str = Field(..., max_length=255)
+    description: str
+    encoding_type: str = Field(..., max_length=255)
+    manufacturer: Optional[str] = Field(None, max_length=255)
+    sensor_model: Optional[str] = Field(None, max_length=255, alias="model")
+    sensor_model_link: Optional[str] = Field(None, max_length=500, alias="modelLink")
+    method_type: str = Field(..., max_length=100)
+    method_link: Optional[str] = Field(None, max_length=500)
+    method_code: Optional[str] = Field(None, max_length=50)
+    workspace_id: Optional[uuid.UUID] = None
+
+    _editable_fields: ClassVar[set[str]] = {
+        "name", "description", "encoding_type", "manufacturer", "sensor_model", "sensor_model_link", "method_type",
+        "method_link", "method_code"
+    }
+
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.sensors, **data)
+
+        self._workspace = None
+
+    @classmethod
+    def get_route(cls):
+        return "sensors"
+
+    @property
+    def workspace(self) -> Optional["Workspace"]:
+        """The workspace this sensor belongs to."""
+
+        if self._workspace is None and self.workspace_id:
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
+
+        return self._workspace

hydroserverpy/api/models/sta/thing.py

@@ -0,0 +1,113 @@
+import uuid
+from typing import Optional, ClassVar, List, Dict, IO, TYPE_CHECKING
+from pydantic import (
+    Field,
+    AliasPath,
+    AliasChoices,
+    AnyHttpUrl,
+    field_validator
+)
+from ..base import HydroServerBaseModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace, Datastream
+
+
+class Thing(HydroServerBaseModel):
+    name: str = Field(..., max_length=200)
+    description: str
+    sampling_feature_type: str = Field(..., max_length=200)
+    sampling_feature_code: str = Field(..., max_length=200)
+    site_type: str = Field(..., max_length=200)
+    data_disclaimer: Optional[str] = None
+    is_private: bool
+    latitude: float = Field(..., ge=-90, le=90, validation_alias=AliasPath("location", "latitude"))
+    longitude: float = Field(..., ge=-180, le=180, validation_alias=AliasPath("location", "longitude"))
+    elevation_m: Optional[float] = Field(
+        None, ge=-99999, le=99999, alias="elevation_m", validation_alias=AliasPath("location", "elevation_m")
+    )
+    elevation_datum: Optional[str] = Field(
+        None, max_length=255, validation_alias=AliasChoices("elevationDatum", AliasPath("location", "elevationDatum"))
+    )
+    state: Optional[str] = Field(None, max_length=200, validation_alias=AliasPath("location", "state"))
+    county: Optional[str] = Field(None, max_length=200, validation_alias=AliasPath("location", "county"))
+    country: Optional[str] = Field(None, max_length=2, validation_alias=AliasPath("location", "country"))
+    tags: Dict[str, str]
+    photos: Dict[str, AnyHttpUrl]
+    workspace_id: uuid.UUID
+
+    _editable_fields: ClassVar[set[str]] = {
+        "name", "description", "sampling_feature_type", "sampling_feature_code", "site_type", "data_disclaimer",
+        "is_private", "latitude", "longitude", "elevation_m", "elevation_datum", "state", "county", "country"
+    }
+
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.things, **data)
+
+        self._workspace = None
+        self._datastreams = None
+
+    @classmethod
+    def get_route(cls):
+        return "things"
+
+    @property
+    def workspace(self) -> "Workspace":
+        """The workspace this thing belongs to."""
+
+        if self._workspace is None:
+            self._workspace = self.client.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.client.datastreams.list(thing=self.uid, fetch_all=True).items
+
+        return self._datastreams
+
+    @field_validator("tags", mode="before")
+    def transform_tags(cls, v):
+        if isinstance(v, list):
+            return {item["key"]: item["value"] for item in v if "key" in item and "value" in item}
+        return v
+
+    @field_validator("photos", mode="before")
+    def transform_photos(cls, v):
+        if isinstance(v, list):
+            return {item["name"]: item["link"] for item in v if "name" in item and "link" in item}
+        return v
+
+    def add_tag(self, key: str, value: str):
+        """Add a tag to this thing."""
+
+        self.client.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.client.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.client.things.delete_tag(uid=self.uid, key=key, value=self.tags[key])
+        del self.tags[key]
+
+    def add_photo(self, file: IO[bytes]):
+        """Add a photo of this thing."""
+
+        photo = self.client.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.client.things.delete_photo(uid=self.uid, name=name)
+        del self.photos[name]

hydroserverpy/api/models/sta/unit.py

@@ -0,0 +1,36 @@
+import uuid
+from typing import Optional, ClassVar, TYPE_CHECKING
+from pydantic import Field
+from ..base import HydroServerBaseModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class Unit(HydroServerBaseModel):
+    name: str = Field(..., max_length=255)
+    symbol: str = Field(..., max_length=255)
+    definition: str
+    unit_type: str = Field(..., max_length=255, alias="type")
+    workspace_id: Optional[uuid.UUID] = None
+
+    _editable_fields: ClassVar[set[str]] = {"name", "symbol", "definition", "unit_type"}
+
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.units, **data)
+
+        self._workspace = None
+
+    @classmethod
+    def get_route(cls):
+        return "units"
+
+    @property
+    def workspace(self) -> Optional["Workspace"]:
+        """The workspace this unit belongs to."""
+
+        if self._workspace is None and self.workspace_id:
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
+
+        return self._workspace

hydroserverpy/api/services/__init__.py

@@ -0,0 +1,12 @@
+from .iam.workspace import WorkspaceService
+from .iam.role import RoleService
+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,118 @@
+import json
+import uuid
+from typing import TYPE_CHECKING, Type, List, Union
+from datetime import datetime
+from hydroserverpy.api.models.base import HydroServerBaseModel, HydroServerCollection
+from hydroserverpy.api.utils import order_by_to_camel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+
+
+class HydroServerBaseService:
+    model: Type[HydroServerBaseModel]
+
+    def __init__(self, client: "HydroServer") -> None:
+        self.client = client
+
+    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 collection
+
+    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(
+            client=self.client, uid=uuid.UUID(str(response.pop("id"))), **response
+        )
+
+    def create(self, **kwargs):
+        path = f"/{self.client.base_route}/{self.model.get_route()}"
+        headers = {"Content-type": "application/json"}
+        response = self.client.request(
+            "post", path, headers=headers, data=json.dumps(kwargs, default=self.default_serializer)
+        ).json()
+
+        return self.model(
+            client=self.client, uid=uuid.UUID(str(response.pop("id"))), **response
+        )
+
+    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"}
+        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(
+            client=self.client, uid=uuid.UUID(str(response.pop("id"))), **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 prune_unset(self, obj):
+        if isinstance(obj, dict):
+            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

hydroserverpy/api/services/etl/data_archive.py

@@ -0,0 +1,166 @@
+from typing import Optional, Union, List, Literal, TYPE_CHECKING
+from uuid import UUID
+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, Datastream
+
+
+class DataArchiveService(HydroServerBaseService):
+    def __init__(self, client: "HydroServer"):
+        self.model = DataArchive
+        super().__init__(client)
+
+    def list(
+        self,
+        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."""
+
+        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 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."""
+
+        body = {
+            "name": name,
+            "workspaceId": normalize_uuid(workspace),
+            "orchestrationSystemId": normalize_uuid(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": (
+                [
+                    normalize_uuid(datastream)
+                    for datastream in datastreams
+                ]
+                if datastreams
+                else []
+            ),
+        }
+
+        return super().create(**body)
+
+    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_body = {
+            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_body = status_body if status_body else ...
+
+        schedule_body = {
+            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_body = schedule_body if schedule_body else ...
+
+        body = {
+            k: v
+            for k, v in {
+                "name": name,
+                "orchestrationSystemId": getattr(
+                    orchestration_system, "uid", orchestration_system
+                ),
+                "settings": settings,
+                "schedule": schedule_body,
+                "status": status_body,
+            }.items()
+            if v is not ...
+        }
+
+        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."""
+
+        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."""
+
+        path = f"/{self.client.base_route}/{self.model.get_route()}/{str(uid)}/datastreams/{normalize_uuid(datastream)}"
+        self.client.request("delete", path)