flespi-sdk 0.1.2__tar.gz → 0.1.4__tar.gz

{flespi_sdk-0.1.2 → flespi_sdk-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flespi-sdk
-Version: 0.1.2
+Version: 0.1.4
 Summary: Add your description here
 Author-email: Sergey Shevchik <sergey.shevchik@gmail.com>
 Requires-Python: >=3.11

{flespi_sdk-0.1.2 → flespi_sdk-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flespi-sdk"
-version = "0.1.2"
+version = "0.1.4"
 description = "Add your description here"
 readme = "README.md"
 authors = [{ name = "Sergey Shevchik", email = "sergey.shevchik@gmail.com" }]

{flespi_sdk-0.1.2 → flespi_sdk-0.1.4}/src/flespi_sdk/account.py

@@ -1,5 +1,7 @@
 from aiohttp import ClientSession
 
+from flespi_sdk.exception import FlespiException
+from flespi_sdk.modules.devices import Devices
 from flespi_sdk.modules.metadata import Metadata
 from flespi_sdk.modules.mqtt import MQTT
 from flespi_sdk.modules.realms import Realms
@@ -60,7 +62,10 @@ class Account:
             "/platform/customer", headers=dict(Authorization=f"FlespiToken {token}")
         ) as response:
             if response.status != 200:
-                raise Exception("Failed to get account ID: " + str(response.status))
+                raise FlespiException(
+                    status_code=response.status,
+                    errors=(await response.json())["errors"],
+                )
             response_json = await response.json()
             result = response_json["result"]
             id = result[0]["id"]
@@ -71,7 +76,13 @@ class Account:
             self._init_modules()
 
     def _init_modules(self):
-        self.metadata = Metadata("platform/customer", self.session, self.id)
+        self.metadata = Metadata(
+            item_path="platform/customer",
+            metadata=None,
+            session=self.session,
+            cid=self.id,
+        )
         self.subaccounts = Subaccounts(self.session, self.id)
         self.realms = Realms(self.session, self.id)
         self.mqtt = MQTT(self.session, self.id)
+        self.devices = Devices(self.session, self.id)

flespi_sdk-0.1.4/src/flespi_sdk/exception.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class FlespiError:
+    code: int
+    reason: str
+    id: int | None = None
+    selector: str | None = None
+
+
+class FlespiException(Exception):
+    def __init__(self, status_code: int, errors: list[dict]):
+        self.status_code = status_code
+        self.errors = [FlespiError(**error) for error in errors]

flespi_sdk-0.1.4/src/flespi_sdk/modules/devices/__init__.py

@@ -0,0 +1,41 @@
+from aiohttp import ClientSession
+from flespi_sdk.modules.devices.device import Device
+from flespi_sdk.modules.flespi_session import FlespiSession
+
+
+class Devices(FlespiSession):
+    def __init__(self, session: ClientSession, cid: int | None = None):
+        super().__init__(session=session, cid=cid)
+
+    async def get(self, id: int, fields: list[str] = []):
+        async with self.session.get(
+            f"/gw/devices/{id}",
+            params=dict(fields=super().prepare_fields(fields)),
+            headers=self.get_headers(),
+        ) as response:
+            result = await self.get_result(response)
+            device = result[0]
+            return Device(
+                id=device["id"],
+                metadata=device["metadata"],
+                fields={field: device[field] for field in fields},
+                session=self.session,
+                cid=self.cid,
+            )
+
+    async def list(self, selector: str = "all", fields: list[str] = []):
+        async with self.session.get(
+            f"/gw/devices/{selector}",
+            headers=self.get_headers(),
+            params=dict(fields=super().prepare_fields(fields)),
+        ) as response:
+            return [
+                Device(
+                    id=device["id"],
+                    metadata=device["metadata"],
+                    fields={field: device[field] for field in fields},
+                    session=self.session,
+                    cid=self.cid,
+                )
+                for device in await self.get_result(response)
+            ]

flespi_sdk-0.1.4/src/flespi_sdk/modules/devices/device.py

@@ -0,0 +1,21 @@
+from aiohttp import ClientSession
+from flespi_sdk.modules.item_with_metadata import ItemWithMetadata
+
+
+class Device(ItemWithMetadata):
+    def __init__(
+        self,
+        id: int,
+        metadata: dict,
+        fields: dict,
+        session: ClientSession,
+        cid: int | None,
+    ):
+        super().__init__(
+            id=id,
+            metadata=metadata,
+            fields=fields,
+            item_path=f"gw/devices/{id}",
+            session=session,
+            cid=cid,
+        )

{flespi_sdk-0.1.2 → flespi_sdk-0.1.4}/src/flespi_sdk/modules/flespi_session.py

@@ -1,5 +1,7 @@
 from aiohttp import ClientSession
 
+from flespi_sdk.exception import FlespiException
+
 
 class FlespiSession:
     def __init__(self, session: ClientSession, cid: int | None = None):
@@ -16,7 +18,12 @@ class FlespiSession:
 
     async def get_result(self, response):
         if response.status != 200:
-            raise Exception("Status code: " + str(response.status))
+            raise FlespiException(
+                status_code=response.status, errors=(await response.json())["errors"]
+            )
         response_json = await response.json()
         result = response_json["result"]
         return result
+
+    def prepare_fields(self, fields: list[str] = []):
+        return ",".join(list(set(["id", "metadata"] + fields)))

{flespi_sdk-0.1.2 → flespi_sdk-0.1.4}/src/flespi_sdk/modules/item_with_metadata.py

@@ -6,17 +6,20 @@ from flespi_sdk.modules.metadata import Metadata
 class ItemWithMetadata(FlespiSession):
     def __init__(
         self,
-        parent_id: int | None,
         id: int,
         item_path: str,
         session: ClientSession,
+        metadata: dict | None = None,
+        fields: dict = {},
         cid: int | None = None,
     ):
         super().__init__(session, cid)
-        self.parent_id = parent_id
         self.id = id
         self.item_path = item_path
-        self.metadata = Metadata(item_path, session, cid)
+        self.initial_fields = fields
+        self.metadata = Metadata(
+            item_path=item_path, metadata=metadata, session=session, cid=cid
+        )
 
     async def get_name(self) -> str:
         """
@@ -29,3 +32,19 @@ class ItemWithMetadata(FlespiSession):
         ) as response:
             result = await self.get_result(response)
             return result[0]["name"]
+
+    def get_initial_fields(self):
+        return self.initial_fields
+
+    async def get_fields(self, fields: list[str]) -> dict:
+        """
+        Get fields for the current device.
+        :return: Dictionary with fields.
+        """
+        async with self.session.get(
+            self.item_path,
+            params=dict(fields=fields),
+            headers=self.get_headers(),
+        ) as response:
+            result = await self.get_result(response)
+            return result[0]

{flespi_sdk-0.1.2 → flespi_sdk-0.1.4}/src/flespi_sdk/modules/metadata/__init__.py

@@ -5,28 +5,39 @@ from flespi_sdk.modules.flespi_session import FlespiSession
 
 class Metadata(FlespiSession):
     def __init__(
-        self, item_path, session: aiohttp.ClientSession, cid: int | None = None
+        self,
+        item_path,
+        metadata: dict | None,
+        session: aiohttp.ClientSession,
+        cid: int | None,
     ):
         super().__init__(session, cid)
         self.item_path = item_path
+        self.metadata_cache = metadata
 
-    async def get(self) -> dict:
+    async def get(self, use_cache: bool = True) -> dict:
         """
         Get metadata for the current account.
         :return: Metadata as a dictionary.
         """
+        if self.metadata_cache and use_cache:
+            return self.metadata_cache
+
         params = {"fields": "metadata"}
         async with self.session.get(
             self.item_path, params=params, headers=self.get_headers()
         ) as response:
             result = await self.get_result(response)
-            return result[0]["metadata"]
+            metadata = result[0]["metadata"]
+            self.metadata_cache = metadata
+            return metadata
 
     async def set(self, metadata: dict) -> None:
         """ "
         "Set metadata for the current account.
         :param metadata: Metadata as a dictionary.
         """
+        self.metadata_cache = None
         async with self.session.put(
             self.item_path,
             json={"metadata": metadata},
@@ -34,13 +45,13 @@ class Metadata(FlespiSession):
         ) as response:
             await self.get_result(response)
 
-    async def get_value(self, key_path: str):
+    async def get_value(self, key_path: str, use_cache: bool = True):
         """
         Get a specific value from the metadata.
         :param key_path: The key path to the value in the metadata.
         :return: The value from the metadata.
         """
-        metadata = await self.get()
+        metadata = await self.get(use_cache=use_cache)
         if not metadata:
             return None
         keys = key_path.split(".")
@@ -58,7 +69,7 @@ class Metadata(FlespiSession):
         :param key_path: The key path to the value in the metadata.
         :param value: The value to set.
         """
-        metadata = await self.get() or {}
+        metadata = await self.get(use_cache=False) or {}
         keys = key_path.split(".")
         metadata_level = metadata
         for key in keys[:-1]:
@@ -73,7 +84,7 @@ class Metadata(FlespiSession):
         Delete a specific key from the metadata.
         :param key_path: The key path to the value in the metadata.
         """
-        metadata = await self.get()
+        metadata = await self.get(use_cache=False)
         if not metadata:
             return
         keys = key_path.split(".")

{flespi_sdk-0.1.2 → flespi_sdk-0.1.4}/src/flespi_sdk/modules/realms/__init__.py

@@ -8,25 +8,36 @@ class Realms(FlespiSession):
     def __init__(self, session: aiohttp.ClientSession, cid: int | None = None):
         super().__init__(session, cid)
 
-    async def get(self, id: int):
+    async def get(self, id: int, fields: list[str] = []):
         async with self.session.get(
-            f"/platform/realms/{id}", headers=self.get_headers()
+            f"/platform/realms/{id}",
+            params=dict(fields=super().prepare_fields(fields)),
+            headers=self.get_headers(),
         ) as response:
             result = await self.get_result(response)
             realm = result[0]
             return Realm(
-                realm_id=realm["id"],
+                id=realm["id"],
+                metadata=realm["metadata"],
+                fields={field: realm[field] for field in fields},
                 session=self.session,
                 cid=self.cid,
             )
 
-    async def list(self, selector: str = "all"):
+    async def list(self, selector: str = "all", fields: list[str] = []):
         async with self.session.get(
             f"/platform/realms/{selector}",
+            params=dict(fields=super().prepare_fields(fields)),
             headers=self.get_headers(),
         ) as response:
             result = await self.get_result(response)
             return [
-                Realm(realm_id=realm["id"], session=self.session, cid=self.cid)
+                Realm(
+                    id=realm["id"],
+                    metadata=realm["metadata"],
+                    fields={field: realm[field] for field in fields},
+                    session=self.session,
+                    cid=self.cid,
+                )
                 for realm in result
             ]

flespi_sdk-0.1.4/src/flespi_sdk/modules/realms/realm.py

@@ -0,0 +1,37 @@
+from aiohttp import ClientSession
+
+from flespi_sdk.modules.realms.realm_home import RealmHome
+from flespi_sdk.modules.realms.realm_token_params import RealmTokenParams
+from flespi_sdk.modules.realms.users import Users
+from flespi_sdk.modules.item_with_metadata import ItemWithMetadata
+
+
+class Realm(ItemWithMetadata):
+    """
+    Represents a realm in the Flespi system.
+    """
+
+    def __init__(
+        self,
+        id: int,
+        metadata: dict,
+        fields: dict,
+        session: ClientSession,
+        cid: int | None = None,
+    ):
+        super().__init__(
+            id=id,
+            item_path=f"platform/realms/{id}",
+            metadata=metadata,
+            fields=fields,
+            session=session,
+            cid=cid,
+        )
+        self.users = Users(
+            realm_id=id,
+            client_session=session,
+            cid=cid,
+        )
+
+        self.home = RealmHome(realm_id=id, session=session, cid=cid)
+        self.token_params = RealmTokenParams(realm_id=id, session=session, cid=cid)

flespi_sdk-0.1.4/src/flespi_sdk/modules/realms/realm_home.py

@@ -0,0 +1,50 @@
+from aiohttp import ClientSession
+from flespi_sdk.modules.flespi_session import FlespiSession
+
+
+class RealmHome(FlespiSession):
+    def __init__(
+        self,
+        realm_id: int,
+        session: ClientSession,
+        cid: int | None = None,
+    ):
+        super().__init__(session, cid)
+        self.realm_id = realm_id
+
+    async def get(self):
+        params = {"fields": "home"}
+        async with self.session.get(
+            f"/platform/realms/{self.realm_id}",
+            params=params,
+            headers=self.get_headers(),
+        ) as response:
+            result = await self.get_result(response)
+            return result[0]["home"]
+
+    async def set(self, data: dict):
+        response = await self.session.put(
+            f"/platform/realms/{self.realm_id}",
+            json={"home": data},
+            headers=self.get_headers(),
+        )
+        return await self.get_result(response)
+
+    async def set_current_subaccount(self):
+        data = {"type": 0}
+        await self.set(data)
+
+    async def set_existing_subaccount(self, subaccount_id: int):
+        data = {"type": 1, "subaccount_id": subaccount_id}
+        await self.set(data)
+
+    async def set_create_new_subaccount(
+        self, subaccount_id: int | None = None, limit_id: int | None = None
+    ):
+        data = {"type": 2}
+        if subaccount_id:
+            data["subaccount_id"] = subaccount_id
+        if limit_id:
+            data["limit_id"] = limit_id
+
+        await self.set(data)

flespi_sdk-0.1.4/src/flespi_sdk/modules/realms/realm_token_params.py

@@ -0,0 +1,82 @@
+from aiohttp import ClientSession
+
+from flespi_sdk.modules.flespi_session import FlespiSession
+
+
+class RealmTokenParams(FlespiSession):
+    def __init__(self, realm_id: int, session: ClientSession, cid: int | None = None):
+        super().__init__(session, cid)
+        self.realm_id = realm_id
+
+    async def get(self):
+        params = {"fields": "token_params"}
+        async with self.session.get(
+            f"platform/realms/{self.realm_id}",
+            params=params,
+            headers=self.get_headers(),
+        ) as response:
+            return (await self.get_result(response))[0]["token_params"]
+
+    async def set(self, data: dict):
+        response = await self.session.put(
+            f"platform/realms/{self.realm_id}",
+            json={"token_params": data},
+            headers=self.get_headers(),
+        )
+        return await self.get_result(response)
+
+    async def set_ttl(self, seconds: int):
+        token_params = await self.get()
+        if token_params["ttl"] == seconds:
+            return
+        token_params["ttl"] = seconds
+        await self.set(token_params)
+
+    async def set_ip_addresses(self, ip_addresses: list[str]):
+        token_params = await self.get()
+        ip_addresses_csv = ",".join(ip_addresses)
+        if "ips" in token_params and token_params["ips"] == ip_addresses_csv:
+            return
+        token_params["ips"] = ip_addresses_csv
+        await self.set(token_params)
+
+    async def allow_all_origins(self):
+        token_params = await self.get()
+        if "origins" in token_params and token_params["origins"] == "*":
+            return
+        token_params["origins"] = "*"
+        await self.set(token_params)
+
+    async def set_origins(self, origins: list[str], allow_flespi_origins: bool = False):
+        token_params = await self.get()
+        token_params["origins"] = origins.copy()
+        if allow_flespi_origins:
+            token_params["origins"].append({"preset": "flespi"})
+        await self.set(token_params)
+
+    async def set_standard_access(self):
+        token_params = await self.get()
+        if token_params["access"]["type"] == 0:
+            return
+        token_params["access"] = {"type": 0}
+        await self.set(token_params)
+
+    async def set_master_access(self):
+        token_params = await self.get()
+        if token_params["access"]["type"] == 1:
+            return
+        token_params["access"] = {"type": 1}
+        await self.set(token_params)
+
+    async def set_acl_access(
+        self, acl: list[dict] = [], templating: bool | None = None
+    ):
+        token_params = await self.get()
+        access = {
+            "type": 2,
+            "acl": acl,
+        }
+        if templating is not None:
+            access["templating"] = templating
+        token_params["access"] = access
+        await self.set(token_params)

{flespi_sdk-0.1.2 → flespi_sdk-0.1.4}/src/flespi_sdk/modules/realms/users/__init__.py

@@ -23,20 +23,29 @@ class Users(FlespiSession):
         super().__init__(client_session, cid)
         self.realm_id = realm_id
 
-    async def get(self, user_id: int) -> User:
+    async def get(self, id: int, fields: list[str] = []) -> User:
         """
         Get a user by ID.
         :param user_id: The ID of the user to retrieve.
         :return: A User object.
         """
         async with self.session.get(
-            f"/platform/realms/{self.realm_id}/users/{user_id}",
+            f"/platform/realms/{self.realm_id}/users/{id}",
+            params=dict(fields=super().prepare_fields(fields)),
             headers=self.get_headers(),
         ) as response:
             result = await self.get_result(response)
-            return User(self.realm_id, result[0]["id"], self.session, self.cid)
+            user = result[0]
+            return User(
+                id=user["id"],
+                realm_id=self.realm_id,
+                metadata=user["metadata"],
+                fields={field: user[field] for field in fields},
+                session=self.session,
+                cid=self.cid,
+            )
 
-    async def list(self, selector: str = "all") -> list[User]:
+    async def list(self, selector: str = "all", fields: list[str] = []) -> list[User]:
         """
         List all users in the realm.
         :param selector: The selector to filter users.
@@ -44,10 +53,18 @@ class Users(FlespiSession):
         """
         async with self.session.get(
             f"/platform/realms/{self.realm_id}/users/{selector}",
+            params=dict(fields=super().prepare_fields(fields)),
             headers=self.get_headers(),
         ) as response:
             result = await self.get_result(response)
             return [
-                User(self.realm_id, user["id"], self.session, self.cid)
+                User(
+                    id=user["id"],
+                    realm_id=self.realm_id,
+                    metadata=user["metadata"],
+                    fields={field: user[field] for field in fields},
+                    session=self.session,
+                    cid=self.cid,
+                )
                 for user in result
             ]

{flespi_sdk-0.1.2 → flespi_sdk-0.1.4}/src/flespi_sdk/modules/realms/users/user.py

@@ -5,8 +5,10 @@ from flespi_sdk.modules.item_with_metadata import ItemWithMetadata
 class User(ItemWithMetadata):
     def __init__(
         self,
+        id: int,
         realm_id: int,
-        user_id: int,
+        metadata: dict,
+        fields: dict,
         session: ClientSession,
         cid: int | None = None,
     ):
@@ -15,11 +17,12 @@ class User(ItemWithMetadata):
 
         :param client: The client instance used to make API requests.
         """
-        item_path = f"platform/realms/{realm_id}/users/{user_id}"
+        self.realm_id = realm_id
         super().__init__(
-            parent_id=realm_id,
-            id=user_id,
-            item_path=item_path,
+            id=id,
+            item_path=f"platform/realms/{realm_id}/users/{id}",
+            metadata=metadata,
+            fields=fields,
             session=session,
             cid=cid,
         )
@@ -37,7 +40,7 @@ class User(ItemWithMetadata):
             raise ValueError("Password must be at least 16 characters long")
 
         async with self.session.put(
-            f"/platform/realms/{self.parent_id}/users/{self.id}",
+            self.item_path,
             json={"password": password},
             headers=self.get_headers(),
         ) as response: