meteo-lt-pkg 0.5.0__py3-none-any.whl → 0.5.0b0__py3-none-any.whl

meteo_lt/__init__.py

@@ -1,13 +1,27 @@
 """init.py"""
 
 from .api import MeteoLtAPI
-from .models import Coordinates, Place, ForecastTimestamp, Forecast, WeatherWarning
+from .models import (
+    Coordinates,
+    LocationBase,
+    Place,
+    ForecastTimestamp,
+    Forecast,
+    WeatherWarning,
+    HydroStation,
+    HydroObservation,
+    HydroObservationData,
+)
 
 __all__ = [
     "MeteoLtAPI",
     "Coordinates",
+    "LocationBase",
     "Place",
     "ForecastTimestamp",
     "Forecast",
     "WeatherWarning",
+    "HydroStation",
+    "HydroObservation",
+    "HydroObservationData",
 ]

meteo_lt/api.py

@@ -1,9 +1,15 @@
 """Main API class script"""
 
-from typing import List
-
-from .models import Forecast, WeatherWarning
-from .utils import find_nearest_place
+from typing import List, Optional
+
+from .models import (
+    Forecast,
+    Place,
+    WeatherWarning,
+    HydroStation,
+    HydroObservationData,
+)
+from .utils import find_nearest_location
 from .client import MeteoLtClient
 from .warnings import WeatherWarningsProcessor
 
@@ -21,7 +27,12 @@ class MeteoLtAPI:
         await self.client.__aenter__()
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
+    async def __aexit__(
+        self,
+        exc_type: Optional[type],
+        exc_val: Optional[Exception],
+        exc_tb: Optional[object],
+    ) -> None:
         """Async context manager exit"""
         await self.client.__aexit__(exc_type, exc_val, exc_tb)
 
@@ -29,31 +40,32 @@ class MeteoLtAPI:
         """Close the API client and cleanup resources"""
         await self.client.close()
 
-    async def fetch_places(self):
+    async def fetch_places(self) -> None:
         """Gets all places from API"""
         self.places = await self.client.fetch_places()
 
-    async def get_nearest_place(self, latitude, longitude):
+    async def get_nearest_place(self, latitude: float, longitude: float) -> Optional[Place]:
         """Finds nearest place using provided coordinates"""
         if not self.places:
             await self.fetch_places()
-        return find_nearest_place(latitude, longitude, self.places)
+        return find_nearest_location(latitude, longitude, self.places)
 
     async def get_forecast_with_warnings(
-        self, latitude=None, longitude=None, place_code=None
-    ):
+        self,
+        latitude: Optional[float] = None,
+        longitude: Optional[float] = None,
+        place_code: Optional[str] = None,
+    ) -> Forecast:
         """Get forecast with weather warnings for a location"""
         if place_code is None:
             if latitude is None or longitude is None:
-                raise ValueError(
-                    "Either place_code or both latitude and longitude must be provided"
-                )
+                raise ValueError("Either place_code or both latitude and longitude must be provided")
             place = await self.get_nearest_place(latitude, longitude)
             place_code = place.code
 
         return await self.get_forecast(place_code, include_warnings=True)
 
-    async def get_forecast(self, place_code, include_warnings=True):
+    async def get_forecast(self, place_code: str, include_warnings: bool = True) -> Forecast:
         """Retrieves forecast data from API"""
         forecast = await self.client.fetch_forecast(place_code)
 
@@ -62,26 +74,36 @@ class MeteoLtAPI:
 
         return forecast
 
-    async def get_weather_warnings(
-        self, administrative_division: str = None
-    ) -> List[WeatherWarning]:
+    async def get_weather_warnings(self, administrative_division: str = None) -> List[WeatherWarning]:
         """Fetches weather warnings from meteo.lt JSON API"""
-        return await self.warnings_processor.get_weather_warnings(
-            administrative_division
-        )
+        return await self.warnings_processor.get_weather_warnings(administrative_division)
 
-    async def _enrich_forecast_with_warnings(self, forecast: Forecast):
+    async def _enrich_forecast_with_warnings(self, forecast: Forecast) -> None:
         """Enrich forecast timestamps with relevant weather warnings"""
-        if (
-            not forecast
-            or not forecast.place
-            or not forecast.place.administrative_division
-        ):
+        if not forecast or not forecast.place or not forecast.place.administrative_division:
             return
 
-        warnings = await self.get_weather_warnings(
-            forecast.place.administrative_division
-        )
+        warnings = await self.get_weather_warnings(forecast.place.administrative_division)
 
         if warnings:
             self.warnings_processor.enrich_forecast_with_warnings(forecast, warnings)
+
+    async def get_hydro_stations(self) -> List[HydroStation]:
+        """Get list of all hydrological stations"""
+        return await self.client.fetch_hydro_stations()
+
+    async def get_nearest_hydro_station(self, latitude: float, longitude: float) -> Optional[HydroStation]:
+        """Find the nearest hydrological station to given coordinates"""
+        stations = await self.get_hydro_stations()
+        if not stations:
+            return None
+        return find_nearest_location(latitude, longitude, stations)
+
+    async def get_hydro_observation_data(
+        self,
+        station_code: str,
+        observation_type: str = "measured",
+        date: str = "latest",
+    ) -> HydroObservationData:
+        """Get hydrological observation data for a station"""
+        return await self.client.fetch_hydro_observation_data(station_code, observation_type, date)

meteo_lt/client.py

@@ -1,11 +1,17 @@
 """MeteoLt API client for external API calls"""
 
 import json
-from typing import List, Optional
+from typing import List, Optional, Dict, Any
 
 import aiohttp
 
-from .models import Place, Forecast
+from .models import (
+    Place,
+    Forecast,
+    HydroStation,
+    HydroObservationData,
+    HydroObservation,
+)
 from .const import BASE_URL, WARNINGS_URL, TIMEOUT, ENCODING
 
 
@@ -25,11 +31,16 @@ class MeteoLtClient:
             )
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
+    async def __aexit__(
+        self,
+        exc_type: Optional[type],
+        exc_val: Optional[Exception],
+        exc_tb: Optional[Any],
+    ) -> None:
         """Async context manager exit"""
         await self.close()
 
-    async def close(self):
+    async def close(self) -> None:
         """Close the client session if we own it"""
         if self._session and self._owns_session:
             await self._session.close()
@@ -55,14 +66,12 @@ class MeteoLtClient:
     async def fetch_forecast(self, place_code: str) -> Forecast:
         """Retrieves forecast data from API"""
         session = await self._get_session()
-        async with session.get(
-            f"{BASE_URL}/places/{place_code}/forecasts/long-term"
-        ) as response:
+        async with session.get(f"{BASE_URL}/places/{place_code}/forecasts/long-term") as response:
             response.encoding = ENCODING
             response_json = await response.json()
             return Forecast.from_dict(response_json)
 
-    async def fetch_weather_warnings(self) -> List[dict]:
+    async def fetch_weather_warnings(self) -> Dict[str, Any]:
         """Fetches raw weather warnings data from meteo.lt JSON API"""
         session = await self._get_session()
 
@@ -78,3 +87,77 @@ class MeteoLtClient:
         async with session.get(latest_file_url) as response:
             text_data = await response.text()
             return json.loads(text_data)
+
+    async def fetch_hydro_stations(self) -> List[HydroStation]:
+        """Get list of all hydrological stations."""
+        session = await self._get_session()
+        async with session.get(f"{BASE_URL}/hydro-stations") as resp:
+            if resp.status == 200:
+                response = await resp.json()
+                stations = []
+                for station_data in response:
+                    stations.append(
+                        HydroStation(
+                            code=station_data.get("code"),
+                            name=station_data.get("name"),
+                            water_body=station_data.get("waterBody"),
+                            coordinates=station_data.get("coordinates", {}),
+                        )
+                    )
+                return stations
+            else:
+                raise Exception(f"API returned status {resp.status}")
+
+    async def fetch_hydro_station(self, station_code: str) -> HydroStation:
+        """Get information about a specific hydrological station."""
+        session = await self._get_session()
+        async with session.get(f"{BASE_URL}/hydro-stations/{station_code}") as resp:
+            if resp.status == 200:
+                response = await resp.json()
+                return HydroStation(
+                    code=response.get("code"),
+                    name=response.get("name"),
+                    water_body=response.get("waterBody"),
+                    coordinates=response.get("coordinates", {}),
+                )
+            else:
+                raise Exception(f"API returned status {resp.status}")
+
+    async def fetch_hydro_observation_data(
+        self,
+        station_code: str,
+        observation_type: str = "measured",
+        date: str = "latest",
+    ) -> HydroObservationData:
+        """Get hydrological observation data for a station."""
+        session = await self._get_session()
+        async with session.get(
+            f"{BASE_URL}/hydro-stations/{station_code}/observations/{observation_type}/{date}"
+        ) as resp:
+            if resp.status == 200:
+                response = await resp.json()
+                station = HydroStation(
+                    code=response["station"].get("code"),
+                    name=response["station"].get("name"),
+                    water_body=response["station"].get("waterBody"),
+                    coordinates=response["station"].get("coordinates", {}),
+                )
+
+                observations = []
+                for obs_data in response.get("observations", []):
+                    observations.append(
+                        HydroObservation(
+                            observation_datetime=obs_data.get("observationTimeUtc"),
+                            water_level=obs_data.get("waterLevel"),
+                            water_temperature=obs_data.get("waterTemperature"),
+                            water_discharge=obs_data.get("waterDischarge"),
+                        )
+                    )
+
+                return HydroObservationData(
+                    station=station,
+                    observations_data_range=response.get("observationsDataRange"),
+                    observations=observations,
+                )
+            else:
+                raise Exception(f"API returned status {resp.status}")

meteo_lt/const.py

@@ -1,10 +1,7 @@
 """const.py"""
 
 BASE_URL = "https://api.meteo.lt/v1"
-WARNINGS_URL = (
-    "https://www.meteo.lt/app/mu-plugins/Meteo/Components/"
-    "WeatherWarningsNew/list_JSON.php"
-)
+WARNINGS_URL = "https://www.meteo.lt/app/mu-plugins/Meteo/Components/" "WeatherWarningsNew/list_JSON.php"
 TIMEOUT = 30
 ENCODING = "utf-8"
 

meteo_lt/models.py

@@ -2,7 +2,7 @@
 
 from dataclasses import dataclass, field, fields
 from datetime import datetime, timezone
-from typing import List, Optional
+from typing import List, Optional, Dict, Any, Type
 
 from .const import COUNTY_MUNICIPALITIES
 
@@ -16,17 +16,12 @@ class Coordinates:
 
 
 @dataclass
-class Place:
-    """Places"""
+class LocationBase:
+    """Base class for locations with coordinates"""
 
     code: str
     name: str
-    administrative_division: str = field(
-        metadata={"json_key": "administrativeDivision"}
-    )
-    country_code: str = field(metadata={"json_key": "countryCode"})
     coordinates: Coordinates
-    counties: List[str] = field(init=False)
 
     @property
     def latitude(self):
@@ -38,13 +33,19 @@ class Place:
         """Longitude from coordinates"""
         return self.coordinates.longitude
 
+
+@dataclass
+class Place(LocationBase):
+    """Places"""
+
+    administrative_division: str = field(metadata={"json_key": "administrativeDivision"})
+    country_code: str = field(metadata={"json_key": "countryCode"})
+    counties: List[str] = field(init=False)
+
     def __post_init__(self):
         self.counties = []
         for county, municipalities in COUNTY_MUNICIPALITIES.items():
-            if (
-                self.administrative_division.replace(" savivaldybė", "")
-                in municipalities
-            ):
+            if self.administrative_division.replace(" savivaldybė", "") in municipalities:
                 self.counties.append(county)
 
 
@@ -60,6 +61,32 @@ class WeatherWarning:
     end_time: Optional[str] = None
 
 
+@dataclass
+class HydroStation(LocationBase):
+    """Hydrological station data."""
+
+    water_body: str
+
+
+@dataclass
+class HydroObservation:
+    """Single hydrological observation."""
+
+    observation_datetime: Optional[str] = None
+    water_level: Optional[float] = None  # cm
+    water_temperature: Optional[float] = None  # °C
+    water_discharge: Optional[float] = None  # m3/s
+
+
+@dataclass
+class HydroObservationData:
+    """Observation data response."""
+
+    station: HydroStation
+    observations_data_range: Optional[dict] = None
+    observations: List[HydroObservation] = field(default_factory=list)
+
+
 @dataclass
 class ForecastTimestamp:
     """ForecastTimestamp"""
@@ -85,16 +112,12 @@ class Forecast:
     place: Place
     forecast_created: str = field(metadata={"json_key": "forecastCreationTimeUtc"})
     current_conditions: ForecastTimestamp
-    forecast_timestamps: List[ForecastTimestamp] = field(
-        metadata={"json_key": "forecastTimestamps"}
-    )
+    forecast_timestamps: List[ForecastTimestamp] = field(metadata={"json_key": "forecastTimestamps"})
 
     def __post_init__(self):
         """Post-initialization processing."""
 
-        current_hour = datetime.now(timezone.utc).replace(
-            minute=0, second=0, microsecond=0
-        )
+        current_hour = datetime.now(timezone.utc).replace(minute=0, second=0, microsecond=0)
         # Current conditions are equal to current hour record
         for forecast in self.forecast_timestamps:
             if (
@@ -118,9 +141,9 @@ class Forecast:
         ]
 
 
-def from_dict(cls, data: dict):
+def from_dict(cls: Type, data: Dict[str, Any]) -> Any:
     """Utility function to convert a dictionary to a dataclass instance."""
-    init_args = {}
+    init_args: Dict[str, Any] = {}
     for f in fields(cls):
         if not f.init:
             continue  # Skip fields that are not part of the constructor
@@ -133,11 +156,9 @@ def from_dict(cls, data: dict):
             value = from_dict(f.type, value)
         elif isinstance(value, list) and hasattr(f.type.__args__[0], "from_dict"):
             value = [from_dict(f.type.__args__[0], item) for item in value]
-        elif f.name in ("datetime", "forecast_created"):
+        elif f.name in ("datetime", "forecast_created", "observation_datetime") and value:
             # Convert datetime to ISO 8601 format
-            dt = datetime.strptime(value, "%Y-%m-%d %H:%M:%S").replace(
-                tzinfo=timezone.utc
-            )
+            dt = datetime.strptime(value, "%Y-%m-%d %H:%M:%S").replace(tzinfo=timezone.utc)
             value = dt.isoformat()
 
         init_args[f.name] = value
@@ -149,3 +170,6 @@ Place.from_dict = classmethod(from_dict)
 ForecastTimestamp.from_dict = classmethod(from_dict)
 Forecast.from_dict = classmethod(from_dict)
 WeatherWarning.from_dict = classmethod(from_dict)
+HydroStation.from_dict = classmethod(from_dict)
+HydroObservation.from_dict = classmethod(from_dict)
+HydroObservationData.from_dict = classmethod(from_dict)

meteo_lt/utils.py

@@ -1,9 +1,12 @@
 """utils.py"""
 
 from math import radians, sin, cos, sqrt, atan2
+from typing import TypeVar, List
 
+LocationT = TypeVar("LocationT")  # Type variable for location objects with latitude/longitude
 
-def haversine(lat1, lon1, lat2, lon2):
+
+def haversine(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
     """Calculate the great-circle distance between two points on the Earth's surface."""
     # Convert latitude and longitude from degrees to radians
     lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])
@@ -17,18 +20,18 @@ def haversine(lat1, lon1, lat2, lon2):
     return r * c
 
 
-def find_nearest_place(latitude, longitude, places):
-    """Find the nearest place from a list of places based on the given latitude and longitude."""
-    nearest_place = None
+def find_nearest_location(latitude: float, longitude: float, locations: List[LocationT]) -> LocationT:
+    """Find the nearest location from a list of locations based on the given latitude and longitude."""
+    nearest_location = None
     min_distance = float("inf")
 
-    for place in places:
-        place_lat = place.latitude
-        place_lon = place.longitude
-        distance = haversine(latitude, longitude, place_lat, place_lon)
+    for location in locations:
+        location_lat = location.latitude
+        location_lon = location.longitude
+        distance = haversine(latitude, longitude, location_lat, location_lon)
 
         if distance < min_distance:
             min_distance = distance
-            nearest_place = place
+            nearest_location = location
 
-    return nearest_place
+    return nearest_location

meteo_lt/warnings.py

@@ -2,7 +2,7 @@
 
 import re
 from datetime import datetime, timezone
-from typing import List
+from typing import List, Optional, Dict, Any
 
 from .models import Forecast, WeatherWarning
 from .const import COUNTY_MUNICIPALITIES
@@ -15,24 +15,18 @@ class WeatherWarningsProcessor:
     def __init__(self, client: MeteoLtClient):
         self.client = client
 
-    async def get_weather_warnings(
-        self, administrative_division: str = None
-    ) -> List[WeatherWarning]:
+    async def get_weather_warnings(self, administrative_division: str = None) -> List[WeatherWarning]:
         """Fetches and processes weather warnings"""
         warnings_data = await self.client.fetch_weather_warnings()
         warnings = self._parse_warnings_data(warnings_data)
 
         # Filter by administrative division if specified
         if administrative_division:
-            warnings = [
-                w
-                for w in warnings
-                if self._warning_affects_area(w, administrative_division)
-            ]
+            warnings = [w for w in warnings if self._warning_affects_area(w, administrative_division)]
 
         return warnings
 
-    def _parse_warnings_data(self, warnings_data: dict) -> List[WeatherWarning]:
+    def _parse_warnings_data(self, warnings_data: Optional[Dict[str, Any]]) -> List[WeatherWarning]:
         """Parse raw warnings data into WeatherWarning objects"""
         warnings = []
 
@@ -49,9 +43,7 @@ class WeatherWarningsProcessor:
             for area_group in phenomenon_group.get("area_groups", []):
                 for alert in area_group.get("single_alerts", []):
                     # Skip alerts with no phenomenon or empty descriptions
-                    if not alert.get("phenomenon") or not alert.get(
-                        "description", {}
-                    ).get("lt"):
+                    if not alert.get("phenomenon") or not alert.get("description", {}).get("lt"):
                         continue
 
                     # Create warnings for each area in the group
@@ -62,7 +54,7 @@ class WeatherWarningsProcessor:
 
         return warnings
 
-    def _create_warning_from_alert(self, alert: dict, area: dict) -> WeatherWarning:
+    def _create_warning_from_alert(self, alert: Dict[str, Any], area: Dict[str, Any]) -> WeatherWarning:
         """Create a WeatherWarning from alert data"""
         county = area.get("name", "Unknown")
         phenomenon = alert.get("phenomenon", "")
@@ -89,15 +81,9 @@ class WeatherWarningsProcessor:
             end_time=alert.get("t_to"),
         )
 
-    def _warning_affects_area(
-        self, warning: WeatherWarning, administrative_division: str
-    ) -> bool:
+    def _warning_affects_area(self, warning: WeatherWarning, administrative_division: str) -> bool:
         """Check if warning affects specified administrative division"""
-        admin_lower = (
-            administrative_division.lower()
-            .replace(" savivaldybė", "")
-            .replace(" sav.", "")
-        )
+        admin_lower = administrative_division.lower().replace(" savivaldybė", "").replace(" sav.", "")
 
         # Check if the administrative division matches the warning county
         if admin_lower in warning.county.lower():
@@ -107,28 +93,20 @@ class WeatherWarningsProcessor:
         if warning.county in COUNTY_MUNICIPALITIES:
             municipalities = COUNTY_MUNICIPALITIES[warning.county]
             for municipality in municipalities:
-                mun_clean = (
-                    municipality.lower()
-                    .replace(" savivaldybė", "")
-                    .replace(" sav.", "")
-                )
+                mun_clean = municipality.lower().replace(" savivaldybė", "").replace(" sav.", "")
                 if admin_lower in mun_clean or mun_clean in admin_lower:
                     return True
 
         return False
 
-    def enrich_forecast_with_warnings(
-        self, forecast: Forecast, warnings: List[WeatherWarning]
-    ):
+    def enrich_forecast_with_warnings(self, forecast: Forecast, warnings: List[WeatherWarning]) -> None:
         """Enrich forecast timestamps with relevant weather warnings"""
         if not warnings:
             return
 
         # For each forecast timestamp, find applicable warnings
         for timestamp in forecast.forecast_timestamps:
-            timestamp.warnings = self._get_warnings_for_timestamp(
-                timestamp.datetime, warnings
-            )
+            timestamp.warnings = self._get_warnings_for_timestamp(timestamp.datetime, warnings)
 
         # Also add warnings to current conditions if available
         if hasattr(forecast, "current_conditions") and forecast.current_conditions:
@@ -136,14 +114,10 @@ class WeatherWarningsProcessor:
                 forecast.current_conditions.datetime, warnings
             )
 
-    def _get_warnings_for_timestamp(
-        self, timestamp_str: str, warnings: List[WeatherWarning]
-    ) -> List[WeatherWarning]:
+    def _get_warnings_for_timestamp(self, timestamp_str: str, warnings: List[WeatherWarning]) -> List[WeatherWarning]:
         """Get warnings that are active for a specific timestamp"""
         try:
-            timestamp = datetime.fromisoformat(timestamp_str).replace(
-                tzinfo=timezone.utc
-            )
+            timestamp = datetime.fromisoformat(timestamp_str).replace(tzinfo=timezone.utc)
             applicable_warnings = []
 
             for warning in warnings:
@@ -151,12 +125,8 @@ class WeatherWarningsProcessor:
                     continue
 
                 try:
-                    start_time = datetime.fromisoformat(
-                        warning.start_time.replace("Z", "+00:00")
-                    )
-                    end_time = datetime.fromisoformat(
-                        warning.end_time.replace("Z", "+00:00")
-                    )
+                    start_time = datetime.fromisoformat(warning.start_time.replace("Z", "+00:00"))
+                    end_time = datetime.fromisoformat(warning.end_time.replace("Z", "+00:00"))
 
                     # Check if timestamp falls within warning period
                     if start_time <= timestamp <= end_time:

{meteo_lt_pkg-0.5.0.dist-info → meteo_lt_pkg-0.5.0b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meteo_lt-pkg
-Version: 0.5.0
+Version: 0.5.0b0
 Summary: A library to fetch weather data from api.meteo.lt
 Author-email: Brunas <brunonas@gmail.com>
 Project-URL: Homepage, https://github.com/Brunas/meteo_lt-pkg
@@ -12,17 +12,17 @@ Classifier: Development Status :: 4 - Beta
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp
+Requires-Dist: aiohttp>=3.13
 Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: pytest-asyncio; extra == "dev"
-Requires-Dist: black; extra == "dev"
-Requires-Dist: coverage; extra == "dev"
-Requires-Dist: flake8; extra == "dev"
-Requires-Dist: pyflakes; extra == "dev"
-Requires-Dist: pylint; extra == "dev"
-Requires-Dist: build; extra == "dev"
+Requires-Dist: pytest>=9.0; extra == "dev"
+Requires-Dist: pytest-cov>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.3; extra == "dev"
+Requires-Dist: black>=26.0; extra == "dev"
+Requires-Dist: coverage>=7.0; extra == "dev"
+Requires-Dist: flake8>=7.0; extra == "dev"
+Requires-Dist: pyflakes>=3.0; extra == "dev"
+Requires-Dist: pylint>=4.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
 Dynamic: license-file
 
 # Meteo.Lt Lithuanian weather forecast package

meteo_lt_pkg-0.5.0b0.dist-info/RECORD

@@ -0,0 +1,12 @@
+meteo_lt/__init__.py,sha256=HRQ5O9YMn6h2bXkhx6yuPF6voo6SiUZDrY8RZFeLaks,456
+meteo_lt/api.py,sha256=TJrtP2ScPhT30QR9rHs2NzPibQgbkppMDrPh9JiyBoU,4086
+meteo_lt/client.py,sha256=LwFRr1GDuVoeFEKj31w0pwmPQegwM-o1prZdtOop5r0,6291
+meteo_lt/const.py,sha256=Mz_8F5k_dVQlGNdYdGQOXqaEye4G5Z0xoBw971O8vBM,2690
+meteo_lt/models.py,sha256=8mUQek55pVMxjuLheW6T8oGwinf0VJdkC1Y8cWv7TIo,5667
+meteo_lt/utils.py,sha256=D2SDbWx0o_iKwJP1tCrHLovWWmT0HUu4C9gNSQEmiDw,1339
+meteo_lt/warnings.py,sha256=6wYzinhBzXC3apR38LSEGPwsxiVTrVgLvDWql9-w0B0,6141
+meteo_lt_pkg-0.5.0b0.dist-info/licenses/LICENSE,sha256=3IGi6xn6NUdXGvcdwD0MUbhy3Yz5NRnUjJrwKanFAD4,1073
+meteo_lt_pkg-0.5.0b0.dist-info/METADATA,sha256=5fBukQnZvFbMZu6XQa4PRAZTxAwivyIFCipoz3uHHhY,10382
+meteo_lt_pkg-0.5.0b0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+meteo_lt_pkg-0.5.0b0.dist-info/top_level.txt,sha256=-aEdc9FzHhcIH4_0TNdKNxuvDnS3chKoJy6LK9Ud-G4,9
+meteo_lt_pkg-0.5.0b0.dist-info/RECORD,,

meteo_lt_pkg-0.5.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-meteo_lt/__init__.py,sha256=TP3DhEXEpHdI6bevRjxb0cbVrEWbI8mEocYc1DwA_KI,255
-meteo_lt/api.py,sha256=3RCNUV9guscSADrcLRbsRomhp9rpPDrMVdCmKXsohmw,3006
-meteo_lt/client.py,sha256=j5F1Ag00EnEI8ErLz0Q2lYqWfO8YgqYlsAHfhzkGyWE,2798
-meteo_lt/const.py,sha256=1xeQ2wErqPREnYfK4OogadlVIu0p2gGoILsOcsIfp8Q,2702
-meteo_lt/models.py,sha256=ki0kVe_uUVOMSC2VQsW5i2pd9A06wvuupn7jgSwyQ-0,4838
-meteo_lt/utils.py,sha256=SL7ZeTEfdrdQoe_DOJaiA2zVxt08ujyFJ24JxJm1Hks,1081
-meteo_lt/warnings.py,sha256=XpHMOkwqXB_mgQccyPdOlmRFcOV58Dkwtva0kNDxdpQ,6520
-meteo_lt_pkg-0.5.0.dist-info/licenses/LICENSE,sha256=3IGi6xn6NUdXGvcdwD0MUbhy3Yz5NRnUjJrwKanFAD4,1073
-meteo_lt_pkg-0.5.0.dist-info/METADATA,sha256=-PAVjCqFFvvdg8kEvn96UJM5ZjRCbOWLwGlbzjE1wpc,10328
-meteo_lt_pkg-0.5.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-meteo_lt_pkg-0.5.0.dist-info/top_level.txt,sha256=-aEdc9FzHhcIH4_0TNdKNxuvDnS3chKoJy6LK9Ud-G4,9
-meteo_lt_pkg-0.5.0.dist-info/RECORD,,