python-weather 2.0.4__py3-none-any.whl → 2.0.6__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.6'
 __all__ = (
   'METRIC',
   'IMPERIAL',

python_weather/base.py

@@ -22,7 +22,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 """
 
-from enum import auto
 from typing import Tuple
 
 from .errors import Error
@@ -38,7 +37,7 @@ class CustomizableBase:
     self.locale = locale
 
   @property
-  def unit(self) -> auto:
+  def unit(self) -> _Unit:
     """The measuring unit used to display information in this object."""
 
     return self.__unit
@@ -68,9 +67,9 @@ class CustomizableBase:
     """
     Sets the default localization used to display information in this object.
 
-    :param to: The new :class:`Locale` to be used to display information in this object.
+    :param to: The new :class:`~python_weather.enums.Locale` to be used to display information in this object.
     :type to: Locale
-    :exception Error: If the ``to`` argument is not a part of the :class:`Locale` enum.
+    :exception Error: If the ``to`` argument is not a part of the :class:`~python_weather.enums.Locale` enum.
     """
 
     if not isinstance(to, Locale):
@@ -79,84 +78,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

@@ -23,10 +23,9 @@ SOFTWARE.
 """
 
 from aiohttp import ClientSession, ClientTimeout, TCPConnector
+from typing import Optional, Tuple, Self
 from urllib.parse import quote_plus
-from typing import Optional, Tuple
 from asyncio import sleep
-from enum import auto
 
 from .errors import Error, RequestError
 from .constants import _Unit, METRIC
@@ -40,32 +39,35 @@ class Client(CustomizableBase):
   The class that lets you interact with the API.
 
   :param unit: Whether to use the metric or imperial/customary system (``IMPERIAL``). Defaults to ``METRIC``.
-  :type unit: Optional[:py:class:`enum.auto`]
+  :type unit: _Unit
   :param locale: Whether to use a different locale/language as the description for the returned forecast. Defaults to ``Locale.ENGLISH``.
-  :type locale: Optional[Locale]
-  :param session: Whether to use an existing aiohttp client session for requesting or not. Defaults to ``None`` (creates a new one instead)
-  :type session: Optional[:class:`aiohttp.ClientSession`]
+  :type locale: Locale
+  :param session: Whether to use an existing aiohttp client session for requesting or not. Defaults to ``None`` (creates a new one instead).
+  :type session: Optional[:class:`~aiohttp.ClientSession`]
+  :param max_retries: Maximum amount of retries upon receiving HTTP request failure before raising a :class:`~python_weather.errors.RequestError`. To have infinite retries, use ``-1`` (NOT recommended). Defaults to ``None`` (or 3 retries).
+  :type max_retries: Optional[:class:`int`]
 
-  :raises Error: If ``unit`` is not ``METRIC`` or ``IMPERIAL``, or if ``locale`` is not ``None`` and not a part of the :class:`Locale` enum.
+  :raises Error: If ``unit`` is not ``METRIC`` or ``IMPERIAL``, or if ``locale`` is not ``None`` and not a part of the :class:`~python_weather.enums.Locale` enum.
   """
 
-  __slots__: Tuple[str, ...] = ('__own_session', '__session')
+  __slots__: Tuple[str, ...] = ('__own_session', '__session', '__max_retries')
 
   def __init__(
     self,
     *,
-    unit: Optional[auto] = METRIC,
-    locale: Optional[Locale] = Locale.ENGLISH,
+    unit: _Unit = METRIC,
+    locale: Locale = Locale.ENGLISH,
     session: Optional[ClientSession] = None,
+    max_retries: Optional[int] = None,
   ):
     super().__init__(unit, locale)
 
     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),
     )
+    self.__max_retries = max_retries or 3
 
   def __repr__(self) -> str:
     return f'<{__class__.__name__} {self.__session!r}>'
@@ -74,7 +76,7 @@ class Client(CustomizableBase):
     self,
     location: str,
     *,
-    unit: Optional[auto] = None,
+    unit: Optional[_Unit] = None,
     locale: Optional[Locale] = None,
   ) -> Forecast:
     """
@@ -83,11 +85,12 @@ class Client(CustomizableBase):
     :param location: The requested location name for said weather forecast.
     :type location: str
     :param unit: Overrides the unit used by this object. Defaults to the one used by this object.
-    :type unit: Optional[:py:class:`enum.auto`]
+    :type unit: Optional[``_Unit``]
     :param locale: Overrides the locale used by this object. Defaults to the one used by this object.
-    :type locale: Optional[Locale]
+    :type locale: Optional[:class:`~python_weather.enums.Locale`]
 
-    :exception Error: If the aiohttp client session used by the :class:`Client` object is already closed, if the ``unit`` argument is not ``None`` and it's also not ``METRIC`` or ``IMPERIAL``, if the ``locale`` argument is not ``None`` and it's also not a part of the :class:`Locale` enum, or if the :class:`Client` cannot send a web request to the web server.
+    :exception Error: If the aiohttp client session used by the :class:`~python_weather.client.Client` object is already closed, if the ``unit`` argument is not ``None`` and it's also not ``METRIC`` or ``IMPERIAL``, if the ``locale`` argument is not ``None`` and it's also not a part of the :class:`~python_weather.enums.Locale` enum.
+    :exception RequestError: If the :class:`~python_weather.client.Client` can't send a web request to the web server.
 
     :returns: The requested weather forecast.
     :rtype: Forecast
@@ -106,28 +109,32 @@ class Client(CustomizableBase):
 
     subdomain = f'{locale.value}.' if locale != Locale.ENGLISH else ''
     delay = 0.5
+    attempts = 0
 
     while True:
       try:
         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:
+        if attempts == self.__max_retries:
           raise RequestError(err)
 
         await sleep(delay)
+        attempts += 1
         delay *= 2
 
   async def close(self) -> None:
-    """Closes the :class:`Client` object. Nothing will happen if the client uses a pre-existing :class:`aiohttp.ClientSession` or if the session is already closed."""
+    """Closes the :class:`~python_weather.client.Client` object. Nothing will happen if the client uses a pre-existing :class:`~aiohttp.ClientSession` or if the session is already closed."""
 
     if self.__own_session and not self.__session.closed:
       await self.__session.close()
 
-  async def __aenter__(self) -> 'Client':
+  async def __aenter__(self) -> Self:
     return self
 
-  async def __aexit__(self, *_, **__):
+  async def __aexit__(self, *_, **__) -> None:
     await self.close()

python_weather/enums.py

@@ -23,7 +23,7 @@ SOFTWARE.
 """
 
 from enum import Enum
-from typing import Union, Tuple
+from typing import Union, Tuple, Self
 
 from .constants import WIND_DIRECTION_EMOJIS
 
@@ -70,14 +70,14 @@ class HeatIndex(IndexedEnum):
   DANGER = None
   EXTREME_DANGER = None
 
-  def _new(celcius_index: int, true_index: int) -> 'HeatIndex':
+  def _new(celcius_index: int, true_index: int) -> Self:
     enum = HeatIndex(celcius_index)
     enum.index = true_index
 
     return enum
 
   @classmethod
-  def _missing_(self, celcius_index: int) -> 'HeatIndex':
+  def _missing_(self, celcius_index: int) -> Self:
     if celcius_index <= 32:
       return self.CAUTION
     elif celcius_index <= 39:
@@ -99,14 +99,14 @@ class UltraViolet(BasicEnum, IndexedEnum):
   VERY_HIGH = None
   EXTREME = None
 
-  def _new(index: int) -> 'UltraViolet':
+  def _new(index: int) -> Self:
     enum = UltraViolet(index)
     enum.index = index
 
     return enum
 
   @classmethod
-  def _missing_(self, index: int) -> 'UltraViolet':
+  def _missing_(self, index: int) -> Self:
     if index <= 2:
       return self.LOW
     elif index <= 5:
@@ -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'
 
-  def _new(value: str, degrees: float) -> 'WindDirection':
+  degrees: float
+  """The wind direction's value in degrees."""
+
+  def _new(value: str, degrees: float) -> Self:
     enum = WindDirection(value)
-    enum.__degrees = degrees
+    enum.degrees = degrees
 
     return enum
 
@@ -183,20 +186,17 @@ class WindDirection(BasicEnum):
     else:
       return 326.25 < other <= 348.75
 
-  def __float__(self) -> float:
-    return self.__degrees
-
-  @property
-  def degrees(self) -> int:
-    """The wind direction's value in degrees."""
+  def __int__(self) -> int:
+    return int(self.degrees)
 
-    return self.__degrees
+  def __float__(self) -> float:
+    return self.degrees
 
   @property
   def emoji(self) -> str:
     """The emoji representing this enum."""
 
-    return WIND_DIRECTION_EMOJIS[int(((self.__degrees + 22.5) % 360) / 45.0)]
+    return WIND_DIRECTION_EMOJIS[int(((self.degrees + 22.5) % 360) / 45.0)]
 
 
 class Locale(Enum):
@@ -310,39 +310,30 @@ class Kind(BasicEnum):
   THUNDERY_SNOW_SHOWERS = 392
 
   @classmethod
-  def _missing_(self, value: int) -> 'Kind':
-    if value == 248 or value == 260:
+  def _missing_(self, value: int) -> Self:
+    if value in (248, 260):
       return self.FOG
-    elif value == 263 or value == 353:
+    elif value in (263, 353):
       return self.LIGHT_SHOWERS
-    elif value == 362 or value == 365 or value == 374:
+    elif value in (362, 365, 374):
       return self.LIGHT_SLEET_SHOWERS
-    elif (
-      value == 185
-      or value == 281
-      or value == 284
-      or value == 311
-      or value == 314
-      or value == 317
-      or value == 350
-      or value == 377
-    ):
+    elif value in (185, 281, 284, 311, 314, 317, 350, 377):
       return self.LIGHT_SLEET
     elif value == 386:
       return self.THUNDERY_SHOWERS
     elif value == 320:
       return self.LIGHT_SNOW
-    elif value == 329 or value == 332 or value == 338:
+    elif value in (329, 332, 338):
       return self.HEAVY_SNOW
-    elif value == 293 or value == 296:
+    elif value in (293, 296):
       return self.LIGHT_RAIN
-    elif value == 305 or value == 356:
+    elif value in (305, 356):
       return self.HEAVY_SHOWERS
-    elif value == 308 or value == 359:
+    elif value in (308, 359):
       return self.HEAVY_RAIN
-    elif value == 326 or value == 368:
+    elif value in (326, 368):
       return self.LIGHT_SNOW_SHOWERS
-    elif value == 371 or value == 395:
+    elif value in (371, 395):
       return self.HEAVY_SNOW_SHOWERS
 
   @property

python_weather/errors.py

@@ -32,12 +32,12 @@ class Error(Exception):
 
 
 class RequestError(Error):
-  """Thrown upon HTTP request failure. Extends :class:`Error`."""
+  """Thrown upon HTTP request failure. Extends :class:`~python_weather.errors.Error`."""
 
   __slots__: Tuple[str, ...] = ('source',)
 
   source: Exception
-  """The :class:`Exception` instance causing this exception."""
+  """The :py:class:`Exception` instance causing this exception."""
 
   def __init__(self, source: Exception):
     self.source = source

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.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-weather
-Version: 2.0.4
+Version: 2.0.6
 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.6.dist-info/RECORD

@@ -0,0 +1,12 @@
+python_weather/__init__.py,sha256=2MqLVKS6sre_Q-2YqV-gNDpJkbT5G2rAGGiz4JgeQ24,1586
+python_weather/base.py,sha256=LU_Es_vMWKiptMeLV2CClmY-GEm54J528g8LfHxw0yw,4684
+python_weather/client.py,sha256=w2tp8Mip2FFVAgq9fIMozjpVwptBLihSo04C2-UwDHw,5567
+python_weather/constants.py,sha256=NzfQkxmAPEYAbUHMBUEi9-4XOq0z8FYj1_G_1z5Of-4,2015
+python_weather/enums.py,sha256=9lMyxQjJBHbAu_ceX4maunbDCk4AWjbT8vTUgpBMsVQ,10375
+python_weather/errors.py,sha256=VmRYlHx6s1SMLZf8J7fEkp64RbEAxGibqW9ZxkQdx6c,1600
+python_weather/forecast.py,sha256=gNdvMisnjIiNyQQfgImltDPhgB6900PTeCl87hZ_gkI,9124
+python_weather-2.0.6.dist-info/LICENSE,sha256=OhQiuzPzGigVn4yKdwlDJMfyglio438lXJU5ny4WCGk,1080
+python_weather-2.0.6.dist-info/METADATA,sha256=xCzycdBmD5XDMyAiQhOrppFO8RmHA8tZ4w8YU4tuhwM,4130
+python_weather-2.0.6.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+python_weather-2.0.6.dist-info/top_level.txt,sha256=NDqLSO3dHB1tjjiNJfEg-a9_eoOmawAZynZsy9Yu48w,15
+python_weather-2.0.6.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,,