rundown-workers 0.1.0__tar.gz

rundown_workers-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: rundown-workers
+Version: 0.1.0
+Summary: Lightweight workflow executor SDK for Python
+Author-email: Ernest <ernestdior5050@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/its-ernest/rundown-workers
+Project-URL: Bug Tracker, https://github.com/its-ernest/rundown-workers/issues
+Project-URL: Documentation, https://github.com/its-ernest/rundown-workers/blob/main/sdk/python/README.md
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+
+# Rundown-Workers Python SDK (v0.1.0)
+
+[![Go Coverage](https://img.shields.io/badge/coverage-80%25-brightgreen)](https://github.com/its-ernest/rundown-workers)
+
+A highly developer-friendly, lightweight Python SDK for implementing and running workflow workers.
+
+## Installation
+
+To install the SDK locally in editable mode (during development):
+
+```bash
+# From the project root
+pip install -e sdk/python
+```
+
+## Basic Usage
+
+The SDK uses decorators to register worker functions.
+
+```python
+import rundown_workers as rw
+
+# Register a simple task
+@rw.queue(name="greetings", max_retries=3)
+def hello_task(payload):
+    print(f"[*] Received: {payload}")
+    return True
+
+if __name__ == "__main__":
+    # Start all registered workers in separate polling threads
+    rw.run()
+```
+
+### Advanced Features
+
+#### 1. Retries with Exponential Backoff
+When enqueuing a job or defining a queue, you can specify `max_retries`. If your function raises an exception, the engine will automatically reschedule the job with an increasing delay (e.g., 5s, 20s, 45s).
+
+#### 2. Local Timeout Enforcement
+You can set a `timeout` (in seconds) for each task. If your function hangs beyond this period, the worker will automatically:
+1. Detect the timeout.
+2. Report the failure to the engine.
+3. Move on to the next available job.
+
+```python
+# This task will fail if it takes longer than 2 seconds
+rw.enqueue(queue="greetings", payload="Hello!", timeout=2)
+```
+
+## Internal Architecture
+
+The Python SDK uses `threading` to handle local polling for multiple queues simultaneously and to monitor task execution times.
+
+- **Polling Loop**: Each queue has its own daemon thread continuously hitting the `/poll` endpoint.
+- **Task Execution**: Handlers are executed in a temporary thread with a `join(timeout=...)` call to ensure the worker process doesn't hang.

rundown_workers-0.1.0/README.md

@@ -0,0 +1,55 @@
+# Rundown-Workers Python SDK (v0.1.0)
+
+[![Go Coverage](https://img.shields.io/badge/coverage-80%25-brightgreen)](https://github.com/its-ernest/rundown-workers)
+
+A highly developer-friendly, lightweight Python SDK for implementing and running workflow workers.
+
+## Installation
+
+To install the SDK locally in editable mode (during development):
+
+```bash
+# From the project root
+pip install -e sdk/python
+```
+
+## Basic Usage
+
+The SDK uses decorators to register worker functions.
+
+```python
+import rundown_workers as rw
+
+# Register a simple task
+@rw.queue(name="greetings", max_retries=3)
+def hello_task(payload):
+    print(f"[*] Received: {payload}")
+    return True
+
+if __name__ == "__main__":
+    # Start all registered workers in separate polling threads
+    rw.run()
+```
+
+### Advanced Features
+
+#### 1. Retries with Exponential Backoff
+When enqueuing a job or defining a queue, you can specify `max_retries`. If your function raises an exception, the engine will automatically reschedule the job with an increasing delay (e.g., 5s, 20s, 45s).
+
+#### 2. Local Timeout Enforcement
+You can set a `timeout` (in seconds) for each task. If your function hangs beyond this period, the worker will automatically:
+1. Detect the timeout.
+2. Report the failure to the engine.
+3. Move on to the next available job.
+
+```python
+# This task will fail if it takes longer than 2 seconds
+rw.enqueue(queue="greetings", payload="Hello!", timeout=2)
+```
+
+## Internal Architecture
+
+The Python SDK uses `threading` to handle local polling for multiple queues simultaneously and to monitor task execution times.
+
+- **Polling Loop**: Each queue has its own daemon thread continuously hitting the `/poll` endpoint.
+- **Task Execution**: Handlers are executed in a temporary thread with a `join(timeout=...)` call to ensure the worker process doesn't hang.

rundown_workers-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rundown-workers"
+version = "0.1.0"
+description = "Lightweight workflow executor SDK for Python"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "Ernest", email = "ernestdior5050@gmail.com" }
+]
+dependencies = [
+    "requests",
+]
+requires-python = ">=3.7"
+
+[project.urls]
+"Homepage" = "https://github.com/its-ernest/rundown-workers"
+"Bug Tracker" = "https://github.com/its-ernest/rundown-workers/issues"
+"Documentation" = "https://github.com/its-ernest/rundown-workers/blob/main/sdk/python/README.md"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["rundown_workers*"]

rundown_workers-0.1.0/rundown_workers/__init__.py

@@ -0,0 +1,54 @@
+from .client import Client
+import functools
+import sys
+import signal
+import threading
+import time
+
+# Global list of workers to start
+_workers = []
+
+def queue(name, host="http://localhost:8181", poll_interval=1.0, max_retries=3):
+	def decorator(func):
+		_workers.append((name, host, func, poll_interval, max_retries))
+		
+		@functools.wraps(func)
+		def wrapper(payload):
+			return func(payload)
+		return wrapper
+	return decorator
+
+def enqueue(queue, payload, host="http://localhost:8181", timeout=None, max_retries=None):
+	"""Submit a job to a queue."""
+	client = Client(host=host)
+	return client.enqueue(queue, payload, timeout=timeout, max_retries=max_retries)
+
+def run():
+	"""Main entry point to start all decorated workers."""
+	if not _workers:
+		print("[!] No workers registered. Use @rw.queue to register functions.")
+		return
+
+	# Handle graceful shutdown (Ctrl+C)
+	def signal_handler(sig, frame):
+		print("\n[*] Rundown-Workers worker stopped.")
+		sys.exit(0)
+	signal.signal(signal.SIGINT, signal_handler)
+
+	# Start each worker in a separate polling thread
+	threads = []
+	for worker_info in _workers:
+		queue_name, host, handler, interval, max_retries = worker_info
+		client = Client(host=host)
+		
+		t = threading.Thread(
+			target=client.start_worker, 
+			args=(queue_name, handler, interval),
+			daemon=True
+		)
+		t.start()
+		threads.append(t)
+	
+	# Keep main thread alive
+	while True:
+		time.sleep(1)

rundown_workers-0.1.0/rundown_workers/client.py

@@ -0,0 +1,105 @@
+import requests
+import time
+import threading
+
+class Client:
+	def __init__(self, host="http://localhost:8181"):
+		self.host = host
+
+	def enqueue(self, queue, payload, timeout=None, max_retries=None):
+		"""
+		Submits a new task to the Rundown-Workers engine.
+
+		:param queue: The name of the queue to join.
+		:param payload: The data content of the job.
+		:param timeout: Optional override for the execution time limit (in seconds).
+		:param max_retries: Optional override for the maximum retry count.
+		"""
+		url = f"{self.host}/enqueue"
+		data = {"queue": queue, "payload": payload}
+		if timeout:
+			data["timeout"] = timeout
+		if max_retries is not None:
+			data["max_retries"] = max_retries
+		resp = requests.post(url, json=data)
+		resp.raise_for_status()
+		return resp.json()
+
+	def poll(self, queue):
+		url = f"{self.host}/poll"
+		data = {"queue": queue}
+		resp = requests.post(url, json=data)
+		if resp.status_code == 204:
+			return None
+		resp.raise_for_status()
+		return resp.json()
+
+	def complete(self, job_id):
+		url = f"{self.host}/complete"
+		data = {"id": job_id}
+		resp = requests.post(url, json=data)
+		resp.raise_for_status()
+
+	def fail(self, job_id):
+		url = f"{self.host}/fail"
+		data = {"id": job_id}
+		resp = requests.post(url, json=data)
+		resp.raise_for_status()
+
+	def start_worker(self, queue_name, handler, poll_interval=1.0):
+		"""
+		Starts a continuous polling loop for a specific queue.
+
+		This method supports thread-safe local execution and will automatically
+		fail jobs if they exceed their timeout limit.
+		"""
+		print(f"[*] Starting worker for queue '{queue_name}'...")
+		while True:
+			try:
+				job = self.poll(queue_name)
+				if not job:
+					time.sleep(poll_interval)
+					continue
+
+				print(f"[*] Job {job['id']} assigned. Executing...")
+				
+				# Get timeout from job (default 300s)
+				job_timeout = job.get('timeout', 300)
+				
+				# Container for thread results
+				# [success, error_message]
+				state = [False, ""]
+				
+				def run_handler():
+					try:
+						handler(job['payload'])
+						state[0] = True
+					except Exception as e:
+						state[1] = str(e)
+
+				task_thread = threading.Thread(target=run_handler, daemon=True)
+				task_thread.start()
+				task_thread.join(timeout=job_timeout)
+
+				if task_thread.is_alive():
+					print(f"[!] Job {job['id']} timed out after {job_timeout}s.")
+					try:
+						self.fail(job['id'])
+					except Exception as fe:
+						print(f"[!] Error reporting timeout: {fe}")
+				elif state[0]:
+					try:
+						self.complete(job['id'])
+						print(f"[*] Job {job['id']} completed successfully.")
+					except Exception as ce:
+						print(f"[!] Error reporting completion: {ce}")
+				else:
+					print(f"[!] Job {job['id']} failed: {state[1]}")
+					try:
+						self.fail(job['id'])
+					except Exception as fe:
+						print(f"[!] Error reporting failure: {fe}")
+
+			except Exception as e:
+				print(f"[!] Worker polling error: {e}")
+				time.sleep(5)

rundown_workers-0.1.0/rundown_workers.egg-info/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: rundown-workers
+Version: 0.1.0
+Summary: Lightweight workflow executor SDK for Python
+Author-email: Ernest <ernestdior5050@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/its-ernest/rundown-workers
+Project-URL: Bug Tracker, https://github.com/its-ernest/rundown-workers/issues
+Project-URL: Documentation, https://github.com/its-ernest/rundown-workers/blob/main/sdk/python/README.md
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+
+# Rundown-Workers Python SDK (v0.1.0)
+
+[![Go Coverage](https://img.shields.io/badge/coverage-80%25-brightgreen)](https://github.com/its-ernest/rundown-workers)
+
+A highly developer-friendly, lightweight Python SDK for implementing and running workflow workers.
+
+## Installation
+
+To install the SDK locally in editable mode (during development):
+
+```bash
+# From the project root
+pip install -e sdk/python
+```
+
+## Basic Usage
+
+The SDK uses decorators to register worker functions.
+
+```python
+import rundown_workers as rw
+
+# Register a simple task
+@rw.queue(name="greetings", max_retries=3)
+def hello_task(payload):
+    print(f"[*] Received: {payload}")
+    return True
+
+if __name__ == "__main__":
+    # Start all registered workers in separate polling threads
+    rw.run()
+```
+
+### Advanced Features
+
+#### 1. Retries with Exponential Backoff
+When enqueuing a job or defining a queue, you can specify `max_retries`. If your function raises an exception, the engine will automatically reschedule the job with an increasing delay (e.g., 5s, 20s, 45s).
+
+#### 2. Local Timeout Enforcement
+You can set a `timeout` (in seconds) for each task. If your function hangs beyond this period, the worker will automatically:
+1. Detect the timeout.
+2. Report the failure to the engine.
+3. Move on to the next available job.
+
+```python
+# This task will fail if it takes longer than 2 seconds
+rw.enqueue(queue="greetings", payload="Hello!", timeout=2)
+```
+
+## Internal Architecture
+
+The Python SDK uses `threading` to handle local polling for multiple queues simultaneously and to monitor task execution times.
+
+- **Polling Loop**: Each queue has its own daemon thread continuously hitting the `/poll` endpoint.
+- **Task Execution**: Handlers are executed in a temporary thread with a `join(timeout=...)` call to ensure the worker process doesn't hang.

rundown_workers-0.1.0/rundown_workers.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+rundown_workers/__init__.py
+rundown_workers/client.py
+rundown_workers.egg-info/PKG-INFO
+rundown_workers.egg-info/SOURCES.txt
+rundown_workers.egg-info/dependency_links.txt
+rundown_workers.egg-info/requires.txt
+rundown_workers.egg-info/top_level.txt

rundown_workers-0.1.0/rundown_workers.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rundown_workers-0.1.0/rundown_workers.egg-info/requires.txt

@@ -0,0 +1 @@
+requests

rundown_workers-0.1.0/rundown_workers.egg-info/top_level.txt

@@ -0,0 +1 @@
+rundown_workers

rundown_workers-0.1.0/setup.cfg

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