meteo-lt-pkg 0.4.0b1__tar.gz → 0.5.0b0__tar.gz

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

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

meteo_lt_pkg-0.5.0b0/meteo_lt/__init__.py

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

meteo_lt_pkg-0.5.0b0/meteo_lt/api.py

@@ -0,0 +1,109 @@
+"""Main API class script"""
+
+from typing import List, Optional
+
+from .models import (
+    Forecast,
+    Place,
+    WeatherWarning,
+    HydroStation,
+    HydroObservationData,
+)
+from .utils import find_nearest_location
+from .client import MeteoLtClient
+from .warnings import WeatherWarningsProcessor
+
+
+class MeteoLtAPI:
+    """Main API class that orchestrates external API calls and warning processing"""
+
+    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: Optional[type],
+        exc_val: Optional[Exception],
+        exc_tb: Optional[object],
+    ) -> None:
+        """Async context manager exit"""
+        await self.client.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def close(self):
+        """Close the API client and cleanup resources"""
+        await self.client.close()
+
+    async def fetch_places(self) -> None:
+        """Gets all places from API"""
+        self.places = await self.client.fetch_places()
+
+    async def get_nearest_place(self, latitude: float, longitude: float) -> Optional[Place]:
+        """Finds nearest place using provided coordinates"""
+        if not self.places:
+            await self.fetch_places()
+        return find_nearest_location(latitude, longitude, self.places)
+
+    async def get_forecast_with_warnings(
+        self,
+        latitude: Optional[float] = None,
+        longitude: Optional[float] = None,
+        place_code: Optional[str] = None,
+    ) -> Forecast:
+        """Get forecast with weather warnings for a location"""
+        if place_code is None:
+            if latitude is None or longitude is None:
+                raise ValueError("Either place_code or both latitude and longitude must be provided")
+            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: str, include_warnings: bool = True) -> Forecast:
+        """Retrieves forecast data from API"""
+        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) -> None:
+        """Enrich forecast timestamps with relevant weather warnings"""
+        if not forecast or not forecast.place or not forecast.place.administrative_division:
+            return
+
+        warnings = await self.get_weather_warnings(forecast.place.administrative_division)
+
+        if warnings:
+            self.warnings_processor.enrich_forecast_with_warnings(forecast, warnings)
+
+    async def get_hydro_stations(self) -> List[HydroStation]:
+        """Get list of all hydrological stations"""
+        return await self.client.fetch_hydro_stations()
+
+    async def get_nearest_hydro_station(self, latitude: float, longitude: float) -> Optional[HydroStation]:
+        """Find the nearest hydrological station to given coordinates"""
+        stations = await self.get_hydro_stations()
+        if not stations:
+            return None
+        return find_nearest_location(latitude, longitude, stations)
+
+    async def get_hydro_observation_data(
+        self,
+        station_code: str,
+        observation_type: str = "measured",
+        date: str = "latest",
+    ) -> HydroObservationData:
+        """Get hydrological observation data for a station"""
+        return await self.client.fetch_hydro_observation_data(station_code, observation_type, date)

meteo_lt_pkg-0.5.0b0/meteo_lt/client.py

@@ -0,0 +1,163 @@
+"""MeteoLt API client for external API calls"""
+
+import json
+from typing import List, Optional, Dict, Any
+
+import aiohttp
+
+from .models import (
+    Place,
+    Forecast,
+    HydroStation,
+    HydroObservationData,
+    HydroObservation,
+)
+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: Optional[type],
+        exc_val: Optional[Exception],
+        exc_tb: Optional[Any],
+    ) -> None:
+        """Async context manager exit"""
+        await self.close()
+
+    async def close(self) -> None:
+        """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) -> Dict[str, Any]:
+        """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)
+
+    async def fetch_hydro_stations(self) -> List[HydroStation]:
+        """Get list of all hydrological stations."""
+        session = await self._get_session()
+        async with session.get(f"{BASE_URL}/hydro-stations") as resp:
+            if resp.status == 200:
+                response = await resp.json()
+                stations = []
+                for station_data in response:
+                    stations.append(
+                        HydroStation(
+                            code=station_data.get("code"),
+                            name=station_data.get("name"),
+                            water_body=station_data.get("waterBody"),
+                            coordinates=station_data.get("coordinates", {}),
+                        )
+                    )
+                return stations
+            else:
+                raise Exception(f"API returned status {resp.status}")
+
+    async def fetch_hydro_station(self, station_code: str) -> HydroStation:
+        """Get information about a specific hydrological station."""
+        session = await self._get_session()
+        async with session.get(f"{BASE_URL}/hydro-stations/{station_code}") as resp:
+            if resp.status == 200:
+                response = await resp.json()
+                return HydroStation(
+                    code=response.get("code"),
+                    name=response.get("name"),
+                    water_body=response.get("waterBody"),
+                    coordinates=response.get("coordinates", {}),
+                )
+            else:
+                raise Exception(f"API returned status {resp.status}")
+
+    async def fetch_hydro_observation_data(
+        self,
+        station_code: str,
+        observation_type: str = "measured",
+        date: str = "latest",
+    ) -> HydroObservationData:
+        """Get hydrological observation data for a station."""
+        session = await self._get_session()
+        async with session.get(
+            f"{BASE_URL}/hydro-stations/{station_code}/observations/{observation_type}/{date}"
+        ) as resp:
+            if resp.status == 200:
+                response = await resp.json()
+                station = HydroStation(
+                    code=response["station"].get("code"),
+                    name=response["station"].get("name"),
+                    water_body=response["station"].get("waterBody"),
+                    coordinates=response["station"].get("coordinates", {}),
+                )
+
+                observations = []
+                for obs_data in response.get("observations", []):
+                    observations.append(
+                        HydroObservation(
+                            observation_datetime=obs_data.get("observationTimeUtc"),
+                            water_level=obs_data.get("waterLevel"),
+                            water_temperature=obs_data.get("waterTemperature"),
+                            water_discharge=obs_data.get("waterDischarge"),
+                        )
+                    )
+
+                return HydroObservationData(
+                    station=station,
+                    observations_data_range=response.get("observationsDataRange"),
+                    observations=observations,
+                )
+            else:
+                raise Exception(f"API returned status {resp.status}")

{meteo_lt_pkg-0.4.0b1 → meteo_lt_pkg-0.5.0b0}/meteo_lt/const.py

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

{meteo_lt_pkg-0.4.0b1 → meteo_lt_pkg-0.5.0b0}/meteo_lt/models.py

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

meteo_lt_pkg-0.5.0b0/meteo_lt/utils.py

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

{meteo_lt_pkg-0.4.0b1 → meteo_lt_pkg-0.5.0b0}/meteo_lt/warnings.py

@@ -1,10 +1,8 @@
 """Weather warnings processor for handling warning-related logic"""
 
-# pylint: disable=W0718
-
 import re
 from datetime import datetime, timezone
-from typing import List
+from typing import List, Optional, Dict, Any
 
 from .models import Forecast, WeatherWarning
 from .const import COUNTY_MUNICIPALITIES
@@ -17,24 +15,18 @@ class WeatherWarningsProcessor:
     def __init__(self, client: MeteoLtClient):
         self.client = client
 
-    async def get_weather_warnings(
-        self, administrative_division: str = None
-    ) -> List[WeatherWarning]:
+    async def get_weather_warnings(self, administrative_division: str = None) -> List[WeatherWarning]:
         """Fetches and processes weather warnings"""
         warnings_data = await self.client.fetch_weather_warnings()
         warnings = self._parse_warnings_data(warnings_data)
 
         # Filter by administrative division if specified
         if administrative_division:
-            warnings = [
-                w
-                for w in warnings
-                if self._warning_affects_area(w, administrative_division)
-            ]
+            warnings = [w for w in warnings if self._warning_affects_area(w, administrative_division)]
 
         return warnings
 
-    def _parse_warnings_data(self, warnings_data: dict) -> List[WeatherWarning]:
+    def _parse_warnings_data(self, warnings_data: Optional[Dict[str, Any]]) -> List[WeatherWarning]:
         """Parse raw warnings data into WeatherWarning objects"""
         warnings = []
 
@@ -51,9 +43,7 @@ class WeatherWarningsProcessor:
             for area_group in phenomenon_group.get("area_groups", []):
                 for alert in area_group.get("single_alerts", []):
                     # Skip alerts with no phenomenon or empty descriptions
-                    if not alert.get("phenomenon") or not alert.get(
-                        "description", {}
-                    ).get("lt"):
+                    if not alert.get("phenomenon") or not alert.get("description", {}).get("lt"):
                         continue
 
                     # Create warnings for each area in the group
@@ -64,51 +54,37 @@ class WeatherWarningsProcessor:
 
         return warnings
 
-    def _create_warning_from_alert(self, alert: dict, area: dict) -> WeatherWarning:
+    def _create_warning_from_alert(self, alert: Dict[str, Any], area: Dict[str, Any]) -> WeatherWarning:
         """Create a WeatherWarning from alert data"""
-        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
+        county = area.get("name", "Unknown")
+        phenomenon = alert.get("phenomenon", "")
+        severity = alert.get("severity", "Minor")
 
-    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.", "")
+        warning_type = re.sub(r"^(dangerous|severe|extreme)-", "", phenomenon)
+
+        desc_dict = alert.get("description", {})
+        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}"
+
+        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"),
         )
 
+    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
@@ -117,28 +93,20 @@ class WeatherWarningsProcessor:
         if warning.county in COUNTY_MUNICIPALITIES:
             municipalities = COUNTY_MUNICIPALITIES[warning.county]
             for municipality in municipalities:
-                mun_clean = (
-                    municipality.lower()
-                    .replace(" savivaldybė", "")
-                    .replace(" sav.", "")
-                )
+                mun_clean = municipality.lower().replace(" savivaldybė", "").replace(" sav.", "")
                 if admin_lower in mun_clean or mun_clean in admin_lower:
                     return True
 
         return False
 
-    def enrich_forecast_with_warnings(
-        self, forecast: Forecast, warnings: List[WeatherWarning]
-    ):
+    def enrich_forecast_with_warnings(self, forecast: Forecast, warnings: List[WeatherWarning]) -> None:
         """Enrich forecast timestamps with relevant weather warnings"""
         if not warnings:
             return
 
         # For each forecast timestamp, find applicable warnings
         for timestamp in forecast.forecast_timestamps:
-            timestamp.warnings = self._get_warnings_for_timestamp(
-                timestamp.datetime, warnings
-            )
+            timestamp.warnings = self._get_warnings_for_timestamp(timestamp.datetime, warnings)
 
         # Also add warnings to current conditions if available
         if hasattr(forecast, "current_conditions") and forecast.current_conditions:
@@ -146,14 +114,10 @@ class WeatherWarningsProcessor:
                 forecast.current_conditions.datetime, warnings
             )
 
-    def _get_warnings_for_timestamp(
-        self, timestamp_str: str, warnings: List[WeatherWarning]
-    ) -> List[WeatherWarning]:
+    def _get_warnings_for_timestamp(self, timestamp_str: str, warnings: List[WeatherWarning]) -> List[WeatherWarning]:
         """Get warnings that are active for a specific timestamp"""
         try:
-            timestamp = datetime.fromisoformat(timestamp_str).replace(
-                tzinfo=timezone.utc
-            )
+            timestamp = datetime.fromisoformat(timestamp_str).replace(tzinfo=timezone.utc)
             applicable_warnings = []
 
             for warning in warnings:
@@ -161,12 +125,8 @@ class WeatherWarningsProcessor:
                     continue
 
                 try:
-                    start_time = datetime.fromisoformat(
-                        warning.start_time.replace("Z", "+00:00")
-                    )
-                    end_time = datetime.fromisoformat(
-                        warning.end_time.replace("Z", "+00:00")
-                    )
+                    start_time = datetime.fromisoformat(warning.start_time.replace("Z", "+00:00"))
+                    end_time = datetime.fromisoformat(warning.end_time.replace("Z", "+00:00"))
 
                     # Check if timestamp falls within warning period
                     if start_time <= timestamp <= end_time:

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

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

meteo_lt_pkg-0.5.0b0/meteo_lt_pkg.egg-info/requires.txt

@@ -0,0 +1,12 @@
+aiohttp>=3.13
+
+[dev]
+pytest>=9.0
+pytest-cov>=7.0
+pytest-asyncio>=1.3
+black>=26.0
+coverage>=7.0
+flake8>=7.0
+pyflakes>=3.0
+pylint>=4.0
+build>=1.0

{meteo_lt_pkg-0.4.0b1 → meteo_lt_pkg-0.5.0b0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "meteo_lt-pkg"
-version = "0.4.0-beta1"
+version = "0.5.0-beta"
 authors = [
   { name="Brunas", email="brunonas@gmail.com" },
 ]
@@ -14,7 +14,7 @@ classifiers = [
     "Development Status :: 4 - Beta",
 ]
 dependencies = [
-    "aiohttp",
+    "aiohttp>=3.13",
 ]
 
 [project.urls]
@@ -23,17 +23,20 @@ Issues = "https://github.com/Brunas/meteo_lt-pkg/issues"
 
 [project.optional-dependencies]
 dev = [
-    "pytest",
-    "pytest-cov",
-    "pytest-asyncio",
-    "black",
-    "coverage",
-    "flake8",
-    "pyflakes",
-    "pylint",
-    "build"
+    "pytest>=9.0",
+    "pytest-cov>=7.0",
+    "pytest-asyncio>=1.3",
+    "black>=26.0",
+    "coverage>=7.0",
+    "flake8>=7.0",
+    "pyflakes>=3.0",
+    "pylint>=4.0",
+    "build>=1.0"
 ]
 
+[tool.black]
+line-length = 120
+
 [build-system]
 requires = ["setuptools>=61.0", "wheel"]
 build-backend = "setuptools.build_meta"

meteo_lt_pkg-0.4.0b1/meteo_lt/__init__.py

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

meteo_lt_pkg-0.4.0b1/meteo_lt/api.py

@@ -1,94 +0,0 @@
-"""Main API class script"""
-
-# pylint: disable=W0718
-
-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 that orchestrates external API calls and warning processing"""
-
-    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"""
-        self.places = await self.client.fetch_places()
-
-    async def get_nearest_place(self, latitude, longitude):
-        """Finds nearest place using provided coordinates"""
-        if not self.places:
-            await self.fetch_places()
-        return find_nearest_place(latitude, longitude, self.places)
-
-    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"""
-        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_pkg-0.4.0b1/meteo_lt/client.py

@@ -1,80 +0,0 @@
-"""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_pkg-0.4.0b1/meteo_lt/utils.py

@@ -1,34 +0,0 @@
-"""utils.py"""
-
-from math import radians, sin, cos, sqrt, atan2
-
-
-def haversine(lat1, lon1, lat2, lon2):
-    """Calculate the great-circle distance between two points on the Earth's surface."""
-    # Convert latitude and longitude from degrees to radians
-    lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])
-
-    # Haversine formula
-    dlat = lat2 - lat1
-    dlon = lon2 - lon1
-    a = sin(dlat / 2) ** 2 + cos(lat1) * cos(lat2) * sin(dlon / 2) ** 2
-    c = 2 * atan2(sqrt(a), sqrt(1 - a))
-    r = 6371  # Radius of Earth in kilometers
-    return r * c
-
-
-def find_nearest_place(latitude, longitude, places):
-    """Find the nearest place from a list of places based on the given latitude and longitude."""
-    nearest_place = None
-    min_distance = float("inf")
-
-    for place in places:
-        place_lat = place.latitude
-        place_lon = place.longitude
-        distance = haversine(latitude, longitude, place_lat, place_lon)
-
-        if distance < min_distance:
-            min_distance = distance
-            nearest_place = place
-
-    return nearest_place

meteo_lt_pkg-0.4.0b1/meteo_lt_pkg.egg-info/requires.txt

@@ -1,12 +0,0 @@
-aiohttp
-
-[dev]
-pytest
-pytest-cov
-pytest-asyncio
-black
-coverage
-flake8
-pyflakes
-pylint
-build