fluss-api 0.1.1__tar.gz

fluss_api-0.1.1/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: fluss_api
+Version: 0.1.1
+Summary: A library to integrate the Fluss API into Home Assistant
+Home-page: UNKNOWN
+Author: Njeru Ndegwa
+Author-email: njeru@fluss.io
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+
+UNKNOWN
+

fluss_api-0.1.1/fluss_api/__init__.py

@@ -0,0 +1,2 @@
+#__init__.py
+from .main import FlussApiClient, FlussApiClientAuthenticationError, FlussApiClientCommunicationError,FlussApiClientError, FlussDeviceError

fluss_api-0.1.1/fluss_api/main.py

@@ -0,0 +1,102 @@
+#main.py
+"""Fluss+ API Client."""
+
+from __future__ import annotations
+
+import asyncio
+import datetime
+import logging
+import socket
+import typing
+
+from aiohttp import ClientSession
+from homeassistant.helpers import aiohttp_client # type: ignore
+
+LOGGER = logging.getLogger(__package__)
+
+
+
+class FlussApiClientError(Exception):
+    """Exception to indicate a general API error."""
+
+
+class FlussDeviceError(Exception):
+    """Exception to indicate that an error occurred when retrieving devices."""
+
+
+class FlussApiClientCommunicationError(FlussApiClientError):
+    """Exception to indicate a communication error."""
+
+
+class FlussApiClientAuthenticationError(FlussApiClientError):
+    """Exception to indicate an authentication error."""
+
+
+class FlussApiClient:
+    """Fluss+ API Client."""
+
+    def __init__(self, api_key: str, hass: HomeAssistant = None) -> None:
+        """Initialize the Fluss+ API Client."""
+        self._api_key = api_key
+        self._session: ClientSession = aiohttp_client.async_get_clientsession(hass) if hass else ClientSession()
+
+    async def async_get_devices(self) -> typing.Any:
+        """Get data from the API."""
+        try:
+            return await self._api_wrapper(
+                method="GET",
+                url="https://zgekzokxrl.execute-api.eu-west-1.amazonaws.com/v1/api/device/list",
+                headers={"Authorization": self._api_key},
+            )
+        except FlussApiClientError as error:
+            LOGGER.error("Failed to get devices: %s", error)
+            raise FlussDeviceError("Failed to retrieve devices") from error
+
+    async def async_trigger_device(self, deviceId: str) -> typing.Any:
+        """Trigger the device."""
+        timestamp = int(datetime.datetime.now().timestamp() * 1000)
+        return await self._api_wrapper(
+            method="POST",
+            url=f"https://zgekzokxrl.execute-api.eu-west-1.amazonaws.com/v1/api/device/{deviceId}/trigger",
+            headers={"Authorization": self._api_key},
+            data={"timeStamp": timestamp, "metaData": {}},
+        )
+
+    async def _api_wrapper(
+        self,
+        method: str,
+        url: str,
+        data: dict | None = None,
+        headers: dict | None = None,
+    ) -> typing.Any:
+        """Get information from the API."""
+        try:
+            async with asyncio.timeout(10):
+                response = await self._session.request(
+                    method=method,
+                    url=url,
+                    headers=headers,
+                    json=data,
+                )
+                if response.status in (401, 403):
+                    raise FlussApiClientAuthenticationError("Invalid credentials")
+                response.raise_for_status()
+                return await response.json()
+
+        except asyncio.TimeoutError as e:
+            LOGGER.error("Timeout error fetching information from %s", url)
+            raise FlussApiClientCommunicationError("Timeout error fetching information") from e
+        except (aiohttp.ClientError, socket.gaierror) as ex:
+            LOGGER.error("Error fetching information from %s: %s", url, ex)
+            raise FlussApiClientCommunicationError("Error fetching information") from ex
+        except FlussApiClientAuthenticationError as auth_ex:
+            LOGGER.error("Authentication error: %s", auth_ex)
+            raise
+        except Exception as exception:  # pylint: disable=broad-except
+            LOGGER.error("Unexpected error occurred: %s", exception)
+            raise FlussApiClientError("Something really wrong happened!") from exception
+
+    async def close(self) -> None:
+        """Close the aiohttp session."""
+        if self._session:
+            await self._session.close()

fluss_api-0.1.1/fluss_api.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: fluss-api
+Version: 0.1.1
+Summary: A library to integrate the Fluss API into Home Assistant
+Home-page: UNKNOWN
+Author: Njeru Ndegwa
+Author-email: njeru@fluss.io
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+
+UNKNOWN
+

fluss_api-0.1.1/fluss_api.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+setup.py
+fluss_api/__init__.py
+fluss_api/main.py
+fluss_api.egg-info/PKG-INFO
+fluss_api.egg-info/SOURCES.txt
+fluss_api.egg-info/dependency_links.txt
+fluss_api.egg-info/top_level.txt
+tests/__init__.py
+tests/test_main.py

fluss_api-0.1.1/fluss_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fluss_api-0.1.1/fluss_api.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+fluss_api
+tests

fluss_api-0.1.1/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fluss_api"
+version = "0.1.1"
+description = "Fluss+ API Client"
+readme = "README.md"
+requires-python = ">=3.7"
+dependencies = ["aiohttp"]
+
+[tool.setuptools.packages.find]
+where = ["fluss_api"]
+
+[project.urls]
+"Homepage" = "https://github.com/yourusername/flussapi"

fluss_api-0.1.1/setup.cfg

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

fluss_api-0.1.1/setup.py

@@ -0,0 +1,20 @@
+import setuptools
+from setuptools import setup, find_packages
+
+setup(
+    name="fluss_api",
+    version="0.1.1",
+    packages= find_packages(),
+    install_requires =[
+
+    ],
+    author="Njeru Ndegwa",
+    author_email="njeru@fluss.io",
+    description='A library to integrate the Fluss API into Home Assistant',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',  # License type
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.10',
+)

fluss_api-0.1.1/tests/test_main.py

@@ -0,0 +1,164 @@
+import asyncio  # noqa: D100
+from datetime import datetime
+import socket
+from unittest.mock import AsyncMock, Mock, patch
+
+import aiohttp
+import pytest
+
+from fluss_api.main import (
+    FlussApiClient,
+    FlussApiClientAuthenticationError,
+    FlussApiClientCommunicationError,
+    FlussApiClientError,
+    FlussDeviceError,
+)
+from aiohttp import ClientSession
+
+@pytest.fixture
+async def mock_hass():  # noqa: D103
+    hass = Mock(spec=ClientSession)
+    hass.data = {}  # Add missing attribute
+    hass.bus = Mock()
+    hass.async_update_entry = AsyncMock()  # Add missing method
+    return hass
+
+
+@pytest.fixture
+async def api_client(mock_hass) -> FlussApiClient:  # type: ignore # noqa: D103, PGH003
+    client = FlussApiClient("test_api_key", mock_hass)
+    yield client
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_async_get_devices(api_client) -> None:  # noqa: D103
+    """Test the async_get_devices method."""
+    with patch.object(
+        api_client, "_api_wrapper", new=AsyncMock(return_value={"devices": []})
+    ) as mock_api_wrapper:
+        devices = await api_client.async_get_devices()
+        assert devices == {"devices": []}
+        mock_api_wrapper.assert_called_once_with(
+            method="get",
+            url="https://zgekzokxrl.execute-api.eu-west-1.amazonaws.com/v1/api/device/list",
+            headers={"Authorization": "test_api_key"},
+        )
+
+
+@pytest.mark.asyncio
+async def test_async_get_devices_error(api_client) -> None:
+    """Test error handling in async_get_devices method."""
+    with (
+        patch.object(
+            api_client,
+            "_api_wrapper",
+            new=AsyncMock(side_effect=FlussApiClientError("Error")),
+        ) as mock_api_wrapper,
+        patch("homeassistant.components.fluss.api.LOGGER.error") as mock_logger,
+    ):
+        with pytest.raises(FlussDeviceError):
+            await api_client.async_get_devices()
+        mock_api_wrapper.assert_called_once()
+        # Comparing string representations to avoid object identity issues
+        mock_logger.assert_called_once()
+        logged_args = mock_logger.call_args[0]
+        assert logged_args[0] == "Failed to get devices: %s"
+        assert str(logged_args[1]) == "Error"
+
+
+@pytest.mark.asyncio
+async def test_async_trigger_device(api_client) -> None:  # noqa: D103
+    """Test the async_trigger_device method."""
+    with patch.object(
+        api_client, "_api_wrapper", new=AsyncMock(return_value={})
+    ) as mock_api_wrapper:
+        response = await api_client.async_trigger_device("device_id")
+        assert response == {}
+        mock_api_wrapper.assert_called_once_with(
+            method="post",
+            url="https://zgekzokxrl.execute-api.eu-west-1.amazonaws.com/v1/api/device/device_id/trigger",
+            headers={"Authorization": "test_api_key"},
+            data={
+                "timeStamp": int(datetime.now().timestamp() * 1000),
+                "metaData": {},
+            },
+        )
+
+
+@pytest.mark.asyncio
+async def test_api_wrapper_authentication_error(api_client) -> None:  # noqa: D103
+    """Test authentication error handling in _api_wrapper."""
+    mock_response = AsyncMock()
+    mock_response.status = 401
+    with (
+        patch.object(
+            api_client._session, "request", new=AsyncMock(return_value=mock_response)
+        ),
+        pytest.raises(FlussApiClientAuthenticationError),
+    ):
+        await api_client._api_wrapper("get", "test_url")
+
+
+@pytest.mark.asyncio
+async def test_api_wrapper_communication_error(api_client) -> None:  # noqa: D103
+    """Test communication error handling in _api_wrapper."""
+    with (
+        patch.object(
+            api_client._session,
+            "request",
+            new=AsyncMock(side_effect=aiohttp.ClientError),
+        ),
+        pytest.raises(FlussApiClientCommunicationError),
+    ):
+        await api_client._api_wrapper("get", "test_url")
+
+
+@pytest.mark.asyncio
+async def test_api_wrapper_timeout_error(api_client) -> None:  # noqa: D103
+    """Test timeout error handling in _api_wrapper."""
+    with (
+        patch.object(
+            api_client._session,
+            "request",
+            new=AsyncMock(side_effect=asyncio.TimeoutError),
+        ),
+        pytest.raises(FlussApiClientCommunicationError),
+    ):
+        await api_client._api_wrapper("get", "test_url")
+
+
+@pytest.mark.asyncio
+async def test_api_wrapper_socket_error(api_client) -> None:  # noqa: D103
+    """Test socket error handling in _api_wrapper."""
+    with (
+        patch.object(
+            api_client._session, "request", new=AsyncMock(side_effect=socket.gaierror)
+        ),
+        pytest.raises(FlussApiClientCommunicationError),
+    ):
+        await api_client._api_wrapper("get", "test_url")
+
+
+@pytest.mark.asyncio
+async def test_api_wrapper_general_error(api_client) -> None:  # noqa: D103
+    """Test general error handling in _api_wrapper."""
+    with (
+        patch.object(
+            api_client._session, "request", new=AsyncMock(side_effect=Exception)
+        ),
+        pytest.raises(FlussApiClientError),
+    ):
+        await api_client._api_wrapper("get", "test_url")
+
+
+@pytest.mark.asyncio
+async def test_api_wrapper_success(api_client) -> None:
+    mock_response = AsyncMock()
+    mock_response.status = 200
+    mock_response.json.return_value = {"key": "value"}
+    with patch.object(
+        api_client._session, "request", new=AsyncMock(return_value=mock_response)
+    ):
+        result = await api_client._api_wrapper("get", "test_url")
+        assert result == {"key": "value"}