# Nedo Vision Worker Core
A powerful Python library for AI-powered computer vision processing in the Nedo Vision platform. This library provides real-time video processing, object detection, PPE compliance monitoring, and safety violation detection with an extensible callback system.
## Features
- **Real-time AI Detection**: Advanced PPE and safety compliance detection
- **Multi-stream Processing**: Handle multiple video sources simultaneously
- **Extensible Callbacks**: Event-driven architecture for detection handling
- **System Diagnostics**: Built-in health checking and troubleshooting
- **Database Integration**: Persistent storage for detections and configurations
- **Drawing Utilities**: Rich visualization tools for detections
- **GPU Acceleration**: CUDA support for optimal performance
- **RTMP Streaming**: Real-time video streaming capabilities
## Installation
### Basic Installation
Install the package from PyPI:
```bash
pip install nedo-vision-worker-core
```
### Installation with RF-DETR Support
RF-DETR is an optional dependency for advanced object detection. Install it separately:
```bash
# Install the main package
pip install nedo-vision-worker-core
```
### GPU Support
For GPU support with CUDA 12.1:
```bash
pip install nedo-vision-worker-core --extra-index-url https://download.pytorch.org/whl/cu121
```
### Development Installation
For development with all tools:
```bash
pip install nedo-vision-worker-core[dev]
```
## Quick Start
### Using the CLI
After installation, you can use the worker core CLI:
```bash
# Show CLI help
nedo-worker-core --help
# Run with default settings
nedo-worker-core run
# Run with custom configuration
nedo-worker-core run --log-level DEBUG --storage-path /data
# System health check
nedo-worker-core doctor
# Run with custom server configuration
nedo-worker-core run --storage-path /custom/storage --rtmp-server rtmp://server.com:1935/live
```
### Configuration Options
The service supports various configuration options:
- `--drawing-assets`: Path to drawing assets directory
- `--log-level`: Logging level (DEBUG|INFO|WARNING|ERROR)
- `--storage-path`: Storage path for databases and files
- `--rtmp-server`: RTMP server URL for video streaming
### Detection Callbacks
The worker core provides a unified callback system for handling detection events:
```python
from nedo_vision_worker_core import (
CoreService,
DetectionType,
CallbackTrigger,
DetectionData,
register_immediate_ppe_callback
)
def handle_ppe_detection(detection_data: DetectionData):
"""Handle PPE detection events."""
if detection_data.has_violations():
# Send alert for safety violations
send_safety_alert(
person_id=detection_data.person_id,
violations=[v.label for v in detection_data.get_violations()],
confidence=detection_data.confidence_score,
image_path=detection_data.image_path
)
# Log all detections for compliance tracking
log_detection_event(detection_data)
def handle_area_violation(detection_data: DetectionData):
"""Handle restricted area violations."""
# Immediate security response
trigger_security_alert(
location=detection_data.pipeline_id,
person_id=detection_data.person_id,
timestamp=detection_data.timestamp
)
# Quick registration
register_immediate_ppe_callback("safety_monitor", handle_ppe_detection)
# Advanced registration
CoreService.register_callback(
name="security_monitor",
callback=handle_area_violation,
trigger=CallbackTrigger.ON_NEW_DETECTION,
detection_types=[DetectionType.AREA_VIOLATION]
)
# Start processing
service = CoreService()
service.run()
```
### Advanced Usage
For interval-based monitoring and complex workflows:
```python
from nedo_vision_worker_core import (
register_interval_ppe_callback,
register_immediate_area_callback,
IntervalMetadata
)
def handle_ongoing_ppe_violations(detection_data: DetectionData):
"""Handle PPE violations that are currently active (called periodically while violations persist)."""
metadata = detection_data.get_interval_metadata()
if metadata:
# This callback is only triggered when there are active violations
current_violations = metadata['current_violation_state']
people_in_violation = metadata['unique_persons_in_violation']
# Take action for ongoing violations
if people_in_violation > 0:
# Escalate persistent violations
escalate_safety_violation(
pipeline_id=detection_data.pipeline_id,
violation_types=current_violations,
affected_count=people_in_violation,
state_time=metadata['state_timestamp']
)
# Continue monitoring until violations are resolved
log_ongoing_violation_state(detection_data, metadata)
def emergency_response(detection_data: DetectionData):
"""Handle immediate area violations."""
# Trigger immediate emergency protocols
emergency_alert = {
'alert_type': 'RESTRICTED_AREA_BREACH',
'location': detection_data.pipeline_id,
'person_id': detection_data.person_id,
'confidence': detection_data.confidence_score,
'timestamp': detection_data.timestamp,
'evidence_image': detection_data.image_path
}
# Send to security team
notify_security_team(emergency_alert)
# Log incident for investigation
log_security_incident(emergency_alert)
def handle_ongoing_area_violations(detection_data: DetectionData):
"""Handle area violations that are currently active (called periodically while violations persist)."""
metadata = detection_data.get_interval_metadata()
if metadata:
# This is called every X seconds while people are still in restricted areas
active_violations = metadata['total_active_violations']
if active_violations > 0:
# Continuous monitoring for ongoing security breaches
maintain_security_alert(
location=detection_data.pipeline_id,
ongoing_violations=active_violations,
duration_check=metadata['state_timestamp']
)
# Register immediate callbacks (triggered on each new detection)
register_immediate_area_callback("immediate_security", emergency_response)
# Register interval callbacks (triggered periodically ONLY when violations are currently active)
register_interval_ppe_callback("ongoing_ppe_monitor", handle_ongoing_ppe_violations, interval_seconds=30)
register_interval_area_callback("ongoing_area_monitor", handle_ongoing_area_violations, interval_seconds=15)
# Monitor multiple detection types with custom logic
def safety_coordinator(detection_data: DetectionData):
"""Coordinate safety responses across all detection types."""
if detection_data.detection_type == DetectionType.PPE_DETECTION:
handle_ppe_safety(detection_data)
elif detection_data.detection_type == DetectionType.AREA_VIOLATION:
handle_security_breach(detection_data)
CoreService.register_callback(
name="safety_coordinator",
callback=safety_coordinator,
trigger=CallbackTrigger.ON_NEW_DETECTION,
detection_types=[DetectionType.PPE_DETECTION, DetectionType.AREA_VIOLATION]
)
```
### Programmatic Usage
You can use the core service programmatically in your applications:
```python
from nedo_vision_worker_core import CoreService
# Basic usage - start the service with default settings
service = CoreService()
service.run()
# Custom configuration
service = CoreService(
log_level="INFO",
storage_path="./data"
)
service.run()
# With error handling
try:
service = CoreService(log_level="DEBUG")
service.run()
except KeyboardInterrupt:
print("Service stopped")
except Exception as e:
print(f"Error: {e}")
```
## Architecture
### Core Components
- **CoreService**: Main service orchestrator with callback management
- **Detection Pipeline**: AI model processing with PyTorch backend
- **Callback System**: Unified event handling with immediate and interval triggers
- **Resource Monitor**: System resource monitoring (GPU, CPU, memory)
- **Database Manager**: Persistent storage for detections and configurations
### Callback System
#### Trigger Types
- **`ON_NEW_DETECTION`**: Triggered immediately on each detection
- **`ON_VIOLATION_INTERVAL`**: Triggered periodically only when violations occur in the interval
#### Detection Types
- **`PPE_DETECTION`**: Personal Protective Equipment compliance
- **`AREA_VIOLATION`**: Restricted area violations
- **`GENERAL_DETECTION`**: All detection events
#### Data Structure
```python
class DetectionData:
detection_id: str
person_id: str
pipeline_id: str
detection_type: DetectionType
confidence_score: float
timestamp: datetime
image_path: str
metadata: dict
def get_violations(self) -> List[DetectionAttribute]
def get_compliance(self) -> List[DetectionAttribute]
def has_violations(self) -> bool
def get_interval_metadata(self) -> Optional[IntervalMetadata]
class IntervalMetadata(TypedDict):
state_timestamp: str # ISO format datetime of current state
total_active_violations: int # Current number of active violations
unique_persons_in_violation: int # Number of people currently in violation
current_violation_state: Dict[str, int] # Current violation types and counts
violation_summary: Dict[str, int] # violation_type -> count (deprecated, use current_violation_state)
total_violations: int # total violations in interval (deprecated, use total_active_violations)
violation_count_in_interval: int # violations in this specific interval
interval_start: str # ISO format datetime
interval_end: str # ISO format datetime
unique_persons: int # total unique persons in interval
```
#### API Methods
```python
# Core callback registration methods
CoreService.register_callback(name, callback, trigger, detection_types, interval_seconds)
CoreService.unregister_callback(name)
CoreService.list_callbacks()
# Convenience functions for common use cases
register_immediate_ppe_callback(name, callback)
register_immediate_area_callback(name, callback)
register_interval_ppe_callback(name, callback, interval_seconds)
register_interval_area_callback(name, callback, interval_seconds)
# Example: Managing callbacks programmatically
def setup_safety_monitoring():
"""Setup comprehensive safety monitoring system."""
# Register immediate response callbacks
register_immediate_ppe_callback("ppe_safety", handle_ppe_violations)
register_immediate_area_callback("area_security", handle_area_breaches)
# Register periodic reporting
register_interval_ppe_callback("hourly_report", generate_hourly_report, interval_seconds=3600)
# Verify registration
active_callbacks = CoreService.list_callbacks()
logging.info(f"Active monitoring: {len(active_callbacks)} callbacks registered")
return active_callbacks
# Cleanup callbacks when needed
def cleanup_monitoring():
"""Remove specific callbacks."""
CoreService.unregister_callback("ppe_safety")
CoreService.unregister_callback("area_security")
```
See [INSTALL.md](INSTALL.md) for detailed installation instructions.
## Troubleshooting
### Common Issues
1. **CUDA not detected**: Ensure NVIDIA drivers and CUDA toolkit are installed
2. **FFmpeg not found**: Install FFmpeg for video processing capabilities
3. **Permission errors**: Check storage directory permissions
4. **Model loading issues**: Verify model files and network connectivity
### Support
For issues and questions:
- Check the logs for detailed error information
- Run `nedo-worker-core doctor` for system diagnostics
- Verify all dependencies are properly installed
Raw data
{
"_id": null,
"home_page": null,
"name": "nedo-vision-worker-core",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": "Willy Achmat Fauzi <willy.achmat@gmail.com>",
"keywords": "computer-vision, machine-learning, ai, worker-core, deep-learning, object-detection, neural-networks, video-processing, pytorch, yolo",
"author": null,
"author_email": "Willy Achmat Fauzi <willy.achmat@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/3e/1a/6a8c9522a430812424bdf4e0c7479a78aefee0cb02a26d8bf3efc6a31881/nedo_vision_worker_core-0.3.7.tar.gz",
"platform": null,
"description": "# Nedo Vision Worker Core\n\nA powerful Python library for AI-powered computer vision processing in the Nedo Vision platform. This library provides real-time video processing, object detection, PPE compliance monitoring, and safety violation detection with an extensible callback system.\n\n## Features\n\n- **Real-time AI Detection**: Advanced PPE and safety compliance detection\n- **Multi-stream Processing**: Handle multiple video sources simultaneously\n- **Extensible Callbacks**: Event-driven architecture for detection handling\n- **System Diagnostics**: Built-in health checking and troubleshooting\n- **Database Integration**: Persistent storage for detections and configurations\n- **Drawing Utilities**: Rich visualization tools for detections\n- **GPU Acceleration**: CUDA support for optimal performance\n- **RTMP Streaming**: Real-time video streaming capabilities\n\n## Installation\n\n### Basic Installation\n\nInstall the package from PyPI:\n\n```bash\npip install nedo-vision-worker-core\n```\n\n### Installation with RF-DETR Support\n\nRF-DETR is an optional dependency for advanced object detection. Install it separately:\n\n```bash\n# Install the main package\npip install nedo-vision-worker-core\n```\n\n### GPU Support\n\nFor GPU support with CUDA 12.1:\n\n```bash\npip install nedo-vision-worker-core --extra-index-url https://download.pytorch.org/whl/cu121\n```\n\n### Development Installation\n\nFor development with all tools:\n\n```bash\npip install nedo-vision-worker-core[dev]\n```\n\n## Quick Start\n\n### Using the CLI\n\nAfter installation, you can use the worker core CLI:\n\n```bash\n# Show CLI help\nnedo-worker-core --help\n\n# Run with default settings\nnedo-worker-core run\n\n# Run with custom configuration\nnedo-worker-core run --log-level DEBUG --storage-path /data\n\n# System health check\nnedo-worker-core doctor\n\n# Run with custom server configuration\nnedo-worker-core run --storage-path /custom/storage --rtmp-server rtmp://server.com:1935/live\n```\n\n### Configuration Options\n\nThe service supports various configuration options:\n\n- `--drawing-assets`: Path to drawing assets directory\n- `--log-level`: Logging level (DEBUG|INFO|WARNING|ERROR)\n- `--storage-path`: Storage path for databases and files\n- `--rtmp-server`: RTMP server URL for video streaming\n\n### Detection Callbacks\n\nThe worker core provides a unified callback system for handling detection events:\n\n```python\nfrom nedo_vision_worker_core import (\n CoreService,\n DetectionType,\n CallbackTrigger,\n DetectionData,\n register_immediate_ppe_callback\n)\n\ndef handle_ppe_detection(detection_data: DetectionData):\n \"\"\"Handle PPE detection events.\"\"\"\n if detection_data.has_violations():\n # Send alert for safety violations\n send_safety_alert(\n person_id=detection_data.person_id,\n violations=[v.label for v in detection_data.get_violations()],\n confidence=detection_data.confidence_score,\n image_path=detection_data.image_path\n )\n\n # Log all detections for compliance tracking\n log_detection_event(detection_data)\n\ndef handle_area_violation(detection_data: DetectionData):\n \"\"\"Handle restricted area violations.\"\"\"\n # Immediate security response\n trigger_security_alert(\n location=detection_data.pipeline_id,\n person_id=detection_data.person_id,\n timestamp=detection_data.timestamp\n )\n\n# Quick registration\nregister_immediate_ppe_callback(\"safety_monitor\", handle_ppe_detection)\n\n# Advanced registration\nCoreService.register_callback(\n name=\"security_monitor\",\n callback=handle_area_violation,\n trigger=CallbackTrigger.ON_NEW_DETECTION,\n detection_types=[DetectionType.AREA_VIOLATION]\n)\n\n# Start processing\nservice = CoreService()\nservice.run()\n```\n\n### Advanced Usage\n\nFor interval-based monitoring and complex workflows:\n\n```python\nfrom nedo_vision_worker_core import (\n register_interval_ppe_callback,\n register_immediate_area_callback,\n IntervalMetadata\n)\n\ndef handle_ongoing_ppe_violations(detection_data: DetectionData):\n \"\"\"Handle PPE violations that are currently active (called periodically while violations persist).\"\"\"\n metadata = detection_data.get_interval_metadata()\n if metadata:\n # This callback is only triggered when there are active violations\n current_violations = metadata['current_violation_state']\n people_in_violation = metadata['unique_persons_in_violation']\n\n # Take action for ongoing violations\n if people_in_violation > 0:\n # Escalate persistent violations\n escalate_safety_violation(\n pipeline_id=detection_data.pipeline_id,\n violation_types=current_violations,\n affected_count=people_in_violation,\n state_time=metadata['state_timestamp']\n )\n\n # Continue monitoring until violations are resolved\n log_ongoing_violation_state(detection_data, metadata)\n\ndef emergency_response(detection_data: DetectionData):\n \"\"\"Handle immediate area violations.\"\"\"\n # Trigger immediate emergency protocols\n emergency_alert = {\n 'alert_type': 'RESTRICTED_AREA_BREACH',\n 'location': detection_data.pipeline_id,\n 'person_id': detection_data.person_id,\n 'confidence': detection_data.confidence_score,\n 'timestamp': detection_data.timestamp,\n 'evidence_image': detection_data.image_path\n }\n\n # Send to security team\n notify_security_team(emergency_alert)\n\n # Log incident for investigation\n log_security_incident(emergency_alert)\n\ndef handle_ongoing_area_violations(detection_data: DetectionData):\n \"\"\"Handle area violations that are currently active (called periodically while violations persist).\"\"\"\n metadata = detection_data.get_interval_metadata()\n if metadata:\n # This is called every X seconds while people are still in restricted areas\n active_violations = metadata['total_active_violations']\n\n if active_violations > 0:\n # Continuous monitoring for ongoing security breaches\n maintain_security_alert(\n location=detection_data.pipeline_id,\n ongoing_violations=active_violations,\n duration_check=metadata['state_timestamp']\n )\n\n# Register immediate callbacks (triggered on each new detection)\nregister_immediate_area_callback(\"immediate_security\", emergency_response)\n\n# Register interval callbacks (triggered periodically ONLY when violations are currently active)\nregister_interval_ppe_callback(\"ongoing_ppe_monitor\", handle_ongoing_ppe_violations, interval_seconds=30)\nregister_interval_area_callback(\"ongoing_area_monitor\", handle_ongoing_area_violations, interval_seconds=15)\n\n# Monitor multiple detection types with custom logic\ndef safety_coordinator(detection_data: DetectionData):\n \"\"\"Coordinate safety responses across all detection types.\"\"\"\n if detection_data.detection_type == DetectionType.PPE_DETECTION:\n handle_ppe_safety(detection_data)\n elif detection_data.detection_type == DetectionType.AREA_VIOLATION:\n handle_security_breach(detection_data)\n\nCoreService.register_callback(\n name=\"safety_coordinator\",\n callback=safety_coordinator,\n trigger=CallbackTrigger.ON_NEW_DETECTION,\n detection_types=[DetectionType.PPE_DETECTION, DetectionType.AREA_VIOLATION]\n)\n```\n\n### Programmatic Usage\n\nYou can use the core service programmatically in your applications:\n\n```python\nfrom nedo_vision_worker_core import CoreService\n\n# Basic usage - start the service with default settings\nservice = CoreService()\nservice.run()\n\n# Custom configuration\nservice = CoreService(\n log_level=\"INFO\",\n storage_path=\"./data\"\n)\nservice.run()\n\n# With error handling\ntry:\n service = CoreService(log_level=\"DEBUG\")\n service.run()\nexcept KeyboardInterrupt:\n print(\"Service stopped\")\nexcept Exception as e:\n print(f\"Error: {e}\")\n```\n\n## Architecture\n\n### Core Components\n\n- **CoreService**: Main service orchestrator with callback management\n- **Detection Pipeline**: AI model processing with PyTorch backend\n- **Callback System**: Unified event handling with immediate and interval triggers\n- **Resource Monitor**: System resource monitoring (GPU, CPU, memory)\n- **Database Manager**: Persistent storage for detections and configurations\n\n### Callback System\n\n#### Trigger Types\n\n- **`ON_NEW_DETECTION`**: Triggered immediately on each detection\n- **`ON_VIOLATION_INTERVAL`**: Triggered periodically only when violations occur in the interval\n\n#### Detection Types\n\n- **`PPE_DETECTION`**: Personal Protective Equipment compliance\n- **`AREA_VIOLATION`**: Restricted area violations\n- **`GENERAL_DETECTION`**: All detection events\n\n#### Data Structure\n\n```python\nclass DetectionData:\n detection_id: str\n person_id: str\n pipeline_id: str\n detection_type: DetectionType\n confidence_score: float\n timestamp: datetime\n image_path: str\n metadata: dict\n\n def get_violations(self) -> List[DetectionAttribute]\n def get_compliance(self) -> List[DetectionAttribute]\n def has_violations(self) -> bool\n def get_interval_metadata(self) -> Optional[IntervalMetadata]\n\nclass IntervalMetadata(TypedDict):\n state_timestamp: str # ISO format datetime of current state\n total_active_violations: int # Current number of active violations\n unique_persons_in_violation: int # Number of people currently in violation\n current_violation_state: Dict[str, int] # Current violation types and counts\n violation_summary: Dict[str, int] # violation_type -> count (deprecated, use current_violation_state)\n total_violations: int # total violations in interval (deprecated, use total_active_violations)\n violation_count_in_interval: int # violations in this specific interval\n interval_start: str # ISO format datetime\n interval_end: str # ISO format datetime\n unique_persons: int # total unique persons in interval\n```\n\n#### API Methods\n\n```python\n# Core callback registration methods\nCoreService.register_callback(name, callback, trigger, detection_types, interval_seconds)\nCoreService.unregister_callback(name)\nCoreService.list_callbacks()\n\n# Convenience functions for common use cases\nregister_immediate_ppe_callback(name, callback)\nregister_immediate_area_callback(name, callback)\nregister_interval_ppe_callback(name, callback, interval_seconds)\nregister_interval_area_callback(name, callback, interval_seconds)\n\n# Example: Managing callbacks programmatically\ndef setup_safety_monitoring():\n \"\"\"Setup comprehensive safety monitoring system.\"\"\"\n\n # Register immediate response callbacks\n register_immediate_ppe_callback(\"ppe_safety\", handle_ppe_violations)\n register_immediate_area_callback(\"area_security\", handle_area_breaches)\n\n # Register periodic reporting\n register_interval_ppe_callback(\"hourly_report\", generate_hourly_report, interval_seconds=3600)\n\n # Verify registration\n active_callbacks = CoreService.list_callbacks()\n logging.info(f\"Active monitoring: {len(active_callbacks)} callbacks registered\")\n\n return active_callbacks\n\n# Cleanup callbacks when needed\ndef cleanup_monitoring():\n \"\"\"Remove specific callbacks.\"\"\"\n CoreService.unregister_callback(\"ppe_safety\")\n CoreService.unregister_callback(\"area_security\")\n```\n\nSee [INSTALL.md](INSTALL.md) for detailed installation instructions.\n\n## Troubleshooting\n\n### Common Issues\n\n1. **CUDA not detected**: Ensure NVIDIA drivers and CUDA toolkit are installed\n2. **FFmpeg not found**: Install FFmpeg for video processing capabilities\n3. **Permission errors**: Check storage directory permissions\n4. **Model loading issues**: Verify model files and network connectivity\n\n### Support\n\nFor issues and questions:\n\n- Check the logs for detailed error information\n- Run `nedo-worker-core doctor` for system diagnostics\n- Verify all dependencies are properly installed\n",
"bugtrack_url": null,
"license": null,
"summary": "Nedo Vision Worker Core Library for AI Vision Processing",
"version": "0.3.7",
"project_urls": {
"Bug Reports": "https://gitlab.com/sindika/research/nedo-vision/nedo-vision-worker-core-v2/-/issues",
"Documentation": "https://gitlab.com/sindika/research/nedo-vision/nedo-vision-worker-core-v2/-/blob/main/README.md",
"Homepage": "https://gitlab.com/sindika/research/nedo-vision/nedo-vision-worker-core-v2",
"Repository": "https://gitlab.com/sindika/research/nedo-vision/nedo-vision-worker-core-v2"
},
"split_keywords": [
"computer-vision",
" machine-learning",
" ai",
" worker-core",
" deep-learning",
" object-detection",
" neural-networks",
" video-processing",
" pytorch",
" yolo"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "b5af2e2eaa8b5a644345ba97836070b1a77ff07e6afb77ec2e0909ae92bb3394",
"md5": "3f517f767a260e01078dd1ecee9e63d9",
"sha256": "526c4377bf1cd41d637b2293ec007495fbf666962801ad56eaa0c2d68b2f8c59"
},
"downloads": -1,
"filename": "nedo_vision_worker_core-0.3.7-py3-none-any.whl",
"has_sig": false,
"md5_digest": "3f517f767a260e01078dd1ecee9e63d9",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 218915,
"upload_time": "2025-10-23T08:48:06",
"upload_time_iso_8601": "2025-10-23T08:48:06.041252Z",
"url": "https://files.pythonhosted.org/packages/b5/af/2e2eaa8b5a644345ba97836070b1a77ff07e6afb77ec2e0909ae92bb3394/nedo_vision_worker_core-0.3.7-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "3e1a6a8c9522a430812424bdf4e0c7479a78aefee0cb02a26d8bf3efc6a31881",
"md5": "25f899d4dd10383709f21140b235a07f",
"sha256": "a439de631c530fbbddf9a70c1b011429b5e79e3fce3333a0eade767c14de49e0"
},
"downloads": -1,
"filename": "nedo_vision_worker_core-0.3.7.tar.gz",
"has_sig": false,
"md5_digest": "25f899d4dd10383709f21140b235a07f",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 188019,
"upload_time": "2025-10-23T08:48:09",
"upload_time_iso_8601": "2025-10-23T08:48:09.373464Z",
"url": "https://files.pythonhosted.org/packages/3e/1a/6a8c9522a430812424bdf4e0c7479a78aefee0cb02a26d8bf3efc6a31881/nedo_vision_worker_core-0.3.7.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-10-23 08:48:09",
"github": false,
"gitlab": true,
"bitbucket": false,
"codeberg": false,
"gitlab_user": "sindika",
"gitlab_project": "research",
"lcname": "nedo-vision-worker-core"
}
JSON