refactor: tighten lints

Author: brian14708

examples/__init__.py

@@ -4,16 +4,12 @@
 import asyncio
 from pathlib import Path
 from typing import TYPE_CHECKING, cast
+from typing_extensions import override
 
 from openai import AsyncOpenAI
-from openai.lib.streaming.chat import (
-    ChatCompletionStreamState,
-)
-from openai.types.chat import (
-    ChatCompletionChunk,
-)
+from openai.lib.streaming.chat import ChatCompletionStreamState
+from openai.types.chat import ChatCompletionChunk
 from pydantic import TypeAdapter
-from typing_extensions import override
 
 import duron
 from duron import RunOptions, op
@@ -22,12 +18,12 @@
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
+    from typing import Any
 
     from openai.types.chat import (
         ChatCompletionMessageParam,
         ParsedChatCompletionMessage,
     )
-    from typing_extensions import Any
 
     from duron.codec import JSONValue
     from duron.typing import TypeHint
@@ -43,7 +39,9 @@ def encode_json(self, result: object) -> JSONValue:
         return cast(
             "JSONValue",
             TypeAdapter(type(result)).dump_python(
-                result, mode="json", exclude_none=True
+                result,
+                mode="json",
+                exclude_none=True,
             ),
         )
 
@@ -53,8 +51,8 @@ def decode_json(self, encoded: JSONValue, expected_type: TypeHint[Any]) -> objec
 
 
 @duron.fn(codec=PydanticCodec())
-async def agent_fn(ctx: duron.Context):
-    completion_result = await completion(
+async def agent_fn(ctx: duron.Context) -> None:
+    _ = await completion(
         ctx,
         messages=[
             {
@@ -67,13 +65,15 @@ async def agent_fn(ctx: duron.Context):
             },
         ],
     )
-    print(completion_result.content)
 
 
-async def main():
+async def main() -> None:
     parser = argparse.ArgumentParser(description="Duron Agent Example")
     _ = parser.add_argument(
-        "--session-id", type=str, required=True, help="Session ID for log storage"
+        "--session-id",
+        type=str,
+        required=True,
+        help="Session ID for log storage",
     )
     args = parser.parse_args()
 
@@ -84,7 +84,8 @@ async def main():
 
 
 async def completion(
-    ctx: duron.Context, messages: list[ChatCompletionMessageParam]
+    ctx: duron.Context,
+    messages: list[ChatCompletionMessageParam],
 ) -> ParsedChatCompletionMessage[None]:
     @op(
         checkpoint=True,
@@ -103,7 +104,8 @@ async def _completion_stream(
     ) -> AsyncGenerator[ChatCompletionChunk, ChatCompletionStreamState | None]:
         if prev:
             msg = prev.current_completion_snapshot.choices[0].message
-            messages = messages + [
+            messages = [
+                *messages,
                 {
                     "role": "assistant",
                     "content": msg.content,
@@ -120,7 +122,7 @@ async def _completion_stream(
                     )
                     if msg.tool_calls
                     else (),
-                }
+                },
             ]
         async for chunk in await client.chat.completions.create(
             messages=messages,

examples/agent.py

@@ -1,4 +1,4 @@
-# type: ignore
+# type: ignore  # noqa: PGH003
 # pyright: basic, reportMissingImports=false
 
 from __future__ import annotations
@@ -10,7 +10,7 @@
 ALL_PYTHON = ["3.14", "3.13", "3.12", "3.11", "3.10"]
 
 
-def install_deps(s: nox.Session, groups: list[str]):
+def install_deps(s: nox.Session, groups: list[str]) -> None:
     s.env["UV_PROJECT_ENVIRONMENT"] = s.virtualenv.location
     cmd = ["uv", "sync", "--frozen"]
     for g in groups:

noxfile.py

@@ -38,19 +38,20 @@ examples = [
 ]
 
 [tool.ruff.lint]
-select = [
-    "E",
-    "F",
-    "UP",
-    "B",
-    "SIM",
-    "I",
-    "TC",
+select = ["ALL"]
+ignore = [
+    "COM812",
+    "CPY", "D",
+    "S101", "S311",
+    "PLR0", "PLR1", "PLR2", "C901",
 ]
 extend-safe-fixes = ["TC"]
 preview = true
 future-annotations = true
 
+[tool.ruff.lint.isort]
+extra-standard-library = ["typing_extensions"]
+
 [tool.ruff.lint.flake8-type-checking]
 runtime-evaluated-base-classes = ["typing_extensions.TypedDict"]
 runtime-evaluated-decorators = ["duron.fn"]
@@ -60,6 +61,7 @@ runtime-evaluated-decorators = ["duron.fn"]
 
 [tool.ruff.format]
 preview = true
+docstring-code-format = true
 
 [tool.mypy]
 disable_error_code = [

pyproject.toml

@@ -23,7 +23,6 @@
     from collections.abc import Callable, Coroutine
     from contextvars import Token
     from types import TracebackType
-
     from typing_extensions import AsyncContextManager
 
     from duron._core.options import RunOptions
@@ -60,15 +59,16 @@ def __exit__(
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
-    ):
+    ) -> None:
         if self._token:
             _context.reset(self._token)
 
     @staticmethod
     def current() -> Context:
         ctx = _context.get()
         if ctx is None:
-            raise RuntimeError("No duron context is active")
+            msg = "No duron context is active"
+            raise RuntimeError(msg)
         return ctx
 
     @overload
@@ -100,7 +100,8 @@ async def run(
         **kwargs: _P.kwargs,
     ) -> _T:
         if asyncio.get_running_loop() is not self._loop:
-            raise RuntimeError("Context time can only be used in the context loop")
+            msg = "Context time can only be used in the context loop"
+            raise RuntimeError(msg)
 
         if isinstance(fn, CheckpointOp):
             async with self.run_stream(fn, options, *args, **kwargs) as stream:
@@ -111,7 +112,7 @@ async def run(
             fn.return_type
             if isinstance(fn, Op) and fn.return_type
             else self._task.codec.inspect_function(
-                cast("Callable[..., object]", fn)
+                cast("Callable[..., object]", fn),
             ).return_type
         )
 
@@ -138,8 +139,9 @@ def run_stream(
     ) -> AsyncContextManager[Stream[_S, _T]]:
         _ = options
         if asyncio.get_running_loop() is not self._loop:
-            raise RuntimeError("Context time can only be used in the context loop")
-        r = run_stream(
+            msg = "Context time can only be used in the context loop"
+            raise RuntimeError(msg)
+        return run_stream(
             self._loop,
             fn.action_type,
             fn.initial(),
@@ -148,7 +150,6 @@ def run_stream(
             *args,
             **kwargs,
         )
-        return r
 
     async def create_stream(
         self,
@@ -158,9 +159,13 @@ async def create_stream(
         metadata: dict[str, JSONValue] | None = None,
     ) -> tuple[Stream[_T, None], StreamWriter[_T]]:
         if asyncio.get_running_loop() is not self._loop:
-            raise RuntimeError("Context time can only be used in the context loop")
+            msg = "Context time can only be used in the context loop"
+            raise RuntimeError(msg)
         return await create_stream(
-            self._loop, dtype, external=external, metadata=metadata
+            self._loop,
+            dtype,
+            external=external,
+            metadata=metadata,
         )
 
     async def create_signal(
@@ -170,7 +175,8 @@ async def create_signal(
         metadata: dict[str, JSONValue] | None = None,
     ) -> tuple[Signal[_T], SignalWriter[_T]]:
         if asyncio.get_running_loop() is not self._loop:
-            raise RuntimeError("Context time can only be used in the context loop")
+            msg = "Context time can only be used in the context loop"
+            raise RuntimeError(msg)
         return await create_signal(self._loop, dtype, metadata=metadata)
 
     async def create_promise(
@@ -180,28 +186,34 @@ async def create_promise(
         metadata: dict[str, JSONValue] | None = None,
     ) -> tuple[str, asyncio.Future[_T]]:
         if asyncio.get_running_loop() is not self._loop:
-            raise RuntimeError("Context time can only be used in the context loop")
+            msg = "Context time can only be used in the context loop"
+            raise RuntimeError(msg)
         fut = create_op(
-            self._loop, ExternalPromiseCreate(metadata=metadata, return_type=dtype)
+            self._loop,
+            ExternalPromiseCreate(metadata=metadata, return_type=dtype),
         )
         return (base64.b64encode(fut.id).decode(), cast("asyncio.Future[_T]", fut))
 
     async def barrier(self) -> int:
         if asyncio.get_running_loop() is not self._loop:
-            raise RuntimeError("Context time can only be used in the context loop")
+            msg = "Context time can only be used in the context loop"
+            raise RuntimeError(msg)
         return await create_op(self._loop, Barrier())
 
     def time(self) -> float:
         if asyncio.get_running_loop() is not self._loop:
-            raise RuntimeError("Context time can only be used in the context loop")
+            msg = "Context time can only be used in the context loop"
+            raise RuntimeError(msg)
         return self._loop.time()
 
     def time_ns(self) -> int:
         if asyncio.get_running_loop() is not self._loop:
-            raise RuntimeError("Context time can only be used in the context loop")
+            msg = "Context time can only be used in the context loop"
+            raise RuntimeError(msg)
         return self._loop.time_us() * 1_000
 
     def random(self) -> Random:
         if asyncio.get_running_loop() is not self._loop:
-            raise RuntimeError("Context random can only be used in the context loop")
+            msg = "Context random can only be used in the context loop"
+            raise RuntimeError(msg)
         return Random(self._loop.generate_op_id())