python-weather 2.0.0__tar.gz → 2.0.1__tar.gz

{python-weather-2.0.0 → python-weather-2.0.1}/MANIFEST.in

@@ -1,9 +1,10 @@
+prune .ruff_cache
 prune .github
 prune docs
 exclude .gitattributes
 exclude .gitignore
 exclude .readthedocs.yml
-exclude .style.yapf
+exclude ruff.toml
 exclude LICENSE
 exclude changelog.yml
 exclude test.py

{python-weather-2.0.0/python_weather.egg-info → python-weather-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-weather
-Version: 2.0.0
+Version: 2.0.1
 Summary: A free and asynchronous weather API wrapper made in Python, for Python.
 Author: null8626
 License: MIT

{python-weather-2.0.0 → python-weather-2.0.1}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools"]
 
 [project]
 name = "python-weather"
-version = "2.0.0"
+version = "2.0.1"
 description = "A free and asynchronous weather API wrapper made in Python, for Python."
 readme = "README.md"
 license = { text = "MIT" }

{python-weather-2.0.0 → python-weather-2.0.1}/python_weather/__init__.py

@@ -1,14 +1,18 @@
-"""
-python-weather
-"""
-
 from .enums import HeatIndex, Kind, Locale, Phase, UltraViolet, WindDirection
 from .constants import METRIC, IMPERIAL
 from .client import Client
 from .errors import Error
 
-__version__ = '2.0.0'
+__version__ = '2.0.1'
 __all__ = (
-  'METRIC', 'IMPERIAL', 'Client', 'Error', 'HeatIndex', 'Kind', 'Locale',
-  'Phase', 'UltraViolet', 'WindDirection'
+  'METRIC',
+  'IMPERIAL',
+  'Client',
+  'Error',
+  'HeatIndex',
+  'Kind',
+  'Locale',
+  'Phase',
+  'UltraViolet',
+  'WindDirection',
 )

{python-weather-2.0.0 → python-weather-2.0.1}/python_weather/base.py

@@ -1,140 +1,137 @@
-from enum import auto, Enum
+from enum import auto
 
+from .errors import Error
 from .enums import WindDirection, Kind, Locale, UltraViolet
 from .constants import _Unit
 
+
 class CustomizableBase:
   __slots__ = ('__unit', '__locale')
-  
+
   def __init__(self, unit: _Unit, locale: Locale):
     self.unit = unit
     self.locale = locale
-  
+
   @property
   def unit(self) -> auto:
     """The measuring unit used to display information in this object."""
-    
+
     return self.__unit
-  
+
   @unit.setter
   def unit(self, to: _Unit):
     """
     Sets the default measuring unit used to display information in this object.
-    
+
     :param to: The new default measuring unit to be used to display information in this object. Must be either ``METRIC`` or ``IMPERIAL``.
     :exception Error: If the ``to`` argument is not either ``METRIC`` or ``IMPERIAL``.
     """
-    
+
     if not isinstance(to, _Unit):
       raise Error('Invalid measuring unit specified!')
-    
+
     self.__unit = to
-  
+
   @property
   def locale(self) -> Locale:
     """The localization used to display information in this object."""
-    
+
     return self.__locale
-  
+
   @locale.setter
   def locale(self, to: Locale):
     """
     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.
     :type to: Locale
     :exception Error: If the ``to`` argument is not a part of the :class:`Locale` enum.
     """
-    
+
     if not isinstance(to, Locale):
       raise Error(f'Expected {to!r} to be a Locale enum')
-    
+
     self.__locale = to
 
+
 class BaseForecast(CustomizableBase):
   __slots__ = ('__inner',)
-  
+
   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."""
-    
-    return int(
-      self.__inner[f'FeelsLike{self._CustomizableBase__unit.temperature}']
-    )
-  
+
+    return int(self.__inner[f'FeelsLike{self._CustomizableBase__unit.temperature}'])
+
   @property
   def humidity(self) -> int:
     """The humidity value in percent."""
-    
+
     return int(self.__inner['humidity'])
-  
+
   @property
   def temperature(self) -> int:
     """The temperature in either Celcius or Fahrenheit."""
-    
+
     return int(self.__inner[f'temp_{self._CustomizableBase__unit.temperature}'])
-  
+
   @property
   def precipitation(self) -> float:
     """The precipitation in either Millimeters or Inches."""
-    
-    return float(
-      self.__inner[f'precip{self._CustomizableBase__unit.precipitation}']
-    )
-  
+
+    return float(self.__inner[f'precip{self._CustomizableBase__unit.precipitation}'])
+
   @property
   def pressure(self) -> float:
     """The pressure in either Pascal or Inches."""
-    
-    return float(
-      self.__inner[f'pressure{self._CustomizableBase__unit.pressure}']
-    )
-  
+
+    return float(self.__inner[f'pressure{self._CustomizableBase__unit.pressure}'])
+
   @property
   def visibility(self) -> int:
     """The visibility distance in either Kilometers or Miles."""
-    
-    return int(
-      self.__inner[f'visibility{self._CustomizableBase__unit.visibility}']
-    )
-  
+
+    return int(self.__inner[f'visibility{self._CustomizableBase__unit.visibility}'])
+
   @property
   def wind_speed(self) -> int:
     """The wind speeds in either Kilometers per hour or Miles per hour."""
-    
-    return int(
-      self.__inner[f'windspeed{self._CustomizableBase__unit.velocity}']
-    )
-  
+
+    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 = self.__inner['weatherDesc'][0]['value'] if self._CustomizableBase__locale == Locale.ENGLISH else self.__inner[f'lang_{self._CustomizableBase__locale.value}'][0]['value'] # yapf: disable
-    
+
+    description = (
+      self.__inner['weatherDesc'][0]['value']
+      if self._CustomizableBase__locale == Locale.ENGLISH
+      else self.__inner[f'lang_{self._CustomizableBase__locale.value}'][0]['value']
+    )
+
     return description.strip()
-  
+
   @property
   def kind(self) -> Kind:
     """The kind of the forecast."""
-    
+
     return Kind(int(self.__inner['weatherCode']))

{python-weather-2.0.0 → python-weather-2.0.1}/python_weather/client.py

@@ -10,81 +10,82 @@ from .forecast import Forecast
 from .errors import Error
 from .enums import Locale
 
+
 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`]
   :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`]
-  
+
   :raises Error: If the ``unit`` argument is not ``None`` and it's also not ``METRIC`` or ``IMPERIAL``, or if the ``locale`` argument is not ``None`` and it's also not a part of the :class:`Locale` enum.
   """
-  
+
   __slots__ = ('__session',)
-  
+
   def __init__(
     self,
     *,
     unit: Optional[auto] = METRIC,
     locale: Optional[Locale] = Locale.ENGLISH,
-    session: Optional[ClientSession] = None
+    session: Optional[ClientSession] = None,
   ):
     super().__init__(unit, locale)
-    
+
     self.__session = session or ClientSession(
       timeout=ClientTimeout(total=5000.0),
-      connector=TCPConnector(verify_ssl=False)
+      connector=TCPConnector(verify_ssl=False),
     )
-  
+
   def __repr__(self) -> str:
     return f'<{self.__class__.__name__} {self.__session!r}>'
-  
+
   async def get(
     self,
     location: str,
     *,
     unit: Optional[auto] = None,
-    locale: Optional[Locale] = None
+    locale: Optional[Locale] = None,
   ) -> Forecast:
     """
     Fetches a weather forecast for a specific location.
-    
+
     :param location: The requested location name for said weather forecast.
     :type location: str
     :param unit: Overrides the metric or imperial/customary system (``IMPERIAL``) used by the :class:`Client` object. Defaults to ``None`` (uses the one from the :class:`Client`).
     :type unit: Optional[:py:class:`enum.auto`]
     :param locale: Overrides the locale/language used by the :class:`Client` object. Defaults to ``None`` (uses the one from the :class:`Client`).
     :type locale: Optional[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.
-    
+
     :returns: The requested weather forecast.
     :rtype: Forecast
     """
-    
+
     if (not isinstance(location, str)) or (not location):
       raise Error(f'Expected a proper location str, got {location!r}')
     elif self.__session.closed:
       raise Error('Client is already closed')
-    
+
     if not isinstance(unit, _Unit):
       unit = self._CustomizableBase__unit
-    
+
     if not isinstance(locale, Locale):
       locale = self._CustomizableBase__locale
-    
+
     subdomain = f'{locale.value}.' if locale != Locale.ENGLISH else ''
     delay = 0
-    
+
     while True:
       if delay != 0:
         await sleep(delay)
         delay *= 2
-      
+
       async with self.__session.get(
         f'https://{subdomain}wttr.in/{quote_plus(location)}?format=j1'
       ) as resp:
@@ -95,15 +96,15 @@ class Client(CustomizableBase):
             raise e  # okay, that's too much requests - just raise the error
           elif delay == 0:
             delay = 0.5
-  
+
   async def close(self):
     """Closes the :class:`Client` object. Nothing will happen if it's already closed."""
-    
+
     if not self.__session.closed:
       await self.__session.close()
-  
+
   async def __aenter__(self):
     return self
-  
+
   async def __aexit__(self, *_, **__):
     await self.close()

{python-weather-2.0.0 → python-weather-2.0.1}/python_weather/constants.py

@@ -1,13 +1,17 @@
 from typing import Union
 from re import compile
-from enum import auto
+
 
 class _Unit:
   __slots__ = (
-    'temperature', 'velocity', 'pressure', 'precipitation', 'visibility',
-    'cm_divisor'
+    'temperature',
+    'velocity',
+    'pressure',
+    'precipitation',
+    'visibility',
+    'cm_divisor',
   )
-  
+
   def __init__(
     self,
     temperature: str,
@@ -23,10 +27,11 @@ class _Unit:
     self.precipitation = precipitation
     self.visibility = visibility
     self.cm_divisor = cm_divisor
-  
+
   def __repr__(self) -> str:
     return f'<Unit [{self.temperature}, {self.velocity}]>'
 
+
 METRIC = _Unit('C', 'Kmph', '', 'MM', '', 1)
 IMPERIAL = _Unit('F', 'Miles', 'Inches', 'Inches', 'Miles', 2.54)
 

{python-weather-2.0.0 → python-weather-2.0.1}/python_weather/enums.py

@@ -1,69 +1,71 @@
-from enum import Enum, auto
+from enum import Enum
 from typing import Union
 
 from .constants import WIND_DIRECTION_EMOJIS
-from .errors import Error
+
 
 class BasicEnum(Enum):
   __slots__ = ()
-  
+
   def __repr__(self) -> str:
     return f'{self.__class__.__name__}.{self.name}'
-  
+
   def __str__(self) -> str:
     return self.name.replace('_', ' ').title()
 
+
 class IndexedEnum(Enum):
   __slots__ = ('__index',)
-  
-  def __lt__(self, other: Union["Self", int, float]) -> bool:
+
+  def __lt__(self, other: Union['IndexedEnum', int, float]) -> bool:
     if isinstance(other, self.__class__):
       return self.__index < other.index
     else:
       return self.__index < other
-  
-  def __eq__(self, other: Union["Self", int, float]) -> bool:
+
+  def __eq__(self, other: Union['IndexedEnum', int, float]) -> bool:
     if isinstance(other, self.__class__):
       return self.__index == other.index
     else:
       return self.__index == other
-  
-  def __gt__(self, other: Union["Self", int, float]) -> bool:
+
+  def __gt__(self, other: Union['IndexedEnum', int, float]) -> bool:
     if isinstance(other, self.__class__):
       return self.__index > other.index
     else:
       return self.__index > other
-  
+
   def __hash__(self) -> int:
     return self.__index
-  
+
   def __int__(self) -> int:
     return self.__index
-  
+
   @property
   def index(self) -> int:
     """The index value."""
-    
+
     return self.__index
-  
+
   @index.setter
   def index(self, new_index: int) -> int:
     self.__index = new_index
 
+
 class HeatIndex(IndexedEnum):
   """Represents a heat index."""
-  
+
   CAUTION = None
   EXTREME_CAUTION = None
   DANGER = None
   EXTREME_DANGER = None
-  
+
   def _new(celcius_index: int, true_index: int):
     enum = HeatIndex(celcius_index)
     enum.index = true_index
-    
+
     return enum
-  
+
   @classmethod
   def _missing_(self, celcius_index: int):
     if celcius_index <= 32:
@@ -75,21 +77,22 @@ class HeatIndex(IndexedEnum):
     else:
       return self.EXTREME_DANGER
 
+
 class UltraViolet(BasicEnum, IndexedEnum):
   """Represents ultra-violet (UV) index."""
-  
+
   LOW = None
   MODERATE = None
   HIGH = None
   VERY_HIGH = None
   EXTREME = None
-  
+
   def _new(index: int):
     enum = UltraViolet(index)
     enum.index = index
-    
+
     return enum
-  
+
   @classmethod
   def _missing_(self, index: int):
     if index <= 2:
@@ -103,38 +106,39 @@ class UltraViolet(BasicEnum, IndexedEnum):
     else:
       return self.EXTREME
 
+
 class WindDirection(BasicEnum):
   """Represents a wind direction."""
-  
+
   __slots__ = ('__degrees',)
-  
-  NORTH = "N"
-  NORTH_NORTHEAST = "NNE"
-  NORTHEAST = "NE"
-  EAST_NORTHEAST = "ENE"
-  EAST = "E"
-  EAST_SOUTHEAST = "ESE"
-  SOUTHEAST = "SE"
-  SOUTH_SOUTHEAST = "SSE"
-  SOUTH = "S"
-  SOUTH_SOUTHWEST = "SSW"
-  SOUTHWEST = "SW"
-  WEST_SOUTHWEST = "WSW"
-  WEST = "W"
-  WEST_NORTHWEST = "WNW"
-  NORTHWEST = "NW"
-  NORTH_NORTHWEST = "NNW"
-  
+
+  NORTH = 'N'
+  NORTH_NORTHEAST = 'NNE'
+  NORTHEAST = 'NE'
+  EAST_NORTHEAST = 'ENE'
+  EAST = 'E'
+  EAST_SOUTHEAST = 'ESE'
+  SOUTHEAST = 'SE'
+  SOUTH_SOUTHEAST = 'SSE'
+  SOUTH = 'S'
+  SOUTH_SOUTHWEST = 'SSW'
+  SOUTHWEST = 'SW'
+  WEST_SOUTHWEST = 'WSW'
+  WEST = 'W'
+  WEST_NORTHWEST = 'WNW'
+  NORTHWEST = 'NW'
+  NORTH_NORTHWEST = 'NNW'
+
   def _new(value: str, degrees: float):
     enum = WindDirection(value)
     enum.__degrees = degrees
-    
+
     return enum
-  
-  def __contains__(self, other: Union["WindDirection", float, int]) -> bool:
+
+  def __contains__(self, other: Union['WindDirection', float, int]) -> bool:
     if isinstance(other, self.__class__):
       other = other.degrees
-    
+
     if self is self.NORTH:
       return other > 348.75 or other <= 11.25
     elif self is self.NORTH_NORTHEAST:
@@ -167,27 +171,28 @@ class WindDirection(BasicEnum):
       return 303.75 < other <= 326.25
     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."""
-    
+
     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)]
 
+
 class Locale(Enum):
   """Represents the list of supported locales/languages by this library."""
-  
+
   __slots__ = ()
-  
+
   AFRIKAANS = 'af'
   AMHARIC = 'am'
   ARABIC = 'ar'
@@ -260,19 +265,20 @@ class Locale(Enum):
   VIETNAMESE = 'vi'
   WELSH = 'cy'
   ZULU = 'zu'
-  
+
   def __repr__(self) -> str:
     return f'{self.__class__.__name__}.{self.name}'
-  
+
   def __str__(self) -> str:
     arr = self.name.title().split('_')
     return f'{arr[:-1].join(" ")} ({arr[-1]})' if len(arr) != 1 else arr[0]
 
+
 class Kind(BasicEnum):
   """Represents a weather forecast kind."""
-  
+
   __slots__ = ()
-  
+
   SUNNY = 113
   PARTLY_CLOUDY = 116
   CLOUDY = 119
@@ -291,7 +297,7 @@ class Kind(BasicEnum):
   HEAVY_SNOW_SHOWERS = 335
   THUNDERY_HEAVY_RAIN = 389
   THUNDERY_SNOW_SHOWERS = 392
-  
+
   @classmethod
   def _missing_(self, value: int):
     if value == 248 or value == 260:
@@ -300,7 +306,16 @@ class Kind(BasicEnum):
       return self.LIGHT_SHOWERS
     elif value == 362 or value == 365 or value == 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 == 185
+      or value == 281
+      or value == 284
+      or value == 311
+      or value == 314
+      or value == 317
+      or value == 350
+      or value == 377
+    ):
       return self.LIGHT_SLEET
     elif value == 386:
       return self.THUNDERY_SHOWERS
@@ -318,11 +333,11 @@ class Kind(BasicEnum):
       return self.LIGHT_SNOW_SHOWERS
     elif value == 371 or value == 395:
       return self.HEAVY_SNOW_SHOWERS
-  
+
   @property
   def emoji(self) -> str:
     """The emoji representing this enum."""
-    
+
     if self is self.CLOUDY:
       return '☁️'
     elif self is self.FOG:
@@ -362,11 +377,12 @@ class Kind(BasicEnum):
     else:
       return '✨'
 
+
 class Phase(BasicEnum):
   """Represents a moon phase."""
-  
+
   __slots__ = ()
-  
+
   NEW_MOON = 'New Moon'
   WAXING_CRESCENT = 'Waxing Crescent'
   FIRST_QUARTER = 'First Quarter'
@@ -375,11 +391,11 @@ class Phase(BasicEnum):
   WANING_GIBBOUS = 'Waning Gibbous'
   LAST_QUARTER = 'Last Quarter'
   WANING_CRESCENT = 'Waning Crescent'
-  
+
   @property
   def emoji(self) -> str:
     """The stylized name for this enum."""
-    
+
     if self is self.NEW_MOON:
       return '🌑'
     elif self is self.WAXING_CRESCENT:

{python-weather-2.0.0 → python-weather-2.0.1}/python_weather/errors.py

@@ -1,4 +1,4 @@
 class Error(Exception):
   """Represents a ``python_weather`` error class. Extends :py:class:`Exception`."""
-  
-  __slots__ = ()
+
+  __slots__ = ()

{python-weather-2.0.0 → python-weather-2.0.1}/python_weather/forecast.py

@@ -1,315 +1,315 @@
 from typing import Iterable, Optional, Tuple
 from datetime import datetime, date, time
-from enum import auto
 
 from .base import BaseForecast, CustomizableBase
 from .enums import Phase, Locale, HeatIndex
 from .constants import _Unit, LATLON_REGEX
 
+
 class HourlyForecast(BaseForecast):
   """Represents a weather forecast of a specific hour."""
-  
+
   __slots__ = ()
-  
+
   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'<{self.__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."""
-    
+
     return int(
       self._BaseForecast__inner[f'DewPoint{self._CustomizableBase__unit.temperature}']
-    ) # yapf: disable
-  
+    )
+
   @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}'])
-    ) # yapf: disable
-  
+      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}']
-    ) # yapf: disable
-  
+    )
+
   @property
   def wind_gust(self) -> int:
     """The wind gust value in either Kilometers per hour or Miles per hour."""
-    
+
     key = f'WindGust{self._CustomizableBase__unit.velocity}'
     return int(self._BaseForecast__inner[key])
-  
+
   @property
   def chances_of_fog(self) -> int:
     """Chances of a fog in percent."""
-    
+
     return int(self._BaseForecast__inner['chanceoffog'])
-  
+
   @property
   def chances_of_frost(self) -> int:
     """Chances of a frost in percent."""
-    
+
     return int(self._BaseForecast__inner['chanceoffrost'])
-  
+
   @property
   def chances_of_high_temperature(self) -> int:
     """Chances of a high temperature in percent."""
-    
+
     return int(self._BaseForecast__inner['chanceofhightemp'])
-  
+
   @property
   def chances_of_overcast(self) -> int:
     """Chances of an overcast in percent."""
-    
+
     return int(self._BaseForecast__inner['chanceofovercast'])
-  
+
   @property
   def chances_of_rain(self) -> int:
     """Chances of a rain in percent."""
-    
+
     return int(self._BaseForecast__inner['chanceofrain'])
-  
+
   @property
   def chances_of_remaining_dry(self) -> int:
     """Chances of remaining dry in percent."""
-    
+
     return int(self._BaseForecast__inner['chanceofremdry'])
-  
+
   @property
   def chances_of_snow(self) -> int:
     """Chances of a snow in percent."""
-    
+
     return int(self._BaseForecast__inner['chanceofsnow'])
-  
+
   @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."""
-    
-    return time() if len(self._BaseForecast__inner['time']) < 3 else datetime.strptime(self._BaseForecast__inner['time'], '%H%M').time() # yapf: disable
+
+    return (
+      time()
+      if len(self._BaseForecast__inner['time']) < 3
+      else datetime.strptime(self._BaseForecast__inner['time'], '%H%M').time()
+    )
+
 
 class DailyForecast(CustomizableBase):
   __slots__ = ('__inner', '__astronomy')
-  
+
   def __init__(self, json: dict, unit: _Unit, locale: Locale):
     self.__astronomy = json.pop('astronomy')[0]
     self.__inner = json
-    
+
     super().__init__(unit, locale)
-  
+
   def __repr__(self) -> str:
-    return f'<{self.__class__.__name__} date={self.date!r} temperature={self.temperature!r}>'
-  
+    return (
+      f'<{self.__class__.__name__} date={self.date!r} temperature={self.temperature!r}>'
+    )
+
   @property
   def moon_illumination(self) -> int:
     """The percentage of the moon illuminated."""
-    
+
     return int(self.__astronomy['moon_illumination'])
-  
+
   @property
   def moon_phase(self) -> Phase:
     """The moon's phase."""
-    
+
     return Phase(self.__astronomy['moon_phase'])
-  
+
   @property
   def moonrise(self) -> Optional[time]:
     """The local time when the moon rises. This can be ``None``."""
-    
+
     try:
       return datetime.strptime(self.__astronomy['moonrise'], '%I:%M %p').time()
     except ValueError:
       ...
-  
+
   @property
   def moonset(self) -> Optional[time]:
     """The local time when the moon sets. This can be ``None``."""
-    
+
     try:
       return datetime.strptime(self.__astronomy['moonset'], '%I:%M %p').time()
     except ValueError:
       ...
-  
+
   @property
   def sunrise(self) -> Optional[time]:
     """The local time when the sun rises. This can be ``None``."""
-    
+
     try:
       return datetime.strptime(self.__astronomy['sunrise'], '%I:%M %p').time()
     except ValueError:
       ...
-  
+
   @property
   def sunset(self) -> Optional[time]:
     """The local time when the sun sets. This can be ``None``."""
-    
+
     try:
       return datetime.strptime(self.__astronomy['sunset'], '%I:%M %p').time()
     except ValueError:
       ...
-  
+
   @property
   def date(self) -> date:
     """The local date of this forecast."""
-    
+
     return datetime.strptime(self.__inner['date'], '%Y-%m-%d').date()
-  
+
   @property
   def lowest_temperature(self) -> int:
     """The lowest temperature in either Celcius or Fahrenheit."""
-    
-    return int(
-      self.__inner[f'mintemp{self._CustomizableBase__unit.temperature}']
-    ) # yapf: disable
-  
+
+    return int(self.__inner[f'mintemp{self._CustomizableBase__unit.temperature}'])
+
   @property
   def highest_temperature(self) -> int:
     """The highest temperature in either Celcius or Fahrenheit."""
-    
-    return int(
-      self.__inner[f'maxtemp{self._CustomizableBase__unit.temperature}']
-    ) # yapf: disable
-  
+
+    return int(self.__inner[f'maxtemp{self._CustomizableBase__unit.temperature}'])
+
   @property
   def temperature(self) -> int:
     """The average temperature in either Celcius or Fahrenheit."""
-    
-    return int(
-      self.__inner[f'avgtemp{self._CustomizableBase__unit.temperature}']
-    ) # yapf: disable
-  
+
+    return int(self.__inner[f'avgtemp{self._CustomizableBase__unit.temperature}'])
+
   @property
   def sunlight(self) -> float:
     """Hours of sunlight."""
-    
+
     return float(self.__inner['sunHour'])
-  
+
   @property
   def snowfall(self) -> float:
     """Total snowfall in either Centimeters or Inches."""
-    
-    return float(
-      self.__inner['totalSnow_cm']
-    ) / self._CustomizableBase__unit.cm_divisor
-  
+
+    return float(self.__inner['totalSnow_cm']) / self._CustomizableBase__unit.cm_divisor
+
   @property
   def hourly_forecasts(self) -> Iterable[HourlyForecast]:
     """The hourly forecasts of this day."""
-    
+
     return (
-      HourlyForecast(
-        elem, self._CustomizableBase__unit, self._CustomizableBase__locale
-      ) for elem in self.__inner['hourly']
+      HourlyForecast(elem, self._CustomizableBase__unit, self._CustomizableBase__locale)
+      for elem in self.__inner['hourly']
     )
 
+
 class Forecast(BaseForecast):
   """Represents today's weather forecast, alongside daily and hourly weather forecasts."""
-  
+
   __slots__ = ('__inner', '__nearest')
-  
+
   def __init__(self, json: dict, unit: _Unit, locale: Locale):
     current = json['current_condition'][0]
     self.__nearest = json.pop('nearest_area')[0]
     self.__inner = json
-    
+
     super().__init__(current, unit, locale)
-  
+
   def __repr__(self) -> str:
     return f'<{self.__class__.__name__} location={self.location!r} datetime={self.datetime!r} temperature={self.temperature!r}>'
-  
+
   @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."""
-    
+
     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']
+      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:
-      for req in filter(
-        lambda x: x['type'] == 'LatLon', self.__inner['request']
-      ):
+      for req in filter(lambda x: x['type'] == 'LatLon', self.__inner['request']):
         lat, lon = LATLON_REGEX.findall(req['query'])[0]
-        
+
         return float(lat), float(lon)
     except:
-      return float(self.__nearest['latitude']), float(self.__nearest['longitude']) # yapf: disable
+      return float(self.__nearest['latitude']), float(self.__nearest['longitude'])

{python-weather-2.0.0 → python-weather-2.0.1/python_weather.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-weather
-Version: 2.0.0
+Version: 2.0.1
 Summary: A free and asynchronous weather API wrapper made in Python, for Python.
 Author: null8626
 License: MIT