weathergrabber 0.0.1__py3-none-any.whl

weathergrabber/domain/precipitation.py

@@ -0,0 +1,20 @@
+class Precipitation:
+
+    def __init__(
+            self,
+            percentage: str,
+            amount: str = None
+        ):
+        self._percentage = percentage
+        self._amount = amount
+
+    @property
+    def percentage(self) -> str:
+        return self._percentage
+    
+    @property
+    def amount(self) -> str:
+        return self._amount
+
+    def __repr__(self):
+        return f"Precipitation(percentage='{self.percentage}', amount='{self.amount}')" 

weathergrabber/domain/search.py

@@ -0,0 +1,15 @@
+class Search:
+    def __init__(self, id: str, search_name: str | None = None):
+        self._id = id
+        self._search_name = search_name
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def search_name(self) -> str:
+        return self._search_name
+
+    def __repr__(self):
+        return f"Search(id={self.id!r}, search_name={self.search_name!r})"

weathergrabber/domain/sunrise_sunset.py

@@ -0,0 +1,40 @@
+from .weather_icon_enum import WeatherIconEnum
+
+class SunriseSunset:
+    class IconValue:
+        def __init__(self, icon: WeatherIconEnum, value: str):
+            self._icon = icon
+            self._value = value
+
+        @property
+        def icon(self) -> WeatherIconEnum:
+            return self._icon
+        
+        @property
+        def value(self) -> str:
+            return self._value
+        
+        def __str__(self):
+            return f"{self._icon.emoji_icon} {self._value}"
+        
+        def __repr__(self):
+            return f"IconValue(icon={self._icon}, value='{self._value}')"
+
+
+    def __init__(self, sunrise: str, sunset: str):
+        self._sunrise = SunriseSunset.IconValue(WeatherIconEnum.SUNRISE, sunrise)
+        self._sunset = SunriseSunset.IconValue(WeatherIconEnum.SUNSET, sunset)
+
+    @property
+    def sunrise(self) -> "SunriseSunset.IconValue":
+        return self._sunrise
+
+    @property
+    def sunset(self) -> "SunriseSunset.IconValue":
+        return self._sunset
+
+    def __str__(self):
+        return f"Sunrise: {self._sunrise}, Sunset: {self._sunset}"
+    
+    def __repr__(self):
+        return f"SunriseSunset(sunrise={self._sunrise}, sunset={self._sunset})"

weathergrabber/domain/temperature_hight_low.py

@@ -0,0 +1,32 @@
+class TemperatureHighLow:
+    def __init__(self, high: str, low: str, label:str = None):
+        self._high = high
+        self._low = low
+        self._label = label
+
+    @classmethod
+    def from_string(cls, data: str, label:str = None) -> 'TemperatureHighLow':
+        parts = data.split('/')
+        if len(parts) == 2:
+            high, low = parts
+            return cls(high=high.strip(), low=low.strip(), label=label)
+        else:
+            raise ValueError("Invalid temperature high/low string format")
+
+    @property
+    def high(self) -> str:
+        return self._high
+    
+    @property
+    def low(self) -> str:
+        return self._low
+
+    @property
+    def label(self) -> str:
+        return self._label
+
+    def __repr__(self):
+        return f"TemperatureHighLow(high={self.high!r}, low={self.low!r}, label={self.label!r})"
+
+    def __str__(self):
+        return f"{self.high}/{self.low}"

weathergrabber/domain/timestamp.py

@@ -0,0 +1,39 @@
+import re
+
+class Timestamp:
+
+    def __init__(self, time: str, gmt: str, text: str = None):
+        self._time = time
+        self._gmt = gmt
+        self._text = text
+
+    @property
+    def time(self) -> str:
+        return self._time
+    
+    @property
+    def gmt(self) -> str:
+        return self._gmt
+    
+    @property
+    def text(self) -> str:
+        return self._text
+    
+    def __repr__(self):
+        return f"Timestamp(time='{self.time}', gmt='{self.gmt}', text='{self.text}')"
+    
+    def __str__(self):
+        if self.text != None:
+            return self.text
+        return f"As of {self.time} {self.gmt}"
+    
+    @classmethod
+    def from_string(cls, text) -> "Timestamp":
+        # "As of 4:23 pm GMT-03:00",
+        # "As of 16:37 GMT-03:00",
+        # "Até 16:38 GMT-03:00"
+        pattern = re.compile(r'(\d{1,2}:\d{2}(?: ?[ap]m)?)\s+(GMT[+-]\d{2}:\d{2})')
+        match = pattern.search(text)
+        if match:
+            time, gmt = match.groups()
+            return cls(time=time, gmt=gmt, text=text)

weathergrabber/domain/today_details.py

@@ -0,0 +1,79 @@
+from .temperature_hight_low import TemperatureHighLow
+from .label_value import LabelValue
+from typing import Optional
+from .uv_index import UVIndex
+from .moon_phase import MoonPhase
+from .sunrise_sunset import SunriseSunset
+
+class TodayDetails:
+
+    def __init__(
+            self,
+            feelslike: LabelValue,
+            sunrise_sunset: Optional["SunriseSunset"],
+            high_low: Optional[TemperatureHighLow],
+            wind: LabelValue,
+            humidity: LabelValue,
+            dew_point: LabelValue,
+            pressure: LabelValue,
+            uv_index: Optional[UVIndex],
+            visibility: LabelValue,
+            moon_phase: Optional[MoonPhase]
+        ):
+        self._feelslike = feelslike
+        self._sunrise_sunset = sunrise_sunset
+        self._high_low = high_low
+        self._wind = wind
+        self._humidity = humidity
+        self._dew_point = dew_point
+        self._pressure = pressure
+        self._uv_index = uv_index
+        self._visibility = visibility
+        self._moon_phase = moon_phase
+
+    @property
+    def feelslike(self) -> LabelValue:
+        return self._feelslike
+
+    @property
+    def sunrise_sunset(self) -> Optional[SunriseSunset]:
+        return self._sunrise_sunset
+
+    @property
+    def high_low(self) -> Optional[TemperatureHighLow]:
+        return self._high_low
+    
+    @property
+    def wind(self) -> LabelValue:
+        return self._wind
+    
+    @property
+    def humidity(self) -> LabelValue:
+        return self._humidity
+    
+    @property
+    def dew_point(self) -> LabelValue:
+        return self._dew_point
+    
+    @property
+    def pressure(self) -> LabelValue:
+        return self._pressure
+    
+    @property
+    def uv_index(self) -> Optional[UVIndex]:
+        return self._uv_index
+    
+    @property
+    def visibility(self) -> LabelValue:
+        return self._visibility
+    
+    @property
+    def moon_phase(self) -> Optional[MoonPhase]:
+        return self._moon_phase
+
+    def __repr__(self):
+        return (f"TodayDetails(feelslike={self.feelslike!r}, sunrise_sunset={self.sunrise_sunset!r},"
+                f"high_low={self.high_low!r}, wind={self.wind!r}, "
+                f"humidity={self.humidity!r}, dew_point={self.dew_point!r}, "
+                f"pressure={self.pressure!r}, uv_index={self.uv_index!r}, "
+                f"visibility={self.visibility!r}, moon_phase={self.moon_phase!r})")

weathergrabber/domain/uv_index.py

@@ -0,0 +1,43 @@
+class UVIndex:
+
+    def __init__(self, string_value: str, index: str, of: str = None, label:str = None):
+        self._string_value = string_value
+        self._index = index
+        self._of = of
+        self._label = label
+
+    @property
+    def string_value(self) -> str:
+        return self._string_value
+
+    @property
+    def index(self) -> str:
+        return self._index
+    
+    @property
+    def of(self) -> str:
+        return self._of
+
+    @property
+    def label(self) -> str:
+        return self._label
+
+    @classmethod
+    def from_string(cls, data: str, label: str = None) -> 'UVIndex':
+        parts = data.split(' ')
+        if len(parts) == 1:
+            return cls(string_value = data, index= parts[0].strip(), of="", label=label)
+        elif len(parts) == 3:
+            index, of, some = parts
+            return cls(string_value = data, index=index.strip(), of=some.strip(), label=label)
+        else:
+            raise ValueError(f"Cannot parse UV Index from string: {data}")
+    
+    def __repr__(self) -> str:
+        return f"UVIndex(string_value={self.string_value!r}, index={self.index!r}, of={self.of!r}, label={self.label!r})"
+    
+    def __str__(self) -> str:
+        if self.string_value:
+            return f"{self.label}: {self.string_value}"
+        elif self.index and self.of:
+            return f"{self.label}: {self.index} {self.of}" if self.label else f"{self.index} {self.of}"

weathergrabber/domain/weather_icon_enum.py

@@ -0,0 +1,58 @@
+from enum import Enum
+
+class WeatherIconEnum(Enum):
+    CLEAR = ('clear', chr(0xF0599), '☀️')
+    CLEAR_NIGHT = ('clear-night', chr(0xF0594), '🌙')
+    CLOUDY = ('cloudy', '\uf0c2', '☁️')
+    CLOUDY_FOGGY_DAY = ('cloudy-foggy-day', '\u200B', '\u200B')
+    CLOUDY_FOGGY_NIGHT = ('cloudy-foggy-night', '\u200B', '\u200B')
+    DAY = ('day', '\uf185', '🌞')
+    FEEL = ('feel', '\uf2c9', '🥵')
+    HUMIDITY = ('humidity', '\uf043', '💧')
+    MOSTLY_CLEAR_DAY = ('mostly-clear-day', chr(0xF0599), '☀️')
+    MOSTLY_CLEAR_NIGHT = ('mostly-clear-night', chr(0xF0594), '🌙')
+    MOSTLY_CLOUDY_DAY = ('mostly-cloudy-day', chr(0xf013), '☁️')
+    MOSTLY_CLOUDY_NIGHT = ('mostly-cloudy-night', chr(0xf013), '☁️')
+    NIGHT = ('night', '\uf186', '🌜')
+    PARTLY_CLOUDY_DAY = ('partly-cloudy-day', chr(0xF0595), '⛅')
+    PARTLY_CLOUDY_NIGHT = ('partly-cloudy-night', chr(0xF0F31), '☁️')
+    RAIN = ('rain', '\uf0e9', '🌧️')
+    RAINY_DAY = ('rainy-day', chr(0x1F326), '🌧️')
+    RAINY_NIGHT = ('rainy-night', chr(0x1F326), '🌧️')
+    SCATTERED_SHOWERS_DAY = ('scattered-showers-day', chr(0x1F326), '🌦️')
+    SCATTERED_SHOWERS_NIGHT = ('scattered-showers-night', chr(0x1F326), '🌦️')
+    SEVERE = ('severe', '\ue317', '🌩️')
+    SHOWERS = ('showers', '\u26c6', '🌧️')
+    SNOW = ('snow', '\uf2dc', '❄️')
+    SNOWY_ICY_DAY = ('snowy-icy-day', '\uf2dc', '❄️')
+    SNOWY_ICY_NIGHT = ('snowy-icy-night', '\uf2dc', '❄️')
+    SUNNY = ('sunny', chr(0xF0599), '☀️')
+    SUNRISE = ('sunrise', '\ue34c', '🌅')
+    SUNSET = ('sunset', '\ue34d', '🌇')
+    THUNDERSTORM = ('thunderstorm', '\uf0e7', '⛈️')
+    VISIBILITY = ('visibility', '\uf06e', '👁️')
+    WIND = ('wind', chr(0xf059d), '🌪️')
+
+    def __init__(self, name: str, fa_icon: str, emoji_icon: str):
+        self._name = name
+        self._fa_icon = fa_icon
+        self._emoji_icon = emoji_icon
+
+    @property
+    def name(self):
+        return self._name
+    
+    @property
+    def fa_icon(self):
+        return self._fa_icon
+    
+    @property
+    def emoji_icon(self):   
+        return self._emoji_icon
+
+    @staticmethod
+    def from_name(name: str):
+        for item in WeatherIconEnum:
+            if item._name == name:
+                return item
+        return None

weathergrabber/domain/wind.py

@@ -0,0 +1,28 @@
+class Wind:
+
+    def __init__(self,direction: str,speed: str):
+        self._direction = direction
+        self._speed = speed
+
+    @property
+    def direction(self) -> str:
+        return self._direction
+    
+    @property
+    def speed(self) -> str:
+        return self._speed
+    
+    def __str__(self):
+        return f"Wind Speed: {self.direction} {self.speed}"
+    
+    def __repr__(self):
+        return f"Wind(direction:'{self.direction}', speed: '{self.speed}')"
+    
+    @classmethod
+    def from_string(cls, data: str) -> 'Wind':
+        parts = data.split(" ")
+        if len(parts) == 2:
+            direction, speed = parts
+            return cls(direction=direction.strip(), speed=speed.strip())
+        else:
+            raise ValueError("Invalid Wind Speed string format")

weathergrabber/service/extract_aqi_service.py

@@ -0,0 +1,30 @@
+import logging
+from weathergrabber.domain.air_quality_index import AirQualityIndex
+from pyquery import PyQuery
+
+class ExtractAQIService:
+
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        pass
+
+    def execute(self, weather_data: PyQuery) -> AirQualityIndex | None:
+
+        self.logger.debug("Extracting Air Quality Index (AQI)...")
+
+        try:
+            # 'Air Quality Index\n27\nGood\nAir quality is considered satisfactory, and air pollution poses little or no risk.\nSee Details\nInfo'
+            aqi_data = weather_data("section[data-testid='AirQualityModule']").text()
+            
+            # 'stroke-width:5;stroke-dasharray:10.021680564951442 172.78759594743863;stroke:#00E838'
+            color_data = weather_data("section[data-testid='AirQualityModule'] svg[data-testid='DonutChart'] circle:nth-of-type(2)").attr("style")
+            
+            air_quality_index = AirQualityIndex.aqi_color_from_string(aqi_data,color_data)
+            
+            self.logger.debug(f"Extracted AQI data: {air_quality_index}")
+            
+            return air_quality_index
+        except Exception as e:
+            self.logger.error(f"Error extracting AQI data: {e}")
+            raise ValueError("Could not extract AQI data") from e
+        

weathergrabber/service/extract_current_conditions_service.py

@@ -0,0 +1,47 @@
+import logging
+from pyquery import PyQuery
+from weathergrabber.domain.weather_icon_enum import WeatherIconEnum
+from weathergrabber.domain.city_location import CityLocation
+from weathergrabber.domain.timestamp import Timestamp
+from weathergrabber.domain.day_night import DayNight
+from weathergrabber.domain.current_conditions import CurrentConditions
+
+class ExtractCurrentConditionsService:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        pass
+
+    def execute(self, weather_data: PyQuery) -> dict:
+        try:
+            self.logger.debug("Extracting Current Conditions")
+
+            data = PyQuery(weather_data('div[data-testid="CurrentConditionsContainer"]'))
+            
+            city_location_data = data.find('h1').text() #'Nova Friburgo, Rio de Janeiro, Brazil'
+            timestamp_data = data.find('span[class*="timestamp"]').text() # 'As of 8:01 pm GMT-03:00'
+            icon_data = data.find('svg[class*="wxIcon"]').attr('name') # 'partly-cloudy-night'
+            temp_day_night = data.find('div[class*="tempHiLoValue"]').text() #'Day\xa063°\xa0•\xa0Night\xa046°'
+
+            city_location = CityLocation.from_string(city_location_data)
+            timestamp = Timestamp.from_string(timestamp_data)
+            temperature = data.find('span[class*="tempValue"]').text() # '48°'
+            icon = WeatherIconEnum.from_name(icon_data)
+            phrase = data.find('div[data-testid*="wxPhrase"]').text() # 'Partly Cloudy'
+            day_night = DayNight.from_string(temp_day_night)
+
+            current_conditions = CurrentConditions(
+                location=city_location,
+                timestamp=timestamp,
+                temperature=temperature,
+                icon=icon,
+                summary=phrase,
+                day_night=day_night
+            )
+
+            self.logger.debug(f"Extracted current conditions: {current_conditions}")
+
+            return current_conditions
+
+        except Exception as e:
+            self.logger.error(f"Error extracting current conditions: {e}")
+            raise ValueError("Could not extract current conditions") from e

weathergrabber/service/extract_daily_forecast_oldstyle_service.py

@@ -0,0 +1,51 @@
+import logging
+from pyquery import PyQuery
+from weathergrabber.domain.daily_predictions import DailyPredictions
+from weathergrabber.domain.temperature_hight_low import TemperatureHighLow
+from weathergrabber.domain.weather_icon_enum import WeatherIconEnum
+from weathergrabber.domain.precipitation import Precipitation
+from typing import List
+
+class ExtractDailyForecastOldstyleService:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        pass
+
+    def execute(self, weather_data: PyQuery) -> List[DailyPredictions]:
+        self.logger.debug("Extracting daily forecast, oldstyle...")
+        
+        try:
+
+            data = weather_data.find("div[class*='DailyWeatherCard'] > ul li")
+
+            if len(data) == 0:
+                raise ValueError("Unable to extract hourly forecast using old style")
+
+            details = [ {
+                "title": PyQuery(item).find("h3 > span").text(),
+                "high-low" : PyQuery(item).find("div[data-testid='SegmentHighTemp']").text(),
+                "icon" : PyQuery(item).find("svg").attr("name"),
+                "summary" : PyQuery(item).find("span[class*='Column--iconPhrase']").text(),
+                "precip-percentage" : PyQuery(item).find("div[data-testid='SegmentPrecipPercentage'] span[class*='Column--precip']").contents().eq(1).text()
+            } for item in data ]
+
+            self.logger.debug("Extracted %s register(s)...",len(details))
+
+            daily_predictions = [DailyPredictions(
+                title=item["title"],
+                high_low=TemperatureHighLow.from_string(item["high-low"]),
+                icon=WeatherIconEnum.from_name(item["icon"]),
+                summary=item["summary"],
+                precipitation=Precipitation(
+                    percentage=item["precip-percentage"]
+                )
+            ) for item in details]
+
+            self.logger.debug("Created daily forecast list with %s registers", len(daily_predictions))
+
+            return daily_predictions
+        
+        except Exception as e:
+
+            self.logger.error(f"Error extracting daily forecast: {e}")
+            raise ValueError("Could not extract daily forecast.") from e

weathergrabber/service/extract_daily_forecast_service.py

@@ -0,0 +1,56 @@
+import logging
+from pyquery import PyQuery
+from weathergrabber.domain.precipitation import Precipitation
+from weathergrabber.domain.weather_icon_enum import WeatherIconEnum
+from weathergrabber.domain.moon_phase_enum import MoonPhaseEnum
+from weathergrabber.domain.moon_phase import MoonPhase
+from weathergrabber.domain.temperature_hight_low import TemperatureHighLow
+from weathergrabber.domain.daily_predictions import DailyPredictions
+
+from typing import List
+
+
+class ExtractDailyForecastService:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        pass
+
+    def execute(self, weather_data: PyQuery) -> List[DailyPredictions]:
+        try:
+            self.logger.debug("Extracting hourly forecast...")
+
+            data = weather_data.find("section[data-testid='DailyForecast'] div[class*='Card'] details")
+
+            if len(data) == 0:
+                raise ValueError("Unable to extract daily forecast")
+
+            details = [ { 
+                "title": PyQuery(item).find("h2[data-testid='daypartName']").text(),
+                "high-low" : PyQuery(item).find("div[data-testid='detailsTemperature']").text(),
+                "icon" : PyQuery(item).find("svg[class*='DetailsSummary']").attr("name"),
+                "summary" : PyQuery(item).find("span[class*='DetailsSummary--wxPhrase']").text(),
+                "precip-percentage": PyQuery(item).find("div[data-testid='Precip'] span[data-testid='PercentageValue']").text(),
+                "moon-phase-icon": PyQuery(item).find("li[data-testid='MoonphaseSection'] svg[class*='DetailsTable']").attr('name'),
+                "moon-phase-value": PyQuery(item).find("li[data-testid='MoonphaseSection'] span[data-testid='moonPhase']").text(),
+            } for item in data ]
+
+            self.logger.debug("Extracted %s register(s)...",len(details))
+
+            daily_predictions = [ 
+                DailyPredictions(
+                    title=item["title"],
+                    high_low = TemperatureHighLow.from_string(item["high-low"]),
+                    icon = WeatherIconEnum.from_name(item["icon"]),
+                    summary = item["summary"],
+                    precipitation = Precipitation(percentage=item["precip-percentage"]),
+                    moon_phase = MoonPhase(MoonPhaseEnum.from_name(item["moon-phase-icon"]),item["moon-phase-value"])
+            ) for item in details ]
+
+            self.logger.debug("Created list of daily predictions with %s items", len(daily_predictions))
+
+            return daily_predictions
+
+
+        except Exception as e:
+            self.logger.error(f"Error extracting daily forecast: {e}")
+            raise ValueError("Could not extract daily forecast.") from e

weathergrabber/service/extract_health_activities_service.py

@@ -0,0 +1,25 @@
+import logging
+from pyquery import PyQuery
+from weathergrabber.domain.health_activities import HealthActivities
+
+class ExtractHealthActivitiesService:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+
+    def execute(self, weather_data: PyQuery) -> HealthActivities | None:
+        
+        self.logger.debug("Extracting Health & Activities...")
+
+        try:
+            # 'Health & Activities\nGrass\nSeasonal Allergies and Pollen Count Forecast\nGrass pollen is low in your area'
+            data = weather_data("section[data-testid='HealthAndActivitiesModule']").text()
+
+            health_activities = HealthActivities.from_text(data) if data else None
+
+            self.logger.debug(f"Extracted Health & Activities data: {health_activities}")
+
+            return health_activities
+        
+        except Exception as e:
+            self.logger.error(f"Error extracting Health & Activities data: {e}")
+            raise ValueError("Could not extract Health & Activities data") from e

weathergrabber/service/extract_hourly_forecast_oldstyle_service.py

@@ -0,0 +1,50 @@
+import logging
+from pyquery import PyQuery
+from weathergrabber.domain.hourly_predictions import HourlyPredictions
+from weathergrabber.domain.weather_icon_enum import WeatherIconEnum
+from weathergrabber.domain.precipitation import Precipitation
+from typing import List
+
+class ExtractHourlyForecastOldstyleService:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        pass
+
+    def execute(self, weather_data: PyQuery) -> List[HourlyPredictions]:
+        self.logger.debug("Extracting hourly forecast, oldstyle...")
+        
+        try:
+
+            data = weather_data.find("div[class*='TodayWeatherCard'] > ul li")
+
+            if len(data) == 0:
+                raise ValueError("Unable to extract hourly forecast using old style")
+
+            details = [ {
+                "title": PyQuery(item).find("h3 > span").text(),
+                "temperature" : PyQuery(item).find("span[data-testid='TemperatureValue']").text(),
+                "icon" : PyQuery(item).find("svg").attr("name"),
+                "summary" : PyQuery(item).find("span[class*='Column--iconPhrase']").text(),
+                "precip-percentage" : PyQuery(item).find("div[data-testid='SegmentPrecipPercentage'] span[class*='Column--precip']").contents().eq(1).text()
+            } for item in data ]
+
+            self.logger.debug("Extracted %s register(s)...",len(details))
+
+            hourly_forecasts = [HourlyPredictions(
+                title=item["title"],
+                temperature=item["temperature"],
+                icon=WeatherIconEnum.from_name(item["icon"]),
+                summary=item["summary"],
+                precipitation=Precipitation(
+                    percentage=item["precip-percentage"]
+                )
+            ) for item in details]
+
+            self.logger.debug("Created hourly forecast list with %s registers", len(hourly_forecasts))
+
+            return hourly_forecasts
+        
+        except Exception as e:
+
+            self.logger.error(f"Error extracting hourly forecast: {e}")
+            raise ValueError("Could not extract hourly forecast.") from e