python-weather 2.0.4__py3-none-any.whl → 2.0.5__py3-none-any.whl

python_weather/__init__.py

@@ -31,7 +31,7 @@ __title__ = 'python-weather'
 __author__ = 'null8626'
 __license__ = 'MIT'
 __copyright__ = 'Copyright (c) 2021-2024 null8626'
-__version__ = '2.0.4'
+__version__ = '2.0.5'
 __all__ = (
   'METRIC',
   'IMPERIAL',

python_weather/base.py

@@ -79,84 +79,71 @@ class CustomizableBase:
     self.__locale = to
 
 
-class BaseForecast(CustomizableBase):
-  __slots__: Tuple[str, ...] = ('__inner',)
+class BaseForecast:
+  __slots__: Tuple[str, ...] = (
+    'ultraviolet',
+    'humidity',
+    'wind_direction',
+    'kind',
+    'feels_like',
+    'temperature',
+    'precipitation',
+    'pressure',
+    'visibility',
+    'wind_speed',
+    'description',
+  )
 
-  def __init__(self, json: dict, unit: _Unit, locale: Locale):
-    self.__inner = json
-
-    super().__init__(unit, locale)
-
-  @property
-  def ultraviolet(self) -> UltraViolet:
-    """The ultra-violet (UV) index."""
-
-    return UltraViolet._new(int(self.__inner['uvIndex']))
-
-  @property
-  def feels_like(self) -> int:
-    """What it felt like, in celcius or fahrenheit."""
+  ultraviolet: UltraViolet
+  """The ultra-violet (UV) index."""
 
-    return int(self.__inner[f'FeelsLike{self._CustomizableBase__unit.temperature}'])
+  humidity: int
+  """The humidity value in percent."""
 
-  @property
-  def humidity(self) -> int:
-    """The humidity value in percent."""
+  wind_direction: WindDirection
+  """The wind direction."""
 
-    return int(self.__inner['humidity'])
+  kind: Kind
+  """The kind of the forecast."""
 
-  @property
-  def temperature(self) -> int:
-    """The temperature in either celcius or Fahrenheit."""
+  feels_like: int
+  """What it felt like, in celcius or fahrenheit."""
 
-    return int(self.__inner[f'temp_{self._CustomizableBase__unit.temperature}'])
+  temperature: int
+  """The temperature in either celcius or Fahrenheit."""
 
-  @property
-  def precipitation(self) -> float:
-    """The precipitation in either millimeters or inches."""
+  precipitation: float
+  """The precipitation in either millimeters or inches."""
 
-    return float(self.__inner[f'precip{self._CustomizableBase__unit.precipitation}'])
+  pressure: float
+  """The pressure in either pascal or inches."""
 
-  @property
-  def pressure(self) -> float:
-    """The pressure in either pascal or inches."""
+  visibility: int
+  """The visibility distance in either kilometers or miles."""
 
-    return float(self.__inner[f'pressure{self._CustomizableBase__unit.pressure}'])
+  wind_speed: int
+  """The wind speeds in either kilometers/hour or miles/hour."""
 
-  @property
-  def visibility(self) -> int:
-    """The visibility distance in either kilometers or miles."""
-
-    return int(self.__inner[f'visibility{self._CustomizableBase__unit.visibility}'])
-
-  @property
-  def wind_speed(self) -> int:
-    """The wind speeds in either kilometers/hour or miles/hour."""
-
-    return int(self.__inner[f'windspeed{self._CustomizableBase__unit.velocity}'])
-
-  @property
-  def wind_direction(self) -> WindDirection:
-    """The wind direction."""
-
-    return WindDirection._new(
-      self.__inner['winddir16Point'], int(self.__inner['winddirDegree'])
-    )
-
-  @property
-  def description(self) -> str:
-    """The description regarding the forecast. This can be localized in different languages depending on the localization used."""
+  description: str
+  """The description regarding the forecast. This can be localized in different languages depending on the localization used."""
 
+  def __init__(self, json: dict, unit: _Unit, locale: Locale):
     description = (
-      self.__inner['weatherDesc'][0]['value']
-      if self._CustomizableBase__locale == Locale.ENGLISH
-      else self.__inner[f'lang_{self._CustomizableBase__locale.value}'][0]['value']
+      json['weatherDesc'][0]['value']
+      if locale is Locale.ENGLISH
+      else json[f'lang_{locale.value}'][0]['value']
     )
 
-    return description.strip()
-
-  @property
-  def kind(self) -> Kind:
-    """The kind of the forecast."""
-
-    return Kind(int(self.__inner['weatherCode']))
+    self.ultraviolet = UltraViolet._new(int(json['uvIndex']))
+    self.humidity = int(json['humidity'])
+    self.wind_direction = WindDirection._new(
+      json['winddir16Point'], int(json['winddirDegree'])
+    )
+    self.kind = Kind(int(json['weatherCode']))
+    self.feels_like = int(json[f'FeelsLike{unit.temperature}'])
+    self.temperature = int(json[f'temp_{unit.temperature}'])
+    self.precipitation = float(json[f'precip{unit.precipitation}'])
+    self.pressure = float(json[f'pressure{unit.pressure}'])
+    self.visibility = int(json[f'visibility{unit.visibility}'])
+    self.wind_speed = int(json[f'windspeed{unit.velocity}'])
+    self.description = description.strip()

python_weather/client.py

@@ -62,7 +62,6 @@ class Client(CustomizableBase):
 
     self.__own_session = session is None
     self.__session = session or ClientSession(
-      raise_for_status=True,
       timeout=ClientTimeout(total=5000.0),
       connector=TCPConnector(verify_ssl=False),
     )
@@ -112,6 +111,8 @@ class Client(CustomizableBase):
         async with self.__session.get(
           f'https://{subdomain}wttr.in/{quote_plus(location)}?format=j1'
         ) as resp:
+          resp.raise_for_status()
+
           return Forecast(await resp.json(), unit, locale)
       except Exception as err:
         if delay == 4:

python_weather/enums.py

@@ -122,7 +122,7 @@ class UltraViolet(BasicEnum, IndexedEnum):
 class WindDirection(BasicEnum):
   """Represents a wind direction."""
 
-  __slots__: Tuple[str, ...] = ('__degrees',)
+  __slots__: Tuple[str, ...] = ('degrees',)
 
   NORTH = 'N'
   NORTH_NORTHEAST = 'NNE'
@@ -141,9 +141,12 @@ class WindDirection(BasicEnum):
   NORTHWEST = 'NW'
   NORTH_NORTHWEST = 'NNW'
 
+  degrees: float
+  """The wind direction's value in degrees."""
+
   def _new(value: str, degrees: float) -> 'WindDirection':
     enum = WindDirection(value)
-    enum.__degrees = degrees
+    enum.degrees = degrees
 
     return enum
 
@@ -186,12 +189,6 @@ class WindDirection(BasicEnum):
   def __float__(self) -> float:
     return self.__degrees
 
-  @property
-  def degrees(self) -> int:
-    """The wind direction's value in degrees."""
-
-    return self.__degrees
-
   @property
   def emoji(self) -> str:
     """The emoji representing this enum."""

python_weather/forecast.py

@@ -25,7 +25,7 @@ SOFTWARE.
 from typing import Iterable, Optional, Tuple, List
 from datetime import datetime, date, time
 
-from .base import BaseForecast, CustomizableBase
+from .base import BaseForecast
 from .enums import Phase, Locale, HeatIndex
 from .constants import _Unit, LATLON_REGEX
 
@@ -33,318 +33,264 @@ from .constants import _Unit, LATLON_REGEX
 class HourlyForecast(BaseForecast):
   """Represents a weather forecast of a specific hour."""
 
-  __slots__: Tuple[str, ...] = ()
+  __slots__: Tuple[str, ...] = (
+    'chances_of_fog',
+    'chances_of_frost',
+    'chances_of_high_temperature',
+    'chances_of_overcast',
+    'chances_of_rain',
+    'chances_of_remaining_dry',
+    'chances_of_snow',
+    'chances_of_sunshine',
+    'chances_of_thunder',
+    'chances_of_windy',
+    'cloud_cover',
+    'time',
+    'dew_point',
+    'heat_index',
+    'wind_chill',
+    'wind_gust',
+  )
 
-  def __init__(self, json: dict, unit: _Unit, locale: Locale):
-    # for inheritance purposes
-    if 'temp_C' not in json:
-      json['temp_C'] = json.pop('tempC')
-    if 'temp_F' not in json:
-      json['temp_F'] = json.pop('tempF')
-
-    super().__init__(json, unit, locale)
-
-  def __repr__(self) -> str:
-    return f'<{__class__.__name__} time={self.time!r} temperature={self.temperature!r} description={self.description!r} kind={self.kind!r}>'
-
-  @property
-  def dew_point(self) -> int:
-    """The dew point in either celcius or fahrenheit."""
+  chances_of_fog: int
+  """Chances of a fog in percent."""
 
-    return int(
-      self._BaseForecast__inner[f'DewPoint{self._CustomizableBase__unit.temperature}']
-    )
-
-  @property
-  def heat_index(self) -> HeatIndex:
-    """The heat index in either celcius or fahrenheit."""
-
-    celcius_index = int(self._BaseForecast__inner['HeatIndexC'])
-
-    return HeatIndex._new(
-      celcius_index,
-      int(
-        self._BaseForecast__inner[
-          f'HeatIndex{self._CustomizableBase__unit.temperature}'
-        ]
-      ),
-    )
-
-  @property
-  def wind_chill(self) -> int:
-    """The wind chill value in either celcius or fahrenheit."""
-
-    return int(
-      self._BaseForecast__inner[f'WindChill{self._CustomizableBase__unit.temperature}']
-    )
-
-  @property
-  def wind_gust(self) -> int:
-    """The wind gust value in either kilometers/hour or miles/hour."""
-
-    return int(
-      self._BaseForecast__inner[f'WindGust{self._CustomizableBase__unit.velocity}']
-    )
+  chances_of_frost: int
+  """Chances of a frost in percent."""
 
-  @property
-  def chances_of_fog(self) -> int:
-    """Chances of a fog in percent."""
+  chances_of_high_temperature: int
+  """Chances of a high temperature in percent."""
 
-    return int(self._BaseForecast__inner['chanceoffog'])
+  chances_of_overcast: int
+  """Chances of an overcast in percent."""
 
-  @property
-  def chances_of_frost(self) -> int:
-    """Chances of a frost in percent."""
+  chances_of_rain: int
+  """Chances of a rain in percent."""
 
-    return int(self._BaseForecast__inner['chanceoffrost'])
+  chances_of_remaining_dry: int
+  """Chances of remaining dry in percent."""
 
-  @property
-  def chances_of_high_temperature(self) -> int:
-    """Chances of a high temperature in percent."""
+  chances_of_snow: int
+  """Chances of a snow in percent."""
 
-    return int(self._BaseForecast__inner['chanceofhightemp'])
+  chances_of_sunshine: int
+  """Chances of a sunshine in percent."""
 
-  @property
-  def chances_of_overcast(self) -> int:
-    """Chances of an overcast in percent."""
+  chances_of_thunder: int
+  """Chances of a thunder in percent."""
 
-    return int(self._BaseForecast__inner['chanceofovercast'])
+  chances_of_windy: int
+  """Chances of windy in percent."""
 
-  @property
-  def chances_of_rain(self) -> int:
-    """Chances of a rain in percent."""
+  cloud_cover: int
+  """The cloud cover value in percent."""
 
-    return int(self._BaseForecast__inner['chanceofrain'])
+  time: 'time'
+  """The local time in hours and minutes."""
 
-  @property
-  def chances_of_remaining_dry(self) -> int:
-    """Chances of remaining dry in percent."""
+  dew_point: int
+  """The dew point in either celcius or fahrenheit."""
 
-    return int(self._BaseForecast__inner['chanceofremdry'])
+  heat_index: HeatIndex
+  """The heat index in either celcius or fahrenheit."""
 
-  @property
-  def chances_of_snow(self) -> int:
-    """Chances of a snow in percent."""
+  wind_chill: int
+  """The wind chill value in either celcius or fahrenheit."""
 
-    return int(self._BaseForecast__inner['chanceofsnow'])
+  wind_gust: int
+  """The wind gust value in either kilometers/hour or miles/hour."""
 
-  @property
-  def chances_of_sunshine(self) -> int:
-    """Chances of a sunshine in percent."""
-
-    return int(self._BaseForecast__inner['chanceofsunshine'])
-
-  @property
-  def chances_of_thunder(self) -> int:
-    """Chances of a thunder in percent."""
-
-    return int(self._BaseForecast__inner['chanceofthunder'])
-
-  @property
-  def chances_of_windy(self) -> int:
-    """Chances of windy in percent."""
-
-    return int(self._BaseForecast__inner['chanceofwindy'])
-
-  @property
-  def cloud_cover(self) -> int:
-    """The cloud cover value in percent."""
-
-    return int(self._BaseForecast__inner['cloudcover'])
-
-  @property
-  def time(self) -> time:
-    """The local time in hours and minutes."""
+  def __init__(self, json: dict, unit: _Unit, locale: Locale):
+    # for inheritance purposes
+    if 'temp_C' not in json:
+      json['temp_C'] = json.pop('tempC')
+    if 'temp_F' not in json:
+      json['temp_F'] = json.pop('tempF')
 
-    return (
-      time()
-      if len(self._BaseForecast__inner['time']) < 3
-      else datetime.strptime(self._BaseForecast__inner['time'], '%H%M').time()
+    celcius_index = int(json['HeatIndexC'])
+    t = json['time']
+
+    self.chances_of_fog = int(json['chanceoffog'])
+    self.chances_of_frost = int(json['chanceoffrost'])
+    self.chances_of_high_temperature = int(json['chanceofhightemp'])
+    self.chances_of_overcast = int(json['chanceofovercast'])
+    self.chances_of_rain = int(json['chanceofrain'])
+    self.chances_of_remaining_dry = int(json['chanceofremdry'])
+    self.chances_of_snow = int(json['chanceofsnow'])
+    self.chances_of_sunshine = int(json['chanceofsunshine'])
+    self.chances_of_thunder = int(json['chanceofthunder'])
+    self.chances_of_windy = int(json['chanceofwindy'])
+    self.cloud_cover = int(json['cloudcover'])
+    self.time = time() if len(t) < 3 else datetime.strptime(t, '%H%M').time()
+    self.dew_point = int(json[f'DewPoint{unit.temperature}'])
+    self.heat_index = HeatIndex._new(
+      celcius_index,
+      int(json[f'HeatIndex{unit.temperature}']),
     )
+    self.wind_chill = int(json[f'WindChill{unit.temperature}'])
+    self.wind_gust = int(json[f'WindGust{unit.velocity}'])
 
+    super().__init__(json, unit, locale)
 
-class DailyForecast(CustomizableBase):
-  __slots__: Tuple[str, ...] = ('__inner', '__astronomy')
-
-  def __init__(self, json: dict, unit: _Unit, locale: Locale):
-    self.__astronomy = json.pop('astronomy')[0]
-    self.__inner = json
+  def __repr__(self) -> str:
+    return f'<{__class__.__name__} time={self.time!r} temperature={self.temperature!r} description={self.description!r} kind={self.kind!r}>'
 
-    super().__init__(unit, locale)
 
-  def __repr__(self) -> str:
-    return f'<{__class__.__name__} date={self.date!r} temperature={self.temperature!r}>'
+class DailyForecast:
+  __slots__: Tuple[str, ...] = (
+    'moon_illumination',
+    'moon_phase',
+    'moonrise',
+    'moonset',
+    'sunrise',
+    'sunset',
+    'date',
+    'sunlight',
+    'lowest_temperature',
+    'highest_temperature',
+    'temperature',
+    'snowfall',
+    'hourly_forecasts',
+  )
 
-  def __iter__(self) -> Iterable[HourlyForecast]:
-    return self.hourly_forecasts
+  moon_illumination: int
+  """The percentage of the moon illuminated."""
 
-  def __list__(self) -> List[HourlyForecast]:
-    return list(iter(self))
+  moon_phase: Phase
+  """The moon's phase."""
 
-  @property
-  def moon_illumination(self) -> int:
-    """The percentage of the moon illuminated."""
+  moonrise: Optional[time]
+  """The local time when the moon rises. This can be ``None``."""
 
-    return int(self.__astronomy['moon_illumination'])
+  moonset: Optional[time]
+  """The local time when the moon sets. This can be ``None``."""
 
-  @property
-  def moon_phase(self) -> Phase:
-    """The moon's phase."""
+  sunrise: Optional[time]
+  """The local time when the sun rises. This can be ``None``."""
 
-    return Phase(self.__astronomy['moon_phase'])
+  sunset: Optional[time]
+  """The local time when the sun sets. This can be ``None``."""
 
-  @property
-  def moonrise(self) -> Optional[time]:
-    """The local time when the moon rises. This can be ``None``."""
+  date: 'date'
+  """The local date of this forecast."""
 
-    try:
-      return datetime.strptime(self.__astronomy['moonrise'], '%I:%M %p').time()
-    except ValueError:
-      ...
+  sunlight: float
+  """Hours of sunlight."""
 
-  @property
-  def moonset(self) -> Optional[time]:
-    """The local time when the moon sets. This can be ``None``."""
+  lowest_temperature: int
+  """The lowest temperature in either celcius or fahrenheit."""
 
-    try:
-      return datetime.strptime(self.__astronomy['moonset'], '%I:%M %p').time()
-    except ValueError:
-      ...
+  highest_temperature: int
+  """The highest temperature in either celcius or fahrenheit."""
 
-  @property
-  def sunrise(self) -> Optional[time]:
-    """The local time when the sun rises. This can be ``None``."""
+  temperature: int
+  """The average temperature in either celcius or fahrenheit."""
 
-    try:
-      return datetime.strptime(self.__astronomy['sunrise'], '%I:%M %p').time()
-    except ValueError:
-      ...
+  snowfall: float
+  """Total snowfall in either centimeters or inches."""
 
-  @property
-  def sunset(self) -> Optional[time]:
-    """The local time when the sun sets. This can be ``None``."""
+  hourly_forecasts: List[HourlyForecast]
+  """The hourly forecasts of this day."""
 
+  def __init__(self, json: dict, unit: _Unit, locale: Locale):
+    astronomy = json['astronomy'][0]
+
+    self.moon_illumination = int(astronomy['moon_illumination'])
+    self.moon_phase = Phase(astronomy['moon_phase'])
+    self.moonrise = __class__.__parse_time(astronomy['moonrise'])
+    self.moonset = __class__.__parse_time(astronomy['moonset'])
+    self.sunrise = __class__.__parse_time(astronomy['sunrise'])
+    self.sunset = __class__.__parse_time(astronomy['sunset'])
+    self.date = datetime.strptime(json['date'], '%Y-%m-%d').date()
+    self.sunlight = float(json['sunHour'])
+    self.lowest_temperature = int(json[f'mintemp{unit.temperature}'])
+    self.highest_temperature = int(json[f'maxtemp{unit.temperature}'])
+    self.temperature = int(json[f'avgtemp{unit.temperature}'])
+    self.snowfall = float(json['totalSnow_cm']) / unit.cm_divisor
+    self.hourly_forecasts = [
+      HourlyForecast(elem, unit, locale) for elem in json['hourly']
+    ]
+
+  @staticmethod
+  def __parse_time(timestamp: str) -> Optional[time]:
     try:
-      return datetime.strptime(self.__astronomy['sunset'], '%I:%M %p').time()
+      return datetime.strptime(timestamp, '%I:%M %p').time()
     except ValueError:
       ...
 
-  @property
-  def date(self) -> date:
-    """The local date of this forecast."""
+  def __repr__(self) -> str:
+    return f'<{__class__.__name__} date={self.date!r} temperature={self.temperature!r}>'
 
-    return datetime.strptime(self.__inner['date'], '%Y-%m-%d').date()
+  def __len__(self) -> int:
+    return len(self.hourly_forecasts)
 
-  @property
-  def lowest_temperature(self) -> int:
-    """The lowest temperature in either celcius or fahrenheit."""
+  def __iter__(self) -> Iterable[HourlyForecast]:
+    return iter(self.hourly_forecasts)
 
-    return int(self.__inner[f'mintemp{self._CustomizableBase__unit.temperature}'])
 
-  @property
-  def highest_temperature(self) -> int:
-    """The highest temperature in either celcius or fahrenheit."""
+class Forecast(BaseForecast):
+  """Represents today's weather forecast, alongside daily and hourly weather forecasts."""
 
-    return int(self.__inner[f'maxtemp{self._CustomizableBase__unit.temperature}'])
+  __slots__: Tuple[str, ...] = (
+    'local_population',
+    'region',
+    'location',
+    'country',
+    'datetime',
+    'coordinates',
+    'daily_forecasts',
+  )
 
-  @property
-  def temperature(self) -> int:
-    """The average temperature in either celcius or fahrenheit."""
+  local_population: int
+  """The local population count."""
 
-    return int(self.__inner[f'avgtemp{self._CustomizableBase__unit.temperature}'])
+  region: str
+  """The local region's name."""
 
-  @property
-  def sunlight(self) -> float:
-    """Hours of sunlight."""
+  location: str
+  """The location's name."""
 
-    return float(self.__inner['sunHour'])
+  country: str
+  """The local country's name."""
 
-  @property
-  def snowfall(self) -> float:
-    """Total snowfall in either centimeters or inches."""
+  datetime: 'datetime'
+  """The local date and time of this weather forecast."""
 
-    return float(self.__inner['totalSnow_cm']) / self._CustomizableBase__unit.cm_divisor
+  coordinates: Tuple[float, float]
+  """A tuple of this forecast's latitude and longitude."""
 
-  @property
-  def hourly_forecasts(self) -> Iterable[HourlyForecast]:
-    """The hourly forecasts of this day."""
+  daily_forecasts: List[DailyForecast]
+  """Daily weather forecasts in this location."""
 
-    return (
-      HourlyForecast(elem, self._CustomizableBase__unit, self._CustomizableBase__locale)
-      for elem in self.__inner['hourly']
-    )
+  def __init__(self, json: dict, unit: _Unit, locale: Locale):
+    current = json['current_condition'][0]
+    nearest = json['nearest_area'][0]
 
+    self.local_population = int(nearest['population'])
+    self.region = nearest['region'][0]['value']
+    self.location = nearest['areaName'][0]['value']
+    self.country = nearest['country'][0]['value']
+    self.datetime = datetime.strptime(current['localObsDateTime'], '%Y-%m-%d %I:%M %p')
 
-class Forecast(BaseForecast):
-  """Represents today's weather forecast, alongside daily and hourly weather forecasts."""
+    try:
+      req = next(filter(lambda x: x['type'] == 'LatLon', json['request']))
+      match = LATLON_REGEX.match(req['query'])
 
-  __slots__: Tuple[str, ...] = ('__inner', '__nearest')
+      self.coordinates = (float(match[1]), float(match[2]))
+    except:
+      self.coordinates = (float(nearest['latitude']), float(nearest['longitude']))
 
-  def __init__(self, json: dict, unit: _Unit, locale: Locale):
-    current = json['current_condition'][0]
-    self.__nearest = json.pop('nearest_area')[0]
-    self.__inner = json
+    self.daily_forecasts = [
+      DailyForecast(elem, unit, locale) for elem in json['weather']
+    ]
 
     super().__init__(current, unit, locale)
 
   def __repr__(self) -> str:
     return f'<{__class__.__name__} location={self.location!r} datetime={self.datetime!r} temperature={self.temperature!r}>'
 
-  def __iter__(self) -> Iterable[DailyForecast]:
-    return self.daily_forecasts
-
-  def __list__(self) -> List[DailyForecast]:
-    return list(iter(self))
-
-  @property
-  def local_population(self) -> int:
-    """The local population count."""
-
-    return int(self.__nearest['population'])
-
-  @property
-  def region(self) -> str:
-    """The local region's name."""
-
-    return self.__nearest['region'][0]['value']
-
-  @property
-  def location(self) -> str:
-    """The location's name."""
-
-    return self.__nearest['areaName'][0]['value']
-
-  @property
-  def country(self) -> str:
-    """The local country's name."""
-
-    return self.__nearest['country'][0]['value']
-
-  @property
-  def datetime(self) -> datetime:
-    """The local date and time of this weather forecast."""
+  def __len__(self) -> int:
+    return len(self.daily_forecasts)
 
-    return datetime.strptime(
-      self._BaseForecast__inner['localObsDateTime'], '%Y-%m-%d %I:%M %p'
-    )
-
-  @property
-  def daily_forecasts(self) -> Iterable[DailyForecast]:
-    """Daily weather forecasts in this location."""
-
-    return (
-      DailyForecast(elem, self._CustomizableBase__unit, self._CustomizableBase__locale)
-      for elem in self.__inner['weather']
-    )
-
-  @property
-  def coordinates(self) -> Tuple[float, float]:
-    """A tuple of this forecast's latitude and longitude."""
-
-    try:
-      req = next(filter(lambda x: x['type'] == 'LatLon', self.__inner['request']))
-      match = LATLON_REGEX.match(req['query'])
-
-      return float(match[1]), float(match[2])
-    except:
-      return float(self.__nearest['latitude']), float(self.__nearest['longitude'])
+  def __iter__(self) -> Iterable[DailyForecast]:
+    return iter(self.daily_forecasts)

{python_weather-2.0.4.dist-info → python_weather-2.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-weather
-Version: 2.0.4
+Version: 2.0.5
 Summary: A free and asynchronous weather API wrapper made in Python, for Python.
 Author: null8626
 License: MIT
@@ -11,12 +11,11 @@ Project-URL: Donate via GitHub Sponsors, https://github.com/sponsors/null8626
 Project-URL: Donate via Ko-fi, https://ko-fi.com/null8626
 Keywords: weather,forecast,weather-api,weather-forecast
 Classifier: Development Status :: 5 - Production/Stable
-Classifier: Framework :: aiohttp
-Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
 Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
 Classifier: Topic :: Education
 Classifier: Topic :: Internet
 Classifier: Topic :: Scientific/Engineering
@@ -32,10 +31,11 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp >=3.10.8
+Requires-Dist: aiohttp >=3.10.10
 
 # [python-weather][pypi-url] [![pypi][pypi-image]][pypi-url] [![downloads][downloads-image]][pypi-url] [![codacy-badge][codacy-url]][codacy-image] [![ko-fi][ko-fi-brief-image]][ko-fi-url]
 

python_weather-2.0.5.dist-info/RECORD

@@ -0,0 +1,12 @@
+python_weather/__init__.py,sha256=Bmexsn_sEwoirakPu6MHXTuFq1AAdSw-mAC18EPntTM,1586
+python_weather/base.py,sha256=rNxoxmiEbsAlQs2DXB0gpMP0Ug8L0vaqxXA69ez-9Mg,4661
+python_weather/client.py,sha256=IlrI7BjDrRmb9hGlBoYwmJDNvXZt8HmbPexUDgvKhRo,5032
+python_weather/constants.py,sha256=NzfQkxmAPEYAbUHMBUEi9-4XOq0z8FYj1_G_1z5Of-4,2015
+python_weather/enums.py,sha256=I8d8DDAhg3RBvCtiCiTCa0WBz7738ZgBFzoH_iqxqp4,10594
+python_weather/errors.py,sha256=sbCEmzXvC_jxyCVJ8aBVOwIMU3FSM4d0Myu2rYUWaI8,1574
+python_weather/forecast.py,sha256=gNdvMisnjIiNyQQfgImltDPhgB6900PTeCl87hZ_gkI,9124
+python_weather-2.0.5.dist-info/LICENSE,sha256=OhQiuzPzGigVn4yKdwlDJMfyglio438lXJU5ny4WCGk,1080
+python_weather-2.0.5.dist-info/METADATA,sha256=wFMEnFpLJ3OhaEhyg5I5-VlGY-v-SVLdWZQ10yvW0PA,4130
+python_weather-2.0.5.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+python_weather-2.0.5.dist-info/top_level.txt,sha256=NDqLSO3dHB1tjjiNJfEg-a9_eoOmawAZynZsy9Yu48w,15
+python_weather-2.0.5.dist-info/RECORD,,

python_weather-2.0.4.dist-info/RECORD

@@ -1,12 +0,0 @@
-python_weather/__init__.py,sha256=FbHn9_8A63GXbpFmiyPalMPynvtcurGVX8zZk96VNZs,1586
-python_weather/base.py,sha256=esxcbl0nf7ExIczzG0cpvTKAFFKEKRtprj5sU_6wBqQ,5031
-python_weather/client.py,sha256=k9PXBUhQIGOLluNasoOpMhvKMblOfGqZOnGE1lDU_Is,5026
-python_weather/constants.py,sha256=NzfQkxmAPEYAbUHMBUEi9-4XOq0z8FYj1_G_1z5Of-4,2015
-python_weather/enums.py,sha256=e5O1rbyQD42vv4ATDJP4z32UPbPn5UVytNdtycYhBOE,10650
-python_weather/errors.py,sha256=sbCEmzXvC_jxyCVJ8aBVOwIMU3FSM4d0Myu2rYUWaI8,1574
-python_weather/forecast.py,sha256=iFoGBhrVELHzbsuJsHcH9xM5FHcbQF8JiRhR74b4yfo,10101
-python_weather-2.0.4.dist-info/LICENSE,sha256=OhQiuzPzGigVn4yKdwlDJMfyglio438lXJU5ny4WCGk,1080
-python_weather-2.0.4.dist-info/METADATA,sha256=1IgvugBGriUP0sYZIePFw1Mo4WgnGvOBYbq_Kl6iUjQ,4097
-python_weather-2.0.4.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-python_weather-2.0.4.dist-info/top_level.txt,sha256=NDqLSO3dHB1tjjiNJfEg-a9_eoOmawAZynZsy9Yu48w,15
-python_weather-2.0.4.dist-info/RECORD,,