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

hydroserverpy/quality/service.py

@@ -20,33 +20,33 @@ from enum import Enum
 class TimeUnit(Enum):
     """Enumeration for time units."""
 
-    SECOND = 's'
-    MINUTE = 'm'
-    HOUR = 'h'
-    DAY = 'D'
-    WEEK = 'W'
-    MONTH = 'M'
-    YEAR = 'Y'
+    SECOND = "s"
+    MINUTE = "m"
+    HOUR = "h"
+    DAY = "D"
+    WEEK = "W"
+    MONTH = "M"
+    YEAR = "Y"
 
 
 class FilterOperation(Enum):
     """Enumeration for filter operations."""
 
-    LT = 'LT'
-    LTE = 'LTE'
-    GT = 'GT'
-    GTE = 'GTE'
-    E = 'E'
+    LT = "LT"
+    LTE = "LTE"
+    GT = "GT"
+    GTE = "GTE"
+    E = "E"
 
 
 class Operator(Enum):
     """Enumeration for mathematical operations."""
 
-    MULT = 'MULT'
-    DIV = 'DIV'
-    ADD = 'ADD'
-    SUB = 'SUB'
-    ASSIGN = 'ASSIGN'
+    MULT = "MULT"
+    DIV = "DIV"
+    ADD = "ADD"
+    SUB = "SUB"
+    ASSIGN = "ASSIGN"
 
 
 class HydroServerQualityControl:
@@ -61,15 +61,23 @@ class HydroServerQualityControl:
 
     datastream_id: Union[UUID, str]
 
-    def __init__(self, datastream_id: Union[UUID, str], observations: pd.DataFrame) -> None:
+    def __init__(
+        self, datastream_id: Union[UUID, str], observations: pd.DataFrame
+    ) -> None:
 
-        assert 'timestamp' in observations.columns, "Observations must have a 'timestamp' column"
-        assert pd.api.types.is_datetime64_any_dtype(observations['timestamp']), \
-            "Observations 'timestamp' column must be of datetime type"
+        assert (
+            "timestamp" in observations.columns
+        ), "Observations must have a 'timestamp' column"
+        assert pd.api.types.is_datetime64_any_dtype(
+            observations["timestamp"]
+        ), "Observations 'timestamp' column must be of datetime type"
 
-        assert 'value' in observations.columns, "Observations must have a 'value' column"
-        assert pd.api.types.is_float_dtype(observations['value']), \
-            "Observations 'value' column must be of float type"
+        assert (
+            "value" in observations.columns
+        ), "Observations must have a 'value' column"
+        assert pd.api.types.is_float_dtype(
+            observations["value"]
+        ), "Observations 'value' column must be of float type"
 
         self.datastream_id = str(datastream_id)
         self._df = observations
@@ -94,7 +102,9 @@ class HydroServerQualityControl:
     ###################
 
     @staticmethod
-    def _has_filter(data_filter: Dict[str, Union[float, int]], key: FilterOperation) -> bool:
+    def _has_filter(
+        data_filter: Dict[str, Union[float, int]], key: FilterOperation
+    ) -> bool:
         """
         Checks if a given filter operation exists in the filter dictionary.
 
@@ -106,9 +116,9 @@ class HydroServerQualityControl:
         :rtype: bool
         """
 
-        return (
-            key.value in data_filter and
-            (isinstance(data_filter[key.value], float) or isinstance(data_filter[key.value], int))
+        return key.value in data_filter and (
+            isinstance(data_filter[key.value], float)
+            or isinstance(data_filter[key.value], int)
         )
 
     def filter(self, data_filter: Dict[str, Union[float, int]]) -> None:
@@ -122,24 +132,19 @@ class HydroServerQualityControl:
         query = []
 
         if self._has_filter(data_filter, FilterOperation.LT):
-            query.append(
-                f'`value` < {data_filter[FilterOperation.LT.value]}')
+            query.append(f"`value` < {data_filter[FilterOperation.LT.value]}")
 
         if self._has_filter(data_filter, FilterOperation.LTE):
-            query.append(
-                f'`value` <= {data_filter[FilterOperation.LTE.value]}')
+            query.append(f"`value` <= {data_filter[FilterOperation.LTE.value]}")
 
         if self._has_filter(data_filter, FilterOperation.GT):
-            query.append(
-                f'`value` > {data_filter[FilterOperation.GT.value]}')
+            query.append(f"`value` > {data_filter[FilterOperation.GT.value]}")
 
         if self._has_filter(data_filter, FilterOperation.GTE):
-            query.append(
-                f'`value` >= {data_filter[FilterOperation.GTE.value]}')
+            query.append(f"`value` >= {data_filter[FilterOperation.GTE.value]}")
 
         if self._has_filter(data_filter, FilterOperation.E):
-            query.append(
-                f'`value` == {data_filter[FilterOperation.E.value]}')
+            query.append(f"`value` == {data_filter[FilterOperation.E.value]}")
 
         if len(query):
             self._filtered_observations = self._df.query(" | ".join(query))
@@ -162,9 +167,13 @@ class HydroServerQualityControl:
         :rtype: pd.DataFrame
         """
 
-        return self.observations[self._df['timestamp'].diff() > np.timedelta64(time_value, time_unit)]
+        return self.observations[
+            self._df["timestamp"].diff() > np.timedelta64(time_value, time_unit)
+        ]
 
-    def fill_gap(self, gap: Tuple[int, str], fill: Tuple[int, str], interpolate_values: bool) -> pd.DataFrame:
+    def fill_gap(
+        self, gap: Tuple[int, str], fill: Tuple[int, str], interpolate_values: bool
+    ) -> pd.DataFrame:
         """
         Fills identified gaps in the observations with placeholder values and optionally interpolates the values.
 
@@ -188,8 +197,8 @@ class HydroServerQualityControl:
             gap_end_index = gap_row[0]
             gap_start_index = gap_end_index - 1
 
-            gap_start_date = self._df.iloc[gap_start_index]['timestamp']
-            gap_end_date = self._df.iloc[gap_end_index]['timestamp']
+            gap_start_date = self._df.iloc[gap_start_index]["timestamp"]
+            gap_end_date = self._df.iloc[gap_end_index]["timestamp"]
 
             start = gap_start_date + time_gap
             end = gap_end_date
@@ -210,15 +219,15 @@ class HydroServerQualityControl:
             self.interpolate(added_index)
 
         # Return the list of points that filled the gaps
-        return pd.DataFrame(
-            points, columns=['timestamp', 'value']
-        )
+        return pd.DataFrame(points, columns=["timestamp", "value"])
 
     ######################################
     # Data point operations
     ######################################
 
-    def add_points(self, points: List[List[Union[str, float]]], index: Optional[List[int]] = None) -> None:
+    def add_points(
+        self, points: List[List[Union[str, float]]], index: Optional[List[int]] = None
+    ) -> None:
         """
         Adds new points to the observations, optionally at specified indices.
 
@@ -251,8 +260,7 @@ class HydroServerQualityControl:
                 df1 = self._df.iloc[:idx, :]
                 df2 = self._df.iloc[idx:, :]
 
-                points_df = pd.DataFrame(
-                    val, columns=['timestamp', 'value'])
+                points_df = pd.DataFrame(val, columns=["timestamp", "value"])
                 self._df = pd.concat([df1, points_df, df2]).reset_index(drop=True)
 
         else:
@@ -260,17 +268,18 @@ class HydroServerQualityControl:
             # data in the DataFrame is pre-sorted.
 
             # Create a new dataframe with the points
-            points_df = pd.DataFrame(
-                points, columns=['timestamp', 'value'])
+            points_df = pd.DataFrame(points, columns=["timestamp", "value"])
 
             # Concatenate both dataframes. New rows will be at the end.
             self._df = pd.concat([self._df, points_df])
 
             # Sort and reset index
-            self._df = self._df.sort_values('timestamp')
+            self._df = self._df.sort_values("timestamp")
             self._df.reset_index(drop=True, inplace=True)
 
-    def change_values(self, index_list: List[int], operator: str, value: Union[int, float]) -> None:
+    def change_values(
+        self, index_list: List[int], operator: str, value: Union[int, float]
+    ) -> None:
         """
         Changes the values of observations based on the specified operator and value.
 
@@ -299,7 +308,9 @@ class HydroServerQualityControl:
             else:
                 return x
 
-        self._df.loc[index_list, 'value'] = self._df.loc[index_list, 'value'].apply(operation)
+        self._df.loc[index_list, "value"] = self._df.loc[index_list, "value"].apply(
+            operation
+        )
 
     def delete_points(self, index_list: List[int]) -> None:
         """
@@ -312,7 +323,9 @@ class HydroServerQualityControl:
         self._df.drop(index=index_list, inplace=True)
         self._df.reset_index(drop=True, inplace=True)
 
-    def shift_points(self, index_list: List[int], time_value: int, time_unit: str) -> None:
+    def shift_points(
+        self, index_list: List[int], time_value: int, time_unit: str
+    ) -> None:
         """
         Shifts the timestamps of the observations at the specified indices by a given time value and unit.
 
@@ -328,8 +341,10 @@ class HydroServerQualityControl:
         condition = self._df.index.isin(index_list)
 
         # Apply the shift
-        self._df.loc[condition, 'timestamp'] = self._df.loc[condition, 'timestamp'] + shift_value
-        self._df = self._df.sort_values('timestamp')
+        self._df.loc[condition, "timestamp"] = (
+            self._df.loc[condition, "timestamp"] + shift_value
+        )
+        self._df = self._df.sort_values("timestamp")
         self._df.reset_index(drop=True, inplace=True)
 
     def interpolate(self, index_list: List[int]) -> None:
@@ -341,8 +356,8 @@ class HydroServerQualityControl:
         """
 
         condition = self._df.index.isin(index_list)
-        self._df['value'].mask(condition, inplace=True)
-        self._df['value'].interpolate(method='linear', inplace=True)
+        self._df["value"].mask(condition, inplace=True)
+        self._df["value"].interpolate(method="linear", inplace=True)
 
     def drift_correction(self, start: int, end: int, gap_width: float) -> pd.DataFrame:
         """
@@ -360,32 +375,31 @@ class HydroServerQualityControl:
 
         # validate range
         if start >= end:
-            print('Start and end index cannot overlap')
+            print("Start and end index cannot overlap")
             return self._df
         elif end > len(self._df) - 1:
-            print('End index out of range')
+            print("End index out of range")
             return self._df
         elif start < 0:
-            print('Start index must be greater than or equal to 0')
+            print("Start index must be greater than or equal to 0")
             return self._df
 
-        points = self._df.iloc[start:end + 1]
-        start_date = points.iloc[0]['timestamp']
-        end_date = points.iloc[-1]['timestamp']
+        points = self._df.iloc[start : end + 1]
+        start_date = points.iloc[0]["timestamp"]
+        end_date = points.iloc[-1]["timestamp"]
 
         x_l = (end_date - start_date).total_seconds()
         ndv = -9999
         # y_n = y_0 + G(x_i / x_l)
 
         def f(row):
-            if row['value'] != ndv:
-                return (
-                    row['value'] +
-                    (gap_width * ((row['timestamp'] - start_date).total_seconds() / x_l))
+            if row["value"] != ndv:
+                return row["value"] + (
+                    gap_width * ((row["timestamp"] - start_date).total_seconds() / x_l)
                 )
             else:
-                return row['value']
+                return row["value"]
 
-        self._df.loc[points.index, 'value'] = points.apply(f, axis=1)
+        self._df.loc[points.index, "value"] = points.apply(f, axis=1)
 
         return self._df

hydroserverpy-0.5.0b1.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: hydroserverpy
+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
+Requires-Dist: simplejson>=3
+Requires-Dist: crontab>=1
+Requires-Dist: python-dateutil>=2.8.2
+Requires-Dist: croniter>=2.0.1
+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.3.0.dist-info → hydroserverpy-0.5.0b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.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,133 +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)}',
-        )

hydroserverpy/core/endpoints/data_loaders.py

@@ -1,92 +0,0 @@
-import json
-from typing import Union, List, TYPE_CHECKING
-from uuid import UUID
-from hydroserverpy.core.endpoints.base import HydroServerEndpoint, expand_docstring
-from hydroserverpy.core.endpoints.data_sources import DataSourceEndpoint
-from hydroserverpy.core.schemas import DataLoader, DataSource
-
-if TYPE_CHECKING:
-    from hydroserverpy.core.service import HydroServer
-
-
-class DataLoaderEndpoint(HydroServerEndpoint):
-    """
-    An endpoint for interacting with DataLoader entities in the HydroServer service.
-
-    :ivar _model: The model class associated with this endpoint, set to `DataLoader`.
-    :ivar _api_route: The base route of the API, derived from the service.
-    :ivar _endpoint_route: The specific route of the endpoint, set to `'data-loaders'`.
-    """
-
-    def __init__(self, service: 'HydroServer') -> None:
-        """
-        Initialize the DataLoaderEndpoint.
-
-        :param service: The HydroServer service instance to use for requests.
-        :type service: HydroServer
-        """
-
-        super().__init__(service)
-        self._model = DataLoader
-        self._api_route = self._service.api_route
-        self._endpoint_route = 'data-loaders'
-
-    def list(self) -> List[DataLoader]:
-        """
-        Retrieve a collection of data loaders owned by the logged-in user.
-        """
-
-        return super()._get()
-
-    @expand_docstring(include_uid=True)
-    def get(self, uid: Union[UUID, str]) -> DataLoader:
-        """
-        Retrieve a data loader owned by the logged-in user.
-        """
-
-        return super()._get(uid)
-
-    @expand_docstring(model=DataLoader)
-    def create(self, **kwargs) -> DataLoader:
-        """
-        Create a new data loader in HydroServer.
-        """
-
-        return super()._post(**kwargs)
-
-    @expand_docstring(model=DataLoader, include_uid=True)
-    def update(self, uid: Union[UUID, str], **kwargs) -> DataLoader:
-        """
-        Update an existing data loader in HydroServer.
-        """
-
-        return super()._patch(uid=uid, **kwargs)
-
-    @expand_docstring(include_uid=True)
-    def delete(self, uid: Union[UUID, str]) -> None:
-        """
-        Delete an existing data loader in HydroServer.
-        """
-
-        super()._delete(uid=uid)
-
-    def list_data_sources(self, uid: Union[UUID, str]) -> List[DataSource]:
-        """
-        Retrieve a list of data source entities associated with a specific data loader.
-
-        :param uid: The unique identifier of the data loader.
-        :type uid: Union[UUID, str]
-        :returns: A list of data sour instances associated with the data loader.
-        :rtype: List[DataSource]
-        """
-
-        response = getattr(self._service, '_request')(
-            'get', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/data-sources'
-        )
-
-        endpoint = DataSourceEndpoint(self._service)
-
-        return [
-            DataSource(_endpoint=endpoint, _uid=UUID(str(entity.pop('id'))), **entity)
-            for entity in json.loads(response.content)
-        ]