crazy-workers 1.2.0__tar.gz → 1.3.0__tar.gz

{crazy_workers-1.2.0 → crazy_workers-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crazy-workers
-Version: 1.2.0
+Version: 1.3.0
 Summary: A Python library for managing background worker processes with persistent state, automatic recovery, and a CLI.
 Author: GioVanni Colasanto
 License: MIT
@@ -139,8 +139,9 @@ See [CLI.md](https://github.com/Vanni-broUser/crazy-workers/blob/main/CLI.md) fo
 | `engine` | `Engine` | `None` | Reuse an existing SQLAlchemy engine so the tables live in your database; **not** disposed by crazy_workers |
 | `worker_env` | `dict` | `None` | Environment variables injected into **every** spawned worker (e.g. `DATABASE_URL`) |
 | `auto_recover` | `bool` | `True` | Recover dead-but-`RUNNING` workers when the manager is constructed |
+| `create_tables` | `bool` | `True` | Create crazy_workers' own tables on init; set `False` when the host owns the schema via its migrations |
 
-See [Backend integration](#backend-integration) for `db_url` / `engine` / `worker_env` / `auto_recover`.
+See [Backend integration](#backend-integration) for `db_url` / `engine` / `worker_env` / `auto_recover` / `create_tables`.
 
 ### `start_worker(worker_type, worker_key=None, parameters=None, env=None)`
 
@@ -338,6 +339,15 @@ the project instead of living off to the side:
   `workers` table inside your database and inherits its persistence and backups
   — so state survives even if the process/container is recreated. A shared
   engine is never disposed by crazy_workers; its owner manages it.
+- **Let your migrations own the schema.** If your project tracks its schema with
+  a migration tool (Alembic, etc.), pass `create_tables=False` so crazy_workers
+  issues no DDL: the `workers` table becomes a normal migration in your history,
+  with a single source of truth and no create-on-import side effect. You own the
+  ordering — the table must exist before the manager queries it, so build the
+  manager *after* your migrations run (and keep `auto_recover=False` until then,
+  since recovery reads that table). See the `workers` schema in
+  [`crazy_workers/database/schema.py`](https://github.com/Vanni-broUser/crazy-workers/blob/main/crazy_workers/database/schema.py)
+  for the columns your migration must create.
 - **Give workers the connection they need.** A worker is a separate process, so
   it can't receive a live DB connection — pass the *configuration* instead.
   `worker_env={'DATABASE_URL': ...}` is injected into every spawned worker

{crazy_workers-1.2.0 → crazy_workers-1.3.0}/README.md

@@ -104,8 +104,9 @@ See [CLI.md](https://github.com/Vanni-broUser/crazy-workers/blob/main/CLI.md) fo
 | `engine` | `Engine` | `None` | Reuse an existing SQLAlchemy engine so the tables live in your database; **not** disposed by crazy_workers |
 | `worker_env` | `dict` | `None` | Environment variables injected into **every** spawned worker (e.g. `DATABASE_URL`) |
 | `auto_recover` | `bool` | `True` | Recover dead-but-`RUNNING` workers when the manager is constructed |
+| `create_tables` | `bool` | `True` | Create crazy_workers' own tables on init; set `False` when the host owns the schema via its migrations |
 
-See [Backend integration](#backend-integration) for `db_url` / `engine` / `worker_env` / `auto_recover`.
+See [Backend integration](#backend-integration) for `db_url` / `engine` / `worker_env` / `auto_recover` / `create_tables`.
 
 ### `start_worker(worker_type, worker_key=None, parameters=None, env=None)`
 
@@ -303,6 +304,15 @@ the project instead of living off to the side:
   `workers` table inside your database and inherits its persistence and backups
   — so state survives even if the process/container is recreated. A shared
   engine is never disposed by crazy_workers; its owner manages it.
+- **Let your migrations own the schema.** If your project tracks its schema with
+  a migration tool (Alembic, etc.), pass `create_tables=False` so crazy_workers
+  issues no DDL: the `workers` table becomes a normal migration in your history,
+  with a single source of truth and no create-on-import side effect. You own the
+  ordering — the table must exist before the manager queries it, so build the
+  manager *after* your migrations run (and keep `auto_recover=False` until then,
+  since recovery reads that table). See the `workers` schema in
+  [`crazy_workers/database/schema.py`](https://github.com/Vanni-broUser/crazy-workers/blob/main/crazy_workers/database/schema.py)
+  for the columns your migration must create.
 - **Give workers the connection they need.** A worker is a separate process, so
   it can't receive a live DB connection — pass the *configuration* instead.
   `worker_env={'DATABASE_URL': ...}` is injected into every spawned worker

{crazy_workers-1.2.0 → crazy_workers-1.3.0}/crazy_workers/core/manager/__init__.py

@@ -25,6 +25,7 @@ class WorkerManager:
     engine=None,
     worker_env=None,
     auto_recover=True,
+    create_tables=True,
   ):
     self.workers_dir = workers_dir
     self._validate_workers_dir(create_dir)
@@ -33,7 +34,7 @@ class WorkerManager:
     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, db_url, engine)
+    self._initialize_storage(create_dir, db_url, engine, create_tables)
     # The backend is the only component that touches OS processes. The default
     # spawns real subprocesses; tests can swap in a fake one (see for_testing).
     self.backend = backend or SubprocessBackend()
@@ -86,7 +87,7 @@ class WorkerManager:
       else:
         raise ValueError(f'Workers directory "{self.workers_dir}" does not exist.')
 
-  def _initialize_storage(self, create_dir, db_url, engine):
+  def _initialize_storage(self, create_dir, db_url, engine, create_tables):
     """Sets up service directories and storage if allowed or if they already exist."""
     if create_dir:
       os.makedirs(self.service_dir, exist_ok=True)
@@ -94,11 +95,12 @@ class WorkerManager:
 
     if engine is not None or db_url is not None:
       # External/shared database (e.g. the host backend's). crazy_workers' tables
-      # are created there; the local .service dir is still used for logs, the
-      # recovery lock and the boot marker.
-      self.storage = Storage(db_url=db_url, engine=engine)
+      # are created there unless the host owns the schema (create_tables=False);
+      # the local .service dir is still used for logs, the recovery lock and the
+      # boot marker.
+      self.storage = Storage(db_url=db_url, engine=engine, create_tables=create_tables)
     elif create_dir or os.path.exists(self.db_path):
-      self.storage = Storage(self.db_path)
+      self.storage = Storage(self.db_path, create_tables=create_tables)
     else:
       self.storage = None
 

{crazy_workers-1.2.0 → crazy_workers-1.3.0}/crazy_workers/database/storage.py

@@ -19,9 +19,15 @@ class Storage:
     A shared engine is NOT disposed by crazy_workers — its owner manages it.
   - ``db_url``: any SQLAlchemy URL (e.g. ``postgresql://user:pass@host/db``).
   - ``db_path``: a SQLite file path — the default, self-contained mode.
+
+  ``create_tables`` controls whether crazy_workers creates its own tables on
+  init. Leave it ``True`` for the self-contained modes. Set it ``False`` when
+  the host owns the schema (e.g. it manages crazy_workers' ``workers`` table
+  through its own migrations): crazy_workers then issues no DDL, and the caller
+  is responsible for the table existing before the storage is used.
   """
 
-  def __init__(self, db_path=None, *, db_url=None, engine=None):
+  def __init__(self, db_path=None, *, db_url=None, engine=None, create_tables=True):
     self.db_path = db_path
 
     if engine is not None:
@@ -37,7 +43,8 @@ class Storage:
       self._install_sqlite_tuning()
 
     self.Session = sessionmaker(bind=self.engine)
-    self._ensure_tables()
+    if create_tables:
+      self._ensure_tables()
 
   def _install_sqlite_tuning(self):
     @event.listens_for(self.engine, 'connect')

{crazy_workers-1.2.0 → crazy_workers-1.3.0}/crazy_workers.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crazy-workers
-Version: 1.2.0
+Version: 1.3.0
 Summary: A Python library for managing background worker processes with persistent state, automatic recovery, and a CLI.
 Author: GioVanni Colasanto
 License: MIT
@@ -139,8 +139,9 @@ See [CLI.md](https://github.com/Vanni-broUser/crazy-workers/blob/main/CLI.md) fo
 | `engine` | `Engine` | `None` | Reuse an existing SQLAlchemy engine so the tables live in your database; **not** disposed by crazy_workers |
 | `worker_env` | `dict` | `None` | Environment variables injected into **every** spawned worker (e.g. `DATABASE_URL`) |
 | `auto_recover` | `bool` | `True` | Recover dead-but-`RUNNING` workers when the manager is constructed |
+| `create_tables` | `bool` | `True` | Create crazy_workers' own tables on init; set `False` when the host owns the schema via its migrations |
 
-See [Backend integration](#backend-integration) for `db_url` / `engine` / `worker_env` / `auto_recover`.
+See [Backend integration](#backend-integration) for `db_url` / `engine` / `worker_env` / `auto_recover` / `create_tables`.
 
 ### `start_worker(worker_type, worker_key=None, parameters=None, env=None)`
 
@@ -338,6 +339,15 @@ the project instead of living off to the side:
   `workers` table inside your database and inherits its persistence and backups
   — so state survives even if the process/container is recreated. A shared
   engine is never disposed by crazy_workers; its owner manages it.
+- **Let your migrations own the schema.** If your project tracks its schema with
+  a migration tool (Alembic, etc.), pass `create_tables=False` so crazy_workers
+  issues no DDL: the `workers` table becomes a normal migration in your history,
+  with a single source of truth and no create-on-import side effect. You own the
+  ordering — the table must exist before the manager queries it, so build the
+  manager *after* your migrations run (and keep `auto_recover=False` until then,
+  since recovery reads that table). See the `workers` schema in
+  [`crazy_workers/database/schema.py`](https://github.com/Vanni-broUser/crazy-workers/blob/main/crazy_workers/database/schema.py)
+  for the columns your migration must create.
 - **Give workers the connection they need.** A worker is a separate process, so
   it can't receive a live DB connection — pass the *configuration* instead.
   `worker_env={'DATABASE_URL': ...}` is injected into every spawned worker

{crazy_workers-1.2.0 → crazy_workers-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crazy-workers"
-version = "1.2.0"
+version = "1.3.0"
 description = "A Python library for managing background worker processes with persistent state, automatic recovery, and a CLI."
 readme = "README.md"
 authors = [{ name = "GioVanni Colasanto" }]