homeassistant 2025.9.0b1__py3-none-any.whl → 2025.9.0b3__py3-none-any.whl

homeassistant/components/vulcan/__init__.py

@@ -1,48 +0,0 @@
-"""The Vulcan component."""
-
-from aiohttp import ClientConnectorError
-from vulcan import Account, Keystore, UnauthorizedCertificateException, Vulcan
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN
-
-PLATFORMS = [Platform.CALENDAR]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up Uonet+ Vulcan integration."""
-    hass.data.setdefault(DOMAIN, {})
-    try:
-        keystore = Keystore.load(entry.data["keystore"])
-        account = Account.load(entry.data["account"])
-        client = Vulcan(keystore, account, async_get_clientsession(hass))
-        await client.select_student()
-        students = await client.get_students()
-        for student in students:
-            if str(student.pupil.id) == str(entry.data["student_id"]):
-                client.student = student
-                break
-    except UnauthorizedCertificateException as err:
-        raise ConfigEntryAuthFailed("The certificate is not authorized.") from err
-    except ClientConnectorError as err:
-        raise ConfigEntryNotReady(
-            f"Connection error - please check your internet connection: {err}"
-        ) from err
-    hass.data[DOMAIN][entry.entry_id] = client
-
-    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."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        hass.data[DOMAIN].pop(entry.entry_id)
-
-    return unload_ok

homeassistant/components/vulcan/calendar.py

@@ -1,176 +0,0 @@
-"""Support for Vulcan Calendar platform."""
-
-from __future__ import annotations
-
-from datetime import date, datetime, timedelta
-import logging
-from typing import cast
-from zoneinfo import ZoneInfo
-
-from aiohttp import ClientConnectorError
-from vulcan import UnauthorizedCertificateException
-
-from homeassistant.components.calendar import (
-    ENTITY_ID_FORMAT,
-    CalendarEntity,
-    CalendarEvent,
-)
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
-from homeassistant.helpers.entity import generate_entity_id
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from . import DOMAIN
-from .fetch_data import get_lessons, get_student_info
-
-_LOGGER = logging.getLogger(__name__)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the calendar platform for entity."""
-    client = hass.data[DOMAIN][config_entry.entry_id]
-    data = {
-        "student_info": await get_student_info(
-            client, config_entry.data.get("student_id")
-        ),
-    }
-    async_add_entities(
-        [
-            VulcanCalendarEntity(
-                client,
-                data,
-                generate_entity_id(
-                    ENTITY_ID_FORMAT,
-                    f"vulcan_calendar_{data['student_info']['full_name']}",
-                    hass=hass,
-                ),
-            )
-        ],
-    )
-
-
-class VulcanCalendarEntity(CalendarEntity):
-    """A calendar entity."""
-
-    _attr_has_entity_name = True
-    _attr_translation_key = "calendar"
-
-    def __init__(self, client, data, entity_id) -> None:
-        """Create the Calendar entity."""
-        self._event: CalendarEvent | None = None
-        self.client = client
-        self.entity_id = entity_id
-        student_info = data["student_info"]
-        self._attr_unique_id = f"vulcan_calendar_{student_info['id']}"
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, f"calendar_{student_info['id']}")},
-            entry_type=DeviceEntryType.SERVICE,
-            name=cast(str, student_info["full_name"]),
-            model=(
-                f"{student_info['full_name']} -"
-                f" {student_info['class']} {student_info['school']}"
-            ),
-            manufacturer="Uonet +",
-            configuration_url=(
-                f"https://uonetplus.vulcan.net.pl/{student_info['symbol']}"
-            ),
-        )
-
-    @property
-    def event(self) -> CalendarEvent | None:
-        """Return the next upcoming event."""
-        return self._event
-
-    async def async_get_events(
-        self, hass: HomeAssistant, start_date: datetime, end_date: datetime
-    ) -> list[CalendarEvent]:
-        """Get all events in a specific time frame."""
-        try:
-            events = await get_lessons(
-                self.client,
-                date_from=start_date,
-                date_to=end_date,
-            )
-        except UnauthorizedCertificateException as err:
-            raise ConfigEntryAuthFailed(
-                "The certificate is not authorized, please authorize integration again"
-            ) from err
-        except ClientConnectorError as err:
-            if self.available:
-                _LOGGER.warning(
-                    "Connection error - please check your internet connection: %s", err
-                )
-            events = []
-
-        event_list = []
-        for item in events:
-            event = CalendarEvent(
-                start=datetime.combine(
-                    item["date"], item["time"].from_, ZoneInfo("Europe/Warsaw")
-                ),
-                end=datetime.combine(
-                    item["date"], item["time"].to, ZoneInfo("Europe/Warsaw")
-                ),
-                summary=item["lesson"],
-                location=item["room"],
-                description=item["teacher"],
-            )
-
-            event_list.append(event)
-
-        return event_list
-
-    async def async_update(self) -> None:
-        """Get the latest data."""
-
-        try:
-            events = await get_lessons(self.client)
-
-            if not self.available:
-                _LOGGER.warning("Restored connection with API")
-                self._attr_available = True
-
-            if events == []:
-                events = await get_lessons(
-                    self.client,
-                    date_to=date.today() + timedelta(days=7),
-                )
-                if events == []:
-                    self._event = None
-                    return
-        except UnauthorizedCertificateException as err:
-            raise ConfigEntryAuthFailed(
-                "The certificate is not authorized, please authorize integration again"
-            ) from err
-        except ClientConnectorError as err:
-            if self.available:
-                _LOGGER.warning(
-                    "Connection error - please check your internet connection: %s", err
-                )
-                self._attr_available = False
-            return
-
-        new_event = min(
-            events,
-            key=lambda d: (
-                datetime.combine(d["date"], d["time"].to) < datetime.now(),
-                abs(datetime.combine(d["date"], d["time"].to) - datetime.now()),
-            ),
-        )
-        self._event = CalendarEvent(
-            start=datetime.combine(
-                new_event["date"], new_event["time"].from_, ZoneInfo("Europe/Warsaw")
-            ),
-            end=datetime.combine(
-                new_event["date"], new_event["time"].to, ZoneInfo("Europe/Warsaw")
-            ),
-            summary=new_event["lesson"],
-            location=new_event["room"],
-            description=new_event["teacher"],
-        )

homeassistant/components/vulcan/config_flow.py

@@ -1,327 +0,0 @@
-"""Adds config flow for Vulcan."""
-
-from collections.abc import Mapping
-import logging
-from typing import TYPE_CHECKING, Any
-
-from aiohttp import ClientConnectionError
-import voluptuous as vol
-from vulcan import (
-    Account,
-    ExpiredTokenException,
-    InvalidPINException,
-    InvalidSymbolException,
-    InvalidTokenException,
-    Keystore,
-    UnauthorizedCertificateException,
-    Vulcan,
-)
-from vulcan.model import Student
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_PIN, CONF_REGION, CONF_TOKEN
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from . import DOMAIN
-from .register import register
-
-_LOGGER = logging.getLogger(__name__)
-
-LOGIN_SCHEMA = {
-    vol.Required(CONF_TOKEN): str,
-    vol.Required(CONF_REGION): str,
-    vol.Required(CONF_PIN): str,
-}
-
-
-class VulcanFlowHandler(ConfigFlow, domain=DOMAIN):
-    """Handle a Uonet+ Vulcan config flow."""
-
-    VERSION = 1
-
-    account: Account
-    keystore: Keystore
-
-    def __init__(self) -> None:
-        """Initialize config flow."""
-        self.students: list[Student] | None = None
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle config flow."""
-        if self._async_current_entries():
-            return await self.async_step_add_next_config_entry()
-
-        return await self.async_step_auth()
-
-    async def async_step_auth(
-        self,
-        user_input: dict[str, str] | None = None,
-        errors: dict[str, str] | None = None,
-    ) -> ConfigFlowResult:
-        """Authorize integration."""
-
-        if user_input is not None:
-            try:
-                credentials = await register(
-                    user_input[CONF_TOKEN],
-                    user_input[CONF_REGION],
-                    user_input[CONF_PIN],
-                )
-            except InvalidSymbolException:
-                errors = {"base": "invalid_symbol"}
-            except InvalidTokenException:
-                errors = {"base": "invalid_token"}
-            except InvalidPINException:
-                errors = {"base": "invalid_pin"}
-            except ExpiredTokenException:
-                errors = {"base": "expired_token"}
-            except ClientConnectionError as err:
-                errors = {"base": "cannot_connect"}
-                _LOGGER.error("Connection error: %s", err)
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors = {"base": "unknown"}
-            if not errors:
-                account = credentials["account"]
-                keystore = credentials["keystore"]
-                client = Vulcan(keystore, account, async_get_clientsession(self.hass))
-                students = await client.get_students()
-
-                if len(students) > 1:
-                    self.account = account
-                    self.keystore = keystore
-                    self.students = students
-                    return await self.async_step_select_student()
-                student = students[0]
-                await self.async_set_unique_id(str(student.pupil.id))
-                self._abort_if_unique_id_configured()
-                return self.async_create_entry(
-                    title=f"{student.pupil.first_name} {student.pupil.last_name}",
-                    data={
-                        "student_id": str(student.pupil.id),
-                        "keystore": keystore.as_dict,
-                        "account": account.as_dict,
-                    },
-                )
-
-        return self.async_show_form(
-            step_id="auth",
-            data_schema=vol.Schema(LOGIN_SCHEMA),
-            errors=errors,
-        )
-
-    async def async_step_select_student(
-        self, user_input: dict[str, str] | None = None
-    ) -> ConfigFlowResult:
-        """Allow user to select student."""
-        errors: dict[str, str] = {}
-        students: dict[str, str] = {}
-        if self.students is not None:
-            for student in self.students:
-                students[str(student.pupil.id)] = (
-                    f"{student.pupil.first_name} {student.pupil.last_name}"
-                )
-        if user_input is not None:
-            if TYPE_CHECKING:
-                assert self.keystore is not None
-            student_id = user_input["student"]
-            await self.async_set_unique_id(str(student_id))
-            self._abort_if_unique_id_configured()
-            return self.async_create_entry(
-                title=students[student_id],
-                data={
-                    "student_id": str(student_id),
-                    "keystore": self.keystore.as_dict,
-                    "account": self.account.as_dict,
-                },
-            )
-
-        return self.async_show_form(
-            step_id="select_student",
-            data_schema=vol.Schema({vol.Required("student"): vol.In(students)}),
-            errors=errors,
-        )
-
-    async def async_step_select_saved_credentials(
-        self,
-        user_input: dict[str, str] | None = None,
-        errors: dict[str, str] | None = None,
-    ) -> ConfigFlowResult:
-        """Allow user to select saved credentials."""
-
-        credentials: dict[str, Any] = {}
-        for entry in self.hass.config_entries.async_entries(DOMAIN):
-            credentials[entry.entry_id] = entry.data["account"]["UserName"]
-
-        if user_input is not None:
-            existing_entry = self.hass.config_entries.async_get_entry(
-                user_input["credentials"]
-            )
-            if TYPE_CHECKING:
-                assert existing_entry is not None
-            keystore = Keystore.load(existing_entry.data["keystore"])
-            account = Account.load(existing_entry.data["account"])
-            client = Vulcan(keystore, account, async_get_clientsession(self.hass))
-            try:
-                students = await client.get_students()
-            except UnauthorizedCertificateException:
-                return await self.async_step_auth(
-                    errors={"base": "expired_credentials"}
-                )
-            except ClientConnectionError as err:
-                _LOGGER.error("Connection error: %s", err)
-                return await self.async_step_select_saved_credentials(
-                    errors={"base": "cannot_connect"}
-                )
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                return await self.async_step_auth(errors={"base": "unknown"})
-            if len(students) == 1:
-                student = students[0]
-                await self.async_set_unique_id(str(student.pupil.id))
-                self._abort_if_unique_id_configured()
-                return self.async_create_entry(
-                    title=f"{student.pupil.first_name} {student.pupil.last_name}",
-                    data={
-                        "student_id": str(student.pupil.id),
-                        "keystore": keystore.as_dict,
-                        "account": account.as_dict,
-                    },
-                )
-            self.account = account
-            self.keystore = keystore
-            self.students = students
-            return await self.async_step_select_student()
-
-        data_schema = {
-            vol.Required(
-                "credentials",
-            ): vol.In(credentials),
-        }
-        return self.async_show_form(
-            step_id="select_saved_credentials",
-            data_schema=vol.Schema(data_schema),
-            errors=errors,
-        )
-
-    async def async_step_add_next_config_entry(
-        self, user_input: dict[str, bool] | None = None
-    ) -> ConfigFlowResult:
-        """Flow initialized when user is adding next entry of that integration."""
-
-        existing_entries = self.hass.config_entries.async_entries(DOMAIN)
-
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            if not user_input["use_saved_credentials"]:
-                return await self.async_step_auth()
-            if len(existing_entries) > 1:
-                return await self.async_step_select_saved_credentials()
-            keystore = Keystore.load(existing_entries[0].data["keystore"])
-            account = Account.load(existing_entries[0].data["account"])
-            client = Vulcan(keystore, account, async_get_clientsession(self.hass))
-            students = await client.get_students()
-            existing_entry_ids = [
-                entry.data["student_id"] for entry in existing_entries
-            ]
-            new_students = [
-                student
-                for student in students
-                if str(student.pupil.id) not in existing_entry_ids
-            ]
-            if not new_students:
-                return self.async_abort(reason="all_student_already_configured")
-            if len(new_students) == 1:
-                await self.async_set_unique_id(str(new_students[0].pupil.id))
-                self._abort_if_unique_id_configured()
-                return self.async_create_entry(
-                    title=(
-                        f"{new_students[0].pupil.first_name} {new_students[0].pupil.last_name}"
-                    ),
-                    data={
-                        "student_id": str(new_students[0].pupil.id),
-                        "keystore": keystore.as_dict,
-                        "account": account.as_dict,
-                    },
-                )
-            self.account = account
-            self.keystore = keystore
-            self.students = new_students
-            return await self.async_step_select_student()
-
-        data_schema = {
-            vol.Required("use_saved_credentials", default=True): bool,
-        }
-        return self.async_show_form(
-            step_id="add_next_config_entry",
-            data_schema=vol.Schema(data_schema),
-            errors=errors,
-        )
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Perform reauth upon an API authentication error."""
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, str] | None = None
-    ) -> ConfigFlowResult:
-        """Reauthorize integration."""
-        errors = {}
-        if user_input is not None:
-            try:
-                credentials = await register(
-                    user_input[CONF_TOKEN],
-                    user_input[CONF_REGION],
-                    user_input[CONF_PIN],
-                )
-            except InvalidSymbolException:
-                errors = {"base": "invalid_symbol"}
-            except InvalidTokenException:
-                errors = {"base": "invalid_token"}
-            except InvalidPINException:
-                errors = {"base": "invalid_pin"}
-            except ExpiredTokenException:
-                errors = {"base": "expired_token"}
-            except ClientConnectionError as err:
-                errors["base"] = "cannot_connect"
-                _LOGGER.error("Connection error: %s", err)
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            if not errors:
-                account = credentials["account"]
-                keystore = credentials["keystore"]
-                client = Vulcan(keystore, account, async_get_clientsession(self.hass))
-                students = await client.get_students()
-                existing_entries = self.hass.config_entries.async_entries(DOMAIN)
-                matching_entries = False
-                for student in students:
-                    for entry in existing_entries:
-                        if str(student.pupil.id) == str(entry.data["student_id"]):
-                            self.hass.config_entries.async_update_entry(
-                                entry,
-                                title=(
-                                    f"{student.pupil.first_name} {student.pupil.last_name}"
-                                ),
-                                data={
-                                    "student_id": str(student.pupil.id),
-                                    "keystore": keystore.as_dict,
-                                    "account": account.as_dict,
-                                },
-                            )
-                            await self.hass.config_entries.async_reload(entry.entry_id)
-                            matching_entries = True
-                if not matching_entries:
-                    return self.async_abort(reason="no_matching_entries")
-                return self.async_abort(reason="reauth_successful")
-
-        return self.async_show_form(
-            step_id="reauth_confirm",
-            data_schema=vol.Schema(LOGIN_SCHEMA),
-            errors=errors,
-        )

homeassistant/components/vulcan/const.py

@@ -1,3 +0,0 @@
-"""Constants for the Vulcan integration."""
-
-DOMAIN = "vulcan"

homeassistant/components/vulcan/fetch_data.py

@@ -1,98 +0,0 @@
-"""Support for fetching Vulcan data."""
-
-
-async def get_lessons(client, date_from=None, date_to=None):
-    """Support for fetching Vulcan lessons."""
-    changes = {}
-    list_ans = []
-    async for lesson in await client.data.get_changed_lessons(
-        date_from=date_from, date_to=date_to
-    ):
-        temp_dict = {}
-        _id = str(lesson.id)
-        temp_dict["id"] = lesson.id
-        temp_dict["number"] = lesson.time.position if lesson.time is not None else None
-        temp_dict["lesson"] = (
-            lesson.subject.name if lesson.subject is not None else None
-        )
-        temp_dict["room"] = lesson.room.code if lesson.room is not None else None
-        temp_dict["changes"] = lesson.changes
-        temp_dict["note"] = lesson.note
-        temp_dict["reason"] = lesson.reason
-        temp_dict["event"] = lesson.event
-        temp_dict["group"] = lesson.group
-        temp_dict["teacher"] = (
-            lesson.teacher.display_name if lesson.teacher is not None else None
-        )
-        temp_dict["from_to"] = (
-            lesson.time.displayed_time if lesson.time is not None else None
-        )
-
-        changes[str(_id)] = temp_dict
-
-    async for lesson in await client.data.get_lessons(
-        date_from=date_from, date_to=date_to
-    ):
-        temp_dict = {}
-        temp_dict["id"] = lesson.id
-        temp_dict["number"] = lesson.time.position
-        temp_dict["time"] = lesson.time
-        temp_dict["date"] = lesson.date.date
-        temp_dict["lesson"] = (
-            lesson.subject.name if lesson.subject is not None else None
-        )
-        if lesson.room is not None:
-            temp_dict["room"] = lesson.room.code
-        else:
-            temp_dict["room"] = "-"
-        temp_dict["visible"] = lesson.visible
-        temp_dict["changes"] = lesson.changes
-        temp_dict["group"] = lesson.group
-        temp_dict["reason"] = None
-        temp_dict["teacher"] = (
-            lesson.teacher.display_name if lesson.teacher is not None else None
-        )
-        temp_dict["from_to"] = (
-            lesson.time.displayed_time if lesson.time is not None else None
-        )
-        if temp_dict["changes"] is None:
-            temp_dict["changes"] = ""
-        elif temp_dict["changes"].type == 1:
-            temp_dict["lesson"] = f"Lekcja odwołana ({temp_dict['lesson']})"
-            temp_dict["changes_info"] = f"Lekcja odwołana ({temp_dict['lesson']})"
-            if str(temp_dict["changes"].id) in changes:
-                temp_dict["reason"] = changes[str(temp_dict["changes"].id)]["reason"]
-        elif temp_dict["changes"].type == 2:
-            temp_dict["lesson"] = f"{temp_dict['lesson']} (Zastępstwo)"
-            temp_dict["teacher"] = changes[str(temp_dict["changes"].id)]["teacher"]
-            if str(temp_dict["changes"].id) in changes:
-                temp_dict["teacher"] = changes[str(temp_dict["changes"].id)]["teacher"]
-                temp_dict["reason"] = changes[str(temp_dict["changes"].id)]["reason"]
-        elif temp_dict["changes"].type == 4:
-            temp_dict["lesson"] = f"Lekcja odwołana ({temp_dict['lesson']})"
-            if str(temp_dict["changes"].id) in changes:
-                temp_dict["reason"] = changes[str(temp_dict["changes"].id)]["reason"]
-        if temp_dict["visible"]:
-            list_ans.append(temp_dict)
-
-    return list_ans
-
-
-async def get_student_info(client, student_id):
-    """Support for fetching Student info by student id."""
-    student_info = {}
-    for student in await client.get_students():
-        if str(student.pupil.id) == str(student_id):
-            student_info["first_name"] = student.pupil.first_name
-            if student.pupil.second_name:
-                student_info["second_name"] = student.pupil.second_name
-            student_info["last_name"] = student.pupil.last_name
-            student_info["full_name"] = (
-                f"{student.pupil.first_name} {student.pupil.last_name}"
-            )
-            student_info["id"] = student.pupil.id
-            student_info["class"] = student.class_
-            student_info["school"] = student.school.name
-            student_info["symbol"] = student.symbol
-            break
-    return student_info

homeassistant/components/vulcan/manifest.json

@@ -1,9 +0,0 @@
-{
-  "domain": "vulcan",
-  "name": "Uonet+ Vulcan",
-  "codeowners": ["@Antoni-Czaplicki"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/vulcan",
-  "iot_class": "cloud_polling",
-  "requirements": ["vulcan-api==2.4.2"]
-}

homeassistant/components/vulcan/register.py

@@ -1,12 +0,0 @@
-"""Support for register Vulcan account."""
-
-from typing import Any
-
-from vulcan import Account, Keystore
-
-
-async def register(token: str, symbol: str, pin: str) -> dict[str, Any]:
-    """Register integration and save credentials."""
-    keystore = await Keystore.create(device_model="Home Assistant")
-    account = await Account.register(keystore, token, symbol, pin)
-    return {"account": account, "keystore": keystore}