hydroserverpy 0.2.3__py3-none-any.whl → 0.3.0__py3-none-any.whl

hydroserverpy/{etl.py → etl/service.py}

@@ -1,14 +1,15 @@
 import csv
 import logging
-import frost_sta_client as fsc
 import croniter
-from typing import IO, List
+import pandas as pd
+from typing import IO, List, TYPE_CHECKING
+from requests import HTTPError
 from datetime import datetime, timezone, timedelta
 from dateutil.parser import isoparse
-from .schemas.data_sources import DataSourceGetResponse
-from .schemas.datastreams import DatastreamGetResponse
 from .exceptions import HeaderParsingError, TimestampParsingError
-from .schemas.data_sources import DataSourcePatchBody
+
+if TYPE_CHECKING:
+    from ..core.schemas import DataSource
 
 logger = logging.getLogger('hydroserver_etl')
 logger.addHandler(logging.NullHandler())
@@ -20,14 +21,13 @@ class HydroServerETL:
             self,
             service,
             data_file: IO[str],
-            data_source: DataSourceGetResponse,
-            datastreams: List[DatastreamGetResponse]
+            data_source: 'DataSource',
     ):
         self._service = service
         self._data_file = data_file
         self._data_source = data_source
         self._datastreams = {
-            datastream.id: datastream for datastream in datastreams
+            datastream.uid: datastream for datastream in data_source.datastreams
         }
 
         self._timestamp_column_index = None
@@ -109,16 +109,16 @@ class HydroServerETL:
         timestamp = self._parse_row_timestamp(row)
 
         for datastream in self._datastreams.values():
-            if str(datastream.id) not in self._datastream_start_row_indexes.keys():
+            if str(datastream.uid) not in self._datastream_start_row_indexes.keys():
                 if not datastream.phenomenon_end_time or timestamp > datastream.phenomenon_end_time:
-                    self._datastream_start_row_indexes[str(datastream.id)] = index
+                    self._datastream_start_row_indexes[str(datastream.uid)] = index
 
-            if str(datastream.id) in self._datastream_start_row_indexes.keys() \
-                    and self._datastream_start_row_indexes[str(datastream.id)] <= index:
-                if str(datastream.id) not in self._observations.keys():
-                    self._observations[str(datastream.id)] = []
+            if str(datastream.uid) in self._datastream_start_row_indexes.keys() \
+                    and self._datastream_start_row_indexes[str(datastream.uid)] <= index:
+                if str(datastream.uid) not in self._observations.keys():
+                    self._observations[str(datastream.uid)] = []
 
-                self._observations[str(datastream.id)].append({
+                self._observations[str(datastream.uid)].append({
                     'phenomenon_time': timestamp,
                     'result': row[self._datastream_column_indexes[datastream.data_source_column]]
                 })
@@ -219,27 +219,17 @@ class HydroServerETL:
                     f'{str(datastream_id)} in data source "{self._data_source.name}".'
                 )
 
-                data_array_value = getattr(fsc.model, 'ext').data_array_value.DataArrayValue()
-
-                datastream = fsc.Datastream(id=datastream_id)
-                components = {data_array_value.Property.PHENOMENON_TIME, data_array_value.Property.RESULT}
-
-                data_array_value.datastream = datastream
-                data_array_value.components = components
-
-                for observation in observations:
-                    data_array_value.add_observation(fsc.Observation(
-                        phenomenon_time=observation['phenomenon_time'].strftime('%Y-%m-%dT%H:%M:%S%z'),
-                        result=observation['result'],
-                        datastream=datastream
-                    ))
-
-                data_array_document = getattr(fsc.model, 'ext').data_array_document.DataArrayDocument()
-                data_array_document.add_data_array_value(data_array_value)
+                observations_df = pd.DataFrame(
+                    [[observation['phenomenon_time'], observation['result']] for observation in observations],
+                    columns=['timestamp', 'value']
+                )
 
                 try:
-                    self._service.sensorthings.observations().create(data_array_document)
-                except KeyError:
+                    self._service.datastreams.load_observations(
+                        uid=datastream_id,
+                        observations=observations_df,
+                    )
+                except HTTPError:
                     failed_datastreams.append(datastream_id)
 
                 if not self._last_loaded_timestamp or (
@@ -280,18 +270,13 @@ class HydroServerETL:
         else:
             next_sync = None
 
-        updated_data_source = DataSourcePatchBody(
-            data_source_thru=self._last_loaded_timestamp,
-            last_sync_successful=(
-                True if not self._file_timestamp_error and not self._file_header_error
-                and len(self._failed_datastreams) == 0 else False
-            ),
-            last_sync_message=self._message,
-            last_synced=datetime.now(timezone.utc),
-            next_sync=next_sync
+        self._data_source.data_source_thru = self._last_loaded_timestamp
+        self._data_source.last_sync_successful = (
+            True if not self._file_timestamp_error and not self._file_header_error
+            and len(self._failed_datastreams) == 0 else False
         )
+        self._data_source.last_sync_message = self._message
+        self._data_source.last_synced = datetime.now(timezone.utc)
+        self._data_source.next_sync = next_sync
 
-        self._service.data_sources.update(
-            data_source_id=str(self._data_source.id),
-            data_source_body=updated_data_source
-        )
+        self._data_source.save()

hydroserverpy/quality/__init__.py

@@ -0,0 +1 @@
+from .service import HydroServerQualityControl, TimeUnit, FilterOperation, Operator

hydroserverpy/quality/service.py

@@ -0,0 +1,391 @@
+import pandas as pd
+import numpy as np
+from uuid import UUID
+from typing import Union, Optional, List, Tuple, Dict
+from enum import Enum
+
+# Tools
+# [x] Interpolate
+# [x] Set a value to a constant
+# [x] Change value by applying arithmetic (+, -, *, /)
+# [x] Shift
+# [x] Drift correction (linear)
+# [x] Delete values
+# [x] Fill values
+
+# Automation
+# [x] Gap filling
+
+
+class TimeUnit(Enum):
+    """Enumeration for time units."""
+
+    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'
+
+
+class Operator(Enum):
+    """Enumeration for mathematical operations."""
+
+    MULT = 'MULT'
+    DIV = 'DIV'
+    ADD = 'ADD'
+    SUB = 'SUB'
+    ASSIGN = 'ASSIGN'
+
+
+class HydroServerQualityControl:
+    """
+    Quality control operations for HydroServer observations.
+
+    :param datastream_id: The ID of the datastream.
+    :type datastream_id: Union[UUID, str]
+    :param observations: DataFrame containing 'timestamp' and 'value' columns.
+    :type observations: pd.DataFrame
+    """
+
+    datastream_id: Union[UUID, str]
+
+    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 '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
+        self._filtered_observations = None
+
+    @property
+    def observations(self) -> pd.DataFrame:
+        """
+        Returns the observations DataFrame, filtered if a filter has been applied.
+
+        :return: Observations DataFrame.
+        :rtype: pd.DataFrame
+        """
+
+        if self._filtered_observations is None:
+            return self._df
+
+        return self._filtered_observations
+
+    ###################
+    # Filters
+    ###################
+
+    @staticmethod
+    def _has_filter(data_filter: Dict[str, Union[float, int]], key: FilterOperation) -> bool:
+        """
+        Checks if a given filter operation exists in the filter dictionary.
+
+        :param data_filter: Dictionary containing the filters.
+        :type data_filter: Dict[str, Union[float, int]]
+        :param key: Filter operation to check for.
+        :type key: FilterOperation
+        :return: True if the filter operation exists, False otherwise.
+        :rtype: bool
+        """
+
+        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:
+        """
+        Executes the applied filters and returns the resulting DataFrame.
+
+        :param data_filter: Dictionary containing filter operations and their values.
+        :type data_filter: Dict[str, Union[float, int]]
+        """
+
+        query = []
+
+        if self._has_filter(data_filter, FilterOperation.LT):
+            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]}')
+
+        if self._has_filter(data_filter, FilterOperation.GT):
+            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]}')
+
+        if self._has_filter(data_filter, FilterOperation.E):
+            query.append(
+                f'`value` == {data_filter[FilterOperation.E.value]}')
+
+        if len(query):
+            self._filtered_observations = self._df.query(" | ".join(query))
+        else:
+            self._filtered_observations = None
+
+    ###################
+    # Gap Analysis
+    ###################
+
+    def find_gaps(self, time_value: int, time_unit: str) -> pd.DataFrame:
+        """
+        Identifies gaps in the observations based on the specified time value and unit.
+
+        :param time_value: The time value for detecting gaps.
+        :type time_value: int
+        :param time_unit: The unit of time (e.g., 's', 'm', 'h').
+        :type time_unit: str
+        :return: DataFrame containing the observations with gaps.
+        :rtype: pd.DataFrame
+        """
+
+        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:
+        """
+        Fills identified gaps in the observations with placeholder values and optionally interpolates the values.
+
+        :param gap: Tuple containing the time value and unit for identifying gaps.
+        :type gap: Tuple[int, str]
+        :param fill: Tuple containing the time value and unit for filling gaps.
+        :type fill: Tuple[int, str]
+        :param interpolate_values: Whether to interpolate values for the filled gaps.
+        :type interpolate_values: bool
+        :return: DataFrame of points that filled the gaps.
+        :rtype: pd.DataFrame
+        """
+
+        gaps_df = self.find_gaps(gap[0], gap[1])
+        time_gap = np.timedelta64(fill[0], fill[1])
+        points = []
+        index = []
+        added_index = []
+
+        for gap_row in gaps_df.iterrows():
+            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']
+
+            start = gap_start_date + time_gap
+            end = gap_end_date
+
+            # Annotate the points that will fill this gap
+            while start < end:
+                points.append([start, -9999])
+                index.append(gap_start_index)
+                start = start + time_gap
+
+                if interpolate_values:
+                    # Keep an index of the position where the points will end up
+                    added_index.append(gap_start_index + len(added_index) + 1)
+
+        self.add_points(points, index)
+
+        if interpolate_values:
+            self.interpolate(added_index)
+
+        # Return the list of points that filled the gaps
+        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:
+        """
+        Adds new points to the observations, optionally at specified indices.
+
+        :param points: List of points to be added.
+        :type points: List[List[Union[str, float]]]
+        :param index: Optional list of indices at which to insert the points.
+        :type index: Optional[List[int]]
+        """
+
+        # If an index list was provided, insert the points to the DataFrame at the corresponding index.
+        # We do this by creating a dictionary of slices where the key is the index to insert at, and the value is an
+        # array of points to insert at that index
+        # We iterate through the dictionary keys in reverse order, so that we can insert without altering the position
+        # of elements before
+        if index is not None:
+            # This is the most efficient way to insert into a DataFrame for a large dataset.
+
+            # create a dictionary of points to insert at each index
+            slices = {}
+            for idx, value in enumerate(index):
+                if value not in slices:
+                    slices[value] = []
+
+                slices[value].append(points[idx])
+
+            for s in sorted(slices.items(), reverse=True):
+                # Split DataFrame and insert new row.
+                idx = s[0] + 1
+                val = s[1]
+                df1 = self._df.iloc[:idx, :]
+                df2 = self._df.iloc[idx:, :]
+
+                points_df = pd.DataFrame(
+                    val, columns=['timestamp', 'value'])
+                self._df = pd.concat([df1, points_df, df2]).reset_index(drop=True)
+
+        else:
+            # This way of inserting is not as efficient, but performance should be good enough given that the existing
+            # data in the DataFrame is pre-sorted.
+
+            # Create a new dataframe with the points
+            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.reset_index(drop=True, inplace=True)
+
+    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.
+
+        :param index_list: List of indices for which values will be changed.
+        :type index_list: List[int]
+        :param operator: The operation to perform ('MULT', 'DIV', 'ADD', 'SUB', 'ASSIGN').
+        :type operator: str
+        :param value: The value to use in the operation.
+        :type value: Union[int, float]
+        """
+
+        def operation(x):
+            if operator == Operator.MULT.value:
+                return x * value
+            elif operator == Operator.DIV.value:
+                if value == 0:
+                    print("Error: cannot divide by 0")
+                    return x
+                return x / value
+            elif operator == Operator.ADD.value:
+                return x + value
+            elif operator == Operator.SUB.value:
+                return x - value
+            elif operator == Operator.ASSIGN.value:
+                return value
+            else:
+                return x
+
+        self._df.loc[index_list, 'value'] = self._df.loc[index_list, 'value'].apply(operation)
+
+    def delete_points(self, index_list: List[int]) -> None:
+        """
+        Deletes points from the observations at the specified indices.
+
+        :param index_list: List of indices for which points will be deleted.
+        :type index_list: List[int]
+        """
+
+        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:
+        """
+        Shifts the timestamps of the observations at the specified indices by a given time value and unit.
+
+        :param index_list: List of indices where timestamps will be shifted.
+        :type index_list: List[int]
+        :param time_value: The amount of time to shift the timestamps.
+        :type time_value: int
+        :param time_unit: The unit of time (e.g., 's' for seconds, 'm' for minutes).
+        :type time_unit: str
+        """
+
+        shift_value = np.timedelta64(time_value, time_unit)
+        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.reset_index(drop=True, inplace=True)
+
+    def interpolate(self, index_list: List[int]) -> None:
+        """
+        Interpolates the values of observations at the specified indices using linear interpolation.
+
+        :param index_list: List of indices where values will be interpolated.
+        :type index_list: list[int]
+        """
+
+        condition = self._df.index.isin(index_list)
+        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:
+        """
+        Applies drift correction to the values of observations within the specified index range.
+
+        :param start: Start index of the range to apply drift correction.
+        :type start: int
+        :param end: End index of the range to apply drift correction.
+        :type end: int
+        :param gap_width: The width of the drift gap to correct.
+        :type gap_width: float
+        :return: DataFrame after applying drift correction.
+        :rtype: pd.DataFrame
+        """
+
+        # validate range
+        if start >= end:
+            print('Start and end index cannot overlap')
+            return self._df
+        elif end > len(self._df) - 1:
+            print('End index out of range')
+            return self._df
+        elif start < 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']
+
+        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))
+                )
+            else:
+                return row['value']
+
+        self._df.loc[points.index, 'value'] = points.apply(f, axis=1)
+
+        return self._df

{hydroserverpy-0.2.3.dist-info → hydroserverpy-0.3.0.dist-info}/METADATA

@@ -1,15 +1,18 @@
 Metadata-Version: 2.1
 Name: hydroserverpy
-Version: 0.2.3
+Version: 0.3.0
+Requires-Python: <4,>=3.9
 License-File: LICENSE
 Requires-Dist: requests >=2
-Requires-Dist: pydantic <2.0.0,>=1.6
+Requires-Dist: pydantic >=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: frost-sta-client >=1.1.44
+Requires-Dist: country-list >=1.1.0
 Provides-Extra: docs
 Requires-Dist: sphinx-autodoc-typehints ; extra == 'docs'
 

hydroserverpy-0.3.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+hydroserverpy/__init__.py,sha256=oVxU_pSr5RZx4s5UHYYNCrjXQAP5lujlosB2a3qG260,223
+hydroserverpy/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/core/service.py,sha256=ch6rwNM8oM3L-9phE474grofCR3QkTQ8AopkMyn9sjo,5339
+hydroserverpy/core/endpoints/__init__.py,sha256=SpN1WLX0R8HOLHBv1cp3VZcIEiKD4BBbgFGQppdA_mw,404
+hydroserverpy/core/endpoints/base.py,sha256=Ay0a8rucNo9x8h1MMMuMaISkBAgc9DK_kouLGtnHPjk,4925
+hydroserverpy/core/endpoints/data_loaders.py,sha256=boUdmn9_9QDJS38nBXwKXYiX_We_rfK1OFjCU8ptQUE,3009
+hydroserverpy/core/endpoints/data_sources.py,sha256=c9hwlFUUY-Ae84TrlB2boLjKIIhN_fzxHSYvPSb9PKA,3007
+hydroserverpy/core/endpoints/datastreams.py,sha256=z8NX21L2qcj07Cotm5sTT3GrNEV2jS0-AjLQDRHeRq8,6899
+hydroserverpy/core/endpoints/observed_properties.py,sha256=7_BtjsCyyGaQ1EMhlQXhWupTs85q7i85LdRLejVUb9o,3309
+hydroserverpy/core/endpoints/processing_levels.py,sha256=pDolo_BqkSufs3w_ykRbsg-93xWME7vYIA6BAwzdT7A,3286
+hydroserverpy/core/endpoints/result_qualifiers.py,sha256=977r3Vf6Y3kkoRcHQwTbQPSCxxeWsJkcDCPhFI30Tss,3301
+hydroserverpy/core/endpoints/sensors.py,sha256=niF6eY8dFdfowqW_dLq9-7CPolWO__lFwElMDJTYtsM,3122
+hydroserverpy/core/endpoints/things.py,sha256=n0nSq2AgJ7zFwAerkTtYlFvc1EzgUfHsu_nNTcVxqr0,8357
+hydroserverpy/core/endpoints/units.py,sha256=UZKizV8ZLMCPZQ0ol5U8UON_MB80uhxL2PUwDbtQLXA,3084
+hydroserverpy/core/schemas/__init__.py,sha256=gUFAim1jcUWAvj0IqpR8UKaCdXT1v11SmFnOzEmcwJM,353
+hydroserverpy/core/schemas/base.py,sha256=k5ctiVXLm5A0TI-Nkz9l3oDGsq16B3yKcQgnZcJVDds,3683
+hydroserverpy/core/schemas/data_loaders.py,sha256=BJv0-IUkgsNisuwyOooUAHaAv1DLCF5SVVnBjpfahYM,2470
+hydroserverpy/core/schemas/data_sources.py,sha256=oearfow10p-JJ5d_3-S2IEJ4039d4SMQlVA0N4dNOH0,8058
+hydroserverpy/core/schemas/datastreams.py,sha256=OEVc7xMVaFSHvLMyunt2g0u6xAfv5xg0fO6Uz8VjOSU,11413
+hydroserverpy/core/schemas/observed_properties.py,sha256=1ibOAYbsf1DQAos68V8KEmvBUoS2WO73dd5MhSWCC90,1161
+hydroserverpy/core/schemas/processing_levels.py,sha256=K4N5by5bfSD3iPcx6Jv1x-xOPxW3_gwhZcEfaqwSDmQ,867
+hydroserverpy/core/schemas/result_qualifiers.py,sha256=ejUMPCDOq3cuq3a6j2uvQNRdVNEVQ1jJAacYv-o9NZI,722
+hydroserverpy/core/schemas/sensors.py,sha256=8nXSEyD1kGAL2Wi76kHvjXNSgh2VFTfMgBkFP8ACsZw,1835
+hydroserverpy/core/schemas/things.py,sha256=Pkr3bIo4VjLML7o53_R2lXwBmx0Z7aoGlvJKC9Diw60,11139
+hydroserverpy/core/schemas/units.py,sha256=EB4HATC-C2RxPC0EpcVN--aQa6nl1O9Lj1jkpXlJ-8Y,826
+hydroserverpy/etl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/etl/exceptions.py,sha256=0UY8YUlNepG0y6FfH36hJyR1bOhwYHSZIdUSSMTg7GA,314
+hydroserverpy/etl/service.py,sha256=g-zp89KK4MDIdcTWQDNKbCg485ByAg0Ui01ooFldxhI,12414
+hydroserverpy/quality/__init__.py,sha256=GGBMkFSXciJLYrbV-NraFrj_mXWCy_GTcy9KKrKXU4c,84
+hydroserverpy/quality/service.py,sha256=3y6hjt1jcRcQSx9xRw37YLFBNCch488MHhn-p5nmR6E,13830
+hydroserverpy-0.3.0.dist-info/LICENSE,sha256=xVqFxDw3QOEJukakL7gQCqIMTQ1dlSCTo6Oc1otNW80,1508
+hydroserverpy-0.3.0.dist-info/METADATA,sha256=8n1ZsmvItJmbNl7EgTtOGE4zr-MqY4xE-H5CUMZ3zgU,488
+hydroserverpy-0.3.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+hydroserverpy-0.3.0.dist-info/top_level.txt,sha256=Zf37hrncXLOYvXhgCrf5mZdeq81G9fShdE2LfYbtb7w,14
+hydroserverpy-0.3.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+hydroserverpy-0.3.0.dist-info/RECORD,,

{hydroserverpy-0.2.3.dist-info → hydroserverpy-0.3.0.dist-info}/WHEEL

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

hydroserverpy/components/data_loaders.py

@@ -1,67 +0,0 @@
-from typing import List
-from uuid import UUID
-from hydroserverpy.schemas.data_loaders import DataLoaderGetResponse, DataLoaderPostBody, DataLoaderPatchBody
-from hydroserverpy.schemas.data_sources import DataSourceGetResponse
-
-
-class DataLoader:
-
-    def __init__(self, service):
-        self._service = service
-
-    def list(self):
-
-        return self._service.get(
-            'data-loaders',
-            response_schema=List[DataLoaderGetResponse]
-        )
-
-    def list_data_sources(self, data_loader_id: UUID):
-
-        return self._service.get(
-            f'data-loaders/{data_loader_id}/data-sources',
-            response_schema=List[DataSourceGetResponse]
-        )
-
-    def get(self, data_loader_id: UUID):
-
-        return self._service.get(
-            f'data-loaders/{str(data_loader_id)}',
-            response_schema=DataLoaderGetResponse
-        )
-
-    def create(self, data_loader_body: DataLoaderPostBody):
-
-        return self._service.post(
-            f'data-loaders',
-            headers={'Content-type': 'application/json'},
-            data=data_loader_body.json(by_alias=True),
-            response_schema=DataLoaderGetResponse
-        )
-
-    def update(self, data_loader_id: UUID, data_loader_body: DataLoaderPatchBody):
-
-        return self._service.patch(
-            f'data-loaders/{str(data_loader_id)}',
-            headers={'Content-type': 'application/json'},
-            data=data_loader_body.json(exclude_unset=True, by_alias=True),
-            response_schema=DataLoaderGetResponse
-        )
-
-    def delete(self, data_loader_id: UUID):
-
-        return self._service.delete(
-            f'data-loaders/{str(data_loader_id)}'
-        )
-
-    def load_data(self, data_loader_id: str):
-
-        data_sources_response = self.list_data_sources(data_loader_id=UUID(data_loader_id))
-
-        if data_sources_response.data:
-            data_sources = data_sources_response.data
-        else:
-            return None
-
-        for data_source in data_sources:
-            self._service.data_sources.load_data(data_source_id=data_source.id)