calltimeout 0.2.0__tar.gz

calltimeout-0.2.0/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

calltimeout-0.2.0/.github/FUNDING.yml

@@ -0,0 +1 @@
+buy_me_a_coffee: jlianesglrs

calltimeout-0.2.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/

calltimeout-0.2.0/CHANGELOG.md

@@ -0,0 +1,61 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.0]
+
+### Added
+
+- `mode="signal"`: a SIGALRM timer raises `CallTimeout` inside the call, which stops
+  pure Python code and blocking system calls in place. POSIX main thread only; other
+  threads get `RuntimeError` and Windows `NotImplementedError`. Timers already armed
+  keep their schedule (a raising outer handler runs once), so calls can be nested, and
+  a call that swallows the timeout still ends in `CallTimeout` when it returns, while
+  `KeyboardInterrupt`, `SystemExit` and unrelated errors propagate.
+- `with_timeout(timeout, *, mode, default)`: a decorator that keeps the wrapped
+  function's signature for type checkers (`ParamSpec`), in every mode including process
+  mode for functions the child can import by name (decorated in place or assigned to a
+  new name).
+- `CallCrashed`: raised in process mode when the child exits without a result, with its
+  exit code, as soon as it is gone.
+
+### Changed
+
+- Process mode waits on the result pipe and the process together, pickles results and
+  errors in the child (an unpicklable result raises `pickle.PicklingError` at once, an
+  unpicklable exception arrives as a `RuntimeError` stand-in), chains the child's
+  traceback as the cause, kills a child that ignores SIGTERM after 1 second, and stops
+  the child whenever the caller leaves early, including on `KeyboardInterrupt`.
+- Process mode notices a crashed child even while a grandchild it forked keeps the
+  pipes open.
+- Process mode pickles the call before starting the child, so a failed start cannot
+  leave the next call reading from a stale pipe on Windows; locks and queues, which
+  only pickle during start, are still passed through.
+- A finished child gets up to 1 second to exit on its own before it is terminated; a
+  result the parent cannot unpickle raises `pickle.UnpicklingError`.
+- `default` is returned only for the call's own timeout; a `CallTimeout` from a nested
+  call propagates.
+- Thread mode runs the call in a copy of the caller's context variables and names the
+  thread `calltimeout:<function>`.
+- `timeout` must be a real number (not a bool), not NaN and at most
+  `threading.TIMEOUT_MAX`; a zero timeout raises without starting the call. Coroutine
+  functions and coroutine results are rejected with a pointer to `asyncio.timeout`.
+  `kwargs` must be a mapping, and `run` and `with_timeout` reject modes the same way.
+- `CallTimeout` keeps its `timeout` through pickle and copy, and reports the validated
+  number of seconds.
+
+## [0.1.0]
+
+- First release.
+- `run(fn, timeout, *, args, kwargs, mode, default)` runs a callable under a
+  wall-clock timeout and returns its typed result.
+- Raises `CallTimeout` (a subclass of `TimeoutError`) on overrun, or returns
+  `default` when one is given.
+- `mode="thread"` (default) stops waiting but cannot kill a stuck,
+  non-cooperative call: the thread lingers until it returns or the process exits.
+- `mode="process"` truly terminates the call on overrun, at the cost of needing
+  picklable arguments and result.

calltimeout-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# Contributing
+
+Thanks for taking the time. This project keeps a small, predictable shape.
+
+## Setup
+
+```
+pip install -r requirements-dev.txt
+```
+
+## Before you open a pull request
+
+- Keep public API in `src/calltimeout/__init__.py`; internals live in `_`-prefixed modules.
+- Add a test for the behaviour you change. Tests inject time, disk and network; they
+  never touch the real thing.
+- Run `scripts/check.ps1` (format, lint, types, tests) and make sure it passes.
+- One logical change per commit, imperative subject line.
+
+Open an issue first if the change is large or shifts the public API.

calltimeout-0.2.0/IMPROVEMENTS-round.md

@@ -0,0 +1,160 @@
+# calltimeout improvement round
+
+Progress:
+- [x] Brainstorm ranked improvements (this file)
+- [x] Validation: timeout type, NaN, infinity, TIMEOUT_MAX, zero budget, coroutine functions
+- [x] Only this call's own timeout returns `default`; nested timeouts propagate
+- [x] Process mode: crash detection, unpicklable results and errors, kill after a grace period, cleanup on interrupt, remote traceback
+- [x] Thread mode: context variables, named threads, coroutine results
+- [x] Signal mode for POSIX main threads, with nesting and swallowed timeouts
+- [x] `with_timeout` decorator that keeps the signature (ParamSpec), process mode included
+- [x] `CallTimeout` and `CallCrashed` pickle and copy
+- [x] Contracts: typing, README examples, installed wheel e2e, POSIX run
+- [x] Docs: README, CHANGELOG, docstrings, packaging metadata
+- [x] Gates: ruff format, ruff check, mypy --strict, pytest
+- [x] Independent review findings fixed with regression tests
+- [x] Pull request opened (#2), guard clean
+
+## Starting point
+
+`0.1.0` runs a callable in a daemon thread or a child process and raises `CallTimeout`
+or returns `default`. Reading it against the standard library documentation turned up
+these gaps:
+
+- A child process that dies without a result (a crash, `os._exit`, the OOM killer) is
+  reported as a timeout, and only after the whole budget has been waited out.
+- A result or exception that cannot be pickled is lost in the queue's feeder thread: the
+  caller waits the full budget and gets `CallTimeout`, which is the wrong error.
+- On POSIX `terminate()` sends SIGTERM. A call that ignores SIGTERM makes `run` hang
+  forever in `process.join()`, with the timeout already spent.
+- If the waiting caller is interrupted (Ctrl+C, an outer timeout), the child process is
+  never terminated.
+- An exception from the child arrives without its traceback.
+- `default` is returned for any `CallTimeout` raised inside the call, including one from a
+  nested `run` that the outer call did not cause.
+- `CallTimeout` does not survive pickling: `timeout` comes back as the message string.
+- `timeout=nan` and `timeout=inf` fail with unrelated errors from `threading`, `True` is
+  accepted as one second, and a coroutine function returns an unawaited coroutine.
+- Thread mode drops the caller's context variables, unlike `asyncio.to_thread`.
+- There is no way to interrupt pure Python code in place on POSIX (SIGALRM), and no
+  decorator, so the call's arguments are never type-checked.
+
+## Sources (fetched 2026-10-12)
+
+- `threading`, https://docs.python.org/3/library/threading.html: `join()` always returns
+  None, so `is_alive()` decides whether it timed out; daemon threads are abruptly stopped
+  at shutdown and their resources may not be released.
+- `signal`, https://docs.python.org/3/library/signal.html: handlers always run in the main
+  thread and only the main thread may set one; a long calculation in C runs uninterrupted
+  until it finishes; `setitimer(ITIMER_REAL, ...)` delivers SIGALRM, takes seconds rounded
+  up to microseconds, returns the old `(delay, interval)` and is cleared by zero seconds;
+  on Windows `signal()` only accepts SIGABRT, SIGFPE, SIGILL, SIGINT, SIGSEGV, SIGTERM and
+  SIGBREAK; an exception from a handler may be raised after any bytecode instruction.
+- `multiprocessing`, https://docs.python.org/3/library/multiprocessing.html: `terminate()`
+  is SIGTERM on POSIX and TerminateProcess on Windows, skips finally clauses and orphans
+  descendant processes; `kill()` is SIGKILL; `sentinel` can be waited on with
+  `multiprocessing.connection.wait()`; since 3.14 the POSIX default start method is
+  forkserver.
+- `asyncio`, https://docs.python.org/3/library/asyncio-task.html: `asyncio.timeout(delay)`
+  limits time spent waiting in a coroutine; `asyncio.to_thread` propagates the current
+  `contextvars.Context` to the thread.
+- PEP 475, https://peps.python.org/pep-0475/: when a system call fails with EINTR and the
+  signal handler raises, the wrapper fails with that exception instead of retrying, so a
+  SIGALRM handler can interrupt `time.sleep` and blocking reads.
+
+## Ranked improvements
+
+1. **Process mode tells a crash from a timeout.** Wait on the result pipe and the process
+   sentinel together; a child that exits without a result raises `CallCrashed` with its
+   exit code at once, instead of `CallTimeout` after the full budget.
+2. **Process mode never hangs and never leaks.** Results and errors are pickled in the
+   child before they are sent, so an unpicklable value becomes a clear error; on overrun
+   the child gets `terminate()`, then `kill()` after a short grace period; a `finally`
+   stops the child whenever the caller leaves early. The child's traceback is chained as
+   the cause, as `concurrent.futures` does.
+3. **`default` only for this call's own timeout.** A `CallTimeout` from a nested call
+   propagates untouched.
+4. **Strict validation.** `timeout` must be a real number (not a bool), finite, not
+   negative and at most `threading.TIMEOUT_MAX`. A zero budget raises at once without
+   starting the call, in every mode. Coroutine functions are rejected with a pointer to
+   `asyncio.timeout`.
+5. **Signal mode.** `mode="signal"` arms `ITIMER_REAL` and raises `CallTimeout` inside the
+   call, which really stops pure Python code and blocking system calls in place, with no
+   thread and no pickling. Main thread on POSIX only, with clear errors elsewhere. The old
+   handler and any outer timer are restored with their remaining time, so nested calls
+   work; a call that swallows the timeout still ends in `CallTimeout`.
+6. **Thread mode like `asyncio.to_thread`.** The call runs in a copy of the caller's
+   context; threads are named after the call so a leaked one is recognisable in
+   `threading.enumerate()`; a call that returns a coroutine is rejected.
+7. **`with_timeout` decorator.** Keeps the wrapped signature with `ParamSpec`, so the
+   arguments are type-checked, and the result type becomes `T | D` with a default. It
+   works in process mode for module-level functions (the child runs the original).
+8. **Exceptions that travel.** `CallTimeout` and `CallCrashed` survive pickle and copy.
+9. **Typed public API, proven.** A test runs mypy on a snippet and checks inferred types,
+   the preserved signature, and rejection of wrong arguments.
+10. **Docs with runnable examples.** Every Python block in the README runs in the test
+    suite with its output pinned; a mechanism table states what each mode can and cannot
+    stop on Windows and POSIX; async usage is documented.
+11. **Packaging.** Classifiers for supported versions and operating systems, keywords,
+    version agreement with the metadata, and an installed-wheel e2e test.
+
+## Findings while implementing
+
+- On Windows, a process start that fails half way through pickling its arguments (a
+  lambda, say) left the next process-mode call of the same parent answering on a stale
+  pipe handle: the child ran, sent its result, and the parent saw a crash with exit code
+  0. Plain `multiprocessing` with a `Pipe` shows the same. Process mode now pickles the
+  call into bytes before it creates the pipe or the process, so a start cannot fail half
+  way (not under fork, where nothing is pickled).
+- Under fork and spawn on POSIX, a grandchild forked by the call inherits both the result
+  pipe and the sentinel pipe, so neither reports the child's exit while the grandchild
+  lives. Waiting now also checks `is_alive()` (waitpid) every 0.25 seconds, and the grace
+  period after `terminate()` is measured the same way instead of with `join(timeout)`.
+
+## Verification
+
+- Windows, Python 3.13 and 3.11; Linux (WSL), Python 3.14 under forkserver, fork and
+  spawn. `mypy --strict --python-version 3.10` on both platforms.
+- Mutations: each guard was removed in turn (pickle reducers, every validation check,
+  the zero-budget shortcut, the signal-mode platform check order, context copying,
+  thread names, the private expiry signal, up-front pickling, child cleanup, the rebuild
+  check, the remote traceback, result pickling, the decorator's child unwrapping and
+  `functools.wraps`; on Linux the waitpid fallback, the grace period, the kill, and in
+  signal mode the swallowed-timeout check, the outer re-arm, passing ticks on, handler
+  restore, disarming, the main-thread check and the deadline check). Every one made the
+  suite fail. Passing the process sentinel to `wait` is a latency optimisation: with the
+  waitpid fallback no test can fail without it.
+
+## Review fixes
+
+- Process mode passes locks, queues and other objects that only pickle inside
+  `Process.start()` instead of refusing them (pre-pickling falls back for them).
+- A finished child is no longer terminated the moment its result arrives: it gets up to
+  1 second to exit on its own, so atexit handlers and non-daemon threads complete.
+- An interrupt during the grace period still kills and reaps the child.
+- A result the parent cannot unpickle raises `pickle.UnpicklingError` chained to the
+  cause; a stand-in error is built even when `str()` of the original fails.
+- Signal mode delivers an outer one-shot tick once even when its handler raises;
+  `KeyboardInterrupt`, `SystemExit` and errors unrelated to the timeout propagate
+  instead of becoming the default; a SIGALRM handler set outside Python is refused
+  because it could not be restored.
+- The process-mode decorator sends the original function when only the original is
+  reachable by name (`fast = with_timeout(...)(slow)`).
+- Validation: a huge int is a `ValueError`, `kwargs` must be a mapping, `with_timeout`
+  rejects an unhashable mode like `run`, `CallTimeout` reports the validated float.
+- The zero-budget test now proves the call never ran with a marker file, which works
+  across processes.
+- Documented: a swallowed signal-mode timeout ends only when the call returns, a call
+  that resets `ITIMER_REAL` cancels the deadline, `sys.exit()` in process mode raises
+  `SystemExit` in the caller, exceptions in process mode are pickled copies.
+
+## Out of scope
+
+- Killing a thread: CPython has no safe way to do it. Thread mode documents the leak
+  instead of hiding it.
+- A start method parameter: process mode uses the platform default, which is what
+  `multiprocessing` users already configure with `set_start_method`.
+- Terminating grandchildren: `terminate()` orphans them by design; a call that spawns
+  processes must manage them itself.
+- An async API: coroutines already have `asyncio.timeout`. For blocking calls the README
+  shows `asyncio.to_thread(run, ...)`.

calltimeout-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javier Lianes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

calltimeout-0.2.0/PKG-INFO

@@ -0,0 +1,233 @@
+Metadata-Version: 2.5
+Name: calltimeout
+Version: 0.2.0
+Summary: Run a callable with a wall-clock timeout in a thread, a process or under SIGALRM, typed, with an honest choice of mechanism
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/calltimeout
+Project-URL: Issues, https://github.com/JaviLianes8/calltimeout/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/calltimeout/blob/main/CHANGELOG.md
+Project-URL: LinkedIn, https://www.linkedin.com/in/jlianes/
+Project-URL: Funding, https://buymeacoffee.com/jlianesglrs
+Author-email: Javier Lianes <javier@lianes8studio.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: deadline,decorator,multiprocessing,paramspec,sigalrm,signal,thread,timeout
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# calltimeout
+
+Run a callable with a wall-clock timeout and get a typed result or a clean
+`TimeoutError`, with an honest choice of mechanism.
+
+## Install
+
+```
+pip install calltimeout
+```
+
+Python 3.10 or newer, no dependencies.
+
+## Usage
+
+```python
+import time
+
+from calltimeout import CallTimeout, run
+
+
+def fetch(delay: float) -> str:
+    time.sleep(delay)
+    return "payload"
+
+
+# The result, when the call finishes in time.
+print(run(fetch, 2.0, args=(0.01,)))  # payload
+
+# CallTimeout, a subclass of TimeoutError, when it does not.
+try:
+    run(fetch, 0.05, args=(1.0,))
+except CallTimeout as exc:
+    print(f"gave up after {exc.timeout} seconds")  # gave up after 0.05 seconds
+
+# Or a fallback instead of raising.
+print(run(fetch, 0.05, args=(1.0,), default="cached"))  # cached
+```
+
+`run(fn, timeout, *, args=(), kwargs=None, mode="thread", default=...)` passes `args`
+and `kwargs` to `fn`. The timeout is a number of seconds: an `int` or `float`, not
+negative, not NaN and not infinite. A zero timeout raises at once without starting the
+call. Exceptions raised by the call reach the caller (in process mode as a pickled copy,
+see below). `default` is only used
+for this call's own timeout: a `CallTimeout` from a nested call inside `fn` propagates.
+`Mode` is the `Literal` type of the three mode names, for annotating your own wrappers.
+
+### As a decorator
+
+`with_timeout` keeps the decorated function's parameters, so type checkers still check
+every call, and the result type becomes `T | D` when a default is given. In process mode
+under spawn or forkserver the child imports the function by name, so either the
+decorated function or the original must be reachable under its module and name (a
+plain `@with_timeout` at module level, or `fast = with_timeout(...)(slow)`):
+
+```python
+import time
+
+from calltimeout import with_timeout
+
+
+@with_timeout(2.0)
+def add(left: int, right: int) -> int:
+    return left + right
+
+
+@with_timeout(0.05, default=None)
+def lookup(key: str) -> str:
+    time.sleep(1.0)
+    return key.upper()
+
+
+print(add(2, 3))  # 5
+print(lookup("id"))  # None
+```
+
+## Choosing a mechanism
+
+The trade-off is the whole point of the library, so it is stated plainly:
+
+| | `"thread"` (default) | `"process"` | `"signal"` |
+|---|---|---|---|
+| Stops a runaway call | No: it keeps running in a daemon thread | Yes: terminated, and killed if still alive 1 second later | Python code and blocking system calls: yes. A long call inside C: once it returns |
+| Where it works | Everywhere | Everywhere | POSIX, main thread only |
+| Pickling | Not needed | `fn`, its arguments and its result | Not needed |
+| Cost | A thread | A new process, whose start counts against the budget | A timer |
+| Context variables | A copy of the caller's, like `asyncio.to_thread` | Not shared | Shared: same thread |
+
+**Thread mode** runs the call in a daemon thread named `calltimeout:<function>` and
+stops waiting after the timeout. Python cannot stop a running thread, so a call that
+ignores the clock (a tight loop, a blocking call without its own timeout) keeps running
+after `run` has raised, until it returns or the process exits. Daemon threads are
+stopped abruptly at shutdown, so do not leave one holding a file or a transaction.
+
+**Process mode** runs the call in a child process and really stops it on overrun. A
+child that exits without a result (a crash, `os._exit`, the out-of-memory killer)
+raises `CallCrashed` with its exit code as soon as it is gone, instead of a timeout. An
+exception from the child arrives with the child's traceback chained as its cause, and a
+result that cannot be pickled raises `pickle.PicklingError` straight away (and one the
+parent cannot rebuild, `pickle.UnpicklingError`). An exception that cannot be pickled
+arrives as a `RuntimeError` naming it, and `sys.exit()` in the call raises `SystemExit`
+in the caller like any other exception. After the result arrives the child gets up to
+1 second to shut down on its own (atexit handlers, non-daemon threads) before it is
+terminated. Locks, queues and other `multiprocessing` objects can be passed as
+arguments. Processes started by the call itself are not stopped with it. Targets must be importable, so
+define them at module level, and guard the entry point of a script with
+`if __name__ == "__main__":` as `multiprocessing` requires.
+
+```python
+import math
+import os
+import time
+
+from calltimeout import CallCrashed, run
+
+print(run(math.factorial, 30.0, args=(20,), mode="process"))  # 2432902008176640000
+
+# The child is terminated, not left running.
+print(run(time.sleep, 0.5, args=(60,), mode="process", default="stopped"))  # stopped
+
+try:
+    run(os._exit, 30.0, args=(3,), mode="process")
+except CallCrashed as exc:
+    print(f"exit code {exc.exitcode}")  # exit code 3
+```
+
+**Signal mode** arms a `SIGALRM` timer and raises `CallTimeout` inside the call, at the
+line it has reached. Since PEP 475 a signal handler that raises also stops blocking
+system calls such as `time.sleep` or a socket read. It needs no thread and no pickling,
+but it only works in the main thread on POSIX: elsewhere it raises `RuntimeError`, and
+on Windows `NotImplementedError`. A call that catches the timeout and carries on still
+ends in `CallTimeout`, but only once it returns: the timer fires once, so a loop that
+keeps catching `OSError` (which `TimeoutError` is) runs on until it gives up. An
+exception raised while handling the timeout counts as the timeout; `KeyboardInterrupt`,
+`SystemExit` and unrelated errors propagate. Timers already armed with `setitimer` or
+`alarm` keep their schedule, so signal-mode calls can be nested, but a call that resets
+`ITIMER_REAL` itself cancels the deadline.
+
+```python
+import sys
+import time
+
+from calltimeout import CallTimeout, run
+
+if sys.platform != "win32":
+    try:
+        run(time.sleep, 0.1, args=(60,), mode="signal")
+    except CallTimeout as exc:
+        # The timeout was raised inside time.sleep and is chained as the cause.
+        print(f"interrupted: {type(exc.__cause__).__name__}")  # interrupted: CallTimeout
+```
+
+## In async code
+
+Coroutines already have `asyncio.timeout()`, and `run` refuses coroutine functions
+with a pointer to it. For a blocking call, run `run` in a worker thread so the event
+loop stays free; process mode then really stops the call:
+
+```python
+import asyncio
+import time
+
+from calltimeout import run
+
+
+async def main() -> str:
+    return await asyncio.to_thread(
+        run, time.sleep, 0.5, args=(60,), mode="process", default="stopped"
+    )
+
+
+print(asyncio.run(main()))  # stopped
+```
+
+## Why
+
+Running a function under a timeout is a common need, but the usual packages have
+gone stale and ship no type information:
+
+- [`func-timeout`](https://pypi.org/project/func-timeout/): last release 2019.
+- [`stopit`](https://pypi.org/project/stopit/): last release 2018.
+- [`timeout-decorator`](https://pypi.org/project/timeout-decorator/): last
+  release 2020.
+
+Beyond age, most of them hide the mechanism and quietly imply they can always
+cancel the work, which a thread cannot. `calltimeout` is small, fully typed
+(`mypy --strict`, `py.typed`), depends on nothing, and makes the choice between
+thread, process and signal explicit rather than a hidden surprise.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/