eero-api 1.2.4__py3-none-any.whl

eero/__init__.py

@@ -0,0 +1,25 @@
+"""Eero API - Async Python client for Eero mesh WiFi networks."""
+
+from .api import EeroAPI
+from .client import EeroClient
+from .exceptions import (
+    EeroAPIException,
+    EeroAuthenticationException,
+    EeroException,
+    EeroNetworkException,
+    EeroRateLimitException,
+    EeroTimeoutException,
+)
+
+__all__ = [
+    "EeroAPI",
+    "EeroClient",
+    "EeroException",
+    "EeroAPIException",
+    "EeroAuthenticationException",
+    "EeroNetworkException",
+    "EeroRateLimitException",
+    "EeroTimeoutException",
+]
+
+__version__ = "1.2.4"

eero/__main__.py

@@ -0,0 +1,6 @@
+"""Command-line entry point for the Eero API package."""
+
+from .cli.main import cli
+
+if __name__ == "__main__":
+    cli()

eero/api/__init__.py

@@ -0,0 +1,137 @@
+"""API module for Eero."""
+
+from typing import Optional
+
+from aiohttp import ClientSession
+
+from .ac_compat import ACCompatAPI
+from .activity import ActivityAPI
+from .auth import AuthAPI
+from .backup import BackupAPI
+from .blacklist import BlacklistAPI
+from .burst_reporters import BurstReportersAPI
+from .devices import DevicesAPI
+from .diagnostics import DiagnosticsAPI
+from .dns import DnsAPI
+from .eeros import EerosAPI
+from .forwards import ForwardsAPI
+from .insights import InsightsAPI
+from .networks import NetworksAPI
+from .ouicheck import OUICheckAPI
+from .password import PasswordAPI
+from .profiles import ProfilesAPI
+from .reservations import ReservationsAPI
+from .routing import RoutingAPI
+from .schedule import ScheduleAPI
+from .security import SecurityAPI
+from .settings import SettingsAPI
+from .sqm import SqmAPI
+from .support import SupportAPI
+from .thread import ThreadAPI
+from .transfer import TransferAPI
+from .updates import UpdatesAPI
+
+
+class EeroAPI:
+    """API client for interacting with the Eero API."""
+
+    def __init__(
+        self,
+        session: Optional[ClientSession] = None,
+        cookie_file: Optional[str] = None,
+        use_keyring: bool = True,
+    ) -> None:
+        """Initialize the EeroAPI.
+
+        Args:
+            session: Optional aiohttp ClientSession to use for requests
+            cookie_file: Optional path to a file for storing authentication cookies
+            use_keyring: Whether to use keyring for secure token storage
+        """
+        self.auth = AuthAPI(session, cookie_file, use_keyring)
+        self.activity = ActivityAPI(self.auth)
+        self.backup = BackupAPI(self.auth)
+        self.dns = DnsAPI(self.auth)
+        self.networks = NetworksAPI(self.auth)
+        self.devices = DevicesAPI(self.auth)
+        self.eeros = EerosAPI(self.auth)
+        self.profiles = ProfilesAPI(self.auth)
+        self.schedule = ScheduleAPI(self.auth)
+        self.security = SecurityAPI(self.auth)
+        self.sqm = SqmAPI(self.auth)
+        self.diagnostics = DiagnosticsAPI(self.auth)
+        self.settings = SettingsAPI(self.auth)
+        self.updates = UpdatesAPI(self.auth)
+        self.insights = InsightsAPI(self.auth)
+        self.routing = RoutingAPI(self.auth)
+        self.thread = ThreadAPI(self.auth)
+        self.support = SupportAPI(self.auth)
+        self.blacklist = BlacklistAPI(self.auth)
+        self.reservations = ReservationsAPI(self.auth)
+        self.forwards = ForwardsAPI(self.auth)
+        self.transfer = TransferAPI(self.auth)
+        self.burst_reporters = BurstReportersAPI(self.auth)
+        self.ac_compat = ACCompatAPI(self.auth)
+        self.ouicheck = OUICheckAPI(self.auth)
+        self.password = PasswordAPI(self.auth)
+
+    async def __aenter__(self) -> "EeroAPI":
+        """Enter async context manager."""
+        await self.auth.__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Exit async context manager."""
+        await self.auth.__aexit__(exc_type, exc_val, exc_tb)
+
+    @property
+    def is_authenticated(self) -> bool:
+        """Check if the client is authenticated."""
+        return self.auth.is_authenticated
+
+    async def login(self, user_identifier: str) -> bool:
+        """Start the login process by requesting a verification code.
+
+        Args:
+            user_identifier: Email address or phone number for the Eero account
+
+        Returns:
+            True if login request was successful
+        """
+        return await self.auth.login(user_identifier)
+
+    async def verify(self, verification_code: str) -> bool:
+        """Verify login with the code sent to the user.
+
+        Args:
+            verification_code: The verification code sent to the user
+
+        Returns:
+            True if verification was successful
+        """
+        return await self.auth.verify(verification_code)
+
+    async def logout(self) -> bool:
+        """Log out from the Eero API.
+
+        Returns:
+            True if logout was successful
+        """
+        return await self.auth.logout()
+
+    def set_preferred_network(self, network_id: str) -> None:
+        """Set the preferred network ID to use for requests.
+
+        Args:
+            network_id: ID of the network to use
+        """
+        self.auth.preferred_network_id = network_id
+
+    @property
+    def preferred_network_id(self) -> Optional[str]:
+        """Get the preferred network ID.
+
+        Returns:
+            Preferred network ID or None
+        """
+        return self.auth.preferred_network_id

eero/api/ac_compat.py

@@ -0,0 +1,49 @@
+"""AC Compatibility API for Eero."""
+
+import logging
+from typing import Any, Dict
+
+from ..const import API_ENDPOINT
+from ..exceptions import EeroAuthenticationException
+from .auth import AuthAPI
+from .base import AuthenticatedAPI
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ACCompatAPI(AuthenticatedAPI):
+    """AC Compatibility API for Eero."""
+
+    def __init__(self, auth_api: AuthAPI) -> None:
+        """Initialize the ACCompatAPI.
+
+        Args:
+            auth_api: Authentication API instance
+        """
+        super().__init__(auth_api, API_ENDPOINT)
+
+    async def get_ac_compat(self, network_id: str) -> Dict[str, Any]:
+        """Get AC compatibility information.
+
+        Args:
+            network_id: ID of the network to get AC compatibility info for
+
+        Returns:
+            AC compatibility data
+
+        Raises:
+            EeroAuthenticationException: If not authenticated
+            EeroAPIException: If the API returns an error
+        """
+        auth_token = await self._auth_api.get_auth_token()
+        if not auth_token:
+            raise EeroAuthenticationException("Not authenticated")
+
+        _LOGGER.debug(f"Getting AC compatibility for network {network_id}")
+
+        response = await self.get(
+            f"networks/{network_id}/ac_compat",
+            auth_token=auth_token,
+        )
+
+        return response.get("data", {})

eero/api/activity.py

@@ -0,0 +1,182 @@
+"""Activity API for Eero (Eero Plus feature)."""
+
+import logging
+from typing import Any, Dict, List
+
+from ..const import API_ENDPOINT
+from ..exceptions import EeroAuthenticationException
+from .auth import AuthAPI
+from .base import AuthenticatedAPI
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ActivityAPI(AuthenticatedAPI):
+    """Activity API for Eero.
+
+    Note: Activity data requires an active Eero Plus/Eero Secure subscription.
+    API calls may return empty data or errors for non-premium accounts.
+    """
+
+    def __init__(self, auth_api: AuthAPI) -> None:
+        """Initialize the ActivityAPI.
+
+        Args:
+            auth_api: Authentication API instance
+        """
+        super().__init__(auth_api, API_ENDPOINT)
+
+    async def get_activity(self, network_id: str) -> Dict[str, Any]:
+        """Get network activity summary.
+
+        Args:
+            network_id: ID of the network to get activity from
+
+        Returns:
+            Activity data including total usage, top clients, etc.
+
+        Raises:
+            EeroAuthenticationException: If not authenticated
+            EeroAPIException: If the API returns an error (may occur for non-premium)
+        """
+        auth_token = await self._auth_api.get_auth_token()
+        if not auth_token:
+            raise EeroAuthenticationException("Not authenticated")
+
+        _LOGGER.debug("Getting activity for network %s", network_id)
+
+        response = await self.get(
+            f"networks/{network_id}/activity",
+            auth_token=auth_token,
+        )
+
+        return response.get("data", {})
+
+    async def get_activity_clients(self, network_id: str) -> List[Dict[str, Any]]:
+        """Get per-client activity data.
+
+        Args:
+            network_id: ID of the network to get client activity from
+
+        Returns:
+            List of clients with their activity data
+
+        Raises:
+            EeroAuthenticationException: If not authenticated
+            EeroAPIException: If the API returns an error
+        """
+        auth_token = await self._auth_api.get_auth_token()
+        if not auth_token:
+            raise EeroAuthenticationException("Not authenticated")
+
+        _LOGGER.debug("Getting client activity for network %s", network_id)
+
+        response = await self.get(
+            f"networks/{network_id}/activity/clients",
+            auth_token=auth_token,
+        )
+
+        # Handle different response formats
+        data = response.get("data", [])
+        if isinstance(data, list):
+            return data
+        elif isinstance(data, dict) and "data" in data:
+            return data.get("data", [])
+        elif isinstance(data, dict) and "clients" in data:
+            return data.get("clients", [])
+        return []
+
+    async def get_activity_for_device(self, network_id: str, device_id: str) -> Dict[str, Any]:
+        """Get activity data for a specific device.
+
+        Args:
+            network_id: ID of the network
+            device_id: ID of the device to get activity for
+
+        Returns:
+            Activity data for the device
+
+        Raises:
+            EeroAuthenticationException: If not authenticated
+            EeroAPIException: If the API returns an error
+        """
+        auth_token = await self._auth_api.get_auth_token()
+        if not auth_token:
+            raise EeroAuthenticationException("Not authenticated")
+
+        _LOGGER.debug("Getting activity for device %s in network %s", device_id, network_id)
+
+        response = await self.get(
+            f"networks/{network_id}/activity/{device_id}",
+            auth_token=auth_token,
+        )
+
+        return response.get("data", {})
+
+    async def get_activity_history(
+        self,
+        network_id: str,
+        period: str = "day",
+    ) -> Dict[str, Any]:
+        """Get historical activity data.
+
+        Args:
+            network_id: ID of the network
+            period: Time period - "hour", "day", "week", or "month"
+
+        Returns:
+            Historical activity data
+
+        Raises:
+            EeroAuthenticationException: If not authenticated
+            EeroAPIException: If the API returns an error
+        """
+        auth_token = await self._auth_api.get_auth_token()
+        if not auth_token:
+            raise EeroAuthenticationException("Not authenticated")
+
+        valid_periods = ["hour", "day", "week", "month"]
+        if period not in valid_periods:
+            _LOGGER.warning("Invalid period '%s', defaulting to 'day'", period)
+            period = "day"
+
+        _LOGGER.debug("Getting activity history for network %s (period: %s)", network_id, period)
+
+        response = await self.get(
+            f"networks/{network_id}/activity/history",
+            auth_token=auth_token,
+            params={"period": period},
+        )
+
+        return response.get("data", {})
+
+    async def get_activity_categories(self, network_id: str) -> List[Dict[str, Any]]:
+        """Get activity data grouped by category.
+
+        Args:
+            network_id: ID of the network
+
+        Returns:
+            Activity data grouped by category (streaming, gaming, social, etc.)
+
+        Raises:
+            EeroAuthenticationException: If not authenticated
+            EeroAPIException: If the API returns an error
+        """
+        auth_token = await self._auth_api.get_auth_token()
+        if not auth_token:
+            raise EeroAuthenticationException("Not authenticated")
+
+        _LOGGER.debug("Getting activity categories for network %s", network_id)
+
+        response = await self.get(
+            f"networks/{network_id}/activity/categories",
+            auth_token=auth_token,
+        )
+
+        data = response.get("data", [])
+        if isinstance(data, list):
+            return data
+        elif isinstance(data, dict) and "categories" in data:
+            return data.get("categories", [])
+        return []