meteo-lt-pkg 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

meteo_lt/__init__.py

@@ -7,7 +7,7 @@ from .models import (
     Place,
     ForecastTimestamp,
     Forecast,
-    WeatherWarning,
+    MeteoWarning,
     HydroStation,
     HydroObservation,
     HydroObservationData,
@@ -20,7 +20,7 @@ __all__ = [
     "Place",
     "ForecastTimestamp",
     "Forecast",
-    "WeatherWarning",
+    "MeteoWarning",
     "HydroStation",
     "HydroObservation",
     "HydroObservationData",

meteo_lt/api.py

@@ -1,17 +1,18 @@
 """Main API class script"""
 
+import asyncio
 from typing import List, Optional
 
 from .models import (
     Forecast,
     Place,
-    WeatherWarning,
+    MeteoWarning,
     HydroStation,
     HydroObservationData,
 )
 from .utils import find_nearest_location
 from .client import MeteoLtClient
-from .warnings import WeatherWarningsProcessor
+from .warnings import WarningsProcessor
 
 
 class MeteoLtAPI:
@@ -20,7 +21,8 @@ class MeteoLtAPI:
     def __init__(self, session=None):
         self.places = []
         self.client = MeteoLtClient(session)
-        self.warnings_processor = WeatherWarningsProcessor(self.client)
+        self.warnings_processor = WarningsProcessor(self.client, category="weather")
+        self.hydro_warnings_processor = WarningsProcessor(self.client, category="hydro")
 
     async def __aenter__(self):
         """Async context manager entry"""
@@ -56,7 +58,7 @@ class MeteoLtAPI:
         longitude: Optional[float] = None,
         place_code: Optional[str] = None,
     ) -> Forecast:
-        """Get forecast with weather warnings for a location"""
+        """Get forecast with all warnings (weather and hydrological) 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")
@@ -65,7 +67,7 @@ class MeteoLtAPI:
 
         return await self.get_forecast(place_code, include_warnings=True)
 
-    async def get_forecast(self, place_code: str, include_warnings: bool = True) -> Forecast:
+    async def get_forecast(self, place_code: str, include_warnings: bool = False) -> Forecast:
         """Retrieves forecast data from API"""
         forecast = await self.client.fetch_forecast(place_code)
 
@@ -74,27 +76,39 @@ 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[MeteoWarning]:
         """Fetches weather warnings from meteo.lt JSON API"""
-        return await self.warnings_processor.get_weather_warnings(administrative_division)
+        return await self.warnings_processor.get_warnings(administrative_division)
+
+    async def get_hydro_warnings(self, administrative_division: str = None) -> List[MeteoWarning]:
+        """Fetches hydrological warnings from meteo.lt JSON API"""
+        return await self.hydro_warnings_processor.get_warnings(administrative_division)
+
+    async def get_all_warnings(self, administrative_division: str = None) -> List[MeteoWarning]:
+        """Fetches both weather and hydrological warnings from meteo.lt JSON API"""
+        weather_task = self.warnings_processor.get_warnings(administrative_division)
+        hydro_task = self.hydro_warnings_processor.get_warnings(administrative_division)
+        weather_warnings, hydro_warnings = await asyncio.gather(weather_task, hydro_task)
+        return weather_warnings + hydro_warnings
 
     async def _enrich_forecast_with_warnings(self, forecast: Forecast) -> None:
-        """Enrich forecast timestamps with relevant weather warnings"""
+        """Enrich forecast timestamps with all relevant warnings (weather and hydrological)"""
         if not forecast or not forecast.place or not forecast.place.administrative_division:
             return
 
-        warnings = await self.get_weather_warnings(forecast.place.administrative_division)
+        all_warnings = await self.get_all_warnings(forecast.place.administrative_division)
 
-        if warnings:
-            self.warnings_processor.enrich_forecast_with_warnings(forecast, warnings)
+        if all_warnings:
+            # Use weather processor to enrich (logic is the same for both)
+            self.warnings_processor.enrich_forecast_with_warnings(forecast, all_warnings)
 
-    async def get_hydro_stations(self) -> List[HydroStation]:
+    async def fetch_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()
+        stations = await self.fetch_hydro_stations()
         if not stations:
             return None
         return find_nearest_location(latitude, longitude, stations)

meteo_lt/client.py

@@ -12,7 +12,7 @@ from .models import (
     HydroObservationData,
     HydroObservation,
 )
-from .const import BASE_URL, WARNINGS_URL, TIMEOUT, ENCODING
+from .const import BASE_URL, TIMEOUT, ENCODING
 
 
 class MeteoLtClient:
@@ -71,12 +71,12 @@ class MeteoLtClient:
             response_json = await response.json()
             return Forecast.from_dict(response_json)
 
-    async def fetch_weather_warnings(self) -> Dict[str, Any]:
-        """Fetches raw weather warnings data from meteo.lt JSON API"""
+    async def fetch_warnings(self, warnings_url: str) -> Dict[str, Any]:
+        """Fetches raw warnings data from meteo.lt JSON API"""
         session = await self._get_session()
 
         # Get the latest warnings file
-        async with session.get(WARNINGS_URL) as response:
+        async with session.get(warnings_url) as response:
             file_list = await response.json()
 
         if not file_list:

meteo_lt/const.py

@@ -1,7 +1,8 @@
 """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"
+HYDRO_WARNINGS_URL = "https://www.meteo.lt/app/mu-plugins/Meteo/Components/HydroWarnings/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, Dict, Any, Type
+from typing import Any, Dict, List, Optional, Type
 
 from .const import COUNTY_MUNICIPALITIES
 
@@ -50,15 +50,17 @@ class Place(LocationBase):
 
 
 @dataclass
-class WeatherWarning:
-    """Weather Warning"""
+class MeteoWarning:
+    """Meteorological Warning (includes both weather and hydrological warnings)"""
 
     county: str
     warning_type: str
     severity: str
     description: str
+    category: str = "weather"  # "weather" or "hydro"
     start_time: Optional[str] = None
     end_time: Optional[str] = None
+    instruction: Optional[str] = None
 
 
 @dataclass
@@ -102,7 +104,7 @@ class ForecastTimestamp:
     pressure: float = field(metadata={"json_key": "seaLevelPressure"})
     humidity: float = field(metadata={"json_key": "relativeHumidity"})
     precipitation: float = field(metadata={"json_key": "totalPrecipitation"})
-    warnings: List[WeatherWarning] = field(default_factory=list, init=False)
+    warnings: List[MeteoWarning] = field(default_factory=list, init=False)
 
 
 @dataclass
@@ -169,7 +171,7 @@ Coordinates.from_dict = classmethod(from_dict)
 Place.from_dict = classmethod(from_dict)
 ForecastTimestamp.from_dict = classmethod(from_dict)
 Forecast.from_dict = classmethod(from_dict)
-WeatherWarning.from_dict = classmethod(from_dict)
+MeteoWarning.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/warnings.py

@@ -1,23 +1,30 @@
-"""Weather warnings processor for handling warning-related logic"""
+"""Unified warnings processor for handling weather and hydrological warning-related logic"""
 
 import re
 from datetime import datetime, timezone
-from typing import List, Optional, Dict, Any
+from typing import Any, Dict, List, Literal, Optional
 
-from .models import Forecast, WeatherWarning
-from .const import COUNTY_MUNICIPALITIES
 from .client import MeteoLtClient
+from .const import COUNTY_MUNICIPALITIES, HYDRO_WARNINGS_URL, WARNINGS_URL
+from .models import Forecast, MeteoWarning
 
+WarningCategory = Literal["weather", "hydro"]
 
-class WeatherWarningsProcessor:
-    """Processes weather warnings data and handles warning-related logic"""
 
-    def __init__(self, client: MeteoLtClient):
+class WarningsProcessor:
+    """Processes weather and hydrological warnings data and handles warning-related logic"""
+
+    def __init__(self, client: MeteoLtClient, category: WarningCategory = "weather"):
         self.client = client
+        self.category = category
+
+    async def get_warnings(self, administrative_division: str = None) -> List[MeteoWarning]:
+        """Fetches and processes warnings (weather or hydro based on category)"""
+        # Determine URL based on category
+        warnings_url = HYDRO_WARNINGS_URL if self.category == "hydro" else WARNINGS_URL
 
-    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()
+        # Fetch warnings data
+        warnings_data = await self.client.fetch_warnings(warnings_url)
         warnings = self._parse_warnings_data(warnings_data)
 
         # Filter by administrative division if specified
@@ -26,8 +33,8 @@ class WeatherWarningsProcessor:
 
         return warnings
 
-    def _parse_warnings_data(self, warnings_data: Optional[Dict[str, Any]]) -> List[WeatherWarning]:
-        """Parse raw warnings data into WeatherWarning objects"""
+    def _parse_warnings_data(self, warnings_data: Optional[Dict[str, Any]]) -> List[MeteoWarning]:
+        """Parse raw warnings data into MeteoWarning objects"""
         warnings = []
 
         # Handle empty response (list instead of dict)
@@ -36,8 +43,12 @@ class WeatherWarningsProcessor:
 
         # Parse the warnings data
         for phenomenon_group in warnings_data.get("phenomenon_groups", []):
-            # Skip hydrological warnings if needed (they're usually for water levels)
-            if phenomenon_group.get("phenomenon_category") == "hydrological":
+            phenomenon_category = phenomenon_group.get("phenomenon_category")
+
+            # Filter based on category
+            if self.category == "hydro" and phenomenon_category != "hydrological":
+                continue
+            if self.category == "weather" and phenomenon_category == "hydrological":
                 continue
 
             for area_group in phenomenon_group.get("area_groups", []):
@@ -54,8 +65,8 @@ class WeatherWarningsProcessor:
 
         return warnings
 
-    def _create_warning_from_alert(self, alert: Dict[str, Any], area: Dict[str, Any]) -> WeatherWarning:
-        """Create a WeatherWarning from alert data"""
+    def _create_warning_from_alert(self, alert: Dict[str, Any], area: Dict[str, Any]) -> MeteoWarning:
+        """Create a MeteoWarning from alert data"""
         county = area.get("name", "Unknown")
         phenomenon = alert.get("phenomenon", "")
         severity = alert.get("severity", "Minor")
@@ -66,22 +77,20 @@ class WeatherWarningsProcessor:
         inst_dict = alert.get("instruction", {})
 
         description = desc_dict.get("en") or desc_dict.get("lt", "")
-        instruction = inst_dict.get("en") or inst_dict.get("lt", "")
-
-        full_description = description
-        if instruction:
-            full_description += f"\n\nRecommendations: {instruction}"
+        instruction = inst_dict.get("en") or inst_dict.get("lt", "") or None
 
-        return WeatherWarning(
+        return MeteoWarning(
             county=county,
             warning_type=warning_type,
             severity=severity,
-            description=full_description,
+            description=description,
+            category=self.category,
             start_time=alert.get("t_from"),
             end_time=alert.get("t_to"),
+            instruction=instruction,
         )
 
-    def _warning_affects_area(self, warning: WeatherWarning, administrative_division: str) -> bool:
+    def _warning_affects_area(self, warning: MeteoWarning, administrative_division: str) -> bool:
         """Check if warning affects specified administrative division"""
         admin_lower = administrative_division.lower().replace(" savivaldybė", "").replace(" sav.", "")
 
@@ -99,22 +108,31 @@ class WeatherWarningsProcessor:
 
         return False
 
-    def enrich_forecast_with_warnings(self, forecast: Forecast, warnings: List[WeatherWarning]) -> None:
-        """Enrich forecast timestamps with relevant weather warnings"""
+    def enrich_forecast_with_warnings(self, forecast: Forecast, warnings: List[MeteoWarning]) -> None:
+        """Enrich forecast timestamps with relevant warnings
+
+        All warnings (weather and hydro) are added to 'warnings' attribute
+        """
         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)
+            # Initialize warnings list if it doesn't exist
+            if not hasattr(timestamp, "warnings"):
+                timestamp.warnings = []
+            # Get warnings for this timestamp and extend the list
+            applicable_warnings = self._get_warnings_for_timestamp(timestamp.datetime, warnings)
+            timestamp.warnings.extend(applicable_warnings)
 
         # Also add warnings to current conditions if available
         if hasattr(forecast, "current_conditions") and forecast.current_conditions:
-            forecast.current_conditions.warnings = self._get_warnings_for_timestamp(
-                forecast.current_conditions.datetime, warnings
-            )
+            if not hasattr(forecast.current_conditions, "warnings"):
+                forecast.current_conditions.warnings = []
+            applicable_warnings = self._get_warnings_for_timestamp(forecast.current_conditions.datetime, warnings)
+            forecast.current_conditions.warnings.extend(applicable_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[MeteoWarning]) -> List[MeteoWarning]:
         """Get warnings that are active for a specific timestamp"""
         try:
             timestamp = datetime.fromisoformat(timestamp_str).replace(tzinfo=timezone.utc)

{meteo_lt_pkg-0.5.1.dist-info → meteo_lt_pkg-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meteo_lt-pkg
-Version: 0.5.1
+Version: 0.5.3
 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
@@ -212,6 +212,8 @@ async def fetch_warnings():
             print(f"Warning: {warning.warning_type} in {warning.county}")
             print(f"Severity: {warning.severity}")
             print(f"Description: {warning.description}")
+            if warning.instruction:
+                print(f"Instruction: {warning.instruction}")
             print(f"Active: {warning.start_time} to {warning.end_time}")
             print("-" * 50)
 
@@ -228,6 +230,70 @@ asyncio.run(fetch_warnings())
 asyncio.run(fetch_warnings_for_area())
 ```
 
+### Fetching Hydrological Warnings
+
+To get hydrological warnings (water-related warnings like floods, high water levels):
+
+```python
+async def fetch_hydro_warnings():
+    async with MeteoLtAPI() as api:
+        # Get all hydrological warnings
+        hydro_warnings = await api.get_hydro_warnings()
+        print(f"Total active hydro warnings: {len(hydro_warnings)}")
+
+        for warning in hydro_warnings:
+            print(f"Hydro Warning: {warning.warning_type} in {warning.county}")
+            print(f"Severity: {warning.severity}")
+            print(f"Description: {warning.description}")
+            if warning.instruction:
+                print(f"Instruction: {warning.instruction}")
+            print("-" * 50)
+
+async def fetch_hydro_warnings_for_area():
+    async with MeteoLtAPI() as api:
+        # Get hydro warnings for specific administrative division
+        warnings = await api.get_hydro_warnings("Vilniaus miesto")
+        print(f"Hydro warnings for Vilnius: {len(warnings)}")
+
+asyncio.run(fetch_hydro_warnings())
+asyncio.run(fetch_hydro_warnings_for_area())
+```
+
+### Fetching All Warnings (Weather + Hydrological)
+
+To get both weather and hydrological warnings combined:
+
+```python
+async def fetch_all_warnings():
+    async with MeteoLtAPI() as api:
+        # Get all warnings (weather + hydrological)
+        all_warnings = await api.get_all_warnings()
+        print(f"Total active warnings (all types): {len(all_warnings)}")
+
+        for warning in all_warnings:
+            print(f"{warning.warning_type} in {warning.county}")
+            print(f"Severity: {warning.severity}")
+            print(f"Description: {warning.description}")
+            if warning.instruction:
+                print(f"Instruction: {warning.instruction}")
+            print("-" * 50)
+
+async def fetch_all_warnings_for_area():
+    async with MeteoLtAPI() as api:
+        # Get all warnings for specific administrative division
+        warnings = await api.get_all_warnings("Vilniaus miesto")
+        print(f"All warnings for Vilnius: {len(warnings)}")
+
+        # Separate by type if needed
+        weather_count = sum(1 for w in warnings if w.category == "weather")
+        hydro_count = sum(1 for w in warnings if w.category == "hydro")
+        print(f"  Weather warnings: {weather_count}")
+        print(f"  Hydro warnings: {hydro_count}")
+
+asyncio.run(fetch_all_warnings())
+asyncio.run(fetch_all_warnings_for_area())
+```
+
 ## Data Models
 
 The package includes several data models to represent the API responses:
@@ -250,8 +316,15 @@ Represents a place with associated metadata.
 ```python
 from meteo_lt import Place
 
-place = Place(code="vilnius", name="Vilnius", administrative_division="Vilnius City Municipality", country="LT", coordinates=coords)
+place = Place(
+    code="vilnius",
+    name="Vilnius",
+    administrative_division="Vilniaus miesto",
+    country_code="LT",
+    coordinates=coords
+)
 print(place.latitude, place.longitude)
+print(place.counties)  # List of counties this place belongs to
 ```
 
 ### ForecastTimestamp
@@ -274,7 +347,10 @@ forecast_timestamp = ForecastTimestamp(
     humidity=60,
     precipitation=0
 )
-print(forecast_timestamp.condition)
+print(f"Temperature: {forecast_timestamp.temperature}°C")
+print(f"Condition: {forecast_timestamp.condition_code}")
+# Warnings list is automatically populated when using get_forecast_with_warnings()
+print(f"Warnings: {len(forecast_timestamp.warnings)}")
 ```
 
 ### Forecast
@@ -286,28 +362,50 @@ from meteo_lt import Forecast
 
 forecast = Forecast(
     place=place,
-    forecast_created=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+    forecast_created="2024-07-23T12:00:00+00:00",
+    current_conditions=forecast_timestamp,
     forecast_timestamps=[forecast_timestamp]
 )
-print(forecast.current_conditions().temperature)
+# current_conditions is automatically set to the current hour's forecast
+print(f"Current temperature: {forecast.current_conditions.temperature}°C")
+# forecast_timestamps are automatically filtered to exclude past hours
+print(f"Future forecasts: {len(forecast.forecast_timestamps)}")
 ```
 
-### WeatherWarning
+### MeteoWarning
 
-Represents a weather warning for a specific area.
+Represents a meteorological warning (weather or hydrological) for a specific area.
 
 ```python
-from meteo_lt import WeatherWarning
+from meteo_lt import MeteoWarning
 
-warning = WeatherWarning(
+# Weather warning example
+weather_warning = MeteoWarning(
     county="Vilniaus apskritis",
     warning_type="frost",
     severity="Moderate",
     description="Ground surface frost 0-5 degrees in many places",
+    instruction="Protect sensitive plants and be cautious on roads",  # Optional safety instruction
+    category="weather",
     start_time="2024-07-23T12:00:00Z",
     end_time="2024-07-23T18:00:00Z"
 )
-print(f"Warning for {warning.county}: {warning.description}")
+print(f"Warning for {weather_warning.county}: {weather_warning.description}")
+if weather_warning.instruction:
+    print(f"Safety instruction: {weather_warning.instruction}")
+print(f"Category: {weather_warning.category}")  # "weather" or "hydro"
+
+# Hydrological warning example
+hydro_warning = MeteoWarning(
+    county="Kauno apskritis",
+    warning_type="flood",
+    severity="High",
+    description="High water levels expected",
+    instruction="Avoid low-lying areas and do not attempt to cross flooded roads",  # Optional
+    category="hydro",
+    start_time="2024-07-23T12:00:00Z",
+    end_time="2024-07-24T12:00:00Z"
+)
 ```
 
 ### HydroStation
@@ -370,7 +468,7 @@ To get the list of all hydrological stations:
 ```python
 async def fetch_hydro_stations():
     async with MeteoLtAPI() as api:
-        stations = await api.get_hydro_stations()
+        stations = await api.fetch_hydro_stations()
         for station in stations:
             print(f"{station.name} ({station.code}) - Water body: {station.water_body}")
 

meteo_lt_pkg-0.5.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+meteo_lt/__init__.py,sha256=3Ef5fihtzaxsRcygINTnNdQI9W_9JULe6ycyeRw8bN8,452
+meteo_lt/api.py,sha256=GQDhDnTj3cx1hokt5188NnGz8FVDJHJDJXGm_fXxop8,5069
+meteo_lt/client.py,sha256=R4lfX9_m-x7Va7IcU6d3rxAE0plOg2gD4NJ9gqtIVvg,5189
+meteo_lt/const.py,sha256=w0eEOss0YbTJzNdpfocrd5DZ7pFSwR3aQ-uMfNttvag,2791
+meteo_lt/models.py,sha256=ENQmWFZMQmXhHIddoAuC7givYbXIlu58v_pI8iACR4o,6143
+meteo_lt/utils.py,sha256=VhXWnqfeBdKrncrsIrSwzsiN3Sg4-kDG5v6Yz-PBOLc,1281
+meteo_lt/warnings.py,sha256=aD28RAlD-6vQdnJHNNkDBW3QkP23Dt0mgJ97A3iWRqo,7101
+meteo_lt_pkg-0.5.3.dist-info/licenses/LICENSE,sha256=3IGi6xn6NUdXGvcdwD0MUbhy3Yz5NRnUjJrwKanFAD4,1073
+meteo_lt_pkg-0.5.3.dist-info/METADATA,sha256=vmWdE8zOaWpCtTWRpKOBvPojy6Ru3RThzzjTqC55ZE4,18261
+meteo_lt_pkg-0.5.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+meteo_lt_pkg-0.5.3.dist-info/top_level.txt,sha256=-aEdc9FzHhcIH4_0TNdKNxuvDnS3chKoJy6LK9Ud-G4,9
+meteo_lt_pkg-0.5.3.dist-info/RECORD,,

meteo_lt_pkg-0.5.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-meteo_lt/__init__.py,sha256=HRQ5O9YMn6h2bXkhx6yuPF6voo6SiUZDrY8RZFeLaks,456
-meteo_lt/api.py,sha256=TJrtP2ScPhT30QR9rHs2NzPibQgbkppMDrPh9JiyBoU,4086
-meteo_lt/client.py,sha256=ubo4-jeIi_829xMhng_8hvPkO24UF1ZioGhu3bIIib8,5200
-meteo_lt/const.py,sha256=Mz_8F5k_dVQlGNdYdGQOXqaEye4G5Z0xoBw971O8vBM,2690
-meteo_lt/models.py,sha256=dWgYBwnvFPN6DjavlB4uD9kSCL7gcnw7CG-rUbz6z7w,6000
-meteo_lt/utils.py,sha256=VhXWnqfeBdKrncrsIrSwzsiN3Sg4-kDG5v6Yz-PBOLc,1281
-meteo_lt/warnings.py,sha256=6wYzinhBzXC3apR38LSEGPwsxiVTrVgLvDWql9-w0B0,6141
-meteo_lt_pkg-0.5.1.dist-info/licenses/LICENSE,sha256=3IGi6xn6NUdXGvcdwD0MUbhy3Yz5NRnUjJrwKanFAD4,1073
-meteo_lt_pkg-0.5.1.dist-info/METADATA,sha256=-5Qzyg9aX-QP8TVeZSaZrZpHb_ufYriz8_j-vaHiZzg,14432
-meteo_lt_pkg-0.5.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-meteo_lt_pkg-0.5.1.dist-info/top_level.txt,sha256=-aEdc9FzHhcIH4_0TNdKNxuvDnS3chKoJy6LK9Ud-G4,9
-meteo_lt_pkg-0.5.1.dist-info/RECORD,,