feat: Major update for flatlib_astrology integration

- Replaced text inputs with Selectors for user and timezone.
- Added new DataUpdateCoordinators for daily, monthly, and yearly horoscopes.
- Implemented API calls for new prediction endpoints.
- Updated API client and config flow to support new features.

Author: navi-vonamut

flatlib_astrology/__init__.py

@@ -1,67 +1,140 @@
-"""The Flatlib Natal Chart integration."""
+# __init__.py
 import logging
-from datetime import timedelta
+from datetime import timedelta, datetime
+import pytz
+
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-from .const import DOMAIN
+
+from .const import DOMAIN, PLATFORMS
 from .api import ApiClient, ApiError
 
 _LOGGER = logging.getLogger(__name__)
-PLATFORMS = ["sensor"]
+
+DAILY_INTERVAL = timedelta(hours=24)
+MONTHLY_INTERVAL = timedelta(hours=24)
+YEARLY_INTERVAL = timedelta(hours=24)
+
+def _convert_timezone_to_offset(tz_name: str) -> str:
+    """Преобразует имя часового пояса в строковое смещение UTC в формате +HH:MM."""
+    try:
+        tz_object = pytz.timezone(tz_name)
+        offset_seconds = tz_object.utcoffset(datetime.now()).total_seconds()
+        
+        offset_hours = int(offset_seconds / 3600)
+        offset_minutes = int((offset_seconds % 3600) / 60)
+        
+        sign = "+" if offset_seconds >= 0 else "-"
+        
+        return f"{sign}{abs(offset_hours):02d}:{abs(offset_minutes):02d}"
+    except (pytz.UnknownTimeZoneError, AttributeError):
+        return "+00:00"
+
+def _get_api_payload(entry: ConfigEntry) -> dict:
+    """Создает полезную нагрузку для запроса API из данных конфигурации."""
+    converted_tz = _convert_timezone_to_offset(entry.data.get("time_zone"))
+    
+    # Теперь отправляем дату в стандартном формате YYYY-MM-DD,
+    # который Home Assistant возвращает и который, как показывает ошибка, ожидает сервер.
+    birth_date_str = entry.data.get("birth_date")
+
+    return {
+        "date": birth_date_str, # Отправляем дату как есть (YYYY-MM-DD)
+        "time": entry.data.get("birth_time"),
+        "tz": converted_tz,
+        "lat": entry.data.get("location", {}).get("latitude"),
+        "lon": entry.data.get("location", {}).get("longitude"),
+    }
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up Flatlib Natal Chart from a config entry."""
-    # Используем общую сессию aiohttp, управляемую Home Assistant
+    """Настройка интеграции Flatlib из записи конфигурации."""
     session = async_get_clientsession(hass)
     api_client = ApiClient(session)
-    
-    # --- ИСПРАВЛЕНИЕ: Получаем данные напрямую, без сложной обработки ---
-    entry_data = entry.data
-    _LOGGER.debug("Setting up Flatlib Natal for: %s", entry_data["name"])
 
-    async def async_update_data():
-        """Fetch data from the flatlib-server API."""
+    async def async_update_natal_data():
+        """Получить данные натальной карты."""
+        payload = _get_api_payload(entry)
         try:
-            location_data = entry.data["location"]
-            # --- ИСПРАВЛЕНИЕ: Корректно форматируем дату и время ---
-            payload = {
-                "date": entry_data["birth_date"],
-                "time": entry_data["birth_time"],
-                "tz": entry_data["time_zone"],
-                "lat": str(location_data["latitude"]),
-                "lon": str(location_data["longitude"]),
-            }
-            _LOGGER.debug("Sending payload to API: %s", payload)
             return await api_client.get_natal_chart(payload)
         except ApiError as err:
-            raise UpdateFailed(f"Error communicating with API: {err}")
-        except KeyError as err:
-            raise UpdateFailed(f"Missing data in config entry: {err}")
+            raise UpdateFailed(f"Ошибка получения натальной карты: {err}")
 
-    coordinator = DataUpdateCoordinator(
+    natal_coordinator = DataUpdateCoordinator(
         hass,
         _LOGGER,
-        name=f"flatlib_natal_{entry_data['name']}",
-        update_method=async_update_data,
-        update_interval=timedelta(hours=24), # Обновляем раз в сутки
+        name=f"flatlib_natal_{entry.data['name']}",
+        update_method=async_update_natal_data,
+        update_interval=DAILY_INTERVAL,
     )
 
-    # Выполняем первое обновление при запуске
-    await coordinator.async_config_entry_first_refresh()
+    async def async_update_daily_data():
+        """Получить данные ежедневного предсказания."""
+        payload = _get_api_payload(entry)
+        try:
+            return await api_client.async_get_daily_prediction(payload)
+        except ApiError as err:
+            raise UpdateFailed(f"Ошибка получения ежедневного предсказания: {err}")
 
-    hass.data.setdefault(DOMAIN, {})
-    hass.data[DOMAIN][entry.entry_id] = coordinator
+    daily_prediction_coordinator = DataUpdateCoordinator(
+        hass,
+        _LOGGER,
+        name=f"flatlib_daily_prediction_{entry.data['name']}",
+        update_method=async_update_daily_data,
+        update_interval=DAILY_INTERVAL,
+    )
+    
+    async def async_update_monthly_data():
+        """Получить данные ежемесячного предсказания."""
+        payload = _get_api_payload(entry)
+        try:
+            return await api_client.async_get_monthly_prediction(payload)
+        except ApiError as err:
+            raise UpdateFailed(f"Ошибка получения ежемесячного предсказания: {err}")
 
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    monthly_prediction_coordinator = DataUpdateCoordinator(
+        hass,
+        _LOGGER,
+        name=f"flatlib_monthly_prediction_{entry.data['name']}",
+        update_method=async_update_monthly_data,
+        update_interval=MONTHLY_INTERVAL,
+    )
 
+    async def async_update_yearly_data():
+        """Получить данные ежегодного предсказания."""
+        payload = _get_api_payload(entry)
+        try:
+            return await api_client.async_get_yearly_prediction(payload)
+        except ApiError as err:
+            raise UpdateFailed(f"Ошибка получения ежегодного предсказания: {err}")
+
+    yearly_prediction_coordinator = DataUpdateCoordinator(
+        hass,
+        _LOGGER,
+        name=f"flatlib_yearly_prediction_{entry.data['name']}",
+        update_method=async_update_yearly_data,
+        update_interval=YEARLY_INTERVAL,
+    )
+
+    await natal_coordinator.async_config_entry_first_refresh()
+    await daily_prediction_coordinator.async_config_entry_first_refresh()
+    await monthly_prediction_coordinator.async_config_entry_first_refresh()
+    await yearly_prediction_coordinator.async_config_entry_first_refresh()
+
+    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = {
+        "natal_coordinator": natal_coordinator,
+        "daily_prediction_coordinator": daily_prediction_coordinator,
+        "monthly_prediction_coordinator": monthly_prediction_coordinator,
+        "yearly_prediction_coordinator": yearly_prediction_coordinator,
+    }
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Unload a config entry."""
+    """Выгрузить запись конфигурации."""
     unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
     if unload_ok:
         hass.data[DOMAIN].pop(entry.entry_id)
-
     return unload_ok

flatlib_astrology/api.py

@@ -1,27 +1,64 @@
-"""API Client for the Flatlib Natal Chart Add-on."""
+# api.py
 import aiohttp
 import asyncio
 from typing import Dict, Any
+from datetime import datetime
+from dateutil.relativedelta import relativedelta  # Новый импорт
 
 class ApiClient:
-    """API Client to communicate with the Flatlib server."""
-
     def __init__(self, session: aiohttp.ClientSession):
-        """Initialize the API client."""
         self._session = session
-        # Supervisor DNS резолвит slug аддона в его IP-адрес
-        self._api_url = f"http://homeassistant.local:8080/natal"
+        self._base_url = "http://localhost:8080"
 
     async def get_natal_chart(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """Get natal chart data from the add-on."""
+        url = f"{self._base_url}/natal"
         try:
-            async with self._session.post(self._api_url, json=payload) as response:
+            async with self._session.post(url, json=payload) as response:
                 response.raise_for_status()
                 return await response.json()
         except asyncio.TimeoutError:
             raise ApiError("Timeout communicating with API")
         except aiohttp.ClientError as err:
             raise ApiError(f"Error communicating with API: {err}")
 
+    async def async_get_daily_prediction(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        url = f"{self._base_url}/predict/daily"
+        
+        today_str = datetime.now().strftime('%Y/%m/%d')
+        prediction_payload = {**payload, "target_date": today_str}
+
+        try:
+            async with self._session.post(url, json=prediction_payload) as response:
+                response.raise_for_status()
+                return await response.json()
+        except asyncio.TimeoutError:
+            raise ApiError("Timeout communicating with API for daily prediction")
+        except aiohttp.ClientError as err:
+            raise ApiError(f"Error communicating with API for daily prediction: {err}")
+
+    # --- НОВЫЙ МЕТОД: Месячный прогноз ---
+    async def async_get_monthly_prediction(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        url = f"{self._base_url}/predict/monthly"
+        try:
+            async with self._session.post(url, json=payload) as response:
+                response.raise_for_status()
+                return await response.json()
+        except asyncio.TimeoutError:
+            raise ApiError("Timeout communicating with API for monthly prediction")
+        except aiohttp.ClientError as err:
+            raise ApiError(f"Error communicating with API for monthly prediction: {err}")
+
+    # --- НОВЫЙ МЕТОД: Годовой прогноз ---
+    async def async_get_yearly_prediction(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        url = f"{self._base_url}/predict/yearly"
+        try:
+            async with self._session.post(url, json=payload) as response:
+                response.raise_for_status()
+                return await response.json()
+        except asyncio.TimeoutError:
+            raise ApiError("Timeout communicating with API for yearly prediction")
+        except aiohttp.ClientError as err:
+            raise ApiError(f"Error communicating with API for yearly prediction: {err}")
+
 class ApiError(Exception):
-    """Exception to indicate a general API error."""
+    """Исключение для обозначения общей ошибки API."""

flatlib_astrology/config_flow.py

@@ -6,36 +6,72 @@
     DateSelector,
     TimeSelector,
     LocationSelector,
+    SelectSelector,
+    SelectSelectorConfig,
 )
 from .const import DOMAIN
+import pytz # <-- Новый импорт!
 
 class FlatlibNatalConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     VERSION = 1
 
     async def async_step_user(self, user_input=None):
-        """Handle the initial step."""
+        """Обработка начального шага."""
         errors = {}
 
+        all_users = await self.hass.auth.async_get_users()
+        excluded_names = ["Supervisor", "Home Assistant Content"]
+        filtered_users = [user for user in all_users if user.name not in excluded_names]
+        user_options = {user.id: user.name for user in filtered_users}
+        
+        # Получаем полный список часовых поясов
+        timezones = pytz.all_timezones
+        timezone_options = [{"value": tz, "label": tz} for tz in timezones]
+        
         if user_input is not None:
-            unique_id = user_input["name"].strip().lower().replace(" ", "_")
-            await self.async_set_unique_id(unique_id)
+            user_id = user_input["user_id"]
+            user_name = user_options.get(user_id, "Unknown User")
+            
+            await self.async_set_unique_id(user_id)
             self._abort_if_unique_id_configured()
+            
+            data = {
+                "user_id": user_id,
+                "name": user_name,
+                "birth_date": user_input["birth_date"],
+                "birth_time": user_input["birth_time"],
+                "location": user_input["location"],
+                "time_zone": user_input["time_zone"],
+            }
+            
             return self.async_create_entry(
-                title=user_input["name"], 
-                data=user_input
+                title=user_name,
+                data=data
             )
 
-        # Правильное создание схемы с использованием vol.Schema
         data_schema={
-            "name": TextSelector(TextSelectorConfig(type="text")),
+            "user_id": SelectSelector(
+                SelectSelectorConfig(
+                    options=[
+                        {"value": user_id, "label": user_name}
+                        for user_id, user_name in user_options.items()
+                    ],
+                    mode="dropdown",
+                )
+            ),
             "birth_date": DateSelector(),
             "birth_time": TimeSelector(),
             "location": LocationSelector(),
-            "time_zone": TextSelector(TextSelectorConfig(type="text")),
+            "time_zone": SelectSelector( # <-- Теперь это SelectSelector!
+                SelectSelectorConfig(
+                    options=timezone_options,
+                    mode="dropdown",
+                )
+            ),
         }
 
         return self.async_show_form(
-            step_id="user", 
+            step_id="user",
             data_schema=vol.Schema(data_schema),
             errors=errors
         )

flatlib_astrology/const.py

@@ -2,6 +2,8 @@
 
 DOMAIN = "flatlib_astrology"
 
+PLATFORMS = ["sensor"]
+
 # Planet display names
 PLANETS = {
     "Sun": "Sun",

flatlib_astrology/manifest.json

@@ -2,10 +2,11 @@
   "domain": "flatlib_astrology",
   "name": "Flatlib Astrology",
   "config_flow": true,
+  "application_credentials": false,
   "documentation": "https://github.com/navi-vonamut/hass-flatlib-integration/blob/main/README.md",
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/navi-vonamut/hass-flatlib-integration/issues",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "codeowners": ["@navi-vonamut"],
   "requirements": ["aiohttp"]
 }