meteo-lt-pkg 0.5.0b0__tar.gz → 0.5.2__tar.gz

{meteo_lt_pkg-0.5.0b0/meteo_lt_pkg.egg-info → meteo_lt_pkg-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meteo_lt-pkg
-Version: 0.5.0b0
+Version: 0.5.2
 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
@@ -228,6 +228,66 @@ 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}")
+            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}")
+            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 +310,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 +341,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 +356,176 @@ 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",
+    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}")
+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",
+    category="hydro",
+    start_time="2024-07-23T12:00:00Z",
+    end_time="2024-07-24T12:00:00Z"
+)
+```
+
+### HydroStation
+
+Represents a hydrological observation station with water body information.
+
+```python
+from meteo_lt import HydroStation
+
+station = HydroStation(
+    code="klaipedos-juru-uosto-vms",
+    name="Klaipėdos jūrų uosto VMS",
+    water_body="Baltijos jūra",
+    coordinates=coords
+)
+print(f"Station: {station.name} on {station.water_body}")
+```
+
+### HydroObservation
+
+Represents a single hydrological observation with water measurements.
+
+```python
+from meteo_lt import HydroObservation
+
+observation = HydroObservation(
+    observation_datetime="2024-07-23T12:00:00+00:00",
+    water_level=481.8,
+    water_temperature=15.5,
+    water_discharge=100.0
+)
+print(f"Water level: {observation.water_level} cm")
+print(f"Water temperature: {observation.water_temperature}°C")
+```
+
+### HydroObservationData
+
+Represents a collection of hydrological observations for a specific station.
+
+```python
+from meteo_lt import HydroObservationData
+
+data = HydroObservationData(
+    station=station,
+    observations=[observation],
+    observations_data_range={"from": "2024-07-01", "to": "2024-07-23"}
+)
+print(f"Station: {data.station.name}")
+print(f"Observations: {len(data.observations)}")
+```
+
+## Hydrological Data
+
+The package provides access to hydrological data from Lithuanian water monitoring stations.
+
+### Fetching Hydrological Stations
+
+To get the list of all hydrological stations:
+
+```python
+async def fetch_hydro_stations():
+    async with MeteoLtAPI() as api:
+        stations = await api.fetch_hydro_stations()
+        for station in stations:
+            print(f"{station.name} ({station.code}) - Water body: {station.water_body}")
+
+asyncio.run(fetch_hydro_stations())
+```
+
+### Finding the Nearest Hydrological Station
+
+You can find the nearest hydrological station using coordinates:
+
+```python
+async def find_nearest_hydro_station():
+    async with MeteoLtAPI() as api:
+        # Example coordinates for Klaipėda, Lithuania
+        nearest_station = await api.get_nearest_hydro_station(55.6872, 21.2797)
+        print(f"Nearest station: {nearest_station.name}")
+        print(f"Water body: {nearest_station.water_body}")
+        print(f"Distance: approximately {nearest_station.latitude}, {nearest_station.longitude}")
+
+asyncio.run(find_nearest_hydro_station())
+```
+
+### Fetching Hydrological Observations
+
+To get water level and temperature observations for a specific station:
+
+```python
+async def fetch_hydro_observations():
+    async with MeteoLtAPI() as api:
+        # Get observations for a station
+        hydro_data = await api.get_hydro_observation_data("klaipedos-juru-uosto-vms")
+
+        print(f"Station: {hydro_data.station.name}")
+        print(f"Water body: {hydro_data.station.water_body}")
+        print(f"\nRecent observations:")
+
+        for observation in hydro_data.observations[:5]:
+            print(f"  {observation.observation_datetime}")
+            print(f"    Water level: {observation.water_level} cm")
+            print(f"    Water temperature: {observation.water_temperature}°C")
+            if observation.water_discharge:
+                print(f"    Water discharge: {observation.water_discharge} m³/s")
+
+asyncio.run(fetch_hydro_observations())
+```
+
+### Getting Observations for Nearest Station
+
+Combine location finding with observation fetching:
+
+```python
+async def get_nearest_station_observations():
+    async with MeteoLtAPI() as api:
+        # Find nearest hydro station to coordinates
+        nearest_station = await api.get_nearest_hydro_station(55.6872, 21.2797)
+
+        # Get observations for the nearest station
+        hydro_data = await api.get_hydro_observation_data(nearest_station.code)
+
+        print(f"Latest observations from {hydro_data.station.name}:")
+        if hydro_data.observations:
+            latest = hydro_data.observations[0]
+            print(f"  Time: {latest.observation_datetime}")
+            print(f"  Water level: {latest.water_level} cm")
+            print(f"  Temperature: {latest.water_temperature}°C")
+
+asyncio.run(get_nearest_station_observations())
 ```
 
 ## Contributing

{meteo_lt_pkg-0.5.0b0 → meteo_lt_pkg-0.5.2}/README.md

@@ -201,6 +201,66 @@ 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}")
+            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}")
+            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:
@@ -223,8 +283,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
@@ -247,7 +314,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
@@ -259,28 +329,176 @@ 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",
+    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}")
+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",
+    category="hydro",
+    start_time="2024-07-23T12:00:00Z",
+    end_time="2024-07-24T12:00:00Z"
+)
+```
+
+### HydroStation
+
+Represents a hydrological observation station with water body information.
+
+```python
+from meteo_lt import HydroStation
+
+station = HydroStation(
+    code="klaipedos-juru-uosto-vms",
+    name="Klaipėdos jūrų uosto VMS",
+    water_body="Baltijos jūra",
+    coordinates=coords
+)
+print(f"Station: {station.name} on {station.water_body}")
+```
+
+### HydroObservation
+
+Represents a single hydrological observation with water measurements.
+
+```python
+from meteo_lt import HydroObservation
+
+observation = HydroObservation(
+    observation_datetime="2024-07-23T12:00:00+00:00",
+    water_level=481.8,
+    water_temperature=15.5,
+    water_discharge=100.0
+)
+print(f"Water level: {observation.water_level} cm")
+print(f"Water temperature: {observation.water_temperature}°C")
+```
+
+### HydroObservationData
+
+Represents a collection of hydrological observations for a specific station.
+
+```python
+from meteo_lt import HydroObservationData
+
+data = HydroObservationData(
+    station=station,
+    observations=[observation],
+    observations_data_range={"from": "2024-07-01", "to": "2024-07-23"}
+)
+print(f"Station: {data.station.name}")
+print(f"Observations: {len(data.observations)}")
+```
+
+## Hydrological Data
+
+The package provides access to hydrological data from Lithuanian water monitoring stations.
+
+### Fetching Hydrological Stations
+
+To get the list of all hydrological stations:
+
+```python
+async def fetch_hydro_stations():
+    async with MeteoLtAPI() as api:
+        stations = await api.fetch_hydro_stations()
+        for station in stations:
+            print(f"{station.name} ({station.code}) - Water body: {station.water_body}")
+
+asyncio.run(fetch_hydro_stations())
+```
+
+### Finding the Nearest Hydrological Station
+
+You can find the nearest hydrological station using coordinates:
+
+```python
+async def find_nearest_hydro_station():
+    async with MeteoLtAPI() as api:
+        # Example coordinates for Klaipėda, Lithuania
+        nearest_station = await api.get_nearest_hydro_station(55.6872, 21.2797)
+        print(f"Nearest station: {nearest_station.name}")
+        print(f"Water body: {nearest_station.water_body}")
+        print(f"Distance: approximately {nearest_station.latitude}, {nearest_station.longitude}")
+
+asyncio.run(find_nearest_hydro_station())
+```
+
+### Fetching Hydrological Observations
+
+To get water level and temperature observations for a specific station:
+
+```python
+async def fetch_hydro_observations():
+    async with MeteoLtAPI() as api:
+        # Get observations for a station
+        hydro_data = await api.get_hydro_observation_data("klaipedos-juru-uosto-vms")
+
+        print(f"Station: {hydro_data.station.name}")
+        print(f"Water body: {hydro_data.station.water_body}")
+        print(f"\nRecent observations:")
+
+        for observation in hydro_data.observations[:5]:
+            print(f"  {observation.observation_datetime}")
+            print(f"    Water level: {observation.water_level} cm")
+            print(f"    Water temperature: {observation.water_temperature}°C")
+            if observation.water_discharge:
+                print(f"    Water discharge: {observation.water_discharge} m³/s")
+
+asyncio.run(fetch_hydro_observations())
+```
+
+### Getting Observations for Nearest Station
+
+Combine location finding with observation fetching:
+
+```python
+async def get_nearest_station_observations():
+    async with MeteoLtAPI() as api:
+        # Find nearest hydro station to coordinates
+        nearest_station = await api.get_nearest_hydro_station(55.6872, 21.2797)
+
+        # Get observations for the nearest station
+        hydro_data = await api.get_hydro_observation_data(nearest_station.code)
+
+        print(f"Latest observations from {hydro_data.station.name}:")
+        if hydro_data.observations:
+            latest = hydro_data.observations[0]
+            print(f"  Time: {latest.observation_datetime}")
+            print(f"  Water level: {latest.water_level} cm")
+            print(f"  Temperature: {latest.water_temperature}°C")
+
+asyncio.run(get_nearest_station_observations())
 ```
 
 ## Contributing

{meteo_lt_pkg-0.5.0b0 → meteo_lt_pkg-0.5.2}/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_pkg-0.5.0b0 → meteo_lt_pkg-0.5.2}/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_pkg-0.5.0b0 → meteo_lt_pkg-0.5.2}/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:
@@ -93,35 +93,23 @@ class MeteoLtClient:
         session = await self._get_session()
         async with session.get(f"{BASE_URL}/hydro-stations") as resp:
             if resp.status == 200:
+                resp.encoding = ENCODING
                 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", {}),
-                        )
-                    )
+                    stations.append(HydroStation.from_dict(station_data))
                 return stations
-            else:
-                raise Exception(f"API returned status {resp.status}")
+            raise aiohttp.ClientError(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:
+                resp.encoding = ENCODING
                 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}")
+                return HydroStation.from_dict(response)
+            raise aiohttp.ClientError(f"API returned status {resp.status}")
 
     async def fetch_hydro_observation_data(
         self,
@@ -136,28 +124,15 @@ class MeteoLtClient:
         ) 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", {}),
-                )
+                station = HydroStation.from_dict(response.get("station"))
 
                 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"),
-                        )
-                    )
+                    observations.append(HydroObservation.from_dict(obs_data))
 
                 return HydroObservationData(
                     station=station,
                     observations_data_range=response.get("observationsDataRange"),
                     observations=observations,
                 )
-            else:
-                raise Exception(f"API returned status {resp.status}")
+            raise aiohttp.ClientError(f"API returned status {resp.status}")

{meteo_lt_pkg-0.5.0b0 → meteo_lt_pkg-0.5.2}/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_pkg-0.5.0b0 → meteo_lt_pkg-0.5.2}/meteo_lt/models.py

@@ -50,13 +50,14 @@ 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
 
@@ -65,17 +66,17 @@ class WeatherWarning:
 class HydroStation(LocationBase):
     """Hydrological station data."""
 
-    water_body: str
+    water_body: str = field(metadata={"json_key": "waterBody"})
 
 
 @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
+    observation_datetime: Optional[str] = field(default=None, metadata={"json_key": "observationTimeUtc"})
+    water_level: Optional[float] = field(default=None, metadata={"json_key": "waterLevel"})  # cm
+    water_temperature: Optional[float] = field(default=None, metadata={"json_key": "waterTemperature"})  # °C
+    water_discharge: Optional[float] = field(default=None, metadata={"json_key": "waterDischarge"})  # m3/s
 
 
 @dataclass
@@ -83,7 +84,7 @@ class HydroObservationData:
     """Observation data response."""
 
     station: HydroStation
-    observations_data_range: Optional[dict] = None
+    observations_data_range: Optional[dict] = field(default=None, metadata={"json_key": "observationsDataRange"})
     observations: List[HydroObservation] = field(default_factory=list)
 
 
@@ -102,7 +103,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 +170,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_pkg-0.5.0b0 → meteo_lt_pkg-0.5.2}/meteo_lt/utils.py

@@ -1,9 +1,8 @@
 """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
+from typing import List
+from meteo_lt.models import LocationBase
 
 
 def haversine(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
@@ -20,7 +19,7 @@ def haversine(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
     return r * c
 
 
-def find_nearest_location(latitude: float, longitude: float, locations: List[LocationT]) -> LocationT:
+def find_nearest_location(latitude: float, longitude: float, locations: List[LocationBase]) -> LocationBase:
     """Find the nearest location from a list of locations based on the given latitude and longitude."""
     nearest_location = None
     min_distance = float("inf")

{meteo_lt_pkg-0.5.0b0 → meteo_lt_pkg-0.5.2}/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 List, Optional, Dict, Any, Literal
 
-from .models import Forecast, WeatherWarning
-from .const import COUNTY_MUNICIPALITIES
+from .models import Forecast, MeteoWarning
+from .const import COUNTY_MUNICIPALITIES, WARNINGS_URL, HYDRO_WARNINGS_URL
 from .client import MeteoLtClient
 
+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")
@@ -72,16 +83,17 @@ class WeatherWarningsProcessor:
         if instruction:
             full_description += f"\n\nRecommendations: {instruction}"
 
-        return WeatherWarning(
+        return MeteoWarning(
             county=county,
             warning_type=warning_type,
             severity=severity,
             description=full_description,
+            category=self.category,
             start_time=alert.get("t_from"),
             end_time=alert.get("t_to"),
         )
 
-    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 +111,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.0b0 → meteo_lt_pkg-0.5.2/meteo_lt_pkg.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meteo_lt-pkg
-Version: 0.5.0b0
+Version: 0.5.2
 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
@@ -228,6 +228,66 @@ 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}")
+            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}")
+            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 +310,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 +341,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 +356,176 @@ 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",
+    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}")
+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",
+    category="hydro",
+    start_time="2024-07-23T12:00:00Z",
+    end_time="2024-07-24T12:00:00Z"
+)
+```
+
+### HydroStation
+
+Represents a hydrological observation station with water body information.
+
+```python
+from meteo_lt import HydroStation
+
+station = HydroStation(
+    code="klaipedos-juru-uosto-vms",
+    name="Klaipėdos jūrų uosto VMS",
+    water_body="Baltijos jūra",
+    coordinates=coords
+)
+print(f"Station: {station.name} on {station.water_body}")
+```
+
+### HydroObservation
+
+Represents a single hydrological observation with water measurements.
+
+```python
+from meteo_lt import HydroObservation
+
+observation = HydroObservation(
+    observation_datetime="2024-07-23T12:00:00+00:00",
+    water_level=481.8,
+    water_temperature=15.5,
+    water_discharge=100.0
+)
+print(f"Water level: {observation.water_level} cm")
+print(f"Water temperature: {observation.water_temperature}°C")
+```
+
+### HydroObservationData
+
+Represents a collection of hydrological observations for a specific station.
+
+```python
+from meteo_lt import HydroObservationData
+
+data = HydroObservationData(
+    station=station,
+    observations=[observation],
+    observations_data_range={"from": "2024-07-01", "to": "2024-07-23"}
+)
+print(f"Station: {data.station.name}")
+print(f"Observations: {len(data.observations)}")
+```
+
+## Hydrological Data
+
+The package provides access to hydrological data from Lithuanian water monitoring stations.
+
+### Fetching Hydrological Stations
+
+To get the list of all hydrological stations:
+
+```python
+async def fetch_hydro_stations():
+    async with MeteoLtAPI() as api:
+        stations = await api.fetch_hydro_stations()
+        for station in stations:
+            print(f"{station.name} ({station.code}) - Water body: {station.water_body}")
+
+asyncio.run(fetch_hydro_stations())
+```
+
+### Finding the Nearest Hydrological Station
+
+You can find the nearest hydrological station using coordinates:
+
+```python
+async def find_nearest_hydro_station():
+    async with MeteoLtAPI() as api:
+        # Example coordinates for Klaipėda, Lithuania
+        nearest_station = await api.get_nearest_hydro_station(55.6872, 21.2797)
+        print(f"Nearest station: {nearest_station.name}")
+        print(f"Water body: {nearest_station.water_body}")
+        print(f"Distance: approximately {nearest_station.latitude}, {nearest_station.longitude}")
+
+asyncio.run(find_nearest_hydro_station())
+```
+
+### Fetching Hydrological Observations
+
+To get water level and temperature observations for a specific station:
+
+```python
+async def fetch_hydro_observations():
+    async with MeteoLtAPI() as api:
+        # Get observations for a station
+        hydro_data = await api.get_hydro_observation_data("klaipedos-juru-uosto-vms")
+
+        print(f"Station: {hydro_data.station.name}")
+        print(f"Water body: {hydro_data.station.water_body}")
+        print(f"\nRecent observations:")
+
+        for observation in hydro_data.observations[:5]:
+            print(f"  {observation.observation_datetime}")
+            print(f"    Water level: {observation.water_level} cm")
+            print(f"    Water temperature: {observation.water_temperature}°C")
+            if observation.water_discharge:
+                print(f"    Water discharge: {observation.water_discharge} m³/s")
+
+asyncio.run(fetch_hydro_observations())
+```
+
+### Getting Observations for Nearest Station
+
+Combine location finding with observation fetching:
+
+```python
+async def get_nearest_station_observations():
+    async with MeteoLtAPI() as api:
+        # Find nearest hydro station to coordinates
+        nearest_station = await api.get_nearest_hydro_station(55.6872, 21.2797)
+
+        # Get observations for the nearest station
+        hydro_data = await api.get_hydro_observation_data(nearest_station.code)
+
+        print(f"Latest observations from {hydro_data.station.name}:")
+        if hydro_data.observations:
+            latest = hydro_data.observations[0]
+            print(f"  Time: {latest.observation_datetime}")
+            print(f"  Water level: {latest.water_level} cm")
+            print(f"  Temperature: {latest.water_temperature}°C")
+
+asyncio.run(get_nearest_station_observations())
 ```
 
 ## Contributing

{meteo_lt_pkg-0.5.0b0 → meteo_lt_pkg-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "meteo_lt-pkg"
-version = "0.5.0-beta"
+version = "0.5.2"
 authors = [
   { name="Brunas", email="brunonas@gmail.com" },
 ]