havenlighting 0.1.0__tar.gz

havenlighting-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.1
+Name: havenlighting
+Version: 0.1.0
+Summary: Python client for Haven Lighting API
+Author-email: Mickey Schwab <mickeyschwab@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.0; extra == "dev"
+
+# Haven Lighting API Client
+
+A Python client library for interacting with the Haven Lighting API.
+
+## Installation
+
+```bash
+pip install havenlighting
+```
+
+## Usage
+
+```python
+from havenlighting import HavenClient
+
+# Initialize the client
+client = HavenClient()
+
+# Authenticate
+authenticated = client.authenticate(
+    email="your-email@example.com",
+    password="your-password"
+)
+
+if authenticated:
+    # Discover locations
+    locations = client.discover_locations()
+    
+    # Print available locations and lights
+    for location_id, location in locations.items():
+        print(f"Location: {location.name}")
+        
+        # Get lights for this location
+        lights = location.get_lights()
+        
+        # Control lights
+        for light_id, light in lights.items():
+            print(f"Light: {light.name}")
+            light.turn_on()   # Turn light on
+            light.turn_off()  # Turn light off
+
+```
+
+## Development
+
+1. Clone the repository
+2. Install development dependencies:
+```bash
+pip install -e ".[dev]"
+```
+
+3. Run tests:
+```bash
+pytest
+```
+
+## License
+
+MIT License - see LICENSE file for details.

havenlighting-0.1.0/README.md

@@ -0,0 +1,59 @@
+# Haven Lighting API Client
+
+A Python client library for interacting with the Haven Lighting API.
+
+## Installation
+
+```bash
+pip install havenlighting
+```
+
+## Usage
+
+```python
+from havenlighting import HavenClient
+
+# Initialize the client
+client = HavenClient()
+
+# Authenticate
+authenticated = client.authenticate(
+    email="your-email@example.com",
+    password="your-password"
+)
+
+if authenticated:
+    # Discover locations
+    locations = client.discover_locations()
+    
+    # Print available locations and lights
+    for location_id, location in locations.items():
+        print(f"Location: {location.name}")
+        
+        # Get lights for this location
+        lights = location.get_lights()
+        
+        # Control lights
+        for light_id, light in lights.items():
+            print(f"Light: {light.name}")
+            light.turn_on()   # Turn light on
+            light.turn_off()  # Turn light off
+
+```
+
+## Development
+
+1. Clone the repository
+2. Install development dependencies:
+```bash
+pip install -e ".[dev]"
+```
+
+3. Run tests:
+```bash
+pytest
+```
+
+## License
+
+MIT License - see LICENSE file for details.

havenlighting-0.1.0/havenlighting/__init__.py

@@ -0,0 +1,14 @@
+from .client import HavenClient
+from .devices.light import Light
+from .devices.location import Location
+from .exceptions import HavenException, AuthenticationError, DeviceError
+
+__version__ = "0.1.0"
+__all__ = [
+    "HavenClient",
+    "Light",
+    "Location",
+    "HavenException",
+    "AuthenticationError",
+    "DeviceError",
+] 

havenlighting-0.1.0/havenlighting/client.py

@@ -0,0 +1,70 @@
+import logging
+from typing import Dict, Any, Optional
+from .credentials import Credentials
+from .devices.light import Light
+from .devices.location import Location
+from .exceptions import AuthenticationError, ApiError
+from .logging import setup_logging
+
+logger = logging.getLogger(__name__)
+
+class HavenClient:
+    """Main client for interacting with Haven Lighting devices."""
+    
+    def __init__(self, log_level: int = logging.INFO, log_file: Optional[str] = None) -> None:
+        """
+        Initialize the Haven Lighting client.
+        
+        Args:
+            log_level: Logging level (default: INFO)
+            log_file: Optional file path for logging output
+        """
+        setup_logging(log_level, log_file)
+        self._credentials = Credentials()
+        self._locations: Dict[int, Location] = {}
+        self._lights: Dict[int, Light] = {}
+        logger.debug("Initialized HavenClient")
+
+    def authenticate(self, email: str, password: str) -> bool:
+        """
+        Authenticate with the Haven Lighting service.
+        
+        Args:
+            email: User's email address
+            password: User's password
+            
+        Returns:
+            bool: True if authentication successful, False otherwise
+            
+        Raises:
+            ApiError: If API request fails
+        """
+        try:
+            authenticated = self._credentials.authenticate(email, password)
+            if authenticated:
+                logger.info("Successfully authenticated user: %s", email)
+            else:
+                logger.warning("Authentication failed for user: %s", email)
+            return authenticated
+        except ApiError as e:
+            logger.error("API error during authentication: %s", str(e))
+            raise
+
+    def get_location(self, location_id: int) -> Location:
+        """Get a location by ID."""
+        if not self._credentials:
+            raise AuthenticationError("Not authenticated")
+            
+        if location_id not in self._locations:
+            self._locations[location_id] = Location(self._credentials, location_id)
+        
+        return self._locations[location_id]
+
+    def discover_locations(self) -> Dict[int, Location]:
+        """Discover all available locations."""
+        if not self._credentials:
+            raise AuthenticationError("Not authenticated")
+            
+        locations = Location.discover(self._credentials)
+        self._locations.update(locations)
+        return self._locations 

havenlighting-0.1.0/havenlighting/config.py

@@ -0,0 +1,25 @@
+"""Configuration constants for Haven Lighting API."""
+
+from typing import Final
+
+# API Configuration
+API_TIMEOUT: Final[int] = 30
+MAX_RETRIES: Final[int] = 3
+
+# Light States
+LIGHT_STATE: Final[dict] = {
+    "OFF": 1,
+    "ON": 2
+}
+
+# Default Light Parameters
+LIGHT_PARAMS: Final[dict] = {
+    "BRIGHTNESS": 63,
+    "COLOR": 63,
+    "PATTERN_SPEED": 63
+}
+
+# API Configuration
+DEVICE_ID: Final[str] = "HavenLightingMobile"
+AUTH_API_BASE: Final[str] = "https://havenwebservices-apiapp-test.azurewebsites.net/api/v2"
+PROD_API_BASE: Final[str] = "https://ase-hvnlght-residential-api-prod.azurewebsites.net/api" 

havenlighting-0.1.0/havenlighting/credentials.py

@@ -0,0 +1,142 @@
+from typing import Dict, Any, Optional, Callable
+import requests
+from functools import wraps
+from .exceptions import AuthenticationError, ApiError
+import logging
+from .config import DEVICE_ID, AUTH_API_BASE, PROD_API_BASE, API_TIMEOUT
+
+logger = logging.getLogger(__name__)
+
+def refresh_on_auth_error(func: Callable) -> Callable:
+    """Decorator to refresh token and retry on authentication errors."""
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        try:
+            return func(self, *args, **kwargs)
+        except AuthenticationError:
+            logger.info("Authentication error, attempting token refresh")
+            if self.refresh_token():
+                logger.info("Token refresh successful, retrying request")
+                return func(self, *args, **kwargs)
+            logger.error("Token refresh failed, unable to retry request")
+            raise
+    return wrapper
+
+class Credentials:
+    """Handles authentication and request credentials."""
+    
+    def __init__(self):
+        self._token: Optional[str] = None
+        self._refresh_token: Optional[str] = None
+        self._user_id: Optional[int] = None
+        logger.debug("Initialized Credentials")
+        
+    @property
+    def is_authenticated(self) -> bool:
+        return bool(self._token and self._user_id)
+        
+    def authenticate(self, email: str, password: str) -> bool:
+        """Authenticate with the Haven Lighting service."""
+        logger.debug("Attempting authentication for user: %s", email)
+        payload = {
+            "email": email,
+            "password": password,
+            "deviceId": DEVICE_ID,
+        }
+        
+        try:
+            response = self._make_request_internal(
+                "POST",
+                "/User/authenticate",
+                json=payload,
+                auth_required=False
+            )
+            if not response["success"] or not response["data"]:
+                logger.error("Authentication failed for user %s: %s", email, response["message"])
+                return False
+            self._update_credentials(response["data"])
+            logger.info("Successfully authenticated user: %s", email)
+            return True
+            
+        except ApiError as e:
+            logger.error("Authentication failed for user %s: %s", email, str(e))
+            return False
+            
+    def refresh_token(self) -> bool:
+        """Refresh the authentication token."""
+        if not self._refresh_token or not self._user_id:
+            return False
+            
+        try:
+            response = self._make_request_internal(
+                "POST",
+                "/User/refresh",
+                json={
+                    "refreshToken": self._refresh_token,
+                    "userId": self._user_id
+                },
+                auth_required=False
+            )
+            self._update_credentials(response["data"])
+            return True
+            
+        except ApiError as e:
+            logger.error("Token refresh failed: %s", str(e))
+            return False
+            
+    def _update_credentials(self, data: Dict[str, Any]) -> None:
+        """Update stored credentials from API response."""
+        self._token = data["token"]
+        self._refresh_token = data["refreshToken"]
+        self._user_id = data["id"]
+        
+    @refresh_on_auth_error
+    def make_request(
+        self, 
+        method: str, 
+        path: str, 
+        auth_required: bool = True,
+        use_prod_api: bool = False,
+        timeout: int = API_TIMEOUT,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Make an authenticated API request with automatic token refresh."""
+        return self._make_request_internal(
+            method, path, auth_required, use_prod_api, timeout, **kwargs
+        )
+        
+    def _make_request_internal(
+        self, 
+        method: str, 
+        path: str, 
+        auth_required: bool = True,
+        use_prod_api: bool = False,
+        timeout: int = API_TIMEOUT,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Internal method for making API requests."""
+        if auth_required and not self.is_authenticated:
+            raise AuthenticationError("Authentication required")
+            
+        base_url = PROD_API_BASE if use_prod_api else AUTH_API_BASE
+        url = f"{base_url}{path}"
+        
+        if self._token:
+            headers = kwargs.pop("headers", {})
+            headers["Authorization"] = f"Bearer {self._token}"
+            kwargs["headers"] = headers
+            
+        try:
+            response = requests.request(method, url, timeout=timeout, **kwargs)
+            response.raise_for_status()
+            data = response.json()
+            
+            if not data.get("success"):
+                if "token" in str(data.get("message", "")).lower():
+                    raise AuthenticationError(data.get("message", "Token expired"))
+                raise ApiError(data.get("message", "Unknown API error"))
+                
+            return data
+        except requests.exceptions.RequestException as e:
+            logger.error("Request failed: %s", str(e))
+            raise ApiError(f"Request failed: {str(e)}") 

havenlighting-0.1.0/havenlighting/devices/light.py

@@ -0,0 +1,73 @@
+from typing import Dict, Any
+import logging
+from ..models import LightData
+from ..config import LIGHT_STATE, LIGHT_PARAMS
+from ..credentials import Credentials
+
+logger = logging.getLogger(__name__)
+
+class Light:
+    """Represents a Haven light device."""
+
+    def __init__(self, credentials: Credentials, location_id: int, light_id: int, data: Dict[str, Any]) -> None:
+        self._credentials = credentials
+        self.location_id = location_id
+        self._data = LightData(
+            light_id=int(data["lightId"]),
+            name=data["name"],
+            status=data.get("lightingStatusId", LIGHT_STATE["OFF"]),
+            brightness=data.get("brightness", LIGHT_PARAMS["BRIGHTNESS"]),
+            color=data.get("color", LIGHT_PARAMS["COLOR"]),
+            pattern_speed=data.get("patternSpeed", LIGHT_PARAMS["PATTERN_SPEED"])
+        )
+        logger.debug("Initialized Light: %s (ID: %d)", self.name, self.id)
+
+    @property
+    def id(self) -> int:
+        return self._data.light_id
+
+    @property
+    def name(self) -> str:
+        return self._data.name
+
+    @property
+    def is_on(self) -> bool:
+        return self._data.status == LIGHT_STATE["ON"]
+
+    def turn_on(self) -> None:
+        """Turn the light on."""
+        logger.debug("Turning on light: %s (ID: %d)", self.name, self.id)
+        try:
+            self._send_command(LIGHT_STATE["ON"])
+            self._data.status = LIGHT_STATE["ON"]
+            logger.info("Light turned on successfully: %s", self.name)
+        except Exception as e:
+            logger.error("Failed to turn on light %s: %s", self.name, str(e))
+            raise
+
+    def turn_off(self) -> None:
+        """Turn the light off."""
+        logger.debug("Turning off light: %s (ID: %d)", self.name, self.id)
+        try:
+            self._send_command(LIGHT_STATE["OFF"])
+            self._data.status = LIGHT_STATE["OFF"]
+            logger.info("Light turned off successfully: %s", self.name)
+        except Exception as e:
+            logger.error("Failed to turn off light %s: %s", self.name, str(e))
+            raise
+        
+    def _send_command(self, status_id: int) -> None:
+        """Send a command to the light."""
+        self._credentials.make_request(
+            "POST",
+            "/Light/CommandV1",
+            params={"locationId": self.location_id},
+            json={
+                "lightingStatusId": status_id,
+                "lightBrightnessId": LIGHT_PARAMS["BRIGHTNESS"],
+                "lightColorId": LIGHT_PARAMS["COLOR"],
+                "patternSpeedId": LIGHT_PARAMS["PATTERN_SPEED"],
+                "selectedLightIds": [self.id],
+                "locationId": self.location_id
+            }
+        )

havenlighting-0.1.0/havenlighting/devices/location.py

@@ -0,0 +1,100 @@
+from typing import Dict, Any, Optional, ClassVar
+import logging
+from ..models import LocationData
+from .light import Light
+from ..credentials import Credentials
+from ..exceptions import AuthenticationError
+
+logger = logging.getLogger(__name__)
+
+class Location:
+    """
+    Represents a Haven location with its associated lights.
+    
+    Attributes:
+        credentials: Credentials object for API requests
+        location_id: Unique identifier for the location
+        name: Location name
+    """
+    
+    MIN_CAPABILITY_LEVEL: ClassVar[int] = 0
+    
+    def __init__(self, credentials: Credentials, location_id: int, data: Optional[Dict[str, Any]] = None) -> None:
+        self._credentials = credentials
+        self._location_id = location_id
+        self._data = LocationData(
+            location_id=location_id,
+            name=data.get("name", ""),
+            owner_name=data.get("ownerName", "")
+        ) if data else None
+        self._lights: Dict[int, Light] = {}
+        logger.debug("Initialized Location: %s (ID: %d)", self.name, location_id)
+        
+    @property
+    def name(self) -> str:
+        """Get location name."""
+        return self._data.owner_name if self._data else ""
+        
+    @classmethod
+    def discover(cls, credentials: Credentials) -> Dict[int, 'Location']:
+        """
+        Discover all locations available to the authenticated user.
+        
+        Args:
+            credentials: Authenticated credentials object
+            
+        Returns:
+            Dictionary of location_id to Location objects
+            
+        Raises:
+            AuthenticationError: If not authenticated
+            ApiError: If API request fails
+        """
+        response = credentials.make_request(
+            "GET",
+            "/Location/OrderedLocationV2",
+            params={"minimumCapabilityLevel": cls.MIN_CAPABILITY_LEVEL},
+            use_prod_api=True
+        )
+        
+        locations = {}
+        for loc_data in response.get("data", []):
+            location_id = int(loc_data["locationId"])
+            locations[location_id] = cls(credentials, location_id, loc_data)
+        return locations
+        
+    def update(self) -> None:
+        """Update location details."""
+        response = self._credentials.make_request(
+            "GET", 
+            f"/Location/InformationSummary/{self._location_id}",
+            use_prod_api=True
+        )
+        self._data = response["data"]
+
+    def get_lights(self) -> Dict[int, Light]:
+        """Get all lights for this location."""
+        logger.debug("Fetching lights for location: %s (ID: %d)", self.name, self._location_id)
+        
+        if not self._lights:
+            try:
+                response = self._credentials.make_request(
+                    "GET",
+                    "/Light/OrderedLightsAndZones",
+                    params={"locationId": self._location_id}
+                )
+                
+                for light_data in response["data"]["lights"]:
+                    light_id = int(light_data["lightId"])
+                    self._lights[light_id] = Light(
+                        self._credentials,
+                        self._location_id,
+                        light_id,
+                        light_data
+                    )
+                logger.info("Found %d lights for location: %s", len(self._lights), self.name)
+            except Exception as e:
+                logger.error("Failed to fetch lights for location %d: %s", self._location_id, str(e))
+                raise
+                
+        return self._lights

havenlighting-0.1.0/havenlighting/exceptions.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+class HavenException(Exception):
+    """Base exception for Haven Lighting API errors."""
+    
+    def __init__(self, message: str, code: Optional[int] = None) -> None:
+        self.message = message
+        self.code = code
+        super().__init__(self.message)
+
+class ApiError(HavenException):
+    """Raised when an API request fails."""
+    pass
+
+class AuthenticationError(HavenException):
+    """Raised when authentication fails or is required but missing."""
+    pass
+
+class DeviceError(HavenException):
+    """Raised when a device operation fails."""
+    pass

havenlighting-0.1.0/havenlighting/logging.py

@@ -0,0 +1,29 @@
+"""Logging configuration for Haven Lighting."""
+
+import logging
+from typing import Optional
+
+def setup_logging(level: int = logging.INFO, 
+                 log_file: Optional[str] = None) -> None:
+    """
+    Configure logging for the Haven Lighting client.
+    
+    Args:
+        level: Logging level (default: INFO)
+        log_file: Optional file path for logging output
+    """
+    logger = logging.getLogger("havenlighting")
+    logger.setLevel(level)
+    
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+        
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler) 

havenlighting-0.1.0/havenlighting/models.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+from typing import Optional
+
+@dataclass
+class LightData:
+    """Data model for light attributes."""
+    light_id: int
+    name: str
+    status: int
+    brightness: int = 63
+    color: int = 63
+    pattern_speed: int = 63
+
+@dataclass
+class LocationData:
+    """Data model for location attributes."""
+    location_id: int
+    name: str
+    owner_name: Optional[str] = None 

havenlighting-0.1.0/havenlighting.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.1
+Name: havenlighting
+Version: 0.1.0
+Summary: Python client for Haven Lighting API
+Author-email: Mickey Schwab <mickeyschwab@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.0; extra == "dev"
+
+# Haven Lighting API Client
+
+A Python client library for interacting with the Haven Lighting API.
+
+## Installation
+
+```bash
+pip install havenlighting
+```
+
+## Usage
+
+```python
+from havenlighting import HavenClient
+
+# Initialize the client
+client = HavenClient()
+
+# Authenticate
+authenticated = client.authenticate(
+    email="your-email@example.com",
+    password="your-password"
+)
+
+if authenticated:
+    # Discover locations
+    locations = client.discover_locations()
+    
+    # Print available locations and lights
+    for location_id, location in locations.items():
+        print(f"Location: {location.name}")
+        
+        # Get lights for this location
+        lights = location.get_lights()
+        
+        # Control lights
+        for light_id, light in lights.items():
+            print(f"Light: {light.name}")
+            light.turn_on()   # Turn light on
+            light.turn_off()  # Turn light off
+
+```
+
+## Development
+
+1. Clone the repository
+2. Install development dependencies:
+```bash
+pip install -e ".[dev]"
+```
+
+3. Run tests:
+```bash
+pytest
+```
+
+## License
+
+MIT License - see LICENSE file for details.

havenlighting-0.1.0/havenlighting.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+havenlighting/__init__.py
+havenlighting/client.py
+havenlighting/config.py
+havenlighting/credentials.py
+havenlighting/exceptions.py
+havenlighting/logging.py
+havenlighting/models.py
+havenlighting.egg-info/PKG-INFO
+havenlighting.egg-info/SOURCES.txt
+havenlighting.egg-info/dependency_links.txt
+havenlighting.egg-info/requires.txt
+havenlighting.egg-info/top_level.txt
+havenlighting/devices/light.py
+havenlighting/devices/location.py
+tests/test_client.py

havenlighting-0.1.0/havenlighting.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

havenlighting-0.1.0/havenlighting.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests>=2.25.0
+
+[dev]
+pytest>=6.0
+pytest-mock>=3.0

havenlighting-0.1.0/havenlighting.egg-info/top_level.txt

@@ -0,0 +1 @@
+havenlighting

havenlighting-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "havenlighting"
+version = "0.1.0"
+description = "Python client for Haven Lighting API"
+authors = [{name = "Mickey Schwab", email = "mickeyschwab@gmail.com"}]
+license = {file = "LICENSE"}
+readme = "README.md"
+requires-python = ">=3.7"
+dependencies = [
+    "requests>=2.25.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=6.0",
+    "pytest-mock>=3.0"
+] 

havenlighting-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

havenlighting-0.1.0/tests/test_client.py

@@ -0,0 +1,76 @@
+import pytest
+
+from havenlighting import HavenClient
+from havenlighting.config import DEVICE_ID
+from havenlighting.credentials import Credentials
+from havenlighting.exceptions import AuthenticationError, DeviceError
+
+
+def test_client_initialization():
+    client = HavenClient()
+    assert isinstance(client._credentials, Credentials)
+    assert not client._credentials.is_authenticated
+    assert client._locations == {}
+    assert client._lights == {}
+
+def test_authentication_success(client, mocker):
+    # Create credentials first
+    credentials = Credentials()
+    
+    # Mock the internal request method
+    mock_request = mocker.patch.object(credentials, '_make_request_internal')
+    mock_request.return_value = {
+        "success": True,
+        "data": {
+            "token": "test_token",
+            "refreshToken": "test_refresh_token",
+            "id": 123
+        }
+    }
+    
+    client._credentials = credentials
+    assert client.authenticate("test@example.com", "password")
+    assert client._credentials.is_authenticated
+    mock_request.assert_called_once_with(
+        "POST",
+        "/User/authenticate",
+        json={
+            "email": "test@example.com",
+            "password": "password",
+            "deviceId": DEVICE_ID
+        },
+        auth_required=False
+    )
+
+def test_authentication_failure(client, mocker):
+    # Create credentials first
+    credentials = Credentials()
+    
+    # Mock failed authentication
+    mock_request = mocker.patch.object(credentials, '_make_request_internal')
+    mock_request.return_value = {
+        "success": False,
+        "returnCode": 600,
+        "severityLevel": 1,
+        "message": "Password is incorrect",
+        "data": None
+    }
+
+    client._credentials = credentials
+    
+    assert not client.authenticate("test@example.com", "wrong_password")
+    assert not client._credentials.is_authenticated
+
+def test_discover_locations(authenticated_client, mock_location_response, mocker):
+    # Mock the location discovery request
+    mock_request = mocker.patch.object(authenticated_client._credentials, 'make_request')
+    mock_request.return_value = mock_location_response
+    
+    locations = authenticated_client.discover_locations()
+    assert len(locations) == 1
+    location = next(iter(locations.values()))
+    assert location.name == "Test Location"
+
+def test_discover_locations_unauthenticated(client):
+    with pytest.raises(AuthenticationError):
+        client.discover_locations()