busylib 0.0.2__py3-none-any.whl → 0.1.0__py3-none-any.whl

busylib/__init__.py

@@ -1,82 +1 @@
-"""
-Main library for interacting with the Busy Bar API.
-"""
-
-from typing import IO
-
-from busylib.client import ApiClient
-from busylib.types import ApiResponse
-
-
-class BusyBar:
-    """
-    Main library class for interacting with the Busy Bar API.
-    """
-
-    def __init__(self, addr: str = "10.0.4.20"):
-        """
-        Creates an instance of BUSY Bar.
-        Initializes the API client with the provided address.
-
-        :param addr: The address of the device.
-        """
-        self._addr = addr
-        self._client = ApiClient(f"http://{self._addr}/api/")
-
-    def upload_asset(
-        self, app_id: str, file_name: str, file: bytes | IO[bytes]
-    ) -> ApiResponse | None:
-        """
-        Uploads an asset to the device.
-
-        :param app_id: Application ID for organizing assets.
-        :param file_name: Filename for the uploaded asset.
-        :param file: File data to upload (bytes or file-like object).
-        :return: Result of the upload operation.
-        """
-        return self._client.upload_asset(app_id, file_name, file)
-
-    def delete_assets(self, app_id: str) -> ApiResponse | None:
-        """
-        Deletes all assets for a specific application from the device.
-
-        :param app_id: Application ID whose assets should be deleted.
-        :return: Result of the delete operation.
-        """
-        return self._client.delete_assets(app_id)
-
-    def draw_display(self, app_id: str, elements: list[dict]) -> ApiResponse | None:
-        """
-        Draws elements on the device display.
-
-        :param app_id: Application ID for organizing display elements.
-        :param elements: Array of display elements (text or image).
-        :return: Result of the draw operation.
-        """
-        return self._client.draw_display(app_id, elements)
-
-    def clear_display(self) -> ApiResponse | None:
-        """
-        Clears the device display.
-
-        :return: Result of the clear operation.
-        """
-        return self._client.clear_display()
-
-    def play_sound(self, app_id: str, path: str) -> ApiResponse | None:
-        """
-        Plays an audio file from the assets directory.
-
-        :param app_id: Application ID for organizing assets.
-        :param path: Path to the audio file within the app's assets directory.
-        :return: Result of the play operation.
-        """
-        return self._client.play_audio(app_id, path)
-
-    def stop_sound(self) -> ApiResponse | None:
-        """
-        Stops any currently playing audio on the device.
-
-        :return: Result of the stop operation.
-        """
-        return self._client.stop_audio()
+from .client import BusyBar

busylib/client.py

@@ -1,108 +1,359 @@
+import dataclasses
+import enum
+import json
+import typing as tp
+import urllib.parse
+
 import requests
-from typing import IO
-from busylib.types import ApiResponse
-
-
-class ApiClient:
-    def __init__(self, base_url: str):
-        if not base_url.endswith("/"):
-            base_url += "/"
-        self.base_url = base_url
-        self.session = requests.Session()
-
-    def _request(
-        self,
-        method: str,
-        endpoint: str,
-        params: dict[str, object] | None = None,
-        json: object | None = None,
-        data: object | None = None,
-        headers: dict[str, str] | None = None,
-    ) -> ApiResponse:
-        url = f"{self.base_url}{endpoint}"
+
+from busylib import exceptions, types
+
+JsonType = dict[str, tp.Any] | list[tp.Any] | str | int | float | bool | None
+
+
+def _serialize_for_json(obj):
+    if isinstance(obj, enum.Enum):
+        return obj.value
+    elif isinstance(obj, dict):
+        return {k: _serialize_for_json(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [_serialize_for_json(item) for item in obj]
+    elif dataclasses.is_dataclass(obj):
+        return _serialize_for_json(dataclasses.asdict(obj))
+    else:
+        return obj
+
+
+class BusyBar:
+    """
+    Main library class for interacting with the Busy Bar API.
+    """
+
+    def __init__(self, addr: str):
+        self.base_url = f"http://{addr}"
+        self.client = requests.Session()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self):
+        self.client.close()
+
+    def _handle_response(
+        self, response: requests.Response, as_bytes: bool = False
+    ) -> bytes | str | JsonType:
+        if response.status_code >= 400:
+            try:
+                error_data = response.json()
+                raise exceptions.BusyBarAPIError(
+                    error=error_data.get("error", "Unknown error"),
+                    code=error_data.get("code", response.status_code),
+                )
+            except json.JSONDecodeError:
+                raise exceptions.BusyBarAPIError(
+                    error=f"HTTP {response.status_code}: {response.text}",
+                    code=response.status_code,
+                )
+
+        if as_bytes:
+            return response.content
+
         try:
-            response = self.session.request(
-                method, url, params=params, json=json, data=data, headers=headers
-            )
-            response.raise_for_status()
-            if response.status_code == 204 or not response.content:
-                return None
-            # We expect a JSON response that can be mapped to our dataclass
-            data = response.json()
-            return ApiResponse(
-                success=data.get("success", True), message=data.get("message")
-            )
-        except requests.exceptions.RequestException as e:
-            # Re-raise as a custom exception for better error handling upstream
-            raise ConnectionError(f"API request failed: {e}") from e
-
-    def post(
-        self,
-        endpoint: str,
-        params: dict[str, object] = None,
-        json: object | None = None,
-        data: object | None = None,
-        headers: dict[str, str] | None = None,
-    ) -> ApiResponse | None:
-        return self._request(
-            "POST", endpoint, params=params, json=json, data=data, headers=headers
-        )
-
-    def get(
-        self, endpoint: str, params: dict[str, object] | None = None
-    ) -> ApiResponse | None:
-        return self._request("GET", endpoint, params=params)
-
-    def delete(
-        self, endpoint: str, params: dict[str, object] | None = None
-    ) -> ApiResponse | None:
-        return self._request("DELETE", endpoint, params=params)
+            return response.json()
+        except json.JSONDecodeError:
+            return response.text
+
+    def get_version(self) -> types.VersionInfo:
+        response = self.client.get(
+            urllib.parse.urljoin(self.base_url, "/api/v0/version")
+        )
+        data = self._handle_response(response)
+        return types.VersionInfo(**data)
+
+    def update_firmware(
+        self, firmware_data: bytes, name: str | None = None
+    ) -> types.SuccessResponse:
+        params = {}
+        if name:
+            params["name"] = name
+
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/update"),
+            params=params,
+            data=firmware_data,
+            headers={"Content-Type": "application/octet-stream"},
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def get_status(self) -> types.Status:
+        response = self.client.get(
+            urllib.parse.urljoin(self.base_url, "/api/v0/status")
+        )
+        data = self._handle_response(response)
+
+        system = None
+        if data.get("system"):
+            system = types.StatusSystem(**data["system"])
+
+        power = None
+        if data.get("power"):
+            power_data = data["power"]
+
+            if power_data.get("state"):
+                power_data["state"] = types.PowerState(power_data["state"])
+
+            power = types.StatusPower(**power_data)
+
+        return types.Status(system=system, power=power)
+
+    def get_system_status(self) -> types.StatusSystem:
+        response = self.client.get(
+            urllib.parse.urljoin(self.base_url, "/api/v0/status/system")
+        )
+        data = self._handle_response(response)
+        return types.StatusSystem(**data)
+
+    def get_power_status(self) -> types.StatusPower:
+        response = self.client.get(
+            urllib.parse.urljoin(self.base_url, "/api/v0/status/power")
+        )
+        data = self._handle_response(response)
+
+        if data.get("state"):
+            data["state"] = types.PowerState(data["state"])
+
+        return types.StatusPower(**data)
+
+    def write_storage_file(self, path: str, data: bytes) -> types.SuccessResponse:
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/storage/write"),
+            params={"path": path},
+            data=data,
+            headers={"Content-Type": "application/octet-stream"},
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def read_storage_file(self, path: str) -> bytes:
+        response = self.client.get(
+            urllib.parse.urljoin(self.base_url, "/api/v0/storage/read"),
+            params={"path": path},
+        )
+        return self._handle_response(response, as_bytes=True)
+
+    def list_storage_files(self, path: str) -> types.StorageList:
+        response = self.client.get(
+            urllib.parse.urljoin(self.base_url, "/api/v0/storage/list"),
+            params={"path": path},
+        )
+        data = self._handle_response(response)
+
+        elements = []
+        for item in data.get("list", []):
+            if item["type"] == "file":
+                elements.append(types.StorageFileElement(**item))
+            elif item["type"] == "dir":
+                elements.append(types.StorageDirElement(**item))
+
+        return types.StorageList(list=elements)
+
+    def remove_storage_file(self, path: str) -> types.SuccessResponse:
+        response = self.client.delete(
+            urllib.parse.urljoin(self.base_url, "/api/v0/storage/remove"),
+            params={"path": path},
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def create_storage_directory(self, path: str) -> types.SuccessResponse:
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/storage/mkdir"),
+            params={"path": path},
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
 
     def upload_asset(
-        self, app_id: str, file_name: str, file: bytes | IO[bytes]
-    ) -> ApiResponse | None:
-        """
-        Uploads an asset to the device.
-        """
-        payload = {"app_id": app_id, "file": file_name}
-        headers = {"Content-Type": "application/octet-stream"}
-        return self.post("v0/assets/upload", params=payload, data=file, headers=headers)
-
-    def delete_assets(self, app_id: str) -> ApiResponse | None:
-        """
-        Deletes all assets for a specific application from the device.
-        """
-        params = {"app_id": app_id}
-        return self.delete("v0/assets/upload", params=params)
-
-    def play_audio(self, app_id: str, path: str) -> ApiResponse | None:
-        """
-        Plays an audio file from the assets directory.
-        """
-        params = {"app_id": app_id, "path": path}
-        return self.post("v0/audio/play", params=params)
-
-    def stop_audio(self) -> ApiResponse | None:
-        """
-        Stops any currently playing audio on the device.
-        """
-        return self.delete("v0/audio/play")
-
-    def draw_display(
-        self, app_id: str, elements: list[dict[str, object]]
-    ) -> ApiResponse | None:
-        """
-        Draws elements on the device display.
-        """
-        default_values = {"timeout": 5, "x": 0, "y": 0, "display": "front"}
-
-        normalized_elements = [default_values | e for e in elements]
-        return self.post(
-            "v0/display/draw", json={"app_id": app_id, "elements": normalized_elements}
-        )
-
-    def clear_display(self) -> ApiResponse | None:
-        """
-        Clears the device display.
-        """
-        return self.delete("v0/display/draw")
+        self, app_id: str, filename: str, data: bytes
+    ) -> types.SuccessResponse:
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/assets/upload"),
+            params={"app_id": app_id, "file": filename},
+            data=data,
+            headers={"Content-Type": "application/octet-stream"},
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def delete_app_assets(self, app_id: str) -> types.SuccessResponse:
+        response = self.client.delete(
+            urllib.parse.urljoin(self.base_url, "/api/v0/assets/upload"),
+            params={"app_id": app_id},
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def draw_on_display(
+        self, display_data: types.DisplayElements
+    ) -> types.SuccessResponse:
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/display/draw"),
+            json=_serialize_for_json(display_data),
+            headers={"Content-Type": "application/json"},
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def clear_display(self) -> types.SuccessResponse:
+        response = self.client.delete(
+            urllib.parse.urljoin(self.base_url, "/api/v0/display/draw")
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def get_display_brightness(self) -> types.DisplayBrightnessInfo:
+        response = self.client.get(
+            urllib.parse.urljoin(self.base_url, "/api/v0/display/brightness")
+        )
+        data = self._handle_response(response)
+        return types.DisplayBrightnessInfo(**data)
+
+    def set_display_brightness(
+        self, front: str | None = None, back: str | None = None
+    ) -> types.SuccessResponse:
+        params = {}
+        if front is not None:
+            params["front"] = front
+        if back is not None:
+            params["back"] = back
+
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/display/brightness"),
+            params=params,
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def play_audio(self, app_id: str, path: str) -> types.SuccessResponse:
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/audio/play"),
+            params={"app_id": app_id, "path": path},
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def stop_audio(self) -> types.SuccessResponse:
+        response = self.client.delete(
+            urllib.parse.urljoin(self.base_url, "/api/v0/audio/play")
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def get_audio_volume(self) -> types.AudioVolumeInfo:
+        response = self.client.get(
+            urllib.parse.urljoin(self.base_url, "/api/v0/audio/volume")
+        )
+        data = self._handle_response(response)
+        return types.AudioVolumeInfo(**data)
+
+    def set_audio_volume(self, volume: float) -> types.SuccessResponse:
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/audio/volume"),
+            params={"volume": volume},
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def send_input_key(self, key: types.InputKey) -> types.SuccessResponse:
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/input"),
+            params={"key": key.value},
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def enable_wifi(self) -> types.SuccessResponse:
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/wifi/enable")
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def disable_wifi(self) -> types.SuccessResponse:
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/wifi/disable")
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def get_wifi_status(self) -> types.StatusResponse:
+        response = self.client.get(
+            urllib.parse.urljoin(self.base_url, "/api/v0/wifi/status")
+        )
+        data = self._handle_response(response)
+
+        if data.get("state"):
+            data["state"] = types.WifiState(data["state"])
+
+        if data.get("security"):
+            data["security"] = types.WifiSecurityMethod(data["security"])
+
+        if data.get("ip_config"):
+            ip_config_data = data["ip_config"]
+            if ip_config_data.get("ip_method"):
+                ip_config_data["ip_method"] = types.WifiIpMethod(
+                    ip_config_data["ip_method"]
+                )
+            if ip_config_data.get("ip_type"):
+                ip_config_data["ip_type"] = types.WifiIpType(ip_config_data["ip_type"])
+            data["ip_config"] = types.WifiIpConfig(**ip_config_data)
+
+        return types.StatusResponse(**data)
+
+    def connect_wifi(self, config: types.ConnectRequestConfig) -> types.SuccessResponse:
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/wifi/connect"),
+            json=_serialize_for_json(config),
+            headers={"Content-Type": "application/json"},
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def disconnect_wifi(self) -> types.SuccessResponse:
+        response = self.client.post(
+            urllib.parse.urljoin(self.base_url, "/api/v0/wifi/disconnect")
+        )
+        data = self._handle_response(response)
+        return types.SuccessResponse(**data)
+
+    def scan_wifi_networks(self) -> types.NetworkResponse:
+        response = self.client.get(
+            urllib.parse.urljoin(self.base_url, "/api/v0/wifi/networks")
+        )
+        data = self._handle_response(response)
+
+        networks = []
+        if data.get("networks"):
+            for network_data in data["networks"]:
+                if network_data.get("security"):
+                    network_data["security"] = types.WifiSecurityMethod(
+                        network_data["security"]
+                    )
+
+                networks.append(types.Network(**network_data))
+
+        return types.NetworkResponse(
+            count=data.get("count"),
+            networks=networks or None,
+        )
+
+    def get_screen_frame(self, display: int) -> bytes:
+        response = self.client.get(
+            urllib.parse.urljoin(self.base_url, "/api/v0/screen"),
+            params={"display": display},
+        )
+        return self._handle_response(response, as_bytes=True)

busylib/exceptions.py

@@ -0,0 +1,5 @@
+class BusyBarAPIError(Exception):
+    def __init__(self, error: str, code: int | None = None):
+        self.error = error
+        self.code = code
+        super().__init__(f"API Error: {error} (code: {code})")

busylib/types.py

@@ -1,9 +1,213 @@
 import dataclasses
+import enum
+import typing as tp
+
+
+class WifiSecurityMethod(enum.Enum):
+    OPEN = "Open"
+    WPA = "WPA"
+    WPA2 = "WPA2"
+    WEP = "WEP"
+    WPA_ENTERPRISE = "WPA (Enterprise)"
+    WPA2_ENTERPRISE = "WPA2 (Enterprise)"
+    WPA_WPA2 = "WPA/WPA2"
+    WPA3 = "WPA3"
+    WPA2_WPA3 = "WPA2/WPA3"
+    WPA3_ENTERPRISE = "WPA3 (Enterprise)"
+    WPA2_WPA3_ENTERPRISE = "WPA2/WPA3 (Enterprise)"
+
+
+class WifiIpMethod(enum.Enum):
+    DHCP = "dhcp"
+    STATIC = "static"
+
+
+class WifiIpType(enum.Enum):
+    IPV4 = "ipv4"
+    IPV6 = "ipv6"
+
+
+class PowerState(enum.Enum):
+    DISCHARGING = "discharging"
+    CHARGING = "charging"
+    CHARGED = "charged"
+
+
+class WifiState(enum.Enum):
+    DISABLED = "disabled"
+    ENABLED = "enabled"
+    CONNECTED = "connected"
+
+
+class ElementType(enum.Enum):
+    FILE = "file"
+    DIR = "dir"
+
+
+class DisplayElementType(enum.Enum):
+    TEXT = "text"
+    IMAGE = "image"
+
+
+class DisplayName(enum.Enum):
+    FRONT = "front"
+    BACK = "back"
+
+
+class InputKey(enum.Enum):
+    UP = "up"
+    DOWN = "down"
+    OK = "ok"
+    BACK = "back"
+    START = "start"
+    BUSY = "busy"
+    STATUS = "status"
+    OFF = "off"
+    APPS = "apps"
+    SETTINGS = "settings"
+
+
+@dataclasses.dataclass(frozen=True)
+class SuccessResponse:
+    result: str
+
+
+@dataclasses.dataclass(frozen=True)
+class Error:
+    error: str
+    code: int | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class VersionInfo:
+    branch: str
+    version: str
+    build_date: str
+    commit_hash: str
+
+
+@dataclasses.dataclass(frozen=True)
+class StatusSystem:
+    version: str | None = None
+    uptime: str | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class StatusPower:
+    state: PowerState | None = None
+    battery_charge: int | None = None
+    battery_voltage: int | None = None
+    battery_current: int | None = None
+    usb_voltage: int | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class Status:
+    system: StatusSystem | None = None
+    power: StatusPower | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class StorageFileElement:
+    type: tp.Literal["file"]
+    name: str
+    size: int
 
 
 @dataclasses.dataclass(frozen=True)
-class ApiResponse:
-    """A generic response from the BusyBar API"""
+class StorageDirElement:
+    type: tp.Literal["dir"]
+    name: str
 
-    success: bool
-    message: str | None = None
+
+StorageListElement = StorageFileElement | StorageDirElement
+
+
+@dataclasses.dataclass(frozen=True)
+class StorageList:
+    list: list[StorageListElement]
+
+
+@dataclasses.dataclass(frozen=True)
+class TextElement:
+    id: str
+    type: tp.Literal["text"]
+    x: int
+    y: int
+    text: str
+    timeout: int | None = None
+    display: DisplayName | None = DisplayName.FRONT
+
+
+@dataclasses.dataclass(frozen=True)
+class ImageElement:
+    id: str
+    type: tp.Literal["image"]
+    x: int
+    y: int
+    path: str
+    timeout: int | None = None
+    display: DisplayName | None = DisplayName.FRONT
+
+
+DisplayElement = TextElement | ImageElement
+
+
+@dataclasses.dataclass(frozen=True)
+class DisplayElements:
+    app_id: str
+    elements: list[DisplayElement]
+
+
+@dataclasses.dataclass(frozen=True)
+class DisplayBrightnessInfo:
+    front: str | None = None
+    back: str | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class AudioVolumeInfo:
+    volume: float | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class WifiIpConfig:
+    ip_method: WifiIpMethod | None = None
+    ip_type: WifiIpType | None = None
+    address: str | None = None
+    mask: str | None = None
+    gateway: str | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class Network:
+    ssid: str | None = None
+    security: WifiSecurityMethod | None = None
+    rssi: int | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class StatusResponse:
+    state: WifiState | None = None
+    ssid: str | None = None
+    security: WifiSecurityMethod | None = None
+    ip_config: WifiIpConfig | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class ConnectRequestConfig:
+    ssid: str | None = None
+    password: str | None = None
+    security: WifiSecurityMethod | None = None
+    ip_config: WifiIpConfig | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class NetworkResponse:
+    count: int | None = None
+    networks: list[Network] | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class ScreenResponse:
+    data: str  # base64 encoded image data

busylib-0.1.0.dist-info/METADATA

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: busylib
+Version: 0.1.0
+Summary: Python library for Busy Bar API
+Author-email: Valerii Lisai <v.lisai@flipperdevices.com>
+Project-URL: Homepage, https://github.com/busy-app/busylib
+Project-URL: Repository, https://github.com/busy-app/busylib
+Project-URL: Documentation, https://busylib.readthedocs.io
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests==2.32.4
+Provides-Extra: dev
+Requires-Dist: pytest==8.4.1; extra == "dev"
+Requires-Dist: requests-mock==1.12.1; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# busylib
+
+A simple and intuitive Python client for interacting with the Busy Bar API. This library allows you to programmatically control the device's display, audio, and assets.
+
+## Features
+
+-   Easy-to-use API for all major device functions.
+-   Upload and manage assets for your applications.
+-   Control the display by drawing text and images.
+-   Play and stop audio files.
+-   Built-in validation for device IP addresses.
+
+## Installation
+
+You can install `busylib` directly from PyPI:
+
+```bash
+pip install busylib
+```
+
+## Usage
+
+First, import and initialize the `BusyBar` client with IP address of your device.
+
+```python
+from busylib import BusyBar
+
+bb = BusyBar("10.0.4.20")
+
+version_info = bb.get_version()
+print(f"Device version: {version_info.version}")
+```
+
+You can also use context manager.
+
+```python
+from busylib import BusyBar
+
+with BusyBar("10.0.4.20") as bb:
+    version_info = bb.get_version()
+    print(f"Device version: {version_info.version}")
+```
+
+## API Examples
+
+Here are some examples of how to use the library to control your Busy Bar device.
+
+### Uploading an Asset
+
+You can upload files (like images or sounds) to be used by your application on the device.
+
+```python
+with open("path/to/your/image.png", "rb") as f:
+    file_bytes = f.read()
+    response = bb.upload_asset(
+        app_id="my-app",
+        filename="logo.png",
+        data=file_bytes
+    )
+    print(f"Upload result: {response.result}")
+
+
+with open("path/to/your/sound.wav", "rb") as f:
+    file_bytes = f.read()
+    response = bb.upload_asset(
+        app_id="my-app",
+        filename="notification.wav",
+        data=file_bytes
+    )
+```
+
+### Drawing on the Display
+
+Draw text or images on the device's screen. The `draw_on_display` method accepts a `DisplayElements` object containing a list of elements to render.
+
+```python
+from busylib import types
+
+
+text_element = types.TextElement(
+    id="hello",
+    type="text",
+    x=10,
+    y=20,
+    text="Hello, World!",
+    display=types.DisplayName.FRONT,
+)
+
+image_element = types.ImageElement(
+    id="logo",
+    type="image",
+    x=50,
+    y=40,
+    path="logo.png",
+    display=types.DisplayName.BACK,
+)
+
+display_data = types.DisplayElements(
+    app_id="my-app",
+    elements=[text_element, image_element]
+)
+
+response = bb.draw_on_display(display_data)
+print(f"Draw result: {response.result}")
+```
+
+### Clearing the Display
+
+To clear everything from the screen:
+
+```python
+response = bb.clear_display()
+print(f"Clear result: {response.result}")
+```
+
+### Playing Audio
+
+Play an audio file that you have already uploaded.
+
+```python
+response = bb.play_audio(app_id="my-app", path="notification.wav")
+print(f"Play result: {response.result}")
+```
+
+### Stopping Audio
+
+To stop any audio that is currently playing:
+
+```python
+response = bb.stop_audio()
+print(f"Stop result: {response.result}")
+```
+
+### Deleting All Assets for an App
+
+This will remove all files associated with a specific `app_id`.
+
+```python
+response = bb.delete_app_assets(app_id="my-app")
+print(f"Delete result: {response.result}")
+```
+
+### Getting Device Status
+
+You can get various status information from the device:
+
+```python
+version = bb.get_version()
+print(f"Version: {version.version}, Branch: {version.branch}")
+
+status = bb.get_status()
+if status.system:
+    print(f"Uptime: {status.system.uptime}")
+if status.power:
+    print(f"Battery: {status.power.battery_charge}%")
+
+brightness = bb.get_display_brightness()
+print(f"Front brightness: {brightness.front}, Back brightness: {brightness.back}")
+
+volume = bb.get_audio_volume()
+print(f"Volume: {volume.volume}")
+```
+
+### Working with Storage
+
+You can manage files in the device's storage:
+
+```python
+file_data = b"Hello, world!"
+response = bb.write_storage_file(path="/my-app/data.txt", data=file_data)
+
+file_content = bb.read_storage_file(path="/my-app/data.txt")
+print(file_content.decode('utf-8'))
+
+storage_list = bb.list_storage_files(path="/my-app")
+for item in storage_list.list:
+    if item.type == "file":
+        print(f"File: {item.name} ({item.size} bytes)")
+    else:
+        print(f"Directory: {item.name}")
+
+response = bb.create_storage_directory(path="/my-app/subdirectory")
+
+response = bb.remove_storage_file(path="/my-app/data.txt")
+```
+
+## Development
+
+To set up a development environment, clone the repository and install the package in editable mode with test dependencies:
+
+```bash
+git clone https://github.com/busy-app/busylib
+cd busylib
+python3 -m venv .venv
+source .venv/bin/activate
+make install-dev
+```
+
+To run the tests:
+
+```bash
+make test
+```

busylib-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+busylib/__init__.py,sha256=7CQFe1iS-QRVAVlufLarG0MXEjkbqZht_DI2kUvsHz0,28
+busylib/client.py,sha256=l-gMVPP5X9m0IGqnjMjKPUo-olw4nf2cHvgz7DtdIjw,12746
+busylib/exceptions.py,sha256=DHYoEXGdADXSxcgLq7BWqq_865J0LsMysZL-Wuip2wc,210
+busylib/types.py,sha256=AGNd39jN5Rn5fI9kk5Ugk-4fr3JeXQpka2YEFeEWKNw,4223
+busylib-0.1.0.dist-info/licenses/LICENSE,sha256=aJO9BQGuVb1fvGzHcgWYiwcC9kEFyD-FBb8SPO-ATJ4,1071
+busylib-0.1.0.dist-info/METADATA,sha256=v8QccaMsA439sMQYg5hrQ9dAcDmIZKXuPHts6UnDIcc,5514
+busylib-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+busylib-0.1.0.dist-info/top_level.txt,sha256=tXeqg2EVVj4E8-ywimkxRzuCJq2HqMXA0571IB15PDA,8
+busylib-0.1.0.dist-info/RECORD,,

busylib-0.0.2.dist-info/METADATA

@@ -1,162 +0,0 @@
-Metadata-Version: 2.4
-Name: busylib
-Version: 0.0.2
-Summary: Python library for Busy Bar API
-Author-email: Valerii Lisai <v.lisai@flipperdevices.com>
-Project-URL: Homepage, https://github.com/busy-app/busylib
-Project-URL: Repository, https://github.com/busy-app/busylib
-Project-URL: Documentation, https://busylib.readthedocs.io
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests==2.32.4
-Provides-Extra: dev
-Requires-Dist: pytest==8.4.1; extra == "dev"
-Requires-Dist: requests-mock==1.12.1; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
-Dynamic: license-file
-
-# busylib
-
-A simple and intuitive Python client for interacting with the Busy Bar API. This library allows you to programmatically control the device's display, audio, and assets.
-
-## Features
-
--   Easy-to-use API for all major device functions.
--   Upload and manage assets for your applications.
--   Control the display by drawing text and images.
--   Play and stop audio files.
--   Built-in validation for device IP addresses.
-
-## Installation
-
-You can install `busylib` directly from PyPI:
-
-```bash
-pip install busylib
-```
-
-## Usage
-
-First, import and initialize the `BusyBar` client with the IP address of your device.
-
-```python
-from busylib import BusyBar
-
-try:
-    # Default IP is 10.0.4.20, but you can specify your own
-    bb = BusyBar("192.168.1.100")
-except ValueError as e:
-    print(f"Error: {e}")
-
-# Now you can use the bb object to interact with your device.
-```
-
-## API Examples
-
-Here are some examples of how to use the library to control your Busy Bar device.
-
-### Uploading an Asset
-
-You can upload files (like images or sounds) to be used by your application on the device.
-
-```python
-# Upload a file from bytes
-with open("path/to/your/image.png", "rb") as f:
-    file_bytes = f.read()
-    bb.upload_asset(
-        app_id="my-app",
-        file_name="logo.png",
-        file=file_bytes
-    )
-
-# Or upload directly from a file-like object
-with open("path/to/your/sound.mp3", "rb") as f:
-    bb.upload_asset(
-        app_id="my-app",
-        file_name="notification.mp3",
-        file=f
-    )
-```
-
-### Drawing on the Display
-
-Draw text or images on the device's screen. The `draw_display` method accepts a list of elements to render.
-
-```python
-elements = [
-    {
-        "type": "text",
-        "value": "Hello, World!",
-        "x": 10,
-        "y": 20,
-        "color": "#FFFFFF" # Optional
-    },
-    {
-        "type": "image",
-        "path": "logo.png", # Must be uploaded first
-        "x": 50,
-        "y": 40
-    }
-]
-
-bb.draw_display(app_id="my-app", elements=elements)
-```
-
-### Clearing the Display
-
-To clear everything from the screen:
-
-```python
-bb.clear_display()
-```
-
-### Playing a Sound
-
-Play an audio file that you have already uploaded.
-
-```python
-bb.play_sound(app_id="my-app", path="notification.mp3")
-```
-
-### Stopping a Sound
-
-To stop any audio that is currently playing:
-
-```python
-bb.stop_sound()
-```
-
-### Deleting All Assets for an App
-
-This will remove all files associated with a specific `app_id`.
-
-```python
-bb.delete_assets(app_id="my-app")
-```
-
-## Development
-
-To set up a development environment, clone the repository and install the package in editable mode with test dependencies:
-
-```bash
-git clone https://github.com/busy-app/busylib
-cd busylib
-python3 -m venv .venv
-source .venv/bin/activate
-make install-dev
-```
-
-To run the tests:
-
-```bash
-make test
-```

busylib-0.0.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-busylib/__init__.py,sha256=uxjPUviskpLD81tC5UqRFTTNr1jh7KkvPaKOnUivhFg,2605
-busylib/client.py,sha256=725I_M8AdLUhDI3OjxSZe-giNQsA68lc5Sm1tBFIEJY,3728
-busylib/types.py,sha256=LlBb1-lQraCjAitU-ImI52EXsayXCMcLvEjyuLXsABQ,176
-busylib-0.0.2.dist-info/licenses/LICENSE,sha256=aJO9BQGuVb1fvGzHcgWYiwcC9kEFyD-FBb8SPO-ATJ4,1071
-busylib-0.0.2.dist-info/METADATA,sha256=43fmietVoW8ILVwAV4Wmse8BOH3AoYl49QqccrtH8AU,3824
-busylib-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-busylib-0.0.2.dist-info/top_level.txt,sha256=tXeqg2EVVj4E8-ywimkxRzuCJq2HqMXA0571IB15PDA,8
-busylib-0.0.2.dist-info/RECORD,,