weathergrabber 0.0.1__py3-none-any.whl

weathergrabber/domain/adapter/output_enum.py

@@ -0,0 +1,6 @@
+from enum import StrEnum
+
+class OutputEnum(StrEnum):
+    CONSOLE = "console"
+    JSON = "json"
+    WAYBAR = "waybar"

weathergrabber/domain/adapter/params.py

@@ -0,0 +1,58 @@
+from .output_enum import OutputEnum
+from .icon_enum import IconEnum
+from typing import Optional
+
+class Params:
+    class Location:
+        def __init__(self, search_name: str = None, id: str = None):
+            self._search_name = search_name
+            self._id = id
+
+        @property
+        def search_name(self) -> str | None:
+            return self._search_name
+        
+        @property
+        def id(self) -> str | None:
+            return self._id
+
+        def __str__(self):
+            return f"Location(search_name={self.search_name}, id={self.id})"
+        
+    def __init__(
+            self,
+            location: Optional["Params.Location"] = None,
+            language: str = "en-US",
+            output_format: OutputEnum = OutputEnum.CONSOLE,
+            keep_open: bool = False,
+            icons: IconEnum = IconEnum.EMOJI
+        ):
+        self._location = location
+        self._language = language
+        self._output_format = output_format
+        self._keep_open = keep_open
+        self._icons = icons
+
+    @property
+    def location(self) -> Optional["Params.Location"]:
+        return self._location
+    
+    @property
+    def language(self) -> str:
+        return self._language
+    
+    @property
+    def output_format(self) -> OutputEnum:
+        return self._output_format
+    
+    @property
+    def keep_open(self) -> bool:
+        return self._keep_open
+    
+    @property
+    def icons(self) -> IconEnum:
+        return self._icons
+    
+    def __str__(self):
+        return f"Params(location={self.location}, language={self.language}, output_format={self.output_format}, keep_open={self.keep_open}, icons={self.icons})"
+    

weathergrabber/domain/air_quality_index.py

@@ -0,0 +1,78 @@
+from .color import Color
+from typing import Optional
+
+class AirQualityIndex:
+    def __init__(self,
+            title: str, 
+            value: int, 
+            category: Optional[str] = None, 
+            description: Optional[str] = None, 
+            acronym: Optional[str] = None, 
+            color: Optional[Color] = None
+        ):
+        self._title = title
+        self._value = value
+        self._category = category
+        self._description = description
+        self._acronym = acronym
+        self._color = color
+
+    @property
+    def title(self) -> str:
+        return self._title
+
+    @property
+    def value(self) -> int:
+        return self._value
+    
+    @property
+    def category(self) -> str | None:
+        return self._category
+    
+    @property
+    def description(self) -> str | None:
+        return self._description
+    
+    @property
+    def acronym(self) -> str | None:
+        return self._acronym
+    
+    @property
+    def color(self) -> Color | None:
+        return self._color
+    
+    def __str__(self) -> str:
+        return f"Title: {self.title}. AQI: {self.value}, Category: {self.category}, Description: {self.description}, Acronym: {self.acronym}, Color: {self.color}"
+    
+    def __repr__(self) -> str:
+        return f"AirQualityIndex(title={self.title}, value={self.value}, category={self.category}, description={self.description}, acronym:{self.acronym}, color={self.color})"
+    
+    @staticmethod
+    def _extract_aqi(data: str):
+        parts = data.split('\n')
+        title = parts[0].strip()
+        aqi = int(parts[1].strip())
+        category = parts[2].strip() if len(parts) > 2 else None
+        description = parts[3].strip() if len(parts) > 3 else None
+        acronym = ''.join(word[0].strip().upper() for word in title.split())
+
+        return title, aqi, category, description, acronym
+    
+    # 'Air Quality Index\n26\nGood\nAir quality is considered satisfactory, and air pollution poses little or no risk.'
+    @classmethod
+    def from_string(cls, data: str) -> 'AirQualityIndex':
+        try:
+            title, aqi, category, description, acronym = AirQualityIndex._extract_aqi(data)
+            return cls(title, aqi, category, description, acronym)
+        except (ValueError, IndexError) as e:
+            raise ValueError("Invalid AQI data format") from e
+        
+    @classmethod
+    def aqi_color_from_string(cls, aqi_data: str, color_data: str):
+        try:
+            title, aqi, category, description, acronym = AirQualityIndex._extract_aqi(aqi_data)
+            color = Color.from_string(color_data)
+            return cls(title, aqi, category, description, acronym, color)
+        except(ValueError, IndexError) as e:
+            raise ValueError("Invalid AQI data format or color data format") from e
+

weathergrabber/domain/city_location.py

@@ -0,0 +1,37 @@
+class CityLocation:
+
+    def __init__(self, city: str, state_province: str = None, country: str = None):
+        self._city = city
+        self._state_province = state_province
+        self._country = country
+
+    @property
+    def city(self) -> str:
+        return self._city
+    
+    @property
+    def state_province(self) -> str:
+        return self._state_province
+    
+    @property
+    def country(self) -> str:
+        return self._country
+    
+    def __repr__(self):
+        return f"CityLocation(city={self.city}, state_province={self.state_province}, country={self.country})"
+
+    @classmethod
+    def from_string(cls, data: str) -> "CityLocation":
+        #'Nova Friburgo, Rio de Janeiro, Brazil'
+        parts = data.split(", ")
+        if len(parts) == 3:
+            city, state_province, country = parts
+            return cls(city=city, state_province=state_province, country=country)
+        if len(parts) == 2:
+            city, state_province = parts
+            return cls(city=city, state_province=state_province)
+        elif len(parts) == 1:
+            city = parts[0]
+            return cls(city=city)
+        else:
+            raise ValueError("Invalid city location string format")

weathergrabber/domain/color.py

@@ -0,0 +1,43 @@
+import re
+
+class Color:
+    
+    def __init__(self, red: str, green: str, blue: str):
+        self._red = red
+        self._green = green
+        self._blue = blue
+
+    @property
+    def red(self):
+        return self._red
+    
+    @property
+    def green(self):
+        return self._green
+    
+    @property
+    def blue(self):
+        return self._blue
+    
+    @classmethod
+    def from_string(cls,string_value: str) -> "Color":
+
+        color_pattern = r"#([0-9A-Fa-f]{6})"        
+        
+        match = re.search(color_pattern, string_value)
+        color = f"#{match.group(1)}"
+        hex_color = color.lstrip('#')
+        r, g, b = int(hex_color[:2], 16), int(hex_color[2:4], 16), int(hex_color[4:], 16)
+        
+        return cls(r, g, b)
+    
+    @property
+    def hex(self) -> str:
+        return f"#{self.red:02x}{self.green:02x}{self.blue:02x}"
+    
+    @property
+    def rgb(self) -> str:
+        return f"rgb({self.red}, {self.green}, {self.blue})"
+    
+    def __repr__(self):
+        return f"Color(red='{self.red}', green='{self.green}', blue='{self.blue}')"

weathergrabber/domain/current_conditions.py

@@ -0,0 +1,53 @@
+from .city_location import CityLocation
+from .timestamp import Timestamp
+from .weather_icon_enum import WeatherIconEnum
+from .day_night import DayNight
+from typing import Optional
+
+class CurrentConditions:
+    def __init__(
+        self,
+        location: Optional[CityLocation],
+        timestamp: Optional[Timestamp],
+        temperature: str,
+        icon: Optional[WeatherIconEnum],
+        summary: str,
+        day_night: Optional[DayNight]
+    ):
+        self._location = location
+        self._timestamp = timestamp
+        self._temperature = temperature
+        self._icon = icon
+        self._summary = summary
+        self._day_night = day_night
+
+    @property
+    def location(self) -> Optional[CityLocation]:
+        return self._location
+
+    @property
+    def timestamp(self) -> Optional[Timestamp]:
+        return self._timestamp
+
+    @property
+    def temperature(self) -> str:
+        return self._temperature
+
+    @property
+    def icon(self) -> Optional[WeatherIconEnum]:
+        return self._icon
+
+    @property
+    def summary(self) -> str:
+        return self._summary
+
+    @property
+    def day_night(self) -> Optional[DayNight]:
+        return self._day_night
+
+    def __repr__(self):
+        return (
+            f"CurrentConditions(location={self._location!r}, timestamp={self._timestamp!r}, "
+            f"temperature={self._temperature!r}, icon={self._icon!r}, summary={self._summary!r}, "
+            f"day_night={self._day_night!r})"
+        )

weathergrabber/domain/daily_predictions.py

@@ -0,0 +1,58 @@
+from .temperature_hight_low import TemperatureHighLow
+from .weather_icon_enum import WeatherIconEnum
+from .moon_phase import MoonPhase
+from .precipitation import Precipitation
+from typing import Optional
+
+class DailyPredictions:
+    def __init__(
+        self,
+        title: str,
+        high_low: Optional[TemperatureHighLow],
+        icon: Optional[WeatherIconEnum],
+        summary: str,
+        precipitation: Optional[Precipitation],
+        moon_phase: Optional[MoonPhase] = None
+    ):
+        self._title = title
+        self._high_low = high_low
+        self._icon = icon
+        self._summary = summary
+        self._precipitation = precipitation
+        self._moon_phase = moon_phase
+
+    # ---- Properties ----
+    @property
+    def title(self) -> str:
+        return self._title
+
+    @property
+    def high_low(self) -> Optional[TemperatureHighLow]:
+        return self._high_low
+
+    @property
+    def icon(self) -> Optional[WeatherIconEnum]:
+        return self._icon
+
+    @property
+    def summary(self) -> str:
+        return self._summary
+
+    @property
+    def precipitation(self) -> Optional[Precipitation]:
+        return self._precipitation
+
+    @property
+    def moon_phase(self) -> Optional[MoonPhase]:
+        return self._moon_phase
+
+    def __repr__(self) -> str:
+        return (
+            f"DailyPredictions("
+            f"title={self._title!r}, "
+            f"high_low={self._high_low!r}, "
+            f"icon={self._icon!r}, "
+            f"summary={self._summary!r}, "
+            f"precipitation={self._precipitation!r}, "
+            f"moon_phase={self._moon_phase!r})"
+        )

weathergrabber/domain/day_night.py

@@ -0,0 +1,50 @@
+class DayNight:
+    class Temperature:
+        def __init__(self, label: str, value: str):
+            self._label = label
+            self._value = value
+
+        @property
+        def label(self):
+            return self._label
+        
+        @property
+        def value(self):
+            return self._value
+        
+        @classmethod
+        def from_string(cls, text:str) -> 'DayNight.Temperature':
+            label, value = text.split("\xa0")
+            return cls(label.strip(), value.strip())
+
+        def __repr__(self):
+            return f"DayNight.Temperature(label={self.label!r}, value={self.value!r})"
+        
+        def __str__(self):
+            return f"{self.label}: {self.value}"
+
+
+    def __init__(self, day: "DayNight.Temperature", night: "DayNight.Temperature"):
+        self._day = day
+        self._night = night
+
+    @property
+    def day(self):
+        return self._day
+    
+    @property
+    def night(self):
+        return self._night
+    
+    @classmethod
+    def from_string(cls, text: str) -> 'DayNight':
+        day_label, night_label = text.split("•")
+        day = DayNight.Temperature.from_string(day_label.strip())
+        night = DayNight.Temperature.from_string(night_label.strip())
+        return cls(day, night)
+    
+    def __repr__(self):
+        return f"DayNight(day={self.day!r}, night={self.night!r})"
+    
+    def __str__(self):
+        return f"Day: {self.day}, Night: {self.night}"

weathergrabber/domain/forecast.py

@@ -0,0 +1,68 @@
+from typing import Optional, List
+from .search import Search
+from .weather_icon_enum import WeatherIconEnum
+from .today_details import TodayDetails
+from .air_quality_index import AirQualityIndex
+from .health_activities import HealthActivities
+from .hourly_predictions import HourlyPredictions
+from .daily_predictions import DailyPredictions
+from .current_conditions import CurrentConditions
+
+
+class Forecast:
+    def __init__(
+        self,
+        search: Optional[Search],
+        current_conditions: Optional[CurrentConditions],
+        today_details: Optional[TodayDetails],
+        air_quality_index: Optional[AirQualityIndex],
+        health_activities: Optional[HealthActivities],
+        hourly_predictions: List[HourlyPredictions],
+        daily_predictions: List[DailyPredictions],
+    ):
+        self._search = search
+        self._current_conditions = current_conditions
+        self._today_details = today_details
+        self._air_quality_index = air_quality_index
+        self._health_activities = health_activities
+        self._hourly_predictions = hourly_predictions
+        self._daily_predictions = daily_predictions
+
+    @property
+    def search(self) -> Optional[Search]:
+        return self._search
+
+    @property
+    def current_conditions(self) -> Optional[CurrentConditions]:
+        return self._current_conditions
+
+    @property
+    def today_details(self) -> Optional[TodayDetails]:
+        return self._today_details
+
+    @property
+    def air_quality_index(self) -> Optional[AirQualityIndex]:
+        return self._air_quality_index
+
+    @property
+    def health_activities(self) -> Optional[HealthActivities]:
+        return self._health_activities
+
+    @property
+    def hourly_predictions(self) -> List[HourlyPredictions]:
+        return self._hourly_predictions
+
+    @property
+    def daily_predictions(self) -> List[DailyPredictions]:
+        return self._daily_predictions
+
+    def __repr__(self) -> str:
+        return (
+            f"Forecast(search={self._search}, "
+            f"current_conditions={self._current_conditions}, "
+            f"today_details={self._today_details}, "
+            f"air_quality_index={self._air_quality_index}, "
+            f"health_activities={self._health_activities}, "
+            f"hourly_predictions={len(self._hourly_predictions)} items, "
+            f"daily_predictions={len(self._daily_predictions)} items)"
+        )

weathergrabber/domain/health_activities.py

@@ -0,0 +1,39 @@
+class HealthActivities:
+    def __init__(self, category_name: str, title: str, description: str):
+        self._category_name = category_name
+        self._title = title
+        self._description = description
+    
+    @property
+    def category_name(self) -> str:
+        return self._category_name
+    
+    @property
+    def title(self) -> str:
+        return self._title
+    
+    @property
+    def description(self) -> str:
+        return self._description
+    
+    def __str__(self) -> str:
+        return f"{self._category_name}: {self._title} - {self._description}"
+    
+    def __repr__(self) -> str:
+        return f"HealthActivities(category_name={self._category_name!r}, title={self._title!r}, description={self._description!r})"
+    
+    # 'Health & Activities\nGrass\nSeasonal Allergies and Pollen Count Forecast\nGrass pollen is low in your area'
+    @staticmethod
+    def from_text(text: str):
+        try:
+            lines = text.split('\n')
+            if len(lines) >= 4:
+                category_name = lines[0].strip()
+                #Ignore the "grass" line
+                title = lines[2].strip()
+                description = ' '.join(line.strip() for line in lines[3:]).strip()
+                return HealthActivities(category_name, title, description)
+            else:
+                raise ValueError("Insufficient data to parse HealthActivities")
+        except Exception as e:
+            raise ValueError("Could not parse HealthActivities from text") from e

weathergrabber/domain/hourly_predictions.py

@@ -0,0 +1,76 @@
+from .weather_icon_enum import WeatherIconEnum
+from .precipitation import Precipitation
+from .wind import Wind
+from .uv_index import UVIndex
+from typing import Optional
+class HourlyPredictions:
+
+    def __init__(
+            self,
+            title: str,
+            temperature: str,
+            icon: WeatherIconEnum,
+            summary: str,
+            precipitation: Optional[Precipitation],
+            wind: Optional[Wind] = None,
+            feels_like: str = None,
+            humidity: str = None,
+            uv_index: Optional[UVIndex] = None,
+            cloud_cover: str = None
+        ):
+        self._title = title
+        self._temperature = temperature
+        self._icon = icon
+        self._summary = summary
+        self._precipitation = precipitation
+        self._wind = wind
+        self._feels_like = feels_like
+        self._humidity = humidity
+        self._uv_index = uv_index
+        self._cloud_cover = cloud_cover
+
+    @property
+    def title(self) -> str:
+        return self._title
+
+    @property
+    def temperature(self) -> str:
+        return self._temperature
+
+    @property
+    def icon(self) -> WeatherIconEnum:
+        return self._icon
+
+    @property
+    def summary(self) -> str:
+        return self._summary
+
+    @property
+    def precipitation(self) -> Optional[Precipitation]:
+        return self._precipitation
+
+    @property
+    def wind(self) -> Optional[Wind]:
+        return self._wind
+
+    @property
+    def feels_like(self) -> str:
+        return self._feels_like
+
+    @property
+    def humidity(self) -> str:
+        return self._humidity
+
+    @property
+    def uv_index(self) -> Optional[UVIndex]:
+        return self._uv_index
+
+    @property
+    def cloud_cover(self) -> str:
+        return self._cloud_cover
+
+    def __repr__(self):
+        return (f"HourlyPredictions(title={self._title!r}, temperature={self._temperature!r}, icon={self._icon!r}, "
+                f"summary={self._summary!r}, precipitation={self._precipitation!r}, wind={self._wind!r}, "
+                f"feels_like={self._feels_like!r}, humidity={self._humidity!r}, uv_index={self._uv_index!r}, "
+                f"cloud_cover={self._cloud_cover!r})")

weathergrabber/domain/label_value.py

@@ -0,0 +1,19 @@
+class LabelValue:
+    def __init__(self, label: str, value: str):
+        self._label = label
+        self._value = value
+
+    @property
+    def label(self) -> str:
+        return self._label
+
+    @property
+    def value(self) -> str:
+        return self._value
+
+    def __repr__(self) -> str:
+        return f"LabelValue(label={self.label!r}, value={self.value!r})"
+    
+
+    def __str__(self) -> str:
+        return f"{self.label} {self.value}"

weathergrabber/domain/moon_phase.py

@@ -0,0 +1,22 @@
+from weathergrabber.domain.moon_phase_enum import MoonPhaseEnum
+
+class MoonPhase:
+    def __init__(self, icon: MoonPhaseEnum, phase: str, label:str = None):
+        self._label = label
+        self._icon = icon
+        self._phase = phase
+
+    @property
+    def label(self) -> str:
+        return self._label
+
+    @property
+    def icon(self) -> MoonPhaseEnum:
+        return self._icon
+    
+    @property
+    def phase(self) -> str:
+        return self._phase
+    
+    def __repr__(self) -> str:
+        return f"MoonPhase(icon={self.icon!r}, phase={self.phase!r},label={self.label!r})"

weathergrabber/domain/moon_phase_enum.py

@@ -0,0 +1,65 @@
+from enum import Enum
+
+class MoonPhaseEnum(Enum):
+# New Moon
+    PHASE_0 = ("phase-0", "\uf186", "🌑")
+    # Waxing Crescent
+    PHASE_1 = ("phase-1", "\uf186", "🌒")
+    PHASE_2 = ("phase-2", "\uf186", "🌒")
+    PHASE_3 = ("phase-3", "\uf186", "🌒")
+    PHASE_4 = ("phase-4", "\uf186", "🌒")
+    PHASE_5 = ("phase-5", "\uf186", "🌒")
+    PHASE_6 = ("phase-6", "\uf186", "🌒")
+    # First Quarter
+    PHASE_7 = ("phase-7", "\uf186", "🌓")
+    # Waxing Gibbous
+    PHASE_8 = ("phase-8", "\uf186", "🌔")
+    PHASE_9 = ("phase-9", "\uf186", "🌔")
+    PHASE_10 = ("phase-10", "\uf186", "🌔")
+    PHASE_11 = ("phase-11", "\uf186", "🌔")
+    PHASE_12 = ("phase-12", "\uf186", "🌔")
+    PHASE_13 = ("phase-13", "\uf186", "🌔")
+    # Full Moon
+    PHASE_14 = ("phase-14", "\uf186", "🌕")
+    # Waning Gibbous
+    PHASE_15 = ("phase-15", "\uf186", "🌖")
+    PHASE_16 = ("phase-16", "\uf186", "🌖")
+    PHASE_17 = ("phase-17", "\uf186", "🌖")
+    PHASE_18 = ("phase-18", "\uf186", "🌖")
+    PHASE_19 = ("phase-19", "\uf186", "🌖")
+    PHASE_20 = ("phase-20", "\uf186", "🌖")
+    # Last Quarter
+    PHASE_21 = ("phase-21", "\uf186", "🌗")
+    # Waning Crescent
+    PHASE_22 = ("phase-22", "\uf186", "🌘")
+    PHASE_23 = ("phase-23", "\uf186", "🌘")
+    PHASE_24 = ("phase-24", "\uf186", "🌘")
+    PHASE_25 = ("phase-25", "\uf186", "🌘")
+    PHASE_26 = ("phase-26", "\uf186", "🌘")
+    PHASE_27 = ("phase-27", "\uf186", "🌘")
+    PHASE_28 = ("phase-28", "\uf186", "🌘")
+    DEFAULT = ("default", "\uf186", "🌑")
+
+    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 MoonPhaseEnum:
+            if item._name == name:
+                return item
+        return None