threadmill 0.1.0__py3-none-any.whl

threadmill/__init__.py

@@ -0,0 +1,9 @@
+"""A queue agnostic worker for Django's task framework."""
+
+from . import _version
+
+__version__ = _version.version
+VERSION = _version.version_tuple
+
+
+__all__ = ["VERSION", "__version__"]

threadmill/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = 'g7270fd320'

threadmill/backends.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import datetime
+from abc import ABC
+
+from django.tasks import TaskResult
+from django.tasks.backends.base import BaseTaskBackend
+
+
+class AcknowledgeableTaskBackend(BaseTaskBackend, ABC):
+    """Provide an interface for tasks queues to be processed by the executor."""
+
+    supports_async_task = True
+    supports_get_result = True
+
+    def acquire(
+        self, *queue_names: str, timeout: datetime.timedelta | None = None
+    ) -> TaskResult:
+        """
+        Return and lock the next task to be processed without removing it from the queue.
+
+        Args:
+            queue_names: The names of the queues to acquire tasks from.
+            timeout: The maximum time to wait for a task. If None, wait indefinitely.
+
+        Raises:
+            TimeoutError: If no task is available within the specified timeout.
+            queue.Empty: If no task is available and timeout is None.
+        """
+        raise NotImplementedError
+
+    def acknowledge(self, task_result: TaskResult) -> None:
+        """Remove the task from the queue and publish the result."""
+        raise NotImplementedError

threadmill/executor.py

@@ -0,0 +1,307 @@
+"""Task worker executor implementation."""
+
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import datetime
+import logging
+import multiprocessing
+import random
+import socket
+import threading
+import time
+import typing
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import suppress
+from inspect import iscoroutinefunction
+from multiprocessing.queues import JoinableQueue
+from queue import Empty
+from traceback import format_exception
+
+from django.tasks import TaskResult
+from django.tasks.base import TaskContext, TaskError, TaskResultStatus
+from django.tasks.signals import task_finished, task_started
+from django.utils import timezone
+from django.utils.json import normalize_json
+
+if typing.TYPE_CHECKING:
+    from .backends import AcknowledgeableTaskBackend
+
+
+logger = multiprocessing.get_logger()
+formatter = logging.Formatter(
+    "%(levelname)s: %(asctime)s - pid=%(process)s - %(message)s"
+)
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+logger.setLevel(logging.INFO)
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class TaskExecutor:
+    """Consume tasks from shared joinable queues with process and thread pools."""
+
+    backend: AcknowledgeableTaskBackend
+    workers: int | None = None
+    threads: int = 1
+    max_tasks: int = 0
+    max_tasks_jitter: int = 0
+    task_timeout: datetime.timedelta = datetime.timedelta(hours=1)
+    is_acquiring: bool = dataclasses.field(default=True, init=False)
+    is_publishing: bool = dataclasses.field(default=True, init=False)
+    worker_processes: list[WorkerProcess] = dataclasses.field(
+        default_factory=list, init=False
+    )
+    process_count: int = dataclasses.field(init=False)
+    thread_count: int = dataclasses.field(init=False)
+    queues: tuple[str]
+    shared_task_queue: multiprocessing.JoinableQueue[TaskResult] = dataclasses.field(
+        init=False
+    )
+    processed_task_queue: multiprocessing.JoinableQueue[TaskResult] = dataclasses.field(
+        init=False
+    )
+    exit_empty: bool = False
+
+    def __post_init__(self) -> None:
+        """Initialize derived orchestration fields and queues."""
+        self.process_count = self.workers or max(multiprocessing.cpu_count() - 1, 1)
+        self.thread_count = max(self.threads, 1)
+        self.shared_task_queue = multiprocessing.JoinableQueue(
+            maxsize=self.process_count * self.thread_count,
+        )
+        self.processed_task_queue = multiprocessing.JoinableQueue()
+
+    def get_maximum_tasks_per_child(self) -> int | None:
+        """Return worker recycling limit based on config and thread count."""
+        if self.max_tasks:
+            return (
+                self.max_tasks + random.randint(0, self.max_tasks_jitter)  # noqa: S311
+            ) // self.thread_count
+
+    def create_worker_process(self) -> WorkerProcess:
+        """Create and start a new worker process."""
+        worker = WorkerProcess(
+            self.shared_task_queue,
+            self.processed_task_queue,
+            self.thread_count,
+            self.task_timeout,
+            self.get_maximum_tasks_per_child(),
+        )
+        worker.start()
+        return worker
+
+    def run(self) -> None:
+        """Start consuming tasks until shutdown is requested."""
+        self.worker_processes = [
+            self.create_worker_process() for _ in range(self.process_count)
+        ]
+        threads = [
+            threading.Thread(target=self.acknowledge_tasks, daemon=True),
+            threading.Thread(target=self.maintain_worker_pool, daemon=True),
+            threading.Thread(target=self.acquire_tasks, daemon=True),
+        ]
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+
+    def acquire_tasks(self) -> None:
+        """Buffer tasks in shared task queue."""
+        while self.is_acquiring:
+            try:
+                work = self.backend.acquire(*self.queues)
+            except Empty:
+                if self.exit_empty:
+                    logger.info("No more tasks to solve. Shutting down.")
+                    self.shutdown()
+                    return
+                time.sleep(0.01)
+            else:
+                self.shared_task_queue.put(work)
+
+    def acknowledge_tasks(self) -> None:
+        """Acknowledge processed tasks and publish updated results in main process."""
+        while self.is_publishing:
+            try:
+                task = self.processed_task_queue.get_nowait()
+            except Empty:
+                time.sleep(0.01)
+            else:
+                self.backend.acknowledge(task)
+                self.processed_task_queue.task_done()
+
+    def shutdown(self) -> None:
+        """Stop queue consumption and terminate all worker processes."""
+        logger.info("Shutting down task executor")
+        self.is_acquiring = False
+        with suppress(ValueError):
+            self.shared_task_queue.join()
+        with suppress(ValueError):
+            self.processed_task_queue.join()
+        with ThreadPoolExecutor(max_workers=self.process_count) as executor:
+            executor.map(lambda worker: worker.shutdown(), self.worker_processes)
+        self.is_publishing = False
+
+    def maintain_worker_pool(self) -> None:
+        """Restart worker processes that have exited."""
+        while self.is_publishing:
+            for index, worker in enumerate(self.worker_processes):
+                if worker.is_alive():
+                    continue
+                worker.join(timeout=0)
+                self.worker_processes[index] = self.create_worker_process()
+            time.sleep(1)
+
+
+class WorkerProcess(multiprocessing.Process):
+    """Single worker process running thread_count consumer threads."""
+
+    def __init__(
+        self,
+        task_queue: JoinableQueue[TaskResult],
+        processed_task_queue: JoinableQueue[TaskResult],
+        thread_count: int,
+        task_timeout: datetime.timedelta,
+        max_tasks: int | None = None,
+    ) -> None:
+        """Create process with dedicated thread pool for task execution."""
+        self.shutdown_requested = multiprocessing.Event()
+        super().__init__(daemon=True)
+        self.task_queue = task_queue
+        self.processed_task_queue = processed_task_queue
+        self.thread_count = thread_count
+        self.task_timeout = task_timeout
+        self.max_tasks = max_tasks
+        self.task_count = 0
+        self.lock: threading.Lock | None = None
+        self.expired: threading.Event | None = None
+
+    def run(self) -> None:
+        """Start consumer execution inside this process."""
+        logger.info("Starting worker process %s", self.name)
+        self.lock = threading.Lock()
+        self.expired = threading.Event()
+        consumer_threads = [
+            WorkerThread(worker=self, index=index) for index in range(self.thread_count)
+        ]
+        for consumer_thread in consumer_threads:
+            consumer_thread.start()
+        for consumer_thread in consumer_threads:
+            consumer_thread.join(self.task_timeout.total_seconds())
+
+    def record_task(self) -> None:
+        """Record one processed task and stop when max_tasks is reached."""
+        if self.max_tasks is None:
+            return
+        if self.lock is None or self.expired is None:
+            return
+        with self.lock:
+            self.task_count += 1
+            if self.task_count >= self.max_tasks:
+                self.expired.set()
+
+    def shutdown(self) -> None:
+        """Request graceful worker stop and wait for process exit."""
+        logger.info("Stopping worker process %s", self.name)
+        self.shutdown_requested.set()
+        self.join()
+
+
+class WorkerThread(threading.Thread):
+    """Single worker thread consuming tasks from the process queue."""
+
+    def __init__(
+        self,
+        *,
+        worker: WorkerProcess,
+        index: int,
+    ) -> None:
+        """Create worker thread bound to process worker state."""
+        super().__init__(name=f"{socket.gethostname()}:{worker.pid}-{index}")
+        self.worker = worker
+
+    def run(self) -> None:
+        """Start consuming tasks for this thread."""
+        while self.worker.expired is None or not self.worker.expired.is_set():
+            try:
+                task_result = self.worker.task_queue.get(timeout=1.0)
+            except Empty:
+                if self.worker.shutdown_requested.is_set():
+                    return
+                continue
+            try:
+                self.worker.processed_task_queue.put(
+                    self.execute_task_result(
+                        task_result,
+                    )
+                )
+            finally:
+                self.worker.task_queue.task_done()
+                self.worker.record_task()
+
+    def execute_task_result(self, task_result: TaskResult) -> TaskResult:
+        """Execute task from task result and update result lifecycle state."""
+        logger.info("Executing task %r", task_result.id)
+        started_at = timezone.now()
+        task_result = dataclasses.replace(
+            task_result,
+            status=TaskResultStatus.RUNNING,
+            started_at=started_at,
+            last_attempted_at=started_at,
+            worker_ids=[*task_result.worker_ids, self.name],
+        )
+        task_started.send(TaskExecutor, task_result=task_result)
+
+        try:
+            return_value = WorkerThread.call_task(task_result)
+        except Exception as exception:
+            task_result = dataclasses.replace(
+                task_result,
+                status=TaskResultStatus.FAILED,
+                errors=[*task_result.errors, WorkerThread.create_task_error(exception)],
+            )
+            logger.exception("Task failed %r", task_result.id)
+        else:
+            task_result = dataclasses.replace(
+                task_result,
+                status=TaskResultStatus.SUCCESSFUL,
+            )
+            object.__setattr__(
+                task_result, "_return_value", normalize_json(return_value)
+            )
+            logger.info("Task successful %r", task_result.id)
+        finally:
+            task_result = dataclasses.replace(
+                task_result,
+                finished_at=timezone.now(),
+            )
+            task_finished.send(TaskExecutor, task_result=task_result)
+
+        return task_result
+
+    @staticmethod
+    def call_task(task_result: TaskResult) -> typing.Any:
+        """Call a task with context when required."""
+        task = task_result.task
+        if task.takes_context:
+            args = [TaskContext(task_result=task_result), *task_result.args]
+        else:
+            args = task_result.args
+        if iscoroutinefunction(task.func):
+            return asyncio.run(task.func(*args, **task_result.kwargs))
+        return task.func(
+            *args,
+            **task_result.kwargs,
+        )
+
+    @staticmethod
+    def create_task_error(exception: BaseException) -> TaskError:
+        """Build a task error payload for failed execution."""
+        exception_type = type(exception)
+        return TaskError(
+            exception_class_path=f"{exception_type.__module__}.{exception_type.__qualname__}",
+            traceback="".join(format_exception(exception)),
+        )

threadmill/management/commands/threadmill.py

@@ -0,0 +1,132 @@
+import datetime
+import signal
+import sys
+
+from django.core.management import BaseCommand, CommandError
+from django.tasks import (
+    DEFAULT_TASK_BACKEND_ALIAS,
+    DEFAULT_TASK_QUEUE_NAME,
+    InvalidTaskBackend,
+    task_backends,
+)
+
+from ...executor import TaskExecutor
+
+
+def kill_softly(signum, frame):
+    """Raise a KeyboardInterrupt to stop the worker gracefully."""
+    signame = signal.Signals(signum).name
+    raise KeyboardInterrupt(f"Received {signame} ({signum}), shutting down…")
+
+
+class Command(BaseCommand):
+    """Run task workers to process enqueued tasks from the specified backends and queues."""
+
+    help = __doc__
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "-b",
+            "--backend",
+            default=DEFAULT_TASK_BACKEND_ALIAS,
+            help="Alias of the tasks backend to use.",
+        )
+        parser.add_argument(
+            "-q",
+            "--queues",
+            nargs="+",
+            default=[DEFAULT_TASK_QUEUE_NAME],
+            help="Queue names to listen to and process tasks from.",
+        )
+        parser.add_argument(
+            "-w",
+            "--workers",
+            type=int,
+            help="Number of worker processes to use. Defaults to the number of CPU cores minus one.",
+        )
+        parser.add_argument(
+            "-t",
+            "--threads",
+            type=int,
+            default=1,
+            help="Number of threads to use. Defaults to 1. ",
+        )
+        parser.add_argument(
+            "--max-tasks",
+            type=int,
+            default=0,
+            help=(
+                "Number of the maximum number of tasks to run until a worker is recycled."
+                " Defaults to 0, which means no limit."
+            ),
+        )
+        parser.add_argument(
+            "--max-tasks-jitter",
+            type=int,
+            default=0,
+            help="Maximum random jitter to add to the max-tasks value by randint(0, max_tasks_jitter).",
+        )
+        parser.add_argument(
+            "--task-timeout",
+            type=float,
+            default=3600.0,
+            help="Kill hung tasks after timeout seconds. Defaults to one hour.",
+        )
+        parser.add_argument(
+            "--task-backlog-size",
+            type=int,
+            default=1,
+            help="The number of tasks to prefetch from the message queue while all workers are busy. Defaults to 1.",
+        )
+        parser.add_argument(
+            "--exit-empty",
+            action="store_true",
+            help="Drain the task queue and exit with 0.",
+        )
+
+    def handle(
+        self,
+        *,
+        verbosity,
+        backend,
+        queues,
+        workers,
+        threads,
+        max_tasks,
+        max_tasks_jitter,
+        task_timeout,
+        exit_empty,
+        **options,
+    ):
+        match sys.platform:
+            case "win32":
+                signal.signal(signal.SIGBREAK, kill_softly)
+            case _:
+                signal.signal(signal.SIGHUP, kill_softly)
+        signal.signal(signal.SIGTERM, kill_softly)
+        signal.signal(signal.SIGINT, kill_softly)
+        self.stdout.write(self.style.SUCCESS("Starting workers…"))
+        try:
+            backend = task_backends[backend]
+        except InvalidTaskBackend:
+            raise CommandError(f"Invalid backend: {backend!r}")
+        if _non_queues := set(queues) - set(backend.queues):
+            raise CommandError(
+                f"Backend does not support all specified queues: {_non_queues!r}"
+            )
+        exe = TaskExecutor(
+            backend=backend,
+            workers=workers,
+            threads=threads,
+            max_tasks=max_tasks,
+            max_tasks_jitter=max_tasks_jitter,
+            task_timeout=datetime.timedelta(seconds=task_timeout),
+            exit_empty=exit_empty,
+            queues=queues,
+        )
+        try:
+            exe.run()
+        except KeyboardInterrupt as e:
+            self.stdout.write(self.style.WARNING(str(e)))
+            self.stdout.write(self.style.NOTICE("Shutting down workers…"))
+            exe.shutdown()

threadmill-0.1.0.dist-info/METADATA

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: threadmill
+Version: 0.1.0
+Summary: A queue agnostic worker for Django's task framework.
+Keywords: Django,tasks,worker
+Author-email: Johannes Maron <johannes@maron.family>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Environment :: Web Environment
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX
+Classifier: Topic :: Communications :: Email
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Software Development
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 6.1
+License-File: LICENSE
+Requires-Dist: django>=6.1a1
+Project-URL: Changelog, https://github.com/codingjoe/threadmill/releases
+Project-URL: Documentation, https://github.com/codingjoe/threadmill/
+Project-URL: Funding, https://github.com/sponsors/codingjoe
+Project-URL: Homepage, https://github.com/codingjoe/threadmill
+Project-URL: Issues, https://github.com/codingjoe/threadmill/issues
+Project-URL: Releasenotes, https://github.com/codingjoe/threadmill/releases/latest
+Project-URL: Source, https://github.com/codingjoe/threadmill
+
+# Threadmill
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/codingjoe/threadmill/raw/main/images/logo-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="https://github.com/codingjoe/threadmill/raw/main/images/logo-light.svg">
+    <img alt="Django Grinder: A queue agnostic worker for Django's task framework." src="https://github.com/codingjoe/threadmill/raw/main/images/logo-light.svg">
+  </picture>
+<br>
+  <a href="https://github.com/codingjoe/threadmill/">Documentation</a> |
+  <a href="https://github.com/codingjoe/threadmill/issues/new/choose">Issues</a> |
+  <a href="https://github.com/codingjoe/threadmill/releases">Changelog</a> |
+  <a href="https://github.com/sponsors/codingjoe">Funding</a> 💚
+</p>
+
+**A queue agnostic worker for Django's task framework.**
+
+## Design Principles
+
+- **Durability** – We recover from any failures, even poorly written tasks.
+- **Consistency** – We never lose data, even if someone unplugs the power or network.
+- **Utilization** – We keep the CPU saturated with tasks, not with idle time or waiting for locks.
+
+> [!WARNING]
+> Threadmill requires a development version of Django and is in a preview stage.
+
+[![PyPi Version](https://img.shields.io/pypi/v/threadmill.svg)](https://pypi.python.org/pypi/threadmill/)
+[![Test Coverage](https://codecov.io/gh/codingjoe/threadmill/branch/main/graph/badge.svg)](https://codecov.io/gh/codingjoe/threadmill)
+[![GitHub License](https://img.shields.io/github/license/codingjoe/threadmill)](https://raw.githubusercontent.com/codingjoe/threadmill/master/LICENSE)
+
+## Setup
+
+You need to have [Django's Task framework][django-tasks] setup properly.
+
+```console
+uv add threadmill
+```
+
+Add `threadmill` to your `INSTALLED_APPS` in `settings.py`:
+
+```python
+# settings.py
+INSTALLED_APPS = [
+    "threadmill",
+    # ...
+]
+```
+
+Finally, you launch the worker pool:
+
+```console
+uv run manage.py threadmill
+```
+
+## Usage
+
+The workers are inspired by Gunicorn, and the CLI is very similar.
+
+### Utilization
+
+Depending on your workload, you can tweak the number of processes and threads.
+Processes allow for parallel compute (no GIL) while threads are great for low-memory concurrent IO.
+
+```console
+uv run manage.py threadmill --processes 4 --threads 2
+```
+
+### Health
+
+If your tasks leak memory, you can recycle (restart) the workers after a certain number of tasks have been processed:
+
+```console
+uv run manage.py threadmill --max-tasks 1000 --max-tasks-jitter 100
+```
+
+This will restart the workers after 1000 tasks have been processed, with a random jitter of up to 100 tasks to avoid all workers restarting at the same time.
+
+Should a worker crash or be killed, the pool will automatically restart it.
+
+### Shutdown
+
+A graceful shutdown is possible with the `SIGTERM` or a keyboard interrupt.
+All workers will finish the tasks they acquired and publish them.
+
+You can use `--exit-empty` to exit immediately after all tasks have been processed,
+which might be useful for draining a one-off queue.
+
+### Task Backlog
+
+You can prefetch tasks from a queue to avoid IO latency bottlenecks.
+However, this will increase the memory usage of the worker pool.
+
+```console
+uv run manage.py threadmill --prefetch 100
+```
+
+### Task Timeouts
+
+> [!WARNING]
+> Work in progress, this feature is not yet stable.
+
+Task timeouts are important to ensure the long-term health of your pool.
+However, they need to be aligned with your queueing system's timeout settings.
+The message queue needs to requeue a task that hasn't been acknowledged within the timeout.
+
+## Integration
+
+> [!NOTE]
+> This section is for people who want to integrate Threadmill into their queueing system.
+
+Threadmill is designed to be durable and requires a queueing system to support late acknowledgement.
+
+To use Threadmill, your backend will need to inherit from `threadmill.backends.AcknowledgeableTaskBackend` and implement the following methods:
+
+```python
+class AcknowledgeableTaskBackend(BaseTaskBackend, ABC):
+    """Provide an interface for tasks queues to be processed by the executor."""
+
+    def acquire(
+        self, *queue_names: str, timeout: datetime.timedelta | None = None
+    ) -> TaskResult:
+        """
+        Return and lock the next task to be processed without removing it from the queue.
+
+        Args:
+            queue_names: The names of the queues to acquire tasks from.
+            timeout: The maximum time to wait for a task. If None, wait indefinitely.
+
+        Raises:
+            TimeoutError: If no task is available within the specified timeout.
+        """
+        raise NotImplementedError
+
+    def acknowledge(self, task_result: TaskResult) -> None:
+        """Remove the task from the queue and publish the result."""
+        raise NotImplementedError
+```
+

threadmill-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+threadmill/__init__.py,sha256=d74cITlnqi-fy8kpkAxnuko9LL3HNcJMdCLWF-1wo1w,187
+threadmill/_version.py,sha256=WfyBXn1Ch4X0PrFrN6x2PrPqz8ypEAzFgY_XX00HkLI,528
+threadmill/backends.py,sha256=YVEpPmweKxtfpLqXJXbHx9tOpqvTyetFeJMko4exrIc,1132
+threadmill/executor.py,sha256=iaEs3VCxeRc7JAqTspCZq-n367m8LmegWFOM0c0hP_0,11243
+threadmill/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+threadmill/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+threadmill/management/commands/threadmill.py,sha256=XiO4V0RF00tq1rHP__MdtYDcqDPAF-DbeELOG8yTqro,4109
+threadmill-0.1.0.dist-info/licenses/LICENSE,sha256=bUZFuK9dEiNN8YcEyAgR8ULo17q2FHLGr-tcqGTIr8A,1303
+threadmill-0.1.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+threadmill-0.1.0.dist-info/METADATA,sha256=XPuuFGsrefIXdn8Vgu0HwDGTm90aQ29k99KYzwQv4h0,6483
+threadmill-0.1.0.dist-info/RECORD,,

threadmill-0.1.0.dist-info/WHEEL

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

threadmill-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, Johannes Maron
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.