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

hydroserverpy/api/services/sta/sensor.py

@@ -0,0 +1,116 @@
+from typing import Optional, Union, List, TYPE_CHECKING
+from uuid import UUID
+from ..base import SensorThingsService
+from hydroserverpy.api.models import Sensor
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+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)
+
+    def list(
+        self,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+        page: int = 1,
+        page_size: int = 100,
+    ) -> 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
+            ),
+        )
+
+    def create(
+        self,
+        workspace: Union["Workspace", UUID, str],
+        name: str,
+        description: str,
+        encoding_type: str,
+        method_type: str,
+        manufacturer: Optional[str] = None,
+        sensor_model: Optional[str] = None,
+        sensor_model_link: Optional[str] = None,
+        method_link: Optional[str] = None,
+        method_code: Optional[str] = None,
+    ) -> "Sensor":
+        """Create a new sensor."""
+
+        kwargs = {
+            "name": name,
+            "description": description,
+            "encodingType": encoding_type,
+            "methodType": method_type,
+            "manufacturer": manufacturer,
+            "model": sensor_model,
+            "modelLink": sensor_model_link,
+            "methodLink": method_link,
+            "methodCode": method_code,
+            "workspaceId": str(getattr(workspace, "uid", workspace)),
+        }
+
+        return super()._create(**kwargs)
+
+    def update(
+        self,
+        uid: Union[UUID, str],
+        name: str = ...,
+        description: str = ...,
+        encoding_type: str = ...,
+        method_type: str = ...,
+        manufacturer: Optional[str] = ...,
+        sensor_model: Optional[str] = ...,
+        sensor_model_link: Optional[str] = ...,
+        method_link: Optional[str] = ...,
+        method_code: Optional[str] = ...,
+    ) -> "Sensor":
+        """Update a sensor."""
+
+        kwargs = {
+            "name": name,
+            "description": description,
+            "encodingType": encoding_type,
+            "methodType": method_type,
+            "manufacturer": manufacturer,
+            "model": sensor_model,
+            "modelLink": sensor_model_link,
+            "methodLink": method_link,
+            "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))

hydroserverpy/api/services/sta/thing.py

@@ -0,0 +1,188 @@
+import json
+from typing import TYPE_CHECKING, Union, IO, List, Dict, Optional
+from uuid import UUID
+from ..base import SensorThingsService
+from hydroserverpy.api.models import Thing
+
+
+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)
+
+    def list(
+        self,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+        page: int = 1,
+        page_size: int = 100,
+    ) -> 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,
+        )
+
+    def create(
+        self,
+        workspace: Union["Workspace", UUID, str],
+        name: str,
+        description: str,
+        sampling_feature_type: str,
+        sampling_feature_code: str,
+        site_type: str,
+        is_private: False,
+        latitude: float,
+        longitude: float,
+        elevation_m: Optional[float] = None,
+        elevation_datum: Optional[str] = None,
+        state: Optional[str] = None,
+        county: Optional[str] = None,
+        country: Optional[str] = None,
+        data_disclaimer: Optional[str] = None,
+    ) -> "Thing":
+        """Create a new thing."""
+
+        kwargs = {
+            "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)),
+        }
+
+        return super()._create(**kwargs)
+
+    def update(
+        self,
+        uid: Union[UUID, str],
+        name: str = ...,
+        description: str = ...,
+        sampling_feature_type: str = ...,
+        sampling_feature_code: str = ...,
+        site_type: str = ...,
+        is_private: False = ...,
+        latitude: float = ...,
+        longitude: float = ...,
+        elevation_m: Optional[float] = ...,
+        elevation_datum: Optional[str] = ...,
+        state: Optional[str] = ...,
+        county: Optional[str] = ...,
+        country: Optional[str] = ...,
+        data_disclaimer: Optional[str] = ...,
+    ) -> "Thing":
+        """Update a thing."""
+
+        kwargs = {
+            "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,
+        }
+
+        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))
+
+    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}),
+        ).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}),
+        ).json()
+
+    def delete_tag(self, uid: Union[UUID, str], key: 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}),
+        )
+
+    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},
+        ).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}),
+        )

hydroserverpy/api/services/sta/unit.py

@@ -0,0 +1,82 @@
+from typing import Optional, Union, List, TYPE_CHECKING
+from uuid import UUID
+from ..base import EndpointService
+from hydroserverpy.api.models import Unit
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class UnitService(EndpointService):
+    def __init__(self, connection: "HydroServer"):
+        self._model = Unit
+        self._api_route = "api/data"
+        self._endpoint_route = "units"
+
+        super().__init__(connection)
+
+    def list(
+        self,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+    ) -> 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 {},
+        )
+
+    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,
+    ) -> "Unit":
+        """Create a new unit."""
+
+        kwargs = {
+            "name": name,
+            "symbol": symbol,
+            "definition": definition,
+            "type": unit_type,
+            "workspaceId": str(getattr(workspace, "uid", workspace)),
+        }
+
+        return super()._create(**kwargs)
+
+    def update(
+        self,
+        uid: Union[UUID, str],
+        name: str = ...,
+        symbol: str = ...,
+        definition: str = ...,
+        unit_type: str = ...,
+    ) -> "Unit":
+        """Update a unit."""
+
+        kwargs = {
+            "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))

hydroserverpy/etl/loaders/hydroserver_loader.py

@@ -1,4 +1,4 @@
-from hydroserverpy.core.service import HydroServer
+from hydroserverpy import HydroServer
 from typing import Dict, Optional
 from .base import Loader
 import logging

hydroserverpy/etl_csv/hydroserver_etl_csv.py

@@ -10,7 +10,7 @@ from .exceptions import HeaderParsingError, TimestampParsingError
 import warnings
 
 if TYPE_CHECKING:
-    from ..core.schemas import DataSource
+    from hydroserverpy_old.core.schemas import DataSource
 
 logger = logging.getLogger("hydroserver_etl")
 logger.addHandler(logging.NullHandler())

{hydroserverpy-0.4.0.dist-info → hydroserverpy-0.5.0b1.dist-info}/METADATA

@@ -1,10 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: hydroserverpy
-Version: 0.4.0
+Version: 0.5.0b1
 Requires-Python: <4,>=3.9
 License-File: LICENSE
 Requires-Dist: requests>=2
 Requires-Dist: pydantic>=2.6
+Requires-Dist: pydantic[email]>=2.6
 Requires-Dist: pandas>=2.2
 Requires-Dist: numpy>=2.0
 Requires-Dist: pyyaml>=5
@@ -12,7 +13,7 @@ Requires-Dist: simplejson>=3
 Requires-Dist: crontab>=1
 Requires-Dist: python-dateutil>=2.8.2
 Requires-Dist: croniter>=2.0.1
-Requires-Dist: country-list>=1.1.0
 Requires-Dist: jmespath>=1.0.1
 Provides-Extra: docs
 Requires-Dist: sphinx_autodoc_typehints; extra == "docs"
+Dynamic: license-file

hydroserverpy-0.5.0b1.dist-info/RECORD

@@ -0,0 +1,59 @@
+hydroserverpy/__init__.py,sha256=FgaGFyhCjwmpJYEKNzOZxvfRx2neWMaOybj1z02_VSE,218
+hydroserverpy/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/api/http.py,sha256=be2L_0t9RtpjRlS4YYlJ0T09wyvUYw2-fg5eXBQwNXA,632
+hydroserverpy/api/main.py,sha256=2IVNMsf5h1UWfDZSxJn1wewOmN2D2kIMq7iqwiBqCNY,4216
+hydroserverpy/api/models/__init__.py,sha256=YwO9ixElkQp3Nwi6gb0XPj4H32aNmUOFm0oXc20E_F8,550
+hydroserverpy/api/models/base.py,sha256=dc2tfMSgizymxAAOVURfy7Jzeh6xIiiq7hfWZI7l1_Q,2280
+hydroserverpy/api/models/etl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/api/models/iam/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/api/models/iam/account.py,sha256=7COk_CPYFlthg1uFWTBlJESfnuqMW90TSjZoIcBb-_8,439
+hydroserverpy/api/models/iam/collaborator.py,sha256=jp661DKDCwk8c8HFPAV-YVhEc80F5eGDKaSHmH62Q8Q,1007
+hydroserverpy/api/models/iam/role.py,sha256=8FVTj_1QwtPF9tk7baliMVg000kjc5N8oP6eYo8vTDY,275
+hydroserverpy/api/models/iam/workspace.py,sha256=IonbIWMGAuxPVum0i0kEy0EJq7l79eH40-2P_SZAJHs,6194
+hydroserverpy/api/models/sta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/api/models/sta/datastream.py,sha256=SfBixRPsR0j6g1hNnjg0fzlCK4AfQxo8voXVyU0tS-o,10744
+hydroserverpy/api/models/sta/observed_property.py,sha256=ThTg8aPMHPxbk9Hzpxw3AwM16gE1xvYpRK8UkiOdGeA,2180
+hydroserverpy/api/models/sta/processing_level.py,sha256=y5_0wX7QGXgswvukXJtbpOiTCZ9pI8E08DXaTSUHakg,1470
+hydroserverpy/api/models/sta/result_qualifier.py,sha256=IJcY04KjP9e2D-jPzUJjH2PC-JvDNCjbi5LKkTVSwgw,1416
+hydroserverpy/api/models/sta/sensor.py,sha256=TD9R1Uwcu1t9tRQBfk0crsSJmV5UN_9kH9Ye9b7lDJc,3055
+hydroserverpy/api/models/sta/thing.py,sha256=o4Xn_Luy2IEOCBjXTbek7GvPoXZyKA0dhfzoFM6nfTs,6357
+hydroserverpy/api/models/sta/unit.py,sha256=Pbxxp9hZErsrYImIb8-1HVnZAsJopE3US_AplSQWOJQ,1398
+hydroserverpy/api/services/__init__.py,sha256=PhqbFlKfZ8a3WJidJUwa0gJ3OADcivepEEqfbQXb1dc,371
+hydroserverpy/api/services/base.py,sha256=Y2aJDMcVR7qxTgZQh1s8UYyRsoogjDY6TkCxvV9jfxA,3025
+hydroserverpy/api/services/etl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/api/services/iam/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/api/services/iam/workspace.py,sha256=jJiqkMxFEp9REjR4LXyVp2o45CGBrrEadGelPPCuRJs,4547
+hydroserverpy/api/services/sta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/api/services/sta/datastream.py,sha256=_m-xFom3z8wo5-1_q8NjWUpcw36wYv1brIG7xeGGadk,12402
+hydroserverpy/api/services/sta/observed_property.py,sha256=7V2PjsQqEGPEWk1n_o3MS0UM_tKQdTCEjDYM2XKMk0I,2894
+hydroserverpy/api/services/sta/processing_level.py,sha256=Oupfeww2XgT83AwR5Spt91VjZK6MG0XIl11Et9fRjA0,2255
+hydroserverpy/api/services/sta/result_qualifier.py,sha256=XG5Ng3xdFT-l3Ktkuq23Cty1RfmepBO7EQ9gPzidZuA,2069
+hydroserverpy/api/services/sta/sensor.py,sha256=SbDhLjlOaM2ypLDfXmQVinj7eHHJ_fHxjTD68dM2pQI,3473
+hydroserverpy/api/services/sta/thing.py,sha256=QL7IBwHHIgDFBpXnQF-LOUpxiRlm_HFWB1qqe7Iqq9s,5972
+hydroserverpy/api/services/sta/unit.py,sha256=ksO-3g___9pPNBNbgM0jyDf1NeBqX79fjeJjCshrftY,2138
+hydroserverpy/etl/__init__.py,sha256=qK2m4LZl8czR3VE8SxrlipSy5tLGLNB60lxD7dD0GjU,659
+hydroserverpy/etl/hydroserver_etl.py,sha256=FSdvM3T7QHEWWulWRT8t-FMHSxAGB4GvleUXtSk5IWc,1507
+hydroserverpy/etl/types.py,sha256=4PY3CM-uoXIsf2lhcqtLC6HaRGXe7HKGDU22R8-H35c,135
+hydroserverpy/etl/extractors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/etl/extractors/base.py,sha256=GZKJfAhfJedRcNagnoqUiDZn286r-JzM7dW_F1dWsfY,275
+hydroserverpy/etl/extractors/ftp_extractor.py,sha256=5LwvHuvLk6LwRSVyE9EkV3DPgVlAvRrOBpl1a8B7dLg,1387
+hydroserverpy/etl/extractors/http_extractor.py,sha256=-duQwnsFBk4NQS2qhO55evcCUOnrBe3JX_LU9RyysX4,2709
+hydroserverpy/etl/extractors/local_file_extractor.py,sha256=T_Y9NTO0cC5L9mDPbIG6wYlXDQoatg8MobP97liFl4U,692
+hydroserverpy/etl/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/etl/loaders/base.py,sha256=DrA9u7SNBxkPKqaszlP368yNbxihdqIGzP8rA6NAp6U,295
+hydroserverpy/etl/loaders/hydroserver_loader.py,sha256=bl4Z5TkXgJyKEHuPdY7LSrKMKOoZW_EDFl8dIRwDkv4,2549
+hydroserverpy/etl/transformers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/etl/transformers/base.py,sha256=237oVBhS3HQ3fcE4bZT5U1437WzV2x5kOFC229DY53M,1741
+hydroserverpy/etl/transformers/csv_transformer.py,sha256=9DKSO4NfUUDlr_c6UnH4AU3-7LxwSSeuQdou0iiCjdM,3238
+hydroserverpy/etl/transformers/json_transformer.py,sha256=ity0MXcYjEnlun4Y6cVSrnjrglKrK4JOXXHxWHIHN2A,2323
+hydroserverpy/etl_csv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/etl_csv/exceptions.py,sha256=0UY8YUlNepG0y6FfH36hJyR1bOhwYHSZIdUSSMTg7GA,314
+hydroserverpy/etl_csv/hydroserver_etl_csv.py,sha256=lpZmlh4BAsljLLCEj4UiDtty3m28MJbnSiOE71gDrCQ,13260
+hydroserverpy/quality/__init__.py,sha256=GGBMkFSXciJLYrbV-NraFrj_mXWCy_GTcy9KKrKXU4c,84
+hydroserverpy/quality/service.py,sha256=U02UfLKVmFvr5ySiH0n0JYzUIabq5uprrHIiwcqBlqY,13879
+hydroserverpy-0.5.0b1.dist-info/licenses/LICENSE,sha256=xVqFxDw3QOEJukakL7gQCqIMTQ1dlSCTo6Oc1otNW80,1508
+hydroserverpy-0.5.0b1.dist-info/METADATA,sha256=ZhKOorHNQG_J18X3L2HnUqBp5gFZBx8QuwwlmPpc0FM,532
+hydroserverpy-0.5.0b1.dist-info/WHEEL,sha256=L0N565qmK-3nM2eBoMNFszYJ_MTx03_tQ0CQu1bHLYo,91
+hydroserverpy-0.5.0b1.dist-info/top_level.txt,sha256=Zf37hrncXLOYvXhgCrf5mZdeq81G9fShdE2LfYbtb7w,14
+hydroserverpy-0.5.0b1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+hydroserverpy-0.5.0b1.dist-info/RECORD,,

{hydroserverpy-0.4.0.dist-info → hydroserverpy-0.5.0b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (78.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

hydroserverpy/core/endpoints/__init__.py

@@ -1,9 +0,0 @@
-from .data_loaders import DataLoaderEndpoint
-from .data_sources import DataSourceEndpoint
-from .datastreams import DatastreamEndpoint
-from .observed_properties import ObservedPropertyEndpoint
-from .processing_levels import ProcessingLevelEndpoint
-from .result_qualifiers import ResultQualifierEndpoint
-from .sensors import SensorEndpoint
-from .things import ThingEndpoint
-from .units import UnitEndpoint

hydroserverpy/core/endpoints/base.py

@@ -1,146 +0,0 @@
-import json
-from uuid import UUID
-from typing import TYPE_CHECKING, Type, Union, List, TypeVar, Optional
-
-if TYPE_CHECKING:
-    from hydroserverpy import HydroServer
-    from hydroserverpy.core.schemas.base import HydroServerCoreModel
-
-    HydroServerModelType = TypeVar("HydroServerModelType", bound=HydroServerCoreModel)
-
-
-def expand_docstring(
-    model: Optional[Type["HydroServerCoreModel"]] = None, include_uid: bool = False
-):
-    def decorator(func):
-        docstring = func.__doc__
-        if model is not None or include_uid is True:
-            docstring += "\n"
-        if include_uid is True:
-            docstring += f":param uid: The entity ID.\n"
-            docstring += f":type uid: Union[UUID, str]\n"
-        if model is not None:
-            for field_name, field in model.model_fields.items():
-                docstring += f":param {field_name}: {field.description}\n"
-                docstring += f':type {field_name}: {getattr(field.annotation, "__name__", field.annotation)}\n'
-        func.__doc__ = docstring
-        return func
-
-    return decorator
-
-
-class HydroServerEndpoint:
-    """
-    A base class for interacting with specific API endpoints within a HydroServer service.
-
-    :ivar _model: The model class associated with this endpoint.
-    :ivar _api_route: The base route of the API.
-    :ivar _endpoint_route: The specific route of the endpoint.
-    """
-
-    _model: Type["HydroServerCoreModel"]
-    _api_route: str
-    _endpoint_route: str
-
-    def __init__(self, service: "HydroServer") -> None:
-        """
-        Initialize the HydroServerEndpoint.
-
-        :param service: The HydroServer service instance to use for requests.
-        :type service: HydroServer
-        """
-
-        self._service = service
-
-    def _get(
-        self, uid: Optional[Union[UUID, str]] = None, params: dict = None
-    ) -> Union[List["HydroServerModelType"], "HydroServerModelType"]:
-        """
-        Fetch an entity collection or single entity from a HydroServer endpoint.
-
-        :param uid: The unique identifier of the entity to retrieve.
-        :type uid: Optional[Union[UUID, str]]
-        :returns: A model instance representing the entity.
-        :rtype: HydroServerCoreModel
-        """
-
-        if params is None:
-            params = {}
-
-        path = f'{self._api_route}/data/{self._endpoint_route}{"/" + str(uid) if uid else ""}'
-        response = getattr(self._service, "_request")("get", path, params=params)
-
-        if uid:
-            entity = json.loads(response.content)
-            result = self._model(
-                _endpoint=self, _uid=UUID(str(entity.pop("id"))), **entity
-            )
-        else:
-            result = [
-                self._model(_endpoint=self, _uid=UUID(str(entity.pop("id"))), **entity)
-                for entity in json.loads(response.content)
-            ]
-
-        return result
-
-    def _post(self, **kwargs) -> "HydroServerModelType":
-        """
-        Create a new entity using the endpoint.
-
-        :param kwargs: The attributes to set on the new entity.
-        :returns: A model instance representing the newly created entity.
-        :rtype: HydroServerModelType
-        """
-
-        response = getattr(self._service, "_request")(
-            "post",
-            f"{self._api_route}/data/{self._endpoint_route}",
-            headers={"Content-type": "application/json"},
-            data=self._model(_endpoint=self, **kwargs).json(
-                exclude_unset=True, by_alias=True
-            ),
-        )
-        entity = json.loads(response.content)
-
-        return self._model(_endpoint=self, _uid=UUID(str(entity.pop("id"))), **entity)
-
-    def _patch(self, uid: Union[UUID, str], **kwargs) -> "HydroServerModelType":
-        """
-        Update an existing entity in the endpoint.
-
-        :param uid: The unique identifier of the entity to update.
-        :type uid: Union[UUID, str]
-        :param kwargs: The attributes to update on the entity.
-        :returns: A model instance representing the updated entity.
-        :rtype: HydroServerModelType
-        """
-
-        response = getattr(self._service, "_request")(
-            "patch",
-            f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}",
-            headers={"Content-type": "application/json"},
-            data=json.dumps(
-                {
-                    self._model.model_fields[key].serialization_alias: value
-                    for key, value in kwargs.items()
-                },
-                default=str,
-            ),
-        )
-        entity = json.loads(response.content)
-
-        return self._model(_endpoint=self, _uid=UUID(str(entity.pop("id"))), **entity)
-
-    def _delete(self, uid: Union[UUID, str]) -> None:
-        """
-        Delete an entity from the endpoint by its unique identifier.
-
-        :param uid: The unique identifier of the entity to delete.
-        :type uid: Union[UUID, str]
-        :returns: None
-        """
-
-        getattr(self._service, "_request")(
-            "delete",
-            f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}",
-        )