py-alaska 0.1.0__py3-none-any.whl

py_alaska/task_signal.py

@@ -0,0 +1,238 @@
+"""
+╔══════════════════════════════════════════════════════════════════════════════╗
+║  ALASK v2.0 Project                                                          ║
+║  Task Signal - Process-Safe Signal Communication Module                      ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║  Version : 2.0.0                                                             ║
+║  Date    : 2026-01-30                                                        ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║  Classes:                                                                    ║
+║    - Signal       : Dataclass representing a signal message                  ║
+║    - SignalBroker : Central broker managing queues and subscriptions         ║
+║    - SignalClient : Client wrapper for signal emission and reception         ║
+║                                                                              ║
+║  Functions:                                                                  ║
+║    - _is_picklable : Check if an object can be pickled for IPC               ║
+║                                                                              ║
+║  Notes (Thread/Process Mixed Mode):                                          ║
+║    1. Handlers cannot be passed between processes - register locally         ║
+║    2. Data must be picklable (no lambdas, sockets, file handles)             ║
+║    3. Process mode requires SyncManager                                      ║
+║    4. Thread-only mode uses mgr=None for lightweight operation               ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+"""
+
+from __future__ import annotations
+from typing import Any, Dict, List, Callable, Optional, TYPE_CHECKING
+from dataclasses import dataclass, field
+import threading
+import queue
+import time
+import uuid
+import pickle
+import traceback
+
+if TYPE_CHECKING:
+    from multiprocessing.managers import SyncManager
+
+
+def _is_picklable(obj: Any) -> bool:
+    """객체가 pickle 가능한지 확인"""
+    try:
+        pickle.dumps(obj)
+        return True
+    except (pickle.PicklingError, TypeError, AttributeError):
+        return False
+
+
+@dataclass
+class Signal:
+    name: str
+    source: str
+    data: Any = None
+    signal_id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
+    timestamp: float = field(default_factory=time.time)
+
+    def validate_for_ipc(self) -> bool:
+        """IPC(프로세스 간 통신)에 사용 가능한지 확인"""
+        return _is_picklable(self.data)
+
+
+class SignalBroker:
+    """시그널 브로커 - Thread/Process 혼용 지원
+
+    mgr=None: 스레드 전용 모드 (경량, 빠름)
+    mgr=Manager(): 프로세스 간 통신 모드 (IPC)
+    """
+    __slots__ = ('_mgr', '_queues', '_subscribers', '_lock', '_mode')
+
+    def __init__(self, mgr: Optional[SyncManager] = None):
+        self._mgr = mgr
+        self._mode = 'process' if mgr else 'thread'
+        self._queues: Dict[str, Any] = {}
+        self._subscribers: Dict[str, List[str]] = {}
+        self._lock = threading.Lock()
+
+    def register(self, task_id: str) -> Any:
+        """태스크 큐 등록 (모드에 따라 적절한 큐 타입 생성)"""
+        queues = self._queues
+        with self._lock:
+            if task_id not in queues:
+                if self._mgr:
+                    queues[task_id] = self._mgr.Queue()
+                else:
+                    queues[task_id] = queue.Queue()
+            return queues[task_id]
+
+    @property
+    def mode(self) -> str:
+        """현재 모드 반환 ('thread' 또는 'process')"""
+        return self._mode
+
+    def unregister(self, task_id: str):
+        with self._lock:
+            self._queues.pop(task_id, None)
+            for subs in self._subscribers.values():
+                if task_id in subs:
+                    subs.remove(task_id)
+
+    def subscribe(self, signal_name: str, task_id: str):
+        subs = self._subscribers
+        with self._lock:
+            if signal_name not in subs:
+                subs[signal_name] = []
+            lst = subs[signal_name]
+            if task_id not in lst:
+                lst.append(task_id)
+
+    def unsubscribe(self, signal_name: str, task_id: str):
+        with self._lock:
+            lst = self._subscribers.get(signal_name)
+            if lst and task_id in lst:
+                lst.remove(task_id)
+
+    def emit(self, signal: Signal, validate: bool = False) -> bool:
+        """시그널 발행
+
+        Args:
+            signal: 발행할 시그널
+            validate: True이면 IPC 모드에서 pickle 가능 여부 검증
+
+        Returns:
+            성공 여부
+        """
+        if validate and self._mode == 'process' and not signal.validate_for_ipc():
+            return False
+
+        with self._lock:
+            lst = self._subscribers.get(signal.name)
+            subscribers = lst[:] if lst else []
+            queues = self._queues
+            q_map = {tid: queues.get(tid) for tid in subscribers}
+        data = signal.__dict__
+        sent = False
+        for tid, q in q_map.items():
+            if q:
+                try:
+                    q.put(data, block=False)
+                    sent = True
+                except queue.Full:
+                    print(f"[SignalBroker] Queue full for task '{tid}', signal '{signal.name}' dropped")
+                except Exception as e:
+                    print(f"[SignalBroker] emit error to '{tid}': {e}")
+        return sent
+
+    def emit_to(self, task_id: str, signal: Signal, validate: bool = False) -> bool:
+        """특정 태스크에 시그널 발행
+
+        Args:
+            task_id: 대상 태스크 ID
+            signal: 발행할 시그널
+            validate: True이면 IPC 모드에서 pickle 가능 여부 검증
+
+        Returns:
+            성공 여부
+        """
+        if validate and self._mode == 'process' and not signal.validate_for_ipc():
+            return False
+
+        with self._lock:
+            q = self._queues.get(task_id)
+        if q:
+            try:
+                q.put(signal.__dict__, block=False)
+                return True
+            except queue.Full:
+                print(f"[SignalBroker] Queue full for task '{task_id}', signal '{signal.name}' dropped")
+            except Exception as e:
+                print(f"[SignalBroker] emit_to error '{task_id}': {e}")
+        return False
+
+    def get_subscribers(self, signal_name: str) -> List[str]:
+        with self._lock:
+            lst = self._subscribers.get(signal_name)
+            return lst[:] if lst else []
+
+
+class SignalClient:
+    __slots__ = ('_broker', '_task_id', '_queue', '_handlers', '_running', '_thread')
+
+    def __init__(self, broker: SignalBroker, task_id: str):
+        self._broker = broker
+        self._task_id = task_id
+        self._queue = broker.register(task_id)
+        self._handlers: Dict[str, List[Callable]] = {}
+        self._running = False
+        self._thread = None
+
+    def start(self):
+        self._running = True
+        self._thread = threading.Thread(target=self._recv_loop, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        self._running = False
+        self._broker.unregister(self._task_id)
+
+    def _recv_loop(self):
+        q, handlers = self._queue, self._handlers
+        while self._running:
+            try:
+                data = q.get(timeout=0.5)
+                signal = Signal(**data) if isinstance(data, dict) else data
+                lst = handlers.get(signal.name)
+                if lst:
+                    for handler in lst:
+                        try:
+                            handler(signal)
+                        except Exception as e:
+                            tb = traceback.format_exc()
+                            print(f"[SignalClient:{self._task_id}] Handler error for '{signal.name}':\n{tb}")
+            except queue.Empty:
+                continue
+            except Exception as e:
+                print(f"[SignalClient:{self._task_id}] recv_loop error: {e}")
+
+    def on(self, signal_name: str, handler: Callable[[Signal], None]):
+        h = self._handlers
+        if signal_name not in h:
+            h[signal_name] = []
+        h[signal_name].append(handler)
+        self._broker.subscribe(signal_name, self._task_id)
+
+    def off(self, signal_name: str, handler: Callable[[Signal], None] = None):
+        lst = self._handlers.get(signal_name)
+        if lst:
+            if handler:
+                if handler in lst:
+                    lst.remove(handler)
+            else:
+                lst.clear()
+        if not self._handlers.get(signal_name):
+            self._broker.unsubscribe(signal_name, self._task_id)
+
+    def emit(self, signal_name: str, data: Any = None):
+        self._broker.emit(Signal(name=signal_name, source=self._task_id, data=data))
+
+    def emit_to(self, task_id: str, signal_name: str, data: Any = None):
+        self._broker.emit_to(task_id, Signal(name=signal_name, source=self._task_id, data=data))

py_alaska-0.1.0.dist-info/METADATA

@@ -0,0 +1,263 @@
+Metadata-Version: 2.4
+Name: py-alaska
+Version: 0.1.0
+Summary: ALASKA - Multiprocess Task Management Framework for Python
+Author-email: DivisionVision <info@division.co.kr>
+Maintainer-email: DivisionVision <info@division.co.kr>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/divisionvision/alaska
+Project-URL: Documentation, https://github.com/divisionvision/alaska#readme
+Project-URL: Repository, https://github.com/divisionvision/alaska.git
+Project-URL: Issues, https://github.com/divisionvision/alaska/issues
+Keywords: multiprocess,task,rmi,ipc,monitoring,shared-memory
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Provides-Extra: monitor
+Requires-Dist: psutil>=5.8.0; extra == "monitor"
+Provides-Extra: camera
+Requires-Dist: PySide6>=6.0.0; extra == "camera"
+Provides-Extra: all
+Requires-Dist: psutil>=5.8.0; extra == "all"
+Requires-Dist: PySide6>=6.0.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# ALASKA
+
+**A**dvanced **L**ightweight **A**synchronous **S**ervice **K**ernel for **A**pplications
+
+[![PyPI version](https://badge.fury.io/py/py-alaska.svg)](https://badge.fury.io/py/py-alaska)
+[![Python](https://img.shields.io/pypi/pyversions/alaska.svg)](https://pypi.org/project/py-alaska/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A Python framework for building multiprocess task management systems with RMI (Remote Method Invocation), shared memory, and real-time monitoring.
+
+## Features
+
+- **Multiprocess Task Management**: Run tasks as separate processes or threads
+- **RMI (Remote Method Invocation)**: Call methods across processes seamlessly
+- **Shared Memory (SmBlock)**: Zero-copy image/data sharing between processes
+- **Signal/Broker Pattern**: Pub/sub messaging between tasks
+- **Web Monitoring Dashboard**: Real-time HTTP-based monitoring UI
+- **Performance Metrics**: IPC/FUNC timing statistics with sliding window
+- **Auto-restart**: Automatic task recovery on failure
+- **JSON Configuration**: Flexible configuration with injection support
+
+## Installation
+
+```bash
+# Basic installation
+pip install py-alaska
+
+# With monitoring support (psutil)
+pip install py-alaska[monitor]
+
+# With camera/GUI support (PySide6)
+pip install py-alaska[camera]
+
+# Full installation
+pip install py-alaska[all]
+```
+
+## Quick Start
+
+### 1. Define a Task
+
+```python
+from py_alaska import TaskClass
+
+@TaskClass(name="my_task", mode="process", restart=True)
+class MyTask:
+    def __init__(self):
+        self.task = None  # Injected by framework
+        self.counter = 0
+
+    def increment(self, value: int) -> int:
+        """RMI method: can be called from other tasks"""
+        self.counter += value
+        return self.counter
+
+    def get_count(self) -> int:
+        """RMI method: query current count"""
+        return self.counter
+
+    def task_loop(self):
+        """Main loop: runs continuously"""
+        while not self.task.should_stop():
+            # Do work here
+            pass
+```
+
+### 2. Create Configuration (config.json)
+
+```json
+{
+    "app_info": {
+        "name": "MyApp",
+        "version": "1.0.0",
+        "id": "myapp_001"
+    },
+    "task_config": {
+        "_monitor": {
+            "port": 7000,
+            "exit_hook": true
+        },
+        "worker/my_task": {
+            "counter": 0
+        }
+    }
+}
+```
+
+### 3. Run the Application
+
+```python
+from py_alaska import TaskManager, gconfig
+import my_task  # Import to register TaskClass
+
+def main():
+    gconfig.load("config.json")
+
+    manager = TaskManager(gconfig)
+    manager.start_all()
+
+    # Access via RMI
+    worker = manager.get_client("worker")
+    result = worker.increment(10)
+    print(f"Counter: {result}")
+
+    # Web monitor at http://localhost:7000
+    import time
+    time.sleep(3600)
+
+    manager.stop_all()
+
+if __name__ == "__main__":
+    main()
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      TaskManager                            │
+├─────────────────────────────────────────────────────────────┤
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
+│  │   Task A    │  │   Task B    │  │   Task C    │         │
+│  │  (Process)  │  │  (Process)  │  │  (Thread)   │         │
+│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘         │
+│         │                │                │                 │
+│         └────────────────┼────────────────┘                 │
+│                          │                                  │
+│                    ┌─────┴─────┐                            │
+│                    │  RMI Bus  │                            │
+│                    │  (Queue)  │                            │
+│                    └─────┬─────┘                            │
+│                          │                                  │
+│                    ┌─────┴─────┐                            │
+│                    │  SmBlock  │                            │
+│                    │ (Shared)  │                            │
+│                    └───────────┘                            │
+├─────────────────────────────────────────────────────────────┤
+│                    TaskMonitor                              │
+│                  HTTP :7000                                 │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Core Components
+
+| Component | Description |
+|-----------|-------------|
+| `TaskManager` | Main orchestrator for all tasks |
+| `TaskClass` | Decorator to define a task |
+| `RmiClient` | Client for calling remote methods |
+| `SmBlock` | Shared memory block pool for zero-copy data sharing |
+| `Signal/SignalBroker` | Pub/sub messaging system |
+| `TaskMonitor` | HTTP-based web monitoring dashboard |
+| `GConfig` | Global configuration management |
+
+## API Reference
+
+### TaskClass Decorator
+
+```python
+@TaskClass(
+    name="task_name",      # Unique task identifier
+    mode="process",        # "process" or "thread"
+    restart=True,          # Auto-restart on failure
+    restart_delay=3.0,     # Delay before restart (seconds)
+)
+```
+
+### RMI Methods
+
+Any public method in a TaskClass becomes an RMI method:
+
+```python
+# In Task A
+def calculate(self, x: int, y: int) -> int:
+    return x + y
+
+# From Task B or main process
+client = manager.get_client("task_a")
+result = client.calculate(10, 20)  # Returns 30
+```
+
+### SmBlock (Shared Memory)
+
+```python
+# Configuration
+"_smblock": {
+    "image_pool": {"shape": [1024, 1024, 3], "maxsize": 100}
+}
+
+# In task
+index = self.smblock.malloc()      # Allocate block
+image = self.smblock.get(index)    # Get numpy array
+image[:] = frame                   # Write data
+self.smblock.mfree(index)          # Release block
+```
+
+## Monitoring
+
+Access the web dashboard at `http://localhost:7000` (configurable port).
+
+**Features:**
+- Real-time task status (alive/stopped)
+- RMI call statistics (count, timing)
+- CPU/Memory usage per task
+- SmBlock pool utilization
+- Configuration editor
+- Performance metrics (IPC/FUNC time)
+
+## Requirements
+
+- Python >= 3.8
+- numpy >= 1.20.0
+- psutil >= 5.8.0 (optional, for monitoring)
+- PySide6 >= 6.0.0 (optional, for camera/GUI)
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

py_alaska-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+py_alaska/SmBlock.py,sha256=pxnKHQmFqcFCZZQF-A__GBBKf4kus0VACdLfsA0Dm7M,10476
+py_alaska/__init__.py,sha256=q4_ibJZWWvtUD7d2vt9RrsmViLTO55X_A_nDf_o3I6c,3355
+py_alaska/div_logo.png,sha256=RKsuiBP7vFWBq1EEMrOEYkwuDzia3nuDMMDfKjzXUVI,26020
+py_alaska/gconfig.py,sha256=6MCnGcjNNEJAjZRMjO06wx67B8D7NBzlJYS9JrXMkJA,43544
+py_alaska/imi_camera.py,sha256=pPt6VTFqPD9U2YPABhalnsq9uFIV6iZkmJCvf8YQauM,15652
+py_alaska/tab_camera.py,sha256=6Rj9n2eMp6LHXTZ8bm0eyoMLkOJDi2eLvPEVYevt5D0,31126
+py_alaska/task_manager.py,sha256=gS6lY3A8g3Qhvk1maYaRPoQRpX-B9iXi_pJyuZP6wl0,28793
+py_alaska/task_monitor.py,sha256=8cFy6i0NxK7hOCePJ4QpuN38hDNL_ey8mtAaClKuyn8,78213
+py_alaska/task_performance.py,sha256=v11o2gOPt_rMKFIXe8qB7qCNRzILxCehvVytem6TWJs,22859
+py_alaska/task_signal.py,sha256=EHlShzxKW6lgpBZ5CSL7W221-Ja9P0o1i5mxaj94-MY,9771
+py_alaska-0.1.0.dist-info/licenses/LICENSE,sha256=wr6kC3HOkdD_s1IPebIBnK6ZnQyf7p-NtJrM_lK9LLk,1092
+py_alaska-0.1.0.dist-info/METADATA,sha256=xD6vBFWynTtgv6nvm6DD8m-YPzgMdZUhfD0FrQNmGOI,9369
+py_alaska-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+py_alaska-0.1.0.dist-info/top_level.txt,sha256=XIUr32XlSdVUarOxE-TaRvlKJitSLRJjqSsWRbw_wOg,10
+py_alaska-0.1.0.dist-info/RECORD,,

py_alaska-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

py_alaska-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DivisionVision
+
+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.

py_alaska-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+py_alaska