plain.jobs 0.43.2__py3-none-any.whl

plain/jobs/workers.py

@@ -0,0 +1,355 @@
+from __future__ import annotations
+
+import gc
+import logging
+import multiprocessing
+import os
+import time
+from concurrent.futures import Future, ProcessPoolExecutor
+from functools import partial
+from typing import TYPE_CHECKING, Any
+
+from plain import models
+from plain.models import transaction
+from plain.runtime import settings
+from plain.signals import request_finished, request_started
+from plain.utils import timezone
+from plain.utils.module_loading import import_string
+
+from .registry import jobs_registry
+
+if TYPE_CHECKING:
+    from .models import JobResult
+
+# Models are NOT imported at the top of this file!
+# See comment on _worker_process_initializer() for explanation.
+
+logger = logging.getLogger("plain.jobs")
+
+
+def _worker_process_initializer() -> None:
+    """Initialize Plain framework in worker process before processing jobs.
+
+    Why this is needed:
+    - We use multiprocessing with 'spawn' context (not 'fork')
+    - Spawn creates fresh Python processes, not forked copies
+    - When a spawned process starts, it re-imports this module BEFORE the initializer runs
+    - If we imported models at the top of this file, model registration would
+      happen before plain.runtime.setup(), causing PackageRegistryNotReady errors
+
+    Solution:
+    - This initializer runs plain.runtime.setup() FIRST in each worker process
+    - All model imports happen lazily inside functions (after setup completes)
+    - This ensures packages registry is ready before any models are accessed
+
+    Execution order in spawned worker:
+    1. Re-import workers.py (but models NOT imported yet - lazy!)
+    2. Run this initializer → plain.runtime.setup()
+    3. Execute process_job() → NOW it's safe to import models
+    """
+    from plain.runtime import setup
+
+    # Each spawned worker process needs to set up Plain
+    # (spawn context creates fresh processes, not forks)
+    setup()
+
+
+class Worker:
+    def __init__(
+        self,
+        queues: list[str],
+        jobs_schedule: list[Any] | None = None,
+        max_processes: int | None = None,
+        max_jobs_per_process: int | None = None,
+        max_pending_per_process: int = 10,
+        stats_every: int | None = None,
+    ) -> None:
+        if jobs_schedule is None:
+            jobs_schedule = []
+
+        self.executor = ProcessPoolExecutor(
+            max_workers=max_processes,
+            max_tasks_per_child=max_jobs_per_process,
+            mp_context=multiprocessing.get_context("spawn"),
+            initializer=_worker_process_initializer,
+        )
+
+        self.queues = queues
+
+        # Filter the jobs schedule to those that are in the same queue as this worker
+        self.jobs_schedule = [
+            x for x in jobs_schedule if x[0].default_queue() in queues
+        ]
+
+        # How often to log the stats (in seconds)
+        self.stats_every = stats_every
+
+        self.max_processes = self.executor._max_workers  # type: ignore[attr-defined]
+        self.max_jobs_per_process = max_jobs_per_process
+        self.max_pending_per_process = max_pending_per_process
+
+        self._is_shutting_down = False
+
+    def run(self) -> None:
+        # Lazy import - see _worker_process_initializer() comment for why
+        from .models import JobRequest
+
+        logger.info(
+            "⬣ Starting Plain worker\n    Registered jobs: %s\n    Queues: %s\n    Jobs schedule: %s\n    Stats every: %s seconds\n    Max processes: %s\n    Max jobs per process: %s\n    Max pending per process: %s\n    PID: %s",
+            "\n                     ".join(
+                f"{name}: {cls}" for name, cls in jobs_registry.jobs.items()
+            ),
+            ", ".join(self.queues),
+            "\n                   ".join(str(x) for x in self.jobs_schedule),
+            self.stats_every,
+            self.max_processes,
+            self.max_jobs_per_process,
+            self.max_pending_per_process,
+            os.getpid(),
+        )
+
+        while not self._is_shutting_down:
+            try:
+                self.maybe_log_stats()
+                self.maybe_check_job_results()
+                self.maybe_schedule_jobs()
+            except Exception as e:
+                # Log the issue, but don't stop the worker
+                # (these tasks are kind of ancilarry to the main job processing)
+                logger.exception(e)
+
+            if len(self.executor._pending_work_items) >= (
+                self.max_processes * self.max_pending_per_process
+            ):
+                # We don't want to convert too many JobRequests to Jobs,
+                # because anything not started yet will be cancelled on deploy etc.
+                # It's easier to leave them in the JobRequest db queue as long as possible.
+                time.sleep(0.5)
+                continue
+
+            with transaction.atomic():
+                job_request = (
+                    JobRequest.query.select_for_update(skip_locked=True)
+                    .filter(
+                        queue__in=self.queues,
+                    )
+                    .filter(
+                        models.Q(start_at__isnull=True)
+                        | models.Q(start_at__lte=timezone.now())
+                    )
+                    .order_by("priority", "-start_at", "-created_at")
+                    .first()
+                )
+                if not job_request:
+                    # Potentially no jobs to process (who knows for how long)
+                    # but sleep for a second to give the CPU and DB a break
+                    time.sleep(1)
+                    continue
+
+                logger.debug(
+                    'Preparing to execute job job_class=%s job_request_uuid=%s job_priority=%s job_source="%s" job_queues="%s"',
+                    job_request.job_class,
+                    job_request.uuid,
+                    job_request.priority,
+                    job_request.source,
+                    job_request.queue,
+                )
+
+                job = job_request.convert_to_job_process()
+
+            job_process_uuid = str(job.uuid)  # Make a str copy
+
+            future = self.executor.submit(process_job, job_process_uuid)
+            future.add_done_callback(
+                partial(future_finished_callback, job_process_uuid)
+            )
+
+    def shutdown(self) -> None:
+        if self._is_shutting_down:
+            # Already shutting down somewhere else
+            return
+
+        logger.info("Job worker shutdown started")
+        self._is_shutting_down = True
+        self.executor.shutdown(wait=True, cancel_futures=True)
+        logger.info("Job worker shutdown complete")
+
+    def maybe_log_stats(self) -> None:
+        if not self.stats_every:
+            return
+
+        now = time.time()
+
+        if not hasattr(self, "_stats_logged_at"):
+            self._stats_logged_at = now
+
+        if now - self._stats_logged_at > self.stats_every:
+            self._stats_logged_at = now
+            self.log_stats()
+
+    def maybe_check_job_results(self) -> None:
+        now = time.time()
+
+        if not hasattr(self, "_job_results_checked_at"):
+            self._job_results_checked_at = now
+
+        check_every = 60  # Only need to check once a minute
+
+        if now - self._job_results_checked_at > check_every:
+            self._job_results_checked_at = now
+            self.rescue_job_results()
+
+    def maybe_schedule_jobs(self) -> None:
+        if not self.jobs_schedule:
+            return
+
+        now = time.time()
+
+        if not hasattr(self, "_jobs_schedule_checked_at"):
+            self._jobs_schedule_checked_at = now
+
+        check_every = 60  # Only need to check once every 60 seconds
+
+        if now - self._jobs_schedule_checked_at > check_every:
+            for job, schedule in self.jobs_schedule:
+                next_start_at = schedule.next()
+
+                # Leverage the concurrency_key to group scheduled jobs
+                # with the same start time
+                schedule_concurrency_key = f"{job.default_concurrency_key()}:scheduled:{int(next_start_at.timestamp())}"
+
+                # Job's should_enqueue hook can control scheduling behavior
+                result = job.run_in_worker(
+                    delay=next_start_at,
+                    concurrency_key=schedule_concurrency_key,
+                )
+                # Result is None if should_enqueue returned False
+                if result:
+                    logger.info(
+                        'Scheduling job job_class=%s job_queue="%s" job_start_at="%s" job_schedule="%s" concurrency_key="%s"',
+                        result.job_class,
+                        result.queue,
+                        result.start_at,
+                        schedule,
+                        result.concurrency_key,
+                    )
+
+            self._jobs_schedule_checked_at = now
+
+    def log_stats(self) -> None:
+        # Lazy import - see _worker_process_initializer() comment for why
+        from .models import JobProcess, JobRequest
+
+        try:
+            num_proccesses = len(self.executor._processes)
+        except (AttributeError, TypeError):
+            # Depending on shutdown timing and internal behavior, this might not work
+            num_proccesses = 0
+
+        jobs_requested = JobRequest.query.filter(queue__in=self.queues).count()
+        jobs_processing = JobProcess.query.filter(queue__in=self.queues).count()
+
+        logger.info(
+            'Job worker stats worker_processes=%s worker_queues="%s" jobs_requested=%s jobs_processing=%s worker_max_processes=%s worker_max_jobs_per_process=%s',
+            num_proccesses,
+            ",".join(self.queues),
+            jobs_requested,
+            jobs_processing,
+            self.max_processes,
+            self.max_jobs_per_process,
+        )
+
+    def rescue_job_results(self) -> None:
+        """Find any lost or failed jobs on this worker's queues and handle them."""
+        # Lazy import - see _worker_process_initializer() comment for why
+        from .models import JobProcess, JobResult
+
+        # TODO return results and log them if there are any?
+        JobProcess.query.filter(queue__in=self.queues).mark_lost_jobs()
+        JobResult.query.filter(queue__in=self.queues).retry_failed_jobs()
+
+
+def future_finished_callback(job_process_uuid: str, future: Future) -> None:
+    # Lazy import - see _worker_process_initializer() comment for why
+    from .models import JobProcess, JobResultStatuses
+
+    if future.cancelled():
+        logger.warning("Job cancelled job_process_uuid=%s", job_process_uuid)
+        try:
+            job = JobProcess.query.get(uuid=job_process_uuid)
+            job.convert_to_result(status=JobResultStatuses.CANCELLED)
+        except JobProcess.DoesNotExist:
+            # Job may have already been cleaned up
+            pass
+    elif exception := future.exception():
+        # Process pool may have been killed...
+        logger.warning(
+            "Job failed job_process_uuid=%s",
+            job_process_uuid,
+            exc_info=exception,
+        )
+        try:
+            job = JobProcess.query.get(uuid=job_process_uuid)
+            job.convert_to_result(status=JobResultStatuses.CANCELLED)
+        except JobProcess.DoesNotExist:
+            # Job may have already been cleaned up
+            pass
+    else:
+        logger.debug("Job finished job_process_uuid=%s", job_process_uuid)
+
+
+def process_job(job_process_uuid: str) -> None:
+    # Lazy import - see _worker_process_initializer() comment for why
+    from .models import JobProcess
+
+    try:
+        worker_pid = os.getpid()
+
+        request_started.send(sender=None)
+
+        job_process = JobProcess.query.get(uuid=job_process_uuid)
+
+        logger.info(
+            'Executing job worker_pid=%s job_class=%s job_request_uuid=%s job_priority=%s job_source="%s" job_queue="%s"',
+            worker_pid,
+            job_process.job_class,
+            job_process.job_request_uuid,
+            job_process.priority,
+            job_process.source,
+            job_process.queue,
+        )
+
+        def middleware_chain(job: JobProcess) -> JobResult:
+            return job.run()
+
+        for middleware_path in reversed(settings.JOBS_MIDDLEWARE):
+            middleware_class = import_string(middleware_path)
+            middleware_instance = middleware_class(middleware_chain)
+            middleware_chain = middleware_instance.process_job
+
+        job_result = middleware_chain(job_process)
+
+        duration = job_result.ended_at - job_result.started_at  # type: ignore[operator]
+        duration = duration.total_seconds()
+
+        logger.info(
+            'Completed job worker_pid=%s job_class=%s job_process_uuid=%s job_request_uuid=%s job_result_uuid=%s job_priority=%s job_source="%s" job_queue="%s" job_duration=%s',
+            worker_pid,
+            job_result.job_class,
+            job_result.job_process_uuid,
+            job_result.job_request_uuid,
+            job_result.uuid,
+            job_result.priority,
+            job_result.source,
+            job_result.queue,
+            duration,
+        )
+    except Exception as e:
+        # Raising exceptions inside the worker process doesn't
+        # seem to be caught/shown anywhere as configured.
+        # So we at least log it out here.
+        # (A job should catch it's own user-code errors, so this is for library errors)
+        logger.exception(e)
+    finally:
+        request_finished.send(sender=None)
+        gc.collect()

plain_jobs-0.43.2.dist-info/METADATA

@@ -0,0 +1,312 @@
+Metadata-Version: 2.4
+Name: plain.jobs
+Version: 0.43.2
+Summary: Process background jobs with a database-driven job queue.
+Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: plain-models<1.0.0
+Requires-Dist: plain<1.0.0
+Description-Content-Type: text/markdown
+
+# plain.jobs
+
+**Process background jobs with a database-driven job queue.**
+
+- [Overview](#overview)
+- [Local development](#local-development)
+- [Job parameters](#job-parameters)
+- [Job methods](#job-methods)
+- [Scheduled jobs](#scheduled-jobs)
+- [Admin interface](#admin-interface)
+- [Job history](#job-history)
+- [Monitoring](#monitoring)
+- [FAQs](#faqs)
+- [Installation](#installation)
+
+## Overview
+
+Jobs are defined using the [`Job`](./jobs.py#Job) base class and the `run()` method at a minimum.
+
+```python
+from plain.jobs import Job, register_job
+from plain.email import send_mail
+
+
+@register_job
+class WelcomeUserJob(Job):
+    def __init__(self, user):
+        self.user = user
+
+    def run(self):
+        send_mail(
+            subject="Welcome!",
+            message=f"Hello from Plain, {self.user}",
+            from_email="welcome@plainframework.com",
+            recipient_list=[self.user.email],
+        )
+```
+
+You can then create an instance of the job and call [`run_in_worker()`](./jobs.py#Job.run_in_worker) to enqueue it for a background worker to pick up.
+
+```python
+user = User.query.get(id=1)
+WelcomeUserJob(user).run_in_worker()
+```
+
+Workers are run using the `plain jobs worker` command.
+
+Jobs can be defined in any Python file, but it is suggested to use `app/jobs.py` or `app/{pkg}/jobs.py` as those will be imported automatically so the [`@register_job`](./registry.py#register_job) decorator will fire.
+
+Run database migrations after installation:
+
+```bash
+plain migrate
+```
+
+## Local development
+
+In development, you will typically want to run the worker alongside your app with auto-reloading enabled. With [`plain.dev`](/plain-dev/plain/dev/README.md) you can do this by adding it to the `[tool.plain.dev.run]` section of your `pyproject.toml` file.
+
+```toml
+# pyproject.toml
+[tool.plain.dev.run]
+worker = {cmd = "plain jobs worker --reload --stats-every 0 --max-processes 2"}
+worker-slow = {cmd = "plain jobs worker --reload --queue slow --stats-every 0 --max-processes 2"}
+```
+
+The `--reload` flag will automatically watch `.py` and `.env*` files for changes and restart the worker when changes are detected.
+
+## Job parameters
+
+When calling `run_in_worker()`, you can specify several parameters to control job execution:
+
+```python
+job.run_in_worker(
+    queue="slow",  # Target a specific queue (default: "default")
+    delay=60,  # Delay in seconds (or timedelta/datetime)
+    priority=10,  # Higher numbers run first (default: 0, use negatives for lower priority)
+    retries=3,  # Number of retry attempts (default: 0)
+    concurrency_key="user-123-welcome",  # Identifier for grouping/deduplication
+)
+```
+
+For more advanced parameter options, see [`Job.run_in_worker()`](./jobs.py#Job.run_in_worker).
+
+## Job methods
+
+The [`Job`](./jobs.py#Job) base class provides several methods you can override to customize behavior:
+
+```python
+class MyJob(Job):
+    def run(self):
+        # Required: The main job logic
+        pass
+
+    # Defaults (can be overridden in run_in_worker)
+    def default_queue(self) -> str:
+        return "default"
+
+    def default_priority(self) -> int:
+        # Higher numbers run first: 10 > 5 > 0 > -5 > -10
+        return 0
+
+    def default_retries(self) -> int:
+        return 0
+
+    def default_concurrency_key(self) -> str:
+        # Identifier for grouping/deduplication
+        return ""
+
+    # Computed values
+    def calculate_retry_delay(self, attempt: int) -> int:
+        # Delay in seconds before retry (attempt starts at 1)
+        return 0
+
+    # Hooks
+    def should_enqueue(self, concurrency_key: str) -> bool:
+        # Called before enqueueing - return False to skip
+        # Use for concurrency limits, rate limits, etc.
+        return True
+```
+
+## Scheduled jobs
+
+You can schedule jobs to run at specific times using the [`Schedule`](./scheduling.py#Schedule) class:
+
+```python
+from plain.jobs import Job, register_job
+from plain.jobs.scheduling import Schedule
+
+@register_job
+class DailyReportJob(Job):
+    schedule = Schedule.from_cron("0 9 * * *")  # Every day at 9 AM
+
+    def run(self):
+        # Generate daily report
+        pass
+```
+
+The `Schedule` class supports standard cron syntax and special strings:
+
+- `@yearly` or `@annually` - Run once a year
+- `@monthly` - Run once a month
+- `@weekly` - Run once a week
+- `@daily` or `@midnight` - Run once a day
+- `@hourly` - Run once an hour
+
+For custom schedules, see [`Schedule`](./scheduling.py#Schedule).
+
+## Admin interface
+
+The jobs package includes admin views for monitoring jobs under the "Jobs" section. The admin interface provides:
+
+- **Requests**: View pending jobs in the queue
+- **Processes**: Monitor currently running jobs
+- **Results**: Review completed and failed job history
+
+Dashboard cards show at-a-glance statistics for successful, errored, lost, and retried jobs.
+
+## Job history
+
+Job execution history is stored in the [`JobResult`](./models.py#JobResult) model. This includes:
+
+- Job class and parameters
+- Start and end times
+- Success/failure status
+- Error messages and tracebacks for failed jobs
+- Worker information
+
+History retention is controlled by the `JOBS_RESULTS_RETENTION` setting (defaults to 7 days):
+
+```python
+# app/settings.py
+JOBS_RESULTS_RETENTION = 60 * 60 * 24 * 30  # 30 days (in seconds)
+```
+
+Job timeout can be configured with `JOBS_TIMEOUT` (defaults to 1 day):
+
+```python
+# app/settings.py
+JOBS_TIMEOUT = 60 * 60 * 24  # 1 day (in seconds)
+```
+
+## Monitoring
+
+Workers report statistics and can be monitored using the `--stats-every` option:
+
+```bash
+# Report stats every 60 seconds
+plain jobs worker --stats-every 60
+```
+
+The worker integrates with OpenTelemetry for distributed tracing. Spans are created for:
+
+- Job scheduling (`run_in_worker`)
+- Job execution
+- Job completion/failure
+
+Jobs can be linked to the originating trace context, allowing you to track jobs initiated from web requests.
+
+## FAQs
+
+#### How do I ensure only one job runs at a time?
+
+Set a `concurrency_key` to automatically enforce uniqueness - only one job with the same key can be pending or processing:
+
+```python
+from plain.jobs import Job, register_job
+
+@register_job
+class ProcessUserJob(Job):
+    def __init__(self, user_id):
+        self.user_id = user_id
+
+    def default_concurrency_key(self):
+        return f"user-{self.user_id}"
+
+    def run(self):
+        process_user(self.user_id)
+
+# Usage
+ProcessUserJob(123).run_in_worker()  # Enqueued
+ProcessUserJob(123).run_in_worker()  # Returns None (blocked - job already pending/processing)
+```
+
+Alternatively, pass `concurrency_key` as a parameter to `run_in_worker()` instead of overriding the method.
+
+#### How do I implement custom concurrency limits?
+
+Use the `should_enqueue()` hook to implement custom concurrency control:
+
+```python
+class ProcessUserDataJob(Job):
+    def __init__(self, user_id):
+        self.user_id = user_id
+
+    def default_concurrency_key(self):
+        return f"user-{self.user_id}"
+
+    def should_enqueue(self, concurrency_key):
+        # Only allow 1 job per user at a time
+        processing = self.get_processing_jobs(concurrency_key).count()
+        pending = self.get_requested_jobs(concurrency_key).count()
+        return processing == 0 and pending == 0
+```
+
+For more patterns like rate limiting and global limits, see [`should_enqueue()`](./jobs.py#should_enqueue) in the source code.
+
+#### How are race conditions prevented?
+
+On **PostgreSQL**, plain-jobs uses [advisory locks](https://www.postgresql.org/docs/current/explicit-locking.html#ADVISORY-LOCKS) to ensure `should_enqueue()` checks are atomic with job creation. The lock is acquired during the transaction and automatically released when the transaction completes. This eliminates race conditions where multiple threads might simultaneously pass the `should_enqueue()` check.
+
+On **SQLite and MySQL**, advisory locks are not available, so a small race condition window exists between checking and creating jobs. For production deployments requiring strict concurrency guarantees, **we recommend PostgreSQL**.
+
+For custom locking behavior (Redis, etc.), override [`get_enqueue_lock()`](./locks.py#get_enqueue_lock).
+
+#### Can I run multiple workers?
+
+Yes, you can run multiple worker processes:
+
+```bash
+plain jobs worker --max-processes 4
+```
+
+Or run workers for specific queues:
+
+```bash
+plain jobs worker --queue slow --max-processes 2
+```
+
+#### How do I handle job failures?
+
+Set the number of retries and implement retry delays:
+
+```python
+class MyJob(Job):
+    def default_retries(self):
+        return 3
+
+    def calculate_retry_delay(self, attempt):
+        # Exponential backoff: 1s, 2s, 4s
+        return 2 ** (attempt - 1)
+```
+
+## Installation
+
+Install the `plain.jobs` package from [PyPI](https://pypi.org/project/plain.jobs/):
+
+```bash
+uv add plain.jobs
+```
+
+Add to your `INSTALLED_PACKAGES`:
+
+```python
+# app/settings.py
+INSTALLED_PACKAGES = [
+    ...
+    "plain.jobs",
+]
+```

plain_jobs-0.43.2.dist-info/RECORD

@@ -0,0 +1,30 @@
+plain/jobs/CHANGELOG.md,sha256=AZRc2EcCW8WpxefXr-WXT2it54-CJ9GSTH05Nib1WLU,22183
+plain/jobs/README.md,sha256=rZLhVm-g4qIBUlQ82eD-6xDWyFGDGlYwXFS0InLTPdE,8917
+plain/jobs/__init__.py,sha256=beHp1U4mfzaCD7H2ZFb4OIQLTZOyWIt3xOLkz1Acd4c,218
+plain/jobs/admin.py,sha256=BQ_f611hGhlNZYQdPRCS1oi8gfmIZQ-kvUSsxNZT4xI,7169
+plain/jobs/chores.py,sha256=oyVU-BfcJxMM3eK2_umn38N2mBsNpcDrZfpeEQju_DA,528
+plain/jobs/cli.py,sha256=ufb5n1ax-IxpmJFZVen-E7WBBEEr_3JFknNzFQd4STI,5882
+plain/jobs/config.py,sha256=PQsl-LxWsWLnjC98f0mvtdcCOuXvXKDMjrCRf1fq44Y,550
+plain/jobs/default_settings.py,sha256=r_95ucg_KY1XW1jarZy8VO3p-ylbllKMUrHzOPJiX6U,227
+plain/jobs/exceptions.py,sha256=KmFyw_VtA6rC2ZaTkYWsxgOyForRSjqe3xNUn2Wk-Sg,1193
+plain/jobs/jobs.py,sha256=iEwFx3_LBO0y1r22vPjrpzsC7c2Oysfc_yy8x1M3pBc,12823
+plain/jobs/locks.py,sha256=bGkYwCAmRYB1Cs7Ov6Fxj_fd5BBsuvJFbuPuD3bJQLM,1409
+plain/jobs/middleware.py,sha256=iQbVPnQz91OpkfNFsDh6-G0RLWW7KxYssUKdk7JEdNE,1228
+plain/jobs/models.py,sha256=IFDmdBzqMjRU8XneFwRuCZx8bdIJ4uTmG2HFl1MmY3g,21086
+plain/jobs/parameters.py,sha256=t9PwEZgwNCJx3YobsT-jfaVZdfMBS54XJcBrT9Wnsg0,6313
+plain/jobs/registry.py,sha256=Rwn5Htll10e549vD2Mu0oyoDynyHhE0bGYZ2bq9uzPU,1679
+plain/jobs/scheduling.py,sha256=b7IRPn_LmTPrINDt7wucv9AqCgcByCAfgeYxISUsHxg,7845
+plain/jobs/workers.py,sha256=SNbKOyR1vdmaUCpe9Uq7bRGH8AHIGFqnL-LMq6gmClQ,13405
+plain/jobs/migrations/0001_initial.py,sha256=EIgIEMVyTsStyx9dmKM8Jb_hwn694Yo31-74DZkNTqo,9452
+plain/jobs/migrations/0002_job_span_id_job_trace_id_jobrequest_span_id_and_more.py,sha256=ph5BwwOAwdfjdNh9RItYmX_IA29lO-Dd9GymYzvChXQ,1953
+plain/jobs/migrations/0003_rename_job_jobprocess_and_more.py,sha256=EdLucHxiH_QshLL2peIcMULRCQyFMPxh476AxCxW5Wk,2615
+plain/jobs/migrations/0004_rename_tables_to_plainjobs.py,sha256=huq-BVFccWFdVYsgyzZDEqAQK3pEIZkaBkm3E5nvhws,1055
+plain/jobs/migrations/0005_rename_constraints_and_indexes.py,sha256=PDGpOw6__tVfn-0BAFv_5OwWt6eBo2QF2kxeTZ92JKg,6408
+plain/jobs/migrations/0006_alter_jobprocess_table_alter_jobrequest_table_and_more.py,sha256=FY0_pcw0mL8MkUSatpDXWtA_xQw0kTZBGIyjLcmYeJE,546
+plain/jobs/migrations/0007_remove_jobrequest_plainjobs_jobrequest_unique_job_class_key_and_more.py,sha256=A5yPC3Gh2-wfE4-6YA_KlB6FKe-PghpKC6KbgKsO1c4,4685
+plain/jobs/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plain/jobs/templates/admin/plainqueue/jobresult_detail.html,sha256=Ybp1s_dARo_bFDcLEzEfETheP8SzqHHE_NNSKhv_eh8,198
+plain_jobs-0.43.2.dist-info/METADATA,sha256=c8enzKAexx8RF_ecKi9uL8zct1F6VUdt0tD43E8FL3c,9277
+plain_jobs-0.43.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+plain_jobs-0.43.2.dist-info/licenses/LICENSE,sha256=cvKM3OlqHx3ijD6e34zsSUkPvzl-ya3Dd63A6EHL94U,1500
+plain_jobs-0.43.2.dist-info/RECORD,,

plain_jobs-0.43.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any