nene2-python 1.1.0__tar.gz → 1.3.0__tar.gz

{nene2_python-1.1.0 → nene2_python-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nene2-python
-Version: 1.1.0
+Version: 1.3.0
 Summary: NENE2 Python — minimal API framework following NENE2's design philosophy
 Project-URL: Homepage, https://github.com/hideyukiMORI/nene2-python
 Project-URL: Repository, https://github.com/hideyukiMORI/nene2-python

nene2_python-1.3.0/docs/field-trials/2026-05-field-trial-10.md

@@ -0,0 +1,167 @@
+# Field Trial 10 — inventory: MySQL アダプター DX 検証
+
+## Date
+
+2026-05-20
+
+## Baseline
+
+- nene2-python v1.2.0（PyPI 経由）
+- Python 3.14（uv managed）
+- プロジェクト: **inventory** — 在庫管理 API
+- エンティティ: `Product(id, name, price, stock, created_at)`
+- HTTP API: ポート 8110（FastAPI + MySQL 8）
+- DB: MySQL 8.0（Docker Compose）
+
+## Goal
+
+FT1〜FT9 はすべて SQLite を使用。MySQL 8 で初めて以下を検証：
+
+1. Docker Compose で MySQL 8 を立ち上げる手順
+2. `SqlAlchemyQueryExecutor` / `SqlAlchemyTransactionManager` の MySQL 上での動作
+3. `parse_db_datetime()` が MySQL の `datetime` オブジェクトを正しく処理するか
+4. SQLite との挙動差（`CURRENT_TIMESTAMP` 型、`RETURNING` 句）
+
+---
+
+## Steps Taken
+
+### 1. Docker Compose で MySQL 8 を起動
+
+```yaml
+services:
+  mysql:
+    image: mysql:8.0
+    environment:
+      MYSQL_ROOT_PASSWORD: rootpass
+      MYSQL_DATABASE: inventory
+      MYSQL_USER: appuser
+      MYSQL_PASSWORD: apppass
+    ports:
+      - "3310:3306"
+    healthcheck:
+      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-uappuser", "-papppass"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+```
+
+`depends_on: condition: service_healthy` でアプリが MySQL の起動完了後に起動する構成。
+
+### 2. 接続文字列と依存
+
+```python
+url = f"mysql+pymysql://{user}:{password}@{host}:{port}/{name}"
+engine = create_engine(url, pool_pre_ping=True)
+```
+
+`pymysql` + `cryptography` を追加（MySQL 8 の認証プラグイン `caching_sha2_password` 対応に必要）。
+
+### 3. `CURRENT_TIMESTAMP` の型差異の確認
+
+| DB | `CURRENT_TIMESTAMP` の Python 型 | `parse_db_datetime()` の結果 |
+|----|----------------------------------|------------------------------|
+| SQLite | `str` (`"2026-05-20 12:34:56"`) | ✓ UTC-aware datetime |
+| MySQL | `datetime` (naive, server timezone) | ✓ UTC-aware datetime |
+
+MySQL は `datetime` オブジェクトを返すが naive（tzinfo なし）。
+`parse_db_datetime()` が `isinstance(value, datetime)` で分岐して `.replace(tzinfo=UTC)` を付与するため、
+SQLite と同一の出力が得られることを確認。
+
+### 4. SELECT-after-INSERT の動作確認
+
+`RETURNING` 句は MySQL 8.0 でサポートされていない（PostgreSQL にはある）。
+FT8 で採用した SELECT-after-INSERT パターンがそのまま動作：
+
+```python
+new_id = executor.write("INSERT INTO products ...", {...})
+row = executor.fetch_one("SELECT ... WHERE id = :id", {"id": new_id})
+```
+
+`executor.write()` の戻り値 (`lastrowid`) が MySQL でも正しく返ることを確認。
+
+---
+
+## Friction Points
+
+### FT10-1: `cryptography` が暗黙の依存として必要（ドキュメントなし）
+
+- **摩擦**: `pymysql` を追加しただけでは MySQL 8 の `caching_sha2_password` 認証が失敗する
+  ```
+  OperationalError: Authentication plugin 'caching_sha2_password' is not supported
+  ```
+- `cryptography` パッケージを別途追加する必要があるが、エラーメッセージが分かりにくい
+- **深刻度**: MEDIUM（初見では原因が pymysql の依存問題と気づきにくい）
+- **解決策**: how-to ガイドに `cryptography` を必須依存として明記（ドキュメント対応）
+
+### FT10-2: `PaginationResponse[T].to_dict()` が items を直列化しない
+
+- **摩擦**: `PaginationResponse[ProductOutput].to_dict()` の `items` フィールドが
+  `ProductOutput` dataclass インスタンスのまま返る → `json.dumps` が失敗
+  ```
+  TypeError: Object of type ProductOutput is not JSON serializable
+  ```
+- `slots=True` の dataclass は `__dict__` を持たないため `JSONResponse(result.__dict__)` も使えない
+- **回避策**: ハンドラーで `[dataclasses.asdict(item) for item in result.items]` に変換
+  ```python
+  return JSONResponse({
+      "items": [dataclasses.asdict(item) for item in result.items],
+      "total": result.total,
+      "limit": result.limit,
+      "offset": result.offset,
+  })
+  ```
+- **深刻度**: HIGH（LIST エンドポイントを書くたびに同じ回避策が必要）
+- **解決策候補**: `PaginationResponse.to_dict()` が dataclass items を自動変換する、
+  または `to_json_dict()` メソッドを追加する
+
+### FT10-3: `ValidationError` の `code` 引数がドキュメントに不足
+
+- **摩擦**: `ValidationError("field", "message")` → `TypeError: missing 1 required argument: 'code'`
+- FT1〜FT9 の既存プロジェクトのコードを参考に 2 引数で書くと失敗する
+- **深刻度**: MEDIUM（他のFTのコードがすべて3引数になっていれば問題ない）
+- **解決策**: how-to ガイドのサンプルコードに `code` 引数を必ず含める
+
+### FT10-4: `DatabaseHealthCheck(executor)` vs `DatabaseHealthCheck(engine)` が紛らわしい
+
+- **摩擦**: `DatabaseHealthCheck` のコンストラクタは `executor` を受け取るが、
+  `create_engine()` の直後に書くと `engine` を渡してしまいやすい
+  ```python
+  engine = create_engine(url)
+  executor = SqlAlchemyQueryExecutor(engine)
+  # 間違い: DatabaseHealthCheck(engine)  ← AttributeError: 'Engine' has no 'fetch_one'
+  # 正しい: DatabaseHealthCheck(executor)
+  ```
+- **深刻度**: LOW（エラーメッセージから原因は特定できる）
+- **解決策**: ドキュメントの使用例を正確に記述する
+
+### FT10-5: `PaginationQueryParser` を FastAPI のパラメータ型として使えない
+
+- **摩擦**: `def list_products(pagination: PaginationQueryParser)` と書くと
+  `FastAPIError: Invalid args for response field` が発生
+- `PaginationQueryParser` は Pydantic モデルではないため、FastAPI の Depends として使えない
+- **回避策**: `request: Request` を受け取り `PaginationQueryParser.parse(request)` を呼ぶ
+- **深刻度**: MEDIUM（直感的な書き方が失敗する）
+- **解決策候補**: `PaginationQueryParser` を `Depends` 互換にする、または
+  `Annotated[PaginationQueryParser, Depends(PaginationQueryParser.parse)]` パターンを提供
+
+---
+
+## Summary
+
+| ID      | 摩擦                                                  | 深刻度 | 解決策                                                    |
+|---------|-------------------------------------------------------|--------|-----------------------------------------------------------|
+| FT10-1  | `cryptography` が暗黙依存（MySQL 8 認証失敗）         | MEDIUM | how-to ガイドに記載                                       |
+| FT10-2  | `PaginationResponse.to_dict()` が items を直列化しない | HIGH   | `to_dict()` に dataclass 自動変換を追加                  |
+| FT10-3  | `ValidationError` の `code` 引数がドキュメント不足    | MEDIUM | how-to サンプルコードを修正                               |
+| FT10-4  | `DatabaseHealthCheck(executor)` vs `engine)` が紛らわしい | LOW | ドキュメント修正                                          |
+| FT10-5  | `PaginationQueryParser` が FastAPI パラメータ型不可   | MEDIUM | `Depends` 互換パターンを提供                              |
+
+**MySQL 固有の問題は FT10-1 のみ**。他は SQLite でも同様に起きる問題（FT1〜9 でたまたま発覚しなかった）。
+`parse_db_datetime()` は MySQL の naive datetime を期待通り UTC-aware に変換できた。
+
+FT11 候補:
+- **FT10-2 の修正**: `PaginationResponse.to_dict()` dataclass 自動変換
+- **FT10-5 の修正**: `PaginationQueryParser` を `Depends` 互換に
+- **PostgreSQL アダプター**: `RETURNING` 句が使えるかを検証
+- **`BearerTokenMiddleware` + `HttpxMcpClient`**: 認証付き API を MCP から呼ぶ

nene2_python-1.3.0/docs/field-trials/2026-05-field-trial-9.md

@@ -0,0 +1,151 @@
+# Field Trial 9 — recipe: HttpxMcpClient + streamable-http トランスポート DX 検証
+
+## Date
+
+2026-05-20
+
+## Baseline
+
+- nene2-python v1.1.0（PyPI 経由）→ LocalMcpServer 修正後は local editable
+- Python 3.14（uv managed）
+- プロジェクト: **recipe** — レシピ管理 API
+- エンティティ: `Recipe(id, title, description, servings)`
+- HTTP API: ポート 8100（FastAPI + InMemory）
+- MCP サーバー: ポート 8101（`streamable-http` トランスポート）
+- MCP ツール: `HttpxMcpClient` で HTTP API を呼び出してデータ共有
+
+## Goal
+
+FT1〜FT8 で未探索のパターンを検証：
+
+1. **`LocalMcpServer.run(transport="streamable-http")`** — HTTP モード MCP の起動
+2. **`HttpxMcpClient`** — MCP ツールハンドラーから HTTP API を呼び出してデータ共有
+3. FT3-F2（MCP と HTTP API のメモリ非共有問題）の正しい解決パターンを実証
+
+---
+
+## Steps Taken
+
+### 1. HTTP API + MCP サーバーの二段構成
+
+```
+HTTP API（app.py, port 8100）
+    ↑ HTTP calls
+MCP Server（mcp_server.py, port 8101）
+    ↓ streamable-http
+Claude / MCP Client
+```
+
+MCP ツールが `HttpxMcpClient` で HTTP API を叩くため、どちらの経路から書いても同じデータが見える。
+
+### 2. HttpxMcpClient でのツール実装
+
+```python
+from nene2.mcp import LocalMcpServer
+from nene2.mcp.http_client import HttpxMcpClient
+
+client = HttpxMcpClient()
+server = LocalMcpServer("recipe-api", instructions="...", port=8101)
+
+@server.tool("List all recipes. Returns paginated results.")
+def list_recipes(limit: int = 20, offset: int = 0) -> str:
+    response = client.get(API_BASE, f"/recipes?limit={limit}&offset={offset}")
+    return response.body
+
+@server.tool("Create a new recipe.")
+def create_recipe(title: str, description: str, servings: int) -> str:
+    response = client.post(API_BASE, "/recipes",
+        {"title": title, "description": description, "servings": servings})
+    return response.body
+```
+
+### 3. 動作確認
+
+```bash
+# HTTP API で作成 → MCP ツールから見える
+curl -X POST http://localhost:8100/recipes -d '{"title":"Ramen",...}' → {"id":1,...}
+MCP: list_recipes() → {"items":[{"id":1,"title":"Ramen",...}],...}
+
+# MCP ツールで作成 → HTTP API から見える
+MCP: create_recipe("Sushi",...) → {"id":2,...}
+curl GET http://localhost:8100/recipes → [Ramen, Sushi]
+```
+
+**FT3-F2 の解決確認**: HTTP API と MCP が `HttpxMcpClient` 経由で完全にデータを共有。
+
+### 4. streamable-http プロトコルのフロー
+
+```
+POST /mcp (initialize) → Session-ID: {uuid} を取得
+POST /mcp + Mcp-Session-Id: {uuid} (tools/list, tools/call)
+```
+
+stdio と異なり、MCP セッション管理が必要。HTTP クライアントライブラリや Claude Desktop が処理するため、手動操作は検証時のみ。
+
+---
+
+## Friction Points
+
+### FT9-1: `LocalMcpServer` にポート指定がない
+
+- **摩擦**: `LocalMcpServer.run(transport="streamable-http")` のデフォルトポートが 8000 で変更不可
+- `FastMCP.__init__` は `host`/`port` を受け取るが、`LocalMcpServer.__init__` が渡していなかった
+- HTTP API（8100）と MCP（8101）を同一マシンで動かす際にポート衝突が起きる
+- **深刻度**: HIGH（2サービス構成で必ずぶつかる）
+- **解決策**: `LocalMcpServer.__init__(name, instructions, *, host, port)` に追加済み（PR #174）
+
+### FT9-2: HTTP エラー（404 等）が `isError: false` で返る
+
+- **摩擦**: MCP ツールが `return response.body` で 404 レスポンスをそのまま返すと、
+  MCP プロトコルの `isError` フラグが `false` になる
+- AI クライアントがエラーを成功として解釈する可能性がある
+- **深刻度**: MEDIUM（AI がエラーを無視して誤った操作を続けるリスク）
+- **解決策**: `McpHttpResponse.raise_for_error()` を追加 → FastMCP が例外を `isError: true` に変換（PR #174）
+
+  ```python
+  def get_recipe(recipe_id: int) -> str:
+      response = client.get(API_BASE, f"/recipes/{recipe_id}")
+      response.raise_for_error()   # ← 追加: 4xx/5xx を例外に変換
+      return response.body
+  ```
+
+### FT9-3: DELETE が 204 No Content を返し `response.body` が空
+
+- **摩擦**: DELETE エンドポイントは 204 を返すため `response.body` が空文字列 `""`
+- MCP ツールの戻り値が `""` になり、AI が「削除完了」を確認できない
+- **解決策**: 明示的に確認メッセージを組み立てる（フレームワークは解決不要、パターンとして文書化）
+
+  ```python
+  def delete_recipe(recipe_id: int) -> str:
+      response = client.delete(API_BASE, f"/recipes/{recipe_id}")
+      response.raise_for_error()
+      if response.status_code == 204:
+          return json.dumps({"deleted": True, "recipe_id": recipe_id})
+      return response.body
+  ```
+
+### FT9-4: streamable-http はセッション管理が必要（stdio より複雑）
+
+- **摩擦**: stdio はプロセス間通信で自動管理されるが、HTTP モードは `initialize` → Session ID → ツール呼び出し の2ステップ
+- Claude Desktop や MCP SDK クライアントが透過的に処理するため、**実際の利用では問題にならない**
+- ただしデバッグ時（curl で直接叩く）には手順が煩雑
+- **深刻度**: LOW（ツール側の問題ではなく、デバッグ時の利便性の問題）
+
+---
+
+## Summary
+
+| ID     | 摩擦                                            | 深刻度 | 解決策                                        |
+|--------|-------------------------------------------------|--------|-----------------------------------------------|
+| FT9-1  | LocalMcpServer にポート指定がない               | HIGH   | `host`/`port` 引数追加済み（PR #174）         |
+| FT9-2  | HTTP エラーが isError: false で返る             | MEDIUM | `raise_for_error()` 追加済み（PR #174）       |
+| FT9-3  | DELETE 204 で body が空 → AI が確認できない     | LOW    | パターンとして文書化（json.dumps で補完）      |
+| FT9-4  | streamable-http のセッション管理が手動で煩雑    | LOW    | クライアント SDK が透過処理するので運用上は問題なし |
+
+**`HttpxMcpClient` + `streamable-http` の組み合わせは FT3-F2 の正しい解決策として機能した。**
+HTTP API を中継することで、MCP と HTTP クライアントが完全にデータを共有できる。
+
+FT10 候補:
+- **MySQL/PostgreSQL アダプター**: SQLite 以外の DB を初めて FT で使用
+- **`BearerTokenMiddleware` + `HttpxMcpClient`**: 認証付き API に対して MCP から呼び出す
+- **`LocalMcpServer` の SSE トランスポート**: `streamable-http` との差異を確認

{nene2_python-1.1.0 → nene2_python-1.3.0}/docs/how-to/sqlalchemy-repository.md

@@ -500,3 +500,81 @@ class InMemoryTransactionManager(DatabaseTransactionManagerInterface):
 ```
 
 > **Rollback on exception**: `SqlAlchemyTransactionManager.transactional()` uses `engine.begin()` — any exception inside the callback triggers an automatic rollback. Domain exceptions (`AccountNotFoundException`, etc.) propagate normally after rollback.
+
+---
+
+## 6. Using MySQL 8
+
+### Required packages
+
+MySQL 8 uses `caching_sha2_password` authentication by default.
+Install **both** `pymysql` and `cryptography` — without `cryptography` the connection fails with
+`Authentication plugin 'caching_sha2_password' is not supported`.
+
+```bash
+uv add pymysql cryptography
+```
+
+### Connection URL
+
+```python
+url = f"mysql+pymysql://{user}:{password}@{host}:{port}/{name}"
+engine = create_engine(url, pool_pre_ping=True)
+```
+
+`pool_pre_ping=True` is recommended for MySQL — it tests the connection before use to handle
+stale connections after the server's `wait_timeout`.
+
+### Health check
+
+`DatabaseHealthCheck` takes a **`SqlAlchemyQueryExecutor`**, not the engine directly:
+
+```python
+from nene2.database import DatabaseHealthCheck, SqlAlchemyQueryExecutor
+
+executor = SqlAlchemyQueryExecutor(engine)
+health = DatabaseHealthCheck(executor)   # ← executor, not engine
+
+app.add_api_route("/health", health.check, methods=["GET"])
+```
+
+### `CURRENT_TIMESTAMP` type difference
+
+SQLite returns `CURRENT_TIMESTAMP` as a `str`; MySQL returns a naive `datetime` object.
+Use `parse_db_datetime()` in `_to_entity()` to handle both transparently:
+
+```python
+from nene2.database import parse_db_datetime
+
+def _to_entity(row: dict[str, Any]) -> Product:
+    return Product(
+        id=int(row["id"]),
+        created_at=parse_db_datetime(row["created_at"]),  # works for both SQLite and MySQL
+    )
+```
+
+### Docker Compose example
+
+```yaml
+services:
+  mysql:
+    image: mysql:8.0
+    environment:
+      MYSQL_ROOT_PASSWORD: rootpass
+      MYSQL_DATABASE: mydb
+      MYSQL_USER: appuser
+      MYSQL_PASSWORD: apppass
+    ports:
+      - "3310:3306"
+    healthcheck:
+      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-uappuser", "-papppass"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+
+  app:
+    build: .
+    depends_on:
+      mysql:
+        condition: service_healthy
+```

{nene2_python-1.1.0 → nene2_python-1.3.0}/docs/reference/framework-modules.md

@@ -10,6 +10,20 @@ Public API of the `nene2` package.
 
 Parses `limit` and `offset` query parameters.
 
+**FastAPI Depends (recommended)**:
+
+```python
+from typing import Annotated
+from fastapi import Depends
+from nene2.http import PaginationQueryParser
+
+@router.get("/items")
+def list_items(pagination: Annotated[PaginationQueryParser, Depends()]) -> JSONResponse:
+    result = use_case.execute(pagination.limit, pagination.offset)
+```
+
+**Legacy (Request-based)**:
+
 ```python
 from nene2.http import PaginationQueryParser
 

{nene2_python-1.1.0 → nene2_python-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nene2-python"
-version = "1.1.0"
+version = "1.3.0"
 description = "NENE2 Python — minimal API framework following NENE2's design philosophy"
 readme = "README.md"
 license = {text = "MIT"}

{nene2_python-1.1.0 → nene2_python-1.3.0}/src/nene2/database/utils.py

@@ -16,6 +16,7 @@ def parse_db_datetime(value: str | datetime) -> datetime:
 
         from nene2.database import parse_db_datetime
 
+
         def _to_post(row: dict[str, Any]) -> Post:
             return Post(
                 id=row["id"],

{nene2_python-1.1.0 → nene2_python-1.3.0}/src/nene2/http/pagination.py

@@ -3,10 +3,11 @@
 Equivalent to PHP Nene2\\Http\\PaginationQueryParser, PaginationQuery, PaginationResponse.
 """
 
+import dataclasses
 from dataclasses import dataclass, field
-from typing import Any
+from typing import Annotated, Any
 
-from fastapi import Request
+from fastapi import Query, Request
 
 from nene2.validation.exceptions import ValidationError, ValidationException
 
@@ -20,7 +21,33 @@ class PaginationQuery:
 
 
 class PaginationQueryParser:
-    """Parses and validates pagination query parameters from a FastAPI Request."""
+    """Parses and validates pagination query parameters.
+
+    Two usage patterns:
+
+    **FastAPI Depends (recommended)**::
+
+        from typing import Annotated
+        from fastapi import Depends
+
+
+        def list_items(pagination: Annotated[PaginationQueryParser, Depends()]) -> JSONResponse:
+            result = use_case.execute(pagination.limit, pagination.offset)
+
+    **Manual parse from Request (legacy)**::
+
+        def list_items(request: Request) -> JSONResponse:
+            pagination = PaginationQueryParser.parse(request)
+            result = use_case.execute(pagination.limit, pagination.offset)
+    """
+
+    def __init__(
+        self,
+        limit: Annotated[int, Query(ge=1, le=100, description="Items per page (1–100)")] = 20,
+        offset: Annotated[int, Query(ge=0, description="Items to skip")] = 0,
+    ) -> None:
+        self.limit = limit
+        self.offset = offset
 
     @staticmethod
     def parse(
@@ -83,8 +110,18 @@ class PaginationResponse:
     total: int | None = field(default=None)
 
     def to_dict(self) -> dict[str, Any]:
+        """Return a JSON-serializable dict.
+
+        Items that are dataclass instances are converted via ``dataclasses.asdict()``
+        so that ``JSONResponse(result.to_dict())`` works without extra steps.
+        """
         data: dict[str, Any] = {
-            "items": self.items,
+            "items": [
+                dataclasses.asdict(item)
+                if dataclasses.is_dataclass(item) and not isinstance(item, type)
+                else item
+                for item in self.items
+            ],
             "limit": self.limit,
             "offset": self.offset,
         }

{nene2_python-1.1.0 → nene2_python-1.3.0}/src/nene2/mcp/__init__.py

@@ -1,11 +1,12 @@
 """NENE2 MCP integration — expose UseCases as MCP tools."""
 
-from .http_client import HttpxMcpClient, McpHttpClientProtocol, McpHttpResponse
+from .http_client import HttpxMcpClient, McpHttpClientProtocol, McpHttpError, McpHttpResponse
 from .server import LocalMcpServer
 
 __all__ = [
     "HttpxMcpClient",
     "LocalMcpServer",
     "McpHttpClientProtocol",
+    "McpHttpError",
     "McpHttpResponse",
 ]

{nene2_python-1.1.0 → nene2_python-1.3.0}/src/nene2/mcp/http_client.py

@@ -11,6 +11,15 @@ import httpx
 from httpx import BaseTransport
 
 
+class McpHttpError(Exception):
+    """Raised by McpHttpResponse.raise_for_error() on 4xx / 5xx responses."""
+
+    def __init__(self, status_code: int, body: str) -> None:
+        super().__init__(f"HTTP {status_code}: {body}")
+        self.status_code = status_code
+        self.body = body
+
+
 @dataclass(frozen=True, slots=True)
 class McpHttpResponse:
     """HTTP response value object returned by McpHttpClientProtocol."""
@@ -22,6 +31,19 @@ class McpHttpResponse:
     def is_successful(self) -> bool:
         return 200 <= self.status_code < 300
 
+    def raise_for_error(self) -> None:
+        """Raise McpHttpError if the response status code indicates an error (4xx / 5xx).
+
+        Use this in MCP tool handlers to propagate HTTP errors as tool errors::
+
+            def get_recipe(recipe_id: int) -> str:
+                response = client.get(API_BASE, f"/recipes/{recipe_id}")
+                response.raise_for_error()
+                return response.body
+        """
+        if not self.is_successful():
+            raise McpHttpError(self.status_code, self.body)
+
     def request_id(self) -> str | None:
         return self.headers.get("x-request-id")
 

{nene2_python-1.1.0 → nene2_python-1.3.0}/src/nene2/mcp/server.py

@@ -13,8 +13,15 @@ from mcp.server.fastmcp import FastMCP
 class LocalMcpServer:
     """MCP server with sensible defaults for local / stdio transport."""
 
-    def __init__(self, name: str, instructions: str = "") -> None:
-        self._mcp = FastMCP(name, instructions=instructions)
+    def __init__(
+        self,
+        name: str,
+        instructions: str = "",
+        *,
+        host: str = "127.0.0.1",
+        port: int = 8000,
+    ) -> None:
+        self._mcp = FastMCP(name, instructions=instructions, host=host, port=port)
 
     def tool(self, description: str = "") -> Callable[[Any], Any]:
         """Register a function as an MCP tool."""

{nene2_python-1.1.0 → nene2_python-1.3.0}/tests/nene2/http/test_pagination.py

@@ -1,9 +1,11 @@
 """Tests for PaginationQueryParser and PaginationResponse."""
 
+from dataclasses import dataclass
+from typing import Annotated
 from unittest.mock import MagicMock
 
 import pytest
-from fastapi import FastAPI, Request
+from fastapi import Depends, FastAPI, Request
 from fastapi.responses import JSONResponse
 from fastapi.testclient import TestClient
 
@@ -19,6 +21,12 @@ def _make_app() -> FastAPI:
         pagination = PaginationQueryParser.parse(request)
         return JSONResponse({"limit": pagination.limit, "offset": pagination.offset})
 
+    @app.get("/items-depends")
+    async def items_depends(
+        pagination: Annotated[PaginationQueryParser, Depends()],
+    ) -> JSONResponse:
+        return JSONResponse({"limit": pagination.limit, "offset": pagination.offset})
+
     return app
 
 
@@ -86,3 +94,34 @@ def test_pagination_response_with_total() -> None:
 def test_pagination_response_total_zero_is_included() -> None:
     r = PaginationResponse(items=[], limit=10, offset=0, total=0)
     assert r.to_dict()["total"] == 0
+
+
+def test_pagination_query_parser_as_depends_default() -> None:
+    r = client.get("/items-depends")
+    assert r.json() == {"limit": 20, "offset": 0}
+
+
+def test_pagination_query_parser_as_depends_custom() -> None:
+    r = client.get("/items-depends?limit=5&offset=10")
+    assert r.json() == {"limit": 5, "offset": 10}
+
+
+def test_pagination_query_parser_as_depends_out_of_range_returns_422() -> None:
+    r = client.get("/items-depends?limit=0")
+    assert r.status_code == 422
+
+
+def test_pagination_response_to_dict_serializes_dataclass_items() -> None:
+    @dataclass(frozen=True, slots=True)
+    class Item:
+        id: int
+        name: str
+
+    r = PaginationResponse(items=[Item(1, "foo"), Item(2, "bar")], limit=20, offset=0, total=2)
+    data = r.to_dict()
+    assert data["items"] == [{"id": 1, "name": "foo"}, {"id": 2, "name": "bar"}]
+
+
+def test_pagination_response_to_dict_passes_through_dict_items() -> None:
+    r = PaginationResponse(items=[{"id": 1}, {"id": 2}], limit=20, offset=0, total=2)
+    assert r.to_dict()["items"] == [{"id": 1}, {"id": 2}]