Bump minimum Python to 3.13 and modernize (#198)

Raise the minimum supported Python version to 3.13 and apply the
modernizations that unlocks:

- pyproject.toml: requires-python >=3.13; ty environment python-version
  3.13
- CI: drop the 3.9-3.12 test matrix rows, keep 3.13 and 3.14
- README/docs: update the advertised minimum version

Source:
- Adopt PEP 695 type-parameter syntax for the generic Proxy/Watcher
  classes, the computed/watch helpers and the Watchable/WatchCallback
  aliases, dropping the module-level TypeVar and typing.Generic bases
- init.py: drop the getattr guard around asyncio.eager_task_factory,
  which now always exists
- watcher.py: import TypeIs from typing (added in 3.13) instead of
  typing_extensions

Tests:
- Remove sys.version_info / hasattr(asyncio, "eager_task_factory")
  guards that are now always true
- Exclude __type_params__ (added by the native PEP 695 generic) from
  the wrapping-completeness check


Claude-Session: https://claude.ai/code/session_01XGH6yjPx1mpY134qtk6rXa

Co-authored-by: Claude <noreply@anthropic.com>

Author: Korijn

.github/workflows/ci.yml

@@ -56,14 +56,6 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - name: Linux py39
-            pyversion: "3.9"
-          - name: Linux py310
-            pyversion: "3.10"
-          - name: Linux py311
-            pyversion: "3.11"
-          - name: Linux py312
-            pyversion: "3.12"
           - name: Linux py313
             pyversion: "3.13"
           - name: Linux py314

README.md

@@ -12,7 +12,7 @@
 
 * **Automatic dependency tracking** — computed state knows exactly what it depends on and lazily re-evaluates only when needed.
 * **React to any change** — watch plain state or computed state and build unidirectional data flow: state changes drive view changes, input events drive state changes.
-* **Zero dependencies, framework agnostic** — a pure Python library (≥ 3.9) that plugs into any event loop: asyncio, Qt, or your own.
+* **Zero dependencies, framework agnostic** — a pure Python library (≥ 3.13) that plugs into any event loop: asyncio, Qt, or your own.
 * **Fully typed** — a [PEP 561](https://peps.python.org/pep-0561/) typed package, checked with [ty](https://github.com/astral-sh/ty) in CI.
 
 ## Quick start

docs/getting-started/installation.md

@@ -1,6 +1,6 @@
 # Installation
 
-Observ is published on [PyPI](https://pypi.org/project/observ/) and has **no dependencies**. It supports Python 3.9 and up.
+Observ is published on [PyPI](https://pypi.org/project/observ/) and has **no dependencies**. It supports Python 3.13 and up.
 
 === "uv"
 

docs/guide/scheduling.md

@@ -21,7 +21,7 @@ You can also pass a specific loop: `scheduler.register_asyncio(loop)`.
 
 !!! tip "Eager task factory"
 
-    On Python 3.12+, observ's `loop_factory()` helper creates a new event loop with the [eager task factory](https://docs.python.org/3/library/asyncio-task.html#asyncio.eager_task_factory) enabled, which reduces the latency of the async callbacks and watched functions that observ schedules as tasks:
+    observ's `loop_factory()` helper creates a new event loop with the [eager task factory](https://docs.python.org/3/library/asyncio-task.html#asyncio.eager_task_factory) enabled, which reduces the latency of the async callbacks and watched functions that observ schedules as tasks:
 
     ```python
     import asyncio

docs/index.md

@@ -1,6 +1,6 @@
 # Observ 👁
 
-Observ is a Python port of [Vue.js](https://vuejs.org/)' [computed properties and watchers](https://vuejs.org/guide/essentials/reactivity-fundamentals.html). It is event loop/framework agnostic and has no dependencies, so it can be used in any project targeting Python >= 3.9.
+Observ is a Python port of [Vue.js](https://vuejs.org/)' [computed properties and watchers](https://vuejs.org/guide/essentials/reactivity-fundamentals.html). It is event loop/framework agnostic and has no dependencies, so it can be used in any project targeting Python >= 3.13.
 
 Observ provides two benefits for stateful applications:
 

observ/init.py

@@ -37,11 +37,9 @@ def init(
 def loop_factory() -> asyncio.AbstractEventLoop:
     """
     Creates a new asyncio event loop with the eager task factory
-    enabled (Python 3.12+), which reduces the latency of the tasks
-    that observ schedules for async functions and callbacks.
+    enabled, which reduces the latency of the tasks that observ
+    schedules for async functions and callbacks.
     """
     loop = asyncio.new_event_loop()
-    eager_task_factory = getattr(asyncio, "eager_task_factory", None)
-    if eager_task_factory is not None:
-        loop.set_task_factory(eager_task_factory)
+    loop.set_task_factory(asyncio.eager_task_factory)
     return loop

observ/proxy.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from copy import copy, deepcopy
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast
+from typing import TYPE_CHECKING, Any, cast
 
 from .proxy_db import proxy_db
 
@@ -10,10 +10,8 @@
 
     from .proxy_db import TargetDep
 
-T = TypeVar("T")
 
-
-class Proxy(Generic[T]):
+class Proxy[T]:
     """
     Proxy for an object/target.
 
@@ -64,7 +62,7 @@ def __deepcopy__(self, memo: dict[int, Any]) -> T:
 PLAIN_TYPES: frozenset[type] = frozenset({type(None), bool, int, float, str, bytes})
 
 
-def proxy(target: T, readonly: bool = False, shallow: bool = False) -> T:
+def proxy[T](target: T, readonly: bool = False, shallow: bool = False) -> T:
     """
     Returns a Proxy for the given object. If a proxy for the given
     configuration already exists, it will return that instead of
@@ -123,14 +121,13 @@ def proxy(target: T, readonly: bool = False, shallow: bool = False) -> T:
 
 
 if TYPE_CHECKING:
-    # Only used for typing: at runtime a Ref is a plain (proxied) dict.
-    # Defined here (instead of unconditionally) because a generic
-    # TypedDict requires Python 3.11
-    class Ref(TypedDict, Generic[T]):
+    # Only used for typing: at runtime a Ref is a plain (proxied) dict,
+    # so it is kept behind TYPE_CHECKING and never constructed.
+    class Ref[T](TypedDict):
         value: T
 
 
-def ref(target: T) -> Ref[T]:
+def ref[T](target: T) -> Ref[T]:
     """
     Returns a reactive dict with a single 'value' key, set to the
     given target. Useful for making a single (plain) value reactive.
@@ -141,30 +138,30 @@ def ref(target: T) -> Ref[T]:
 reactive = proxy
 
 
-def readonly(target: T) -> T:
+def readonly[T](target: T) -> T:
     """
     Returns a readonly proxy for the given target: reads are tracked,
     but any write raises a ReadonlyError.
     """
     return proxy(target, readonly=True)
 
 
-def shallow_reactive(target: T) -> T:
+def shallow_reactive[T](target: T) -> T:
     """
     Returns a shallow proxy for the given target: only the first level
     of the target is made reactive, nested values are returned raw.
     """
     return proxy(target, shallow=True)
 
 
-def shallow_readonly(target: T) -> T:
+def shallow_readonly[T](target: T) -> T:
     """
     Combination of `shallow_reactive` and `readonly`.
     """
     return proxy(target, readonly=True, shallow=True)
 
 
-def trigger_ref(target: Proxy[T] | T) -> None:
+def trigger_ref[T](target: Proxy[T] | T) -> None:
     """
     Force-notify the watchers that depend on the given proxy, as if
     its first level was written to. This is typically used together
@@ -192,7 +189,7 @@ def trigger_ref(target: Proxy[T] | T) -> None:
     dep.notify()
 
 
-def to_raw(target: Proxy[T] | T) -> T:
+def to_raw[T](target: Proxy[T] | T) -> T:
     """
     Returns a raw object from which any trace of proxy has been replaced
     with its wrapped target value.
@@ -201,7 +198,7 @@ def to_raw(target: Proxy[T] | T) -> T:
     # that rebuilding a container from its (recursively unproxied)
     # items yields a value of the same type as the original target
     if isinstance(target, Proxy):
-        return to_raw(target.__target__)
+        return cast(T, to_raw(target.__target__))
 
     if isinstance(target, list):
         return cast(T, [to_raw(t) for t in target])

observ/watcher.py

@@ -12,32 +12,30 @@
 from collections.abc import Container
 from functools import wraps
 from itertools import count
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast, overload
+from typing import TYPE_CHECKING, Any, cast, overload
 from weakref import ref
 
 from .dep import Dep
 from .proxy import PLAIN_TYPES, Proxy, proxy
 from .proxy_db import proxy_db
 from .scheduler import scheduler
 
-T = TypeVar("T")
-
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Callable
     from types import MethodType
-    from typing import ClassVar, Protocol
-
-    from typing_extensions import TypeIs
+    from typing import ClassVar, Protocol, TypeIs
 
     # Something that can be watched: a function (which doesn't have to
     # return anything) or a coroutine function, or a proxy (or other
     # container of proxies), which implies deep watching
-    Watchable = Callable[[], T] | Callable[[], Awaitable[T]] | T
+    type Watchable[T] = Callable[[], T] | Callable[[], Awaitable[T]] | T
     # Callbacks may accept zero, one (new value) or two
     # (new and old value) arguments
-    WatchCallback = Callable[[], Any] | Callable[[T], Any] | Callable[[T, T], Any]
+    type WatchCallback[T] = (
+        Callable[[], Any] | Callable[[T], Any] | Callable[[T, T], Any]
+    )
 
-    class Computed(Protocol[T]):
+    class Computed[T](Protocol):
         """
         The cached getter returned by `computed`.
         """
@@ -47,7 +45,7 @@ class Computed(Protocol[T]):
         def __call__(self) -> T: ...
 
 
-def watch(
+def watch[T](
     fn: Watchable[T],
     callback: WatchCallback[T] | None = None,
     sync: bool = False,
@@ -81,7 +79,7 @@ def watch(
     return watcher
 
 
-def watch_effect(
+def watch_effect[T](
     fn: Watchable[T],
     sync: bool = False,
     deep: bool = True,
@@ -95,14 +93,14 @@ def watch_effect(
 
 
 @overload
-def computed(_fn: Callable[[], T]) -> Computed[T]: ...
+def computed[T](_fn: Callable[[], T]) -> Computed[T]: ...
 
 
 @overload
-def computed(*, deep: bool = True) -> Callable[[Callable[[], T]], Computed[T]]: ...
+def computed[T](*, deep: bool = True) -> Callable[[Callable[[], T]], Computed[T]]: ...
 
 
-def computed(
+def computed[T](
     _fn: Callable[[], T] | None = None, *, deep: bool = True
 ) -> Computed[T] | Callable[[Callable[[], T]], Computed[T]]:
     """
@@ -245,7 +243,7 @@ class WrongNumberOfArgumentsError(TypeError):
     pass
 
 
-class Watcher(Generic[T]):
+class Watcher[T]:
     __slots__ = (
         "__weakref__",
         "_active",

pyproject.toml

@@ -6,7 +6,7 @@ authors = [
     { name = "Korijn van Golen", email = "korijn@gmail.com" },
     { name = "Berend Klein Haneveld", email = "berendkleinhaneveld@gmail.com" },
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.13"
 readme = "README.md"
 license = "MIT"
 classifiers = ["Typing :: Typed"]
@@ -73,7 +73,7 @@ include = ["observ"]
 [tool.ty.environment]
 # Match the oldest supported Python version (requires-python), so
 # that the type checker catches use of newer typing features
-python-version = "3.9"
+python-version = "3.13"
 
 [tool.pytest.ini_options]
 # GC pauses during timed rounds are a major source of benchmark noise

tests/test_asyncio.py

@@ -22,10 +22,6 @@ def plain_loop():
 
 
 def create_eager_loop():
-    # only python>=3.12
-    if not hasattr(asyncio, "eager_task_factory"):
-        pytest.skip()
-
     loop = create_plain_loop()
     loop.set_task_factory(asyncio.eager_task_factory)
     return loop