quebec 0.2.1__cp39-abi3-win32.whl → 0.2.3__cp39-abi3-win32.whl

quebec/__init__.py

@@ -1,5 +1,6 @@
-from .quebec import * # NOQA
+from .quebec import *  # NOQA
 from . import quebec
+from . import sqlalchemy  # NOQA
 from .quebec import Quebec, ActiveJob
 import logging
 import time
@@ -30,8 +31,8 @@ class JobBuilder:
 
     def _calculate_scheduled_at(self) -> Optional[datetime]:
         """Calculate scheduled_at from wait or wait_until options."""
-        wait = self.options.get('wait')
-        wait_until = self.options.get('wait_until')
+        wait = self.options.get("wait")
+        wait_until = self.options.get("wait_until")
 
         if wait_until is not None:
             if isinstance(wait_until, datetime):
@@ -53,19 +54,19 @@ class JobBuilder:
 
         return None
 
-    def perform_later(self, qc: 'Quebec', *args, **kwargs) -> 'ActiveJob':
+    def perform_later(self, qc: "Quebec", *args, **kwargs) -> "ActiveJob":
         """Enqueue the job with configured options."""
         scheduled_at = self._calculate_scheduled_at()
 
         # Pass internal options via kwargs (will be filtered out before serialization)
         if scheduled_at is not None:
-            kwargs['_scheduled_at'] = scheduled_at.timestamp()
+            kwargs["_scheduled_at"] = scheduled_at.timestamp()
 
-        if 'queue' in self.options:
-            kwargs['_queue'] = self.options['queue']
+        if "queue" in self.options:
+            kwargs["_queue"] = self.options["queue"]
 
-        if 'priority' in self.options:
-            kwargs['_priority'] = self.options['priority']
+        if "priority" in self.options:
+            kwargs["_priority"] = self.options["priority"]
 
         # Call the original perform_later
         return self.job_class.perform_later(qc, *args, **kwargs)
@@ -73,18 +74,22 @@ class JobBuilder:
 
 class NoNewOverrideMeta(type):
     def __new__(cls, name, bases, dct):
-        if '__new__' in dct:
+        if "__new__" in dct:
             raise TypeError(f"Overriding __new__ is not allowed in class {name}")
-        if '__init__' in dct:
+        if "__init__" in dct:
             raise TypeError(f"Overriding __init__ is not allowed in class {name}")
         return super().__new__(cls, name, bases, dct)
 
+
 class BaseClass(ActiveJob, metaclass=NoNewOverrideMeta):
     @classmethod
-    def set(cls, wait: Union[int, float, timedelta] = None,
-            wait_until: datetime = None,
-            queue: str = None,
-            priority: int = None) -> JobBuilder:
+    def set(
+        cls,
+        wait: Union[int, float, timedelta] = None,
+        wait_until: datetime = None,
+        queue: str = None,
+        priority: int = None,
+    ) -> JobBuilder:
         """Configure job options before enqueueing.
 
         Args:
@@ -103,13 +108,13 @@ class BaseClass(ActiveJob, metaclass=NoNewOverrideMeta):
         """
         options = {}
         if wait is not None:
-            options['wait'] = wait
+            options["wait"] = wait
         if wait_until is not None:
-            options['wait_until'] = wait_until
+            options["wait_until"] = wait_until
         if queue is not None:
-            options['queue'] = queue
+            options["queue"] = queue
         if priority is not None:
-            options['priority'] = priority
+            options["priority"] = priority
         return JobBuilder(cls, **options)
 
 
@@ -142,7 +147,9 @@ class ThreadedRunner:
             except (queue.ShutDown, KeyboardInterrupt):
                 break
             except Exception as e:
-                logger.error(f"Unexpected exception in ThreadedRunner: {e}", exc_info=True)
+                logger.error(
+                    f"Unexpected exception in ThreadedRunner: {e}", exc_info=True
+                )
             finally:
                 self.cleanup()
 
@@ -151,7 +158,7 @@ class ThreadedRunner:
     def cleanup(self):
         """Cleanup after job execution"""
         try:
-            if self.execution and hasattr(self.execution, 'cleanup'):
+            if self.execution and hasattr(self.execution, "cleanup"):
                 self.execution.cleanup()
         except Exception as e:
             logger.error(f"Error in cleanup: {e}", exc_info=True)
@@ -197,11 +204,11 @@ def _quebec_start(
         self.spawn_all()
     else:
         for component in spawn:
-            if component == 'worker':
+            if component == "worker":
                 self.spawn_job_claim_poller()
-            elif component == 'dispatcher':
+            elif component == "dispatcher":
                 self.spawn_dispatcher()
-            elif component == 'scheduler':
+            elif component == "scheduler":
                 self.spawn_scheduler()
             else:
                 raise ValueError(f"Unknown component: {component}")
@@ -225,15 +232,15 @@ def _quebec_start(
     # Start worker threads as daemon so program can exit after start()
     worker_threads = []
     for i in range(threads):
-        t = threading.Thread(target=run_worker, name=f'quebec-worker-{i}', daemon=True)
+        t = threading.Thread(target=run_worker, name=f"quebec-worker-{i}", daemon=True)
         t.start()
         worker_threads.append(t)
 
     # Store state by instance id
     _quebec_state[id(self)] = {
-        'shutdown_event': shutdown_event,
-        'job_queue': job_queue,
-        'worker_threads': worker_threads,
+        "shutdown_event": shutdown_event,
+        "job_queue": job_queue,
+        "worker_threads": worker_threads,
     }
 
     return self  # Enable chaining: qc.start().wait()
@@ -254,14 +261,14 @@ def _quebec_wait(self):
         raise RuntimeError("Quebec not started. Call start() first.")
 
     try:
-        while not state['shutdown_event'].is_set():
+        while not state["shutdown_event"].is_set():
             time.sleep(0.5)
     except KeyboardInterrupt:
-        logger.debug('KeyboardInterrupt, shutting down...')
+        logger.debug("KeyboardInterrupt, shutting down...")
         self.graceful_shutdown()
     finally:
         # Wait for worker threads to finish
-        for t in state['worker_threads']:
+        for t in state["worker_threads"]:
             t.join(timeout=5.0)
         _quebec_state.pop(id(self), None)
 

quebec/logger.py

@@ -3,8 +3,13 @@ import contextvars
 from datetime import datetime, timezone
 from typing import Optional
 
-job_id_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar("job_id", default=None)
-queue_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar("queue", default=None)
+job_id_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
+    "job_id", default=None
+)
+queue_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
+    "queue", default=None
+)
+
 
 class ContextFilter(logging.Filter):
     def filter(self, record: logging.LogRecord) -> bool:
@@ -16,17 +21,18 @@ class ContextFilter(logging.Filter):
             record.queue = None
         return True
 
+
 class QuebecFormatter(logging.Formatter):
     def formatTime(self, record, datefmt=None):
         dt = datetime.fromtimestamp(record.created, tz=timezone.utc)
-        return dt.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
+        return dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
 
     def format(self, record: logging.LogRecord) -> str:
         record.asctime = self.formatTime(record)
         record.message = record.getMessage()
-        jid = getattr(record, 'job_id', None)
-        queue = getattr(record, 'queue', None)
-        if jid not in (None, '', '-'):
+        jid = getattr(record, "job_id", None)
+        queue = getattr(record, "queue", None)
+        if jid not in (None, "", "-"):
             ctx = f' {{queue="{queue}" jid="{jid}" tid="{record.thread}"}}:'
         else:
             ctx = ""
@@ -45,3 +51,188 @@ def setup_logging(level: int = logging.INFO, *, replace_root: bool = True) -> No
     handler.setFormatter(QuebecFormatter())
     handler.addFilter(ContextFilter())
     root.addHandler(handler)
+
+
+def _add_job_id(logger, method_name, event_dict):
+    """Processor to add job_id from contextvars."""
+    jid = job_id_var.get(None)
+    if jid:
+        event_dict["jid"] = jid
+    return event_dict
+
+
+def _rename_event_to_message(logger, method_name, event_dict):
+    """Rename 'event' to 'message' for Rust tracing-logfmt compatibility."""
+    if "event" in event_dict:
+        event_dict["message"] = event_dict.pop("event")
+    return event_dict
+
+
+# Module-level flag to prevent duplicate warnings
+_styles_warning_shown = False
+
+
+class TracingConsoleRenderer:
+    """Renderer matching Rust tracing console format.
+
+    Format: 2026-01-20T14:22:53Z  INFO target: lineno: message key=value
+    """
+
+    def __init__(self, colors: bool = True):
+        import os
+        import sys
+
+        self._use_colors = os.environ.get("QUEBEC_COLOR") == "always" or (
+            os.environ.get("QUEBEC_COLOR") != "never" and colors and sys.stdout.isatty()
+        )
+        self._styles = self._load_styles() if self._use_colors else None
+
+    def _load_styles(self) -> Optional[dict]:
+        """Load styles from structlog's ConsoleRenderer.
+
+        Note: Uses private attributes (_styles, _level_styles) which may change
+        in future structlog versions. Falls back to plain output if unavailable.
+        """
+        try:
+            import structlog
+
+            cr = structlog.dev.ConsoleRenderer(colors=True)
+            return {
+                "reset": cr._styles.reset,
+                "dim": cr._styles.timestamp,
+                "bright": cr._styles.bright,
+                "levels": cr._level_styles,
+            }
+        except (AttributeError, Exception) as e:
+            global _styles_warning_shown
+            if not _styles_warning_shown:
+                import sys
+
+                print(
+                    f"quebec: failed to load structlog color styles ({e}), falling back to plain output",
+                    file=sys.stderr,
+                )
+                _styles_warning_shown = True
+            return None
+
+    def __call__(self, logger, method_name, event_dict):
+        timestamp = event_dict.pop("timestamp", "")
+        level = event_dict.pop("level", "info").upper()
+        event = event_dict.pop("event", "")
+        lineno = event_dict.pop("lineno", "")
+        target = event_dict.pop("target", "quebec")
+
+        extra = self._format_kv(event_dict)
+        lineno_part = f"{lineno}: " if lineno else ""
+
+        if self._styles:
+            s = self._styles
+            ts = f"{s['dim']}{timestamp}{s['reset']}"
+            lvl_style = s["levels"].get(method_name, "")
+            lvl = f"{lvl_style}{level:>5}{s['reset']}"
+            return f"{ts} {lvl} {target}: {lineno_part}{event}{extra}"
+
+        return f"{timestamp} {level:>5} {target}: {lineno_part}{event}{extra}"
+
+    @staticmethod
+    def _format_kv(event_dict: dict) -> str:
+        """Format key-value pairs for console output.
+
+        Escapes quotes and handles values with whitespace per logfmt conventions.
+        """
+        if not event_dict:
+            return ""
+        parts = []
+        for k, v in event_dict.items():
+            if isinstance(v, str):
+                # Escape internal quotes and wrap in quotes if contains whitespace/quotes
+                escaped = v.replace("\\", "\\\\").replace('"', '\\"')
+                parts.append(f'{k}="{escaped}"')
+            else:
+                parts.append(f"{k}={v}")
+        return " " + " ".join(parts)
+
+
+def setup_structlog(level: int = logging.INFO, *, format: str | None = None) -> None:
+    """Configure structlog with job_id context support.
+
+    Args:
+        level: Logging level (default INFO)
+        format: Output format - "console" (colored), "json", or "logfmt".
+                Defaults to QUEBEC_LOG_FORMAT env var, or "console" if not set.
+
+    Example:
+        from quebec.logger import setup_structlog, get_structlog
+        setup_structlog(level=logging.DEBUG)
+        setup_structlog(format="logfmt")  # logfmt output
+        setup_structlog(format="json")    # JSON output
+        log = get_structlog()
+        log.info("job started", queue="default")
+    """
+    import os
+
+    if format is None:
+        format = os.environ.get("QUEBEC_LOG_FORMAT", "console")
+    try:
+        import structlog
+    except ImportError:
+        raise ImportError("structlog is required. Install with: pip install structlog")
+
+    shared_processors = [
+        structlog.contextvars.merge_contextvars,
+        _add_job_id,
+        structlog.processors.add_log_level,
+        structlog.processors.CallsiteParameterAdder(
+            [
+                structlog.processors.CallsiteParameter.LINENO,
+            ]
+        ),
+    ]
+
+    if format == "json":
+        processors = shared_processors + [
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.processors.JSONRenderer(),
+        ]
+    elif format == "logfmt":
+        # Use ts=/message= to match Rust tracing-logfmt output
+        processors = shared_processors + [
+            structlog.processors.TimeStamper(fmt="iso", key="ts"),
+            _rename_event_to_message,
+            structlog.processors.LogfmtRenderer(
+                key_order=["ts", "level", "message"],
+                sort_keys=True,
+            ),
+        ]
+    else:  # console
+        processors = shared_processors + [
+            structlog.processors.TimeStamper(fmt="iso"),
+            TracingConsoleRenderer(colors=True),
+        ]
+
+    structlog.configure(
+        processors=processors,
+        wrapper_class=structlog.make_filtering_bound_logger(level),
+        context_class=dict,
+        logger_factory=structlog.PrintLoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+
+def get_structlog(name: Optional[str] = None):
+    """Get a structlog logger instance.
+
+    Example:
+        log = get_structlog(__name__)
+        log.info("processing", job_id=123, queue="default")
+    """
+    try:
+        import structlog
+    except ImportError:
+        raise ImportError("structlog is required. Install with: pip install structlog")
+
+    # Bind the logger name as 'target' to match Rust tracing output
+    logger = structlog.get_logger()
+    if name:
+        logger = logger.bind(target=name)
+    return logger

quebec/sqlalchemy.py

@@ -0,0 +1,408 @@
+"""SQLAlchemy models for Quebec database tables.
+
+These models mirror the Rust SeaORM entities and can be used for querying
+the Quebec database directly from Python using SQLAlchemy.
+
+Example usage:
+    from sqlalchemy import create_engine
+    from sqlalchemy.orm import Session
+    from quebec.models import Job, ReadyExecution
+
+    engine = create_engine("postgresql://localhost/quebec")
+    with Session(engine) as session:
+        # Query ready jobs with their job details
+        ready = session.query(ReadyExecution).join(Job).filter(
+            ReadyExecution.queue_name == "default"
+        ).all()
+
+        for r in ready:
+            print(f"Job {r.job.class_name} ready in queue {r.queue_name}")
+"""
+
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import (
+    BigInteger,
+    Boolean,
+    DateTime,
+    ForeignKey,
+    Index,
+    Integer,
+    String,
+    Text,
+    text,
+)
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+
+
+class Base(DeclarativeBase):
+    """Base class for all Quebec models."""
+
+    pass
+
+
+class Job(Base):
+    """Main job table containing job definitions and state.
+
+    Relationships:
+        - ready_execution: One-to-one with ReadyExecution
+        - claimed_execution: One-to-one with ClaimedExecution
+        - blocked_execution: One-to-one with BlockedExecution
+        - scheduled_execution: One-to-one with ScheduledExecution
+        - failed_execution: One-to-one with FailedExecution
+        - recurring_execution: One-to-one with RecurringExecution
+    """
+
+    __tablename__ = "solid_queue_jobs"
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    queue_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    class_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    arguments: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    priority: Mapped[int] = mapped_column(
+        Integer, nullable=False, server_default=text("0")
+    )
+    failed_attempts: Mapped[int] = mapped_column(
+        Integer, nullable=False, server_default=text("0")
+    )
+    active_job_id: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+    scheduled_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+    finished_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+    concurrency_key: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+
+    # Relationships
+    ready_execution: Mapped[Optional["ReadyExecution"]] = relationship(
+        back_populates="job", uselist=False, cascade="all, delete-orphan"
+    )
+    claimed_execution: Mapped[Optional["ClaimedExecution"]] = relationship(
+        back_populates="job", uselist=False, cascade="all, delete-orphan"
+    )
+    blocked_execution: Mapped[Optional["BlockedExecution"]] = relationship(
+        back_populates="job", uselist=False, cascade="all, delete-orphan"
+    )
+    scheduled_execution: Mapped[Optional["ScheduledExecution"]] = relationship(
+        back_populates="job", uselist=False, cascade="all, delete-orphan"
+    )
+    failed_execution: Mapped[Optional["FailedExecution"]] = relationship(
+        back_populates="job", uselist=False, cascade="all, delete-orphan"
+    )
+    recurring_execution: Mapped[Optional["RecurringExecution"]] = relationship(
+        back_populates="job", uselist=False, cascade="all, delete-orphan"
+    )
+
+    __table_args__ = (
+        Index("idx_solid_queue_jobs_queue_priority", "queue_name", "priority"),
+        Index("idx_solid_queue_jobs_class_name", "class_name"),
+        Index("idx_solid_queue_jobs_finished_at", "finished_at"),
+    )
+
+    def __repr__(self) -> str:
+        return f"<Job(id={self.id}, class_name={self.class_name!r}, queue={self.queue_name!r})>"
+
+
+class ReadyExecution(Base):
+    """Jobs that are ready to be executed.
+
+    Jobs move here when they are enqueued and ready for immediate execution.
+    Workers claim jobs from this table using FOR UPDATE SKIP LOCKED.
+    """
+
+    __tablename__ = "solid_queue_ready_executions"
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    job_id: Mapped[int] = mapped_column(
+        BigInteger,
+        ForeignKey("solid_queue_jobs.id", ondelete="CASCADE"),
+        unique=True,
+        nullable=False,
+    )
+    queue_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    priority: Mapped[int] = mapped_column(
+        Integer, nullable=False, server_default=text("0")
+    )
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+
+    job: Mapped["Job"] = relationship(back_populates="ready_execution")
+
+    __table_args__ = (
+        Index(
+            "idx_solid_queue_ready_executions_queue_priority",
+            "queue_name",
+            "priority",
+        ),
+    )
+
+    def __repr__(self) -> str:
+        return f"<ReadyExecution(id={self.id}, job_id={self.job_id}, queue={self.queue_name!r})>"
+
+
+class ClaimedExecution(Base):
+    """Jobs that are currently being executed by a worker.
+
+    When a worker claims a job, it moves from ready_executions to here.
+    The process_id links to the worker process that claimed the job.
+    """
+
+    __tablename__ = "solid_queue_claimed_executions"
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    job_id: Mapped[int] = mapped_column(
+        BigInteger,
+        ForeignKey("solid_queue_jobs.id", ondelete="CASCADE"),
+        unique=True,
+        nullable=False,
+    )
+    process_id: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+
+    job: Mapped["Job"] = relationship(back_populates="claimed_execution")
+
+    def __repr__(self) -> str:
+        return f"<ClaimedExecution(id={self.id}, job_id={self.job_id}, process_id={self.process_id})>"
+
+
+class BlockedExecution(Base):
+    """Jobs that are blocked due to concurrency limits.
+
+    When a job has a concurrency_key and the semaphore limit is reached,
+    the job is placed here until a slot becomes available.
+    """
+
+    __tablename__ = "solid_queue_blocked_executions"
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    job_id: Mapped[int] = mapped_column(
+        BigInteger,
+        ForeignKey("solid_queue_jobs.id", ondelete="CASCADE"),
+        unique=True,
+        nullable=False,
+    )
+    queue_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    priority: Mapped[int] = mapped_column(
+        Integer, nullable=False, server_default=text("0")
+    )
+    concurrency_key: Mapped[str] = mapped_column(String(255), nullable=False)
+    expires_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+
+    job: Mapped["Job"] = relationship(back_populates="blocked_execution")
+
+    __table_args__ = (
+        Index(
+            "idx_solid_queue_blocked_executions_concurrency_key",
+            "concurrency_key",
+        ),
+        Index("idx_solid_queue_blocked_executions_expires_at", "expires_at"),
+    )
+
+    def __repr__(self) -> str:
+        return f"<BlockedExecution(id={self.id}, job_id={self.job_id}, key={self.concurrency_key!r})>"
+
+
+class ScheduledExecution(Base):
+    """Jobs that are scheduled for future execution.
+
+    Jobs with a scheduled_at time in the future are placed here.
+    The dispatcher moves them to ready_executions when the time comes.
+    """
+
+    __tablename__ = "solid_queue_scheduled_executions"
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    job_id: Mapped[int] = mapped_column(
+        BigInteger,
+        ForeignKey("solid_queue_jobs.id", ondelete="CASCADE"),
+        unique=True,
+        nullable=False,
+    )
+    queue_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    priority: Mapped[int] = mapped_column(
+        Integer, nullable=False, server_default=text("0")
+    )
+    scheduled_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+
+    job: Mapped["Job"] = relationship(back_populates="scheduled_execution")
+
+    __table_args__ = (
+        Index("idx_solid_queue_scheduled_executions_scheduled_at", "scheduled_at"),
+    )
+
+    def __repr__(self) -> str:
+        return f"<ScheduledExecution(id={self.id}, job_id={self.job_id}, scheduled_at={self.scheduled_at})>"
+
+
+class FailedExecution(Base):
+    """Jobs that have failed execution.
+
+    When a job fails and exhausts retries (or has no retry strategy),
+    it is moved here with the error message.
+    """
+
+    __tablename__ = "solid_queue_failed_executions"
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    job_id: Mapped[int] = mapped_column(
+        BigInteger,
+        ForeignKey("solid_queue_jobs.id", ondelete="CASCADE"),
+        unique=True,
+        nullable=False,
+    )
+    error: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+
+    job: Mapped["Job"] = relationship(back_populates="failed_execution")
+
+    def __repr__(self) -> str:
+        return f"<FailedExecution(id={self.id}, job_id={self.job_id})>"
+
+
+class RecurringExecution(Base):
+    """Tracks which recurring task occurrences have been executed.
+
+    Used to prevent duplicate execution of recurring jobs when
+    multiple scheduler instances are running.
+    """
+
+    __tablename__ = "solid_queue_recurring_executions"
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    job_id: Mapped[int] = mapped_column(
+        BigInteger,
+        ForeignKey("solid_queue_jobs.id", ondelete="CASCADE"),
+        unique=True,
+        nullable=False,
+    )
+    task_key: Mapped[str] = mapped_column(String(255), nullable=False)
+    run_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+
+    job: Mapped["Job"] = relationship(back_populates="recurring_execution")
+
+    __table_args__ = (
+        Index(
+            "index_solid_queue_recurring_executions_on_task_key_and_run_at",
+            "task_key",
+            "run_at",
+            unique=True,
+        ),
+    )
+
+    def __repr__(self) -> str:
+        return f"<RecurringExecution(id={self.id}, task_key={self.task_key!r}, run_at={self.run_at})>"
+
+
+class RecurringTask(Base):
+    """Recurring task definitions loaded from schedule configuration.
+
+    Defines cron-like schedules for periodic job execution.
+    """
+
+    __tablename__ = "solid_queue_recurring_tasks"
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    key: Mapped[str] = mapped_column(String(255), nullable=False, unique=True)
+    schedule: Mapped[str] = mapped_column(String(255), nullable=False)
+    command: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+    class_name: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+    arguments: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    queue_name: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+    priority: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
+    static: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, server_default=text("false")
+    )
+    description: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+
+    def __repr__(self) -> str:
+        return f"<RecurringTask(id={self.id}, key={self.key!r}, schedule={self.schedule!r})>"
+
+
+class Process(Base):
+    """Worker, dispatcher, and scheduler process registration.
+
+    Each running process registers itself here and updates its heartbeat
+    periodically. Used for process monitoring and orphan detection.
+    """
+
+    __tablename__ = "solid_queue_processes"
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    kind: Mapped[str] = mapped_column(String(255), nullable=False)
+    last_heartbeat_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+    supervisor_id: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True)
+    pid: Mapped[int] = mapped_column(Integer, nullable=False)
+    hostname: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+    metadata_: Mapped[Optional[str]] = mapped_column("metadata", Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+
+    __table_args__ = (
+        Index("idx_solid_queue_processes_kind", "kind"),
+        Index("idx_solid_queue_processes_last_heartbeat", "last_heartbeat_at"),
+    )
+
+    def __repr__(self) -> str:
+        return f"<Process(id={self.id}, kind={self.kind!r}, pid={self.pid}, hostname={self.hostname!r})>"
+
+
+class Semaphore(Base):
+    """Concurrency semaphores for limiting parallel job execution.
+
+    Each unique concurrency_key has a semaphore with a value (available slots)
+    and a limit. When value reaches 0, jobs with that key are blocked.
+    """
+
+    __tablename__ = "solid_queue_semaphores"
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    key: Mapped[str] = mapped_column(String(255), nullable=False, unique=True)
+    value: Mapped[int] = mapped_column(
+        Integer, nullable=False, server_default=text("0")
+    )
+    expires_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+
+    __table_args__ = (Index("idx_solid_queue_semaphores_expires_at", "expires_at"),)
+
+    def __repr__(self) -> str:
+        return f"<Semaphore(id={self.id}, key={self.key!r}, value={self.value})>"
+
+
+class Pause(Base):
+    """Queue pause state.
+
+    When a queue is paused, no jobs from that queue will be processed
+    until the pause is removed.
+    """
+
+    __tablename__ = "solid_queue_pauses"
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    queue_name: Mapped[str] = mapped_column(String(255), nullable=False, unique=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+
+    def __repr__(self) -> str:
+        return f"<Pause(id={self.id}, queue_name={self.queue_name!r})>"
+
+
+# Convenience exports
+__all__ = [
+    "Base",
+    "Job",
+    "ReadyExecution",
+    "ClaimedExecution",
+    "BlockedExecution",
+    "ScheduledExecution",
+    "FailedExecution",
+    "RecurringExecution",
+    "RecurringTask",
+    "Process",
+    "Semaphore",
+    "Pause",
+]

{quebec-0.2.1.dist-info → quebec-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quebec
-Version: 0.2.1
+Version: 0.2.3
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -17,13 +17,13 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
-Requires-Dist: pytest>=7.0.0 ; extra == 'test'
-Requires-Dist: pytest-cov ; extra == 'test'
 Requires-Dist: sphinx>=7.0 ; extra == 'docs'
 Requires-Dist: shibuya ; extra == 'docs'
 Requires-Dist: myst-parser ; extra == 'docs'
-Provides-Extra: test
+Requires-Dist: pytest>=7.0.0 ; extra == 'test'
+Requires-Dist: pytest-cov ; extra == 'test'
 Provides-Extra: docs
+Provides-Extra: test
 License-File: LICENSE
 Summary: Quebec is a simple background task queue for processing asynchronous tasks.
 Keywords: solid_queue,postgresql,mysql,sqlite,queue

quebec-0.2.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+quebec\__init__.py,sha256=5SmUfnETyLt5fJMuXdKY4TSFF7AOr3CQF0E_PVD1S-c,10756
+quebec\logger.py,sha256=u4PgwFjfq_tqkRm6sYU7rvfEOhw2jC3D9lhe3XyFwRU,8269
+quebec\quebec.pyd,sha256=lDebxl3fdgNYo47HUDPQMoZCCt0tIPaSVKG185jZHG4,20989952
+quebec\sqlalchemy.py,sha256=ftw7QU7xl0fLUSuKUmk90IfCPXu3k0CjjQTsucmHCXE,15243
+quebec-0.2.3.dist-info\METADATA,sha256=qjusSzEliU96bIufi893zbXmoxtQN0Y0VTb9pJtAkm0,5061
+quebec-0.2.3.dist-info\WHEEL,sha256=R9yL9L75E0L3ZWd23Kt3_bdVV0VNkcHjlSm3_njNpM4,91
+quebec-0.2.3.dist-info\licenses\LICENSE,sha256=EMUpCdp2I-buVSjzgRTpd6TZDSnUcm1Pi4w8vOiwsQk,1095
+quebec-0.2.3.dist-info\RECORD,,

{quebec-0.2.1.dist-info → quebec-0.2.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.10.2)
+Generator: maturin (1.11.5)
 Root-Is-Purelib: false
 Tag: cp39-abi3-win32

quebec-0.2.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-quebec-0.2.1.dist-info/METADATA,sha256=yXF8dzOOSwTX5sv_sZTdfrEAt5ZTZC0vVN-724RjdwA,5061
-quebec-0.2.1.dist-info/WHEEL,sha256=l-zZhOZ2a5ZXnfk1pQvieCLMom_QD7Et38SJZ8iK5h8,91
-quebec-0.2.1.dist-info/licenses/LICENSE,sha256=EMUpCdp2I-buVSjzgRTpd6TZDSnUcm1Pi4w8vOiwsQk,1095
-quebec/__init__.py,sha256=382fYpy2xb2oAoEG-sRJVLXVjHr7ltkWcy7WBhSv3zM,10665
-quebec/logger.py,sha256=gX0O1S77HWEQ2bkTFBV3kolSonvTP0p41xYV7WLmBNY,1806
-quebec/quebec.pyd,sha256=wa_w_9KK9cwfOMwcJPn-ulUCmb5hpkpbDh71vhKt5Dc,20173312
-quebec-0.2.1.dist-info/RECORD,,