py-alaska 0.1.0__tar.gz

py_alaska-0.1.0/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/MANIFEST.in

@@ -0,0 +1,25 @@
+# Include documentation
+include LICENSE
+include README.md
+include requirements.txt
+
+# Include package data
+recursive-include src/py_alaska *.py *.png *.json
+
+# Exclude development files
+exclude .gitignore
+exclude .pre-commit-config.yaml
+recursive-exclude * __pycache__
+recursive-exclude * *.py[cod]
+recursive-exclude * *.so
+recursive-exclude * .DS_Store
+
+# Exclude test and example directories
+prune example
+prune doc
+prune tests
+prune .git
+prune .github
+prune dist
+prune build
+prune *.egg-info

py_alaska-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,222 @@
+# 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/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "py-alaska"
+version = "0.1.0"
+description = "ALASKA - Multiprocess Task Management Framework for Python"
+readme = "README.md"
+license = "MIT"
+authors = [
+    {name = "DivisionVision", email = "info@division.co.kr"}
+]
+maintainers = [
+    {name = "DivisionVision", email = "info@division.co.kr"}
+]
+requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: System :: Distributed Computing",
+]
+keywords = ["multiprocess", "task", "rmi", "ipc", "monitoring", "shared-memory"]
+
+dependencies = [
+    "numpy>=1.20.0",
+]
+
+[project.optional-dependencies]
+monitor = ["psutil>=5.8.0"]
+camera = ["PySide6>=6.0.0"]
+all = ["psutil>=5.8.0", "PySide6>=6.0.0"]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "build>=1.0.0",
+    "twine>=4.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/divisionvision/alaska"
+Documentation = "https://github.com/divisionvision/alaska#readme"
+Repository = "https://github.com/divisionvision/alaska.git"
+Issues = "https://github.com/divisionvision/alaska/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+py_alaska = ["*.png", "*.json"]

py_alaska-0.1.0/requirements.txt

@@ -0,0 +1,14 @@
+# ALASKA - Core Dependencies
+numpy>=1.20.0
+
+# Optional: Monitoring (install with: pip install alaska[monitor])
+# psutil>=5.8.0
+
+# Optional: Camera/GUI (install with: pip install alaska[camera])
+# PySide6>=6.0.0
+
+# Development Dependencies (install with: pip install alaska[dev])
+# pytest>=7.0.0
+# pytest-cov>=4.0.0
+# build>=1.0.0
+# twine>=4.0.0

py_alaska-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

py_alaska-0.1.0/setup.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+ALASKA - Multiprocess Task Management Framework
+
+Backward compatibility setup script.
+Configuration is in pyproject.toml (PEP 517/518).
+"""
+
+from setuptools import setup
+
+if __name__ == "__main__":
+    setup()