kiosker-python-api 1.2.1__py2.py3-none-any.whl

kiosker/__init__.py

@@ -0,0 +1,2 @@
+from .api import KioskerAPI
+from .data import Status, Result, Blackout

kiosker/api.py

@@ -0,0 +1,103 @@
+import httpx
+from .data import Status, Result, Blackout, ScreensaverState
+
+API_PATH = '/api/v1'
+
+class KioskerAPI:
+    def __init__(self, host, token, port=8081, ssl=False):
+        if ssl:
+            self.conf_host = f'https://{host}:{port}'
+        else:
+            self.conf_host = f'http://{host}:{port}'
+
+        self.conf_headers = {'accept': 'application/json',
+                             'Authorization': f'Bearer {token}'}
+        
+    def _get(self, path: str):
+        r = httpx.get(f'{self.conf_host}{API_PATH}{path}', headers=self.conf_headers)
+        if r.status_code == 200:
+            return r.json()
+        elif r.status_code == 401:
+            raise RuntimeError("Unauthorized")
+        elif r.status_code == 403:
+            raise RuntimeError("IP not allowed")
+        else:
+            r.raise_for_status()
+            
+    def _post(self, path: str, json=None):
+        if json is None:
+            json = {}
+        r = httpx.post(f'{self.conf_host}{API_PATH}{path}', headers=self.conf_headers, json=json)
+        if r.status_code == 200:
+            return r.json()
+        elif r.status_code == 401:
+            raise RuntimeError("Unauthorized")
+        elif r.status_code == 403:
+            raise RuntimeError("IP not allowed")
+        elif r.status_code == 400:
+            raise RuntimeError("Bad request")
+        else:
+            r.raise_for_status()
+
+    def status(self):
+        status_data = self._get('/status').get('status')
+        return Status.from_dict(status_data)
+
+    def ping(self):
+        response_json = self._get('/ping')
+        result = Result.from_dict(response_json)
+        if result.error is False:
+            return True
+        else:
+            raise RuntimeError(f'Ping error: {result.reason}')
+    
+    # Navigation
+    def navigate_home(self):
+        return Result.from_dict(self._post('/navigate/home'))
+    
+    def navigate_refresh(self):
+        return Result.from_dict(self._post('/navigate/refresh'))
+    
+    def navigate_forward(self):
+        return Result.from_dict(self._post('/navigate/forward'))
+    
+    def navigate_backward(self):
+        return Result.from_dict(self._post('/navigate/backward'))
+    
+    def navigate_url(self, url: str):
+        return Result.from_dict(self._post('/navigate/url', json={'url': url}))
+    
+    # Print
+    def print(self):
+        return Result.from_dict(self._post('/print'))
+    
+    # Clear
+    def clear_cookies(self):
+        return Result.from_dict(self._post('/clear/cookies'))
+    
+    def clear_cache(self):
+        return Result.from_dict(self._post('/clear/cache'))
+    
+    # Screensaver
+    def screensaver_interact(self):
+        return Result.from_dict(self._post('/screensaver/interact'))
+    
+    def screensaver_set_disabled_state(self, disabled: bool):
+        return Result.from_dict(self._post('/screensaver/state', json={'disabled': disabled}))
+    
+    def screensaver_get_state(self):
+        screensaver_status_data = self._get('/screensaver/state').get('screensaver')
+        return ScreensaverState.from_dict(screensaver_status_data)
+    
+    # Blackout
+    def blackout_set(self, blackout: Blackout):
+        return Result.from_dict(self._post('/blackout', json=blackout.to_dict()))
+    
+    def blackout_get(self):
+        blackout_data = self._get('/blackout/state').get('blackout')
+        if blackout_data is None:
+            return None
+        return Blackout.from_dict(blackout_data)
+    
+    def blackout_clear(self):
+        return Result.from_dict(self._post('/blackout', json={'visible': False}))

kiosker/data.py

@@ -0,0 +1,84 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+@dataclass
+class Status:
+    battery_level: int
+    battery_state: str
+    model: str
+    os_version: str
+    last_interaction: datetime
+    last_update: datetime
+    device_id: str
+    last_motion: Optional[datetime]
+    screensaver_pause: Optional[bool]
+    
+    @classmethod
+    def from_dict(cls, status_data):
+        return cls(battery_level=status_data['batteryLevel'], battery_state=status_data['batteryState'], model=status_data['model'], os_version=status_data['osVersion'], last_interaction=datetime.fromisoformat(status_data['lastInteraction']), last_motion=datetime.fromisoformat(status_data['lastMotion']) if status_data.get('lastMotion') else None, last_update=datetime.fromisoformat(status_data['date']), device_id=status_data['deviceId'], screensaver_pause=status_data['screensaverPause'] if status_data.get('screensaverPause') else None)
+
+@dataclass
+class Result:
+    error: bool
+    reason: Optional[str]
+    function: Optional[str]
+    
+    @classmethod
+    def from_dict(cls, result_data):
+        return cls(error=result_data['error'], reason=result_data['reason'] if result_data.get('reason') else None , function=result_data.get('function') if result_data.get('function') else None)
+
+@dataclass
+class ScreensaverState:
+    visible: bool
+    disabled: bool
+    
+    @classmethod
+    def from_dict(cls, state_data):
+        return cls(visible=state_data['visible'], disabled=state_data['disabled'])
+
+        
+@dataclass
+class Blackout:
+    visible: bool
+    background: Optional[str] = None
+    foreground: Optional[str] = None
+    expire: Optional[int] = None
+    text: Optional[str] = None
+    icon: Optional[str] = None
+    dismissible: Optional[bool] = False
+    buttonBackground: Optional[str] = None
+    buttonForeground: Optional[str] = None
+    buttonText: Optional[str] = None
+    sound: Optional[str] = None
+
+    def to_dict(self):
+        return {
+            'visible': self.visible,
+            'background': self.background,
+            'foreground': self.foreground,
+            'expire': self.expire,
+            'text': self.text,
+            'icon': self.icon,
+            'dismissible': self.dismissible,
+            'buttonBackground': self.buttonBackground,
+            'buttonForeground': self.buttonForeground,
+            'buttonText': self.buttonText,
+            'sound': self.sound,
+        }
+
+    @classmethod
+    def from_dict(cls, blackout_data):
+        return cls(
+            visible=blackout_data['visible'],
+            background=blackout_data['background'],
+            foreground=blackout_data['foreground'],
+            expire=blackout_data['expire'],
+            text=blackout_data.get('text'),
+            icon=blackout_data.get('icon'),
+            dismissible=blackout_data.get('dismissible', False),
+            buttonBackground=blackout_data.get('buttonBackground'),
+            buttonForeground=blackout_data.get('buttonForeground'),
+            buttonText=blackout_data.get('buttonText'),
+            sound=blackout_data.get('sound'),
+        )

kiosker_python_api-1.2.1.dist-info/METADATA

@@ -0,0 +1,261 @@
+Metadata-Version: 2.4
+Name: kiosker-python-api
+Version: 1.2.1
+Summary: A python wrapper for the Kiosker API
+Project-URL: Homepage, https://kiosker.io
+Project-URL: Documentation, https://docs.kiosker.io
+Project-URL: Repository, https://github.com/Top-North/kiosker-python.git
+Project-URL: Issues, https://github.com/Top-North/kiosker-python/issues
+Author-email: Martin Claesson <martin@topnorth.se>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,kiosk,kiosker,kiosker pro
+Requires-Dist: httpx
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Python wrapper for Kiosker API
+Python wrapper for Kiosker API-integration.
+
+---
+
+### Installation
+
+```shell
+pip3 install kiosker-python
+```
+
+---
+
+### Setup
+
+```python
+from kiosker.api import KioskerAPI
+api = KioskerAPI('10.0.1.100', 'token')
+```
+
+---
+
+### Functions
+
+#### Get Status
+```python
+status = api.status()
+
+print('Status:')
+print(f'Device ID: {status.device_id}')
+print(f'Model: {status.model}')
+print(f'OS version: {status.os_version}')
+print(f'Battery level: {status.battery_level}%')
+print(f'Battery state: {status.battery_state}')
+print(f'Last interaction: {status.last_interaction}')
+print(f'Last motion: {status.last_motion}')
+print(f'Last status update: {status.last_update}')
+print(f'Screensaver pause: {status.screensaver_pause}')
+```
+**Description**: Retrieves the current status of the kiosk.
+
+#### Ping the API
+```python
+result = api.ping()
+print(f"Ping successful: {result}")
+```
+**Description**: Checks if the API is reachable. Returns `True` if successful, otherwise raises an error.
+
+#### Navigate to a URL
+```python
+result = api.navigate_url('https://example.com')
+print(f"Navigation result: {result}")
+```
+**Description**: Navigates the kiosk to the specified URL.
+
+#### Refresh the Page
+```python
+result = api.navigate_refresh()
+print(f"Refresh result: {result}")
+```
+**Description**: Refreshes the current page on the kiosk.
+
+#### Navigate Home
+```python
+result = api.navigate_home()
+print(f"Home navigation result: {result}")
+```
+**Description**: Navigates the kiosk to the home page.
+
+#### Navigate Forward
+```python
+result = api.navigate_forward()
+print(f"Navigate forward result: {result}")
+```
+**Description**: Navigates forward in the browser's history.
+
+#### Navigate Backward
+```python
+result = api.navigate_backward()
+print(f"Navigate backward result: {result}")
+```
+**Description**: Navigates backward in the browser's history.
+
+#### Print
+```python
+result = api.print()
+print(f"Print result: {result}")
+```
+**Description**: Sends a print command to the kiosk.
+
+#### Clear Cookies
+```python
+result = api.clear_cookies()
+print(f"Cookies cleared: {result}")
+```
+**Description**: Clears all cookies stored on the kiosk.
+
+#### Clear Cache
+```python
+result = api.clear_cache()
+print(f"Cache cleared: {result}")
+```
+**Description**: Clears the cache on the kiosk.
+
+#### Interact with Screensaver
+```python
+result = api.screensaver_interact()
+print(f"Screensaver interaction result: {result}")
+```
+**Description**: Simulates user interaction with the screensaver to prevent it from activating.
+
+#### Set Screensaver State
+```python
+result = api.screensaver_set_state(disabled=True)
+print(f"Screensaver disabled: {result}")
+```
+**Description**: Enables or disables the screensaver.
+
+#### Get Screensaver State
+```python
+state = api.screensaver_get_state()
+print(f"Screensaver state: {state}")
+```
+**Description**: Retrieves the current state of the screensaver (enabled or disabled).
+
+#### Set Blackout
+```python
+from kiosker.data import Blackout
+
+blackout = Blackout(
+    visible=True,                   # Required: show blackout screen
+    text="Maintenance in progress", # Optional: text to display
+    background="#000000",           # Optional: background color (hex)
+    foreground="#FFFFFF",           # Optional: foreground/text color (hex)
+    icon="warning",                 # Optional: icon name (SF Symbol)
+    expire=60,                      # Optional: time in seconds before blackout expires
+    dismissible=True,               # Optional: allow user to dismiss blackout with a button
+    buttonBackground="#FF0000",     # Optional: button background color (hex)
+    buttonForeground="#FFFFFF",     # Optional: button text color (hex)
+    buttonText="OK",                # Optional: button label
+    sound="1003"                    # Optional: sound to play (SystemSoundID)
+)
+result = api.blackout_set(blackout)
+print(f"Blackout set: {result}")
+```
+**Description**: Sets a blackout screen with customizable text, colors, expiration time, and optional button/sound options.
+
+#### Get Blackout State
+```python
+blackout_state = api.blackout_get()
+print(f"Blackout state: {blackout_state}")
+```
+**Description**: Retrieves the current state of the blackout screen.
+
+#### Clear Blackout
+```python
+result = api.blackout_clear()
+print(f"Blackout cleared: {result}")
+```
+**Description**: Clears the blackout screen.
+
+---
+
+### Objects
+
+#### `Status`
+Represents the current status of the kiosk.
+
+**Attributes**:
+- `battery_level` (int): Battery percentage.
+- `battery_state` (str): Current battery state (e.g., charging, discharging).
+- `model` (str): Device model.
+- `os_version` (str): Operating system version.
+- `last_interaction` (datetime): Timestamp of the last user interaction.
+- `last_motion` (Optional[datetime]): Timestamp of the last detected motion.
+- `last_update` (datetime): Timestamp of the last status update.
+- `device_id` (str): Unique identifier for the device.
+- `screensaver_pause` (Optional[bool]): Whether the screensaver is paused.
+
+#### `Result`
+Represents the result of an API operation.
+
+**Attributes**:
+- `error` (bool): Indicates if an error occurred.
+- `reason` (Optional[str]): Reason for the error, if any.
+- `function` (Optional[str]): Name of the function that caused the error.
+
+#### `Blackout`
+Represents a blackout screen configuration.
+
+**Attributes**:
+- `visible` (bool): Whether the blackout screen is visible.
+- `text` (Optional[str]): Text to display on the blackout screen.
+- `background` (str): Background color in hex format.
+- `foreground` (str): Foreground color in hex format.
+- `icon` (Optional[str]): Icon to display on the blackout screen.
+- `expire` (int): Time in seconds before the blackout screen expires.
+
+---
+
+### Development
+1. Clone the project
+
+2. Create a virtual environment
+```shell
+python3 -m venv venv
+```
+
+3. Activate the virtual environment
+```shell
+source venv/bin/activate
+```
+
+4. Install dependencies
+```shell
+pip install wheel setuptools twine pytest httpx
+```
+
+5. Run tests
+```shell
+HOST="0.0.0.0" TOKEN="" pytest -s
+```
+
+6. Build the library
+```shell
+python -m build --wheel
+```
+
+7. Upload to test
+```shell
+twine upload --repository testpypi dist/*
+```
+
+---
+
+### API Documentation
+- [Docs](https://docs.kiosker.io/#/api)
+- [Definition](https://swagger.kiosker.io)
+
+---
+
+### Get Kiosker for iOS on the App Store
+- [Kiosker](https://apps.apple.com/us/app/kiosker-fullscreen-web-kiosk/id1481691530?uo=4&at=11l6hc&ct=fnd)
+- [Kiosker Pro](https://apps.apple.com/us/app/kiosker-pro-web-kiosk/id1446738885?uo=4&at=11l6hc&ct=fnd)

kiosker_python_api-1.2.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+kiosker/__init__.py,sha256=2IUwkYlNimXNczxs09J33WoNGdRTEDFD23VtYl6TDg4,70
+kiosker/api.py,sha256=bqa5UWzZbFXYb34dev71jCb2SfHmNS0CU66cikrlLuE,3561
+kiosker/data.py,sha256=ku8monJFlLxR4RQpqA18NituZRuNSDVFbYyAE85AY7Q,3114
+kiosker_python_api-1.2.1.dist-info/METADATA,sha256=2EQ3rsW45s8RSO4g5f5-5ksXnqPUd6TdoF1oIBgVYhY,7140
+kiosker_python_api-1.2.1.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+kiosker_python_api-1.2.1.dist-info/licenses/LICENSE,sha256=mjD-_yvrBLGI96FVJteQTq936wbgJmFImKQ2Het_8HQ,1069
+kiosker_python_api-1.2.1.dist-info/RECORD,,

kiosker_python_api-1.2.1.dist-info/WHEEL

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

kiosker_python_api-1.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Top North AB
+
+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.