crazy-workers 0.1.0__py3-none-any.whl

crazy_workers/__init__.py

@@ -0,0 +1,5 @@
+from .core.manager import WorkerManager
+from .database.schema import WorkerStatus
+
+
+__all__ = ['WorkerManager', 'WorkerStatus']

crazy_workers/_bootstrap.py

@@ -0,0 +1,33 @@
+"""
+Thin launcher invoked by WorkerManager for every worker subprocess.
+Configures logging once so individual worker scripts don't have to.
+
+Invocation (managed internally by WorkerManager):
+    python -m crazy_workers._bootstrap <worker_path> <json_params>
+"""
+
+import logging
+import os
+import runpy
+import sys
+
+
+def main():
+  logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    stream=sys.stderr,
+    force=True,
+  )
+
+  # Restore sys.argv so the worker sees [worker_path, json_params]
+  sys.argv = sys.argv[1:]
+
+  worker_path = sys.argv[0]
+  sys.path.insert(0, os.path.dirname(os.path.abspath(worker_path)))
+
+  runpy.run_path(worker_path, run_name='__main__')
+
+
+if __name__ == '__main__':
+  main()

crazy_workers/cli/__init__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+
+__all__ = ['main']

crazy_workers/cli/commands/__init__.py

@@ -0,0 +1,8 @@
+from .lister import list_workers
+from .params import show_params
+from .restorer import restore_workers
+from .starter import start_worker
+from .stopper import stop_worker
+
+
+__all__ = ['list_workers', 'show_params', 'start_worker', 'stop_worker', 'restore_workers']

crazy_workers/cli/commands/lister.py

@@ -0,0 +1,57 @@
+import json
+from datetime import datetime
+from rich.table import Table
+
+from ..ui import console
+
+
+def list_workers(manager):
+  workers = manager.list_workers()
+  if not workers:
+    console().print('[yellow]No workers found in database.[/yellow]')
+    return []
+  else:
+    table = Table(
+      title='[bold cyan]Active & Registered Workers[/bold cyan]', border_style='cyan', header_style='bold magenta'
+    )
+    table.add_column('#', justify='right', style='dim')
+    table.add_column('Key', style='bold')
+    table.add_column('Type')
+    table.add_column('Status', justify='center')
+    table.add_column('PID', justify='right', style='green')
+    table.add_column('Last Action', justify='center')
+    table.add_column('Params', overflow='ellipsis')
+
+    for i, w in enumerate(workers, 1):
+      status = w['status']
+      status_style = 'green' if status == 'RUNNING' else 'yellow'
+      if status in ['CRASHED', 'FAILED']:
+        status_style = 'bold red'
+      elif status == 'STOPPED':
+        status_style = 'dim'
+      elif status == 'NEVER_STARTED':
+        status_style = 'cyan'
+
+      last_action = '-'
+      if status == 'RUNNING' and w.get('last_started_at'):
+        dt = datetime.fromisoformat(w['last_started_at'])
+        last_action = f'[green]Started {dt.strftime("%H:%M:%S")}[/green]'
+      elif w.get('last_stopped_at'):
+        dt = datetime.fromisoformat(w['last_stopped_at'])
+        last_action = f'[dim]Stopped {dt.strftime("%H:%M:%S")}[/dim]'
+
+      params_str = json.dumps(w['parameters']) if w['parameters'] else '-'
+      if len(params_str) > 30:
+        params_str = params_str[:27] + '...'
+
+      table.add_row(
+        str(i),
+        w['worker_key'] or '-',
+        w['worker_type'],
+        f'[{status_style}]{status}[/{status_style}]',
+        str(w['pid']) if w['pid'] else '-',
+        last_action,
+        params_str,
+      )
+    console().print(table)
+    return workers

crazy_workers/cli/commands/params.py

@@ -0,0 +1,37 @@
+import json
+from rich.prompt import IntPrompt
+
+from ..ui import console, err_console
+
+
+def show_params(manager, worker_key):
+
+  workers = manager.list_workers()
+  if not workers:
+    console().print('[yellow]No workers found.[/yellow]')
+    return False
+
+  if not worker_key:
+    # Interactive mode
+    active_workers = [w for w in workers if w['worker_key'] is not None]
+
+    if not active_workers:
+      console().print('[yellow]No registered workers to show parameters for.[/yellow]')
+      return False
+
+    console().print('\n[bold cyan]Select a worker to show parameters:[/bold cyan]')
+    for i, w in enumerate(active_workers, 1):
+      status_style = 'green' if w['status'] == 'RUNNING' else 'dim'
+      console().print(f'  [bold]{i})[/bold] {w["worker_key"]} [{status_style}]({w["status"]})[/{status_style}]')
+
+    choice = IntPrompt.ask('Enter the number', choices=[str(i) for i in range(1, len(active_workers) + 1)])
+    selected_worker = active_workers[choice - 1]
+  else:
+    selected_worker = next((w for w in workers if w['worker_key'] == worker_key), None)
+    if not selected_worker:
+      err_console().print(f'[bold red]Error:[/bold red] Worker {worker_key} not found')
+      return False
+
+  console().print(f'\n[bold cyan]Parameters for worker:[/bold cyan] {selected_worker["worker_key"]}')
+  console().print_json(json.dumps(selected_worker['parameters']))
+  return True

crazy_workers/cli/commands/restorer.py

@@ -0,0 +1,14 @@
+from ..ui import console
+
+
+def restore_workers(manager):
+  restarted = manager.recover_workers()
+
+  if restarted:
+    console().print(f'[bold green]Successfully restored {len(restarted)} workers:[/bold green]')
+    for key in restarted:
+      console().print(f'  - {key}')
+    return True
+  else:
+    console().print('[yellow]No workers needed restoration.[/yellow]')
+    return True

crazy_workers/cli/commands/starter.py

@@ -0,0 +1,36 @@
+import os
+from rich.prompt import IntPrompt
+
+from ..ui import console, err_console
+
+
+def start_worker(manager, worker_type, worker_key=None, parameters=None):
+
+  if not worker_type:
+    # Interactive mode: list .py files in workers_dir
+    try:
+      files = [f[:-3] for f in os.listdir(manager.workers_dir) if f.endswith('.py')]
+    except Exception as e:
+      err_console().print(f'[bold red]Error reading workers directory:[/bold red] {e}')
+      return False
+
+    if not files:
+      console().print(f'[yellow]No worker scripts found in {manager.workers_dir}[/yellow]')
+      return False
+
+    console().print('\n[bold cyan]Select a worker type to start:[/bold cyan]')
+    for i, f in enumerate(files, 1):
+      console().print(f'  [bold]{i})[/bold] {f}')
+
+    choice = IntPrompt.ask('Enter the number', choices=[str(i) for i in range(1, len(files) + 1)])
+    worker_type = files[choice - 1]
+
+  success, result = manager.start_worker(worker_type, worker_key=worker_key, parameters=parameters)
+  if success:
+    console().print('[bold green]Success:[/bold green] Worker started')
+    console().print(f'  [bold]Key:[/bold] {result["worker_key"]}')
+    console().print(f'  [bold]PID:[/bold] {result["pid"]}')
+  else:
+    err_console().print(f'[bold red]Error:[/bold red] {result}')
+    return False
+  return True

crazy_workers/cli/commands/stopper.py

@@ -0,0 +1,30 @@
+from rich.prompt import IntPrompt
+
+from ..ui import console, err_console
+
+
+def stop_worker(manager, worker_key):
+
+  if not worker_key:
+    # Interactive mode
+    workers = manager.list_workers()
+    running_workers = [w for w in workers if w['status'] == 'RUNNING']
+
+    if not running_workers:
+      console().print('[yellow]No running workers to stop.[/yellow]')
+      return False
+
+    console().print('\n[bold cyan]Select a worker to stop:[/bold cyan]')
+    for i, w in enumerate(running_workers, 1):
+      console().print(f'  [bold]{i})[/bold] {w["worker_key"]} [dim]({w["worker_type"]})[/dim]')
+
+    choice = IntPrompt.ask('Enter the number', choices=[str(i) for i in range(1, len(running_workers) + 1)])
+    worker_key = running_workers[choice - 1]['worker_key']
+
+  success, message = manager.stop_worker(worker_key)
+  if success:
+    console().print(f'[bold green]Success:[/bold green] {message}')
+  else:
+    err_console().print(f'[bold red]Error:[/bold red] {message}')
+    return False
+  return True

crazy_workers/cli/discovery.py

@@ -0,0 +1,93 @@
+import os
+import sys
+from rich.prompt import Prompt
+
+from .ui import console, err_console
+
+
+def load_env():
+  """Loads variables from .env file into os.environ."""
+  if not os.path.exists('.env'):
+    return
+  with open('.env', 'r') as f:
+    for line in f:
+      line = line.strip()
+      if not line or line.startswith('#'):
+        continue
+      if '=' in line:
+        key, value = line.split('=', 1)
+        os.environ.setdefault(key.strip(), value.strip().strip('"').strip("'"))
+
+
+def save_to_env(key, value):
+  """Saves a key-value pair to .env file, using an atomic write."""
+  lines = []
+  if os.path.exists('.env'):
+    with open('.env', 'r') as f:
+      lines = f.readlines()
+
+  found = False
+  new_line = f'{key}={value}\n'
+  for i, line in enumerate(lines):
+    if line.strip().startswith(f'{key}='):
+      lines[i] = new_line
+      found = True
+      break
+
+  if not found:
+    if lines and not lines[-1].endswith('\n'):
+      lines.append('\n')
+    lines.append(new_line)
+
+  tmp = '.env.tmp'
+  with open(tmp, 'w') as f:
+    f.writelines(lines)
+  os.replace(tmp, '.env')
+
+
+def resolve_workers_dir(flag_dir):
+  load_env()
+
+  # 1. Flag priority
+  if flag_dir:
+    if os.path.isdir(flag_dir):
+      return flag_dir
+    else:
+      err_console().print(f'[bold red]Error:[/bold red] Directory "{flag_dir}" does not exist.')
+      sys.exit(1)
+
+  # 2. Environment Variable
+  env_dir = os.environ.get('CRAZY_WORKERS_DIR')
+  if env_dir:
+    if os.path.isdir(env_dir):
+      return env_dir
+    else:
+      err_console().print(f'[bold red]Error:[/bold red] Directory "{env_dir}" (from CRAZY_WORKERS_DIR) does not exist.')
+      sys.exit(1)
+
+  # 3. Interactive Prompt
+  if sys.stdin.isatty():
+    console().print('[bold yellow]CRAZY_WORKERS_DIR not set in environment.[/bold yellow]')
+    user_input = Prompt.ask('Please enter the path to your workers directory')
+    if user_input:
+      if os.path.isdir(user_input):
+        abs_path = os.path.abspath(user_input)
+        try:
+          save_to_env('CRAZY_WORKERS_DIR', abs_path)
+          console().print(f'[bold green]Saved CRAZY_WORKERS_DIR={abs_path} to .env[/bold green]')
+        except Exception as e:
+          err_console().print(f'[bold red]Failed to save configuration:[/bold red] {e}')
+        return abs_path
+      else:
+        err_console().print(f'[bold red]Error:[/bold red] "{user_input}" is not a valid directory.')
+        sys.exit(1)
+
+  # 4. Fallback
+  if os.path.isdir('workers'):
+    return 'workers'
+
+  err_console().print(
+    '[bold red]Error:[/bold red] Workers directory not found. '
+    'Please provide it via --workers-dir or set CRAZY_WORKERS_DIR.'
+  )
+  sys.exit(1)

crazy_workers/cli/main.py

@@ -0,0 +1,85 @@
+import argparse
+import sys
+from rich.panel import Panel
+
+from ..core.manager import WorkerManager
+from .commands import list_workers, restore_workers, show_params, start_worker, stop_worker
+from .discovery import resolve_workers_dir
+from .ui import console, err_console
+
+
+def main():
+
+  def formatter(prog):
+    return argparse.HelpFormatter(prog, max_help_position=32)
+
+  parser = argparse.ArgumentParser(description='Crazy Workers CLI', formatter_class=formatter)
+  parser.add_argument('--workers-dir', help='Directory containing worker scripts')
+
+  subparsers = parser.add_subparsers(dest='command', help='Commands')
+
+  # List command
+  subparsers.add_parser('list', help='List all workers and their status')
+
+  # Start command
+  start_parser = subparsers.add_parser('start', help='Start a worker (interactive if type missing)')
+  start_parser.add_argument('worker_type', nargs='?', help='The type (filename) of worker to start')
+  start_parser.add_argument('--key', help='Optional custom key for the worker')
+  start_parser.add_argument('--params', help='JSON string of parameters for the worker')
+
+  # Stop command
+  stop_parser = subparsers.add_parser('stop', help='Stop a worker (interactive if key missing)')
+  stop_parser.add_argument('worker_key', nargs='?', help='The key of the worker to stop')
+
+  # Params command
+  params_parser = subparsers.add_parser('params', help='Show parameters for a worker')
+  params_parser.add_argument('worker_key', nargs='?', help='The key of the worker')
+
+  # Restore command
+  subparsers.add_parser('restore', help='Restore workers that should be running')
+
+  args = parser.parse_args()
+
+  if not args.command:
+    console().print(
+      Panel.fit(
+        '[bold cyan]Crazy Workers CLI[/bold cyan]\n[dim]Manage your background processes with ease[/dim]',
+        border_style='cyan',
+      )
+    )
+    parser.print_help()
+    sys.exit(1)
+
+  workers_dir = resolve_workers_dir(args.workers_dir)
+  try:
+    with WorkerManager(workers_dir, create_dir=False) as manager:
+      if args.command == 'list':
+        list_workers(manager)
+      elif args.command == 'start':
+        import json
+
+        params = None
+        if args.params:
+          try:
+            params = json.loads(args.params)
+          except json.JSONDecodeError:
+            err_console().print('[bold red]Error:[/bold red] Invalid JSON in --params')
+            sys.exit(1)
+
+        if not start_worker(manager, args.worker_type, worker_key=args.key, parameters=params):
+          sys.exit(1)
+      elif args.command == 'stop':
+        if not stop_worker(manager, args.worker_key):
+          sys.exit(1)
+      elif args.command == 'params':
+        if not show_params(manager, args.worker_key):
+          sys.exit(1)
+      elif args.command == 'restore':
+        restore_workers(manager)
+  except ValueError as e:
+    err_console().print(f'[bold red]Error:[/bold red] {e}')
+    sys.exit(1)
+
+
+if __name__ == '__main__':
+  main()

crazy_workers/cli/ui.py

@@ -0,0 +1,9 @@
+from rich.console import Console
+
+
+def console() -> Console:
+  return Console()
+
+
+def err_console() -> Console:
+  return Console(stderr=True)

crazy_workers/core/__init__.py

@@ -0,0 +1,4 @@
+from .manager import WorkerManager
+
+
+__all__ = ['WorkerManager']

crazy_workers/core/engine.py

@@ -0,0 +1,90 @@
+import logging
+import psutil
+import subprocess
+
+
+logger = logging.getLogger('crazy_workers')
+
+
+def get_running_process(pid):
+  """Returns a psutil.Process object if the PID exists and is not a zombie."""
+  if pid is None:
+    return None
+  try:
+    proc = psutil.Process(pid)
+    if proc.is_running() and proc.status() != psutil.STATUS_ZOMBIE:
+      return proc
+  except (psutil.NoSuchProcess, psutil.AccessDenied):
+    pass
+  return None
+
+
+def is_process_running(pid):
+  """Checks if a process is truly running. Very resilient."""
+  try:
+    return get_running_process(pid) is not None
+  except (psutil.Error, OSError):
+    return False
+
+
+def terminate_process(pid, timeout=5, popen_process=None, exclude_pids=None):
+  """Gracefully terminates a process and its non-managed children.
+
+  Children whose PIDs appear in exclude_pids are left alive — they are
+  independently managed workers that should outlive their parent.
+  Any other child process (raw subprocesses, shell helpers, etc.) is
+  terminated alongside the parent.
+  """
+  proc = get_running_process(pid)
+  if not proc:
+    return True
+
+  # Build the full exclusion set: each managed PID and all its descendants.
+  # This is necessary on platforms where a single logical worker spans more
+  # than one OS process (e.g. the Python launcher on Windows spawns the
+  # actual interpreter as a child).
+  excluded: set[int] = set(exclude_pids or [])
+  for mpid in list(excluded):
+    try:
+      for desc in psutil.Process(mpid).children(recursive=True):
+        excluded.add(desc.pid)
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+      pass
+
+  try:
+    # Snapshot descendant PIDs before killing the parent; the list becomes
+    # unavailable once the parent exits.
+    try:
+      children = [c for c in proc.children(recursive=True) if c.pid not in excluded]
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+      children = []
+
+    proc.terminate()
+    for child in children:
+      try:
+        child.terminate()
+      except (psutil.NoSuchProcess, psutil.AccessDenied):
+        pass
+
+    try:
+      if popen_process:
+        popen_process.wait(timeout=timeout)
+      else:
+        proc.wait(timeout=timeout)
+    except (psutil.TimeoutExpired, subprocess.TimeoutExpired):
+      if popen_process:
+        popen_process.kill()
+        popen_process.wait()
+      else:
+        proc.kill()
+      for child in children:
+        try:
+          if child.is_running():
+            child.kill()
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+          pass
+
+    return True
+  except Exception as e:
+    logger.error(f'Unexpected error terminating process {pid}: {e}')
+    raise

crazy_workers/core/manager/__init__.py

@@ -0,0 +1,89 @@
+import logging
+import os
+
+from ...database.storage import Storage
+from ..engine import is_process_running
+from ..recovery import RecoveryLock
+from .lister import list_workers
+from .recoverer import recover_workers
+from .starter import start_worker
+from .stopper import stop_worker
+
+
+logger = logging.getLogger('crazy_workers')
+
+
+class WorkerManager:
+  def __init__(self, workers_dir='workers', create_dir=True):
+    self.workers_dir = workers_dir
+    self._validate_workers_dir(create_dir)
+
+    self.service_dir = os.path.join(self.workers_dir, '.service')
+    self.logs_dir = os.path.join(self.service_dir, 'logs')
+    self.db_path = os.path.join(self.service_dir, 'workers.db')
+
+    self._initialize_storage(create_dir)
+    self._active_processes = {}  # worker_key -> Popen object
+
+  def __enter__(self):
+    return self
+
+  def __exit__(self, exc_type, exc_val, exc_tb):
+    self.dispose()
+
+  def _validate_workers_dir(self, create_dir):
+    """Checks if the workers directory exists and creates it if allowed."""
+    if not os.path.isdir(self.workers_dir):
+      if create_dir:
+        os.makedirs(self.workers_dir, exist_ok=True)
+      else:
+        raise ValueError(f'Workers directory "{self.workers_dir}" does not exist.')
+
+  def _initialize_storage(self, create_dir):
+    """Sets up service directories and storage if allowed or if they already exist."""
+    if create_dir:
+      os.makedirs(self.service_dir, exist_ok=True)
+      os.makedirs(self.logs_dir, exist_ok=True)
+      self.storage = Storage(self.db_path)
+    else:
+      # If not allowed to create, only initialize storage if the DB already exists
+      if os.path.exists(self.db_path):
+        self.storage = Storage(self.db_path)
+      else:
+        self.storage = None
+
+  def _is_process_running(self, pid):
+    """Internal wrapper for process check."""
+    return is_process_running(pid)
+
+  def start_worker(self, worker_type, worker_key=None, parameters=None, env=None):
+    return start_worker(self, worker_type, worker_key, parameters, env)
+
+  def stop_worker(self, worker_key):
+    return stop_worker(self, worker_key)
+
+  def list_workers(self):
+    return list_workers(self)
+
+  def recover_workers(self):
+    if not os.path.exists(self.service_dir):
+      return []
+
+    lock_path = f'{self.db_path}.recovery.lock'
+    lock = RecoveryLock(lock_path)
+
+    if lock.acquire():
+      try:
+        logger.info('Starting worker recovery process.')
+        return recover_workers(self)
+      finally:
+        lock.release()
+    else:
+      logger.debug('Recovery lock held by another process. Skipping.')
+      return []
+
+  def dispose(self):
+    """Clean up resources like database connections. Does NOT kill background processes."""
+    self._active_processes.clear()
+    if self.storage:
+      self.storage.dispose()

crazy_workers/core/manager/lister.py

@@ -0,0 +1,67 @@
+import logging
+import os
+
+from ...database.schema import Worker, WorkerStatus
+
+
+logger = logging.getLogger('crazy_workers')
+
+
+def list_workers(manager):
+  """Logic for listing workers, discovered and registered."""
+  # 1. Get all .py files from workers_dir
+  try:
+    available_types = {f[:-3] for f in os.listdir(manager.workers_dir) if f.endswith('.py') and f != '__init__.py'}
+  except Exception:
+    available_types = set()
+
+  if not manager.storage:
+    # If no storage, return virtual workers for all found files
+    return [
+      {
+        'worker_key': None,
+        'worker_type': t,
+        'parameters': {},
+        'pid': None,
+        'status': WorkerStatus.NEVER_STARTED.value,
+        'last_started_at': None,
+        'last_stopped_at': None,
+      }
+      for t in sorted(available_types)
+    ]
+
+  with manager.storage.session_scope() as session:
+    # 2. Get registered workers from DB
+    db_workers = session.query(Worker).all()
+    results = []
+
+    for worker in db_workers:
+      # Update status if dead
+      if worker.status == WorkerStatus.RUNNING:
+        if not manager._is_process_running(worker.pid):
+          logger.warning(
+            f'Worker {worker.worker_key} found in RUNNING state but PID {worker.pid} is dead. Updating status.'
+          )
+          worker.status = WorkerStatus.STOPPED
+          worker.pid = None
+      results.append(worker.to_dict())
+
+    # 3. Add virtual workers for files not in DB (using filename as key)
+    # Note: A file might be in DB multiple times with different keys,
+    # but here we only want to show types that have NEVER been started at all.
+    registered_types = {w['worker_type'] for w in results}
+    for w_type in sorted(available_types):
+      if w_type not in registered_types:
+        results.append(
+          {
+            'worker_key': None,
+            'worker_type': w_type,
+            'parameters': {},
+            'pid': None,
+            'status': WorkerStatus.NEVER_STARTED.value,
+            'last_started_at': None,
+            'last_stopped_at': None,
+          }
+        )
+
+    return results