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

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,107 +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')
-    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

hydroserverpy/service.py

@@ -1,170 +0,0 @@
-import requests
-import json
-import frost_sta_client as fsc
-from typing import Optional, Union, Tuple
-from pydantic import AnyHttpUrl
-
-
-class BaseService:
-
-    def __init__(
-            self,
-            host: Union[AnyHttpUrl, str],
-            sta_path: str,
-            api_path: str,
-            auth: Optional[Tuple[str, str]] = None,
-    ):
-        self.host = host.strip('/')
-        self.auth = auth
-        self.sensorthings = None
-        self._sta_path = sta_path.strip('/')
-        self._api_path = api_path.strip('/')
-        self._session = None
-        self._timeout = 60
-        self._initialize_session()
-
-    def _initialize_session(self):
-        """
-        The _initialize_session function is used to initialize the session object.
-
-        :param self
-        :return: None
-        """
-
-        if self._session is not None:
-            self._session.close()
-
-        self._session = requests.Session()
-
-        if self.auth and self.auth[0] == '__token__':
-            self._session.headers.update(
-                {'Authorization': f'Bearer {self.auth[1]}'}
-            )
-        elif self.auth:
-            self._session.auth = self.auth
-
-        self.sensorthings = fsc.SensorThingsService(
-            url=f'{self.host}/{self._sta_path}',
-            auth_handler=fsc.service.auth_handler.AuthHandler(
-                username=self.auth[0],
-                password=self.auth[1]
-            )
-        )
-
-    def _request(self, method, path, *args, **kwargs):
-        """
-        The _request function is a helper function that makes it easier to make requests to the API.
-        It takes in a method, path, and any other arguments you want to pass into the request.
-        The method argument should be one of 'get', 'post', or 'delete'. The path argument should be
-        the endpoint you are trying to reach (e.g., '/users/me'). Any additional arguments will be passed
-        into the request as-is.
-
-        :param self
-        :param method: Specify the type of request that is being made
-        :param path: Specify the path of the request
-        :return: A response object
-        """
-
-        for attempt in range(2):
-            try:
-                return getattr(self._session, method)(
-                    f'{self.host}/{self._api_path}/{path.strip("/")}',
-                    timeout=self._timeout,
-                    *args, **kwargs
-                )
-            except requests.exceptions.ConnectionError as e:
-                if attempt == 0:
-                    self._initialize_session()
-                    continue
-                else:
-                    raise e
-
-    def get(self, path, response_schema=None, *args, **kwargs):
-        """
-        The get function accepts a path and any other arguments that are passed to it,
-        and then calls the _request function with the 'get' method. If the request is successful,
-        the response content is parsed and added to the response object to be returned.
-
-        :param self: Represent the instance of the class
-        :param path: Specify the url of the request
-        :param response_schema: Specify the schema of the response
-        :return: A response object
-        """
-
-        response = self._request('get', path, *args, **kwargs)
-
-        if response.status_code == 200:
-            if not response_schema:
-                response.data = json.loads(response.content)
-            elif getattr(response_schema, '__origin__', None) == list:
-                response.data = [
-                    response_schema.__args__[0](**entity)
-                    for entity in json.loads(response.content)
-                ]
-            else:
-                response.data = response_schema(**json.loads(response.content))
-
-        else:
-            response.data = None
-
-        return response
-
-    def post(self, path, response_schema=None, *args, **kwargs):
-        """
-        The post function accepts a path and any other arguments that are passed to it,
-        and then calls the _request function with the 'post' method. If the request is successful,
-        the response content is parsed and added to the response object to be returned.
-
-        :param self: Represent the instance of the class
-        :param path: Specify the url of the request
-        :param response_schema: Specify the schema of the response
-        :return: A response object
-        """
-
-        response = self._request('post', path, *args, **kwargs)
-
-        if response.status_code == 201:
-            if not response_schema:
-                response.data = json.loads(response.content)
-            else:
-                response.data = response_schema(**json.loads(response.content))
-        else:
-            response.data = None
-
-        return response
-
-    def patch(self, path, response_schema=None, *args, **kwargs):
-        """
-        The patch function accepts a path and any other arguments that are passed to it,
-        and then calls the _request function with the 'patch' method. If the request is successful,
-        the response content is parsed and added to the response object to be returned.
-
-        :param self: Represent the instance of the class
-        :param path: Specify the url of the request
-        :param response_schema: Specify the schema of the response
-        :return: A response object
-        """
-
-        response = self._request('patch', path, *args, **kwargs)
-
-        if response.status_code == 203:
-            if not response_schema:
-                response.data = json.loads(response.content)
-            else:
-                response.data = response_schema(**json.loads(response.content))
-        else:
-            response.data = None
-
-        return response
-
-    def delete(self, path, *args, **kwargs):
-        """
-        The patch function accepts a path and any other arguments that are passed to it,
-        and then calls the _request function with the 'delete' method.
-
-        :param self: Represent the instance of the class
-        :param path: Specify the url of the request
-        :return: A response object
-        """
-
-        return self._request('delete', path, *args, **kwargs)

hydroserverpy/utils.py

@@ -1,37 +0,0 @@
-import inspect
-from pydantic import BaseModel
-from typing import Callable
-
-
-def allow_partial(*fields) -> Callable:
-    """
-    The allow_partial function is a decorator that allows you to mark fields as not required.
-    This means that the field will be allowed to be missing from the input data, and if it is missing,
-    the default value for the field will be used instead. This can also be done by setting required=False on each field.
-
-    :return: A decorator that can be applied to a class
-    """
-
-    def dec(_cls):
-        for field in fields:
-            _cls.__fields__[field].required = False
-        return _cls
-
-    if fields and inspect.isclass(fields[0]) and issubclass(fields[0], BaseModel):
-        cls = fields[0]
-        fields = cls.__fields__
-        return dec(cls)
-
-    return dec
-
-
-def entity_path(self, entity_id):
-    """
-    The entity_path function returns the path to a specific entity.
-
-    :param self: Represent the instance of the class
-    :param entity_id: Specify the entity id of the entity to be retrieved
-    :return: The entity type and the id of the entity
-    """
-
-    return "{}({})".format(self.entitytype_plural, entity_id)

hydroserverpy-0.2.5.dist-info/METADATA

@@ -1,15 +0,0 @@
-Metadata-Version: 2.1
-Name: hydroserverpy
-Version: 0.2.5
-License-File: LICENSE
-Requires-Dist: requests >=2
-Requires-Dist: pydantic <2.0.0,>=1.6
-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
-Provides-Extra: docs
-Requires-Dist: sphinx-autodoc-typehints ; extra == 'docs'
-

hydroserverpy-0.2.5.dist-info/RECORD

@@ -1,35 +0,0 @@
-hydroserverpy/__init__.py,sha256=iZcBLrXpuWr7SYUIgIT3ngDKcI63LgfRNCwCIiv_CW4,616
-hydroserverpy/etl.py,sha256=3cczra-7m1WxdHXm3yZO3hlz-OkWUJdQkA8mdhF8bi0,13229
-hydroserverpy/exceptions.py,sha256=0UY8YUlNepG0y6FfH36hJyR1bOhwYHSZIdUSSMTg7GA,314
-hydroserverpy/main.py,sha256=UD8l4wFvJbLWA07r0kR5tYPW3dnD7OCQoB4PJVpHkeo,1421
-hydroserverpy/models.py,sha256=IxQrSEHM344Bn6qtwjGFdY7bqyH_-lc8TJggVqDsvdg,8174
-hydroserverpy/service.py,sha256=wMuOi4TwZbaB0kPgTOzdfP0HLwmlHTVREuksyxJJ1YQ,6150
-hydroserverpy/utils.py,sha256=VWnd1ffMaiQDVNAKBCr3HhiWMe1YxAmbkb7UNcHSA6k,1173
-hydroserverpy/components/__init__.py,sha256=raT0GabQrFf6lHRW0nm0GYbnQgpScP6FocKCFWwii3w,356
-hydroserverpy/components/data_loaders.py,sha256=83a4oYNGxn5QkJmiOPbk0cx713RvNpyoBSz9genWu3M,2066
-hydroserverpy/components/data_sources.py,sha256=UEdTBU2V5HWqptVk7eZWpKon0osDhq99CgHV7foan6k,3262
-hydroserverpy/components/datastreams.py,sha256=rXdKjSH21IT6cVY3kP0GWS22CYL0I3oeZaInzqwju3w,1365
-hydroserverpy/components/observed_properties.py,sha256=D2yvdDgJc4cNr5H73kb1QZ4Ju4IcsrBubp-4yYn8_fA,1551
-hydroserverpy/components/processing_levels.py,sha256=0bVYp3WJv3MaBz_mqCNirHMu25W6pVg4u0THbTHElVs,1518
-hydroserverpy/components/result_qualifiers.py,sha256=JmAF1gfSz0mPtXHptWxaZvlTonZ363-bBwXwiKAjgX4,1522
-hydroserverpy/components/sensors.py,sha256=V6tQi4i4Amoy1o0HFYx-YdELVfQQomJV4hzdUsvj38I,1268
-hydroserverpy/components/things.py,sha256=-XCkoQj_VdvADGOwbi6czjr6vCdaXhFEZhPvmClG4bw,1246
-hydroserverpy/components/units.py,sha256=2nHmJgd97loHjh6jt84PQPjD7XzztECWbCr4o8VwHD8,1216
-hydroserverpy/components/users.py,sha256=jpZ6TGOImK_j3ghwTFoAxpD9WMBG9DzIC0vcsb2G1w0,622
-hydroserverpy/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hydroserverpy/schemas/data_loaders.py,sha256=5YIXryh1LaVgjRetruyZHvBivsCS1XqOnT6lbcMCIMg,459
-hydroserverpy/schemas/data_sources.py,sha256=cYnhKUaKqirhJjxo9niSgtOdokv98Fah635rOywosAE,2053
-hydroserverpy/schemas/datastreams.py,sha256=wOY3O8UBLjfJXlVJI18rkcPNFApGDteKmFGsCbCv4s4,2266
-hydroserverpy/schemas/observed_properties.py,sha256=-DpFuo4UYY5dx7mAxRSyN6EqjHGp9-CT5AapzSOE2RQ,698
-hydroserverpy/schemas/processing_levels.py,sha256=MWy7fRIP-hDJtjwmSB1PK27agx9U2UFpjhl5lrYMIHA,686
-hydroserverpy/schemas/result_qualifiers.py,sha256=m2OfJHefO1jFfRqV-Klgv6b50jOM0X1UtNCrSon3Znc,652
-hydroserverpy/schemas/sensors.py,sha256=mUilTxc61zkrL2GULhJTO-q3P58Rkh2leHyCSZl1-Ug,918
-hydroserverpy/schemas/things.py,sha256=79WMxbf54vgob-3JtHwC_e85W-5U__GI0ZOMnCxJDL0,3300
-hydroserverpy/schemas/units.py,sha256=_28zmCz9TDuNfHa4Ycj1RKkxwUB_J832NSWIO3cBK9k,550
-hydroserverpy/schemas/users.py,sha256=TauiaArJ4LVjAKq80KvjKjxex5DAwQekc_nDXHyaU3U,675
-hydroserverpy-0.2.5.dist-info/LICENSE,sha256=xVqFxDw3QOEJukakL7gQCqIMTQ1dlSCTo6Oc1otNW80,1508
-hydroserverpy-0.2.5.dist-info/METADATA,sha256=hKbR4GdMGSCVPlfzcYRXsj8is5ClxC5jy0OleMwh0I8,419
-hydroserverpy-0.2.5.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-hydroserverpy-0.2.5.dist-info/top_level.txt,sha256=Zf37hrncXLOYvXhgCrf5mZdeq81G9fShdE2LfYbtb7w,14
-hydroserverpy-0.2.5.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-hydroserverpy-0.2.5.dist-info/RECORD,,