pycaldera 0.1.dev0__py3-none-any.whl

pycaldera/__init__.py

@@ -0,0 +1,22 @@
+"""Python client for Caldera Spa Connexion API."""
+
+from .async_client import AsyncCalderaClient
+from .exceptions import (
+    AuthenticationError,
+    CalderaError,
+    ConnectionError,
+    InvalidParameterError,
+    SpaControlError,
+)
+from .models import LiveSettings
+
+__all__ = [
+    "AsyncCalderaClient",
+    "LiveSettings",
+    "CalderaError",
+    "AuthenticationError",
+    "ConnectionError",
+    "SpaControlError",
+    "InvalidParameterError",
+]
+__version__ = "0.1.0"

pycaldera/__meta__.py

@@ -0,0 +1,12 @@
+# `name` is the name of the package as used for `pip install package`
+name = "pycaldera"
+# `path` is the name of the package for `import package`
+path = name.lower().replace("-", "_").replace(" ", "_")
+# Your version number should follow https://python.org/dev/peps/pep-0440 and
+# https://semver.org
+version = "0.1.dev0"
+author = "Mark Watson"
+author_email = "markwatson@cantab.net"
+description = "Unofficial Python client for Caldera Spa API"  # One-liner
+url = "https://github.com/mwatson2/pycaldera"  # Add your GitHub repo URL
+license = "MIT"  # See https://choosealicense.com

pycaldera/async_client.py

@@ -0,0 +1,495 @@
+"""Async client implementation for Caldera Spa API."""
+
+import json
+import logging
+from asyncio import AbstractEventLoop
+from typing import Any, Optional
+
+import aiohttp
+import pydantic
+from aiohttp import ClientError, ClientSession
+
+from .exceptions import (
+    AuthenticationError,
+    ConnectionError,
+    InvalidParameterError,
+    SpaControlError,
+)
+from .models import (
+    AuthResponse,
+    LiveSettings,
+    LiveSettingsResponse,
+    SpaResponseDato,
+    SpaStatusResponse,
+)
+
+logger = logging.getLogger(__name__)
+
+# Pump speed constants
+PUMP_OFF = 0
+PUMP_LOW = 1
+PUMP_HIGH = 2
+
+
+class AsyncCalderaClient:
+    """Async client for interacting with Caldera Spa API."""
+
+    BASE_URL = "https://connectedspa.watkinsmfg.com/connextion"
+
+    def __init__(
+        self,
+        email: str,
+        password: str,
+        timeout: float = 10.0,
+        debug: bool = False,
+        session: Optional[ClientSession] = None,
+        loop: Optional[AbstractEventLoop] = None,
+    ) -> None:
+        """Initialize the async Caldera client.
+
+        Args:
+            email: Email address for authentication
+            password: Password for authentication
+            timeout: Request timeout in seconds
+            debug: Enable debug logging
+            session: Optional aiohttp ClientSession to use
+            loop: Optional asyncio event loop to use
+        """
+        self.email = email
+        self.password = password
+        self.timeout = timeout
+        self._session = session
+        self._loop = loop
+        self._owns_session = False
+        self._token: Optional[str] = None
+        self._spa_id: Optional[int] = None
+        self._hna_number: Optional[str] = None
+
+        if debug:
+            logging.basicConfig(level=logging.DEBUG)
+        else:
+            logging.basicConfig(level=logging.INFO)
+
+    async def __aenter__(self) -> "AsyncCalderaClient":
+        """Enter async context manager."""
+        if self._session is None:
+            self._session = aiohttp.ClientSession(loop=self._loop)
+            self._owns_session = True
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Exit async context manager."""
+        if self._session and self._owns_session:
+            await self._session.close()
+            self._session = None
+
+    async def _make_request(
+        self, method: str, endpoint: str, **kwargs
+    ) -> tuple[dict[str, Any], dict[str, str]]:
+        """Make an async HTTP request to the API.
+
+        Returns:
+            Tuple of (response_data, response_headers)
+        """
+        if not self._session:
+            raise RuntimeError("Client not initialized. Use async context manager.")
+
+        url = f"{self.BASE_URL}/{endpoint}"
+        kwargs.setdefault("timeout", self.timeout)
+
+        # Add Authorization header if we have a token (except for login)
+        if self._token and not endpoint.endswith("auth/login"):
+            headers = kwargs.get("headers", {})
+            headers["Authorization"] = f"Bearer {self._token}"
+            kwargs["headers"] = headers
+
+        try:
+            logger.debug(f"Making async {method} request to {url}: {kwargs}")
+            async with self._session.request(method, url, **kwargs) as response:
+                response.raise_for_status()
+                data = await response.json()
+
+                if data.get("statusCode") != 200:
+                    raise SpaControlError(f"API error: {data.get('message')}")
+
+                return data, dict(response.headers)
+
+        except aiohttp.ClientResponseError as e:
+            if e.status == 401:
+                raise AuthenticationError("Authentication failed") from e
+            raise ConnectionError(f"HTTP error: {str(e)}") from e
+
+        except ClientError as e:
+            raise ConnectionError(f"Connection error: {str(e)}") from e
+
+        except json.JSONDecodeError as e:
+            raise ConnectionError(f"Invalid JSON response: {str(e)}") from e
+
+    async def authenticate(self) -> AuthResponse:
+        """Authenticate with the Caldera API."""
+        logger.info("Authenticating with Caldera API")
+        try:
+            data, headers = await self._make_request(
+                "POST",
+                "auth/login",
+                json={
+                    "emailAddress": self.email,
+                    "password": self.password,
+                    "deviceType": "IOS",
+                    "osType": "17.4.1",
+                    "mobileDeviceToken": "dummy_token:APA91bDummy0123456789",
+                    "location": "",
+                },
+            )
+
+            if not self._session:
+                raise RuntimeError("Session not initialized")
+
+            logger.debug(f"Authentication response: {json.dumps(data)}")
+
+            token = headers.get("Authorization", "")
+
+            if not token:
+                raise AuthenticationError("No authentication token received")
+
+            self._token = token  # Store just the raw token
+            logger.debug(f"Received authentication token: {self._token}")
+            logger.debug("Authentication successful")
+            return AuthResponse(**data)
+
+        except aiohttp.ClientResponseError as e:
+            logger.error(f"Authentication failed: {str(e)}")
+            raise AuthenticationError("Authentication failed") from e
+        except Exception as e:
+            logger.error(f"Authentication failed: {str(e)}")
+            raise
+
+    async def _ensure_auth(self) -> None:
+        """Ensure we have a valid authentication token."""
+        if not self._token:
+            await self.authenticate()
+
+    async def _ensure_spa_info(self) -> None:
+        """Ensure we have the spa ID and HNA number."""
+        if not self._hna_number or not self._spa_id:
+            status = await self.get_spa_status()
+            self._hna_number = status.hnaNumber
+            self._spa_id = status.spaId
+
+    def _parse_json_field(self, obj: dict, field_name: str) -> None:
+        """Parse a JSON string field and replace it with the parsed object.
+
+        Args:
+            obj: Dictionary containing the field to parse
+            field_name: Name of the field containing JSON string
+
+        Raises:
+            SpaControlError: If JSON parsing fails
+        """
+        if field_name in obj:
+            try:
+                json_str = obj[field_name]
+                parsed_data = json.loads(json_str)
+                obj[field_name] = parsed_data
+            except json.JSONDecodeError as e:
+                logger.error(f"Failed to parse {field_name}: {e}")
+                raise SpaControlError(f"Invalid {field_name} format") from e
+
+    async def get_spa_status(self) -> SpaResponseDato:
+        """Get the current status of the spa.
+
+        Returns:
+            SpaResponseDato containing current spa state
+
+        Raises:
+            AuthenticationError: If authentication fails
+            ConnectionError: If connection fails
+            SpaControlError: If the API returns an error
+        """
+        await self._ensure_auth()
+
+        try:
+            data, _ = await self._make_request("POST", "spa/my-spas", json={})
+            # logger.debug(f"Spa status response: {json.dumps(data)}")
+
+            # Pre-process the response to parse nested JSON
+            if not isinstance(data, dict):
+                raise SpaControlError("Invalid response format")
+
+            response_data = data.get("data", {}).get("responseDto", [])
+            if not response_data:
+                raise SpaControlError("No spa data in response")
+
+            # Parse nested JSON fields for each spa in the response
+            for spa in response_data:
+                # Parse thingWorxData in spaSettings
+                if "spaSettings" in spa:
+                    self._parse_json_field(spa["spaSettings"], "thingWorxData")
+
+                # Parse fields in isConnectedData
+                if "isConnectedData" in spa:
+                    connected_data = spa["isConnectedData"]
+                    self._parse_json_field(connected_data, "liveSettings")
+                    self._parse_json_field(connected_data, "isDeviceConnected")
+
+            # Now validate with pydantic
+            response = SpaStatusResponse(**data)
+            return response.data.responseDto[0]
+
+        except aiohttp.ClientResponseError as e:
+            logger.error(f"Failed to get spa status: {str(e)}")
+            if e.status == 401:
+                raise AuthenticationError("Authentication failed") from e
+            raise ConnectionError(f"HTTP error: {str(e)}") from e
+        except (KeyError, IndexError) as e:
+            logger.error(f"Invalid response format: {str(e)}")
+            raise SpaControlError("Unexpected API response format") from e
+        except pydantic.ValidationError as e:
+            logger.error(f"Invalid response data: {str(e)}")
+            raise SpaControlError("Invalid spa status data received") from e
+        except Exception as e:
+            logger.error(f"Failed to get spa status: {str(e)}")
+            raise ConnectionError(f"Unexpected error: {str(e)}") from e
+
+    async def get_live_settings(self) -> LiveSettings:
+        """Get current live settings from the spa.
+
+        Returns:
+            LiveSettings object containing current spa state
+
+        Raises:
+            AuthenticationError: If authentication fails
+            ConnectionError: If connection fails
+            SpaControlError: If the API returns an error
+        """
+        await self._ensure_auth()
+        await self._ensure_spa_info()
+
+        try:
+            data, _ = await self._make_request(
+                "GET", "setting/live-spa-settings", params={"hnaNo": self._hna_number}
+            )
+            logger.debug(f"Live settings response: {json.dumps(data)}")
+
+            # Pre-process the response to parse nested JSON
+            if not isinstance(data, dict):
+                raise SpaControlError("Invalid response format")
+
+            # Parse the nested JSON string in data field
+            self._parse_json_field(data, "data")
+
+            # Now validate with pydantic
+            response = LiveSettingsResponse(**data)
+            if not response.data.rows:
+                raise SpaControlError("No live settings data in response")
+
+            return response.data.rows[0]
+
+        except aiohttp.ClientResponseError as e:
+            logger.error(f"Failed to get live settings: {str(e)}")
+            if e.status == 401:
+                raise AuthenticationError("Authentication failed") from e
+            raise ConnectionError(f"HTTP error: {str(e)}") from e
+        except pydantic.ValidationError as e:
+            logger.error(f"Invalid response data: {str(e)}")
+            raise SpaControlError("Invalid spa settings data received") from e
+        except Exception as e:
+            logger.error(f"Failed to get live settings: {str(e)}")
+            raise ConnectionError(f"Unexpected error: {str(e)}") from e
+
+    async def set_temperature(self, temperature: float, unit: str = "F") -> bool:
+        """Set the target temperature for the spa.
+
+        Args:
+            temperature: Target temperature
+            unit: Temperature unit ('F' or 'C')
+
+        Returns:
+            bool indicating success
+
+        Raises:
+            InvalidParameterError: If temperature is out of valid range
+            AuthenticationError: If authentication fails
+            ConnectionError: If connection fails
+            SpaControlError: If the API returns an error
+        """
+        if unit.upper() == "F":
+            if not (80 <= temperature <= 104):
+                raise InvalidParameterError(
+                    "Temperature must be between 80°F and 104°F"
+                )
+        else:
+            if not (26.5 <= temperature <= 40):
+                raise InvalidParameterError(
+                    "Temperature must be between 26.5°C and 40°C"
+                )
+
+        await self._ensure_auth()
+        await self._ensure_spa_info()
+
+        # Convert to Fahrenheit if needed
+        if unit.upper() == "C":
+            temperature = (temperature * 9 / 5) + 32
+
+        # Hypothesize that 65535 is for 104 and 1 degree is 128
+        # (based on observing that 102 might be 65280)
+        temp_value = min(65535, 65536 - int((104 - temperature) * 128))
+
+        logger.debug(
+            f"Temperature encoding:\n"
+            f"  Requested: {temperature}°F\n"
+            f"  Current method: {temp_value} (0x{temp_value:04X})\n"
+        )
+
+        try:
+            await self._make_request(
+                "POST",
+                "setting/send-my-spa-settings-to-thingWorx",
+                params={"hnaNo": self._hna_number, "spaTempStatus": 1},
+                json={"param": json.dumps({"usr_set_temperature": str(temp_value)})},
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Failed to set temperature: {str(e)}")
+            raise
+
+    async def set_lights(self, state: bool) -> bool:
+        """Turn spa lights on or off.
+
+        Args:
+            state: True to turn lights on, False to turn off
+
+        Returns:
+            bool indicating success
+
+        Raises:
+            AuthenticationError: If authentication fails
+            ConnectionError: If connection fails
+            SpaControlError: If the API returns an error
+        """
+        await self._ensure_auth()
+        await self._ensure_spa_info()
+
+        light_value = "1041" if state else "1040"
+        logger.info(f"Setting lights {'on' if state else 'off'}")
+
+        try:
+            await self._make_request(
+                "POST",
+                "setting/send-my-spa-settings-to-thingWorx",
+                params={"hnaNo": self._hna_number},
+                json={"param": json.dumps({"usr_set_mz_light": light_value})},
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Failed to set lights: {str(e)}")
+            raise
+
+    async def set_pump(self, pump_number: int, speed: int) -> bool:
+        """Control a jet pump.
+
+        Args:
+            pump_number: Pump number (1-3)
+            speed: Pump speed (0=off, 1=low, 2=high)
+
+        Returns:
+            bool indicating success
+
+        Raises:
+            InvalidParameterError: If pump number or speed is invalid
+            AuthenticationError: If authentication fails
+            ConnectionError: If connection fails
+            SpaControlError: If the API returns an error
+        """
+        if not 1 <= pump_number <= 3:
+            raise InvalidParameterError("Pump number must be 1, 2, or 3")
+        if not 0 <= speed <= 2:
+            raise InvalidParameterError("Speed must be 0 (off), 1 (low), or 2 (high)")
+
+        await self._ensure_auth()
+        await self._ensure_spa_info()
+
+        param_name = f"usr_set_pump{pump_number}_speed"
+        logger.info(f"Setting pump {pump_number} to speed {speed}")
+
+        try:
+            await self._make_request(
+                "POST",
+                "setting/send-my-spa-settings-to-thingWorx",
+                params={"hnaNo": self._hna_number},
+                json={"param": json.dumps({param_name: str(speed)})},
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Failed to set pump: {str(e)}")
+            raise
+
+    async def set_temp_lock(self, locked: bool) -> bool:
+        """Lock or unlock temperature controls.
+
+        Args:
+            locked: True to lock, False to unlock
+
+        Returns:
+            bool indicating success
+
+        Raises:
+            AuthenticationError: If authentication fails
+            ConnectionError: If connection fails
+            SpaControlError: If the API returns an error
+        """
+        await self._ensure_auth()
+        await self._ensure_spa_info()
+
+        logger.info(f"Setting temperature lock to {'locked' if locked else 'unlocked'}")
+
+        try:
+            await self._make_request(
+                "POST",
+                "setting/send-my-spa-settings-to-thingWorx",
+                params={"hnaNo": self._hna_number},
+                json={
+                    "param": json.dumps(
+                        {"usr_set_temp_lock_state": "2" if locked else "1"}
+                    )
+                },
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Failed to set temperature lock: {str(e)}")
+            raise
+
+    async def set_spa_lock(self, locked: bool) -> bool:
+        """Lock or unlock all spa controls.
+
+        Args:
+            locked: True to lock, False to unlock
+
+        Returns:
+            bool indicating success
+
+        Raises:
+            AuthenticationError: If authentication fails
+            ConnectionError: If connection fails
+            SpaControlError: If the API returns an error
+        """
+        await self._ensure_auth()
+        await self._ensure_spa_info()
+
+        logger.info(f"Setting spa lock to {'locked' if locked else 'unlocked'}")
+
+        try:
+            await self._make_request(
+                "POST",
+                "setting/send-my-spa-settings-to-thingWorx",
+                params={"hnaNo": self._hna_number},
+                json={
+                    "param": json.dumps(
+                        {"usr_set_spa_lock_state": "2" if locked else "1"}
+                    )
+                },
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Failed to set spa lock: {str(e)}")
+            raise

pycaldera/exceptions.py

@@ -0,0 +1,31 @@
+"""Custom exceptions for the Caldera client."""
+
+
+class CalderaError(Exception):
+    """Base exception for all Caldera client errors."""
+
+    pass
+
+
+class AuthenticationError(CalderaError):
+    """Raised when authentication fails."""
+
+    pass
+
+
+class ConnectionError(CalderaError):
+    """Raised when connection to the spa fails."""
+
+    pass
+
+
+class SpaControlError(CalderaError):
+    """Raised when a control operation fails."""
+
+    pass
+
+
+class InvalidParameterError(CalderaError):
+    """Raised when an invalid parameter is provided."""
+
+    pass

pycaldera/models.py

@@ -0,0 +1,261 @@
+"""Data models for Caldera Spa API."""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+class AuthResponse(BaseModel):
+    """Response from authentication endpoint."""
+
+    statusCode: int
+    message: str
+    data: dict
+    timeStamp: str
+    nTime: str
+
+
+class LiveSettings(BaseModel):
+    """Live settings from the spa ThingWorx system."""
+
+    # Temperature settings
+    ctrl_head_water_temperature: float
+    ctrl_head_set_temperature: float
+    usr_set_temperature: str
+    usr_set_temperature_ack: str
+    ctrl_head_water_temperature_ack: str
+    temp_diff: float
+    feature_configuration_degree_celcius: str
+
+    # Pump settings
+    usr_set_pump1_speed: str
+    usr_set_pump2_speed: str
+    usr_set_pump3_speed: str
+    usr_set_blower: str
+    usr_set_heat_pump: str
+
+    # Light settings
+    usr_set_light_state: str
+    usr_set_mz_light: str
+    usr_set_mz_ack: str
+
+    # Lock states
+    usr_set_temp_lock_state: str
+    usr_set_spa_lock_state: str
+    usr_set_clean_lock_state: str
+
+    # Filter and cleaning
+    filter_time_1: str
+    filter_time_2: str
+    usr_set_clean_cycle: str
+    usr_set_stm_state: str
+
+    # Audio settings
+    audio_power: str
+    audio_source_selection: str
+    usr_set_audio_data: str
+    usr_set_audio_ack: str
+
+    # System status
+    mz_system_status: str
+    hawk_status_econ: str
+    g3_level2_errors: str
+    g3_clrmtr_test_data: str
+    lls_power_and_ready_ace_err: str
+    usr_set_system_reset: str
+
+    # Usage tracking
+    spa_usage: str
+    usr_spa_usage: str
+    salline_test: str
+
+    # Menu entries
+    usr_set_tanas_menu_entry: str
+    usr_set_tanas_menu_entry_ack: str
+    usr_set_tanas_menu_entry_test: str
+    usr_set_tanas_menu_entry_boost: str
+
+    # Metadata
+    name: str
+    description: str
+    thingTemplate: str
+    tags: list[dict[str, str]]
+
+
+class LiveSettingsFieldDefinition(BaseModel):
+    """Definition of a field in live settings."""
+
+    name: str
+    description: str = ""
+    baseType: str
+    ordinal: int
+    aspects: dict[str, Any]
+
+
+class LiveSettingsDataShape(BaseModel):
+    """Shape of the live settings data."""
+
+    fieldDefinitions: dict[str, LiveSettingsFieldDefinition]
+
+
+class LiveSettingsData(BaseModel):
+    """Parsed live settings data structure."""
+
+    dataShape: LiveSettingsDataShape
+    rows: list[LiveSettings]
+
+
+class LiveSettingsResponse(BaseModel):
+    """Response from the live settings endpoint."""
+
+    statusCode: int
+    message: str
+    data: LiveSettingsData
+    oldUserData: Optional[Any] = None
+    timeStamp: str
+    nTime: str
+
+
+class SpaDetails(BaseModel):
+    """Details about a specific spa model."""
+
+    Brand: str
+    Series: str
+    Model: str
+
+
+class LightSettings(BaseModel):
+    """Light configuration for the spa."""
+
+    Lights: bool
+    Bartop: bool
+    Dimming: str
+    Underwater_Main_Light: bool
+    Water_Feature: bool
+    Lighting_Type: str
+    Exterior_Light: bool
+
+
+class JetPumps(BaseModel):
+    """Configuration of jet pumps."""
+
+    Jet_Pump_1: str
+    Jet_Pump_2: str
+    Jet_Pump_3: str
+
+
+class OptionalFeatures(BaseModel):
+    """Optional spa features."""
+
+    Audio: bool
+    CoolZoneTM: bool
+    FreshWater_Salt_SystemTM: bool = Field(alias="FreshWater Salt SystemTM")
+
+
+class SpaConfiguration(BaseModel):
+    """Complete spa configuration."""
+
+    Control_Box: str = Field(alias="Control Box")
+    Circulation_Pump: str = Field(alias="Circulation Pump")
+    SPA_Details: SpaDetails
+    JET_PUMPS: JetPumps = Field(alias="JET PUMPS")
+    Summer_Timer: str = Field(alias="Summer_Timer")
+    Lights: LightSettings
+    OPTIONAL_FEATURES: OptionalFeatures = Field(alias="OPTIONAL FEATURES")
+
+
+class SpaSettings(BaseModel):
+    """Settings configuration for the spa."""
+
+    id: int
+    thingWorxData: SpaConfiguration  # Changed from str to SpaConfiguration
+    tempLock: bool
+    spaLock: bool
+    filterStatus: Optional[str]
+    cleanUpCycle: bool
+    summerTimer: bool
+    units: Optional[str]
+    spaEmailNotification: bool
+    promotionEmailNotification: bool
+    spaPushNotification: bool
+    createdAt: str
+    updatedAt: str
+    userTempratureUnit: bool
+    promotionPushNotification: bool
+
+
+class DeviceConnectionRow(BaseModel):
+    """Single row of device connection data."""
+
+    result: bool
+
+
+class ThingWorxResponse(BaseModel):
+    """Generic ThingWorx response structure."""
+
+    dataShape: dict  # Keep as dict since it's metadata we don't need
+    rows: list
+
+
+class ThingWorxLiveSettings(ThingWorxResponse):
+    """Live settings from ThingWorx system."""
+
+    rows: list[LiveSettings]  # Override rows type for live settings
+
+
+class ThingWorxDeviceConnection(ThingWorxResponse):
+    """Device connection status from ThingWorx system."""
+
+    rows: list[DeviceConnectionRow]  # Override rows type for device connection
+
+
+class IsConnectedData(BaseModel):
+    """Connection status data for the spa."""
+
+    liveSettings: ThingWorxLiveSettings
+    isDeviceConnected: ThingWorxDeviceConnection
+
+
+class SpaResponseDato(BaseModel):
+    """Individual spa response data."""
+
+    spaId: int
+    spaName: str
+    spaSerialNumber: str
+    hnaNumber: str
+    snaNumber: str
+    output: Optional[str]
+    address: Optional[str]
+    state: Optional[str]
+    country: Optional[str]
+    postalCode: Optional[str]
+    status: str
+    spaSettings: SpaSettings
+    spaTempStatus: int
+    installationDate: str
+    spaOwnerStatus: str
+    invitationMailStatus: str
+    isConnectedData: IsConnectedData
+    userId: int
+    firstName: str
+    lastName: str
+    emailAddress: str
+    userTempratureUnit: bool
+
+
+class ResponseData(BaseModel):
+    """Data field for spa status response."""
+
+    responseDto: list[SpaResponseDato]
+    unReadNotificationCount: int
+
+
+class SpaStatusResponse(BaseModel):
+    """Complete response from spa status endpoint."""
+
+    statusCode: int
+    message: str
+    data: ResponseData
+    oldUserData: list
+    timeStamp: str
+    nTime: str

pycaldera-0.1.dev0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mark Watson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pycaldera-0.1.dev0.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.2
+Name: pycaldera
+Version: 0.1.dev0
+Summary: Unofficial Python client for Caldera Spa API
+Home-page: https://github.com/mwatson2/pycaldera
+Author: Mark Watson
+Author-email: markwatson@cantab.net
+License: MIT
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: black>=23.0.0
+Requires-Dist: isort>=5.12.0
+Requires-Dist: mypy>=1.0.0
+Requires-Dist: pylint>=2.17.0
+Requires-Dist: pytest>=7.0.0
+Requires-Dist: pytest-aiohttp>=1.0.0
+Requires-Dist: pytest-asyncio>=0.21.0
+Requires-Dist: pytest-cov>=4.0.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-flake8; extra == "test"
+Provides-Extra: docs
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: pypandoc>=1.6.3; extra == "docs"
+Requires-Dist: readthedocs-sphinx-search; python_version >= "3.6" and extra == "docs"
+Requires-Dist: sphinx<6,>=3.5.4; extra == "docs"
+Requires-Dist: sphinx-autobuild; extra == "docs"
+Requires-Dist: sphinx_book_theme; extra == "docs"
+Requires-Dist: watchdog<1.0.0; python_version < "3.6" and extra == "docs"
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pylint>=2.17.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-aiohttp>=1.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Provides-Extra: all
+Requires-Dist: black>=23.0.0; extra == "all"
+Requires-Dist: isort>=5.12.0; extra == "all"
+Requires-Dist: mypy>=1.0.0; extra == "all"
+Requires-Dist: myst-parser; extra == "all"
+Requires-Dist: pylint>=2.17.0; extra == "all"
+Requires-Dist: pypandoc>=1.6.3; extra == "all"
+Requires-Dist: pytest; extra == "all"
+Requires-Dist: pytest-aiohttp>=1.0.0; extra == "all"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "all"
+Requires-Dist: pytest-cov; extra == "all"
+Requires-Dist: pytest-cov>=4.0.0; extra == "all"
+Requires-Dist: pytest-flake8; extra == "all"
+Requires-Dist: pytest>=7.0.0; extra == "all"
+Requires-Dist: readthedocs-sphinx-search; python_version >= "3.6" and extra == "all"
+Requires-Dist: sphinx-autobuild; extra == "all"
+Requires-Dist: sphinx<6,>=3.5.4; extra == "all"
+Requires-Dist: sphinx_book_theme; extra == "all"
+Requires-Dist: watchdog<1.0.0; python_version < "3.6" and extra == "all"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# pycaldera
+
+Python client library for controlling Caldera spas via their cloud API.
+
+## Installation
+
+```bash
+pip install pycaldera
+```
+
+## Usage
+
+```python
+import asyncio
+from pycaldera import AsyncCalderaClient, PUMP_OFF, PUMP_LOW, PUMP_HIGH
+
+async def main():
+    async with AsyncCalderaClient("email@example.com", "password") as spa:
+        # Get current spa status
+        status = await spa.get_spa_status()
+        print(f"Current temperature: {status.ctrl_head_water_temperature}°F")
+        
+        # Get detailed live settings
+        settings = await spa.get_live_settings()
+        print(f"Target temperature: {settings.ctrl_head_set_temperature}°F")
+        
+        # Control the spa
+        await spa.set_temperature(102)  # Set temperature to 102°F
+        await spa.set_pump(1, PUMP_HIGH)  # Set pump 1 to high speed
+        await spa.set_lights(True)  # Turn on the lights
+
+asyncio.run(main())
+```
+
+## API Reference
+
+### AsyncCalderaClient
+
+Main client class for interacting with the spa.
+
+```python
+client = AsyncCalderaClient(
+    email="email@example.com",
+    password="password",
+    timeout=10.0,      # Optional: request timeout in seconds
+    debug=False,       # Optional: enable debug logging
+)
+```
+
+### Temperature Control
+
+```python
+# Set temperature (80-104°F or 26.5-40°C)
+await spa.set_temperature(102)      # Fahrenheit
+await spa.set_temperature(39, "C")  # Celsius
+```
+
+### Pump Control
+
+```python
+# Set pump speed
+await spa.set_pump(1, PUMP_HIGH)  # Set pump 1 to high speed
+await spa.set_pump(2, PUMP_LOW)   # Set pump 2 to low speed
+await spa.set_pump(3, PUMP_OFF)   # Turn off pump 3
+```
+
+### Light Control
+
+```python
+await spa.set_lights(True)   # Turn lights on
+await spa.set_lights(False)  # Turn lights off
+```
+
+### Status & Settings
+
+```python
+# Get basic spa status
+status = await spa.get_spa_status()
+print(f"Spa name: {status.spaName}")
+print(f"Current temp: {status.ctrl_head_water_temperature}°F")
+print(f"Online: {status.status == 'ONLINE'}")
+
+# Get detailed live settings
+settings = await spa.get_live_settings()
+print(f"Target temp: {settings.ctrl_head_set_temperature}°F")
+print(f"Pump 1 speed: {settings.usr_set_pump1_speed}")
+print(f"Lights on: {settings.usr_set_light_state}")
+```
+
+## Development
+
+1. Clone the repository
+2. Create a virtual environment:
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # or `venv\Scripts\activate` on Windows
+   ```
+3. Install development dependencies:
+   ```bash
+   pip install -r requirements-dev.txt
+   ```
+4. Install pre-commit hooks:
+   ```bash
+   pre-commit install
+   ```
+
+The pre-commit hooks will run automatically on git commit, checking:
+- Code formatting (Black)
+- Import sorting (isort)
+- Type checking (mypy)
+- Linting (pylint, ruff)
+- YAML/TOML syntax
+- Trailing whitespace and file endings
+
+## License
+
+MIT License - see LICENSE file for details. 

pycaldera-0.1.dev0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pycaldera/__init__.py,sha256=SedSnpd6wzkEFL0-bBriisov9hXmn-w8fElAaa0EUzk,475
+pycaldera/__meta__.py,sha256=4SeJRcZ0dx95LkerGYzb5tMxDhByJ8xLuSUC_HRAwx0,581
+pycaldera/async_client.py,sha256=HypE0XmshrBq3A26zTYqakCKN0PNqhn-dhxXdBl8mJ0,17515
+pycaldera/exceptions.py,sha256=DYXRGoCL30fWyD1zw9pBj2Vhir1e3mUKKJwXqbPAjWY,553
+pycaldera/models.py,sha256=Tu-zMUXyUY6-flFHlpH_2zQBf1NuX3b_-lKLaHJJSnM,5929
+pycaldera-0.1.dev0.dist-info/LICENSE,sha256=oYq3ICPDw6q1C74Hei_Y1Q5C0l3-OmLcNp5GWRj8kJM,1068
+pycaldera-0.1.dev0.dist-info/METADATA,sha256=ZWk1tmuyPd5U_4_xDfTqSI4AXB7nJ4V2jABwYuOAGjc,6016
+pycaldera-0.1.dev0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+pycaldera-0.1.dev0.dist-info/top_level.txt,sha256=35Jd7XNrb8Mk0PyhbVarv3GtWx4pegc8MPx5yznIcYI,10
+pycaldera-0.1.dev0.dist-info/RECORD,,

pycaldera-0.1.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pycaldera-0.1.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pycaldera