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

hydroserverpy/core/schemas/things.py

@@ -1,346 +0,0 @@
-from pydantic import BaseModel, Field, AliasPath, AliasChoices, field_validator
-from typing import Optional, List, Literal, IO, TYPE_CHECKING
-from uuid import UUID
-from country_list import countries_for_language
-from hydroserverpy.core.schemas.base import HydroServerCoreModel, HydroServerBaseModel
-
-if TYPE_CHECKING:
-    from hydroserverpy.core.schemas.datastreams import Datastream
-
-
-class ThingFields(BaseModel):
-    name: str = Field(
-        ...,
-        strip_whitespace=True,
-        max_length=200,
-        description="The name of the site/thing.",
-    )
-    description: str = Field(
-        ..., strip_whitespace=True, description="A description of the site/thing."
-    )
-    sampling_feature_type: str = Field(
-        ...,
-        strip_whitespace=True,
-        max_length=200,
-        description="The sampling feature type of the site/thing.",
-    )
-    sampling_feature_code: str = Field(
-        ...,
-        strip_whitespace=True,
-        max_length=200,
-        description="A code representing the sampling feature of the site/thing.",
-    )
-    site_type: str = Field(
-        ...,
-        strip_whitespace=True,
-        max_length=200,
-        description="The type of the site/thing.",
-    )
-    data_disclaimer: Optional[str] = Field(
-        None,
-        strip_whitespace=True,
-        description="An optional data disclaimer to attach to observations collected at this site/thing.",
-    )
-
-
-# Get a list of all ISO 3166-1 alpha-2 country codes
-valid_country_codes = [code for code, _ in countries_for_language("en")]
-
-
-class LocationFields(BaseModel):
-    latitude: float = Field(
-        ...,
-        ge=-90,
-        le=90,
-        serialization_alias="latitude",
-        validation_alias=AliasChoices("latitude", AliasPath("location", "latitude")),
-        description="The WGS84 latitude of the location.",
-    )
-    longitude: float = Field(
-        ...,
-        ge=-180,
-        le=180,
-        serialization_alias="longitude",
-        validation_alias=AliasChoices("longitude", AliasPath("location", "longitude")),
-        description="The WGS84 longitude of the location.",
-    )
-    elevation_m: Optional[float] = Field(
-        None,
-        ge=-99999,
-        le=99999,
-        serialization_alias="elevation_m",
-        validation_alias=AliasChoices(
-            "elevation_m", AliasPath("location", "elevation_m")
-        ),
-        description="The elevation in meters of the location.",
-    )
-    elevation_datum: Optional[str] = Field(
-        None,
-        strip_whitespace=True,
-        max_length=255,
-        serialization_alias="elevationDatum",
-        validation_alias=AliasChoices(
-            "elevationDatum", AliasPath("location", "elevationDatum")
-        ),
-        description="The datum used to represent the elevation of the location.",
-    )
-    state: Optional[str] = Field(
-        None,
-        strip_whitespace=True,
-        max_length=200,
-        serialization_alias="state",
-        validation_alias=AliasChoices("state", AliasPath("location", "state")),
-        description="The state/province of the location.",
-    )
-    county: Optional[str] = Field(
-        None,
-        strip_whitespace=True,
-        max_length=200,
-        serialization_alias="county",
-        validation_alias=AliasChoices("county", AliasPath("location", "county")),
-        description="The county/district of the location.",
-    )
-    country: Optional[str] = Field(
-        None,
-        strip_whitespace=True,
-        max_length=2,
-        serialization_alias="country",
-        validation_alias=AliasChoices("country", AliasPath("location", "country")),
-        description="The ISO 3166-1 alpha-2 country code of the location.",
-    )
-
-    @field_validator("country", mode="after")
-    def check_country_code(cls, value: str) -> str:
-        """
-        Validate the country code to ensure it is an ISO 3166-1 alpha-2 country code.
-
-        :param value: The country code to validate.
-        :type value: Optional[str]
-        :raises ValueError: If the country code is invalid.
-        :return: The validated country code.
-        :rtype: Optional[str]
-        """
-
-        if value and value.upper() not in valid_country_codes:
-            raise ValueError(
-                f"Invalid country code: {value}. Must be an ISO 3166-1 alpha-2 country code."
-            )
-
-        return value
-
-
-class Thing(HydroServerCoreModel, ThingFields, LocationFields):
-    """
-    A model representing a site/thing, combining core attributes from ThingFields and LocationFields with methods for
-    interacting with related entities.
-
-    :ivar _datastreams: A private attribute to cache the list of datastreams associated with the thing.
-    :ivar _tags: A private attribute to cache the list of tags associated with the thing.
-    :ivar _photos: A private attribute to cache the list of photos associated with the thing.
-    :ivar _archive: A private attribute to cache the archive associated with the thing.
-    """
-
-    def __init__(self, _endpoint, _uid: Optional[UUID] = None, **data):
-        """
-        Initialize a Thing instance.
-
-        :param _endpoint: The endpoint associated with the thing.
-        :type _endpoint: str
-        :param _uid: The unique identifier for the thing.
-        :type _uid: Optional[UUID]
-        :param data: Additional attributes for the thing.
-        """
-
-        super().__init__(_endpoint=_endpoint, _uid=_uid, **data)
-        self._datastreams = None
-        self._tags = None
-        self._photos = None
-        self._archive = None
-
-    @property
-    def datastreams(self) -> List["Datastream"]:
-        """
-        The datastreams associated with the thing. If not already cached, fetch the datastreams from the
-        server.
-
-        :return: A list of datastreams associated with the thing.
-        :rtype: List[Datastream]
-        """
-
-        if self._datastreams is None:
-            self._datastreams = self._endpoint.list_datastreams(uid=self.uid)
-
-        return self._datastreams
-
-    @property
-    def tags(self) -> List["Tag"]:
-        """
-        The tags associated with the thing. If not already cached, fetch the tags from the server.
-
-        :return: A list of tags associated with the thing.
-        :rtype: List[Tag]
-        """
-
-        if self._tags is None:
-            self._tags = self._endpoint.list_tags(uid=self.uid)
-
-        return self._tags
-
-    @property
-    def photos(self) -> List["Photo"]:
-        """
-        The photos associated with the thing. If not already cached, fetch the photos from the server.
-
-        :return: A list of photos associated with the thing.
-        :rtype: List[Photo]
-        """
-
-        if self._photos is None:
-            self._photos = self._endpoint.list_photos(uid=self.uid)
-
-        return self._photos
-
-    @property
-    def archive(self) -> "Archive":
-        """
-        The archive associated with the thing. If not already cached, fetch the archive from the server.
-
-        :return: The archive associated with the thing.
-        :rtype: Archive
-        """
-
-        if self._archive is None:
-            self._archive = self._endpoint.get_archive(uid=self.uid)
-
-        return self._archive
-
-    def refresh(self) -> None:
-        """
-        Refresh the thing with the latest data from the server and update cached datastreams, tags, photos, and archive
-        if they were previously loaded.
-        """
-
-        entity = self._endpoint.get(uid=self.uid).model_dump(exclude=["uid"])
-        self._original_data = entity
-        self.__dict__.update(entity)
-        if self._datastreams is not None:
-            self._datastreams = self._endpoint.list_datastreams(uid=self.uid)
-        if self._tags is not None:
-            self._tags = self._endpoint.list_tags(uid=self.uid)
-        if self._photos is not None:
-            self._photos = self._endpoint.list_photos(uid=self.uid)
-        if self._archive is not None:
-            self._archive = self._endpoint.get_archive(uid=self.uid)
-
-    def add_tag(self, key: str, value: str) -> None:
-        """
-        Add a new tag to the thing.
-
-        :param key: The key of the new tag.
-        :param value: The value of the new tag.
-        """
-
-        if self.tags is not None:
-            new_tag = self._endpoint.create_tag(uid=self.uid, key=key, value=value)
-            self._tags.append(new_tag)
-
-    def update_tag(self, key: str, value: str) -> None:
-        """
-        Update the value of an existing tag on the thing.
-
-        :param key: The key of the tag to update.
-        :param value: The new value for the tag.
-        """
-
-        selected_tag = next((tag for tag in self._tags if tag.key == key))
-        updated_tag = self._endpoint.update_tag(
-            uid=self.uid, tag_uid=selected_tag.uid, value=value
-        )
-        self._tags = [tag if tag.key != key else updated_tag for tag in self._tags]
-
-    def delete_tag(self, key: str) -> None:
-        """
-        Delete a tag from the thing.
-
-        :param key: The key of the tag to delete.
-        """
-
-        selected_tag = next((tag for tag in self._tags if tag.key == key))
-        self._endpoint.delete_tag(uid=self.uid, tag_uid=selected_tag.uid)
-        self._tags = [tag for tag in self._tags if tag.key != selected_tag.key]
-
-    def add_photo(self, photo: IO) -> None:
-        """
-        Add a photo to the thing.
-
-        :param photo: The photo file to upload.
-        :type photo: IO
-        """
-
-        if self.photos is not None:
-            photos = self._endpoint.upload_photo(uid=self.uid, file=photo)
-            self._photos.extend(photos)
-
-    def delete_photo(self, link: str) -> None:
-        """
-        Delete a photo from the thing.
-
-        :param link: The link to the photo to delete.
-        """
-
-        selected_photo = next((photo for photo in self._photos if photo.link == link))
-        self._endpoint.delete_photo(uid=self.uid, photo_uid=selected_photo.uid)
-        self._photos = [
-            photo for photo in self._photos if photo.link != selected_photo.link
-        ]
-
-
-class Archive(HydroServerBaseModel):
-    """
-    A model representing an archive associated with a thing.
-    """
-
-    link: Optional[str] = Field(
-        None,
-        strip_whitespace=True,
-        max_length=255,
-        description="A link to the HydroShare resource containing the archived site/thing.",
-    )
-    frequency: Optional[Literal["daily", "weekly", "monthly"]] = Field(
-        ...,
-        description="The frequency at which the site/thing should be archived.",
-    )
-    path: str = Field(
-        ...,
-        strip_whitespace=True,
-        max_length=255,
-        description="The path within the HydroShare resource containing the archived data.",
-    )
-    datastream_ids: List[UUID] = Field(
-        ...,
-        description="The list of datastreams that are included in the archived data.",
-    )
-
-
-class Tag(HydroServerBaseModel):
-    """
-    A model representing a tag associated with a thing.
-    """
-
-    key: str = Field(
-        ..., strip_whitespace=True, max_length=255, description="The key of the tag."
-    )
-    value: str = Field(
-        ..., strip_whitespace=True, max_length=255, description="The value of the tag."
-    )
-
-
-class Photo(HydroServerBaseModel):
-    """
-    A model representing a photo associated with a thing.
-    """
-
-    file_path: str = Field(
-        ..., strip_whitespace=True, description="The file path of the photo."
-    )
-    link: str = Field(..., strip_whitespace=True, description="The link to the photo.")

hydroserverpy/core/schemas/units.py

@@ -1,29 +0,0 @@
-from pydantic import Field
-from hydroserverpy.core.schemas.base import HydroServerCoreModel
-
-
-class UnitFields:
-    name: str = Field(
-        ..., strip_whitespace=True, max_length=255, description="The name of the unit."
-    )
-    symbol: str = Field(
-        ...,
-        strip_whitespace=True,
-        max_length=255,
-        description="The symbol of the unit.",
-    )
-    definition: str = Field(
-        ..., strip_whitespace=True, description="The definition of the unit."
-    )
-    type: str = Field(
-        ..., strip_whitespace=True, max_length=255, description="The type of the unit."
-    )
-
-
-class Unit(HydroServerCoreModel, UnitFields):
-    """
-    A model representing a unit, extending the core functionality of HydroServerCoreModel with additional
-    fields defined in UnitFields.
-    """
-
-    pass

hydroserverpy/core/service.py

@@ -1,200 +0,0 @@
-import requests
-from typing import Optional
-from hydroserverpy.core.endpoints import (
-    DataLoaderEndpoint,
-    DataSourceEndpoint,
-    DatastreamEndpoint,
-    ThingEndpoint,
-    SensorEndpoint,
-    UnitEndpoint,
-    ProcessingLevelEndpoint,
-    ObservedPropertyEndpoint,
-    ResultQualifierEndpoint,
-)
-
-
-class HydroServer:
-    """
-    Connects to a HydroServer instance and used to interact with HydroServer's Data Management API endpoints.
-
-    :param host: The base URL or host of the HydroServer API.
-    :type host: str
-    :param username: The username for basic authentication, if required.
-    :type username: Optional[str]
-    :param password: The password for basic authentication, if required.
-    :type password: Optional[str]
-    :param apikey: The API key for authentication, if using API key authentication.
-    :type apikey: Optional[str]
-    :param api_route: The API route to use, default is 'api'.
-    :type api_route: str
-    """
-
-    def __init__(
-        self,
-        host: str,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        apikey: Optional[str] = None,
-        api_route: str = "api",
-    ):
-        self.host = host.strip("/")
-        self.auth = (
-            (
-                username or "__key__",
-                password or apikey,
-            )
-            if (username and password) or apikey
-            else None
-        )
-        self.api_route = api_route.strip("/")
-        self._session = None
-        self._timeout = 60
-        self._initialize_session()
-
-    def _initialize_session(self) -> None:
-        """
-        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] == "__key__":
-            self._session.headers.update({"key": self.auth[1]})
-        elif self.auth:
-            self._session.auth = self.auth
-
-    def _request(self, method, path, *args, **kwargs) -> requests.Response:
-        """
-        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:
-                response = getattr(self._session, method)(
-                    f'{self.host}/{path.strip("/")}',
-                    timeout=self._timeout,
-                    *args,
-                    **kwargs,
-                )
-                response.raise_for_status()
-                return response
-            except requests.exceptions.ConnectionError as e:
-                if attempt == 0:
-                    self._initialize_session()
-                    continue
-                else:
-                    raise e
-
-    @property
-    def dataloaders(self):
-        """
-        Data Loader Endpoint.
-
-        :return: An instance of DataLoaderEndpoint.
-        :rtype: DataLoaderEndpoint
-        """
-
-        return DataLoaderEndpoint(self)
-
-    @property
-    def datasources(self):
-        """
-        Data Source Endpoint.
-
-        :return: An instance of DataSourceEndpoint.
-        :rtype: DataSourceEndpoint
-        """
-
-        return DataSourceEndpoint(self)
-
-    @property
-    def datastreams(self):
-        """
-        Datastream Endpoint.
-
-        :return: An instance of DatastreamEndpoint.
-        :rtype: DatastreamEndpoint
-        """
-
-        return DatastreamEndpoint(self)
-
-    @property
-    def observedproperties(self):
-        """
-        Observed Property Endpoint.
-
-        :return: An instance of ObservedPropertyEndpoint.
-        :rtype: ObservedPropertyEndpoint
-        """
-
-        return ObservedPropertyEndpoint(self)
-
-    @property
-    def processinglevels(self):
-        """
-        Processing Level Endpoint.
-
-        :return: An instance of ProcessingLevelEndpoint.
-        :rtype: ProcessingLevelEndpoint
-        """
-
-        return ProcessingLevelEndpoint(self)
-
-    @property
-    def resultqualifiers(self):
-        """
-        Result Qualifier Endpoint.
-
-        :return: An instance of ResultQualifierEndpoint.
-        :rtype: ResultQualifierEndpoint
-        """
-
-        return ResultQualifierEndpoint(self)
-
-    @property
-    def sensors(self):
-        """
-        Sensor Endpoint.
-
-        :return: An instance of SensorEndpoint.
-        :rtype: SensorEndpoint
-        """
-
-        return SensorEndpoint(self)
-
-    @property
-    def things(self):
-        """
-        Thing Endpoint.
-
-        :return: An instance of ThingEndpoint.
-        :rtype: ThingEndpoint
-        """
-
-        return ThingEndpoint(self)
-
-    @property
-    def units(self):
-        """
-        Unit Endpoint.
-
-        :return: An instance of UnitEndpoint.
-        :rtype: UnitEndpoint
-        """
-
-        return UnitEndpoint(self)

hydroserverpy-0.4.0.dist-info/RECORD

@@ -1,51 +0,0 @@
-hydroserverpy/__init__.py,sha256=6DIpIX9JiKm5FFHCvT6HdLN3sNkwXIf-fDPeLG6OM8c,231
-hydroserverpy/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hydroserverpy/core/service.py,sha256=L5klm7KfmcgjNJChh7ZrHA0xeLS78Yy2S2pWdhtS6H0,5356
-hydroserverpy/core/endpoints/__init__.py,sha256=SpN1WLX0R8HOLHBv1cp3VZcIEiKD4BBbgFGQppdA_mw,404
-hydroserverpy/core/endpoints/base.py,sha256=1LKmlMqki0wPsZfo78Fmjo-t_N-3EXbMSOd7m0rGjxI,5088
-hydroserverpy/core/endpoints/data_loaders.py,sha256=L2-smADgOIsUTfh6KS8ty6JQgvad7flPWzrydE_ptf8,3022
-hydroserverpy/core/endpoints/data_sources.py,sha256=lBximQw-UkCkix_ESx2QuwLeO3eIT9GWw23LsmvzslY,3020
-hydroserverpy/core/endpoints/datastreams.py,sha256=k1o5y-WdKjFqGd3pZv46_vd8cOLzlNrJmK5Roo3dkIc,7651
-hydroserverpy/core/endpoints/observed_properties.py,sha256=p_vQUxJE58-YDu1bt3n854vGoNr0yK66G_3fqh3flgo,3512
-hydroserverpy/core/endpoints/processing_levels.py,sha256=sy89Lgdr3kdXCq9W6nqM-_BCBqVmU5TQ5rcF91j-KlU,3489
-hydroserverpy/core/endpoints/result_qualifiers.py,sha256=VHImVsoqylnW4kpziKueDBxguVixoKVIp7O1wo3v2fw,3504
-hydroserverpy/core/endpoints/sensors.py,sha256=vF4p2I-7UioDEbIBfHrTgDtznI7ANTRJtgdQiyQ2RbQ,3325
-hydroserverpy/core/endpoints/things.py,sha256=KOlea2LxXd2qoeZafnsixNDOHdZZsG2AYIHGdfzfPNE,8597
-hydroserverpy/core/endpoints/units.py,sha256=HKgAlyC5kKi4GgnzxvHKnQcwth1IGBsImq1wFG3eV8M,3287
-hydroserverpy/core/schemas/__init__.py,sha256=gUFAim1jcUWAvj0IqpR8UKaCdXT1v11SmFnOzEmcwJM,353
-hydroserverpy/core/schemas/base.py,sha256=weVvt4b3csRVDXUl6dT5v5B_ujijA8nm69BNpJNEtSI,3720
-hydroserverpy/core/schemas/data_loaders.py,sha256=1EdZqXaHUqamh6IHguakdPzkkaEMHhcqq12EnEJv_sY,2487
-hydroserverpy/core/schemas/data_sources.py,sha256=T23nB8xlyu7X59EHjf4k4p7QEvcGk3MMK5_LL2sJV2Q,8262
-hydroserverpy/core/schemas/datastreams.py,sha256=eUU9KqeBxL6y3_l7rlKysNpdzqPVOCLBjVPiruYb8Gw,11782
-hydroserverpy/core/schemas/observed_properties.py,sha256=cT7SLtSXv52ywUjeWl5x7p0S0LqmwXGo2y4nQ2YjFEo,1230
-hydroserverpy/core/schemas/processing_levels.py,sha256=zJ-yOgUQaLjY4N1oahRWetI2BMY0ot7OC0826gjiVus,902
-hydroserverpy/core/schemas/result_qualifiers.py,sha256=ONKs4Cry9YqnOH3JFyDyBVfOTv9k3iXR_D3xlJ1mWrE,748
-hydroserverpy/core/schemas/sensors.py,sha256=1sGlAOs97zaN-oId227EQlsNipu9vwA_RufrymESP-Q,1963
-hydroserverpy/core/schemas/things.py,sha256=q9xAv_-A6aVRP8dNutFU4gDhrS4mN4FrcTA9-gfjEGo,11489
-hydroserverpy/core/schemas/units.py,sha256=TmSez08JadMa5se8_1egG9oKdyG-tV4PZn5JGKEDAho,819
-hydroserverpy/etl/__init__.py,sha256=qK2m4LZl8czR3VE8SxrlipSy5tLGLNB60lxD7dD0GjU,659
-hydroserverpy/etl/hydroserver_etl.py,sha256=FSdvM3T7QHEWWulWRT8t-FMHSxAGB4GvleUXtSk5IWc,1507
-hydroserverpy/etl/types.py,sha256=4PY3CM-uoXIsf2lhcqtLC6HaRGXe7HKGDU22R8-H35c,135
-hydroserverpy/etl/extractors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hydroserverpy/etl/extractors/base.py,sha256=GZKJfAhfJedRcNagnoqUiDZn286r-JzM7dW_F1dWsfY,275
-hydroserverpy/etl/extractors/ftp_extractor.py,sha256=5LwvHuvLk6LwRSVyE9EkV3DPgVlAvRrOBpl1a8B7dLg,1387
-hydroserverpy/etl/extractors/http_extractor.py,sha256=-duQwnsFBk4NQS2qhO55evcCUOnrBe3JX_LU9RyysX4,2709
-hydroserverpy/etl/extractors/local_file_extractor.py,sha256=T_Y9NTO0cC5L9mDPbIG6wYlXDQoatg8MobP97liFl4U,692
-hydroserverpy/etl/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hydroserverpy/etl/loaders/base.py,sha256=DrA9u7SNBxkPKqaszlP368yNbxihdqIGzP8rA6NAp6U,295
-hydroserverpy/etl/loaders/hydroserver_loader.py,sha256=8BMsSKAL1YHSCeO4hgbFkX47QmFiI4mGgSomykw5Whk,2562
-hydroserverpy/etl/transformers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hydroserverpy/etl/transformers/base.py,sha256=237oVBhS3HQ3fcE4bZT5U1437WzV2x5kOFC229DY53M,1741
-hydroserverpy/etl/transformers/csv_transformer.py,sha256=9DKSO4NfUUDlr_c6UnH4AU3-7LxwSSeuQdou0iiCjdM,3238
-hydroserverpy/etl/transformers/json_transformer.py,sha256=ity0MXcYjEnlun4Y6cVSrnjrglKrK4JOXXHxWHIHN2A,2323
-hydroserverpy/etl_csv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hydroserverpy/etl_csv/exceptions.py,sha256=0UY8YUlNepG0y6FfH36hJyR1bOhwYHSZIdUSSMTg7GA,314
-hydroserverpy/etl_csv/hydroserver_etl_csv.py,sha256=9pu37ZmcpjVHfGTopfhw1oNvRNMx1uCPMOJJC-3wxn4,13244
-hydroserverpy/quality/__init__.py,sha256=GGBMkFSXciJLYrbV-NraFrj_mXWCy_GTcy9KKrKXU4c,84
-hydroserverpy/quality/service.py,sha256=U02UfLKVmFvr5ySiH0n0JYzUIabq5uprrHIiwcqBlqY,13879
-hydroserverpy-0.4.0.dist-info/LICENSE,sha256=xVqFxDw3QOEJukakL7gQCqIMTQ1dlSCTo6Oc1otNW80,1508
-hydroserverpy-0.4.0.dist-info/METADATA,sha256=gpws0OQEo2rfwLHQ_gFSjS7f5-fHld36y5hqrKJjYg8,507
-hydroserverpy-0.4.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-hydroserverpy-0.4.0.dist-info/top_level.txt,sha256=Zf37hrncXLOYvXhgCrf5mZdeq81G9fShdE2LfYbtb7w,14
-hydroserverpy-0.4.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-hydroserverpy-0.4.0.dist-info/RECORD,,