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

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,8 @@
+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

hydroserverpy/api/services/base.py

@@ -0,0 +1,92 @@
+from typing import TYPE_CHECKING, Type, Union, Optional
+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=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=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
+
+
+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/iam/workspace.py

@@ -0,0 +1,126 @@
+from typing import TYPE_CHECKING, Union, List
+from pydantic import EmailStr
+from uuid import UUID
+from hydroserverpy.api.models import Workspace, Role, Collaborator
+from ..base import EndpointService
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+
+
+class WorkspaceService(EndpointService):
+    def __init__(self, connection: "HydroServer"):
+        self._model = Workspace
+        self._api_route = "api/auth"
+        self._endpoint_route = "workspaces"
+
+        super().__init__(connection)
+
+    def list(self, associated_only: bool = False) -> List["Workspace"]:
+        """Fetch a collection of HydroServer resources."""
+
+        return super()._list(params={"associated_only": associated_only})
+
+    def get(self, uid: Union[UUID, str]) -> "Workspace":
+        """Get a workspace by ID."""
+
+        return super()._get(uid=str(uid))
+
+    def create(self, name: str, is_private: bool, **_) -> "Workspace":
+        """Create a new workspace."""
+
+        kwargs = {"name": name, "isPrivate": is_private}
+
+        return super()._create(**kwargs)
+
+    def update(
+        self, uid: Union[UUID, str], name: str = ..., is_private: bool = ..., **_
+    ) -> "Workspace":
+        """Update a workspace."""
+
+        kwargs = {"name": name, "isPrivate": is_private}
+
+        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 workspace."""
+
+        super()._delete(uid=str(uid))
+
+    def list_roles(self, uid: Union[UUID, str]) -> List["Role"]:
+        """Get all roles that can be assigned within a workspace."""
+
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}/roles"
+        response = self._connection.request("get", path)
+
+        return [Role(**obj) for obj in response.json()]
+
+    def list_collaborators(self, uid: Union[UUID, str]) -> List["Collaborator"]:
+        """Get all collaborators associated with a workspace."""
+
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}/collaborators"
+        response = self._connection.request("get", path)
+
+        return [
+            Collaborator(_connection=self._connection, workspace_id=uid, **obj)
+            for obj in response.json()
+        ]
+
+    def add_collaborator(
+        self, uid: Union[UUID, str], email: EmailStr, role: Union["Role", UUID, str]
+    ) -> "Collaborator":
+        """Add a collaborator to a workspace."""
+
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}/collaborators"
+        response = self._connection.request(
+            "post",
+            path,
+            json={"email": email, "roleId": str(getattr(role, "uid", role))},
+        )
+
+        return Collaborator(
+            _connection=self._connection, workspace_id=uid, **response.json()
+        )
+
+    def edit_collaborator_role(
+        self, uid: Union[UUID, str], email: EmailStr, role: Union["Role", UUID, str]
+    ) -> "Collaborator":
+        """Edit the role of a collaborator in a workspace."""
+
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}/collaborators"
+        response = self._connection.request(
+            "put",
+            path,
+            json={"email": email, "roleId": str(getattr(role, "uid", role))},
+        )
+
+        return Collaborator(
+            _connection=self._connection, workspace_id=uid, **response.json()
+        )
+
+    def remove_collaborator(self, uid: Union[UUID, str], email: EmailStr) -> None:
+        """Remove a collaborator from a workspace."""
+
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}/collaborators"
+        self._connection.request("delete", path, json={"email": email})
+
+    def transfer_ownership(self, uid: Union[UUID, str], email: str) -> None:
+        """Transfer ownership of a workspace to another HydroServer user."""
+
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}/transfer"
+        self._connection.request("post", path, json={"newOwner": email})
+
+    def accept_ownership_transfer(self, uid: Union[UUID, str]) -> None:
+        """Accept ownership transfer of a workspace."""
+
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}/transfer"
+        self._connection.request("put", path)
+
+    def cancel_ownership_transfer(self, uid: Union[UUID, str]) -> None:
+        """Cancel ownership transfer of a workspace."""
+
+        path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}/transfer"
+        self._connection.request("delete", path)