quilt-hp-python 0.1.1__py3-none-any.whl

quilt_hp/services/user.py

@@ -0,0 +1,143 @@
+"""UserService — current user info."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Any, Protocol, cast
+
+import grpc.aio
+
+from quilt_hp._proto import quilt_services_pb2 as svc
+from quilt_hp._proto import quilt_services_pb2_grpc as svc_grpc
+from quilt_hp.exceptions import QuiltError
+
+
+class DeclaredUserType(IntEnum):
+    """Declared user type used by UserAttributes."""
+
+    UNSPECIFIED = int(svc.DECLARED_USER_TYPE_UNSPECIFIED)
+    HOMEOWNER = int(svc.DECLARED_USER_TYPE_HOMEOWNER)
+    PARTNER = int(svc.DECLARED_USER_TYPE_PARTNER)
+
+
+@dataclass(slots=True)
+class User:
+    """Quilt user account."""
+
+    id: str
+    first_name: str
+    last_name: str
+    email: str
+    phone_number: str
+
+
+@dataclass(slots=True)
+class UserAttributes:
+    """Additional user attributes exposed by UserService."""
+
+    declared_user_type: DeclaredUserType
+
+
+class _UserServiceStub(Protocol):
+    async def GetLoggedInUser(self, request: svc.GetLoggedInUserRequest) -> object: ...
+    async def UpdateLoggedInUser(self, request: svc.UpdateLoggedInUserRequest) -> object: ...
+    async def GetUserAttributes(self, request: svc.GetUserAttributesRequest) -> object: ...
+    async def PatchUserAttributes(self, request: svc.PatchUserAttributesRequest) -> object: ...
+
+
+def _to_user(response: Any) -> User:
+    user = response.user if hasattr(response, "user") else response
+    return User(
+        id=user.quilt_user_id,
+        first_name=user.first_name,
+        last_name=user.last_name,
+        email=user.email,
+        phone_number=user.phone_number,
+    )
+
+
+def _to_user_attributes(response: Any) -> UserAttributes:
+    try:
+        declared_user_type = DeclaredUserType(response.declared_user_type)
+    except ValueError:
+        declared_user_type = DeclaredUserType.UNSPECIFIED
+    return UserAttributes(declared_user_type=declared_user_type)
+
+
+class UserService:
+    """Async wrapper for UserService gRPC methods."""
+
+    def __init__(self, channel: grpc.aio.Channel) -> None:
+        factory = cast("Callable[[grpc.aio.Channel], _UserServiceStub]", svc_grpc.UserServiceStub)
+        self._stub: _UserServiceStub = factory(channel)
+
+    async def get_current_user(self) -> User:
+        """Get the currently authenticated user."""
+        try:
+            response = cast(
+                "Any",
+                await self._stub.GetLoggedInUser(svc.GetLoggedInUserRequest()),
+            )
+        except grpc.aio.AioRpcError as exc:
+            raise QuiltError(f"GetLoggedInUser failed: {exc.details()}") from exc
+        return _to_user(response)
+
+    async def update_current_user(
+        self,
+        *,
+        first_name: str,
+        last_name: str,
+        phone_number: str | None = None,
+    ) -> User:
+        """Update first/last name and optional phone number for current user."""
+        try:
+            response = cast(
+                "Any",
+                await self._stub.UpdateLoggedInUser(
+                    svc.UpdateLoggedInUserRequest(
+                        first_name=first_name,
+                        last_name=last_name,
+                        phone_number=phone_number or "",
+                    )
+                ),
+            )
+        except grpc.aio.AioRpcError as exc:
+            raise QuiltError(f"UpdateLoggedInUser failed: {exc.details()}") from exc
+        return _to_user(response)
+
+    async def get_user_attributes(self) -> UserAttributes:
+        """Get current user's additional attributes."""
+        try:
+            response = cast(
+                "Any",
+                await self._stub.GetUserAttributes(svc.GetUserAttributesRequest()),
+            )
+        except grpc.aio.AioRpcError as exc:
+            raise QuiltError(f"GetUserAttributes failed: {exc.details()}") from exc
+        return _to_user_attributes(response)
+
+    async def patch_user_attributes(
+        self,
+        *,
+        declared_user_type: DeclaredUserType,
+    ) -> UserAttributes:
+        """Patch user attributes for the current user."""
+        try:
+            response = cast(
+                "Any",
+                await self._stub.PatchUserAttributes(
+                    svc.PatchUserAttributesRequest(
+                        user_attributes=svc.UserAttributes(
+                            declared_user_type=cast(
+                                "svc.DeclaredUserType.ValueType",
+                                int(declared_user_type),
+                            ),
+                        )
+                    )
+                ),
+            )
+        except grpc.aio.AioRpcError as exc:
+            raise QuiltError(f"PatchUserAttributes failed: {exc.details()}") from exc
+        return _to_user_attributes(response)

quilt_hp/tokens.py

@@ -0,0 +1,119 @@
+"""Token types and storage protocols for Quilt authentication.
+
+The core library defines the data types and an async-first ``TokenStore``
+protocol. Persistence is the caller's responsibility — the CLI provides
+``FileStore`` in ``quilt_hp.cli.store``.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Protocol
+
+_TOKEN_BUFFER_S = 300  # treat tokens as expired 5 min before actual expiry
+
+
+@dataclass(slots=True)
+class CachedTokens:
+    """A Cognito IdToken plus its refresh token and expiry timestamp."""
+
+    id_token: str
+    refresh_token: str
+    expires_at: float  # unix timestamp
+
+    @property
+    def is_expired(self) -> bool:
+        """True if the IdToken has expired (with a 5-minute safety buffer)."""
+        return time.time() > self.expires_at - _TOKEN_BUFFER_S
+
+
+class TokenStore(Protocol):
+    """Async-first protocol for token persistence.
+
+    Implement this to integrate with any storage backend
+    (filesystem, HA secure storage, database, keychain, …).
+    """
+
+    async def load(self, email: str) -> CachedTokens | None:
+        """Return cached tokens for *email*, or None if absent / invalid."""
+        ...
+
+    async def save(self, email: str, tokens: CachedTokens) -> None:
+        """Persist *tokens* for *email*."""
+        ...
+
+
+class LegacyTokenStore(Protocol):
+    """Compatibility protocol for existing synchronous token stores."""
+
+    def load(self, email: str) -> CachedTokens | None:
+        """Return cached tokens for *email*, or None if absent / invalid."""
+        ...
+
+    def save(self, email: str, tokens: CachedTokens) -> None:
+        """Persist *tokens* for *email*."""
+        ...
+
+
+type TokenStoreLike = TokenStore | LegacyTokenStore
+type TokenPersistenceBackend = TokenStoreLike
+
+
+class CurrentTokenProvider(Protocol):
+    """Protocol for objects that can provide the current auth token."""
+
+    def get_current_token(self) -> str:
+        """Return the current authorization token."""
+        ...
+
+
+class TokenRefreshReason(StrEnum):
+    """Why a token refresh is being attempted."""
+
+    EXPIRED_CACHED_TOKEN = "expired_cached_token"
+    TRANSPORT_UNAUTHENTICATED = "transport_unauthenticated"
+    STREAM_UNAUTHENTICATED = "stream_unauthenticated"
+
+
+@dataclass(slots=True, frozen=True)
+class TokenRefreshContext:
+    """Context describing a token refresh attempt."""
+
+    reason: TokenRefreshReason
+    source: str
+    attempt: int = 1
+
+
+class RefreshFailureAction(StrEnum):
+    """Policy decision for handling refresh failures."""
+
+    FALLBACK_TO_OTP = "fallback_to_otp"
+    RAISE = "raise"
+
+
+class TokenRefreshHooks(Protocol):
+    """Optional lifecycle hooks invoked around token refresh attempts."""
+
+    async def on_refresh_start(self, context: TokenRefreshContext) -> None:
+        """Called before attempting token refresh."""
+        ...
+
+    async def on_refresh_success(self, context: TokenRefreshContext, tokens: CachedTokens) -> None:
+        """Called when refresh succeeds and new tokens are produced."""
+        ...
+
+    async def on_refresh_failure(self, context: TokenRefreshContext, error: Exception) -> None:
+        """Called when refresh fails."""
+        ...
+
+
+class TokenRefreshPolicy(Protocol):
+    """Host-defined policy for deciding what to do after refresh failure."""
+
+    def on_refresh_failure(
+        self, context: TokenRefreshContext, error: Exception
+    ) -> RefreshFailureAction:
+        """Return fallback strategy when refresh fails."""
+        ...

quilt_hp/transport.py

@@ -0,0 +1,192 @@
+"""Async gRPC transport — channel creation and auth interceptor."""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Awaitable, Callable
+from typing import cast
+
+import grpc
+import grpc.aio
+
+from quilt_hp.const import (
+    APP_VERSION,
+    GRPC_CHANNEL_OPTIONS,
+    Environment,
+    grpc_host,
+)
+from quilt_hp.tokens import CurrentTokenProvider, TokenRefreshContext, TokenRefreshReason
+
+type RefreshCallback = (
+    Callable[[], Awaitable[None]] | Callable[[TokenRefreshContext], Awaitable[None]]
+)
+type TokenProviderLike = Callable[[], str] | CurrentTokenProvider
+
+
+def _resolve_token_provider(token_provider: TokenProviderLike) -> Callable[[], str]:
+    if callable(token_provider):
+        return token_provider
+    return token_provider.get_current_token
+
+
+async def _invoke_refresh_callback(
+    refresh_callback: RefreshCallback, context: TokenRefreshContext
+) -> None:
+    try:
+        has_params = bool(inspect.signature(refresh_callback).parameters)
+    except TypeError:
+        has_params = False
+    except ValueError:
+        has_params = False
+    if has_params:
+        await cast("Callable[[TokenRefreshContext], Awaitable[None]]", refresh_callback)(context)
+        return
+    await cast("Callable[[], Awaitable[None]]", refresh_callback)()
+
+
+class _AuthInterceptor(
+    grpc.aio.UnaryUnaryClientInterceptor,  # type: ignore[misc]
+    grpc.aio.UnaryStreamClientInterceptor,  # type: ignore[misc]
+    grpc.aio.StreamUnaryClientInterceptor,  # type: ignore[misc]
+    grpc.aio.StreamStreamClientInterceptor,  # type: ignore[misc]
+):
+    """Injects authorization and app-version metadata into every gRPC call.
+
+    If ``refresh_callback`` is provided, it is awaited once on
+    ``UNAUTHENTICATED`` and the call is retried with fresh credentials.
+    """
+
+    def __init__(
+        self,
+        token_provider: TokenProviderLike,
+        refresh_callback: RefreshCallback | None = None,
+    ) -> None:
+        self._token_provider = _resolve_token_provider(token_provider)
+        self._refresh_callback = refresh_callback
+
+    def _metadata(self) -> list[tuple[str, str]]:
+        return [
+            ("authorization", self._token_provider()),
+            ("x-quilt-app-version", APP_VERSION),
+        ]
+
+    def _patch(
+        self, client_call_details: grpc.aio.ClientCallDetails
+    ) -> grpc.aio.ClientCallDetails:
+        return grpc.aio.ClientCallDetails(
+            method=client_call_details.method,
+            timeout=client_call_details.timeout,
+            metadata=list(client_call_details.metadata or []) + self._metadata(),
+            credentials=client_call_details.credentials,
+            wait_for_ready=client_call_details.wait_for_ready,
+        )
+
+    async def _refresh_and_retry(
+        self,
+        continuation: Callable[..., Awaitable[object]],
+        client_call_details: grpc.aio.ClientCallDetails,
+        *args: object,
+    ) -> object:
+        """Refresh the token and retry the call once."""
+        if self._refresh_callback is not None:
+            await _invoke_refresh_callback(
+                self._refresh_callback,
+                TokenRefreshContext(
+                    reason=TokenRefreshReason.TRANSPORT_UNAUTHENTICATED,
+                    source="transport",
+                ),
+            )
+        return await continuation(self._patch(client_call_details), *args)
+
+    async def intercept_unary_unary(
+        self,
+        continuation: Callable[
+            [grpc.aio.ClientCallDetails, object],
+            Awaitable[object],
+        ],
+        client_call_details: grpc.aio.ClientCallDetails,
+        request: object,
+    ) -> object:
+        try:
+            return await continuation(self._patch(client_call_details), request)
+        except grpc.aio.AioRpcError as exc:
+            if exc.code() == grpc.StatusCode.UNAUTHENTICATED and self._refresh_callback:
+                return await self._refresh_and_retry(continuation, client_call_details, request)
+            raise
+
+    async def intercept_unary_stream(
+        self,
+        continuation: Callable[
+            [grpc.aio.ClientCallDetails, object],
+            Awaitable[object],
+        ],
+        client_call_details: grpc.aio.ClientCallDetails,
+        request: object,
+    ) -> object:
+        try:
+            return await continuation(self._patch(client_call_details), request)
+        except grpc.aio.AioRpcError as exc:
+            if exc.code() == grpc.StatusCode.UNAUTHENTICATED and self._refresh_callback:
+                return await self._refresh_and_retry(continuation, client_call_details, request)
+            raise
+
+    async def intercept_stream_unary(
+        self,
+        continuation: Callable[
+            [grpc.aio.ClientCallDetails, object],
+            Awaitable[object],
+        ],
+        client_call_details: grpc.aio.ClientCallDetails,
+        request_iterator: object,
+    ) -> object:
+        return await continuation(self._patch(client_call_details), request_iterator)
+
+    async def intercept_stream_stream(
+        self,
+        continuation: Callable[
+            [grpc.aio.ClientCallDetails, object],
+            Awaitable[object],
+        ],
+        client_call_details: grpc.aio.ClientCallDetails,
+        request_iterator: object,
+    ) -> object:
+        return await continuation(self._patch(client_call_details), request_iterator)
+
+
+def create_channel(
+    token_provider: TokenProviderLike,
+    environment: Environment = Environment.PROD,
+    refresh_callback: RefreshCallback | None = None,
+) -> grpc.aio.Channel:
+    """Create an authenticated async gRPC channel.
+
+    Args:
+        token_provider: A callable that returns the current JWT token.
+        environment: Which Quilt API environment to connect to.
+        refresh_callback: Optional async callable invoked once on
+            UNAUTHENTICATED to refresh the token before retrying.
+
+    Returns:
+        An async gRPC channel with TLS and auth interceptor.
+    """
+    host = grpc_host(environment)
+    creds = grpc.ssl_channel_credentials()
+    interceptors = [_AuthInterceptor(token_provider, refresh_callback)]
+    return grpc.aio.secure_channel(
+        host,
+        creds,
+        options=GRPC_CHANNEL_OPTIONS,
+        interceptors=interceptors,
+    )
+
+
+def auth_metadata(token_provider: TokenProviderLike) -> list[tuple[str, str]]:
+    """Build gRPC metadata with auth headers.
+
+    Useful for stream-stream RPCs where the channel interceptor may not fire.
+    """
+    resolved_provider = _resolve_token_provider(token_provider)
+    return [
+        ("authorization", resolved_provider()),
+        ("x-quilt-app-version", APP_VERSION),
+    ]

quilt_hp_python-0.1.1.dist-info/METADATA

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: quilt-hp-python
+Version: 0.1.1
+Summary: Async Python client for Quilt mini-split HVAC systems
+Project-URL: Repository, https://github.com/eman/quilt-hp-python
+Project-URL: Issues, https://github.com/eman/quilt-hp-python/issues
+Project-URL: Changelog, https://github.com/eman/quilt-hp-python/blob/main/CHANGELOG.md
+Author: Emmanuel
+License: MIT License
+        
+        Copyright (c) 2026
+        
+        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.
+License-File: LICENSE
+Keywords: grpc,home-automation,hvac,mini-split,quilt
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Home Automation
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Requires-Dist: boto3>=1.35
+Requires-Dist: grpcio>=1.70
+Requires-Dist: platformdirs>=4.0
+Requires-Dist: protobuf>=5.0
+Provides-Extra: cli
+Requires-Dist: rich>=13.0; extra == 'cli'
+Requires-Dist: textual>=0.80; extra == 'cli'
+Requires-Dist: typer>=0.12; extra == 'cli'
+Provides-Extra: dev
+Requires-Dist: boto3-stubs[cognito-idp]; extra == 'dev'
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: grpcio-tools>=1.70; extra == 'dev'
+Requires-Dist: mypy-protobuf>=3.6; extra == 'dev'
+Requires-Dist: mypy>=1.15; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.0; extra == 'dev'
+Requires-Dist: pytest-cov>=6.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.11; extra == 'dev'
+Requires-Dist: twine>=6.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocs>=1.6; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.29; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# quilt-hp-python
+
+Async Python client library for [Quilt](https://www.quilt.com/) mini-split HVAC systems.
+
+Communicates with the Quilt cloud API via gRPC to control spaces (rooms), indoor units,
+comfort presets, schedules, and stream real-time updates.
+
+## Installation
+
+```bash
+pip install quilt-hp-python
+```
+
+With the optional CLI:
+
+```bash
+pip install "quilt-hp-python[cli]"
+```
+
+## Quick Start
+
+```python
+import asyncio
+from quilt_hp import QuiltClient
+
+async def main():
+    async with QuiltClient("user@example.com") as client:
+        await client.login(otp_callback=lambda email: input(f"OTP for {email}: "))
+
+        # List spaces
+        for space in await client.list_spaces():
+            print(f"{space.name}: {space.state.ambient_temperature_c}°C")
+
+        # Set a room to COOL at 22°C
+        from quilt_hp.models.enums import HVACMode
+        spaces = await client.list_spaces()
+        await client.set_space(spaces[0].id, mode=HVACMode.COOL, cool_setpoint_c=22.0)
+
+        # Stream real-time updates
+        spaces = await client.list_spaces()
+        topics = [f"hds/space/{s.id}" for s in spaces]
+        async with client.stream(topics) as stream:
+            stream.on_space_update(lambda s: print(f"{s.name}: {s.state.ambient_temperature_c}°C"))
+            await asyncio.sleep(60)
+
+asyncio.run(main())
+```
+
+## CLI
+
+```bash
+# Authenticate (caches tokens for subsequent commands)
+quilt login --email user@example.com
+
+# Full system inventory + telemetry (summary)
+quilt info
+
+# Full system snapshot as JSON for automation
+quilt info --output json
+
+# All device/entity IDs (includes update entities)
+quilt devices
+
+# Current sensor values + setpoints
+quilt values
+
+# Machine-readable values for scripting
+quilt values --output json
+
+# Energy usage
+quilt energy --period week
+
+# Set a room to cooling mode
+quilt set "Living Room" --mode cool --cool 22
+```
+
+## Development
+
+```bash
+git clone https://github.com/eman/quilt-hp-python.git
+cd quilt-hp-python
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev,cli]"
+
+# Run checks
+ruff check src/ tests/
+ruff format --check src/ tests/
+mypy src/quilt_hp/
+pytest
+python -m build
+twine check dist/*
+
+# Recompile protobuf stubs (requires grpcio-tools)
+# Proto sources are vendored in ./proto/cleaned for standalone use.
+# Optional but recommended: install protobuf includes (e.g. `brew install protobuf`)
+./scripts/regen_protos.sh
+
+# Build project docs (MkDocs Material)
+pip install -e ".[docs]"
+python scripts/check_docs_nav.py
+mkdocs build --strict
+```
+
+## License
+
+MIT

quilt_hp_python-0.1.1.dist-info/RECORD

@@ -0,0 +1,53 @@
+quilt_hp/__init__.py,sha256=kNmiou9vOsvN8Sg_6kXTeQmXqG1vr210yeKWt5GiO_s,465
+quilt_hp/_paths.py,sha256=3IX2Fsv4gU48jM6ypsAiHJr_y4yyTAizM0cDLjL8r9o,691
+quilt_hp/auth.py,sha256=vMd2eZMfRcfUf5xLoxsVxumURXUB0y5ABV53fKMQGKY,8642
+quilt_hp/client.py,sha256=J60DjZTDzSdQyi3aKA9FskC42cDWFe2ea7HqnrhwASs,22126
+quilt_hp/const.py,sha256=GdmBwkxIxo0dPEf5ITxDHTmqKGOhOuQ3_EtmNW9_6aY,1423
+quilt_hp/exceptions.py,sha256=atgwk3aEmNyC69A1MOZKiu9hbl661ip-zGPCWRhOvgw,570
+quilt_hp/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+quilt_hp/tokens.py,sha256=njju8FoJI4q574J_yjWTdfTapq5kH_a5mJ0q-zXuKYM,3530
+quilt_hp/transport.py,sha256=uVJ6SYmJyF5yuPuYzK3O-1T06kAKYHybFwiW8S59QkQ,6628
+quilt_hp/_proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quilt_hp/_proto/quilt_device_pairing_pb2.py,sha256=L7Cznr5ZdkWQkeywwu48EVBntoUMXwgCrqIhsULqRa4,5208
+quilt_hp/_proto/quilt_device_pairing_pb2.pyi,sha256=bE6bLf0KSxuxB2ZBR6x9LP81dt0ZIL2PWJEfVfiR7oM,14432
+quilt_hp/_proto/quilt_device_pairing_pb2_grpc.py,sha256=hwZfEd_JyPoSmvGNs8oWNFrKQVTNkqIp6Ow_gu8HEBo,900
+quilt_hp/_proto/quilt_hds_pb2.py,sha256=AbyE_UkPDgEj2xKN8974BPttnuqGBrs5rjcNf9u2Mp0,56965
+quilt_hp/_proto/quilt_hds_pb2.pyi,sha256=9AltfIubzJYFUmhmLCGDLXFZs7AtvREvvRn8oAcSoIU,184746
+quilt_hp/_proto/quilt_hds_pb2_grpc.py,sha256=i1A_YrWb1jGTYHouJuwYnUGz-zTVDd8dhpSaRWrdhbM,73293
+quilt_hp/_proto/quilt_notifier_pb2.py,sha256=PTmm2PidkThgoHqLtTTGfBMGOGdQUz9an8l2p_6QvxY,4006
+quilt_hp/_proto/quilt_notifier_pb2.pyi,sha256=hNuiMk94cEHL0vWwSSBeqsGbYqtGu6cgzvQ5yC9wce8,12133
+quilt_hp/_proto/quilt_notifier_pb2_grpc.py,sha256=vnhGBxxpUnk_-RBa_S5RZCXWybUQh7NwLPfArcQ93Ho,3610
+quilt_hp/_proto/quilt_services_pb2.py,sha256=2NFjxOIaeI_AItpF3yvTZY6ygJcI5O031qng_gsg4hg,20644
+quilt_hp/_proto/quilt_services_pb2.pyi,sha256=Sl-0t0YfreU860BADDJAR5gh26Gk756GDsjsdKIFXj0,55650
+quilt_hp/_proto/quilt_services_pb2_grpc.py,sha256=ur45Zvr21aNnx4PssSoopuXQMTcGrUP_3XAAKiY54Ko,49470
+quilt_hp/_proto/quilt_system_pb2.py,sha256=veOHtkK31bcilruYl_jNOxT8AnQpZSvfuP1N3wlnO5o,3428
+quilt_hp/_proto/quilt_system_pb2.pyi,sha256=bnyzhp-oGUGhTQSrjAffADM4wzs5hY_RSrbQ1pnl5JA,5877
+quilt_hp/_proto/quilt_system_pb2_grpc.py,sha256=NzgPa-lCbWxLF_DcDZ_wWM56wjFYW6OFa6cTQWeP2CE,10588
+quilt_hp/cli/__init__.py,sha256=C63yWifzpA0IV7YWDatpAdrhoV8zjqxAKv0xMf09VdM,19
+quilt_hp/cli/main.py,sha256=OYDGixJ0GxCiLE_LCMKbkXW0BFL3iyQdqqypAfFYGxQ,30807
+quilt_hp/cli/settings.py,sha256=yncVe0wuMrhy2E4NTZGBsxc1AAP1afnwCwa3jQmAZnU,4040
+quilt_hp/cli/store.py,sha256=IcVEo7eXicpgBdr0V1S6yGtHnykDKqjc5WpAGZoV0bc,3923
+quilt_hp/cli/tui.py,sha256=3eAg_4Omr0BT7_oO5V2Lh3YaVY3QI4JxzZ68nbekJ6M,100955
+quilt_hp/models/__init__.py,sha256=R3n809_nmAo5dH8JM75NvGTiCvPgpSKQwnUwqXJBPQQ,2077
+quilt_hp/models/comfort.py,sha256=QgszDMYioPk0v6D-TFZrpH75UCPg6zU7vBr0rNHGMGo,1600
+quilt_hp/models/controller.py,sha256=ryeEKdWispuYAXeqn9IHYvMi7ogCjuhLKTnHuMbolpc,5759
+quilt_hp/models/energy.py,sha256=heC0HTHjbMD-znHBMfrUobo4SJbpuDl0a2AHz77nkvM,702
+quilt_hp/models/enums.py,sha256=SlFbYPj58MTTGscFGJQkuYKMUKZLwLYo3S8w3tj2lZk,6436
+quilt_hp/models/indoor_unit.py,sha256=TkocuwtssPo8kYMPJZGc2T8PJIN044DUmFn0t2c53ts,15190
+quilt_hp/models/outdoor_unit.py,sha256=HH6sxr0wE08zgpPiNxfsdBk7x3zUZgcb-_QwX6p1YTc,2861
+quilt_hp/models/qsm.py,sha256=1P9l0rA2OmHT1SpfVe79yIzBryrePcS9MgUauHKxKLg,3788
+quilt_hp/models/schedule.py,sha256=a-ZG4-7jbAipxShaLeHDfj3vVfoOnG9DR3bHfQytews,2741
+quilt_hp/models/sensor.py,sha256=RPIeTZ_F49a9ZEvQtJAOERiGMNqNjxUTPmKuQEb7AHM,3607
+quilt_hp/models/software_update.py,sha256=F1XpQr7vgNXkrNoQk78-vb2skFicPRd7EkJkKDTa8kU,2561
+quilt_hp/models/space.py,sha256=n5AXZddFQgFjxsMRKt-iMuCbIsFdc4XWiAxImzNV9h4,6498
+quilt_hp/models/system.py,sha256=aDCgFhAQsihT9qTFiC_9hjT-YvtmEQgzOGleIIyMJyQ,20453
+quilt_hp/services/__init__.py,sha256=LcsLtnzXqkhaiCIlNNKnmzlY0TAJ3vUwL0nkV8oI1gQ,63
+quilt_hp/services/hds.py,sha256=xPlYvhvHYKUCBTl48B83an8aJl_3ZT4yg6YJFBsjhYw,19781
+quilt_hp/services/streaming.py,sha256=boga8QGacc-mxEfSePvLDXeeKYPHA_lECot21SG8J-w,22707
+quilt_hp/services/system.py,sha256=WIXEfCcifhXlwd2yr8Uc0Qom98NatNrNm1wwWvYo9WU,3203
+quilt_hp/services/user.py,sha256=KpRD5V7aZqMXZ0CHGmeZfNl9vLA0bZBnCSNX_XCBlxo,4771
+quilt_hp_python-0.1.1.dist-info/METADATA,sha256=d2y3x8Fmu47GjZiFEmcemQaGgRziMFNbiHf6L4E43q0,5547
+quilt_hp_python-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+quilt_hp_python-0.1.1.dist-info/entry_points.txt,sha256=9kOMlIRUGPx1WCxpM-QG4YPXnhee5DBlmWWaunlwrNk,48
+quilt_hp_python-0.1.1.dist-info/licenses/LICENSE,sha256=ESYyLizI0WWtxMeS7rGVcX3ivMezm-HOd5WdeOh-9oU,1056
+quilt_hp_python-0.1.1.dist-info/RECORD,,

quilt_hp_python-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

quilt_hp_python-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+quilt = quilt_hp.cli.main:app