meteo-lt-pkg 0.2.4__py3-none-any.whl → 0.4.0b1__py3-none-any.whl

meteo_lt/__init__.py

@@ -1,6 +1,13 @@
 """init.py"""
 
 from .api import MeteoLtAPI
-from .models import Coordinates, Place, ForecastTimestamp, Forecast
+from .models import Coordinates, Place, ForecastTimestamp, Forecast, WeatherWarning
 
-__all__ = ["MeteoLtAPI", "Coordinates", "Place", "ForecastTimestamp", "Forecast"]
+__all__ = [
+    "MeteoLtAPI",
+    "Coordinates",
+    "Place",
+    "ForecastTimestamp",
+    "Forecast",
+    "WeatherWarning",
+]

meteo_lt/api.py

@@ -1,31 +1,39 @@
 """Main API class script"""
 
-import aiohttp
+# pylint: disable=W0718
 
-from .models import Place, Forecast
+from typing import List
+
+from .models import Forecast, WeatherWarning
 from .utils import find_nearest_place
+from .client import MeteoLtClient
+from .warnings import WeatherWarningsProcessor
 
 
 class MeteoLtAPI:
-    """Main API class"""
-
-    BASE_URL = "https://api.meteo.lt/v1"
-    TIMEOUT = 30
-    ENCODING = "utf-8"
+    """Main API class that orchestrates external API calls and warning processing"""
 
-    def __init__(self):
+    def __init__(self, session=None):
         self.places = []
+        self.client = MeteoLtClient(session)
+        self.warnings_processor = WeatherWarningsProcessor(self.client)
+
+    async def __aenter__(self):
+        """Async context manager entry"""
+        await self.client.__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit"""
+        await self.client.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def close(self):
+        """Close the API client and cleanup resources"""
+        await self.client.close()
 
     async def fetch_places(self):
         """Gets all places from API"""
-        async with aiohttp.ClientSession(
-            timeout=aiohttp.ClientTimeout(total=self.TIMEOUT)
-        ) as session:
-            async with session.get(f"{self.BASE_URL}/places") as response:
-                response.raise_for_status()
-                response.encoding = self.ENCODING
-                response_json = await response.json()
-                self.places = [Place.from_dict(place) for place in response_json]
+        self.places = await self.client.fetch_places()
 
     async def get_nearest_place(self, latitude, longitude):
         """Finds nearest place using provided coordinates"""
@@ -33,15 +41,54 @@ class MeteoLtAPI:
             await self.fetch_places()
         return find_nearest_place(latitude, longitude, self.places)
 
-    async def get_forecast(self, place_code):
+    async def get_forecast_with_warnings(
+        self, latitude=None, longitude=None, place_code=None
+    ):
+        """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"
+                )
+            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):
         """Retrieves forecast data from API"""
-        async with aiohttp.ClientSession(
-            timeout=aiohttp.ClientTimeout(total=self.TIMEOUT)
-        ) as session:
-            async with session.get(
-                f"{self.BASE_URL}/places/{place_code}/forecasts/long-term"
-            ) as response:
-                response.raise_for_status()
-                response.encoding = self.ENCODING
-                response_json = await response.json()
-                return Forecast.from_dict(response_json)
+        forecast = await self.client.fetch_forecast(place_code)
+
+        if include_warnings:
+            await self._enrich_forecast_with_warnings(forecast)
+
+        return forecast
+
+    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
+        )
+
+    async def _enrich_forecast_with_warnings(self, forecast: Forecast):
+        """Enrich forecast timestamps with relevant weather warnings"""
+        if (
+            not forecast
+            or not forecast.place
+            or not forecast.place.administrative_division
+        ):
+            return
+
+        try:
+            warnings = await self.get_weather_warnings(
+                forecast.place.administrative_division
+            )
+
+            if warnings:
+                self.warnings_processor.enrich_forecast_with_warnings(
+                    forecast, warnings
+                )
+        except Exception as e:
+            print(f"Warning: Could not fetch weather warnings: {e}")

meteo_lt/client.py

@@ -0,0 +1,80 @@
+"""MeteoLt API client for external API calls"""
+
+import json
+from typing import List, Optional
+
+import aiohttp
+
+from .models import Place, Forecast
+from .const import BASE_URL, WARNINGS_URL, TIMEOUT, ENCODING
+
+
+class MeteoLtClient:
+    """Client for external API calls to meteo.lt"""
+
+    def __init__(self, session: Optional[aiohttp.ClientSession] = None):
+        self._session = session
+        self._owns_session = session is None
+
+    async def __aenter__(self):
+        """Async context manager entry"""
+        if self._session is None:
+            self._session = aiohttp.ClientSession(
+                timeout=aiohttp.ClientTimeout(total=TIMEOUT),
+                raise_for_status=True,
+            )
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit"""
+        await self.close()
+
+    async def close(self):
+        """Close the client session if we own it"""
+        if self._session and self._owns_session:
+            await self._session.close()
+            self._session = None
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        """Get or create a session"""
+        if self._session is None:
+            self._session = aiohttp.ClientSession(
+                timeout=aiohttp.ClientTimeout(total=TIMEOUT),
+                raise_for_status=True,
+            )
+        return self._session
+
+    async def fetch_places(self) -> List[Place]:
+        """Gets all places from API"""
+        session = await self._get_session()
+        async with session.get(f"{BASE_URL}/places") as response:
+            response.encoding = ENCODING
+            response_json = await response.json()
+            return [Place.from_dict(place) for place in response_json]
+
+    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:
+            response.encoding = ENCODING
+            response_json = await response.json()
+            return Forecast.from_dict(response_json)
+
+    async def fetch_weather_warnings(self) -> List[dict]:
+        """Fetches raw weather 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:
+            file_list = await response.json()
+
+        if not file_list:
+            return []
+
+        # Fetch the latest warnings data
+        latest_file_url = file_list[0]  # First file is the most recent
+        async with session.get(latest_file_url) as response:
+            text_data = await response.text()
+            return json.loads(text_data)

meteo_lt/const.py

@@ -0,0 +1,108 @@
+"""const.py"""
+
+BASE_URL = "https://api.meteo.lt/v1"
+WARNINGS_URL = (
+    "https://www.meteo.lt/app/mu-plugins/Meteo/Components/"
+    "WeatherWarningsNew/list_JSON.php"
+)
+TIMEOUT = 30
+ENCODING = "utf-8"
+
+# Define the county to administrative divisions mapping
+# https://www.infolex.lt/teise/DocumentSinglePart.aspx?AktoId=125125&StrNr=5#
+COUNTY_MUNICIPALITIES = {
+    "Alytaus apskritis": [
+        "Alytaus miesto",
+        "Alytaus rajono",
+        "Druskininkų",
+        "Lazdijų rajono",
+        "Varėnos rajono",
+    ],
+    "Kauno apskritis": [
+        "Birštono",
+        "Jonavos rajono",
+        "Kaišiadorių rajono",
+        "Kauno miesto",
+        "Kauno rajono",
+        "Kėdainių rajono",
+        "Prienų rajono",
+        "Raseinių rajono",
+    ],
+    "Klaipėdos apskritis": [
+        "Klaipėdos rajono",
+        "Klaipėdos miesto",
+        "Kretingos rajono",
+        "Neringos",
+        "Palangos miesto",
+        "Skuodo rajono",
+        "Šilutės rajono",
+    ],
+    "Marijampolės apskritis": [
+        "Kalvarijos",
+        "Kazlų Rūdos",
+        "Marijampolės",
+        "Šakių rajono",
+        "Vilkaviškio rajono",
+    ],
+    "Panevėžio apskritis": [
+        "Biržų rajono",
+        "Kupiškio rajono",
+        "Panevėžio miesto",
+        "Panevėžio rajono",
+        "Pasvalio rajono",
+        "Rokiškio rajono",
+    ],
+    "Šiaulių apskritis": [
+        "Joniškio rajono",
+        "Kelmės rajono",
+        "Pakruojo rajono",
+        "Akmenės rajono",
+        "Radviliškio rajono",
+        "Šiaulių miesto",
+        "Šiaulių rajono",
+    ],
+    "Tauragės apskritis": [
+        "Jurbarko rajono",
+        "Pagėgių",
+        "Šilalės rajono",
+        "Tauragės rajono",
+    ],
+    "Telšių apskritis": [
+        "Mažeikių rajono",
+        "Plungės rajono",
+        "Rietavo",
+        "Telšių rajono",
+    ],
+    "Utenos apskritis": [
+        "Anykščių rajono",
+        "Ignalinos rajono",
+        "Molėtų rajono",
+        "Utenos rajono",
+        "Visagino",
+        "Zarasų rajono",
+    ],
+    "Vilniaus apskritis": [
+        "Elektrėnų",
+        "Šalčininkų rajono",
+        "Širvintų rajono",
+        "Švenčionių rajono",
+        "Trakų rajono",
+        "Ukmergės rajono",
+        "Vilniaus miesto",
+        "Vilniaus rajono",
+    ],
+}
+
+# Artificial area for Baltic coast and Curonian Lagoon created by meteo.lt
+# Adding separately for better visibility
+COUNTY_MUNICIPALITIES.update(
+    {
+        "Pietryčių Baltija, Kuršių marios": [
+            "Klaipėdos rajono",
+            "Klaipėdos miesto",
+            "Neringos",
+            "Palangos miesto",
+            "Šilutės rajono",
+        ],
+    }
+)

meteo_lt/models.py

@@ -2,7 +2,9 @@
 
 from dataclasses import dataclass, field, fields
 from datetime import datetime, timezone
-from typing import List
+from typing import List, Optional
+
+from .const import COUNTY_MUNICIPALITIES
 
 
 @dataclass
@@ -22,8 +24,9 @@ class Place:
     administrative_division: str = field(
         metadata={"json_key": "administrativeDivision"}
     )
-    country: str
+    country_code: str = field(metadata={"json_key": "countryCode"})
     coordinates: Coordinates
+    counties: List[str] = field(init=False)
 
     @property
     def latitude(self):
@@ -35,6 +38,15 @@ class Place:
         """Longitude from coordinates"""
         return self.coordinates.longitude
 
+    def __post_init__(self):
+        self.counties = []
+        for county, municipalities in COUNTY_MUNICIPALITIES.items():
+            if (
+                self.administrative_division.replace(" savivaldybė", "")
+                in municipalities
+            ):
+                self.counties.append(county)
+
 
 @dataclass
 class ForecastTimestamp:
@@ -51,10 +63,7 @@ class ForecastTimestamp:
     pressure: float = field(metadata={"json_key": "seaLevelPressure"})
     humidity: float = field(metadata={"json_key": "relativeHumidity"})
     precipitation: float = field(metadata={"json_key": "totalPrecipitation"})
-    condition: str = field(init=False)
-
-    def __post_init__(self):
-        self.condition = map_condition(self.condition_code)
+    warnings: List["WeatherWarning"] = field(default_factory=list, init=False)
 
 
 @dataclass
@@ -123,36 +132,20 @@ def from_dict(cls, data: dict):
     return cls(**init_args)
 
 
+@dataclass
+class WeatherWarning:
+    """Weather Warning"""
+
+    county: str
+    warning_type: str
+    severity: str
+    description: str
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+
+
 Coordinates.from_dict = classmethod(from_dict)
 Place.from_dict = classmethod(from_dict)
 ForecastTimestamp.from_dict = classmethod(from_dict)
 Forecast.from_dict = classmethod(from_dict)
-
-
-def map_condition(api_condition):
-    """Condition code mapping"""
-    condition_mapping = {
-        "clear": "sunny",
-        "partly-cloudy": "partlycloudy",
-        "cloudy-with-sunny-intervals": "partlycloudy",
-        "cloudy": "cloudy",
-        "thunder": "lightning",
-        "isolated-thunderstorms": "lightning-rainy",
-        "thunderstorms": "lightning-rainy",
-        "heavy-rain-with-thunderstorms": "lightning-rainy",
-        "light-rain": "rainy",
-        "rain": "rainy",
-        "heavy-rain": "pouring",
-        "light-sleet": "snowy-rainy",
-        "sleet": "snowy-rainy",
-        "freezing-rain": "snowy-rainy",
-        "hail": "hail",
-        "light-snow": "snowy",
-        "snow": "snowy",
-        "heavy-snow": "snowy",
-        "fog": "fog",
-        None: "exceptional",  # For null or undefined conditions
-    }
-
-    # Default to 'exceptional' if the condition is not found in the mapping
-    return condition_mapping.get(api_condition, "exceptional")
+WeatherWarning.from_dict = classmethod(from_dict)

meteo_lt/warnings.py

@@ -0,0 +1,183 @@
+"""Weather warnings processor for handling warning-related logic"""
+
+# pylint: disable=W0718
+
+import re
+from datetime import datetime, timezone
+from typing import List
+
+from .models import Forecast, WeatherWarning
+from .const import COUNTY_MUNICIPALITIES
+from .client import MeteoLtClient
+
+
+class WeatherWarningsProcessor:
+    """Processes weather warnings data and handles warning-related logic"""
+
+    def __init__(self, client: MeteoLtClient):
+        self.client = client
+
+    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)
+            ]
+
+        return warnings
+
+    def _parse_warnings_data(self, warnings_data: dict) -> List[WeatherWarning]:
+        """Parse raw warnings data into WeatherWarning objects"""
+        warnings = []
+
+        # Handle empty response (list instead of dict)
+        if not warnings_data or isinstance(warnings_data, list):
+            return warnings
+
+        # 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":
+                continue
+
+            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"):
+                        continue
+
+                    # Create warnings for each area in the group
+                    for area in area_group.get("areas", []):
+                        warning = self._create_warning_from_alert(alert, area)
+                        if warning:
+                            warnings.append(warning)
+
+        return warnings
+
+    def _create_warning_from_alert(self, alert: dict, area: dict) -> WeatherWarning:
+        """Create a WeatherWarning from alert data"""
+        try:
+            county = area.get("name", "Unknown")
+            phenomenon = alert.get("phenomenon", "")
+            severity = alert.get("severity", "Minor")
+
+            # Clean phenomenon name (remove severity prefixes)
+            warning_type = re.sub(r"^(dangerous|severe|extreme)-", "", phenomenon)
+
+            # Get descriptions and instructions
+            desc_dict = alert.get("description", {})
+            inst_dict = alert.get("instruction", {})
+
+            # Prefer English, fall back to Lithuanian
+            description = desc_dict.get("en") or desc_dict.get("lt", "")
+            instruction = inst_dict.get("en") or inst_dict.get("lt", "")
+
+            # Combine description and instruction
+            full_description = description
+            if instruction:
+                full_description += f"\n\nRecommendations: {instruction}"
+
+            return WeatherWarning(
+                county=county,
+                warning_type=warning_type,
+                severity=severity,
+                description=full_description,
+                start_time=alert.get("t_from"),
+                end_time=alert.get("t_to"),
+            )
+        except Exception as e:
+            print(f"Error creating warning: {e}")
+            return None
+
+    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.", "")
+        )
+
+        # Check if the administrative division matches the warning county
+        if admin_lower in warning.county.lower():
+            return True
+
+        # Check if the administrative division is in the warning's county municipalities
+        if warning.county in COUNTY_MUNICIPALITIES:
+            municipalities = COUNTY_MUNICIPALITIES[warning.county]
+            for municipality in municipalities:
+                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]
+    ):
+        """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
+            )
+
+        # 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
+            )
+
+    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
+            )
+            applicable_warnings = []
+
+            for warning in warnings:
+                if not warning.start_time or not warning.end_time:
+                    continue
+
+                try:
+                    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:
+                        applicable_warnings.append(warning)
+
+                except (ValueError, AttributeError):
+                    # Skip warnings with invalid time formats
+                    continue
+
+            return applicable_warnings
+
+        except (ValueError, AttributeError):
+            # Return empty list if timestamp parsing fails
+            return []

meteo_lt_pkg-0.4.0b1.dist-info/METADATA

@@ -0,0 +1,324 @@
+Metadata-Version: 2.4
+Name: meteo_lt-pkg
+Version: 0.4.0b1
+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
+Project-URL: Issues, https://github.com/Brunas/meteo_lt-pkg/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+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"
+Dynamic: license-file
+
+# Meteo.Lt Lithuanian weather forecast package
+
+[![GitHub Release][releases-shield]][releases]
+[![GitHub Activity][commits-shield]][commits]
+[![License][license-shield]](LICENSE)
+![Project Maintenance][maintenance-shield]
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+<a href="https://buymeacoffee.com/pdfdc52z8h" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 40px !important;width: 145px !important;" ></a>
+
+MeteoLt-Pkg is a Python library designed to fetch weather data from [`api.meteo.lt`](https://api.meteo.lt/). This library provides convenient methods to interact with the API and obtain weather forecasts and related data. Please visit for more information.
+
+## Installation
+
+You can install the package using pip:
+
+```bash
+pip install meteo_lt-pkg
+```
+
+## Quick Start
+
+Here's a quick example to get you started:
+
+```python
+import asyncio
+from meteo_lt import MeteoLtAPI
+
+async def quick_example():
+    async with MeteoLtAPI() as api:
+        # Get current weather for Vilnius
+        forecast = await api.get_forecast("vilnius")
+        current = forecast.current_conditions
+
+        print(f"Current temperature in Vilnius: {current.temperature}°C")
+        print(f"Condition: {current.condition_code}")
+        print(f"Wind: {current.wind_speed} m/s")
+
+        # Check for weather warnings
+        warnings = await api.get_weather_warnings("Vilniaus miesto")
+        if warnings:
+            print(f"Active warnings: {len(warnings)}")
+            for warning in warnings:
+                print(f"   - {warning.warning_type}: {warning.severity}")
+        else:
+            print("No active weather warnings")
+
+asyncio.run(quick_example())
+```
+
+## Usage
+
+### Basic Usage (Recommended)
+
+The recommended way to use the library is with the `async with` context manager, which ensures proper cleanup of HTTP sessions:
+
+```python
+import asyncio
+from meteo_lt import MeteoLtAPI
+
+async def main():
+    async with MeteoLtAPI() as api:
+        # Get weather forecast for Vilnius
+        forecast = await api.get_forecast("vilnius")
+        print(f"Current temperature in {forecast.place.name}: {forecast.current_conditions.temperature}°C")
+
+        # Get weather warnings for Vilnius
+        warnings = await api.get_weather_warnings("Vilniaus miesto")
+        print(f"Active warnings: {len(warnings)}")
+        for warning in warnings:
+            print(f"- {warning.warning_type}: {warning.description}")
+
+asyncio.run(main())
+```
+
+### Alternative Usage
+
+If you prefer not to use the context manager, make sure to call `close()` to properly cleanup resources:
+
+```python
+async def alternative_usage():
+    api = MeteoLtAPI()
+    try:
+        forecast = await api.get_forecast("kaunas")
+        print(f"Temperature: {forecast.current_conditions.temperature}°C")
+    finally:
+        await api.close()  # Important: prevents session warnings
+
+asyncio.run(alternative_usage())
+```
+
+### Fetching Places
+
+To get the list of available places:
+
+```python
+async def fetch_places():
+    async with MeteoLtAPI() as api:
+        await api.fetch_places()
+        for place in api.places:
+            print(f"{place.name} ({place.code})")
+
+asyncio.run(fetch_places())
+```
+
+### Getting the Nearest Place
+
+You can find the nearest place using latitude and longitude coordinates:
+
+```python
+async def find_nearest_place():
+    async with MeteoLtAPI() as api:
+        # Example coordinates for Vilnius, Lithuania
+        nearest_place = await api.get_nearest_place(54.6872, 25.2797)
+        print(f"Nearest place: {nearest_place.name}")
+
+asyncio.run(find_nearest_place())
+```
+
+> **NOTE**: If no places are retrieved before, that is done automatically in `get_nearest_place` method.
+
+### Fetching Weather Forecast
+
+To get the weather forecast for a specific place:
+
+```python
+async def fetch_forecast():
+    async with MeteoLtAPI() as api:
+        # Get forecast for Vilnius
+        forecast = await api.get_forecast("vilnius")
+
+        # Current conditions
+        current = forecast.current_conditions
+        print(f"Current temperature: {current.temperature}°C")
+        print(f"Feels like: {current.apparent_temperature}°C")
+        print(f"Condition: {current.condition_code}")
+
+        # Future forecasts
+        print(f"\nNext 24 hours:")
+        for timestamp in forecast.forecast_timestamps[:24]:
+            print(f"{timestamp.datetime}: {timestamp.temperature}°C")
+
+asyncio.run(fetch_forecast())
+```
+
+> **NOTE**: `current_conditions` is the current hour record from the `forecast_timestamps` array. Also, `forecast_timestamps` array has past time records filtered out due to `api.meteo.lt` not doing that automatically.
+
+### Fetching Weather Forecast with Warnings
+
+To get weather forecast enriched with warnings:
+
+```python
+async def fetch_forecast_with_warnings():
+    async with MeteoLtAPI() as api:
+        # Get forecast with warnings using coordinates
+        forecast = await api.get_forecast_with_warnings(
+            latitude=54.6872,
+            longitude=25.2797
+        )
+
+        print(f"Forecast for {forecast.place.name}")
+        print(f"Current temperature: {forecast.current_conditions.temperature}°C")
+
+        # Check for warnings in current conditions
+        if forecast.current_conditions.warnings:
+            print("Current warnings:")
+            for warning in forecast.current_conditions.warnings:
+                print(f"- {warning.warning_type}: {warning.severity}")
+
+asyncio.run(fetch_forecast_with_warnings())
+```
+
+### Fetching Weather Warnings
+
+To get weather warnings for Lithuania or specific administrative areas:
+
+```python
+async def fetch_warnings():
+    async with MeteoLtAPI() as api:
+        # Get all weather warnings
+        warnings = await api.get_weather_warnings()
+        print(f"Total active warnings: {len(warnings)}")
+
+        for warning in warnings:
+            print(f"Warning: {warning.warning_type} in {warning.county}")
+            print(f"Severity: {warning.severity}")
+            print(f"Description: {warning.description}")
+            print(f"Active: {warning.start_time} to {warning.end_time}")
+            print("-" * 50)
+
+async def fetch_warnings_for_area():
+    async with MeteoLtAPI() as api:
+        # Get warnings for specific administrative division
+        vilnius_warnings = await api.get_weather_warnings("Vilniaus miesto")
+        print(f"Warnings for Vilnius: {len(vilnius_warnings)}")
+
+        for warning in vilnius_warnings:
+            print(f"- {warning.warning_type} ({warning.severity})")
+
+asyncio.run(fetch_warnings())
+asyncio.run(fetch_warnings_for_area())
+```
+
+## Data Models
+
+The package includes several data models to represent the API responses:
+
+### Coordinates
+
+Represents geographic coordinates.
+
+```python
+from meteo_lt import Coordinates
+
+coords = Coordinates(latitude=54.6872, longitude=25.2797)
+print(coords)
+```
+
+### Place
+
+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)
+print(place.latitude, place.longitude)
+```
+
+### ForecastTimestamp
+
+Represents a timestamp within the weather forecast, including various weather parameters.
+
+```python
+from meteo_lt import ForecastTimestamp
+
+forecast_timestamp = ForecastTimestamp(
+    datetime="2024-07-23T12:00:00+00:00",
+    temperature=25.5,
+    apparent_temperature=27.0,
+    condition_code="clear",
+    wind_speed=5.0,
+    wind_gust_speed=8.0,
+    wind_bearing=180,
+    cloud_coverage=20,
+    pressure=1012,
+    humidity=60,
+    precipitation=0
+)
+print(forecast_timestamp.condition)
+```
+
+### Forecast
+
+Represents the weather forecast for a place, containing multiple forecast timestamps.
+
+```python
+from meteo_lt import Forecast
+
+forecast = Forecast(
+    place=place,
+    forecast_created=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+    forecast_timestamps=[forecast_timestamp]
+)
+print(forecast.current_conditions().temperature)
+```
+
+### WeatherWarning
+
+Represents a weather warning for a specific area.
+
+```python
+from meteo_lt import WeatherWarning
+
+warning = WeatherWarning(
+    county="Vilniaus apskritis",
+    warning_type="frost",
+    severity="Moderate",
+    description="Ground surface frost 0-5 degrees in many places",
+    start_time="2024-07-23T12:00:00Z",
+    end_time="2024-07-23T18:00:00Z"
+)
+print(f"Warning for {warning.county}: {warning.description}")
+```
+
+## Contributing
+
+Contributions are welcome! For major changes please open an issue to discuss or submit a pull request with your changes. If you want to contribute you can use devcontainers in vscode for easiest setup follow [instructions here](.devcontainer/README.md).
+
+***
+
+[commits-shield]: https://img.shields.io/github/commit-activity/y/Brunas/meteo_lt-pkg.svg?style=flat-square
+[commits]: https://github.com/Brunas/meteo_lt-pkg/commits/main
+[license-shield]: https://img.shields.io/github/license/Brunas/meteo_lt-pkg.svg?style=flat-square
+[maintenance-shield]: https://img.shields.io/badge/maintainer-Brunas%20%40Brunas-blue.svg?style=flat-square
+[releases-shield]: https://img.shields.io/github/release/Brunas/meteo_lt-pkg.svg?style=flat-square
+[releases]: https://github.com/Brunas/meteo_lt-pkg/releases

meteo_lt_pkg-0.4.0b1.dist-info/RECORD

@@ -0,0 +1,12 @@
+meteo_lt/__init__.py,sha256=TP3DhEXEpHdI6bevRjxb0cbVrEWbI8mEocYc1DwA_KI,255
+meteo_lt/api.py,sha256=ouM8zB51CuJVm3NmT6uuRMJsvuu49fmFMGyFzy3UJyM,3202
+meteo_lt/client.py,sha256=j5F1Ag00EnEI8ErLz0Q2lYqWfO8YgqYlsAHfhzkGyWE,2798
+meteo_lt/const.py,sha256=1xeQ2wErqPREnYfK4OogadlVIu0p2gGoILsOcsIfp8Q,2702
+meteo_lt/models.py,sha256=xLx9DcrXOolED8PPQ2fcu4dNdPA6ykS9c_zherLTCj8,4840
+meteo_lt/utils.py,sha256=SL7ZeTEfdrdQoe_DOJaiA2zVxt08ujyFJ24JxJm1Hks,1081
+meteo_lt/warnings.py,sha256=YthSCVDAJgzxHwtZ6jZmnImq1ZZsj2Nd9y9RKMPZoG0,6954
+meteo_lt_pkg-0.4.0b1.dist-info/licenses/LICENSE,sha256=3IGi6xn6NUdXGvcdwD0MUbhy3Yz5NRnUjJrwKanFAD4,1073
+meteo_lt_pkg-0.4.0b1.dist-info/METADATA,sha256=yv1prhcoQzP8lug8rEbBf47W1twMj8NaINxN5eFOcBI,10330
+meteo_lt_pkg-0.4.0b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+meteo_lt_pkg-0.4.0b1.dist-info/top_level.txt,sha256=-aEdc9FzHhcIH4_0TNdKNxuvDnS3chKoJy6LK9Ud-G4,9
+meteo_lt_pkg-0.4.0b1.dist-info/RECORD,,

{meteo_lt_pkg-0.2.4.dist-info → meteo_lt_pkg-0.4.0b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

meteo_lt_pkg-0.2.4.dist-info/METADATA

@@ -1,178 +0,0 @@
-Metadata-Version: 2.2
-Name: meteo_lt-pkg
-Version: 0.2.4
-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
-Project-URL: Issues, https://github.com/Brunas/meteo_lt-pkg/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Development Status :: 4 - Beta
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: aiohttp
-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"
-
-# Meteo.Lt Lithuanian weather forecast package
-
-[![GitHub Release][releases-shield]][releases]
-[![GitHub Activity][commits-shield]][commits]
-[![License][license-shield]](LICENSE)
-![Project Maintenance][maintenance-shield]
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-
-<a href="https://buymeacoffee.com/pdfdc52z8h" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 40px !important;width: 145px !important;" ></a>
-
-MeteoLt-Pkg is a Python library designed to fetch weather data from [`api.meteo.lt`](https://api.meteo.lt/). This library provides convenient methods to interact with the API and obtain weather forecasts and related data. Please visit for more information.
-
-## Installation
-
-You can install the package using pip:
-
-```bash
-pip install meteo_lt-pkg
-```
-
-## Usage
-
-Initializing the API Client
-To start using the library, you need to initialize the `MeteoLtAPI` client:
-
-```python
-from meteo_lt import MeteoLtAPI
-
-api_client = MeteoLtAPI()
-```
-
-### Fetching Places
-
-To get the list of available places:
-
-```python
-import asyncio
-
-async def fetch_places():
-    await api_client.fetch_places()
-    for place in api_client.places:
-        print(place)
-
-asyncio.run(fetch_places())
-```
-
-### Getting the Nearest Place
-
-You can find the nearest place using latitude and longitude coordinates:
-
-```python
-async def find_nearest_place(latitude, longitude):
-    nearest_place = await api_client.get_nearest_place(latitude, longitude)
-    print(f"Nearest place: {nearest_place.name}")
-
- # Example coordinates for Vilnius, Lithuania
-asyncio.run(find_nearest_place(54.6872, 25.2797))
-```
-
-Also, if no places are retrieved before, that is done automatically in `get_nearest_place` method.
-
-### Fetching Weather Forecast
-
-To get the weather forecast for a specific place, use the get_forecast method with the place code:
-
-```python
-async def fetch_forecast(place_code):
-    forecast = await api_client.get_forecast(place_code)
-    current_conditions = forecast.current_conditions()
-    print(f"Current temperature: {current_conditions.temperature}°C")
-
-# Example place code for Vilnius, Lithuania
-asyncio.run(fetch_forecast("vilnius"))
-```
->**NOTE** `current_conditions` is the current hour record from the `forecast_timestamps` array. Also, `forecast_timestamps` array has past time records filtered out due to `api.meteo.lt` not doing that automatically.
-
-## Data Models
-
-The package includes several data models to represent the API responses:
-
-### Coordinates
-
-Represents geographic coordinates.
-
-```python
-from meteo_lt import Coordinates
-
-coords = Coordinates(latitude=54.6872, longitude=25.2797)
-print(coords)
-```
-
-### Place
-
-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)
-print(place.latitude, place.longitude)
-```
-
-### ForecastTimestamp
-
-Represents a timestamp within the weather forecast, including various weather parameters.
-
-```python
-from meteo_lt import ForecastTimestamp
-
-forecast_timestamp = ForecastTimestamp(
-    datetime="2024-07-23T12:00:00+00:00",
-    temperature=25.5,
-    apparent_temperature=27.0,
-    condition_code="clear",
-    wind_speed=5.0,
-    wind_gust_speed=8.0,
-    wind_bearing=180,
-    cloud_coverage=20,
-    pressure=1012,
-    humidity=60,
-    precipitation=0
-)
-print(forecast_timestamp.condition)
-```
-
-### Forecast
-
-Represents the weather forecast for a place, containing multiple forecast timestamps.
-
-```python
-from meteo_lt import Forecast
-
-forecast = Forecast(
-    place=place,
-    forecast_created=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-    forecast_timestamps=[forecast_timestamp]
-)
-print(forecast.current_conditions().temperature)
-```
-
-## Contributing
-
-Contributions are welcome! For major changes please open an issue to discuss or submit a pull request with your changes. If you want to contribute you can use devcontainers in vscode for easiest setup follow [instructions here](.devcontainer/README.md).
-
-***
-
-[commits-shield]: https://img.shields.io/github/commit-activity/y/Brunas/meteo_lt-pkg.svg?style=flat-square
-[commits]: https://github.com/Brunas/meteo_lt-pkg/commits/main
-[license-shield]: https://img.shields.io/github/license/Brunas/meteo_lt-pkg.svg?style=flat-square
-[maintenance-shield]: https://img.shields.io/badge/maintainer-Brunas%20%40Brunas-blue.svg?style=flat-square
-[releases-shield]: https://img.shields.io/github/release/Brunas/meteo_lt-pkg.svg?style=flat-square
-[releases]: https://github.com/Brunas/meteo_lt-pkg/releases

meteo_lt_pkg-0.2.4.dist-info/RECORD

@@ -1,9 +0,0 @@
-meteo_lt/__init__.py,sha256=3RXg8MWNyXDJ4PpifsXRAT7t1mRNAJwSFlqJBmLeoPk,194
-meteo_lt/api.py,sha256=oFpIqdOmVcSUdaMrnlbGV1k5w1XIdIJsKroXkczz8JE,1620
-meteo_lt/models.py,sha256=brL4d0Mo4Fg29tKd13lxINygLL6EOQZJj6jOXrbP9Z0,5148
-meteo_lt/utils.py,sha256=SL7ZeTEfdrdQoe_DOJaiA2zVxt08ujyFJ24JxJm1Hks,1081
-meteo_lt_pkg-0.2.4.dist-info/LICENSE,sha256=3IGi6xn6NUdXGvcdwD0MUbhy3Yz5NRnUjJrwKanFAD4,1073
-meteo_lt_pkg-0.2.4.dist-info/METADATA,sha256=vmOqwXFTRmqdyRG7VdRBl4TBc6Rau71cz3FiOqDHPdQ,5670
-meteo_lt_pkg-0.2.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-meteo_lt_pkg-0.2.4.dist-info/top_level.txt,sha256=-aEdc9FzHhcIH4_0TNdKNxuvDnS3chKoJy6LK9Ud-G4,9
-meteo_lt_pkg-0.2.4.dist-info/RECORD,,