feat: update pyproject.toml

Author: brian14708

.devcontainer/devcontainer.json

@@ -5,7 +5,7 @@
     "ghcr.io/devcontainers-extra/features/nox:2": {},
     "ghcr.io/devcontainers-extra/features/uv:1": {}
   },
-  "postCreateCommand": "uv sync --all-groups --all-extras",
+  "postCreateCommand": "uv sync",
   "appPort": [],
   "customizations": {
     "vscode": {

.github/workflows/ci.yaml

@@ -27,12 +27,14 @@ jobs:
         with:
           enable-cache: true
       - name: Sync dependencies
-        run: uv sync --all-groups --all-extras --no-group docs
+        run: uv sync
       - name: Run tests
         run: uv run pytest
       - name: Run linter
-        run: uv run ruff check .
+        run: uv run ruff check
+      - name: Run formatter
+        run: uv run ruff format --check
       - name: Run mypy
-        run: uv run mypy .
+        run: uv run mypy
       - name: Run basedpyright
-        run: uv run basedpyright .
+        run: uv run basedpyright

noxfile.py

@@ -12,30 +12,42 @@
 
 def install_deps(s: nox.Session, groups: list[str]) -> None:
     s.env["UV_PROJECT_ENVIRONMENT"] = s.virtualenv.location
-    cmd = ["uv", "sync", "--frozen", "--all-extras"]
+    cmd = ["uv", "sync", "--frozen"]
+    cmd.append("--no-dev")
     for g in groups:
         cmd.extend(("--group", g))
     _ = s.run_install(*cmd)
 
 
-@nox.session(python=ALL_PYTHON)
-def test(s: nox.Session) -> None:
-    install_deps(s, [])
+@nox.session(reuse_venv=True, default=False)
+def check(s: nox.Session) -> None:
+    install_deps(s, ["test", "typing", "lint"])
+    _ = s.run("ruff", "format")
+    _ = s.run("ruff", "check", "--fix")
+    _ = s.run("ruff", "format")
     _ = s.run("pytest")
+    _ = s.run("mypy")
+    _ = s.run("basedpyright", "--venvpath", s.virtualenv.location)
 
 
 @nox.session(python=ALL_PYTHON)
+def test(s: nox.Session) -> None:
+    install_deps(s, ["test"])
+    _ = s.run("pytest", "--runslow")
+
+
+@nox.session
 def type_check(s: nox.Session) -> None:
-    install_deps(s, ["type-checking", "examples"])
+    install_deps(s, ["typing", "examples"])
     _ = s.run("mypy", ".")
     _ = s.run("basedpyright", "--venvpath", s.virtualenv.location, ".")
 
 
 @nox.session
 def lint(s: nox.Session) -> None:
     install_deps(s, ["lint"])
-    _ = s.run("ruff", "check", ".")
-    _ = s.run("ruff", "format", "--check", ".")
+    _ = s.run("ruff", "check")
+    _ = s.run("ruff", "format", "--check")
 
 
 @nox.session

pyproject.toml

@@ -15,28 +15,35 @@ build-backend = "uv_build"
 
 [dependency-groups]
 dev = [
-    "pydantic>=2.11.9",
-    "pytest-asyncio>=0.21",
-    "pytest-codspeed>=4.1.1",
-    "pytest>=7.0",
+    {include-group = "lint"},
+    {include-group = "test"},
+    {include-group = "typing"},
 ]
-type-checking = [
-    "basedmypy>=2.10.0",
-    "basedpyright>=1.31.2",
+test = [
+    "pytest",
+    "pytest-asyncio",
+    "pytest-codspeed",
+    "pydantic",
+]
+typing = [
+    "basedmypy",
+    "basedpyright",
+    "pytest",
+    "pydantic",
 ]
 lint = [
-    "ruff>=0.12.8",
+    "ruff",
 ]
 docs = [
-    "mkdocs-material>=9.6.18",
-    "mkdocs-mermaid2-plugin>=1.2.1",
-    "mkdocs>=1.6.1",
-    "mkdocstrings[python]>=0.30.0",
+    "mkdocs",
+    "mkdocs-material",
+    "mkdocs-mermaid2-plugin",
+    "mkdocstrings[python]",
 ]
 examples = [
-    "openai>=2.2.0",
-    "pydantic>=2.11.9",
-    "rich>=14.1.0",
+    "openai",
+    "pydantic",
+    "rich",
 ]
 
 [tool.ruff.lint]
@@ -70,15 +77,20 @@ preview = true
 docstring-code-format = true
 
 [tool.mypy]
+files = ["src", "tests"]
+strict = true
+python_version = "3.10"
 disable_error_code = [
     "decorated-any",
     "explicit-any",
     "any",
 ]
 
 [tool.pyright]
+include = ["src", "tests"]
 venv = "."
 venvPath = ".venv"
+typeCheckingMode = "strict"
 enableExperimentalFeatures = true
 reportAny = false
 reportExplicitAny = false

src/duron/_core/context.py

@@ -104,7 +104,9 @@ async def run(
             raise RuntimeError(msg)
 
         if isinstance(fn, CheckpointOp):
-            async with self.run_stream(fn, *args, **kwargs) as stream:
+            async with self.run_stream(
+                cast("CheckpointOp[_P, _T, Any]", fn), *args, **kwargs
+            ) as stream:
                 await stream.discard()
                 return await stream
 
@@ -142,7 +144,7 @@ def run_stream(
             fn.action_type,
             fn.initial(),
             fn.reducer,
-            fn,
+            fn.fn,
             *args,
             **kwargs,
         )

tests/conftest.py

@@ -0,0 +1,24 @@
+from typing import cast
+
+import pytest
+
+
+def pytest_addoption(parser: pytest.OptionGroup) -> None:
+    parser.addoption(
+        "--runslow", action="store_true", default=False, help="run slow tests"
+    )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line("markers", "slow: mark test as slow to run")
+
+
+def pytest_collection_modifyitems(
+    config: pytest.Config, items: list[pytest.Item]
+) -> None:
+    if cast("bool", cast("object", config.getoption("--runslow"))):
+        return
+    skip_slow = pytest.mark.skip(reason="need --runslow option to run")
+    for item in items:
+        if "slow" in item.keywords:
+            item.add_marker(skip_slow)

tests/test_pydantic.py

@@ -3,8 +3,8 @@
 from typing import TYPE_CHECKING, cast
 from typing_extensions import Any, override
 
+import pydantic
 import pytest
-from pydantic import BaseModel, TypeAdapter
 
 from duron import Context, fn
 from duron.codec import Codec
@@ -15,26 +15,29 @@
     from duron.typing import TypeHint
 
 
-class PydanticPoint(BaseModel):
+class PydanticPoint(pydantic.BaseModel):
     x: int
     y: int
 
 
-class PydanticCodec(Codec):
-    @override
-    def encode_json(self, result: object) -> JSONValue:
-        return cast(
-            "JSONValue",
-            TypeAdapter(type(result)).dump_python(result, mode="json"),
-        )
-
-    @override
-    def decode_json(self, encoded: JSONValue, expected_type: TypeHint[Any]) -> object:
-        return cast("object", TypeAdapter(expected_type).validate_python(encoded))
-
-
 @pytest.mark.asyncio
 async def test_pydantic_serialize() -> None:
+    class PydanticCodec(Codec):
+        @override
+        def encode_json(self, result: object) -> JSONValue:
+            return cast(
+                "JSONValue",
+                pydantic.TypeAdapter(type(result)).dump_python(result, mode="json"),
+            )
+
+        @override
+        def decode_json(
+            self, encoded: JSONValue, expected_type: TypeHint[Any]
+        ) -> object:
+            return cast(
+                "object", pydantic.TypeAdapter(expected_type).validate_python(encoded)
+            )
+
     @fn(codec=PydanticCodec())
     async def activity(ctx: Context) -> PydanticPoint:
         def new_pt() -> PydanticPoint: