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

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

hydroserverpy/schemas/data_sources.py

@@ -1,58 +0,0 @@
-from pydantic import BaseModel, Field
-from typing import Optional, Literal, Union
-from pydantic import AnyHttpUrl, conint
-from datetime import datetime
-from uuid import UUID
-from hydroserverpy.utils import allow_partial
-
-
-class DataSourceID(BaseModel):
-    id: UUID
-
-
-class DataSourceFields(BaseModel):
-    name: str
-    path: Optional[str]
-    url: Optional[AnyHttpUrl]
-    header_row: Optional[conint(gt=0)] = Field(None, alias='headerRow')
-    data_start_row: Optional[conint(gt=0)] = Field(1, alias='dataStartRow')
-    delimiter: Optional[str] = ','
-    quote_char: Optional[str] = Field('"', alias='quoteChar')
-    interval: Optional[conint(gt=0)]
-    interval_units: Optional[Literal['minutes', 'hours', 'days', 'weeks', 'months']] = \
-        Field(None, alias='intervalUnits')
-    crontab: Optional[str]
-    start_time: Optional[datetime] = Field(None, alias='startTime')
-    end_time: Optional[datetime] = Field(None, alias='endTime')
-    paused: Optional[bool]
-    timestamp_column: Union[conint(gt=0), str] = Field(..., alias='timestampColumn')
-    timestamp_format: Optional[str] = Field('%Y-%m-%dT%H:%M:%S%Z', alias='timestampFormat')
-    timestamp_offset: Optional[str] = Field('+0000', alias='timestampOffset')
-    data_loader_id: UUID = Field(..., alias='dataLoaderId')
-    data_source_thru: Optional[datetime] = Field(None, alias='dataSourceThru')
-    last_sync_successful: Optional[bool] = Field(None, alias='lastSyncSuccessful')
-    last_sync_message: Optional[str] = Field(None, alias='lastSyncMessage')
-    last_synced: Optional[datetime] = Field(None, alias='lastSynced')
-    next_sync: Optional[datetime] = Field(None, alias='nextSync')
-
-
-class DataSourceGetResponse(DataSourceFields, DataSourceID):
-    pass
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-class DataSourcePostBody(DataSourceFields):
-    pass
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-@allow_partial
-class DataSourcePatchBody(DataSourceFields):
-    pass
-
-    class Config:
-        allow_population_by_field_name = True

hydroserverpy/schemas/datastreams.py

@@ -1,56 +0,0 @@
-from pydantic import BaseModel, Field
-from typing import Union, Literal, Optional
-from uuid import UUID
-from datetime import datetime
-from hydroserverpy.utils import allow_partial
-
-
-class DatastreamID(BaseModel):
-    id: UUID
-
-
-class DatastreamFields(BaseModel):
-    name: Union[UUID, str]
-    description: str
-    observation_type: str = Field(..., alias='observationType')
-    sampled_medium: str = Field(..., alias='sampledMedium')
-    no_data_value: float = Field(..., alias='noDataValue')
-    aggregation_statistic: str = Field(..., alias='aggregationStatistic')
-    time_aggregation_interval: float = Field(..., alias='timeAggregationInterval')
-    status: str = None
-    result_type: str = Field(..., alias='resultType')
-    value_count: int = Field(None, alias='valueCount')
-    intended_time_spacing: float = Field(None, alias='intendedTimeSpacing')
-    phenomenon_begin_time: datetime = Field(None, alias='phenomenonBeginTime')
-    phenomenon_end_time: datetime = Field(None, alias='phenomenonEndTime')
-    result_begin_time: datetime = Field(None, alias='resultBeginTime')
-    result_end_time: datetime = Field(None, alias='resultEndTime')
-    data_source_id: UUID = Field(None, alias='dataSourceId')
-    data_source_column: str = Field(None, alias='dataSourceColumn')
-    is_visible: bool = Field(True, alias='isVisible')
-    thing_id: UUID = Field(..., alias='thingId')
-    sensor_id: UUID = Field(..., alias='sensorId')
-    observed_property_id: UUID = Field(..., alias='observedPropertyId')
-    processing_level_id: UUID = Field(..., alias='processingLevelId')
-    unit_id: UUID = Field(..., alias='unitId')
-    time_aggregation_interval_units: Literal['seconds', 'minutes', 'hours', 'days'] = \
-        Field(..., alias='timeAggregationIntervalUnits')
-    intended_time_spacing_units: Optional[Literal['seconds', 'minutes', 'hours', 'days']] = \
-        Field(None, alias='intendedTimeSpacingUnits')
-
-
-class DatastreamGetResponse(DatastreamFields, DatastreamID):
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-class DatastreamPostBody(DatastreamFields):
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-@allow_partial
-class DatastreamPatchBody(DatastreamFields):
-    thing_id: UUID = Field(..., alias='thingId')

hydroserverpy/schemas/observed_properties.py

@@ -1,33 +0,0 @@
-from pydantic import BaseModel
-from uuid import UUID
-from typing import Optional
-from hydroserverpy.utils import allow_partial
-from hydroserverpy.schemas.users import UserFields
-
-
-class ObservedPropertyID(BaseModel):
-    id: UUID
-
-
-class ObservedPropertyFields(BaseModel):
-    name: str
-    definition: str
-    description: str = None
-    type: str = None
-    code: str = None
-
-
-class ObservedPropertyGetResponse(ObservedPropertyFields, ObservedPropertyID):
-    owner: Optional[str]
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-class ObservedPropertyPostBody(ObservedPropertyFields):
-    pass
-
-
-@allow_partial
-class ObservedPropertyPatchBody(ObservedPropertyFields):
-    pass

hydroserverpy/schemas/processing_levels.py

@@ -1,33 +0,0 @@
-from pydantic import BaseModel
-from uuid import UUID
-from typing import Optional
-from ..utils import allow_partial
-from ..schemas.users import UserFields
-
-
-class ProcessingLevelID(BaseModel):
-    id: UUID
-
-
-class ProcessingLevelFields(BaseModel):
-    code: str
-    definition: str = None
-    explanation: str = None
-
-
-class ProcessingLevelGetResponse(ProcessingLevelFields, ProcessingLevelID):
-    owner: Optional[str]
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-class ProcessingLevelPostBody(ProcessingLevelFields):
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-@allow_partial
-class ProcessingLevelPatchBody(ProcessingLevelFields):
-    pass

hydroserverpy/schemas/result_qualifiers.py

@@ -1,32 +0,0 @@
-from pydantic import BaseModel
-from uuid import UUID
-from typing import Optional
-from ..utils import allow_partial
-from ..schemas.users import UserFields
-
-
-class ResultQualifierID(BaseModel):
-    id: UUID
-
-
-class ResultQualifierFields(BaseModel):
-    code: str
-    description: str
-
-
-class ResultQualifierGetResponse(ResultQualifierFields, ResultQualifierID):
-    owner: Optional[str]
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-class ResultQualifierPostBody(ResultQualifierFields):
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-@allow_partial
-class ResultQualifierPatchBody(ResultQualifierFields):
-    pass

hydroserverpy/schemas/sensors.py

@@ -1,39 +0,0 @@
-from pydantic import BaseModel, Field
-from uuid import UUID
-from typing import Optional
-from hydroserverpy.utils import allow_partial
-from hydroserverpy.schemas.users import UserFields
-
-
-class SensorID(BaseModel):
-    id: UUID
-
-
-class SensorFields(BaseModel):
-    name: str
-    description: str
-    encoding_type: str = Field(alias="encodingType")
-    manufacturer: str = None
-    model: str = None
-    model_link: str = Field(None, alias='modelLink')
-    method_type: str = Field(alias='methodType')
-    method_link: str = Field(None, alias='methodLink')
-    method_code: str = Field(None, alias='methodCode')
-
-
-class SensorGetResponse(SensorFields, SensorID):
-    owner: Optional[str]
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-class SensorPostBody(SensorFields):
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-@allow_partial
-class SensorPatchBody(SensorFields):
-    pass

hydroserverpy/schemas/things.py

@@ -1,108 +0,0 @@
-from pydantic import BaseModel, Field, root_validator
-from typing import List, Optional
-from uuid import UUID
-from hydroserverpy.utils import allow_partial
-from hydroserverpy.schemas.observed_properties import ObservedPropertyGetResponse
-from hydroserverpy.schemas.processing_levels import ProcessingLevelGetResponse
-from hydroserverpy.schemas.units import UnitGetResponse
-from hydroserverpy.schemas.sensors import SensorGetResponse
-
-
-class ThingID(BaseModel):
-    id: UUID
-
-
-class ThingFields(BaseModel):
-    name: str
-    description: str
-    sampling_feature_type: str = Field(alias='samplingFeatureType')
-    sampling_feature_code: str = Field(alias='samplingFeatureCode')
-    site_type: str = Field(alias='siteType')
-    data_disclaimer: str = Field(None, alias='dataDisclaimer')
-
-
-class LocationFields(BaseModel):
-    latitude: float
-    longitude: float
-    elevation_m: float = None
-    elevation_datum: str = Field(None, alias='elevationDatum')
-    state: str = None
-    county: str = None
-
-
-class OrganizationFields(BaseModel):
-    organization_name: Optional[str] = Field(None, alias='organizationName')
-
-
-class AssociationFields(BaseModel):
-    is_primary_owner: bool = Field(..., alias='isPrimaryOwner')
-
-
-class PersonFields(BaseModel):
-    first_name: str = Field(..., alias='firstName')
-    last_name: str = Field(..., alias='lastName')
-    email: str
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-class OwnerFields(AssociationFields, OrganizationFields, PersonFields):
-    pass
-
-
-class ThingGetResponse(LocationFields, ThingFields, ThingID):
-    is_private: bool = Field(..., alias='isPrivate')
-    is_primary_owner: bool = Field(..., alias='isPrimaryOwner')
-    owns_thing: bool = Field(..., alias='ownsThing')
-    follows_thing: bool = Field(..., alias='followsThing')
-    owners: List[OwnerFields]
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-class ThingPostBody(ThingFields, LocationFields):
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-@allow_partial
-class ThingPatchBody(ThingFields, LocationFields):
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-class ThingOwnershipPatchBody(BaseModel):
-    email: str
-    make_owner: Optional[bool] = Field(False, alias='makeOwner')
-    remove_owner: Optional[bool] = Field(False, alias='removeOwner')
-    transfer_primary: Optional[bool] = Field(False, alias='transferPrimary')
-
-    @root_validator()
-    def validate_only_one_method_allowed(cls, field_values):
-
-        assert [
-                   field_values.get('make_owner', False),
-                   field_values.get('remove_owner', False),
-                   field_values.get('transfer_primary', False)
-               ].count(True) == 1, \
-            'You must perform one and only one action from among "makeOwner", "removeOwner", and "transferPrimary".'
-
-        return field_values
-
-
-class ThingPrivacyPatchBody(BaseModel):
-    is_private: bool = Field(..., alias="isPrivate")
-
-
-class ThingMetadataGetResponse(BaseModel):
-    units: List[UnitGetResponse]
-    sensors: List[SensorGetResponse]
-    processing_levels: List[ProcessingLevelGetResponse] = Field(..., alias='processingLevels')
-    observed_properties: List[ObservedPropertyGetResponse] = Field(..., alias='observedProperties')
-
-    class Config:
-        allow_population_by_field_name = True

hydroserverpy/schemas/units.py

@@ -1,32 +0,0 @@
-from pydantic import BaseModel
-from uuid import UUID
-from typing import Optional
-from hydroserverpy.utils import allow_partial
-from hydroserverpy.schemas.users import UserFields
-
-
-class UnitID(BaseModel):
-    id: UUID
-
-
-class UnitFields(BaseModel):
-    name: str
-    symbol: str
-    definition: str
-    type: str
-
-
-class UnitGetResponse(UnitFields, UnitID):
-    owner: Optional[str]
-
-    class Config:
-        allow_population_by_field_name = True
-
-
-class UnitPostBody(UnitFields):
-    pass
-
-
-@allow_partial
-class UnitPatchBody(UnitFields):
-    pass

hydroserverpy/schemas/users.py

@@ -1,28 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class OrganizationFields(BaseModel):
-    code: str
-    name: str
-    description: str = None
-    type: str
-    link: str = None
-
-    @classmethod
-    def is_empty(cls, obj):
-        return not (obj.name and obj.code and obj.type)
-
-
-class UserFields(BaseModel):
-    first_name: str = Field(alias="firstName")
-    last_name: str = Field(alias="lastName")
-    email: str = None
-    middle_name: str = Field(default=None, alias="middleName")
-    phone: str = None
-    address: str = None
-    type: str = None
-    link: str = None
-    organization: OrganizationFields = None
-
-    class Config:
-        allow_population_by_field_name = True