crazy-workers 0.1.0__py3-none-any.whl

crazy_workers/core/manager/recoverer.py

@@ -0,0 +1,25 @@
+import logging
+
+from ...database.schema import Worker, WorkerStatus
+from ..engine import is_process_running
+
+
+logger = logging.getLogger('crazy_workers')
+
+
+def recover_workers(manager):
+  if not manager.storage:
+    return []
+
+  with manager.storage.session_scope() as session:
+    workers_to_restart = session.query(Worker).filter_by(status=WorkerStatus.RUNNING).all()
+    to_process = [(w.worker_key, w.worker_type, w.parameters, w.pid) for w in workers_to_restart]
+
+  restarted = []
+  for key, w_type, params, pid in to_process:
+    if not is_process_running(pid):
+      logger.info(f'Recovering worker {key}...')
+      success, _ = manager.start_worker(w_type, key, params)
+      if success:
+        restarted.append(key)
+  return restarted

crazy_workers/core/manager/starter.py

@@ -0,0 +1,137 @@
+import json
+import logging
+import os
+import subprocess
+import sys
+from sqlalchemy import func
+from sqlalchemy.exc import IntegrityError
+
+from ...database.schema import Worker, WorkerStatus
+
+
+logger = logging.getLogger('crazy_workers')
+
+
+def start_worker(manager, worker_type, worker_key=None, parameters=None, env=None):
+  if not manager.storage:
+    return False, 'System not initialized (database missing)'
+
+  worker_key = worker_key or worker_type
+  if not _validate_inputs(worker_type, worker_key):
+    return False, 'Invalid worker_type or worker_key'
+
+  parameters = parameters or {}
+  with manager.storage.session_scope() as session:
+    worker = session.query(Worker).filter_by(worker_key=worker_key).first()
+
+    if _check_already_running(manager, worker, session):
+      return False, 'Worker already running'
+
+    worker = _prepare_worker_record(worker, worker_type, worker_key, parameters, session)
+    if not worker:
+      return False, 'Worker state conflict (concurrent start)'
+
+    worker_path = _get_worker_script_path(manager, worker_type)
+    if not worker_path:
+      worker.status = WorkerStatus.STOPPED
+      return False, f'Worker file {worker_type}.py not found'
+
+    return _spawn_worker_process(manager, worker, worker_path, parameters, env, session)
+
+
+def _validate_inputs(worker_type, worker_key):
+  for name, val in [('worker_type', worker_type), ('worker_key', worker_key)]:
+    if '..' in val or os.path.isabs(val) or '/' in val or '\\' in val:
+      logger.error(f'Invalid {name}: {val}. Potential path traversal attempt.')
+      return False
+  return True
+
+
+def _check_already_running(manager, worker, session):
+  if worker and worker.status == WorkerStatus.RUNNING:
+    if manager._is_process_running(worker.pid):
+      logger.info(f'Worker {worker.worker_key} already running with PID {worker.pid}')
+      return True
+    else:
+      logger.warning(f'Worker {worker.worker_key} found in RUNNING state but PID {worker.pid} is dead. Cleaning up.')
+      worker.status = WorkerStatus.CRASHED
+      session.commit()
+  return False
+
+
+def _prepare_worker_record(worker, worker_type, worker_key, parameters, session):
+  if not worker:
+    worker = Worker(worker_key=worker_key, worker_type=worker_type, parameters=parameters)
+    session.add(worker)
+  else:
+    worker.worker_type = worker_type
+    worker.parameters = parameters
+    worker.status = WorkerStatus.STARTING
+
+  try:
+    session.commit()
+    return worker
+  except IntegrityError:
+    session.rollback()
+    logger.error(f'Concurrent start attempt for worker {worker_key}')
+    return None
+
+
+def _get_worker_script_path(manager, worker_type):
+  worker_filename = f'{worker_type}.py'
+  worker_path = os.path.join(manager.workers_dir, worker_filename)
+  if not os.path.exists(worker_path):
+    logger.error(f'Worker file {worker_filename} not found in {manager.workers_dir}')
+    return None
+  return worker_path
+
+
+def _spawn_worker_process(manager, worker, worker_path, parameters, env, session):
+  child_env = os.environ.copy()
+  if env:
+    child_env.update(env)
+
+  log_file_path = os.path.join(manager.logs_dir, f'{worker.worker_key}.log')
+  try:
+    log_fh = open(log_file_path, 'a')
+    logger.info(f'Worker {worker.worker_key} logging to {log_file_path}')
+  except Exception as e:
+    logger.error(f'Failed to open log file for worker {worker.worker_key}: {e}')
+    log_fh = None
+
+  # log_fh ownership is transferred to Popen; do NOT close it here.
+  stdout_dest = log_fh if log_fh else subprocess.DEVNULL
+  stderr_dest = log_fh if log_fh else subprocess.DEVNULL
+
+  process = subprocess.Popen(
+    [sys.executable, '-u', '-m', 'crazy_workers._bootstrap', worker_path, json.dumps(parameters)],
+    stdout=stdout_dest,
+    stderr=stderr_dest,
+    text=True,
+    env=child_env,
+  )
+
+  # Close our copy of the handle — Popen duplicated it via os.dup2 internally.
+  if log_fh:
+    log_fh.close()
+
+  try:
+    process.wait(timeout=0.05)
+    # If we reach here, it means the process exited immediately
+    logger.error(f'Worker {worker.worker_key} failed to start immediately (exit code: {process.returncode})')
+    worker.status = WorkerStatus.CRASHED
+    worker.pid = None
+    session.commit()
+    return False, 'Worker process failed to start'
+  except subprocess.TimeoutExpired:
+    # This is the expected case: the process is still running after the timeout
+    pass
+
+  worker.pid = process.pid
+  worker.status = WorkerStatus.RUNNING
+  worker.last_started_at = func.now()
+  session.commit()
+
+  manager._active_processes[worker.worker_key] = process
+  logger.info(f'Worker {worker.worker_key} started with PID {worker.pid}')
+  return True, worker.to_dict()

crazy_workers/core/manager/stopper.py

@@ -0,0 +1,58 @@
+import logging
+from sqlalchemy import func
+
+from ...database.schema import Worker, WorkerStatus
+from ..engine import terminate_process
+
+
+logger = logging.getLogger('crazy_workers')
+
+
+def stop_worker(manager, worker_key):
+  if not manager.storage:
+    return False, 'System not initialized (database missing)'
+
+  # Collect everything we need from the DB, then release the session before
+  # calling terminate_process (which can block for up to `timeout` seconds).
+  with manager.storage.session_scope() as session:
+    worker = session.query(Worker).filter_by(worker_key=worker_key).first()
+    if not worker:
+      return False, 'Worker not found'
+    if worker.status != WorkerStatus.RUNNING:
+      return False, 'Worker is not running'
+
+    pid = worker.pid
+    # PIDs of other managed workers — their processes must not be killed even
+    # if they happen to be child processes of the worker being stopped.
+    managed_pids = {
+      w.pid
+      for w in session.query(Worker)
+      .filter(
+        Worker.status == WorkerStatus.RUNNING,
+        Worker.worker_key != worker_key,
+        Worker.pid.isnot(None),
+      )
+      .all()
+    }
+
+  logger.info(f'Stopping worker {worker_key} (PID {pid})')
+  process = manager._active_processes.get(worker_key)
+
+  try:
+    terminate_process(pid, popen_process=process, exclude_pids=managed_pids)
+  except Exception as e:
+    logger.error(f'Error stopping worker {worker_key}: {e}')
+    return False, str(e)
+
+  if worker_key in manager._active_processes:
+    del manager._active_processes[worker_key]
+
+  with manager.storage.session_scope() as session:
+    worker = session.query(Worker).filter_by(worker_key=worker_key).first()
+    if worker:
+      worker.status = WorkerStatus.STOPPED
+      worker.pid = None
+      worker.last_stopped_at = func.now()
+
+  logger.info(f'Worker {worker_key} stopped.')
+  return True, 'Worker stopped'

crazy_workers/core/recovery.py

@@ -0,0 +1,68 @@
+import logging
+import os
+import psutil
+
+
+logger = logging.getLogger('crazy_workers')
+
+
+class RecoveryLock:
+  def __init__(self, path):
+    self.path = path
+
+  def acquire(self):
+    try:
+      fd = os.open(self.path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+      with os.fdopen(fd, 'w') as f:
+        f.write(str(os.getpid()))
+      return True
+    except FileExistsError:
+      return self._handle_existing_lock()
+
+  def release(self):
+    try:
+      os.remove(self.path)
+    except OSError:
+      pass
+
+  def _handle_existing_lock(self):
+    try:
+      with open(self.path, 'r') as f:
+        old_pid_str = f.read().strip()
+    except OSError:
+      return False
+
+    if not old_pid_str:
+      logger.warning('Found empty recovery lock. Breaking lock.')
+      return self._break_and_reacquire()
+
+    try:
+      old_pid = int(old_pid_str)
+    except ValueError:
+      logger.warning(f'Found invalid recovery lock content: "{old_pid_str}". Breaking lock.')
+      return self._break_and_reacquire()
+
+    try:
+      alive = psutil.pid_exists(old_pid)
+    except OSError:
+      return False
+
+    if not alive:
+      logger.warning(f'Found stale recovery lock from dead PID {old_pid}. Breaking lock.')
+      return self._break_and_reacquire()
+
+    return False
+
+  def _break_and_reacquire(self):
+    try:
+      os.remove(self.path)
+    except OSError:
+      return False
+    # Re-acquire once — if another process grabbed the lock in the meantime, give up.
+    try:
+      fd = os.open(self.path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+      with os.fdopen(fd, 'w') as f:
+        f.write(str(os.getpid()))
+      return True
+    except FileExistsError:
+      return False

crazy_workers/database/__init__.py

@@ -0,0 +1,5 @@
+from .schema import Worker, WorkerStatus
+from .storage import Storage
+
+
+__all__ = ['Worker', 'WorkerStatus', 'Storage']

crazy_workers/database/schema.py

@@ -0,0 +1,42 @@
+import enum
+from datetime import datetime
+from sqlalchemy import JSON, Column, DateTime, Enum, Integer, String, func
+from sqlalchemy.orm import DeclarativeBase
+
+
+class WorkerStatus(enum.Enum):
+  NEVER_STARTED = 'NEVER_STARTED'
+  STARTING = 'STARTING'
+  RUNNING = 'RUNNING'
+  STOPPED = 'STOPPED'
+  CRASHED = 'CRASHED'
+
+
+class Base(DeclarativeBase):
+  pass
+
+
+class Worker(Base):
+  __tablename__ = 'workers'
+
+  id = Column(Integer, primary_key=True)
+  worker_key = Column(String(255), unique=True, nullable=False)
+  worker_type = Column(String(255), nullable=False)  # Name of the .py file
+  parameters = Column(JSON, nullable=False, default={})
+  pid = Column(Integer, nullable=True)
+  status = Column(Enum(WorkerStatus), default=WorkerStatus.STOPPED)
+  last_started_at: datetime = Column(DateTime, nullable=True)
+  last_stopped_at: datetime = Column(DateTime, nullable=True)
+  created_at = Column(DateTime, server_default=func.now())
+  updated_at = Column(DateTime, onupdate=func.now())
+
+  def to_dict(self):
+    return {
+      'worker_key': self.worker_key,
+      'worker_type': self.worker_type,
+      'parameters': self.parameters,
+      'pid': self.pid,
+      'status': self.status.value,
+      'last_started_at': self.last_started_at.isoformat() if self.last_started_at else None,
+      'last_stopped_at': self.last_stopped_at.isoformat() if self.last_stopped_at else None,
+    }

crazy_workers/database/storage.py

@@ -0,0 +1,56 @@
+import logging
+from contextlib import contextmanager
+from sqlalchemy import create_engine, event
+from sqlalchemy.orm import sessionmaker
+
+from .schema import Base
+
+
+logger = logging.getLogger('crazy_workers')
+
+
+class Storage:
+  def __init__(self, db_path):
+    # sqlite:///path/to/db
+    self.db_path = db_path
+    self.engine = create_engine(f'sqlite:///{db_path}', connect_args={'timeout': 30})
+
+    @event.listens_for(self.engine, 'connect')
+    def set_sqlite_pragma(dbapi_connection, connection_record):
+      cursor = dbapi_connection.cursor()
+      cursor.execute('PRAGMA journal_mode=WAL')
+      cursor.close()
+
+    @event.listens_for(self.engine, 'begin')
+    def do_begin(conn):
+      conn.exec_driver_sql('BEGIN IMMEDIATE')
+
+    self.Session = sessionmaker(bind=self.engine)
+    self._ensure_tables()
+
+  def _ensure_tables(self):
+    """Initializes the database schema."""
+    self._create_tables()
+
+  def _create_tables(self):
+    logger.info(f'Creating tables for database at {self.db_path}')
+    Base.metadata.create_all(self.engine)
+
+  def get_session(self):
+    return self.Session()
+
+  @contextmanager
+  def session_scope(self):
+    """Provides a transactional scope around a series of operations."""
+    session = self.get_session()
+    try:
+      yield session
+      session.commit()
+    except Exception:
+      session.rollback()
+      raise
+    finally:
+      session.close()
+
+  def dispose(self):
+    self.engine.dispose()

crazy_workers-0.1.0.dist-info/METADATA

@@ -0,0 +1,247 @@
+Metadata-Version: 2.4
+Name: crazy-workers
+Version: 0.1.0
+Summary: A Python library for managing background worker processes with persistent state, automatic recovery, and a CLI.
+Author: GioVanni Colasanto
+License: MIT
+Project-URL: Homepage, https://github.com/Vanni-broUser/crazy-workers
+Project-URL: Bug Tracker, https://github.com/Vanni-broUser/crazy-workers/issues
+Project-URL: Source, https://github.com/Vanni-broUser/crazy-workers
+Keywords: workers,background,processes,process-manager,task-runner,cli,psutil
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: flask; extra == "dev"
+Dynamic: license-file
+
+# Crazy Workers
+
+A Python library for managing background worker processes with persistent state, automatic crash recovery, and a built-in CLI.
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## Features
+
+- **Persistent State** — SQLite database tracks worker status, PIDs, and parameters across restarts.
+- **Process Management** — Start, stop, and monitor background Python scripts as independent OS processes.
+- **Automatic Recovery** — Detects crashed workers and restarts them on application boot.
+- **Child Process Control** — On stop, terminates unmanaged subprocesses while preserving independently-managed nested workers.
+- **CLI Interface** — Manage workers from the terminal with interactive prompts and auto-discovery (see [CLI.md](CLI.md)).
+- **Security** — Built-in protection against path traversal in worker type and key names.
+- **Observability** — Per-worker file logging; all service files (DB, lock, logs) live in a `.service/` folder inside your workers directory.
+- **Zombie Protection** — Distinguishes active processes from zombies using `psutil`.
+- **Gunicorn-safe** — File-based lock prevents concurrent recovery runs across multiple workers.
+
+## Installation
+
+```bash
+pip install crazy-workers
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/Vanni-broUser/crazy-workers
+cd crazy-workers
+pip install .
+```
+
+## Quick Start
+
+### 1. Create a worker script
+
+```python
+# workers/my_worker.py
+import json, sys, time
+
+params = json.loads(sys.argv[1]) if len(sys.argv) > 1 else {}
+duration = params.get('duration', 60)
+
+for _ in range(duration):
+    time.sleep(1)
+```
+
+### 2. Manage it from Python
+
+```python
+from crazy_workers import WorkerManager
+
+manager = WorkerManager('workers')
+
+# Start
+success, result = manager.start_worker(
+    'my_worker',
+    worker_key='job_1',
+    parameters={'duration': 30},
+)
+print(result['pid'])   # OS process ID
+print(result['status'])  # 'RUNNING'
+
+# List
+for w in manager.list_workers():
+    print(w['worker_key'], w['status'])
+
+# Stop
+manager.stop_worker('job_1')
+
+# Recover crashed workers (call on app startup)
+restarted = manager.recover_workers()
+
+manager.dispose()  # releases DB connection; does NOT kill workers
+```
+
+### 3. Or from the CLI
+
+```bash
+crazy-workers list
+crazy-workers start my_worker --key job_1 --params '{"duration": 30}'
+crazy-workers stop job_1
+crazy-workers restore
+```
+
+See [CLI.md](CLI.md) for full CLI documentation.
+
+## API Reference
+
+### `WorkerManager(workers_dir, create_dir=True)`
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `workers_dir` | `str` | `'workers'` | Directory containing worker `.py` scripts |
+| `create_dir` | `bool` | `True` | Create `workers_dir` and `.service/` if they don't exist |
+
+### `start_worker(worker_type, worker_key=None, parameters=None, env=None)`
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `worker_type` | `str` | — | Filename (without `.py`) of the worker script |
+| `worker_key` | `str` | `worker_type` | Unique identifier; allows multiple instances of the same type |
+| `parameters` | `dict` | `{}` | JSON-serializable dict passed as `sys.argv[1]` to the worker |
+| `env` | `dict` | `None` | Extra environment variables injected into the worker process |
+
+Returns `(bool, dict | str)` — `(True, worker_dict)` on success, `(False, error_message)` on failure.
+
+### `stop_worker(worker_key)`
+
+Gracefully terminates the worker (SIGTERM → SIGKILL after timeout). Returns `(bool, str)`.
+
+### `list_workers()`
+
+Returns a list of worker dicts including RUNNING, STOPPED, CRASHED, and NEVER_STARTED (filesystem-discovered) workers.
+
+### `recover_workers()`
+
+Restarts any worker whose DB status is RUNNING but whose process is dead. Uses a file lock to prevent concurrent recovery. Returns a list of restarted keys.
+
+### `dispose()`
+
+Closes the database connection and clears internal process references. Does **not** kill background workers — they continue running independently.
+
+## Worker Script Contract
+
+A worker receives its parameters as a JSON string in `sys.argv[1]`:
+
+```python
+import json, sys
+
+params = json.loads(sys.argv[1]) if len(sys.argv) > 1 else {}
+# ... do work ...
+```
+
+## Project Structure
+
+```
+crazy_workers/       # Library package
+  core/              # WorkerManager, process engine, recovery lock
+  cli/               # CLI entry point, commands, discovery
+  database/          # SQLAlchemy schema and SQLite storage
+example_app/         # Flask demo application
+  app.py
+  workers/           # Example worker scripts
+tests/
+  core/              # Unit tests for core modules
+  cli/               # Unit tests for CLI modules
+  database/          # Unit tests for storage layer
+  integration/       # Full-stack integration tests (real processes)
+  app/               # Tests for the example Flask app
+```
+
+## Flask Integration
+
+```python
+from crazy_workers import WorkerManager
+
+def create_app():
+    app = Flask(__name__)
+    manager = WorkerManager('workers')
+
+    @app.route('/workers/start', methods=['POST'])
+    def start():
+        data = request.json
+        success, result = manager.start_worker(
+            data['worker_type'],
+            worker_key=data.get('worker_key'),
+            parameters=data.get('parameters', {}),
+        )
+        return (jsonify(result), 200) if success else (jsonify({'error': result}), 400)
+
+    manager.recover_workers()  # restart any crashed workers on boot
+    return app
+```
+
+See `example_app/app.py` for a complete example.
+
+## Gunicorn / Multi-Process Servers
+
+When using a pre-fork server like Gunicorn:
+
+- **Recovery is atomic** — a file lock (`.service/workers.db.recovery.lock`) ensures `recover_workers()` runs once even when multiple workers boot simultaneously.
+- **Workers outlive their parent** — if a Gunicorn worker is recycled, background processes keep running. The next recovery cycle re-attaches or restarts them.
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/Vanni-broUser/crazy-workers
+cd crazy-workers
+pip install -e .[dev]
+```
+
+### Commands
+
+```bash
+# Lint and format
+ruff check . --fix && ruff format .
+
+# Run tests
+pytest
+
+# Run tests with coverage
+coverage run -m pytest && coverage report
+```
+
+### Standards
+
+See [AI.md](AI.md) for the full coding and testing standards used in this project.
+

crazy_workers-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+crazy_workers/__init__.py,sha256=E-P1e5BIOUQBNtFy3kJ329eglZhMmD-qS6RTpipOHUs,128
+crazy_workers/_bootstrap.py,sha256=jWG6fvnQ6InfzfrqbyDJsqUaNwOAw9jFuSeWswccnVk,753
+crazy_workers/cli/__init__.py,sha256=lySqDljKE4Rt0heEH8gh7Kd3x2MYlwm1hMil8HiUuCo,44
+crazy_workers/cli/discovery.py,sha256=utpaJnsvHK9wZsve4bTOsmAIjFcufkwkBoc93b5tgMI,2653
+crazy_workers/cli/main.py,sha256=woOdKkQE0qJvv8oUMiqBOxQ3Sh7JYF8yrtZ5Ri45yV0,2942
+crazy_workers/cli/ui.py,sha256=-6s-O1LNPOGeLyFZl9-XsA2w6fdzdbgf8yf_7ykA600,142
+crazy_workers/cli/commands/__init__.py,sha256=owAZyn-BXrJB_FzAMTnSpwA0JDxkiXfrq14JpcfOBok,264
+crazy_workers/cli/commands/lister.py,sha256=mAmf2z8OoOlSHFU4eEnn1RAXJF0GQzFTsDpm8OxMHY0,1913
+crazy_workers/cli/commands/params.py,sha256=DtAz0tdVj1USJMcEr3jSZEqpeeRE2vmedcYhYh0F5iY,1391
+crazy_workers/cli/commands/restorer.py,sha256=OWo0r-DeUBEIAjCaYUDNrWtgV-Mrr9BlBsNK737QdDk,384
+crazy_workers/cli/commands/starter.py,sha256=Nvxmzm20XN33QKPK0ZEGlWNHfzWBPHBKlZLK7HBxuFI,1315
+crazy_workers/cli/commands/stopper.py,sha256=kS4w9yOXG5-qr58p36WcnmpY3iqt-BcKw7Of1_vRFjg,1011
+crazy_workers/core/__init__.py,sha256=22cwXOaOtqyo2YFofcBI6rXnVcO98W2SOt_qZBrmBVI,65
+crazy_workers/core/engine.py,sha256=tGUwqiyTOHm4pvD1oXofoEss8isrrAgoJErWFTQeXR8,2659
+crazy_workers/core/recovery.py,sha256=o7GHWtUCTtOt7L-hVJA75BED93oVNKuXOvae04BnvsE,1665
+crazy_workers/core/manager/__init__.py,sha256=XVGXygXs0X1uj0V-HEe7QUh9b15IBBkkfwxH61XcV9Y,2792
+crazy_workers/core/manager/lister.py,sha256=dLpONofDpZT5BmlpkV48Mqvq1BpPhkZylvCz4LJtFM4,2091
+crazy_workers/core/manager/recoverer.py,sha256=wFdl6K1qCjLWFrQXhdE143esIqLOvZhi-3o0hsySRHI,745
+crazy_workers/core/manager/starter.py,sha256=spUBtLUN_v3HVJfZMknt5aHrDaJLgG0-4KhAXEe1H2g,4651
+crazy_workers/core/manager/stopper.py,sha256=gYnJT_VHon2FM9EU0ZW3AzSnDWThVeP8wrU2-PXuJFk,1879
+crazy_workers/database/__init__.py,sha256=hggJ9S84uhCofJm3YNYJJzGpp6LAr9v6y6bLnFV_vF0,120
+crazy_workers/database/schema.py,sha256=S4vrjdSaKF_NkqLcMJtNWUtTA12kaYv6Gq5_DLZFOgY,1384
+crazy_workers/database/storage.py,sha256=0qd3EFqCxTe9KDEscsvYw84KZyhUE5ZhjRsIyp78L70,1445
+crazy_workers-0.1.0.dist-info/licenses/LICENSE,sha256=_rtyiMzX9GiLWkxcFJALIyiQ2SkCNKyjFakhn1z1m_U,1062
+crazy_workers-0.1.0.dist-info/METADATA,sha256=tKb5fNr0ntZPmxeWSLT1eb47Dbd99Ku-BdxrbFyazlI,7984
+crazy_workers-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+crazy_workers-0.1.0.dist-info/entry_points.txt,sha256=UzmFuEpQGyNASJY1q1GRsW2mvPJumngWSPKWsJFzAYA,57
+crazy_workers-0.1.0.dist-info/top_level.txt,sha256=0J_jqq2xxlzP1cEmhpvJYCkVTI2OnoZEzLDPZjFn_cc,14
+crazy_workers-0.1.0.dist-info/RECORD,,

crazy_workers-0.1.0.dist-info/WHEEL

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

crazy_workers-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+crazy-workers = crazy_workers.cli:main