camera-ui-common 1.0.0__tar.gz

camera_ui_common-1.0.0/LICENSE.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2020-2024 seydx <dev@seydx.com>
+
+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.

camera_ui_common-1.0.0/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: camera-ui-common
+Version: 1.0.0
+Summary: camera.ui python utilities
+Author-email: seydx <dev@seydx.com>
+Maintainer-email: seydx <dev@seydx.com>
+Project-URL: Homepage, https://github.com/seydx/camera.ui
+Project-URL: Documentation, https://github.com/seydx/camera.ui
+Project-URL: Repository, https://github.com/seydx/camera.ui
+Project-URL: Bug Tracker, https://github.com/seydx/camera.ui/issues
+Project-URL: Changelog, https://github.com/seydx/camera.ui/blob/master/CHANGELOG.md
+Keywords: camera.ui,python,utilities
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: typing_extensions>=4.12.2
+Requires-Dist: reactivex>=4.0.4
+Requires-Dist: camera-ui-sdk>=1.0.0
+Dynamic: license-file
+
+# camera-ui-python-common
+
+Shared utilities for Python-based camera.ui plugins including logging, reactive programming, and common helpers.
+
+## Installation
+
+```bash
+pip install camera-ui-python-common
+```
+
+## Core Features
+
+- **Logging** - Colored, structured logging
+- **Reactive Programming** - Observable properties
+- **Signal Handling** - Graceful shutdown
+- **Object Utilities** - Deep object manipulation
+- **Async Helpers** - Task and thread management
+
+## Logging
+
+```python
+from camera_ui_python_common import LoggerService
+
+logger = LoggerService({
+    "prefix": "MyPlugin",
+    "debug_enabled": True
+})
+
+logger.log("Plugin started")
+logger.error("Something went wrong")
+logger.success("Operation completed")
+logger.debug("Debug information")
+```
+
+## Reactive Programming
+
+```python
+from camera_ui_python_common import ReactiveProperty
+
+# Create reactive state
+state = ReactiveProperty({"count": 0, "active": True})
+
+# Subscribe to changes
+state.observable.subscribe(lambda value: print(f"State: {value}"))
+
+# Update state
+state.next({"count": 1, "active": True})
+```
+
+## Signal Handling
+
+```python
+from camera_ui_python_common import SignalHandler
+
+async def cleanup():
+    print("Cleaning up...")
+
+signal_handler = SignalHandler({
+    "display_name": "MyPlugin",
+    "logger": logger,
+    "close_function": cleanup
+})
+
+signal_handler.setup_handlers()
+```
+
+## Object Path Operations
+
+```python
+from camera_ui_python_common import ObjectPath
+
+data = {"camera": {"settings": {"resolution": "1080p"}}}
+
+# Get nested values
+resolution = ObjectPath.get(data, "camera.settings.resolution")
+
+# Set nested values  
+ObjectPath.set(data, "camera.settings.bitrate", 5000)
+
+# Check if path exists
+has_setting = ObjectPath.has(data, "camera.settings.fps")
+```
+
+## Async Utilities
+
+### Task Management
+```python
+from camera_ui_python_common import TaskSet
+
+tasks = TaskSet("MyTasks")
+tasks.add(my_async_function())
+await tasks
+```
+
+### Thread Operations
+```python
+from camera_ui_python_common import to_thread
+
+# Run blocking operation in thread
+result = await to_thread(blocking_function)
+```
+
+### Sync/Async Bridge
+```python
+from camera_ui_python_common import make_sync
+
+# Convert async function to sync
+sync_version = make_sync(async_function)
+result = sync_version(args)
+```
+
+## RTSP Utilities
+
+```python
+from camera_ui_python_common import build_target_url
+
+url = build_target_url("rtsp://camera.local/stream", {
+    "video": True,
+    "audio": ["pcma", "opus"],
+    "timeout": 30
+})
+```
+
+## Complete Example
+
+```python
+import asyncio
+from camera_ui_python_common import LoggerService, ReactiveProperty, SignalHandler
+
+class MyPlugin:
+    def __init__(self):
+        self.logger = LoggerService({"prefix": "MyPlugin"})
+        self.state = ReactiveProperty({"active": False})
+        
+        self.signal_handler = SignalHandler({
+            "display_name": "MyPlugin",
+            "logger": self.logger,
+            "close_function": self.cleanup
+        })
+    
+    async def start(self):
+        self.logger.log("Starting plugin...")
+        self.signal_handler.setup_handlers()
+        
+        # Update state
+        self.state.next({"active": True})
+        
+        # Keep running
+        await asyncio.Future()
+    
+    async def cleanup(self):
+        self.logger.log("Stopping plugin...")
+
+# Usage
+plugin = MyPlugin()
+asyncio.run(plugin.start())
+```
+
+## Contributing
+
+Contributions are welcome! Please read our contributing guidelines and submit pull requests to our repository.
+
+## License
+
+MIT
+
+---
+
+*Part of the camera.ui ecosystem - A comprehensive camera management solution.*

camera_ui_common-1.0.0/README.md

@@ -0,0 +1,169 @@
+# camera-ui-python-common
+
+Shared utilities for Python-based camera.ui plugins including logging, reactive programming, and common helpers.
+
+## Installation
+
+```bash
+pip install camera-ui-python-common
+```
+
+## Core Features
+
+- **Logging** - Colored, structured logging
+- **Reactive Programming** - Observable properties
+- **Signal Handling** - Graceful shutdown
+- **Object Utilities** - Deep object manipulation
+- **Async Helpers** - Task and thread management
+
+## Logging
+
+```python
+from camera_ui_python_common import LoggerService
+
+logger = LoggerService({
+    "prefix": "MyPlugin",
+    "debug_enabled": True
+})
+
+logger.log("Plugin started")
+logger.error("Something went wrong")
+logger.success("Operation completed")
+logger.debug("Debug information")
+```
+
+## Reactive Programming
+
+```python
+from camera_ui_python_common import ReactiveProperty
+
+# Create reactive state
+state = ReactiveProperty({"count": 0, "active": True})
+
+# Subscribe to changes
+state.observable.subscribe(lambda value: print(f"State: {value}"))
+
+# Update state
+state.next({"count": 1, "active": True})
+```
+
+## Signal Handling
+
+```python
+from camera_ui_python_common import SignalHandler
+
+async def cleanup():
+    print("Cleaning up...")
+
+signal_handler = SignalHandler({
+    "display_name": "MyPlugin",
+    "logger": logger,
+    "close_function": cleanup
+})
+
+signal_handler.setup_handlers()
+```
+
+## Object Path Operations
+
+```python
+from camera_ui_python_common import ObjectPath
+
+data = {"camera": {"settings": {"resolution": "1080p"}}}
+
+# Get nested values
+resolution = ObjectPath.get(data, "camera.settings.resolution")
+
+# Set nested values  
+ObjectPath.set(data, "camera.settings.bitrate", 5000)
+
+# Check if path exists
+has_setting = ObjectPath.has(data, "camera.settings.fps")
+```
+
+## Async Utilities
+
+### Task Management
+```python
+from camera_ui_python_common import TaskSet
+
+tasks = TaskSet("MyTasks")
+tasks.add(my_async_function())
+await tasks
+```
+
+### Thread Operations
+```python
+from camera_ui_python_common import to_thread
+
+# Run blocking operation in thread
+result = await to_thread(blocking_function)
+```
+
+### Sync/Async Bridge
+```python
+from camera_ui_python_common import make_sync
+
+# Convert async function to sync
+sync_version = make_sync(async_function)
+result = sync_version(args)
+```
+
+## RTSP Utilities
+
+```python
+from camera_ui_python_common import build_target_url
+
+url = build_target_url("rtsp://camera.local/stream", {
+    "video": True,
+    "audio": ["pcma", "opus"],
+    "timeout": 30
+})
+```
+
+## Complete Example
+
+```python
+import asyncio
+from camera_ui_python_common import LoggerService, ReactiveProperty, SignalHandler
+
+class MyPlugin:
+    def __init__(self):
+        self.logger = LoggerService({"prefix": "MyPlugin"})
+        self.state = ReactiveProperty({"active": False})
+        
+        self.signal_handler = SignalHandler({
+            "display_name": "MyPlugin",
+            "logger": self.logger,
+            "close_function": self.cleanup
+        })
+    
+    async def start(self):
+        self.logger.log("Starting plugin...")
+        self.signal_handler.setup_handlers()
+        
+        # Update state
+        self.state.next({"active": True})
+        
+        # Keep running
+        await asyncio.Future()
+    
+    async def cleanup(self):
+        self.logger.log("Stopping plugin...")
+
+# Usage
+plugin = MyPlugin()
+asyncio.run(plugin.start())
+```
+
+## Contributing
+
+Contributions are welcome! Please read our contributing guidelines and submit pull requests to our repository.
+
+## License
+
+MIT
+
+---
+
+*Part of the camera.ui ecosystem - A comprehensive camera management solution.*

camera_ui_common-1.0.0/camera_ui_common/__init__.py

@@ -0,0 +1,28 @@
+from .common_utils.object_path import ObjectPath, Path
+from .common_utils.promise import Deferred
+from .common_utils.reactive import ReactiveProperty
+from .common_utils.signal_handler import SignalHandler, SignalHandlerOptions
+from .common_utils.subscribed import Subscribed
+from .common_utils.task import TaskSet
+from .common_utils.thread import to_thread
+from .common_utils.utils import make_sync, merge, merge_with
+from .logger_service.ansicolor import Ansicolor
+from .logger_service.logger import LoggerOptions, LoggerService
+
+__all__ = [
+    "Deferred",
+    "ObjectPath",
+    "Path",
+    "SignalHandler",
+    "SignalHandlerOptions",
+    "Subscribed",
+    "TaskSet",
+    "to_thread",
+    "make_sync",
+    "merge",
+    "merge_with",
+    "ReactiveProperty",
+    "Ansicolor",
+    "LoggerOptions",
+    "LoggerService",
+]

camera_ui_common-1.0.0/camera_ui_common/camera_utils/__init__.py

@@ -0,0 +1,5 @@
+"""Camera utilities module."""
+
+from .utils import build_target_url
+
+__all__ = ["build_target_url"]

camera_ui_common-1.0.0/camera_ui_common/camera_utils/utils.py

@@ -0,0 +1,75 @@
+"""Camera utility functions."""
+
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+from camera_ui_python_types import RTSPUrlOptions
+
+
+def build_target_url(rtsp_url: str, options: RTSPUrlOptions | None = None) -> str:
+    """
+    Build a target URL with streaming options.
+
+    Args:
+        rtsp_url: The base RTSP URL
+        options: Optional streaming options
+
+    Returns:
+        The constructed URL with query parameters
+    """
+    if options is None:
+        options = {}
+
+    parsed = urlparse(rtsp_url)
+    base_url = f"{parsed.scheme}://{parsed.netloc}{parsed.path}"
+
+    # Extract options with defaults
+    video = options.get("video", True)
+    audio = options.get("audio", True)
+    audio_single_track = options.get("audioSingleTrack", True)
+    backchannel = options.get("backchannel", False)
+    timeout = options.get("timeout", 15)
+    gop = options.get("gop", True)
+    prebuffer = options.get("prebuffer", False)
+
+    # Validate timeout (5-30 seconds)
+    validated_timeout = min(max(5, timeout), 30)
+
+    params: list[str] = []
+
+    # Video parameter
+    if video:
+        params.append("video")
+
+    # Audio parameter
+    if audio:
+        if isinstance(audio, bool):
+            params.append("audio")
+        elif isinstance(audio, list):
+            if audio_single_track:
+                # Single track with multiple codecs
+                params.append(f"audio={','.join(audio)}")
+            else:
+                # Multiple tracks
+                for codec in audio:
+                    params.append(f"audio={codec}")
+        else:
+            params.append(f"audio={audio}")
+
+    # Backchannel parameter
+    if backchannel:
+        params.append("backchannel=1")
+
+    # GOP parameter
+    if gop:
+        params.append("gop=1")
+
+    # Prebuffer parameter
+    if prebuffer:
+        params.append("prebuffer=5")
+
+    # Timeout parameter
+    params.append(f"timeout={validated_timeout}")
+
+    return f"{base_url}?{'&'.join(params)}"

camera_ui_common-1.0.0/camera_ui_common/common_utils/__init__.py

@@ -0,0 +1,22 @@
+from .object_path import ObjectPath, Path
+from .promise import Deferred
+from .reactive import ReactiveProperty
+from .signal_handler import SignalHandler
+from .subscribed import Subscribed
+from .task import TaskSet
+from .thread import to_thread
+from .utils import make_sync, merge, merge_with
+
+__all__ = [
+    "Deferred",
+    "make_sync",
+    "merge",
+    "merge_with",
+    "ObjectPath",
+    "Path",
+    "ReactiveProperty",
+    "SignalHandler",
+    "Subscribed",
+    "TaskSet",
+    "to_thread",
+]