hydroserverpy 0.2.5__py3-none-any.whl → 0.4.0__py3-none-any.whl

hydroserverpy/components/datastreams.py

@@ -1,47 +0,0 @@
-from uuid import UUID
-from typing import List
-from hydroserverpy.schemas.datastreams import DatastreamGetResponse, DatastreamPostBody, DatastreamPatchBody
-
-
-class Datastream:
-
-    def __init__(self, service):
-        self._service = service
-
-    def list(self):
-
-        return self._service.get(
-            'datastreams',
-            response_schema=List[DatastreamGetResponse]
-        )
-
-    def get(self, datastream_id: str):
-
-        return self._service.get(
-            f'datastreams/{datastream_id}',
-            response_schema=DatastreamGetResponse
-        )
-
-    def create(self, datastream_body: DatastreamPostBody):
-
-        return self._service.post(
-            f'datastreams',
-            headers={'Content-type': 'application/json'},
-            data=datastream_body.json(by_alias=True),
-            response_schema=DatastreamGetResponse
-        )
-
-    def update(self, datastream_id: UUID, datastream_body: DatastreamPatchBody):
-
-        return self._service.patch(
-            f'datastreams/{str(datastream_id)}',
-            headers={'Content-type': 'application/json'},
-            data=datastream_body.json(exclude_unset=True, by_alias=True),
-            response_schema=DatastreamGetResponse
-        )
-
-    def delete(self, datastream_id: UUID):
-
-        return self._service.delete(
-            f'datastreams/{str(datastream_id)}'
-        )

hydroserverpy/components/observed_properties.py

@@ -1,48 +0,0 @@
-from typing import List
-from uuid import UUID
-from hydroserverpy.schemas.observed_properties import ObservedPropertyGetResponse, ObservedPropertyPostBody, \
-     ObservedPropertyPatchBody
-
-
-class ObservedProperty:
-
-    def __init__(self, service):
-        self._service = service
-
-    def list(self):
-
-        return self._service.get(
-            'observed-properties',
-            response_schema=List[ObservedPropertyGetResponse]
-        )
-
-    def get(self, observed_property_id: UUID):
-
-        return self._service.get(
-            f'observed-properties/{observed_property_id}',
-            response_schema=ObservedPropertyGetResponse
-        )
-
-    def create(self, observed_property_body: ObservedPropertyPostBody):
-
-        return self._service.post(
-            f'observed-properties',
-            headers={'Content-type': 'application/json'},
-            data=observed_property_body.json(by_alias=True),
-            response_schema=ObservedPropertyGetResponse
-        )
-
-    def update(self, observed_property_id: UUID, observed_property_body: ObservedPropertyPatchBody):
-
-        return self._service.patch(
-            f'observed-properties/{str(observed_property_id)}',
-            headers={'Content-type': 'application/json'},
-            data=observed_property_body.json(exclude_unset=True, by_alias=True),
-            response_schema=ObservedPropertyGetResponse
-        )
-
-    def delete(self, observed_property_id: UUID):
-
-        return self._service.delete(
-            f'observed-properties/{str(observed_property_id)}'
-        )

hydroserverpy/components/processing_levels.py

@@ -1,48 +0,0 @@
-from typing import List
-from uuid import UUID
-from hydroserverpy.schemas.processing_levels import ProcessingLevelGetResponse, ProcessingLevelPostBody, \
-     ProcessingLevelPatchBody
-
-
-class ProcessingLevel:
-
-    def __init__(self, service):
-        self._service = service
-
-    def list(self):
-
-        return self._service.get(
-            'processing-levels',
-            response_schema=List[ProcessingLevelGetResponse]
-        )
-
-    def get(self, processing_level_id: str):
-
-        return self._service.get(
-            f'processing-levels/{processing_level_id}',
-            response_schema=ProcessingLevelGetResponse
-        )
-
-    def create(self, processing_level_body: ProcessingLevelPostBody):
-
-        return self._service.post(
-            f'processing-levels',
-            headers={'Content-type': 'application/json'},
-            data=processing_level_body.json(by_alias=True),
-            response_schema=ProcessingLevelGetResponse
-        )
-
-    def update(self, processing_level_id: UUID, processing_level_body: ProcessingLevelPatchBody):
-
-        return self._service.patch(
-            f'processing-levels/{str(processing_level_id)}',
-            headers={'Content-type': 'application/json'},
-            data=processing_level_body.json(exclude_unset=True, by_alias=True),
-            response_schema=ProcessingLevelGetResponse
-        )
-
-    def delete(self, processing_level_id: UUID):
-
-        return self._service.delete(
-            f'processing-levels/{str(processing_level_id)}'
-        )

hydroserverpy/components/result_qualifiers.py

@@ -1,48 +0,0 @@
-from typing import List
-from uuid import UUID
-from hydroserverpy.schemas.result_qualifiers import ResultQualifierGetResponse, ResultQualifierPostBody, \
-     ResultQualifierPatchBody
-
-
-class ResultQualifier:
-
-    def __init__(self, service):
-        self._service = service
-
-    def list(self):
-
-        return self._service.get(
-            'result-qualifiers',
-            response_schema=List[ResultQualifierGetResponse]
-        )
-
-    def get(self, result_qualifier_id: str):
-
-        return self._service.get(
-            f'result-qualifiers/{result_qualifier_id}',
-            response_schema=ResultQualifierGetResponse
-        )
-    
-    def create(self, result_qualifier_body: ResultQualifierPostBody):
-
-        return self._service.post(
-            f'result-qualifiers',
-            headers={'Content-type': 'application/json'},
-            data=result_qualifier_body.json(by_alias=True),
-            response_schema=ResultQualifierGetResponse
-        )
-
-    def update(self, result_qualifier_id: UUID, result_qualifier_body: ResultQualifierPatchBody):
-
-        return self._service.patch(
-            f'result-qualifiers/{str(result_qualifier_id)}',
-            headers={'Content-type': 'application/json'},
-            data=result_qualifier_body.json(exclude_unset=True, by_alias=True),
-            response_schema=ResultQualifierGetResponse
-        )
-
-    def delete(self, result_qualifier_id: UUID):
-
-        return self._service.delete(
-            f'result-qualifiers/{str(result_qualifier_id)}'
-        )

hydroserverpy/components/sensors.py

@@ -1,48 +0,0 @@
-from typing import List
-from uuid import UUID
-from hydroserverpy.schemas.sensors import SensorGetResponse, SensorPostBody, \
-     SensorPatchBody
-
-
-class Sensor:
-
-    def __init__(self, service):
-        self._service = service
-
-    def list(self):
-
-        return self._service.get(
-            'sensors',
-            response_schema=List[SensorGetResponse]
-        )
-
-    def get(self, sensor_id: str):
-
-        return self._service.get(
-            f'sensors/{sensor_id}',
-            response_schema=SensorGetResponse
-        )
-
-    def create(self, sensor_body: SensorPostBody):
-
-        return self._service.post(
-            f'sensors',
-            headers={'Content-type': 'application/json'},
-            data=sensor_body.json(by_alias=True),
-            response_schema=SensorGetResponse
-        )
-
-    def update(self, sensor_id: UUID, sensor_body: SensorPatchBody):
-
-        return self._service.patch(
-            f'sensors/{str(sensor_id)}',
-            headers={'Content-type': 'application/json'},
-            data=sensor_body.json(exclude_unset=True, by_alias=True),
-            response_schema=SensorGetResponse
-        )
-
-    def delete(self, sensor_id: UUID):
-
-        return self._service.delete(
-            f'sensors/{str(sensor_id)}'
-        )

hydroserverpy/components/things.py

@@ -1,48 +0,0 @@
-from typing import List
-from uuid import UUID
-from hydroserverpy.schemas.things import ThingGetResponse, ThingPostBody, \
-     ThingPatchBody
-
-
-class Thing:
-
-    def __init__(self, service):
-        self._service = service
-
-    def list(self):
-
-        return self._service.get(
-            'things',
-            response_schema=List[ThingGetResponse]
-        )
-
-    def get(self, thing_id: str):
-
-        return self._service.get(
-            f'things/{thing_id}',
-            response_schema=ThingGetResponse
-        )
-    
-    def create(self, thing_body: ThingPostBody):
-
-        return self._service.post(
-            f'things',
-            headers={'Content-type': 'application/json'},
-            data=thing_body.json(by_alias=True),
-            response_schema=ThingGetResponse
-        )
-
-    def update(self, thing_id: UUID, thing_body: ThingPatchBody):
-
-        return self._service.patch(
-            f'things/{str(thing_id)}',
-            headers={'Content-type': 'application/json'},
-            data=thing_body.json(exclude_unset=True, by_alias=True),
-            response_schema=ThingGetResponse
-        )
-
-    def delete(self, thing_id: UUID):
-
-        return self._service.delete(
-            f'things/{str(thing_id)}'
-        )

hydroserverpy/components/units.py

@@ -1,48 +0,0 @@
-from typing import List
-from uuid import UUID
-from hydroserverpy.schemas.units import UnitGetResponse, UnitPostBody, \
-     UnitPatchBody
-
-
-class Unit:
-
-    def __init__(self, service):
-        self._service = service
-
-    def list(self):
-
-        return self._service.get(
-            'units',
-            response_schema=List[UnitGetResponse]
-        )
-
-    def get(self, unit_id: str):
-
-        return self._service.get(
-            f'units/{unit_id}',
-            response_schema=UnitGetResponse
-        )
-
-    def create(self, unit_body: UnitPostBody):
-
-        return self._service.post(
-            f'units',
-            headers={'Content-type': 'application/json'},
-            data=unit_body.json(by_alias=True),
-            response_schema=UnitGetResponse
-        )
-
-    def update(self, unit_id: UUID, unit_body: UnitPatchBody):
-
-        return self._service.patch(
-            f'units/{str(unit_id)}',
-            headers={'Content-type': 'application/json'},
-            data=unit_body.json(exclude_unset=True, by_alias=True),
-            response_schema=UnitGetResponse
-        )
-
-    def delete(self, unit_id: UUID):
-
-        return self._service.delete(
-            f'units/{str(unit_id)}'
-        )

hydroserverpy/components/users.py

@@ -1,28 +0,0 @@
-from pydantic import BaseModel, Field
-from typing import Optional
-
-
-class Organization(BaseModel):
-    code: str
-    name: str
-    description: Optional[str]
-    type: str
-    link: Optional[str]
-
-
-class UserResponse(BaseModel):
-    email: str
-    first_name: str = Field(..., alias='firstName')
-    last_name: str = Field(..., alias='lastName')
-    middle_name: Optional[str] = Field(None, alias='middleName')
-    phone: Optional[str]
-    address: Optional[str]
-    type: str
-    link: Optional[str]
-    organization: Optional[Organization]
-
-
-class User:
-
-    def __init__(self, service):
-        self._service = service

hydroserverpy/main.py

@@ -1,62 +0,0 @@
-from typing import Optional, Union, Tuple
-from pydantic import AnyHttpUrl
-from hydroserverpy.service import BaseService
-from hydroserverpy.components import DataLoader, DataSource, Datastream, ObservedProperty, ProcessingLevel, \
-     ResultQualifier, Sensor, Thing, Unit, User
-
-
-class HydroServer(BaseService):
-
-    def __init__(
-            self,
-            host: Union[AnyHttpUrl, str],
-            auth: Optional[Tuple[str, str]] = None,
-            sta_path: str = 'api/sensorthings/v1.1',
-            api_path: str = 'api/data'
-    ):
-        super().__init__(
-            host=host,
-            auth=auth,
-            sta_path=sta_path,
-            api_path=api_path
-        )
-
-    @property
-    def data_loaders(self):
-        return DataLoader(self)
-
-    @property
-    def data_sources(self):
-        return DataSource(self)
-
-    @property
-    def datastreams(self):
-        return Datastream(self)
-
-    @property
-    def observed_properties(self):
-        return ObservedProperty(self)
-
-    @property
-    def processing_levels(self):
-        return ProcessingLevel(self)
-
-    @property
-    def result_qualifiers(self):
-        return ResultQualifier(self)
-
-    @property
-    def sensors(self):
-        return Sensor(self)
-
-    @property
-    def things(self):
-        return Thing(self)
-
-    @property
-    def units(self):
-        return Unit(self)
-
-    @property
-    def users(self):
-        return User(self)

hydroserverpy/models.py

@@ -1,218 +0,0 @@
-import yaml
-import re
-import simplejson as json
-from uuid import UUID
-from datetime import datetime
-from crontab import CronTab
-from pydantic import BaseModel, validator, root_validator, conint, AnyHttpUrl, Field
-from typing import List, Optional, Literal, Union
-
-
-class HydroLoaderDatastream(BaseModel):
-    id: UUID
-    value_count: Optional[int] = Field(None, alias='valueCount')
-    result_time: Optional[datetime] = Field(None, alias='resultTime')
-    phenomenon_time: Optional[datetime] = Field(None, alias='phenomenonTime')
-    file_row_start_index: Optional[int]
-    file_result_end_time: Optional[datetime]
-    chunk_result_start_time: Optional[datetime]
-    chunk_result_end_time: Optional[datetime]
-
-
-class HydroLoaderObservationsResponse(BaseModel):
-    datastream_id: str
-    request_url: str
-    status_code: int
-    reason: str
-    chunk_start_time: str
-    chunk_end_time: str
-
-
-class HydroLoaderConfSchedule(BaseModel):
-    crontab: Optional[str]
-    interval_units: Optional[Literal['minutes', 'hours', 'days', 'weeks', 'months']]
-    interval: Optional[conint(gt=0)]
-    start_time: Optional[datetime]
-    end_time: Optional[datetime]
-    paused: Optional[bool]
-
-    @root_validator(pre=True)
-    def check_crontab_or_interval(cls, values):
-        """
-        The check_crontab_or_interval function is a validator that ensures that the HydroLoaderConfSchedule model
-        does not include both a crontab and an interval. It also ensures that if an interval is
-        included, it includes both an interval and its units.
-
-        :param cls: Pass the class of the model to be created
-        :param values: Pass the values of the fields in a form to
-        :return: The values dictionary
-        """
-
-        if values.get('crontab') and (values.get('interval_units') or values.get('interval')):
-            raise ValueError('Schedule can include either a crontab or an interval, not both.')
-
-        if (
-            values.get('interval_units') and not values.get('interval')
-        ) or (
-            not values.get('interval_units') and values.get('interval')
-        ):
-            raise ValueError('Interval must include both an interval and interval_units.')
-
-        return values
-
-    @validator('crontab')
-    def check_valid_crontab(cls, v):
-        """
-        The check_valid_crontab function is a validator that uses the CronTab library to check if the inputted
-        crontab string is valid. If it's not, an exception will be raised.
-
-        :param cls: Pass the class to the function
-        :param v: Pass the value of the field to be validated
-        :return: The crontab string
-        """
-
-        if v is not None:
-            CronTab(v)
-
-        return v
-
-
-class HydroLoaderConfFileAccess(BaseModel):
-    path: Optional[str]
-    url: Optional[AnyHttpUrl]
-    header_row: Optional[conint(gt=0)] = None
-    data_start_row: Optional[conint(gt=0)] = 1
-    delimiter: Optional[str] = ','
-    quote_char: Optional[str] = '"'
-
-    @root_validator(pre=True)
-    def check_path_or_url(cls, values):
-        """
-        The check_path_or_url function is a validator that takes in the values of the HydroLoaderConfFileAccess model
-        and checks to see if there is either a path or url. If there isn't, it raises an error.
-
-        :param cls: Pass the class of the object being created
-        :param values: Pass in the values of the path and url parameters
-        :return: The values dictionary
-        """
-
-        if bool(values.get('path')) == bool(values.get('url')):
-            raise ValueError('File access must include either a path or a URL.')
-
-        return values
-
-    @root_validator(pre=True)
-    def check_header_and_data_rows(cls, values):
-        """
-        The check_header_and_data_rows function is a class method that takes in the values of the header_row and
-        data_start_row and ensures the header row is not greater than the data start row. If it is, it raises an error.
-
-        :param cls: Refer to the class that is being created
-        :param values: Get the values of the header_row and data_start_row
-        :return: The values dictionary
-        """
-
-        if values.get('header_row') is not None and values.get('header_row') >= values.get('data_start_row'):
-            raise ValueError('Header row cannot occur after data start row.')
-
-        return values
-
-    @validator('delimiter')
-    def convert_delimiters(cls, v):
-        """
-        The convert_delimiters function is a validator that takes in a string and replaces all instances of '\\t' with
-        '\t'. This function is used to convert the delimiters from the input file into tab-delimited format.
-
-        :param cls: Pass the class object to the function
-        :param v: Pass the value of the escaped delimiter into the function
-        :return: An unescaped delimiter string
-        """
-
-        return v.replace('\\t', '\t')
-
-
-class HydroLoaderConfFileTimestamp(BaseModel):
-    column: Union[conint(gt=0), str]
-    format: Optional[str] = '%Y-%m-%dT%H:%M:%S%Z'
-    offset: Optional[str] = '+0000'
-
-    @validator('format')
-    def check_valid_strftime(cls, v):
-        """
-        The check_valid_strftime function is a validator that takes in a datetime strf string and checks to see if it
-        is valid. It uses the strftime function from the datetime module, which returns an error if the string passed
-        to it is not valid.
-
-        :param cls: Pass the class to which the validator is attached
-        :param v: Pass the value of the argument to be checked
-        :return: The value of the string
-        """
-
-        datetime.now().strftime(v)
-
-        return v
-
-    @validator('offset', always=True)
-    def parse_tzinfo(cls, v):
-        """
-        The parse_tzinfo function is a validator for the offset field. It takes in a string and returns an instance
-        of datetime.tzinfo, which is used by Python's datetime module to represent timezone information. The function
-        first checks that the input string is a valid UTC offset formatted like "+0000". If it is not valid, then it
-        raises an exception.
-
-        :param cls: Pass in the class of the object being created
-        :param v: Pass the timezone offset
-        :return: A tzinfo object
-        """
-
-        tzinfo_pattern = r'^[+-](0[0-9]|1[0-4])[0-5][0-9]$'
-        if v is not None and re.match(tzinfo_pattern, v) is None:
-            raise ValueError('The offset must be a valid UTC timezone offset formatted such as "+0000".')
-
-        return v  # datetime.strptime(v, '%z').tzinfo if v is not None else None
-
-
-class HydroLoaderConfFileDatastream(BaseModel):
-    column: Union[conint(gt=0), str]
-    id: UUID
-
-
-class HydroLoaderConf(BaseModel):
-    schedule: Optional[HydroLoaderConfSchedule]
-    file_access: HydroLoaderConfFileAccess
-    file_timestamp: HydroLoaderConfFileTimestamp
-    datastreams: List[HydroLoaderConfFileDatastream]
-
-    @root_validator()
-    def check_header_and_fields(cls, values):
-        """"""
-
-        if not values.get('file_access') or not values['file_access'].header_row:
-            if values.get('file_timestamp') and not isinstance(values['file_timestamp'].column, int):
-                raise ValueError('If no header row is defined, all column identifiers must be integers.')
-            if values.get('datastreams'):
-                for datastream in values['datastreams']:
-                    if not isinstance(datastream.column, int):
-                        raise ValueError('If no header row is defined, all column identifiers must be integers.')
-
-        return values
-
-    def to_yaml(
-            self,
-            file_path: str
-    ):
-        """
-        The to_yaml function takes a file path and writes the configuration to that file in YAML format.
-
-        :param self: Refer to the current instance of the class
-        :param file_path: str: Specify the file path to save the configuration
-        :return: A yaml file
-        """
-
-        with open(file_path, 'w') as conf_file:
-            yaml.dump(
-                json.loads(self.json()),
-                conf_file,
-                sort_keys=False,
-                default_flow_style=False
-            )

hydroserverpy/schemas/data_loaders.py

@@ -1,27 +0,0 @@
-from pydantic import BaseModel
-from uuid import UUID
-from hydroserverpy.utils import allow_partial
-
-
-class DataLoaderID(BaseModel):
-    id: UUID
-
-
-class DataLoaderFields(BaseModel):
-    name: str
-
-
-class DataLoaderGetResponse(DataLoaderFields, DataLoaderID):
-    pass
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-class DataLoaderPostBody(DataLoaderFields):
-    pass
-
-
-@allow_partial
-class DataLoaderPatchBody(DataLoaderFields):
-    pass