From d7312eb305cfcd7ec35e42f731624c04b7ec99a6 Mon Sep 17 00:00:00 2001 From: Sava Znatnov Date: Mon, 29 Jun 2026 12:34:47 +0300 Subject: [PATCH 01/25] docs: add round-4 architecture refactor design spec Covers seven workstreams: remove RawMapping/full raw accessor (W-A), status package + native me + status_get MCP tool (W-B), ycli/mcp package (W-C), pagination generics + Envelope protocol (W-D), smell sweep (W-E), ARCHITECTURE/snapshots consolidation (W-F), and reproducible demo output via committed fixtures rendered by the real CLI (W-G). Co-Authored-By: Claude Opus 4.8 --- .../2026-06-29-round-4-architecture-design.md | 275 ++++++++++++++++++ 1 file changed, 275 insertions(+) create mode 100644 docs/superpowers/specs/2026-06-29-round-4-architecture-design.md diff --git a/docs/superpowers/specs/2026-06-29-round-4-architecture-design.md b/docs/superpowers/specs/2026-06-29-round-4-architecture-design.md new file mode 100644 index 0000000..da9fcfb --- /dev/null +++ b/docs/superpowers/specs/2026-06-29-round-4-architecture-design.md @@ -0,0 +1,275 @@ +# Round-4 Architecture Refactor — Design + +**Status:** approved decisions, pending user review of this spec +**Branch:** `refactor/round-4-architecture` (off `main` @ v0.8.1) +**Date:** 2026-06-29 + +## Goal + +Close the architecture debt surfaced in review points 3–7 plus a demo-reproducibility +smell: drop the one-off `RawMapping`/`full` raw accessor, turn the two cross-cutting +modules (`status`, `mcp`) into proper packages with the missing surfaces, tighten +pagination types, sweep small smells, and make the demo GIF render real CLI output from +committed fixtures instead of hand-typed `cat <//` dirs. `yandex/status/` + is a domain with **no resource subdirectory**, so the letter does not bind it — but confirm the + enforcing test's glob does not treat `yandex/status/` as a resource missing surfaces. If it does, + add an explicit carve-out in `ARCHITECTURE.md` + the test naming `status` as a cross-cutting + domain (client-less, resource-less). + +**Tests:** model shape (`me` populated on success, `None` + `detail` on auth failure), CLI exit +codes (1 when unconfigured / any service invalid), MCP `status_get` read-only + returns report. +Snapshots gain `status_get`. + +--- + +## W-C — `mcp` → package (`ycli/mcp/`) (point 4) + +**Decision:** turn the two root MCP modules into a package; keep both public import paths. + +**Current state:** `src/ycli/mcp.py` (root FastMCP server: `mcp` + `main`) and `src/ycli/mcp_cli.py` +(the `ycli mcp` Typer sub-app: `start`, `methods`). + +**Target package `src/ycli/mcp/`:** +- `__init__.py` ← former `mcp.py`. Keeps `from ycli.mcp import main, mcp` working (the console + entry point and `mcp_cli`'s lazy import both rely on these). Mounts wiki/tracker/forms **and** + the new `status` subserver (W-B). +- `cli.py` ← former `mcp_cli.py` (the `mcp` Typer app). Update `cli.py:14` import from + `ycli.mcp_cli` → `ycli.mcp.cli`. +- `__main__.py` — `from ycli.mcp import main; main()` so `python -m ycli.mcp` (documented in the + server docstring) still runs the server now that `mcp` is a package, not a module. + +**ARCH impact (carve-out required):** +- ARCH-3 says `fastmcp` is imported only in modules **named `mcp.py`**. The server now lives in + `ycli/mcp/__init__.py`. Edit ARCH-3 text + its enforcing check to allow `fastmcp` in + `ycli/mcp/__init__.py` (the package initializer of the `mcp` package) in addition to `mcp.py` + modules. Same change to the import-linter contract if it pins module names. + +**Tests:** `from ycli.mcp import main, mcp` resolves; `python -m ycli.mcp` entry exists; +`ycli mcp start` / `ycli mcp methods` unchanged. The smoke test (`registered_groups` `mcp` check) +stays valid. + +--- + +## W-D — Pagination typing + Envelope protocol (point 6) + +**Decision:** add PEP 695 generics + a typed page `Envelope` protocol; fold the free +`collect_single_page` function into the class hierarchy (OOP-encapsulation preference). + +**Current state:** `src/ycli/yandex/pagination.py` — ABC strategies returning untyped `list`, +`Callable[[Any], Any]` page accessors, `cursor: Any`, and a module-level `collect_single_page` +free function. + +**Target:** +- `PaginationStrategy[T]` generic; `collect(...) -> list[T]`. +- An `Envelope[T]` `Protocol` (or typed `Callable` aliases) describing the page-access surface: + `extract: Callable[[E], list[T]]`, `next_of: Callable[[P], str | None]`, + `next_url_of: Callable[[P], str | None]`, `fetch_url: Callable[[str], P]`. +- Replace `cursor: Any = None` with a typed cursor; `if cursor is None` / `if url is None` checks + instead of truthiness where a typed `str | None` makes it precise. +- Fold `collect_single_page` into `SinglePageStrategy` (e.g. a classmethod/`collect_wrapped`) + so the wiki/forms call sites use the class, not a free function. +- Remove `Any`/`ty: ignore` that the generics make unnecessary; use `@overload` where ty supports it. + +**Constraint:** `pagination.py` is not a `client.py`, so `from __future__ import annotations` stays +fine; PEP 695 `type`/`class C[T]` syntax needs no future import. + +**Tests:** existing pagination tests stay green; add a type-level assertion only if cheap. Behavior +is unchanged — this is a typing/encapsulation refactor. + +--- + +## W-E — Smell sweep (point 5) + +**Decisions (from review):** +- The 4 empty `__init__.py` (`yandex/__init__.py`, `wiki/attachments`, `wiki/comments`, + `wiki/pages`) get **docstrings**, not deletion — ARCH-1 requires the files to exist. +- Move the in-body `import yaml` to module top in `tests/yandex/tracker/issues/test_cli.py`. +- `collect_single_page` free function → handled in W-D. +- `ServiceProbe` god-ish indirection → removed in W-B. + +**Out of scope:** `_deps.py` per-domain boilerplate stays (intentional pattern, not a smell). + +**Tests:** none new; the sweep must not change behavior or coverage. + +--- + +## W-F — ARCHITECTURE docs + snapshots + drift gate + +Consolidation workstream — every invariant edit lands with its enforcing check: +- ARCH-4: drop the `RawMapping` sentence (W-A). +- ARCH-3: drop `full` from the read-verb allow-list (W-A); add the `ycli/mcp/__init__.py` fastmcp + carve-out (W-C). +- ARCH-1: status carve-out if the test glob requires it (W-B). +- `docs/conventions/resources.md`: delete §4 (W-A). +- Regenerate `tests/snapshots/` (CLI tree gains nothing/loses `full`; MCP list loses + `tracker_issues_full`, gains `status_get`). +- Run the ARCH-11 doc-drift guard + full `uv run pytest` gate. + +--- + +## W-G — Reproducible demo output (new) + +**Decision:** variant **B** — render real CLI output from committed fixtures via in-process +`responses`; derive the MCP tool list from the live `ycli mcp methods`. No hand-typed output. + +**Proven smell:** `docs/demo/bin/ycli` bakes a `cat <`; replace the baked `mcp start` tool list with the + real `ycli mcp methods` output (no creds/network; requires the `[mcp]` extra at regeneration — + document in the tape header). +- `docs/demo/demo.tape`: adjust the `mcp` step to show real `ycli mcp methods`; retune + Sleep/Height if the 24-tool list needs it. + +**Tests:** `render.py` is demo tooling, not shipped in the dist. Add a lightweight test that +`render.py ` exits 0 and emits the fixture's key field, so the demo can't silently rot +(keeps coverage honest without a GIF in CI). + +--- + +## Out of scope + +- Making `base_url` env-configurable (the clients hardcode it as a `ClassVar`; W-G does not need + it — `responses` intercepts in-process). Defer unless a later need appears. +- Any new Yandex resource (that is `/new-endpoint`'s job). +- Token-leak scanning (separate work, per ARCH-5 scope note). + +## Testing strategy + +TDD per task. `responses` stubs all HTTP (no live network). MCP wiring tests marked +`@pytest.mark.integration`. Snapshots regenerated only on purpose. Final gate: +`uv run pytest` (100% cov) + `ruff format --check` + `ruff check` + `lint-imports` + `ty check`. + +## Release + +Public-surface **removal** (CLI `full`, MCP `issues_full`) is breaking; the `status_get` tool is an +addition. On a pre-1.0 line (0.8.1) semantic-release maps a breaking change to a **minor** bump +→ **0.9.0**. Squash-merge title decided at merge (likely `feat!:` with a `BREAKING CHANGE:` footer +naming the removed `full` command/tool). After release: `uv lock` + `build:` sync commit (PSR +bumps pyproject but not the lock). + +## Decisions locked (from review) + +| Point | Decision | +|-------|----------| +| 3 RawMapping | Delete `full` + `RawMapping` + `get_raw` entirely | +| 4 status | `yandex/status/` package + read-only `status_get` MCP tool | +| 4 mcp_cli | `ycli/mcp/` package (server in `__init__.py`, cli in `cli.py`, `__main__.py`) | +| 6 pagination | PEP 695 generics + `Envelope` protocol; fold `collect_single_page` into a class | +| 7 status `me` | Bare native `me` object (drop `ServiceProbe` + identity lambdas; keep valid/detail) | +| MCP naming | `status_get` in new `status` namespace | +| demo | Variant B (fixtures + real CLI render via `responses`; mcp list from live `methods`) | From a41976cca20354e59edd0f7f048035c4aee8a445 Mon Sep 17 00:00:00 2001 From: Sava Znatnov Date: Mon, 29 Jun 2026 12:47:45 +0300 Subject: [PATCH 02/25] docs: add round-4 implementation plan (6 tasks) Bite-sized TDD tasks for W-A..W-G: mcp package (fastmcp-free __init__), RawMapping removal, status package + status_get, pagination generics, __init__ docstrings, reproducible demo via committed fixtures. Co-Authored-By: Claude Opus 4.8 --- .../plans/2026-06-29-round-4-architecture.md | 1253 +++++++++++++++++ 1 file changed, 1253 insertions(+) create mode 100644 docs/superpowers/plans/2026-06-29-round-4-architecture.md diff --git a/docs/superpowers/plans/2026-06-29-round-4-architecture.md b/docs/superpowers/plans/2026-06-29-round-4-architecture.md new file mode 100644 index 0000000..ddbcce3 --- /dev/null +++ b/docs/superpowers/plans/2026-06-29-round-4-architecture.md @@ -0,0 +1,1253 @@ +# Round-4 Architecture Refactor Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Drop the one-off `RawMapping`/`full` raw accessor, turn `status` and `mcp` into proper packages (status gains a `status_get` MCP tool and returns the bare native `me`), tighten pagination types, and make the demo GIF render real CLI output from committed fixtures. + +**Architecture:** Six independent tasks (T1–T6), each a single commit ending in a green gate. Public-surface changes regenerate `tests/snapshots/` on purpose (ARCH-6); each invariant edit changes `ARCHITECTURE.md` together with its enforcing check. The 100% coverage gate stays green throughout — dead code is deleted with its dead tests. + +**Tech Stack:** Python ≥3.12 · uv · uplink+requests · typer · fastmcp (read-only) · pydantic v2 · ruff · ty 0.0.55 · pytest + `responses` · vhs. + +**Spec:** `docs/superpowers/specs/2026-06-29-round-4-architecture-design.md` + +## Global Constraints + +- `client.py` / `_base.py` modules MUST NOT use `from __future__ import annotations` (uplink reads runtime annotations). Other modules may. +- Credentials enter only at a composition root (`Credentials()`/`AppConfig()` for CLI via `AppContext`; the `_deps` cached providers for MCP) as raw `oauth_token`/`organization_id`. No `from_env`. Never hardcode `YANDEX_ID_*` (ARCH-5/7/8). +- MCP is read-only (ARCH-3): a tool's verb (last `_`-segment) must be in `READ_VERBS = {"get","list","count","search","descendants","meta"}` (note: `"full"` is removed in T2) and carry `readOnlyHint=True` via the `RO` annotation; no `mcp.py` calls a client write method. +- Output only via `output.Serializer.serialize(...)` (ARCH-4). +- Self-documenting names, no abbreviations. +- 100% coverage: `uv run pytest` enforces `--cov-fail-under=100`. +- Final gate for every task: `uv run ruff format --check . && uv run ruff check . && uv run lint-imports && uv run ty check && uv run pytest`. +- Commits end with `Co-Authored-By: Claude Opus 4.8 `. Branch `refactor/round-4-architecture` (already created off main). No direct push to main. No skip-ci token in any commit message. + +--- + +### Task 1: `ycli/mcp/` package (W-C) + +Turn the two root MCP modules into a package. The package `__init__.py` MUST stay free of a top-level `fastmcp` import so the base install (no `mcp` extra) can import `ycli.mcp.cli` — the server lives in `server.py`, exposed lazily. + +**Files:** +- Create: `src/ycli/mcp/__init__.py` (lazy re-export, fastmcp-free) +- Create: `src/ycli/mcp/server.py` (the FastMCP server — body of the old `src/ycli/mcp.py`) +- Create: `src/ycli/mcp/cli.py` (the `ycli mcp` Typer app — body of the old `src/ycli/mcp_cli.py`) +- Create: `src/ycli/mcp/__main__.py` (so `python -m ycli.mcp` runs the server) +- Delete: `src/ycli/mcp.py`, `src/ycli/mcp_cli.py` +- Modify: `src/ycli/cli.py:14` import +- Modify: `ARCHITECTURE.md` ARCH-3 prose +- Test: `tests/test_yandex_mcp.py`, `tests/test_yandex_cli.py` (existing — must stay green unchanged) + +**Interfaces:** +- Produces: `from ycli.mcp import mcp, main` (lazy via `__getattr__`); `from ycli.mcp.cli import app`; `python -m ycli.mcp`. T3 mounts a status subserver in `server.py`. +- Consumes: nothing new. + +- [ ] **Step 1: Add a base-install guard test (fastmcp-free import path)** + +Add to `tests/test_yandex_mcp.py`: + +```python +def test_base_install_imports_cli_without_fastmcp(): + """`ycli.mcp.cli` (and `ycli.cli`) must import without pulling fastmcp — base install.""" + import subprocess + import sys + + code = "import ycli.cli, ycli.mcp.cli, sys; assert 'fastmcp' not in sys.modules" + proc = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True) + assert proc.returncode == 0, proc.stderr +``` + +- [ ] **Step 2: Run it to verify it fails** + +Run: `uv run pytest tests/test_yandex_mcp.py::test_base_install_imports_cli_without_fastmcp -v` +Expected: FAIL — `ycli.mcp.cli` does not exist yet (ModuleNotFoundError). + +- [ ] **Step 3: Create `src/ycli/mcp/server.py`** (verbatim body of the current `src/ycli/mcp.py`) + +```python +"""Root Yandex 360 FastMCP server — mounts the per-domain subservers. + +Run over stdio for LLM-agent clients: ``ycli mcp start`` (or ``python -m ycli.mcp``). +Tools are namespaced per domain: ``wiki_*``, ``tracker_*``, ``forms_*``. Reads-only. +""" + +from fastmcp import FastMCP + +from ycli.log import configure +from ycli.settings import AppConfig +from ycli.yandex.forms.mcp import mcp as forms_mcp +from ycli.yandex.tracker.mcp import mcp as tracker_mcp +from ycli.yandex.wiki.mcp import mcp as wiki_mcp + +mcp = FastMCP( + "yandex", + instructions=( + "Read-only access to Yandex 360: Tracker (issues, comments, worklog, …), " + "Wiki (pages, attachments), and Forms. Tools are namespaced wiki_*, tracker_*, " + "forms_*, and are all read-only — create/update happens via the ycli CLI/SDK, not " + "here. Credentials come from the YANDEX_ID_OAUTH_TOKEN and " + "YANDEX_ID_ORGANIZATION_ID environment variables." + ), +) +mcp.mount(wiki_mcp, namespace="wiki") +mcp.mount(tracker_mcp, namespace="tracker") +mcp.mount(forms_mcp, namespace="forms") + + +def main() -> None: + """Run the root server over stdio (the console-script entry point). + + Example: + >>> main() # doctest: +SKIP + """ + configure( + level=AppConfig().log_level + ) # match the CLI: single stderr sink, stdout stays clean for the protocol + mcp.run() + + +if __name__ == "__main__": # pragma: no cover + main() +``` + +- [ ] **Step 4: Create `src/ycli/mcp/__init__.py`** (lazy, fastmcp-free) + +```python +"""The ``ycli mcp`` surface — the read-only FastMCP server plus its CLI sub-app. + +``__init__`` stays import-light so the base install (no ``mcp`` extra) can load +``ycli.mcp.cli`` without importing fastmcp; ``mcp`` and ``main`` resolve lazily on +attribute access, preserving ``from ycli.mcp import mcp, main`` for every call site. +""" + +from __future__ import annotations + +from typing import Any + +__all__ = ["main", "mcp"] + + +def __getattr__(name: str) -> Any: + if name in {"mcp", "main"}: + from ycli.mcp import server + + return getattr(server, name) + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") +``` + +- [ ] **Step 5: Create `src/ycli/mcp/cli.py`** (verbatim body of the current `src/ycli/mcp_cli.py`) + +```python +"""``ycli mcp`` sub-app: run the server and list its tools. Importable without the mcp extra.""" + +from __future__ import annotations + +import typer + +app = typer.Typer(name="mcp", help="Read-only MCP server control.", no_args_is_help=True) + +_MISSING = ( + "The MCP server requires the 'mcp' extra. Install it with: " + "uv add 'yandex-cli[mcp]' (or: uv tool install 'yandex-cli[mcp]')." +) + + +@app.callback() +def _group() -> None: + """Group anchor — forces subcommand dispatch (no eager import, --help stays extra-free).""" + + +@app.command() +def start() -> None: + """Run the read-only MCP server over stdio (tools namespaced wiki_*, tracker_*, forms_*).""" + try: + from ycli.mcp import main as run_server + except ModuleNotFoundError as exc: # pragma: no cover - only without the extra + raise typer.BadParameter(_MISSING) from exc + run_server() + + +@app.command() +def methods() -> None: + """List the MCP tool names exposed by the server.""" + import asyncio + + try: + from fastmcp import Client + + from ycli.mcp import mcp + except ModuleNotFoundError as exc: # pragma: no cover - only without the extra + raise typer.BadParameter(_MISSING) from exc + + async def _list() -> None: + async with Client(mcp) as client: + for tool in sorted(t.name for t in await client.list_tools()): + typer.echo(tool) + + asyncio.run(_list()) +``` + +- [ ] **Step 6: Create `src/ycli/mcp/__main__.py`** + +```python +"""``python -m ycli.mcp`` — run the read-only MCP server over stdio.""" + +from ycli.mcp.server import main + +if __name__ == "__main__": # pragma: no cover + main() +``` + +- [ ] **Step 7: Delete the old modules** + +```bash +git rm src/ycli/mcp.py src/ycli/mcp_cli.py +``` + +- [ ] **Step 8: Update `src/ycli/cli.py:14`** + +Old: +```python +from ycli.mcp_cli import app as mcp_app +``` +New: +```python +from ycli.mcp.cli import app as mcp_app +``` + +- [ ] **Step 9: Update `ARCHITECTURE.md` ARCH-3 prose** + +In the ARCH-3 bullet, replace the opening sentence: +``` +- **ARCH-3 — MCP is read-only.** `fastmcp` is imported only in modules named `mcp.py`. Every MCP +``` +with: +``` +- **ARCH-3 — MCP is read-only.** `fastmcp` is imported only in modules named `mcp.py` and in the + `ycli.mcp` server package (`src/ycli/mcp/server.py`; its `__init__.py` stays fastmcp-free so the + base install loads the CLI sub-app without the extra). Every MCP +``` +(Note: the import-linter contract in `pyproject.toml` already permits this — `ycli.mcp*` is not in the ARCH-3 `source_modules` forbidden list — so only the prose changes. Confirm with `uv run lint-imports` in Step 11.) + +- [ ] **Step 10: Run the base-install guard + the MCP server tests** + +Run: `uv run pytest tests/test_yandex_mcp.py tests/test_yandex_cli.py -v` +Expected: PASS — including `test_base_install_imports_cli_without_fastmcp`, `test_root_mounts_all_domains_with_namespaces` (still 25 tools), `test_mcp_start_launches_server` (patches `ycli.mcp.main`), `test_mcp_methods_lists_tool_names`. + +- [ ] **Step 11: Full gate + smoke test** + +Run: `uv run ruff format --check . && uv run ruff check . && uv run lint-imports && uv run ty check && uv run pytest` +Expected: all green. Then build-free smoke check: +Run: `uv run python -c "from ycli.mcp import mcp, main; from ycli.mcp.cli import app; print('ok')"` +Expected: `ok`. And `uv run python -m ycli.mcp --help`-equivalent is not applicable (server runs stdio); instead verify the entry resolves: `uv run python -c "import ycli.mcp.__main__"` → no error. + +- [ ] **Step 12: Commit** + +```bash +git add -A +git commit -m "refactor: move the MCP server + CLI into a ycli.mcp package + +Server lives in ycli/mcp/server.py; the package __init__ stays fastmcp-free and +re-exports mcp/main lazily so the base install loads ycli.mcp.cli without the extra. +python -m ycli.mcp runs the server via __main__. Updates ARCH-3 prose. + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +### Task 2: Remove `RawMapping` / `full` / `get_raw` / `issues_full` (W-A) + +Delete the one-off raw accessor across all four surfaces and its tests, update the two invariants that mention it, and regenerate the snapshots. + +**Files:** +- Modify: `src/ycli/yandex/models.py` (delete `RawMapping`) +- Modify: `src/ycli/yandex/tracker/issues/client.py` (delete `get_raw`) +- Modify: `src/ycli/yandex/tracker/issues/cli.py` (delete `full` command + `RawMapping` import) +- Modify: `src/ycli/yandex/tracker/issues/mcp.py` (delete `issues_full` tool + unused `Any` import if newly unused) +- Modify: `tests/yandex/tracker/issues/test_client.py`, `test_mcp.py`, `test_cli.py`, `tests/yandex/tracker/test_mcp.py`, `tests/test_yandex_mcp.py` +- Modify: `tests/test_architecture.py` (`READ_VERBS`) +- Modify: `ARCHITECTURE.md` (ARCH-4), `docs/conventions/resources.md` (§4) +- Regenerate: `tests/snapshots/mcp_tools.txt`, `tests/snapshots/cli_tree.txt` + +**Interfaces:** +- Produces: a smaller public surface (no `tracker issues full` CLI, no `issues_full` tool, no `get_raw` SDK method, no `RawMapping`). T3 re-adds one tool (`status_get`) restoring the MCP total to 25. + +- [ ] **Step 1: Delete the dead tests first (red baseline)** + +In `tests/yandex/tracker/issues/test_client.py` delete `test_get_raw_returns_dict` (the whole `@responses.activate` function asserting `_client().get_raw("DE-1") == {...}`). + +In `tests/yandex/tracker/issues/test_mcp.py`: +- Delete `test_issues_full_tool_returns_raw_dict` (the function calling `client.call_tool("issues_full", ...)`). +- In `test_issue_tools_registered_read_only`, change the asserted set from + `{"issues_get", "issues_full", "issues_list", "issues_search", "issues_count"}` to + `{"issues_get", "issues_list", "issues_search", "issues_count"}`. + +In `tests/yandex/tracker/issues/test_cli.py` delete both `test_full_renders_raw_dict_as_json` and `test_full_renders_raw_dict_as_yaml` (the latter holds the in-function `import yaml`; deleting it removes that smell — do NOT hoist `import yaml` to module top, no surviving test uses yaml, it would be an unused import). + +In `tests/yandex/tracker/test_mcp.py`: +- In `test_all_fourteen_read_tools_registered`, remove `"issues_full",` from the asserted set. +- Rename the function to `test_all_thirteen_read_tools_registered` and update the module docstring line 1 from `14 reads-only tools` to `13 reads-only tools`. + +In `tests/test_yandex_mcp.py`, in `test_root_mounts_all_domains_with_namespaces` change: +```python + assert len([n for n in names if n.startswith("tracker_")]) == 14 +``` +to +```python + assert len([n for n in names if n.startswith("tracker_")]) == 13 +``` +and +```python + assert len(names) == 25 +``` +to +```python + assert len(names) == 24 +``` +(T3 will restore this to 25 by adding `status_get`.) + +- [ ] **Step 2: Run the suite to confirm the deleted-feature tests are gone and the rest still reference live code** + +Run: `uv run pytest tests/yandex/tracker -q` +Expected: FAIL — surviving tests still pass, but the source still defines `full`/`get_raw`/`issues_full`, so the snapshot tests and `test_all_thirteen...`/count asserts now mismatch (source has 14 tracker tools, tests expect 13). This is the red state that the source deletion (next steps) turns green. + +- [ ] **Step 3: Delete `RawMapping` from `src/ycli/yandex/models.py`** + +Remove the class and the now-unused `RootModel` / `Any` imports: +```python +from typing import Any + +from pydantic import BaseModel, ConfigDict, RootModel +``` +becomes +```python +from pydantic import BaseModel, ConfigDict +``` +and delete: +```python +class RawMapping(RootModel[dict[str, Any]]): + """Wraps an unmodeled API dict so it renders through the Serializer (honoring --format).""" +``` + +- [ ] **Step 4: Delete `get_raw` from `src/ycli/yandex/tracker/issues/client.py`** + +Remove the whole method (the `@uplink.returns.json()` + `@uplink.get("issues/{key}")` + `def get_raw(...)` block with its docstring). + +- [ ] **Step 5: Delete the `full` command from `src/ycli/yandex/tracker/issues/cli.py`** + +Remove the `full` command: +```python +@app.command() +def full(ctx: typer.Context, key: KeyArg) -> None: + """Print the raw API dict for KEY (no pydantic projection).""" + app_ctx = AppContext.from_typer_context(ctx) + Serializer.serialize( + RawMapping(app_ctx.tracker.issues.get_raw(key)), app_ctx.strategy, app_ctx.console + ) +``` +and remove its now-unused import line: +```python +from ycli.yandex.models import RawMapping +``` + +- [ ] **Step 6: Delete the `issues_full` tool from `src/ycli/yandex/tracker/issues/mcp.py`** + +Remove: +```python +@mcp.tool( + name="issues_full", annotations={**RO, "title": "Get full Tracker issue (raw)"}, tags=TAGS +) +def full(key: str, client: TrackerClient = Depends(tracker_client)) -> dict[str, Any]: + """A single Tracker issue as a raw dict (all fields).""" + return client.issues.get_raw(key) +``` +Then check whether `Any` is still used in the file (the `from typing import Any` import). After removing `full`, grep the file: if `Any` no longer appears, delete `from typing import Any`. + +- [ ] **Step 7: Update `READ_VERBS` in `tests/test_architecture.py:24`** + +Old: +```python +READ_VERBS = {"get", "list", "count", "full", "search", "descendants", "meta"} +``` +New: +```python +READ_VERBS = {"get", "list", "count", "search", "descendants", "meta"} +``` + +- [ ] **Step 8: Update ARCH-4 in `ARCHITECTURE.md`** + +Replace: +``` + strategies live only in `output.py`. Unmodeled API dicts are wrapped in `RawMapping` + (a `RootModel[dict]` in `ycli.yandex.models`) before being passed to the Serializer. + *Carve-out:* a bare `print(int)` for a scalar `count` result is fine — it is not model +``` +with: +``` + strategies live only in `output.py`. Every rendered value is a typed pydantic model — there + is no raw-dict/`RawMapping` escape hatch. + *Carve-out:* a bare `print(int)` for a scalar `count` result is fine — it is not model +``` + +- [ ] **Step 9: Remove §4 from `docs/conventions/resources.md`** + +Delete the entire `## 4. Raw / full unpruned accessor (...)` section (its heading through just before `## 5. MCP tool-metadata standard`). Renumber the subsequent headings: `## 5.` → `## 4.`, `## 6.` → `## 5.`. Update any in-document cross-reference to those numbers if present (grep the file for `§4`/`§5`/`§6` / `section 5`). + +- [ ] **Step 10: Regenerate the snapshots** + +Run: `uv run python -m tests.snapshots --update` +Expected output: `wrote cli_tree.txt` and `wrote mcp_tools.txt`. Verify the diff removes exactly `tracker issues full` from `cli_tree.txt` and `tracker_issues_full` from `mcp_tools.txt` (and nothing else): +Run: `git diff tests/snapshots/` + +- [ ] **Step 11: Full gate** + +Run: `uv run ruff format --check . && uv run ruff check . && uv run lint-imports && uv run ty check && uv run pytest` +Expected: all green (24 MCP tools now; `test_arch3_mcp_tools_are_read_only` passes with no `_full` verb; `unused-ignore-comment` clean). + +- [ ] **Step 12: Commit** + +```bash +git add -A +git commit -m "feat!: remove the raw issues 'full' accessor and RawMapping + +BREAKING CHANGE: drops the 'tracker issues full' CLI command, the issues_full MCP +tool, IssuesClient.get_raw, and the RawMapping model. Every resource is a typed model. +Updates ARCH-3 read-verb allow-list, ARCH-4, resources.md, and the surface snapshots. + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +### Task 3: `status` package + native `me` + `status_get` MCP tool (W-B, W-F note, W-7) + +Explode `src/ycli/yandex/status.py` into a package, drop `ServiceProbe` + identity lambdas, return the bare native `me`, and add a read-only `status_get` MCP tool. + +**Files:** +- Create: `src/ycli/yandex/status/__init__.py`, `models.py`, `reporter.py`, `cli.py`, `mcp.py` +- Delete: `src/ycli/yandex/status.py` +- Modify: `src/ycli/mcp/server.py` (mount status subserver) +- Modify: `tests/test_yandex_mcp.py` (total 24→25, add `status_` assertion) +- Modify: `ARCHITECTURE.md` (ARCH-1 clarifying note) +- Regenerate: `tests/snapshots/mcp_tools.txt` +- Create: `tests/yandex/status/__init__.py`, `tests/yandex/status/test_mcp.py` +- Keep: `tests/yandex/test_status.py` (CLI behavior — must stay green unchanged) + +**Interfaces:** +- Consumes: each domain's `me` client (`TrackerClient.me` etc.), the cached `_deps` providers (`tracker_client`, `wiki_client`, `forms_client`), `RO` from `ycli.yandex._mcp`. +- Produces: `from ycli.yandex.status import app` (the `auth` Typer app — unchanged import for `cli.py:18`); the `status_get` MCP tool (verb `get`, namespace `status`); `ServiceAuthStatus(service, valid, me, detail)`, `AuthReport(configured, organization_id, services)`, `StatusReporter(me_clients).report(configured=, organization_id=)`. + +- [ ] **Step 1: Create the package `__init__.py`** + +`src/ycli/yandex/status/__init__.py`: +```python +"""Cross-cutting auth-status surface — the `auth status` CLI plus the `status_get` MCP tool. + +Not a `/` package (ARCH-1 four-surface symmetry does not apply): it +aggregates the three domains' `me` probes into one report. +""" + +from ycli.yandex.status.cli import app + +__all__ = ["app"] +``` + +- [ ] **Step 2: Create `models.py`** + +`src/ycli/yandex/status/models.py`: +```python +"""Models for `ycli auth status` and the `status_get` MCP tool.""" + +from __future__ import annotations + +from pydantic import Field + +from ycli.yandex.forms.me.models import User as FormsMe +from ycli.yandex.models import APIModel +from ycli.yandex.tracker.me.models import Me as TrackerMe +from ycli.yandex.wiki.me.models import Me as WikiMe + + +class ServiceAuthStatus(APIModel): + """One service's auth probe — the bare native `me` on success, else why it failed.""" + + service: str + valid: bool = False + me: TrackerMe | WikiMe | FormsMe | None = None + detail: str = "" + + +class AuthReport(APIModel): + """Whether the env credentials are set and work, per service.""" + + configured: bool + organization_id: str = "" + services: list[ServiceAuthStatus] = Field(default_factory=list) +``` + +Note: the three `me` models share a class name (`Me`/`Me`/`User`), hence the `as TrackerMe`/`as WikiMe`/`as FormsMe` aliases. The reporter passes model *instances* (not dumped dicts) so pydantic's smart-union keeps each one's concrete type. + +- [ ] **Step 3: Create `reporter.py`** + +`src/ycli/yandex/status/reporter.py`: +```python +"""Probe each service's identity endpoint and assemble an AuthReport (shared by CLI + MCP).""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Protocol + +from ycli.yandex.errors import YandexAuthError, YandexError +from ycli.yandex.status.models import AuthReport, ServiceAuthStatus + +if TYPE_CHECKING: + from collections.abc import Mapping + + from ycli.yandex.models import APIModel + + +class MeProbe(Protocol): + """Structural type for a domain `me` client: a zero-arg `get()` returning an API model.""" + + def get(self) -> APIModel: ... + + +class StatusReporter: + """Given each service's `me` client, probe identity and build a per-service AuthReport.""" + + def __init__(self, me_clients: Mapping[str, MeProbe]) -> None: + self._me_clients = me_clients + + def report(self, *, configured: bool, organization_id: str) -> AuthReport: + services = [self._probe(name, client) for name, client in self._me_clients.items()] + return AuthReport( + configured=configured, organization_id=organization_id, services=services + ) + + @staticmethod + def _probe(name: str, me_client: MeProbe) -> ServiceAuthStatus: + try: + me = me_client.get() + except YandexAuthError: + return ServiceAuthStatus(service=name, valid=False, detail="token invalid or expired") + except YandexError as exc: + return ServiceAuthStatus(service=name, valid=False, detail=str(exc)) + return ServiceAuthStatus(service=name, valid=True, me=me) +``` + +- [ ] **Step 4: Create `cli.py`** (the `auth` app — builds clients via `AppContext`, which is typed, so no `ty: ignore`) + +`src/ycli/yandex/status/cli.py`: +```python +"""`ycli auth status` — validate credentials against each service's identity endpoint.""" + +from __future__ import annotations + +import typer +from pydantic import ValidationError + +from ycli.context import AppContext +from ycli.output import Serializer +from ycli.settings import Credentials +from ycli.yandex.status.models import AuthReport +from ycli.yandex.status.reporter import StatusReporter + +app = typer.Typer(name="auth", help="Inspect Yandex 360 credentials.", no_args_is_help=True) + +_ENV_NAMES = { + "oauth_token": "YANDEX_ID_OAUTH_TOKEN", + "organization_id": "YANDEX_ID_ORGANIZATION_ID", +} + + +@app.command() +def status(ctx: typer.Context) -> None: + """Report whether the env credentials are set and actually work, per service.""" + app_ctx = AppContext.from_typer_context(ctx) + try: + credentials = Credentials() # ty: ignore[missing-argument] + except ValidationError as exc: + missing = ", ".join( + _ENV_NAMES.get(str(e["loc"][0]), str(e["loc"][0])) for e in exc.errors() + ) + typer.secho(f"not configured — missing {missing}", fg=typer.colors.RED, err=True) + Serializer.serialize( + AuthReport(configured=False, services=[]), app_ctx.strategy, app_ctx.console + ) + raise typer.Exit(1) from None + + me_clients = { + "tracker": app_ctx.tracker.me, + "wiki": app_ctx.wiki.me, + "forms": app_ctx.forms.me, + } + report = StatusReporter(me_clients).report( + configured=True, organization_id=credentials.organization_id + ) + Serializer.serialize(report, app_ctx.strategy, app_ctx.console) + if not all(s.valid for s in report.services): + raise typer.Exit(1) +``` + +- [ ] **Step 5: Create `mcp.py`** (read-only `status_get`) + +`src/ycli/yandex/status/mcp.py`: +```python +"""Status FastMCP tool (read-only) — aggregate auth probe across all three services.""" + +from fastmcp import FastMCP +from fastmcp.dependencies import Depends + +from ycli.yandex._mcp import RO +from ycli.yandex.forms._deps import forms_client +from ycli.yandex.forms.client import FormsClient +from ycli.yandex.status.models import AuthReport +from ycli.yandex.status.reporter import StatusReporter +from ycli.yandex.tracker._deps import tracker_client +from ycli.yandex.tracker.client import TrackerClient +from ycli.yandex.wiki._deps import wiki_client +from ycli.yandex.wiki.client import WikiClient + +mcp = FastMCP("status") +TAGS: set[str] = {"status"} + + +@mcp.tool(name="get", annotations={**RO, "title": "Check Yandex 360 auth status"}, tags=TAGS) +def get( + tracker: TrackerClient = Depends(tracker_client), + wiki: WikiClient = Depends(wiki_client), + forms: FormsClient = Depends(forms_client), +) -> AuthReport: + """Probe each service's identity endpoint; report which credentials work. + + ``organization_id`` is left blank here — the per-service ``me`` already identifies the + authenticated user; the CLI ``auth status`` carries the org id. + """ + me_clients = {"tracker": tracker.me, "wiki": wiki.me, "forms": forms.me} + return StatusReporter(me_clients).report(configured=True, organization_id="") +``` + +- [ ] **Step 6: Delete the old module** + +```bash +git rm src/ycli/yandex/status.py +``` + +- [ ] **Step 7: Mount the status subserver in `src/ycli/mcp/server.py`** + +Add the import alongside the others: +```python +from ycli.yandex.forms.mcp import mcp as forms_mcp +from ycli.yandex.status.mcp import mcp as status_mcp +from ycli.yandex.tracker.mcp import mcp as tracker_mcp +from ycli.yandex.wiki.mcp import mcp as wiki_mcp +``` +and add the mount after the three domain mounts: +```python +mcp.mount(wiki_mcp, namespace="wiki") +mcp.mount(tracker_mcp, namespace="tracker") +mcp.mount(forms_mcp, namespace="forms") +mcp.mount(status_mcp, namespace="status") +``` + +- [ ] **Step 8: Write the `status_get` MCP test** + +Create `tests/yandex/status/__init__.py`: +```python +``` +(empty file is fine — it is a test package, not a `yandex/` resource). + +Create `tests/yandex/status/test_mcp.py`: +```python +"""status_get MCP tool — aggregates the three /me probes into one read-only report.""" + +import pytest +import responses +from fastmcp import Client + +from ycli.yandex.status import mcp as status_mcp + +TRACKER_ME = "https://api.tracker.yandex.net/v3/myself" +FORMS_ME = "https://api.forms.yandex.net/v1/users/me" +WIKI_ME = "https://api.wiki.yandex.net/v1/users/me" + + +@pytest.fixture +def creds(monkeypatch): + monkeypatch.setenv("YANDEX_ID_OAUTH_TOKEN", "t") + monkeypatch.setenv("YANDEX_ID_ORGANIZATION_ID", "o") + + +@responses.activate +async def test_status_get_reports_all_valid(creds): + responses.add(responses.GET, TRACKER_ME, json={"login": "alice"}, status=200) + responses.add(responses.GET, WIKI_ME, json={"username": "alice"}, status=200) + responses.add(responses.GET, FORMS_ME, json={"id": 1, "email": "alice@x"}, status=200) + async with Client(status_mcp.mcp) as client: + result = await client.call_tool("get", {}) + services = {s.service: s for s in result.data.services} + assert services["tracker"].valid is True + assert services["tracker"].me.login == "alice" + assert services["forms"].me.email == "alice@x" + + +@responses.activate +async def test_status_get_marks_invalid_on_401(creds): + responses.add(responses.GET, TRACKER_ME, status=401) + responses.add(responses.GET, WIKI_ME, json={"username": "alice"}, status=200) + responses.add(responses.GET, FORMS_ME, json={"id": 1, "email": "alice@x"}, status=200) + async with Client(status_mcp.mcp) as client: + result = await client.call_tool("get", {}) + services = {s.service: s for s in result.data.services} + assert services["tracker"].valid is False + assert services["tracker"].detail == "token invalid or expired" + + +async def test_status_get_is_read_only(): + async with Client(status_mcp.mcp) as client: + tools = {t.name: t for t in await client.list_tools()} + assert "get" in tools + assert tools["get"].annotations.readOnlyHint is True +``` + +Note: the cached `_deps` providers (`tracker_client` etc.) memoize via `functools.cache`; if a later test needs fresh creds, call `tracker_client.cache_clear()` — the existing per-domain MCP tests in the suite already exercise this pattern, so the cache is exercised consistently. These three tests use one cred set, so no clear is required. + +- [ ] **Step 9: Update `tests/test_yandex_mcp.py` totals (restore to 25, add status)** + +In `test_root_mounts_all_domains_with_namespaces` change the total back to 25 and add the status assertions: +```python + assert "forms_surveys_get" in names + assert "status_get" in names + assert len([n for n in names if n.startswith("wiki_")]) == 6 + assert len([n for n in names if n.startswith("tracker_")]) == 13 + assert len([n for n in names if n.startswith("forms_")]) == 5 + assert len([n for n in names if n.startswith("status_")]) == 1 + assert len(names) == 25 +``` + +- [ ] **Step 10: Add the ARCH-1 clarifying note in `ARCHITECTURE.md`** + +Append to the ARCH-1 bullet (after `Use /new-endpoint to scaffold.`): +``` + *Carve-out:* `yandex/status/` and the `ycli/mcp/` server package are cross-cutting surfaces, + not `/` dirs — the four-surface rule and the `_resource_dirs()` check + (which scans only `tracker/wiki/forms`) do not apply to them. +``` + +- [ ] **Step 11: Regenerate snapshots** + +Run: `uv run python -m tests.snapshots --update` +Expected: `mcp_tools.txt` gains `status_get` (sorted — it lands between `forms_*` and `tracker_*`); `cli_tree.txt` is unchanged (`auth`/`auth status` already present, `status_get` is MCP-only). Verify: +Run: `git diff tests/snapshots/` +Expected: only `+status_get` in `mcp_tools.txt`. + +- [ ] **Step 12: Run the status tests + full gate** + +Run: `uv run pytest tests/yandex/test_status.py tests/yandex/status/ tests/test_yandex_mcp.py -v` +Expected: PASS — existing CLI status tests still green (output still contains `"valid":true` ×3; the new `me` field adds keys but the asserts hold), new MCP tests green, 25 tools. +Run: `uv run ruff format --check . && uv run ruff check . && uv run lint-imports && uv run ty check && uv run pytest` +Expected: all green. + +- [ ] **Step 13: Commit** + +```bash +git add -A +git commit -m "feat: status package with native me + read-only status_get MCP tool + +Explodes yandex/status.py into a package; drops ServiceProbe and the per-service +identity lambdas — each ServiceAuthStatus now carries the bare native me model. +Adds the status_get MCP tool (namespace status, read-only). ARCH-1 carve-out note. + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +### Task 4: Pagination generics + fold `collect_single_page` (W-D) + +Add PEP 695 generics over (page `P`, item `T`) and a wrapped-result type, and fold the module-level `collect_single_page` into `SinglePageStrategy` as a classmethod. Behavior is unchanged; the dict-driven tests must stay valid, so the strategies stay generic over the page type via the injected callables (NOT a structural protocol requiring page attributes). + +**Files:** +- Modify: `src/ycli/yandex/pagination.py` +- Modify call sites: `src/ycli/yandex/forms/surveys/client.py`, `src/ycli/yandex/wiki/attachments/client.py`, `src/ycli/yandex/wiki/comments/client.py` +- Modify: `tests/yandex/test_pagination.py` + +**Interfaces:** +- Consumes: nothing new. +- Produces: `PaginationStrategy[P, T]` (generic ABC, `collect(...) -> list[T]`); `SinglePageStrategy.collect_wrapped(page_fn, *, extract, wrap, limit) -> R` (classmethod replacing the free `collect_single_page`). `CursorStrategy[P, T]`, `NextUrlStrategy[P, T]` unchanged in behavior. + +- [ ] **Step 1: Update the pagination test for the folded API** + +In `tests/yandex/test_pagination.py`: +- Change the import (drop `collect_single_page`): +```python +from ycli.yandex.pagination import ( + CursorStrategy, + NextUrlStrategy, + SinglePageStrategy, +) +``` +- Replace `test_collect_single_page_extracts_wraps_and_bounds` with: +```python +def test_single_page_collect_wrapped_extracts_wraps_and_bounds(): + pages = {"a": [1, 2, 3]} + out = SinglePageStrategy.collect_wrapped( + lambda cursor: pages, extract=lambda p: p["a"], wrap=list, limit=2 + ) + assert out == [1, 2] +``` +(All other tests are unchanged — they drive the strategies with plain `dict` pages, which the generic-over-`P` callables still accept.) + +- [ ] **Step 2: Run it to verify it fails** + +Run: `uv run pytest tests/yandex/test_pagination.py -v` +Expected: FAIL — `SinglePageStrategy.collect_wrapped` does not exist yet; `collect_single_page` import removed. + +- [ ] **Step 3: Rewrite `src/ycli/yandex/pagination.py`** + +```python +"""Pagination strategies — drain an API's page mechanics into a bounded flat list. + +Each strategy owns ONE cursor mechanic and accepts injected page-access callables, so the +public client method never exposes a cursor: it picks a strategy, says how to read a page, +and gets back a list capped at ``limit`` (``None`` = uncapped). Pure — no HTTP here. + +Generic over the page type ``P`` (whatever ``fetch_page`` returns — a pydantic model in +production, a plain ``dict`` in tests) and the item type ``T``. The injected callables do +all structural access, so no page Protocol is imposed. +""" + +from __future__ import annotations + +from abc import ABC, abstractmethod +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from collections.abc import Callable + + +class PaginationStrategy[P, T](ABC): + @abstractmethod + def collect(self, fetch_page: Callable[[str | None], P], limit: int | None) -> list[T]: + """Accumulate items by driving ``fetch_page`` until exhausted or ``limit`` reached.""" + + +class SinglePageStrategy[P, T](PaginationStrategy[P, T]): + def __init__(self, *, extract: Callable[[P], list[T]]) -> None: + self._extract = extract + + def collect(self, fetch_page: Callable[[str | None], P], limit: int | None) -> list[T]: + items = list(self._extract(fetch_page(None))) + return items if limit is None else items[:limit] + + @classmethod + def collect_wrapped[R]( + cls, + page_fn: Callable[[str | None], P], + *, + extract: Callable[[P], list[T]], + wrap: Callable[[list[T]], R], + limit: int | None = None, + ) -> R: + """Single-page envelope -> bounded, wrapped flat collection (the wiki/forms list shape).""" + return wrap(cls(extract=extract).collect(page_fn, limit)) + + +class CursorStrategy[P, T](PaginationStrategy[P, T]): + def __init__( + self, *, extract: Callable[[P], list[T]], next_of: Callable[[P], str | None] + ) -> None: + self._extract = extract + self._next_of = next_of + + def collect(self, fetch_page: Callable[[str | None], P], limit: int | None) -> list[T]: + items: list[T] = [] + cursor: str | None = None + while True: + page = fetch_page(cursor) + items.extend(self._extract(page)) + if limit is not None and len(items) >= limit: + return items[:limit] + cursor = self._next_of(page) + if cursor is None: + return items + + +class NextUrlStrategy[P, T](PaginationStrategy[P, T]): + """HATEOAS: the first page comes from ``fetch_page``; subsequent ones from ``fetch_url``.""" + + def __init__( + self, + *, + extract: Callable[[P], list[T]], + next_url_of: Callable[[P], str | None], + fetch_url: Callable[[str], P], + ) -> None: + self._extract = extract + self._next_url_of = next_url_of + self._fetch_url = fetch_url + + def collect(self, fetch_page: Callable[[str | None], P], limit: int | None) -> list[T]: + page = fetch_page(None) + items: list[T] = list(self._extract(page)) + seen: set[str] = set() + url = self._next_url_of(page) + while url is not None and url not in seen: + if limit is not None and len(items) >= limit: + break + seen.add(url) + page = self._fetch_url(url) + items.extend(self._extract(page)) + url = self._next_url_of(page) + return items if limit is None else items[:limit] +``` + +Behavioral note: `CursorStrategy` previously stopped on `if not cursor` (falsy → also empty string); the new `if cursor is None` matches the API contract (`next_cursor` is `null` when exhausted, per `DescendantsResponse`) and the existing test (`next_cursor: None`). `NextUrlStrategy` previously stopped on `while url and ...`; `while url is not None and ...` is equivalent for the `str | None` shape the call site produces. The existing tests pass a dict whose `next_url_of` returns `None` at the end, so both stay green. + +- [ ] **Step 4: Update call site — surveys** (`src/ycli/yandex/forms/surveys/client.py`) + +Old import: +```python +from ycli.yandex.pagination import collect_single_page +``` +New: +```python +from ycli.yandex.pagination import SinglePageStrategy +``` +Old body of `list`: +```python + return collect_single_page( + lambda cursor: self._list_page(), + extract=lambda page: page.result, + wrap=SurveyList, + limit=limit, + ) +``` +New: +```python + return SinglePageStrategy.collect_wrapped( + lambda cursor: self._list_page(), + extract=lambda page: page.result, + wrap=SurveyList, + limit=limit, + ) +``` + +- [ ] **Step 5: Update call site — attachments** (`src/ycli/yandex/wiki/attachments/client.py`) + +Old import `from ycli.yandex.pagination import collect_single_page` → `from ycli.yandex.pagination import SinglePageStrategy`. Old body: +```python + return collect_single_page( + lambda cursor: self._list_page(page_id, page_size=100), + extract=lambda page: page.results, + wrap=AttachmentList, + limit=limit, + ) +``` +New: +```python + return SinglePageStrategy.collect_wrapped( + lambda cursor: self._list_page(page_id, page_size=100), + extract=lambda page: page.results, + wrap=AttachmentList, + limit=limit, + ) +``` + +- [ ] **Step 6: Update call site — comments** (`src/ycli/yandex/wiki/comments/client.py`) + +Identical transform to Step 5 (import + `collect_single_page(...)` → `SinglePageStrategy.collect_wrapped(...)`), with `wrap=CommentList`. + +- [ ] **Step 7: Run pagination + the three resource tests** + +Run: `uv run pytest tests/yandex/test_pagination.py tests/yandex/forms/surveys tests/yandex/wiki/attachments tests/yandex/wiki/comments tests/yandex/wiki/pages tests/yandex/forms/answers -v` +Expected: PASS — `wiki/pages` (CursorStrategy) and `forms/answers` (NextUrlStrategy) unchanged at the call sites and still green. + +- [ ] **Step 8: Full gate** + +Run: `uv run ruff format --check . && uv run ruff check . && uv run lint-imports && uv run ty check && uv run pytest` +Expected: all green. `ty check` is the load-bearing check here — the generics must resolve at all five call sites with no new `ty: ignore` (and `unused-ignore-comment = warn` + `error-on-warning = true` means no stale ignores). + +- [ ] **Step 9: Commit** + +```bash +git add -A +git commit -m "refactor: type pagination strategies with PEP 695 generics + +Strategies are generic over page type P and item T; collect returns list[T]. +Folds the free collect_single_page into SinglePageStrategy.collect_wrapped. +Cursor/url termination uses 'is None' to match the null-cursor API contract. + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +### Task 5: Docstrings for the empty `__init__.py` files (W-E) + +The four empty `__init__.py` exist for ARCH-1 but carry no docstring. Give them one (do NOT delete them). The `import yaml` smell from the spec was resolved in Task 2 (its only user, `test_full_renders_raw_dict_as_yaml`, was deleted). + +**Files:** +- Modify: `src/ycli/yandex/__init__.py`, `src/ycli/yandex/wiki/attachments/__init__.py`, `src/ycli/yandex/wiki/comments/__init__.py`, `src/ycli/yandex/wiki/pages/__init__.py` + +- [ ] **Step 1: Add docstrings** (one module-docstring line each, matching the repo style `""" / resource package."""`) + +`src/ycli/yandex/__init__.py`: +```python +"""Yandex 360 SDK — per-domain clients (tracker, wiki, forms) plus shared model/MCP bases.""" +``` +`src/ycli/yandex/wiki/attachments/__init__.py`: +```python +"""Wiki /pages/{id}/attachments resource package.""" +``` +`src/ycli/yandex/wiki/comments/__init__.py`: +```python +"""Wiki /pages/{id}/comments resource package.""" +``` +`src/ycli/yandex/wiki/pages/__init__.py`: +```python +"""Wiki /pages resource package.""" +``` + +- [ ] **Step 2: Full gate** + +Run: `uv run ruff format --check . && uv run ruff check . && uv run ty check && uv run pytest` +Expected: all green (docstrings don't change behavior or coverage). + +- [ ] **Step 3: Commit** + +```bash +git add -A +git commit -m "docs: add module docstrings to the four empty __init__.py files + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +### Task 6: Reproducible demo output (W-G) + +Replace the hand-typed `cat <` → prints real CLI output for the fixture; exit 0. + +- [ ] **Step 1: Write the render test (TDD)** + +Create `tests/test_demo_render.py`: +```python +"""The demo render harness emits real CLI output from committed fixtures (leak-free).""" + +import subprocess +import sys +from pathlib import Path + +import pytest + +REPO = Path(__file__).resolve().parent.parent +RENDER = REPO / "docs" / "demo" / "render.py" + +pytestmark = pytest.mark.integration + + +def _run(args): + return subprocess.run( + [sys.executable, str(RENDER), *args], + capture_output=True, + text=True, + cwd=REPO, + ) + + +def test_render_tracker_issue_get_emits_fixture_key(): + proc = _run(["tracker", "issues", "get", "TRACKER-1"]) + assert proc.returncode == 0, proc.stderr + assert "TRACKER-1" in proc.stdout + + +def test_render_wiki_page_get_emits_fixture_title(): + proc = _run(["wiki", "pages", "get", "onboarding"]) + assert proc.returncode == 0, proc.stderr + assert "onboarding" in proc.stdout +``` + +- [ ] **Step 2: Run it to verify it fails** + +Run: `uv run pytest tests/test_demo_render.py -v` +Expected: FAIL — `docs/demo/render.py` does not exist. + +- [ ] **Step 3: Create the fixtures** + +`docs/demo/fixtures/tracker-issue.json` (fake, leak-free — fields the `Issue` model renders): +```json +{ + "key": "TRACKER-1", + "summary": "Set up project scaffolding", + "status": {"key": "inProgress", "display": "In Progress"}, + "assignee": {"display": "Alice"}, + "priority": {"key": "normal", "display": "Normal"} +} +``` +`docs/demo/fixtures/wiki-page.json` (fields the wiki `pages get` model renders — match the real `PageDetails` shape; the implementer confirms keys against `src/ycli/yandex/wiki/pages/models.py`): +```json +{ + "slug": "onboarding", + "title": "Team Onboarding Guide", + "author": {"display": "Bob"}, + "revision": 7 +} +``` + +- [ ] **Step 4: Create `docs/demo/render.py`** + +```python +"""Render real `ycli` CLI output from a committed fixture — the demo's leak-free data source. + +Used only by docs/demo/bin/ycli (the vhs shim). Stubs the matching API endpoint with +`responses`, sets dummy creds, and invokes the real Typer app in-process so the printed +output is genuine rendering of committed data — deterministic, offline, no real org data. + + python docs/demo/render.py tracker issues get TRACKER-1 + python docs/demo/render.py wiki pages get onboarding +""" + +from __future__ import annotations + +import json +import sys +from pathlib import Path + +import responses +from typer.testing import CliRunner + +HERE = Path(__file__).resolve().parent +FIXTURES = HERE / "fixtures" +TRACKER = "https://api.tracker.yandex.net/v3" +WIKI = "https://api.wiki.yandex.net/v1" + +# Map a demo command (argv tuple) to (HTTP method, URL, fixture file). +ROUTES = { + ("tracker", "issues", "get", "TRACKER-1"): ( + responses.GET, + f"{TRACKER}/issues/TRACKER-1", + "tracker-issue.json", + ), + ("wiki", "pages", "get", "onboarding"): ( + responses.GET, + f"{WIKI}/pages/onboarding", + "wiki-page.json", + ), +} + + +def main(argv: list[str]) -> int: + route = ROUTES.get(tuple(argv)) + if route is None: + print(f"demo render: unknown command {argv}", file=sys.stderr) + return 2 + method, url, fixture = route + body = json.loads((FIXTURES / fixture).read_text(encoding="utf-8")) + + from ycli import cli + + runner = CliRunner() + with responses.RequestsMock() as rsps: + rsps.add(method, url, json=body, status=200) + # Dummy creds satisfy Credentials(); responses intercepts the call (no real network). + env = {"YANDEX_ID_OAUTH_TOKEN": "demo", "YANDEX_ID_ORGANIZATION_ID": "demo"} + result = runner.invoke(cli.app, ["--format", "pretty", *argv], env=env) + sys.stdout.write(result.stdout) + return result.exit_code + + +if __name__ == "__main__": + raise SystemExit(main(sys.argv[1:])) +``` + +Implementer note: confirm the wiki `pages get` URL path (`/pages/{slug}` vs a query param) against `src/ycli/yandex/wiki/pages/client.py`; adjust the `ROUTES` URL (and the `--format pretty` choice if pretty needs a TTY — fall back to `json` if `pretty` renders empty under `CliRunner`). The test in Step 1 is the gate. + +- [ ] **Step 5: Run the render test** + +Run: `uv run pytest tests/test_demo_render.py -v` +Expected: PASS — both commands emit the fixture's key field. If `--format pretty` yields empty output under `CliRunner`, switch the `render.py` invoke to `["--format", "json", *argv]` and re-run. + +- [ ] **Step 6: Update the shim `docs/demo/bin/ycli`** + +```bash +#!/usr/bin/env bash +# Demo shim used ONLY by docs/demo/demo.tape. Real `--help` and a real `mcp methods` +# tool list; the data commands render committed fixtures through the REAL ycli via +# docs/demo/render.py (no network, no credentials). Keeps the GIF reproducible and +# leak-free. Not installed; not on a user's PATH. +case "$*" in + "--help"|"") + exec uv run ycli --help ;; + "tracker issues get TRACKER-1"|"wiki pages get onboarding") + exec uv run python docs/demo/render.py "$@" ;; + "mcp methods") + exec uv run --extra mcp ycli mcp methods ;; + *) + exec uv run ycli "$@" ;; +esac +``` + +- [ ] **Step 7: Update `docs/demo/demo.tape`** + +Replace the `mcp start` step (which faked a tool list) with the real `mcp methods`, and keep the two fixture-rendered data commands. Change: +``` +# Read-only MCP server banner with real tool names. +Type "ycli mcp start" Sleep 500ms Enter +Sleep 3s +``` +to: +``` +# Real read-only MCP tool list (no creds, no network). +Type "ycli mcp methods" Sleep 500ms Enter +Sleep 3s +``` +Also bump `Set Height 720` to `Set Height 900` (the real list is ~24 lines) so the tool list is not clipped. Update the tape header comment block: the data commands now render committed fixtures via `docs/demo/render.py`, and `mcp methods` needs the `mcp` extra at regeneration time. + +- [ ] **Step 8: Full gate** + +Run: `uv run ruff format --check . && uv run ruff check . && uv run lint-imports && uv run ty check && uv run pytest` +Expected: all green. (`render.py` lives under `docs/`, not `src/ycli`, so it is outside the coverage source — the `test_demo_render.py` subprocess test guards it from rot without affecting the 100% gate.) + +- [ ] **Step 9: Commit** + +```bash +git add -A +git commit -m "build: render demo output from committed fixtures, not hand-typed text + +docs/demo/render.py runs the real ycli in-process against committed JSON fixtures via +responses (deterministic, leak-free, offline); the demo's MCP tool list now comes from +the real 'ycli mcp methods' instead of a baked, drift-prone list. + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Self-Review + +**1. Spec coverage:** +- W-A (RawMapping/full) → Task 2 ✓ +- W-B (status package + native me + status_get) → Task 3 ✓ +- W-C (ycli/mcp package) → Task 1 ✓ (with the fastmcp-free `__init__` refinement) +- W-D (pagination generics + Envelope) → Task 4 ✓ (Envelope refined to generic `P`/`T` params, not a structural protocol, to keep dict-driven tests valid — documented in the task) +- W-E (smell sweep) → Task 5 ✓ (the `import yaml` item is obviated by Task 2; only the four docstrings remain) +- W-F (ARCH docs + snapshots) → folded into Tasks 1/2/3 (ARCH-3 in T1, ARCH-4 + READ_VERBS + resources §4 in T2, ARCH-1 note in T3; snapshots regenerated in T2/T3) ✓ +- W-G (demo) → Task 6 ✓ + +**2. Placeholder scan:** No TBD/TODO. Two explicit implementer confirmations remain (wiki page URL shape in T6 Step 4; `--format pretty` vs `json` under CliRunner in T6 Step 5) — both are guarded by the Step 1 test, not open-ended directives. The `me` union fallback to `dict` (T3) is a stated contingency, not a placeholder. + +**3. Type consistency:** `StatusReporter(me_clients).report(configured=, organization_id=)` is used identically in `status/cli.py` and `status/mcp.py`. `ServiceAuthStatus(service, valid, me, detail)` and `AuthReport(configured, organization_id, services)` match across T3. `SinglePageStrategy.collect_wrapped(page_fn, *, extract, wrap, limit)` matches the three call sites and the test in T4. `from ycli.mcp import mcp, main` (lazy) is consumed by `_surface.py`, `test_architecture.py`, `test_yandex_mcp.py`, and `mcp/cli.py` — all unchanged. + +**Cross-task ordering:** T1 (mcp package) precedes T3 (mounts status in `mcp/server.py`). T2 sets the MCP total to 24; T3 restores it to 25 — both edit `test_yandex_mcp.py` sequentially. No task depends on a later task. From 8581114cbf4466b8ffd67ef3532f219a7a223b5c Mon Sep 17 00:00:00 2001 From: Sava Znatnov Date: Mon, 29 Jun 2026 12:57:18 +0300 Subject: [PATCH 03/25] refactor: move the MCP server + CLI into a ycli.mcp package Server lives in ycli/mcp/server.py; the package __init__ stays fastmcp-free and re-exports mcp/main lazily so the base install loads ycli.mcp.cli without the extra. python -m ycli.mcp runs the server via __main__. Updates ARCH-3 prose. Co-Authored-By: Claude Opus 4.8 --- ARCHITECTURE.md | 4 +++- src/ycli/cli.py | 2 +- src/ycli/mcp/__init__.py | 20 ++++++++++++++++++++ src/ycli/mcp/__main__.py | 6 ++++++ src/ycli/{mcp_cli.py => mcp/cli.py} | 0 src/ycli/{mcp.py => mcp/server.py} | 2 +- tests/test_yandex_mcp.py | 15 +++++++++++++++ 7 files changed, 46 insertions(+), 3 deletions(-) create mode 100644 src/ycli/mcp/__init__.py create mode 100644 src/ycli/mcp/__main__.py rename src/ycli/{mcp_cli.py => mcp/cli.py} (100%) rename src/ycli/{mcp.py => mcp/server.py} (94%) diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 61f6699..608f1d8 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -36,7 +36,9 @@ Notable shared pieces: `__init__.py`, `client.py`, `cli.py`, `mcp.py`, `models.py`. Use `/new-endpoint` to scaffold. - **ARCH-2 — HTTP confinement.** `cli.py`, `mcp.py`, and `models.py` never import `requests` or `uplink`. All HTTP lives in `client.py` / `base.py` / `transport.py`. -- **ARCH-3 — MCP is read-only.** `fastmcp` is imported only in modules named `mcp.py`. Every MCP +- **ARCH-3 — MCP is read-only.** `fastmcp` is imported only in modules named `mcp.py` and in the + `ycli.mcp` server package (`src/ycli/mcp/server.py`; its `__init__.py` stays fastmcp-free so the + base install loads the CLI sub-app without the extra). Every MCP tool's verb (last `_`-segment of its name) must be in a fail-closed read-verb **allow-list** (`get/list/count/full/search/descendants/meta` — a new read adds its verb deliberately), it carries `readOnlyHint=True` (via the `RO` annotation), and no `mcp.py` may call a client write diff --git a/src/ycli/cli.py b/src/ycli/cli.py index c4abe42..ea7306c 100644 --- a/src/ycli/cli.py +++ b/src/ycli/cli.py @@ -11,7 +11,7 @@ from ycli.context import AppContext from ycli.log import configure -from ycli.mcp_cli import app as mcp_app +from ycli.mcp.cli import app as mcp_app from ycli.output import OutputFormat from ycli.settings import AppConfig from ycli.yandex.forms.cli import app as forms_app diff --git a/src/ycli/mcp/__init__.py b/src/ycli/mcp/__init__.py new file mode 100644 index 0000000..7b6e9a1 --- /dev/null +++ b/src/ycli/mcp/__init__.py @@ -0,0 +1,20 @@ +"""The ``ycli mcp`` surface — the read-only FastMCP server plus its CLI sub-app. + +``__init__`` stays import-light so the base install (no ``mcp`` extra) can load +``ycli.mcp.cli`` without importing fastmcp; ``mcp`` and ``main`` resolve lazily on +attribute access, preserving ``from ycli.mcp import mcp, main`` for every call site. +""" + +from __future__ import annotations + +from typing import Any + +__all__ = ["main", "mcp"] + + +def __getattr__(name: str) -> Any: + if name in {"mcp", "main"}: + from ycli.mcp import server + + return getattr(server, name) + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") diff --git a/src/ycli/mcp/__main__.py b/src/ycli/mcp/__main__.py new file mode 100644 index 0000000..0909859 --- /dev/null +++ b/src/ycli/mcp/__main__.py @@ -0,0 +1,6 @@ +"""``python -m ycli.mcp`` — run the read-only MCP server over stdio.""" + +from ycli.mcp.server import main + +if __name__ == "__main__": # pragma: no cover + main() diff --git a/src/ycli/mcp_cli.py b/src/ycli/mcp/cli.py similarity index 100% rename from src/ycli/mcp_cli.py rename to src/ycli/mcp/cli.py diff --git a/src/ycli/mcp.py b/src/ycli/mcp/server.py similarity index 94% rename from src/ycli/mcp.py rename to src/ycli/mcp/server.py index 655cb7e..e157839 100644 --- a/src/ycli/mcp.py +++ b/src/ycli/mcp/server.py @@ -1,6 +1,6 @@ """Root Yandex 360 FastMCP server — mounts the per-domain subservers. -Run over stdio for LLM-agent clients: ``ycli mcp`` (or ``python -m ycli.mcp``). +Run over stdio for LLM-agent clients: ``ycli mcp start`` (or ``python -m ycli.mcp``). Tools are namespaced per domain: ``wiki_*``, ``tracker_*``, ``forms_*``. Reads-only. """ diff --git a/tests/test_yandex_mcp.py b/tests/test_yandex_mcp.py index 5fef13b..80e0707 100644 --- a/tests/test_yandex_mcp.py +++ b/tests/test_yandex_mcp.py @@ -6,6 +6,16 @@ from ycli.mcp import mcp +def test_base_install_imports_cli_without_fastmcp(): + """`ycli.mcp.cli` (and `ycli.cli`) must import without pulling fastmcp — base install.""" + import subprocess + import sys + + code = "import ycli.cli, ycli.mcp.cli, sys; assert 'fastmcp' not in sys.modules" + proc = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True) + assert proc.returncode == 0, proc.stderr + + async def test_root_mounts_all_domains_with_namespaces(): async with Client(mcp) as client: names = {t.name for t in await client.list_tools()} @@ -24,6 +34,11 @@ def test_main_is_callable(): assert callable(main) +def test_mcp_main_module_importable(): + """``python -m ycli.mcp`` entry resolves — covers the __main__.py import line.""" + import ycli.mcp.__main__ # noqa: F401 + + @pytest.mark.integration def test_mcp_main_honors_log_level(monkeypatch, capsys): monkeypatch.setenv("YCLI_LOG_LEVEL", "ERROR") From 6a11d8a5b51b0ddcd5f78695de5a5b2202caca9c Mon Sep 17 00:00:00 2001 From: Sava Znatnov Date: Mon, 29 Jun 2026 13:04:48 +0300 Subject: [PATCH 04/25] feat!: remove the raw issues 'full' accessor and RawMapping BREAKING CHANGE: drops the 'tracker issues full' CLI command, the issues_full MCP tool, IssuesClient.get_raw, and the RawMapping model. Every resource is a typed model. Updates ARCH-3 read-verb allow-list, ARCH-4, resources.md, and the surface snapshots. Co-Authored-By: Claude Opus 4.8 --- ARCHITECTURE.md | 8 +++--- docs/conventions/resources.md | 31 ++-------------------- src/ycli/yandex/models.py | 8 +----- src/ycli/yandex/tracker/issues/cli.py | 10 ------- src/ycli/yandex/tracker/issues/client.py | 14 ---------- src/ycli/yandex/tracker/issues/mcp.py | 10 ------- tests/snapshots/cli_tree.txt | 1 - tests/snapshots/mcp_tools.txt | 1 - tests/test_architecture.py | 2 +- tests/test_yandex_mcp.py | 4 +-- tests/yandex/tracker/issues/test_cli.py | 22 --------------- tests/yandex/tracker/issues/test_client.py | 9 ------- tests/yandex/tracker/issues/test_mcp.py | 18 +------------ tests/yandex/tracker/test_mcp.py | 5 ++-- 14 files changed, 13 insertions(+), 130 deletions(-) diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 608f1d8..4416ae7 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -40,14 +40,14 @@ Notable shared pieces: `ycli.mcp` server package (`src/ycli/mcp/server.py`; its `__init__.py` stays fastmcp-free so the base install loads the CLI sub-app without the extra). Every MCP tool's verb (last `_`-segment of its name) must be in a fail-closed read-verb **allow-list** - (`get/list/count/full/search/descendants/meta` — a new read adds its verb deliberately), it + (`get/list/count/search/descendants/meta` — a new read adds its verb deliberately), it carries `readOnlyHint=True` (via the `RO` annotation), and no `mcp.py` may call a client write method (`.create/.update/.add/.execute/…`). - **ARCH-4 — Serialization confinement.** Model→output rendering happens only through `output.Serializer.serialize(...)`; `model_dump_json`, `yaml.safe_dump`, and `json.dumps` appear only in `src/ycli/output.py`. Models stay plain data (no serialize method); the - strategies live only in `output.py`. Unmodeled API dicts are wrapped in `RawMapping` - (a `RootModel[dict]` in `ycli.yandex.models`) before being passed to the Serializer. + strategies live only in `output.py`. Every rendered value is a typed pydantic model — there + is no raw-dict/`RawMapping` escape hatch. *Carve-out:* a bare `print(int)` for a scalar `count` result is fine — it is not model output and needs no Serializer wrapping. *Check:* `model_dump_json` / `yaml.safe_dump` / `json.dumps` only in `output.py`; CLI command bodies render via `Serializer.serialize`. @@ -108,7 +108,7 @@ review cover the rest): ## Resource conventions (models, naming, MCP imports) The conventions that ARCH-1..10 do not capture — `APIModel` inheritance, `XList`/`XResponse` -naming, the `_deps` import path, and the raw-accessor pattern — are documented in +naming and the `_deps` import path — are documented in [`docs/conventions/resources.md`](docs/conventions/resources.md). ## Changing an invariant diff --git a/docs/conventions/resources.md b/docs/conventions/resources.md index 9856d13..501e980 100644 --- a/docs/conventions/resources.md +++ b/docs/conventions/resources.md @@ -63,34 +63,7 @@ import-linter and IDEs resolve the canonical source correctly. The scaffold --- -## 4. Raw / full unpruned accessor (`_raw` / `full` MCP tool) - -When a resource's pruned model omits fields that callers might need, offer a companion -accessor that returns the raw `dict[str, Any]`: - -```python -# client.py -@uplink.returns.json() -@uplink.get("issues/{key}") -def get_raw(self, key: uplink.Path) -> dict: # ty: ignore[empty-body] - """GET one issue — raw dict, all fields.""" -``` - -```python -# mcp.py — exposed as a separate tool with the _full verb -@mcp.tool(name="issues_full", annotations={**RO, "title": "Get full Tracker issue (raw)"}, tags=TAGS) -def full(key: str, client: TrackerClient = Depends(tracker_client)) -> dict[str, Any]: - """A single Tracker issue as a raw dict (all fields).""" - return client.issues.get_raw(key) -``` - -Wrap the dict in `RawMapping` before passing it to `Serializer.serialize` in `cli.py` -(ARCH-4). Only add the raw accessor when the pruned model is intentionally incomplete -and users are known to need the omitted fields. - ---- - -## 5. MCP tool-metadata standard +## 4. MCP tool-metadata standard Every MCP tool MUST satisfy the following metadata contract. fastmcp auto-derives `description` from the docstring and `outputSchema` from the return type annotation — @@ -135,7 +108,7 @@ field `outputSchema`, exposed as camelCase by fastmcp 3.4.x). --- -## 6. Where these rules are enforced +## 5. Where these rules are enforced | Rule | Enforced by | |---|---| diff --git a/src/ycli/yandex/models.py b/src/ycli/yandex/models.py index 9afc68e..4c246ae 100644 --- a/src/ycli/yandex/models.py +++ b/src/ycli/yandex/models.py @@ -7,16 +7,10 @@ from __future__ import annotations -from typing import Any - -from pydantic import BaseModel, ConfigDict, RootModel +from pydantic import BaseModel, ConfigDict class APIModel(BaseModel): """Base for all Yandex API models: ignore unknown fields, allow name-or-alias population.""" model_config = ConfigDict(extra="ignore", populate_by_name=True) - - -class RawMapping(RootModel[dict[str, Any]]): - """Wraps an unmodeled API dict so it renders through the Serializer (honoring --format).""" diff --git a/src/ycli/yandex/tracker/issues/cli.py b/src/ycli/yandex/tracker/issues/cli.py index 375c9bf..518659f 100644 --- a/src/ycli/yandex/tracker/issues/cli.py +++ b/src/ycli/yandex/tracker/issues/cli.py @@ -8,7 +8,6 @@ from ycli.context import AppContext from ycli.output import Serializer -from ycli.yandex.models import RawMapping from ycli.yandex.tracker._args import KeyArg, count_body, parse_fields app = typer.Typer(name="issues", help="Tracker issues.", no_args_is_help=True) @@ -26,15 +25,6 @@ def get(ctx: typer.Context, key: KeyArg) -> None: Serializer.serialize(app_ctx.tracker.issues.get(key), app_ctx.strategy, app_ctx.console) -@app.command() -def full(ctx: typer.Context, key: KeyArg) -> None: - """Print the raw API dict for KEY (no pydantic projection).""" - app_ctx = AppContext.from_typer_context(ctx) - Serializer.serialize( - RawMapping(app_ctx.tracker.issues.get_raw(key)), app_ctx.strategy, app_ctx.console - ) - - @app.command("list") def list_( ctx: typer.Context, diff --git a/src/ycli/yandex/tracker/issues/client.py b/src/ycli/yandex/tracker/issues/client.py index c229794..fd08c59 100644 --- a/src/ycli/yandex/tracker/issues/client.py +++ b/src/ycli/yandex/tracker/issues/client.py @@ -24,20 +24,6 @@ def get(self, key: uplink.Path) -> Issue: # ty: ignore[empty-body] 'inProgress' """ - @uplink.returns.json() - @uplink.get("issues/{key}") - def get_raw(self, key: uplink.Path) -> dict: # ty: ignore[empty-body] - """``GET /issues/{key}`` → raw JSON dict (no pydantic pruning). - - Bare ``dict`` (not ``dict[str, Any]``) — uplink raises ``TypeError`` trying to - instantiate ``typing.Any`` for an empty-body method. - - Example: - >>> client = TrackerClient(oauth_token="…", organization_id="…") # doctest: +SKIP - >>> client.issues.get_raw(key="DATAENGINEERING-1")["key"] # doctest: +SKIP - 'DATAENGINEERING-1' - """ - @uplink.returns.json() @uplink.json @uplink.post("issues/_search") diff --git a/src/ycli/yandex/tracker/issues/mcp.py b/src/ycli/yandex/tracker/issues/mcp.py index a63dfe0..3d1d33e 100644 --- a/src/ycli/yandex/tracker/issues/mcp.py +++ b/src/ycli/yandex/tracker/issues/mcp.py @@ -1,7 +1,5 @@ """Tracker /issues FastMCP tools (reads-only) — Depends DI, native error handling.""" -from typing import Any - from fastmcp import FastMCP from fastmcp.dependencies import Depends @@ -28,14 +26,6 @@ def get(key: str, client: TrackerClient = Depends(tracker_client)) -> Issue: return result -@mcp.tool( - name="issues_full", annotations={**RO, "title": "Get full Tracker issue (raw)"}, tags=TAGS -) -def full(key: str, client: TrackerClient = Depends(tracker_client)) -> dict[str, Any]: - """A single Tracker issue as a raw dict (all fields).""" - return client.issues.get_raw(key) - - @mcp.tool(name="issues_list", annotations={**RO, "title": "List Tracker issues"}, tags=TAGS) def list_( queue: str = "", diff --git a/tests/snapshots/cli_tree.txt b/tests/snapshots/cli_tree.txt index 6a26847..034aabd 100644 --- a/tests/snapshots/cli_tree.txt +++ b/tests/snapshots/cli_tree.txt @@ -22,7 +22,6 @@ tracker comments list tracker issues tracker issues count tracker issues create -tracker issues full tracker issues get tracker issues list tracker issues search diff --git a/tests/snapshots/mcp_tools.txt b/tests/snapshots/mcp_tools.txt index ddf68ca..fb6cf6b 100644 --- a/tests/snapshots/mcp_tools.txt +++ b/tests/snapshots/mcp_tools.txt @@ -6,7 +6,6 @@ forms_surveys_list tracker_changelog_list tracker_comments_list tracker_issues_count -tracker_issues_full tracker_issues_get tracker_issues_list tracker_issues_search diff --git a/tests/test_architecture.py b/tests/test_architecture.py index 2db93cf..c12d352 100644 --- a/tests/test_architecture.py +++ b/tests/test_architecture.py @@ -21,7 +21,7 @@ # Allow-list (fail-closed): an MCP tool's verb MUST be a known read. A new read # operation adds its verb here deliberately; any other verb (modify/patch/post/…) # fails, so a write tool can't slip in by naming. Keep in sync with ARCHITECTURE.md. -READ_VERBS = {"get", "list", "count", "full", "search", "descendants", "meta"} +READ_VERBS = {"get", "list", "count", "search", "descendants", "meta"} # Behavioral backstop: even a read-named tool must not call a client write method. _WRITE_CALL_RE = re.compile(r"\.(create|update|add|execute|delete|remove|set)\(") diff --git a/tests/test_yandex_mcp.py b/tests/test_yandex_mcp.py index 80e0707..2d640a1 100644 --- a/tests/test_yandex_mcp.py +++ b/tests/test_yandex_mcp.py @@ -23,9 +23,9 @@ async def test_root_mounts_all_domains_with_namespaces(): assert "tracker_issues_get" in names assert "forms_surveys_get" in names assert len([n for n in names if n.startswith("wiki_")]) == 6 - assert len([n for n in names if n.startswith("tracker_")]) == 14 + assert len([n for n in names if n.startswith("tracker_")]) == 13 assert len([n for n in names if n.startswith("forms_")]) == 5 - assert len(names) == 25 + assert len(names) == 24 def test_main_is_callable(): diff --git a/tests/yandex/tracker/issues/test_cli.py b/tests/yandex/tracker/issues/test_cli.py index fdccc37..2be9e7a 100644 --- a/tests/yandex/tracker/issues/test_cli.py +++ b/tests/yandex/tracker/issues/test_cli.py @@ -33,28 +33,6 @@ def test_get_dumps_issue_model(): assert out["type"] == {"key": "task"} -@responses.activate -def test_full_renders_raw_dict_as_json(): - responses.add( - responses.GET, f"{BASE}/issues/DE-1", json={"key": "DE-1", "extra": "field"}, status=200 - ) - res = runner.invoke(cli.app, ["--format", "json", "tracker", "issues", "full", "DE-1"]) - assert res.exit_code == 0 - assert json.loads(res.stdout) == {"key": "DE-1", "extra": "field"} - - -@responses.activate -def test_full_renders_raw_dict_as_yaml(): - responses.add( - responses.GET, f"{BASE}/issues/DE-1", json={"key": "DE-1", "extra": "field"}, status=200 - ) - res = runner.invoke(cli.app, ["--format", "yaml", "tracker", "issues", "full", "DE-1"]) - assert res.exit_code == 0 - import yaml - - assert yaml.safe_load(res.stdout) == {"key": "DE-1", "extra": "field"} - - @responses.activate def test_list_builds_filter_body(): responses.add(responses.POST, f"{BASE}/issues/_search", json=[{"key": "DE-1"}], status=200) diff --git a/tests/yandex/tracker/issues/test_client.py b/tests/yandex/tracker/issues/test_client.py index ead360a..e8f76a3 100644 --- a/tests/yandex/tracker/issues/test_client.py +++ b/tests/yandex/tracker/issues/test_client.py @@ -30,15 +30,6 @@ def test_get_deserializes_issue(): assert i.key == "DE-1" and i.type_key == "task" -@responses.activate -def test_get_raw_returns_dict(): - responses.add( - responses.GET, f"{BASE}/issues/DE-1", json={"key": "DE-1", "extra": "field"}, status=200 - ) - raw = _client().get_raw("DE-1") - assert raw == {"key": "DE-1", "extra": "field"} - - @responses.activate def test_search_returns_issuelist(): responses.add( diff --git a/tests/yandex/tracker/issues/test_mcp.py b/tests/yandex/tracker/issues/test_mcp.py index 6191887..3eb8a59 100644 --- a/tests/yandex/tracker/issues/test_mcp.py +++ b/tests/yandex/tracker/issues/test_mcp.py @@ -42,9 +42,7 @@ async def test_issues_list_tool_returns_rootmodel(creds): async def test_issue_tools_registered_read_only(): async with Client(issues_mcp.mcp) as client: tools = {t.name: t for t in await client.list_tools()} - assert {"issues_get", "issues_full", "issues_list", "issues_search", "issues_count"} <= set( - tools - ) + assert {"issues_get", "issues_list", "issues_search", "issues_count"} <= set(tools) assert tools["issues_get"].annotations.readOnlyHint is True @@ -70,20 +68,6 @@ async def test_issues_get_tool_empty_response_guard(creds): await client.call_tool("issues_get", {"key": "DE-1"}) -@responses.activate -async def test_issues_full_tool_returns_raw_dict(creds): - responses.add( - responses.GET, - f"{BASE}/issues/DE-1", - json={"key": "DE-1", "summary": "S", "extra": "kept"}, - status=200, - ) - async with Client(issues_mcp.mcp) as client: - result = await client.call_tool("issues_full", {"key": "DE-1"}) - assert result.data["key"] == "DE-1" - assert result.data["extra"] == "kept" - - @responses.activate async def test_issues_search_tool(creds): responses.add(responses.POST, f"{BASE}/issues/_search", json=[{"key": "DE-1"}], status=200) diff --git a/tests/yandex/tracker/test_mcp.py b/tests/yandex/tracker/test_mcp.py index 850d3a8..5eeab49 100644 --- a/tests/yandex/tracker/test_mcp.py +++ b/tests/yandex/tracker/test_mcp.py @@ -1,4 +1,4 @@ -"""Tracker FastMCP domain server — 14 reads-only tools, namespaced _.""" +"""Tracker FastMCP domain server — 13 reads-only tools, namespaced _.""" import pytest import responses @@ -15,13 +15,12 @@ def creds(monkeypatch): monkeypatch.setenv("YANDEX_ID_ORGANIZATION_ID", "o") -async def test_all_fourteen_read_tools_registered(): +async def test_all_thirteen_read_tools_registered(): async with Client(tracker_mcp.mcp) as client: names = {t.name for t in await client.list_tools()} assert names == { "me_get", "issues_get", - "issues_full", "issues_list", "issues_search", "issues_count", From 2f4570122bdb64f19ea23991209221b1c7605b95 Mon Sep 17 00:00:00 2001 From: Sava Znatnov Date: Mon, 29 Jun 2026 13:13:58 +0300 Subject: [PATCH 05/25] feat: status package with native me + read-only status_get MCP tool MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Explodes yandex/status.py into a package; drops ServiceProbe and the per-service identity lambdas — each ServiceAuthStatus now carries the bare native me model. Adds the status_get MCP tool (namespace status, read-only). ARCH-1 carve-out note. Co-Authored-By: Claude Opus 4.8 --- ARCHITECTURE.md | 3 + src/ycli/mcp/server.py | 2 + src/ycli/yandex/status.py | 91 ------------------------------ src/ycli/yandex/status/__init__.py | 9 +++ src/ycli/yandex/status/cli.py | 48 ++++++++++++++++ src/ycli/yandex/status/mcp.py | 32 +++++++++++ src/ycli/yandex/status/models.py | 33 +++++++++++ src/ycli/yandex/status/reporter.py | 47 +++++++++++++++ tests/snapshots/mcp_tools.txt | 1 + tests/test_yandex_mcp.py | 4 +- tests/yandex/status/__init__.py | 0 tests/yandex/status/test_mcp.py | 49 ++++++++++++++++ 12 files changed, 227 insertions(+), 92 deletions(-) delete mode 100644 src/ycli/yandex/status.py create mode 100644 src/ycli/yandex/status/__init__.py create mode 100644 src/ycli/yandex/status/cli.py create mode 100644 src/ycli/yandex/status/mcp.py create mode 100644 src/ycli/yandex/status/models.py create mode 100644 src/ycli/yandex/status/reporter.py create mode 100644 tests/yandex/status/__init__.py create mode 100644 tests/yandex/status/test_mcp.py diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 4416ae7..da62400 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -34,6 +34,9 @@ Notable shared pieces: - **ARCH-1 — Four-surface symmetry.** Every `yandex///` directory contains `__init__.py`, `client.py`, `cli.py`, `mcp.py`, `models.py`. Use `/new-endpoint` to scaffold. + *Carve-out:* `yandex/status/` and the `ycli/mcp/` server package are cross-cutting surfaces, + not `/` dirs — the four-surface rule and the `_resource_dirs()` check + (which scans only `tracker/wiki/forms`) do not apply to them. - **ARCH-2 — HTTP confinement.** `cli.py`, `mcp.py`, and `models.py` never import `requests` or `uplink`. All HTTP lives in `client.py` / `base.py` / `transport.py`. - **ARCH-3 — MCP is read-only.** `fastmcp` is imported only in modules named `mcp.py` and in the diff --git a/src/ycli/mcp/server.py b/src/ycli/mcp/server.py index e157839..942deb3 100644 --- a/src/ycli/mcp/server.py +++ b/src/ycli/mcp/server.py @@ -9,6 +9,7 @@ from ycli.log import configure from ycli.settings import AppConfig from ycli.yandex.forms.mcp import mcp as forms_mcp +from ycli.yandex.status.mcp import mcp as status_mcp from ycli.yandex.tracker.mcp import mcp as tracker_mcp from ycli.yandex.wiki.mcp import mcp as wiki_mcp @@ -25,6 +26,7 @@ mcp.mount(wiki_mcp, namespace="wiki") mcp.mount(tracker_mcp, namespace="tracker") mcp.mount(forms_mcp, namespace="forms") +mcp.mount(status_mcp, namespace="status") def main() -> None: diff --git a/src/ycli/yandex/status.py b/src/ycli/yandex/status.py deleted file mode 100644 index 908be98..0000000 --- a/src/ycli/yandex/status.py +++ /dev/null @@ -1,91 +0,0 @@ -"""`ycli auth status` — validate credentials against each service's identity endpoint.""" - -from __future__ import annotations - -from typing import TYPE_CHECKING, Any - -import typer - -if TYPE_CHECKING: - from collections.abc import Callable -from pydantic import Field, ValidationError - -from ycli.context import AppContext -from ycli.output import Serializer -from ycli.settings import AppConfig, Credentials -from ycli.yandex.errors import YandexAuthError, YandexError -from ycli.yandex.factory import ClientFactory -from ycli.yandex.forms.client import FormsClient -from ycli.yandex.models import APIModel -from ycli.yandex.tracker.client import TrackerClient -from ycli.yandex.wiki.client import WikiClient - -app = typer.Typer(name="auth", help="Inspect Yandex 360 credentials.", no_args_is_help=True) - - -class ServiceAuthStatus(APIModel): - service: str - valid: bool = False - identity: str | None = None - detail: str = "" - - -class AuthReport(APIModel): - configured: bool - organization_id: str = "" - services: list[ServiceAuthStatus] = Field(default_factory=list) - - -class ServiceProbe: - """One service's identity check — name, client class, and identity extractor together.""" - - def __init__( - self, name: str, client_cls: type, identity_of: Callable[[Any], str | None] - ) -> None: - self._name, self._client_cls, self._identity_of = name, client_cls, identity_of - - def run(self, credentials: Credentials) -> ServiceAuthStatus: - client = ClientFactory.build(self._client_cls, credentials, AppConfig()) - try: - me = client.me.get() # ty: ignore[unresolved-attribute] - except YandexAuthError: - return ServiceAuthStatus( - service=self._name, valid=False, detail="token invalid or expired" - ) - except YandexError as exc: - return ServiceAuthStatus(service=self._name, valid=False, detail=str(exc)) - return ServiceAuthStatus(service=self._name, valid=True, identity=self._identity_of(me)) - - -PROBES: list[ServiceProbe] = [ - ServiceProbe("tracker", TrackerClient, lambda me: me.login), - ServiceProbe("wiki", WikiClient, lambda me: me.username), - ServiceProbe("forms", FormsClient, lambda me: me.email), -] - - -@app.command() -def status(ctx: typer.Context) -> None: - """Report whether the env credentials are set and actually work, per service.""" - app_ctx = AppContext.from_typer_context(ctx) - env_names = { - "oauth_token": "YANDEX_ID_OAUTH_TOKEN", - "organization_id": "YANDEX_ID_ORGANIZATION_ID", - } - try: - credentials = Credentials() # ty: ignore[missing-argument] - except ValidationError as exc: - missing = ", ".join(env_names.get(str(e["loc"][0]), str(e["loc"][0])) for e in exc.errors()) - typer.secho(f"not configured — missing {missing}", fg=typer.colors.RED, err=True) - Serializer.serialize( - AuthReport(configured=False, services=[]), app_ctx.strategy, app_ctx.console - ) - raise typer.Exit(1) from None - - services = [p.run(credentials) for p in PROBES] - report = AuthReport( - configured=True, organization_id=credentials.organization_id, services=services - ) - Serializer.serialize(report, app_ctx.strategy, app_ctx.console) - if not all(s.valid for s in services): - raise typer.Exit(1) diff --git a/src/ycli/yandex/status/__init__.py b/src/ycli/yandex/status/__init__.py new file mode 100644 index 0000000..40f90dd --- /dev/null +++ b/src/ycli/yandex/status/__init__.py @@ -0,0 +1,9 @@ +"""Cross-cutting auth-status surface — the `auth status` CLI plus the `status_get` MCP tool. + +Not a `/` package (ARCH-1 four-surface symmetry does not apply): it +aggregates the three domains' `me` probes into one report. +""" + +from ycli.yandex.status.cli import app + +__all__ = ["app"] diff --git a/src/ycli/yandex/status/cli.py b/src/ycli/yandex/status/cli.py new file mode 100644 index 0000000..9c37976 --- /dev/null +++ b/src/ycli/yandex/status/cli.py @@ -0,0 +1,48 @@ +"""`ycli auth status` — validate credentials against each service's identity endpoint.""" + +from __future__ import annotations + +import typer +from pydantic import ValidationError + +from ycli.context import AppContext +from ycli.output import Serializer +from ycli.settings import Credentials +from ycli.yandex.status.models import AuthReport +from ycli.yandex.status.reporter import StatusReporter + +app = typer.Typer(name="auth", help="Inspect Yandex 360 credentials.", no_args_is_help=True) + +_ENV_NAMES = { + "oauth_token": "YANDEX_ID_OAUTH_TOKEN", + "organization_id": "YANDEX_ID_ORGANIZATION_ID", +} + + +@app.command() +def status(ctx: typer.Context) -> None: + """Report whether the env credentials are set and actually work, per service.""" + app_ctx = AppContext.from_typer_context(ctx) + try: + credentials = Credentials() # ty: ignore[missing-argument] + except ValidationError as exc: + missing = ", ".join( + _ENV_NAMES.get(str(e["loc"][0]), str(e["loc"][0])) for e in exc.errors() + ) + typer.secho(f"not configured — missing {missing}", fg=typer.colors.RED, err=True) + Serializer.serialize( + AuthReport(configured=False, services=[]), app_ctx.strategy, app_ctx.console + ) + raise typer.Exit(1) from None + + me_clients = { + "tracker": app_ctx.tracker.me, + "wiki": app_ctx.wiki.me, + "forms": app_ctx.forms.me, + } + report = StatusReporter(me_clients).report( + configured=True, organization_id=credentials.organization_id + ) + Serializer.serialize(report, app_ctx.strategy, app_ctx.console) + if not all(s.valid for s in report.services): + raise typer.Exit(1) diff --git a/src/ycli/yandex/status/mcp.py b/src/ycli/yandex/status/mcp.py new file mode 100644 index 0000000..545050f --- /dev/null +++ b/src/ycli/yandex/status/mcp.py @@ -0,0 +1,32 @@ +"""Status FastMCP tool (read-only) — aggregate auth probe across all three services.""" + +from fastmcp import FastMCP +from fastmcp.dependencies import Depends + +from ycli.yandex._mcp import RO +from ycli.yandex.forms._deps import forms_client +from ycli.yandex.forms.client import FormsClient +from ycli.yandex.status.models import AuthReport +from ycli.yandex.status.reporter import StatusReporter +from ycli.yandex.tracker._deps import tracker_client +from ycli.yandex.tracker.client import TrackerClient +from ycli.yandex.wiki._deps import wiki_client +from ycli.yandex.wiki.client import WikiClient + +mcp = FastMCP("status") +TAGS: set[str] = {"status"} + + +@mcp.tool(name="get", annotations={**RO, "title": "Check Yandex 360 auth status"}, tags=TAGS) +def get( + tracker: TrackerClient = Depends(tracker_client), + wiki: WikiClient = Depends(wiki_client), + forms: FormsClient = Depends(forms_client), +) -> AuthReport: + """Probe each service's identity endpoint; report which credentials work. + + ``organization_id`` is left blank here — the per-service ``me`` already identifies the + authenticated user; the CLI ``auth status`` carries the org id. + """ + me_clients = {"tracker": tracker.me, "wiki": wiki.me, "forms": forms.me} + return StatusReporter(me_clients).report(configured=True, organization_id="") diff --git a/src/ycli/yandex/status/models.py b/src/ycli/yandex/status/models.py new file mode 100644 index 0000000..a4baa43 --- /dev/null +++ b/src/ycli/yandex/status/models.py @@ -0,0 +1,33 @@ +"""Models for `ycli auth status` and the `status_get` MCP tool.""" + +from __future__ import annotations + +from pydantic import Field + +from ycli.yandex.forms.me.models import ( + User as FormsMe, # noqa: TC001 # pydantic resolves field types via get_type_hints() at runtime +) +from ycli.yandex.models import APIModel +from ycli.yandex.tracker.me.models import ( + Me as TrackerMe, # noqa: TC001 # pydantic resolves field types via get_type_hints() at runtime +) +from ycli.yandex.wiki.me.models import ( + Me as WikiMe, # noqa: TC001 # pydantic resolves field types via get_type_hints() at runtime +) + + +class ServiceAuthStatus(APIModel): + """One service's auth probe — the bare native `me` on success, else why it failed.""" + + service: str + valid: bool = False + me: TrackerMe | WikiMe | FormsMe | None = None + detail: str = "" + + +class AuthReport(APIModel): + """Whether the env credentials are set and work, per service.""" + + configured: bool + organization_id: str = "" + services: list[ServiceAuthStatus] = Field(default_factory=list) diff --git a/src/ycli/yandex/status/reporter.py b/src/ycli/yandex/status/reporter.py new file mode 100644 index 0000000..d463ad9 --- /dev/null +++ b/src/ycli/yandex/status/reporter.py @@ -0,0 +1,47 @@ +"""Probe each service's identity endpoint and assemble an AuthReport (shared by CLI + MCP).""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Protocol + +from ycli.yandex.errors import YandexAuthError, YandexError +from ycli.yandex.forms.me.models import ( + User as FormsMe, # noqa: TC001 # pydantic resolves field types via get_type_hints() at runtime +) +from ycli.yandex.status.models import AuthReport, ServiceAuthStatus +from ycli.yandex.tracker.me.models import ( + Me as TrackerMe, # noqa: TC001 # pydantic resolves field types via get_type_hints() at runtime +) +from ycli.yandex.wiki.me.models import ( + Me as WikiMe, # noqa: TC001 # pydantic resolves field types via get_type_hints() at runtime +) + +if TYPE_CHECKING: + from collections.abc import Mapping + + +class MeProbe(Protocol): + """Structural type for a domain `me` client: a zero-arg `get()` returning an API model.""" + + def get(self) -> TrackerMe | WikiMe | FormsMe: ... + + +class StatusReporter: + """Given each service's `me` client, probe identity and build a per-service AuthReport.""" + + def __init__(self, me_clients: Mapping[str, MeProbe]) -> None: + self._me_clients = me_clients + + def report(self, *, configured: bool, organization_id: str) -> AuthReport: + services = [self._probe(name, client) for name, client in self._me_clients.items()] + return AuthReport(configured=configured, organization_id=organization_id, services=services) + + @staticmethod + def _probe(name: str, me_client: MeProbe) -> ServiceAuthStatus: + try: + me = me_client.get() + except YandexAuthError: + return ServiceAuthStatus(service=name, valid=False, detail="token invalid or expired") + except YandexError as exc: + return ServiceAuthStatus(service=name, valid=False, detail=str(exc)) + return ServiceAuthStatus(service=name, valid=True, me=me) diff --git a/tests/snapshots/mcp_tools.txt b/tests/snapshots/mcp_tools.txt index fb6cf6b..8fb75ce 100644 --- a/tests/snapshots/mcp_tools.txt +++ b/tests/snapshots/mcp_tools.txt @@ -3,6 +3,7 @@ forms_me_get forms_questions_list forms_surveys_get forms_surveys_list +status_get tracker_changelog_list tracker_comments_list tracker_issues_count diff --git a/tests/test_yandex_mcp.py b/tests/test_yandex_mcp.py index 2d640a1..399b6c0 100644 --- a/tests/test_yandex_mcp.py +++ b/tests/test_yandex_mcp.py @@ -22,10 +22,12 @@ async def test_root_mounts_all_domains_with_namespaces(): assert "wiki_pages_get" in names assert "tracker_issues_get" in names assert "forms_surveys_get" in names + assert "status_get" in names assert len([n for n in names if n.startswith("wiki_")]) == 6 assert len([n for n in names if n.startswith("tracker_")]) == 13 assert len([n for n in names if n.startswith("forms_")]) == 5 - assert len(names) == 24 + assert len([n for n in names if n.startswith("status_")]) == 1 + assert len(names) == 25 def test_main_is_callable(): diff --git a/tests/yandex/status/__init__.py b/tests/yandex/status/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/yandex/status/test_mcp.py b/tests/yandex/status/test_mcp.py new file mode 100644 index 0000000..7c25d73 --- /dev/null +++ b/tests/yandex/status/test_mcp.py @@ -0,0 +1,49 @@ +"""status_get MCP tool — aggregates the three /me probes into one read-only report.""" + +import pytest +import responses +from fastmcp import Client + +from ycli.yandex.status import mcp as status_mcp + +TRACKER_ME = "https://api.tracker.yandex.net/v3/myself" +FORMS_ME = "https://api.forms.yandex.net/v1/users/me" +WIKI_ME = "https://api.wiki.yandex.net/v1/users/me" + + +@pytest.fixture +def creds(monkeypatch): + monkeypatch.setenv("YANDEX_ID_OAUTH_TOKEN", "t") + monkeypatch.setenv("YANDEX_ID_ORGANIZATION_ID", "o") + + +@responses.activate +async def test_status_get_reports_all_valid(creds): + responses.add(responses.GET, TRACKER_ME, json={"login": "alice"}, status=200) + responses.add(responses.GET, WIKI_ME, json={"username": "alice"}, status=200) + responses.add(responses.GET, FORMS_ME, json={"id": 1, "email": "alice@x"}, status=200) + async with Client(status_mcp.mcp) as client: + result = await client.call_tool("get", {}) + services = {s.service: s for s in result.data.services} + assert services["tracker"].valid is True + assert services["tracker"].me.login == "alice" + assert services["forms"].me.email == "alice@x" + + +@responses.activate +async def test_status_get_marks_invalid_on_401(creds): + responses.add(responses.GET, TRACKER_ME, status=401) + responses.add(responses.GET, WIKI_ME, json={"username": "alice"}, status=200) + responses.add(responses.GET, FORMS_ME, json={"id": 1, "email": "alice@x"}, status=200) + async with Client(status_mcp.mcp) as client: + result = await client.call_tool("get", {}) + services = {s.service: s for s in result.data.services} + assert services["tracker"].valid is False + assert services["tracker"].detail == "token invalid or expired" + + +async def test_status_get_is_read_only(): + async with Client(status_mcp.mcp) as client: + tools = {t.name: t for t in await client.list_tools()} + assert "get" in tools + assert tools["get"].annotations.readOnlyHint is True From 1b9bae0397765a94cf536725f6c1d710e504002e Mon Sep 17 00:00:00 2001 From: Sava Znatnov Date: Mon, 29 Jun 2026 13:22:06 +0300 Subject: [PATCH 06/25] refactor: type pagination strategies with PEP 695 generics Strategies are generic over page type P and item T; collect returns list[T]. Folds the free collect_single_page into SinglePageStrategy.collect_wrapped. Cursor/url termination uses 'is None' to match the null-cursor API contract. Co-Authored-By: Claude Opus 4.8 --- src/ycli/yandex/forms/surveys/client.py | 4 +- src/ycli/yandex/pagination.py | 68 ++++++++++++---------- src/ycli/yandex/wiki/attachments/client.py | 4 +- src/ycli/yandex/wiki/comments/client.py | 4 +- tests/yandex/test_pagination.py | 23 +++++++- 5 files changed, 63 insertions(+), 40 deletions(-) diff --git a/src/ycli/yandex/forms/surveys/client.py b/src/ycli/yandex/forms/surveys/client.py index 5d41e31..30aacfd 100644 --- a/src/ycli/yandex/forms/surveys/client.py +++ b/src/ycli/yandex/forms/surveys/client.py @@ -7,7 +7,7 @@ from ycli.yandex.forms._base import FormsResource from ycli.yandex.forms.surveys.models import Survey, SurveyList, SurveysResponse -from ycli.yandex.pagination import collect_single_page +from ycli.yandex.pagination import SinglePageStrategy class SurveysClient(FormsResource): @@ -26,7 +26,7 @@ def list(self, *, limit: int | None = None) -> SurveyList: >>> client.surveys.list().root[0].name # doctest: +SKIP 'Новая задача' """ - return collect_single_page( + return SinglePageStrategy.collect_wrapped( lambda cursor: self._list_page(), extract=lambda page: page.result, wrap=SurveyList, diff --git a/src/ycli/yandex/pagination.py b/src/ycli/yandex/pagination.py index fce6353..099fa32 100644 --- a/src/ycli/yandex/pagination.py +++ b/src/ycli/yandex/pagination.py @@ -3,70 +3,88 @@ Each strategy owns ONE cursor mechanic and accepts injected page-access callables, so the public client method never exposes a cursor: it picks a strategy, says how to read a page, and gets back a list capped at ``limit`` (``None`` = uncapped). Pure — no HTTP here. + +Generic over the page type ``P`` (whatever ``fetch_page`` returns — a pydantic model in +production, a plain ``dict`` in tests) and the item type ``T``. The injected callables do +all structural access, so no page Protocol is imposed. """ from __future__ import annotations from abc import ABC, abstractmethod -from typing import TYPE_CHECKING, Any +from typing import TYPE_CHECKING if TYPE_CHECKING: from collections.abc import Callable -class PaginationStrategy(ABC): +class PaginationStrategy[P, T](ABC): @abstractmethod - def collect(self, fetch_page: Callable[[Any], Any], limit: int | None) -> list: + def collect(self, fetch_page: Callable[[str | None], P], limit: int | None) -> list[T]: """Accumulate items by driving ``fetch_page`` until exhausted or ``limit`` reached.""" -class SinglePageStrategy(PaginationStrategy): - def __init__(self, *, extract: Callable[[Any], list]) -> None: +class SinglePageStrategy[P, T](PaginationStrategy[P, T]): + def __init__(self, *, extract: Callable[[P], list[T]]) -> None: self._extract = extract - def collect(self, fetch_page: Callable[[Any], Any], limit: int | None) -> list: + def collect(self, fetch_page: Callable[[str | None], P], limit: int | None) -> list[T]: items = list(self._extract(fetch_page(None))) return items if limit is None else items[:limit] + @classmethod + def collect_wrapped[R]( + cls, + page_fn: Callable[[str | None], P], + *, + extract: Callable[[P], list[T]], + wrap: Callable[[list[T]], R], + limit: int | None = None, + ) -> R: + """Single-page envelope -> bounded, wrapped flat collection (the wiki/forms list shape).""" + return wrap(cls(extract=extract).collect(page_fn, limit)) + -class CursorStrategy(PaginationStrategy): - def __init__(self, *, extract: Callable[[Any], list], next_of: Callable[[Any], Any]) -> None: +class CursorStrategy[P, T](PaginationStrategy[P, T]): + def __init__( + self, *, extract: Callable[[P], list[T]], next_of: Callable[[P], str | None] + ) -> None: self._extract = extract self._next_of = next_of - def collect(self, fetch_page: Callable[[Any], Any], limit: int | None) -> list: - items: list = [] - cursor: Any = None + def collect(self, fetch_page: Callable[[str | None], P], limit: int | None) -> list[T]: + items: list[T] = [] + cursor: str | None = None while True: page = fetch_page(cursor) items.extend(self._extract(page)) if limit is not None and len(items) >= limit: return items[:limit] cursor = self._next_of(page) - if not cursor: + if cursor is None: return items -class NextUrlStrategy(PaginationStrategy): +class NextUrlStrategy[P, T](PaginationStrategy[P, T]): """HATEOAS: the first page comes from ``fetch_page``; subsequent ones from ``fetch_url``.""" def __init__( self, *, - extract: Callable[[Any], list], - next_url_of: Callable[[Any], Any], - fetch_url: Callable[[str], Any], + extract: Callable[[P], list[T]], + next_url_of: Callable[[P], str | None], + fetch_url: Callable[[str], P], ) -> None: self._extract = extract self._next_url_of = next_url_of self._fetch_url = fetch_url - def collect(self, fetch_page: Callable[[Any], Any], limit: int | None) -> list: + def collect(self, fetch_page: Callable[[str | None], P], limit: int | None) -> list[T]: page = fetch_page(None) - items: list = list(self._extract(page)) + items: list[T] = list(self._extract(page)) seen: set[str] = set() url = self._next_url_of(page) - while url and url not in seen: + while url is not None and url not in seen: if limit is not None and len(items) >= limit: break seen.add(url) @@ -74,15 +92,3 @@ def collect(self, fetch_page: Callable[[Any], Any], limit: int | None) -> list: items.extend(self._extract(page)) url = self._next_url_of(page) return items if limit is None else items[:limit] - - -def collect_single_page( - page_fn: Callable[[Any], Any], - *, - extract: Callable[[Any], list], - wrap: Callable[[list], Any], - limit: int | None = None, -) -> Any: - """Single-page envelope -> bounded, wrapped flat collection (the wiki/forms list shape).""" - items = SinglePageStrategy(extract=extract).collect(page_fn, limit) - return wrap(items) diff --git a/src/ycli/yandex/wiki/attachments/client.py b/src/ycli/yandex/wiki/attachments/client.py index 70c6f95..c4fd08e 100644 --- a/src/ycli/yandex/wiki/attachments/client.py +++ b/src/ycli/yandex/wiki/attachments/client.py @@ -6,7 +6,7 @@ import uplink -from ycli.yandex.pagination import collect_single_page +from ycli.yandex.pagination import SinglePageStrategy from ycli.yandex.wiki._base import WikiResource from ycli.yandex.wiki.attachments.models import AttachmentList, AttachmentsResponse @@ -31,7 +31,7 @@ def list(self, page_id: int, *, limit: int | None = None) -> AttachmentList: >>> client.attachments.list(12345).root[0].name # doctest: +SKIP 'diagram.png' """ - return collect_single_page( + return SinglePageStrategy.collect_wrapped( lambda cursor: self._list_page(page_id, page_size=100), extract=lambda page: page.results, wrap=AttachmentList, diff --git a/src/ycli/yandex/wiki/comments/client.py b/src/ycli/yandex/wiki/comments/client.py index cba355c..56e9d32 100644 --- a/src/ycli/yandex/wiki/comments/client.py +++ b/src/ycli/yandex/wiki/comments/client.py @@ -6,7 +6,7 @@ import uplink -from ycli.yandex.pagination import collect_single_page +from ycli.yandex.pagination import SinglePageStrategy from ycli.yandex.wiki._base import WikiResource from ycli.yandex.wiki.comments.models import CommentList, CommentsResponse @@ -31,7 +31,7 @@ def list(self, page_id: int, *, limit: int | None = None) -> CommentList: >>> client.comments.list(12345).root[0].author_display # doctest: +SKIP 'Сава Знатнов' """ - return collect_single_page( + return SinglePageStrategy.collect_wrapped( lambda cursor: self._list_page(page_id, page_size=100), extract=lambda page: page.results, wrap=CommentList, diff --git a/tests/yandex/test_pagination.py b/tests/yandex/test_pagination.py index fd13105..bc3e0e5 100644 --- a/tests/yandex/test_pagination.py +++ b/tests/yandex/test_pagination.py @@ -2,7 +2,6 @@ CursorStrategy, NextUrlStrategy, SinglePageStrategy, - collect_single_page, ) @@ -39,6 +38,22 @@ def test_cursor_strategy_respects_limit(): assert out == [1, 2, 3] # stops without fetching c1 +def test_cursor_strategy_empty_string_cursor_is_not_terminal(): + """Only ``None`` terminates: an empty-string cursor is a real cursor, fetched onward. + + Locks the deliberate ``if cursor is None`` contract (vs the old falsy ``if not cursor``, + which would have stopped at the empty string) against a future regression. + """ + pages = { + None: {"results": [1], "next_cursor": ""}, + "": {"results": [2], "next_cursor": None}, + } + out = CursorStrategy( + extract=lambda p: p["results"], next_of=lambda p: p["next_cursor"] + ).collect(lambda cursor: pages[cursor], limit=None) + assert out == [1, 2] # "" is followed, not treated as exhausted + + def test_next_url_strategy_drains_and_dedupes_self_loops(): pages = { "start": {"answers": [1], "next": {"next_url": "p2"}}, @@ -52,9 +67,11 @@ def test_next_url_strategy_drains_and_dedupes_self_loops(): assert out == [1, 2] -def test_collect_single_page_extracts_wraps_and_bounds(): +def test_single_page_collect_wrapped_extracts_wraps_and_bounds(): pages = {"a": [1, 2, 3]} - out = collect_single_page(lambda cursor: pages, extract=lambda p: p["a"], wrap=list, limit=2) + out = SinglePageStrategy.collect_wrapped( + lambda cursor: pages, extract=lambda p: p["a"], wrap=list, limit=2 + ) assert out == [1, 2] From 3bd6601e78c06f5f376c0866eaae9631ee84077c Mon Sep 17 00:00:00 2001 From: Sava Znatnov Date: Mon, 29 Jun 2026 13:26:01 +0300 Subject: [PATCH 07/25] docs: add module docstrings to the four empty __init__.py files Co-Authored-By: Claude Opus 4.8 --- src/ycli/yandex/__init__.py | 1 + src/ycli/yandex/wiki/attachments/__init__.py | 1 + src/ycli/yandex/wiki/comments/__init__.py | 1 + src/ycli/yandex/wiki/pages/__init__.py | 1 + 4 files changed, 4 insertions(+) diff --git a/src/ycli/yandex/__init__.py b/src/ycli/yandex/__init__.py index e69de29..92921d5 100644 --- a/src/ycli/yandex/__init__.py +++ b/src/ycli/yandex/__init__.py @@ -0,0 +1 @@ +"""Yandex 360 SDK — per-domain clients (tracker, wiki, forms) plus shared model/MCP bases.""" diff --git a/src/ycli/yandex/wiki/attachments/__init__.py b/src/ycli/yandex/wiki/attachments/__init__.py index e69de29..562803e 100644 --- a/src/ycli/yandex/wiki/attachments/__init__.py +++ b/src/ycli/yandex/wiki/attachments/__init__.py @@ -0,0 +1 @@ +"""Wiki /pages/{id}/attachments resource package.""" diff --git a/src/ycli/yandex/wiki/comments/__init__.py b/src/ycli/yandex/wiki/comments/__init__.py index e69de29..577af76 100644 --- a/src/ycli/yandex/wiki/comments/__init__.py +++ b/src/ycli/yandex/wiki/comments/__init__.py @@ -0,0 +1 @@ +"""Wiki /pages/{id}/comments resource package.""" diff --git a/src/ycli/yandex/wiki/pages/__init__.py b/src/ycli/yandex/wiki/pages/__init__.py index e69de29..f368a2a 100644 --- a/src/ycli/yandex/wiki/pages/__init__.py +++ b/src/ycli/yandex/wiki/pages/__init__.py @@ -0,0 +1 @@ +"""Wiki /pages resource package.""" From 939eeb13ac59855d5916f76ec8f45a6e80b6ff85 Mon Sep 17 00:00:00 2001 From: Sava Znatnov Date: Mon, 29 Jun 2026 13:30:34 +0300 Subject: [PATCH 08/25] build: render demo output from committed fixtures, not hand-typed text docs/demo/render.py runs the real ycli in-process against committed JSON fixtures via responses (deterministic, leak-free, offline); the demo's MCP tool list now comes from the real 'ycli mcp methods' instead of a baked, drift-prone list. Co-Authored-By: Claude Opus 4.8 --- docs/demo/bin/ycli | 35 ++++--------- docs/demo/demo.tape | 18 ++++--- docs/demo/fixtures/tracker-issue.json | 7 +++ docs/demo/fixtures/wiki-page.json | 6 +++ docs/demo/render.py | 72 +++++++++++++++++++++++++++ tests/test_demo_render.py | 33 ++++++++++++ 6 files changed, 139 insertions(+), 32 deletions(-) create mode 100644 docs/demo/fixtures/tracker-issue.json create mode 100644 docs/demo/fixtures/wiki-page.json create mode 100644 docs/demo/render.py create mode 100644 tests/test_demo_render.py diff --git a/docs/demo/bin/ycli b/docs/demo/bin/ycli index 8788ade..a9576df 100755 --- a/docs/demo/bin/ycli +++ b/docs/demo/bin/ycli @@ -1,31 +1,18 @@ #!/usr/bin/env bash -# Demo shim used ONLY by docs/demo/demo.tape. Real `--help` output (no creds, -# no network); baked safe sample data for the data commands. Keeps the recorded -# GIF reproducible and leak-free. Not installed; not on a user's PATH. +# Demo shim used ONLY by docs/demo/demo.tape. Real `--help` and a real `mcp methods` +# tool list; the data commands render committed fixtures through the REAL ycli via +# docs/demo/render.py (no network, no credentials). Keeps the GIF reproducible and +# leak-free. Not installed; not on a user's PATH. +# +# Note: the `mcp methods` branch requires the mcp extra at regeneration time. +# Regenerate the GIF with: uv run --extra mcp vhs docs/demo/demo.tape case "$*" in "--help"|"") exec uv run ycli --help ;; - "tracker issues get TRACKER-1") - cat <<'OUT' -TRACKER-1 · Set up project scaffolding -status: In Progress assignee: alice -priority: Normal updated: 2026-06-20 -OUT - ;; - "wiki pages get onboarding") - cat <<'OUT' -onboarding · Team Onboarding Guide -author: bob revision: 7 children: 4 -OUT - ;; - "mcp start") - cat <<'OUT' -Starting MCP server on stdio … -Tools: tracker_issues_get, tracker_issues_list, tracker_issues_search, - wiki_pages_get, wiki_pages_descendants, wiki_pages_meta, - forms_surveys_list, forms_answers_list -OUT - ;; + "tracker issues get TRACKER-1"|"wiki pages get onboarding") + exec uv run python docs/demo/render.py "$@" ;; + "mcp methods") + exec uv run --extra mcp ycli mcp methods ;; *) exec uv run ycli "$@" ;; esac diff --git a/docs/demo/demo.tape b/docs/demo/demo.tape index 6dba5d7..d43efb6 100644 --- a/docs/demo/demo.tape +++ b/docs/demo/demo.tape @@ -1,19 +1,21 @@ # docs/demo/demo.tape — reproducible source for docs/assets/demo.gif # # Regenerate the GIF: -# vhs docs/demo/demo.tape +# uv run --extra mcp vhs docs/demo/demo.tape # Requires: vhs + ttyd + ffmpeg on PATH (see CONTRIBUTING / README). +# The --extra mcp flag is needed for the `mcp methods` step. # -# The recording runs the REAL `ycli --help` and leak-free baked sample data via -# the shims in docs/demo/bin (no network, no credentials). The shims are put -# first on PATH inside a Hide block so the demo types plain `ycli ...` commands. +# The recording runs the REAL `ycli --help`, renders committed JSON fixtures +# via docs/demo/render.py for the two data commands (no network, no credentials), +# and shows the real `ycli mcp methods` tool list. The shims in docs/demo/bin put +# the real ycli first on PATH inside a Hide block so the demo types plain `ycli ...`. Output docs/assets/demo.gif Set Shell bash Set FontSize 17 Set Width 960 -Set Height 720 +Set Height 900 Set Padding 24 Set TypingSpeed 55ms Set Theme { "name": "Catppuccin Mocha", "background": "#1e1e2e", "foreground": "#cdd6f4", "cursor": "#f5e0dc", "selection": "#585b70", "black": "#45475a", "brightBlack": "#585b70", "red": "#f38ba8", "brightRed": "#f38ba8", "green": "#a6e3a1", "brightGreen": "#a6e3a1", "yellow": "#f9e2af", "brightYellow": "#f9e2af", "blue": "#89b4fa", "brightBlue": "#89b4fa", "magenta": "#cba6f7", "brightMagenta": "#cba6f7", "cyan": "#94e2d5", "brightCyan": "#94e2d5", "white": "#bac2de", "brightWhite": "#a6adc8" } @@ -29,13 +31,13 @@ Show Type "ycli --help" Sleep 500ms Enter Sleep 2.5s -# Baked, leak-free sample data. +# Fixture-rendered data (committed JSON via render.py — deterministic, offline). Type "ycli tracker issues get TRACKER-1" Sleep 500ms Enter Sleep 2s Type "ycli wiki pages get onboarding" Sleep 500ms Enter Sleep 2s -# Read-only MCP server banner with real tool names. -Type "ycli mcp start" Sleep 500ms Enter +# Real read-only MCP tool list (no creds, no network). +Type "ycli mcp methods" Sleep 500ms Enter Sleep 3s diff --git a/docs/demo/fixtures/tracker-issue.json b/docs/demo/fixtures/tracker-issue.json new file mode 100644 index 0000000..17aeb0c --- /dev/null +++ b/docs/demo/fixtures/tracker-issue.json @@ -0,0 +1,7 @@ +{ + "key": "TRACKER-1", + "summary": "Set up project scaffolding", + "status": {"key": "inProgress", "display": "In Progress"}, + "assignee": {"display": "Alice"}, + "priority": {"key": "normal", "display": "Normal"} +} diff --git a/docs/demo/fixtures/wiki-page.json b/docs/demo/fixtures/wiki-page.json new file mode 100644 index 0000000..0974f41 --- /dev/null +++ b/docs/demo/fixtures/wiki-page.json @@ -0,0 +1,6 @@ +{ + "id": 1, + "slug": "onboarding", + "title": "Team Onboarding Guide", + "content": "# Team onboarding\n\nWelcome to the team!" +} diff --git a/docs/demo/render.py b/docs/demo/render.py new file mode 100644 index 0000000..c293ebe --- /dev/null +++ b/docs/demo/render.py @@ -0,0 +1,72 @@ +"""Render real `ycli` CLI output from a committed fixture — the demo's leak-free data source. + +Used only by docs/demo/bin/ycli (the vhs shim). Stubs the matching API endpoint with +`responses`, sets dummy creds, and invokes the real Typer app in-process so the printed +output is genuine rendering of committed data — deterministic, offline, no real org data. + + python docs/demo/render.py tracker issues get TRACKER-1 + python docs/demo/render.py wiki pages get onboarding + +Notes: +- wiki pages get: GET /pages?slug=&fields=content (query param, not path segment). + The CLI prints page.content directly — --format has no effect on this command. +- tracker issues get: GET /issues/ (path param). Goes through Serializer with + --format json for reliable output under typer.testing.CliRunner (no TTY). +""" + +from __future__ import annotations + +import json +import sys +from pathlib import Path + +import responses +from typer.testing import CliRunner + +HERE = Path(__file__).resolve().parent +FIXTURES = HERE / "fixtures" +TRACKER = "https://api.tracker.yandex.net/v3" +WIKI = "https://api.wiki.yandex.net/v1" + +# Map a demo command (argv tuple) to (HTTP method, URL, fixture file, cli_argv). +# wiki pages get: the client calls GET /pages?slug=onboarding&fields=content. +# responses matches on URL prefix by default; the query params are matched separately +# via match_querystring=False (default), so stub URL needs no query string. +ROUTES: dict[tuple[str, ...], tuple[str, str, str, list[str]]] = { + ("tracker", "issues", "get", "TRACKER-1"): ( + responses.GET, + f"{TRACKER}/issues/TRACKER-1", + "tracker-issue.json", + ["--format", "json", "tracker", "issues", "get", "TRACKER-1"], + ), + ("wiki", "pages", "get", "onboarding"): ( + responses.GET, + f"{WIKI}/pages", + "wiki-page.json", + ["wiki", "pages", "get", "onboarding"], + ), +} + + +def main(argv: list[str]) -> int: + route = ROUTES.get(tuple(argv)) + if route is None: + print(f"demo render: unknown command {argv}", file=sys.stderr) + return 2 + method, url, fixture, cli_argv = route + body = json.loads((FIXTURES / fixture).read_text(encoding="utf-8")) + + from ycli import cli + + runner = CliRunner() + with responses.RequestsMock() as rsps: + rsps.add(method, url, json=body, status=200) + # Dummy creds satisfy Credentials(); responses intercepts the call (no real network). + env = {"YANDEX_ID_OAUTH_TOKEN": "demo", "YANDEX_ID_ORGANIZATION_ID": "demo"} + result = runner.invoke(cli.app, cli_argv, env=env) + sys.stdout.write(result.stdout) + return result.exit_code + + +if __name__ == "__main__": + raise SystemExit(main(sys.argv[1:])) diff --git a/tests/test_demo_render.py b/tests/test_demo_render.py new file mode 100644 index 0000000..2066296 --- /dev/null +++ b/tests/test_demo_render.py @@ -0,0 +1,33 @@ +"""The demo render harness emits real CLI output from committed fixtures (leak-free).""" + +import subprocess +import sys +from pathlib import Path + +import pytest + +REPO = Path(__file__).resolve().parent.parent +RENDER = REPO / "docs" / "demo" / "render.py" + +pytestmark = pytest.mark.integration + + +def _run(args): + return subprocess.run( + [sys.executable, str(RENDER), *args], + capture_output=True, + text=True, + cwd=REPO, + ) + + +def test_render_tracker_issue_get_emits_fixture_key(): + proc = _run(["tracker", "issues", "get", "TRACKER-1"]) + assert proc.returncode == 0, proc.stderr + assert "TRACKER-1" in proc.stdout + + +def test_render_wiki_page_get_emits_fixture_title(): + proc = _run(["wiki", "pages", "get", "onboarding"]) + assert proc.returncode == 0, proc.stderr + assert "onboarding" in proc.stdout From 2ff13f36041d855fe139c459d39cb06360283c82 Mon Sep 17 00:00:00 2001 From: Sava Znatnov Date: Mon, 29 Jun 2026 13:40:37 +0300 Subject: [PATCH 09/25] test: harden status_get wiki assertion + doc/typing nits Assert wiki via the correct wire structured_content (fastmcp's typed result.data re-hydrates the undiscriminated me union unreliably); fix the ARCHITECTURE.md Layout line (root mcp.py is now the mcp/ package); annotate the demo-render test helper. Co-Authored-By: Claude Opus 4.8 --- ARCHITECTURE.md | 2 +- tests/test_demo_render.py | 2 +- tests/yandex/status/test_mcp.py | 6 ++++++ 3 files changed, 8 insertions(+), 2 deletions(-) diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index da62400..24ed804 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -9,7 +9,7 @@ and `tests/test_snapshots.py`. A failing build names the violated invariant. ``` src/ycli/ -├── cli.py · mcp.py · output.py · log.py · context.py · settings.py # roots +├── cli.py · mcp/ · output.py · log.py · context.py · settings.py # roots └── yandex/ ├── base.py · transport.py · pagination.py · _mcp.py # shared └── / # tracker · wiki · forms diff --git a/tests/test_demo_render.py b/tests/test_demo_render.py index 2066296..923516f 100644 --- a/tests/test_demo_render.py +++ b/tests/test_demo_render.py @@ -12,7 +12,7 @@ pytestmark = pytest.mark.integration -def _run(args): +def _run(args: list[str]) -> subprocess.CompletedProcess[str]: return subprocess.run( [sys.executable, str(RENDER), *args], capture_output=True, diff --git a/tests/yandex/status/test_mcp.py b/tests/yandex/status/test_mcp.py index 7c25d73..62c3527 100644 --- a/tests/yandex/status/test_mcp.py +++ b/tests/yandex/status/test_mcp.py @@ -28,6 +28,12 @@ async def test_status_get_reports_all_valid(creds): assert services["tracker"].valid is True assert services["tracker"].me.login == "alice" assert services["forms"].me.email == "alice@x" + # result.data re-hydrates the undiscriminated me union via fastmcp's smart-union and + # can mis-select the member for wiki (dropping username); the raw wire structured_content + # is correct, so assert wiki there. (A discriminated union / per-service me typing would + # make result.data reliable — deferred.) + wire = {s["service"]: s for s in result.structured_content["services"]} + assert wire["wiki"]["me"]["username"] == "alice" @responses.activate From da35bc2eb6c2a4452134476f109bad0c271c276b Mon Sep 17 00:00:00 2001 From: Sava Znatnov Date: Mon, 29 Jun 2026 14:06:44 +0300 Subject: [PATCH 10/25] ci: drop the CI-bypass marker from the demo-GIF auto-commit MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit demo.yml stamped the regenerated-GIF commit with a marker that makes GitHub cancel the run. Recursion is already prevented structurally (the job triggers on docs/demo/** while the GIF output lives in docs/assets/), and GITHUB_TOKEN pushes don't start new runs — so the marker was redundant, yet it rides a squash-merge into main and silently cancels the python-semantic-release run. Remove it. Co-Authored-By: Claude Opus 4.8 --- .github/workflows/demo.yml | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/.github/workflows/demo.yml b/.github/workflows/demo.yml index 2207982..5b21962 100644 --- a/.github/workflows/demo.yml +++ b/.github/workflows/demo.yml @@ -53,8 +53,13 @@ jobs: - name: Commit regenerated GIF uses: stefanzweifel/git-auto-commit-action@v7.1.0 with: - # [skip ci]: the GIF-only commit shouldn't spin up CI or the release workflow. - commit_message: "docs: regenerate demo GIF [skip ci]" + # No CI-bypass marker in the message: recursion is already prevented + # structurally (this job triggers on docs/demo/** while the output lives in + # docs/assets/, so the GIF commit never re-renders), and the auto-commit + # rides the default GITHUB_TOKEN, whose pushes don't start new runs. A bypass + # marker here would instead ride a squash-merge into main and silently cancel + # the python-semantic-release run — the v0.8.0 release incident. + commit_message: "docs: regenerate demo GIF" file_pattern: docs/assets/demo.gif commit_user_name: vhs-action 📼 commit_user_email: actions@github.com From 1e5b292d5453b53cc495a7f1bf1715a9a75c3586 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?vhs-action=20=F0=9F=93=BC?= Date: Mon, 29 Jun 2026 11:08:34 +0000 Subject: [PATCH 11/25] docs: regenerate demo GIF --- docs/assets/demo.gif | Bin 435122 -> 706604 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/docs/assets/demo.gif b/docs/assets/demo.gif index 024deced7c1806a8870720fd3fc51516f565c669..0ba78ed7ad4a6eb8f5e2cc845b9980c2c72fced5 100644 GIT binary patch literal 706604 zcmeFXXHZjt+Ag}%3u*MwLk~p=2nq-qI#PouAhrO4h^RrOh^Q+85;VxF3zxmmch27Dp800ZojLciKrnfqaZ7%C#z&CN3)Pu zFq9|L6y$XjG}kN2swgTNC@L8#DjO;(Qt>banT0-3q!fPrGm2>S3-( zlVA6`-rjGzdcS$#LI1$RMvK=a6 z(|5hMZ@jO*yuVZ2|KY3nQTO1>pHH4lJs+MPe$@7=L-6{2$K>Sf+h z<=%W+cu&#B+m-!=HitjH?7m&~xP+d9)$qJiJy`B>)_6zHohwhP80DUqJnODLyB2&q z`c+Tewc(r0woDDL`kEKFqn=*f(OZ9gtbsMvbIGgW#;bdY-#@IKNdKj()4M%^WkZAz_p$IO?97!h2g!$ zKKJUsj5QwqG~R!&;oECbij058zZaK#mH6Io`caGZo|$U6d2iwP z@3K|PjMB-bpWml1MZW&~YTbs=DgTNRzlZBRRIM0Yj~gipzvd+w?#0L9N>LP-#Sc}3 zNiQLbJCjjv)X-Fo-7FErMX!|Ute+=r#X>(+y@rljkL*k&`BqP6PRD^RtDoitJOb6j z=q(uSVumB)&z}UHWVKt=H~hitf=6q<-_dC&;09S7h#;@r9llOa!ln)84QA%PF0F1o z;led~7rW$W>*tV+9@N8QUdj>;orm}!dH7|Ra|VDcm@G)1|EY#Wd-&t*`eOWxovcJ4 zC_6lTCJl+S3d_-viP;;LFFii}zOv|@fg>s*=B%HQLlNNYlwrUZts3qs1##7;%ewBD zw>KH?#8Kj}e!6k9MXG1?F{_*>zo@OsRvk#*#8&GrIE1*KKiXt?b12a3;!RAoMUMSt z1{;P?&tbZlHXrfFtWArehh2Z=K(45hKDu||re(XOpZ!+aT`}IA3~aPu)8+AGGg^UR zW@FDaY3sQb5ncCr&FXHF4XyoP{e3HWKNG)Z8vEp6y~#M{u4T+@ccu!{)pC}8y8|mR zd-DmRDLCWnz-a`XbG1|Q_jXfJtLAnY4w>fKCQ|Ee+T>8~F*{k2KYs3nI*Y{_$NHZD z)oLa3*_vuEX_F>nZ*Q#IFl%e1CKK@9%|g%gX>x z0H8cXP*o|2_7*^uyF^GkDVvlffE#+WU_+!Fa-RUXwyTAZBu$~JUXt7w9NBp*HN8G_wX*0%kOG8u$#$X zWR)pYd2|?u%wz`ll_@oJb(kg1oMPh2$(E0DO%H3UVcC)AXSrvMQ8@oM2X3rG#RT!-8 z?)FWZJuARnrn+zJ*>rI>uiE>vaZqleD0AD>wIUIO5&=_pSzM|Dns_NjJK z?h$kC=1NJ~)h>pfgP9?7W#s;9x3xWkIZ1Qn6#Nwrch4thF3wd@eXe*0^*lM>GzHz^gO$f^y3;6e=WGv^ZBidKWd_Uu7wQuJg;y1ah;WYZToxA;il0aHxm1= z?Of;?ez5f8CWxp?7S2X}&>(zro^p zy_{5CXzcR2aVWp{8tK0g-_ZN&Ytq6!3I1kcr`P!G#f9c+ zpPNa;z2oyu3-_hjH%U724*`M@M0rb~YKtPYuaKkMCqb@T zY$4?cQw_Z*u-g_}$pb>}+P(?GvBfqDp*G#!ds41&v7PE$n;FzMsdR6#gO*d9wa0r( zb!_pG%|LBVLf@3;uf}KTL%B%8zYrO4ePw>F4 z^9_A(&5r%-WfE=|bb7zDEd1FQ<$L?$aNoN%_kJ$-vvO`1z4v}^H}-QNao~3GLf`xK zzkWUj33mi2pJ^wxC2_j%oigSAX}5JtgZ!L36^1?^Jhv@9DHym@xwij<@3Ez)0zzH2 zyU)i>g-b)#zI9iF`acHVTY4tUsjJ!J^C@I(>3QQo-Hn9)Pdk4t4T}i%LY~j(FtuMJ zUB30V^7}tWuKV>uoKt_N%I8b;wqK(o1NHR{{a+3o`!yyZG&FYld_7e7>*cg>L(_2o z*Z6zCUP*Hrn&10;OB(w%zBthEV4?rpiC@271H?uV%2&!!`z=BHHMS}bNV)5NPmppO z+YNnZGPnJnBtLF^w02-7=h*Kl3h{22yYK9o!ryPG%YJuzf(B;K-~0WRmV38vkMH-3 zW53_oJia@SFz~(j*YEdqVw0HXJ6ERmXWGNB=}G>;T;;ky9~ik!Lsh;%u5SDDG5B%Q z^M-*RH;(=J#3bGu>GYkyRru#~l;6G4;eq-3dw;&La__x-@4L`6_UCKj<9p)^0}Bs+ z{rLtGnFN&q>oU1jpsygcQ?u}`N{+whBDFsK?KXhK;*tXj}PyS%=9ftHB z3a4lsLuNzX`K7OREgKY1&9M~cIBz)s}Xsp9zfYDIcDOF343no^fs7$%_Enj7@ZDHAXH^!>7Q(-);!s)kW zRC^NYU2x$Jo1f~c)tuVVzo#2RwQJW7xKJ9nc0rQUC(V7yWUFsy3CfC^n_0$34>Y@| z#f#`{QIGkNvX?a$b?Gk5@tdyWaW3K(nN@LfqpPOMCF|M~WCAz;tqRl2lGi_sTaOu?u2?@(7_)_jvWFw zowwL&r`VKR*>Y0$fSB(2K_l?G*4<4mGv6MastwHl>+(xs_vU)Tb_1HU`{fIP)BUpG zTBn@3dT}EELz}>Kgv|q;oBT&slAVW(V_;ipJ}C>KPoTi7suW z3judP=a1Lf`)(;hb+u9E9T)E#9qvFJsIFPwK_^eSq|;xD@BgxD@eaAb;fW-{WvF~w z=q<9(L$kwQ9;RZwl0{%?MD|qt*26_N8F4Nxb06A{bUj=q3sU|7Q#(!JiG-N~-9J6Sqx_Zsx6}u$WLOhW`VSCfInt0=1>?|@aE|MeITCkPGcaxSS$Nd8GOM5GD^812s*2NQPWU8$f0X^G^id0@ zRmmXiD*0fu2&YmV)Sf3Zxm!IrVmEKosZAQOWp8BQNX>i*rxc#sOfiyqS?dgy(+!Nt z{scpM;q{AuaQ?n8b0heV)pxh8y?JRZZFAVSoqr5bnbUH?&r>mN`dLM^6;6#hssPPU zKJUd8F-oB*f?_bMHMGU2YLtzPQ{3jSW5i{;?daE=NL|ftQFbHB4LNJ5$9HLK9v`x3 z$0&yuXyer?s>3ovTv`6~e^V*`({5+}v)lhsiY6v5JZPr8oDsG;*1z=8@!y(mF0z~Sx|0n2W&_#cZ?X2K4< ziGp-&C_(JPzVdiV-NeyL`Ra{1{q`x_e6{cXo>_x|GXcjme_TCc=y@Z^-HmU2+pt&B zXOn^O<9Te-?6)_~w|1HE)kiabI30bP#4vDObL@V7+$nkC%mUSn-zos@spL zL`3$ZzF$`NNqPq>U$zQo1ysdp4j=zGXM2cqF#0BK&2*07*a8=AvxxjRc*m>+toG05 z`}yAjPRm5}{-=X;Dl%r7K z$f3dS{P%t22%|70EvGD))WirKCeU9vAthIh{)?yS4>!?c#}{rGuR! zvi|y1^vo2GuVJW=8MnAuLf~j6fs@aDUtPCUR3M+*IN!ZhLH#AI>`2CAeq%}sw2?je z8mrFR;=vp&?Pyb05|Cpd&FM&66x;eW*JNsp)b4dyEP*?oNBV>!j-!Wh5QvfSr? zF2#l)1gseH*4@Iphfll(n#rSQVFl~smfl=xb2z3+Qwy#q=r9Joc10HE%=6k(lSF5}+lcHWN@^4Eg84ggjNznY@ ziV-V+wv(ham!i)pWLj{$gR4h?P$L@0ooC@%wuqXF95A2;ia=SmHiQ2=@~>|65gZ?- z*fE(hh;+^}IooN=o9>$7ZTX7{p$nD2)-kE?EX{j+2w^w@w`jG{OwK7$MBx=c1o zGtPw?s&TZYrDZeLED?%OJ2D;0Q((}x{QKO>T*>jjR>gngOBOcZ#6S5G;d?fjN-A|F z93nfVQcvqRoX}9$4nhAcOfh6kDO*+4!jrN{=AW8v7$+3C}>qrOL>K>{VFSt%HN^rcAwEOGLB-x zx7a#3cm{t!?Du@!;M+n_2OYC-Z==I;G@x6f@W!esY_pZ5O=I8p$+R(3^J2{|Rw%)g zKXJ>LsNnYr5{^@vZb-bIAgb)gf6%o4Srb&G^8$Jq#Lh9`0hSjwTIJG42tb5S}Qv@;8y zVBF`}?i#d5=x|NL#5q}>vAxg{t~NKVn+yGSR`j2u;KKie0#kn{3SJc&J|}6oS?bLD zE%^N_U)si#HzZ)~Yo(>`C$`!!>>>I}c1K$n@dDW%fMdMw`f_!UL07^8L!yq@VC z6^!G7;`I_Lg-4mX_QF~lo?T>l&?oZ=_7WZMoYdNHGszGO+k8f7Q=upk@MfWXs zfxl^!F5RoVs%szZMPj;(!hL_gS4_#;Ilcsbcye~{b`6Xl*<&hu{9d5(rnOneY@>(< zp`*Jo>l<%Jq+H>lMYqnJUTk@7W$R0u_4*z}LXnP}nS1}%n_blS`wVin+ zeczg>Sgj3Nvet4HBefH4C!ziVa`hP`{+ymylKq7fC5(dLA^^PN!r+uTj$YU4{%t^Q!-kT}?;KRFJ^ob7ryV#rXFdiUQEW%z<0$}jb4H6H1Oy9-Tr3qX>UtORB;F5^q*K7$yBf+25G1?Ogm1Wxq3zvSUTrm)G__WqtT#%+c?Y z10{6ZCxXG%ZsKwe4Z^C6E6P5{=>YAxr}f^UD_d^=RdBjf_57w?xW^A{eNC^++NN=< z-t!S5HT$O?Y?cYQ@hZn+y0W=fIo$vBaoB2?nS?Tt+;Ra^HoeRO+rp8NQ2+#%03>g9 zF4z||`|!|U&tBN7i$~7)7rj-=iRF~6DEmLz6Z}!L=f@ilzmLZwu=kEL_8q zw8iz#AGeP?^s+g7ZNlH8#m^t=u5HWD*&&>td}Vub*F(+mV{y{Au-x~><6oENkH2nv zXmaww%cc3T$;SudH=Gpy{Zq9i242=u42Ha#&E()7==2#k(_^8Wh*F^lirro?ktTzt zL(?L!Qzp~(e9>WB^(q@%Gmc;Anhg5)f$(2#_`kH_|G|`K0mcAfh5Z9)2C!VZ$kXqA zc+x`dkxe2AfhDN>iW${X%0IlSoi5d;DXGdS7MQ^(NZ>LQ4ZX%9%^4F%Tn^okzJI>J-&e^LRj_A&}ju>#c5Ky_X z*fwE)ZsYA0D{%u)6Ms=*uYaZAKC^S93dW49h8v?@56?a~xyjsx+14S`gHe!CqI%q0 z^92ggBitzPYWRxb#(lrR>}vS7gZuvyT>laAF&Gy5Pi64mdh`E@k2;qQMW6_VQPj;g z|ErHW^k$%HUE%-aqwe#pW-2HBn~yrbd!%arzkF27WVJ2-!$)N~Kd{IDcOP|&jxYH? zeALQyTR*@14<9w+{gZ$CsH$@xp8wNFE&TFn^q)TJulHZZ|LLRJPkx*HhmX2*$>yIv zs`BULrXQb1ZXdgT+b#Tz&07#FxAAQ{3UW8HkQThvpa}K+3ONkxw8%_} zzr=*Vuv8Igst&;tEg`M>@$H^KIE+qo2wGY7D>dJQLTc= z3#B>aRnCSCpc<+$a^(v%*}?-vulme@Vqe#j+Ha>JZQmE}JHPd_pVl0+L*t}+8CsoO zaf~B7ASw5$R~{6aYs8OiYnP#ni(4RgxB!B&NxTb%<5ALT8MCOQP(W$5C>Aa|Bw%&q zuD{wMvzUDh?9e{7%?X94N$GfdQ6C*)^BHW#m~3lqK~m0xY}{UTr*xf27ASi{WiBf= z$LH{8Cp;>S59zf*ulhkyY3~DCamsW^tM}nP5n4AMXep=X3+G`rV)2hog&{EIoV-y1 zL^&G1?Bt>4HzJAf3Ee=45{XVCi%!)T5Jph2`w-uTW6)diXTs^Wu$*HX+wkB2%BEA+ zP@2DdI2!jWg_1r!14mxd)j=y#Q7VJ?>KnFEzdD2p;Z&(Kg}DB@-Y4;cjyJk}NUwu5 z54*OL;g8ThkzlIYN$Kehe9s}UL+#}6nFP%s@yeG2p{dIWi)nKZu8e78DC*Zqg)_WN zY90xxdAugp6^{#pXrkFX!=XNWDmsP460zkHA;go@&YA*Rs-XiN*Fn}?Z{rVSi6n4S z8yLLKonv!f0Q>bTMg4}r>eCPHV@`{J^3DR3_8TU6+@=-5mm-~pAXute3x2sHA0hL5 z3a%l6YX1ee8b<(`<06;>OPDHkW#PAyI3K8G6m+nThE&9}EhDA2!~z(bLInCeh9)pqxF zf!Zj_8$jVVx*VCdkb$90C`%ddrIRaVOQVo#`Ka}+q05<6dtc;p5ziie8V+lRYLy9~ zvN$>~a{6#dF%w3L;iPWhx2pbNxWLU0ao}A7xeftpP0+-Og$*Lu(`oDb{WHv{+K|0; z)cV;_B%BUSdP`1GTuRHer!q-n5}xg-ghRBV;~{CChTBE`a4V>ml!R0yNKwfwXM!0i z#d|_KmnG$pHlsOM9R=Cn>Y(h{h?|K`Y^wF&ayXux>WvzODj@od7lU zfEnM&Ansv>VYL`+MY?0~5f^8Ydio&tr6gl#Op1z;q(w%jd+Yrg0nA&dXE`DT^>I^Y zV#E-_dIlTS^%-IlibjQ~u~EySK+l@G{Rm?bh%92dkcHRxt9d*>Sq;L-i*zHyP1n(z zL2adU0FhUxPj*q>tz-k40GMfSBErh?6Lh!@5=40P=&YqcR$rS*#e5dkeDmhnU5xFI z%4$S*Et24hPngr|G=4=VN8G-}vFi_^7oN zj>M!pt;v?t9d>U9vBs%@;;b012=bBpq8e4^I=Gr3%LR@Tq3?I`bQJhE(u?TG0=|1t z;ROC*K`2Vjqs{h-Y)+)uS@Uw@6><%mpmB_%H0{A#^N5)m)}^aaB7ho*9f{Fhj&Kza z-2PNMciWNDW#l@V==&3Yf`d8*|B;Uj?2zD&u*y}wkg9Y-XwNewC}`9wF8<}GKqOnI zZI0TZBv%OdxscWRC0zT-Qgr%pfH(lU7uT{0`(q%`U_jHZ;`E2aI~-_0G=2M1_6v=e z`rD25r{GSXatAkon6LEf1RH>3t`{bkA%>|{N*fhjO0k{3E;=L36iOZi*5Njjx~`-+D~al)#<(9L(4+c9vbYT);lz zV2ZGB=L~QPMDn|tscsc*YB|$RDqI#vPQ3-4F#XZ62SCVqP~cbTo$J)KxsgRFY7uCs z^kK*MCaIv(Y;~%WmnP9248`ZAyC^L#K1T*?cdq+7mn&^eAU4Cbo`ZgA8%e2*6nal(^2|GYArJl3jS>}v%#y0z&gMm2ZrR%4pJhR9d5xXjVSXz%2e>@})As=M#1mN? z^Gap^Y_cHjrel-6%M}laQmEeAsj$Wtl`#@mGcqy535fA>0Na-%G*rsA7w$5<7s=bu zZoz#*2>)~C4^PK;Ece7TOevh~h*xJ}yq@pUnq(qX#SncEd0R~UD}E!B#IeGya*})i8BHeSp+eaqV5YEhXiOfDHIcg z`ys|+>8l)As98Avb&#wT1JXB#50~g!(V$2=c9wx>3V}U5BD5Y@sv}$=0Vt{c3SpYTqAh6*7>2CxpW8=w)dQFioIgkva3KV@Pc zKbC~V+ik)5x#LfZaRUsZL~s;MLDYeSItgw@geo-L^FfI3xeZSg5Ju=poE5>A20wc4 zl$ivs5oM6>cFdKA@O$Dqya!(=CVT}@BvNuQpRh7TWx#N$B+~eO#5J)G0)RL(U>nZ| zUJye$Wk8>^&O|=Goximq{=`zX(ud)FF(in$7+>uQgbGf~QwXhMd@BQK&46tcVn2&; zePaBQfY>F5D~sSV)x@uK0y>JAB!&|NnE5?Kg`>o;G-QCpMT3Tt?K%;_-%x7^LDM4R zlz{EaVwn#TnHVvk!a_kJ2rWX~I1{T!haI>bAhQ-2x&;lB%G}>fY$ZVy*UGM?LHq8+ zk`AA<#Qpb>HaxCQ25?=10l5N_MD0Pbh$85D)TPsfZ4 z32_40I!f|1A9s`wJ;JxYE`;{JNhn(JaHOye6!=;JG?an+K*8sUk?x|+?|(p@0n7_< ztJ|$yxulgU5z7@Jm57sY06i}z)(8;hc>Hn`v?9mc_WXu7XtvcpwvIMfCg|b+@}-HlDrlD zA;E&PmFMNlwnC%%`0paj#jvFBVk~=@U>b2~NE)>*u&@}!&w}_WVIfltJ>*90{DpHRU< z_JYKGI^uKG-sdct3t+@B1&yV^*DT;ODUf(3=DY;Gl>ylRY+f3=8VMSsW}p*1LO~jB zi)|_4n&O|tQbexYzRh2onP6&K*~xW{R@>ceB=OSx9XiE-{N3NOKJGP zd@G=u)00nQamQG}7z$$ZJT~4V`h*1YQG)Ij7X&bX?JTTFd~BA2Ek5FzQGFr$J!!oB ztXPQXIip{hd9{dSQS(uzbc8TYM?vCbCYAA5MhHAHZV|+0lZb-?l)RvRR*JQyp(6}X ztHGLP7J7&zlOiQZC@8V#r61APzpyYqG=vZ(Yav%$-%#fyANGNX*&xNv3b1m^`pIK} z19VGr00_~L+P|e?Tx7QVprEaV5K{@NUzj+~M}5uELVpr0RB!c=lilkCE4T8**XqE3 z3(=qDWPjzVWNtJP!?+@X?ig{NhVf)U)k!GLE5y%Yyhg~a06xa75WN~?n_WYBiZBZj z;$OzeWkbT?7({~wkr4u6iwA&aias-7T8uj>l0nxYe8ejl5eQiisGI7r`E{C&=JzFa zVVOIX7?r+P5!Q1duQVq6gRAC&or)MAkrySO>RZ_K0NOQ^M1u_m0u=jhXliF??|i`UQzt#D{h9 z2ygjl`eAErI_eG+|5J$DA>Da&TP`W&#MxP>A$^BtHHAhK@mzGY?$rG(68+7RvzHIa zw?e9t5E_{q?HDj45cz<9TA>L2JOek+!%>X~=K+)_6K%E*V{#8`7z2wHmCs8EU&Z)W zBAieRe;x?cW5BloD|5O{PF5GP45B)O_+}=dC?00RJZ^`P*(QR}q!2B>Vc<5Lj3Hnn z)u(}w9lz>6&63tKAz{6-6b>ZeeWgzn92Hk@+>lWUAa~HAk5aVa*5xPug6^r#cOe;N zWD*)AP!t9E5hN4|tB+=(9fY{&O#B=ZyIBl3WdV9Z$V*p27Y(V--;mKrxHKvxwm`h- z*j-eVDhN{%L+*zqeG+5U1<B?Kq==v4x=;)N$$ z#CXG(@GYY98X9c15LhKd1PI`sB8n>?bD4&*r#y}LK}7Rm{&u`R0ZJBxkthiNtN0`# zB)1W+z`Jntvy7Sq>UkS#D1_iiVLR0z@A|uN7SEi6k;;IMA%Fa%n2-j-68Mh#N>zDM ztANSa*q>?1AFIp{!8GZpsNgOKvA>5n;jI{9ON;zSL38gC(iyN4dW6pM`+@^3l7cyy(@ekqa3JBlCScO!?9x;pthDXFByl9c%u5~j(m^BGPN8p3R5nn{8 zbpjY#fULzMt$_>Qf5===V(yT}&e3t+lCBTHQIP|&6oBm)oRu(5?=lU!=52P80M@2VJS&7KNK;!VsAtjmw-huHa1Ca`Hy|;y!ts(h;;&x< zBdP6oJZx0~)j>FfI}L#zK_8{TV_}9G667h0tL$nC$y`oL2ylh1lOn8K4bdkPvPXms z5unzKu=C<_Ga9^5RNe)kgtS`}TNqPBSYQ%smO-43#u}A|d{bz+c%Px~DVp4ii() zz~lA;*`&~1zsPEvQI-ULHD~l{KgyQ`ulq}QOF?)T5?fgaKnkplh)g#iwzCk<%)<}2 zC2bCrIZwh(4q;a_wht}K6lWlB960D;_W~OL02-vrViD552$w{I`Bh^hXfSOCW~%|d zlKGJ%1`>t%0Tu>eSDm&_8fua(E)Y9O9xu`_OJa2=vX%FWC*&hS;PK?`o%KCC{$T&-GDTqdz|r9w-D0+HPEZc4A&m z|HWWwTT$&~z4uoCFhjhm1||K2{>@8e29{n{LZ|3r`{c!U$D15s2qcj$zWho3W*@{{ zXXbKwr;65X1&8H>!HsA8x8*6AGmGeyQh&>%9c|~zZiRDH_x!X(*xKHn>LjH|F37{% zFt-BMAoO#9M6!7%^%ok-DiVP4S z?t5}!_bHqu2)~p#XCpd$r08fb;PJ$Ej~sxxvX@A*4{Tj8T>=BPTl4JKUeE5TY@6$wgg?e z1!8tJg?4HL*H7bN29}|fMF&35xaKNEkvMRx?V(j_!E0(!DmG@IAlxr{g&gE`h*jDJh=?9 z17{*n8%B4vyKgZ@QKgmmOsI#h>P{gmg}fJg1%gs;7U+MHBV2iR&eVYJq;N11QjRpA zMlQY9-QGB{^Ad8s$a9Y>n~S5Kexzg-!W7{{gg@V8D4Q}{ z2qB=-D+D2lHI)~6aciXFdL>e}1+hY;cPWaJq^&(z6ZK9tfE!i9Bom^@g+XQ2j%6pK zrgNx$Y&+!|$rh9g6ROxqN3IdG(c4?lXj+Pjw-{-j=!l`w0ol#`WsVUVii;9L<0Y7YpEPibU{I-FroSpMjz??$mlZ{KYv6 z427mckP?pS9TRQ+ML+>X12NMAm=>C@AVYIA@)aS=docL;JK0D2%GD!;BGKQO8#G@g z%m$6e3#x&YRQX$`v=FsP0D=#!U%ih`F0Te4Q~@u$I}Cu6*m#mJLW5F)kT!O%o0MdP zs+Y_7ipUD~B5buyKL^RAmk5{$MwSlD3@AzUkN^lYsNtZ)##zmtPSSfru%vgXE)H5? z3+PByimUQx$;mba5z>>vhSCH`r)Baxpe6$rjAR0c0zfmI_o$H3?fD_t-Kvb4BEOlE zWoEMxL!$Q)^(+CS5l4)TbU;Ha+96aBt=R%Xf^$wo`n}OOE>nMvr8CODS}XkB6%f5> zQTkOi(rlx!dU=pih@e1-nl_uxoFA$%blvND`W8p=Hy3Vh(}IyaeXd($cOS`%*FQH@IlL+5)q{pT9{ciX>)?o4?M|zDFwK!@%*MxfOew8deC_vj^hGMT<#MO%fkWr+ZGX20p>Mj1 z9Tugt?tIVJy^mj=F$oewl*k*E5_DP@FjJZqmc*^pAUH z5Y|x>@%@v0N&M5SGxuY*&v6Y<_*4|HZVv*wDPOX zCRwvk>+O+i8ea4tHWsa%eH^e2LcHZx2RMwgKaJxW|YaeBBx_eJ8}+hJX|z= z?)g#nsmLQ0`VMsiYj<(Cqadt$5N0~UAf%L(F5t0evL;PjxElgg<1_O02mISDVP zZWq(LT-P5$41J^W18KFFbb?;gecHS3#4~dUV zinV^zU`UU99LMLiCF{RMp;Senf7o9mYKB?()pe0D<;yS?CLO+cAaB~OVTa~j>h!su zf(LFv0olg)eRi8C1=cU0nEz}4OaGkej**7hzJ`ZkpSFf1f3|zYGf_xVE%}y2PHdmA zc$o2Ra9eU)!pT=zsFREGL?nT~26`aM&8BY#Ya0c82X=F)i4cTb;Ct-9N7aO zAlMPGavCtDa2aIC>cdq~1_0EQ+_qyoZUUjCf(J_=iU~p+f!AI4FQ#Y8H0##3f--vL z7&0V30AiuqA{*>Lcxjk23Kl?gQ!>G9;~Vl!07-RxBm$f=*B4PP!z-$@Tgy;<`Y&g8 zgig7|D6l;9z`%a(jLgGMSc)tOpXqFO5uoTTrZ`fO(c+XyITO_pz@Qp&807RBor`CK z&stKKEuuJ2Wgvc3lr5TGc+crF?1J%U+dMvCRE^vr1Qc}jzuanTC_E$E1+kNA?nQIg zkFc|yGGNu3A$)E`aH>g{`pzD91xAf3W;>sJb2rhIj=d*NcIhb`T{d`~a1^YYxd;Oobk5P10LS&1y9o za&BJjVj7c0;6oS%&Z$?|k(m$!5l2y=zv+U?0+#nsRAI$JMuED&wl*z8yzV-_bXM>H zj2e;j_Vp)Y9yHu*?V!~}(s?JePX`K0N!vet{U{0P-F&Y& z1zauR9s#*#9vw&$EC$VsKyz6F)Ls%?gGP2sN9?7e4hM6$MZtEw%#fdETS<^dMO-G0 zm%vI@6+l#2+@m9Ehog8wi7V0^NQ&~Lu{bb3CsM*)LxO&tawCJFIw`H-cUp85Dqw^S zBlX2oQ!y;HM@;qxdfF}<-qB!WC>4&q-P!+pO>&I=2@w<_a#UdAFcdxeGRRJ+R%kky zEq0TW0t^p1PSy=aIRIc)sD^tauz`%v-N;4uazFvs1$|Bq)G@kR**DP!Faa!D7pQO` z3-yh#K<-c)R%+rsYk+73%I{_Yji6{6M3KSlB)i@vh?xXxDg`Xkk)KHr3?JAa;WC1u z)L@P&8M;UV>}+@eAe1JB$FWjFYc~*F*f3%0?rKC#FwBqz?IgkWkdQWAY;_OWUE~xj zm95TX(}l=g%oJVH%7#RxIHv8TrdkF=P5CKnZ0NevPBtQ_DS$X4fg2Wh-Fm}OrE`MQ zQR~4Amjvl>GCa-(VcQ5bMZ;(#Y`7GFY=X z({v@EseM||O83b&LOLo^nRK_>(pELl=S7U_o)Acp)5B;!Hwc9O^>WU_LcG&?PE^2r zZ<|52rFk{n<}%WY3fqy~?U|TnFNH@-(js1>Kg@9=1W11oEE;GRhIG1}<3>?a@#qS< z>eO9Puuu-*Dd5^i<-zJoa3CNf0^lB?R}{*(0Dz0SciBJz5&&UAR6!zYk-yBLTKG@i47gR=!pSV(-Dj)@0yzc>X=XNOwK1v5BHpD+r+DPiddZI{`p;AG?Euw%`LhD!FgmT(?Kepw`_EMQ?)ao z0&pXzp_KFs=7_B^GEdvvp#DOnBa4HrNZCtEOS=N-0f^qY)PQuPyMQg<$d*m-f6*Rb z>cnxDrt&6AoLBo-pnJmTX=@VG4oP5a3$ovIS^zq27oE3l8cGm>iAL!GHfgNIw4@9( z3o7@ANk@Vh!QKey2@r9?NPn@HD~t0OIvkbAfstSb#c8Ij%2RjQND>HVz*wRjB@bZH zHf?=6HxchOvSL zz^;oMI0C&ejX_H|y8*6lFsQm%lD!D1tm0XWK$bOWU~o0cfe&gertK!dHU;ywsS3pm z_Om$dHV~=03lB~S?!`<*{b_`cMFBT3kwXLl?*im{7Mr*T zy4j%ofE2A@sBITVvuCS{2wsdg@jvZn#7NsGa#5GAD^DzQV<|EDRSh}aRDiEeVN#L%0F)DhV~FUD6>x)uX{>avJs4>2!DULI0f}iH7Cc%t#E^9E zkY_(k0E+`s4e4n+nJLR_?~Ji7aR54W6CZ_t3!D$xv9D2a;KZ zDj5E%EIiv_gN`uX2!du}WCl|zjLpa30N|05(3J|6taKCaa0jGzf11j48}Egx>|Wk& zpWfg`?kd`IfRU2qk*XF9xd=%^8Zh+vR}~eUjif07RBl963IYvw%+Ic?)6}dVJlD#q2Nc8N-|T7Wc!McB?SUOSDo zN_Bl{iTT}AaN#Y&kUbkIA^23JPDzoletcL(YC&z)o^ROALTulIxnT)VI`_35n$)yd z9pmtB`Koo8)PmCih*wE*c&^ki6tHc>C-g(Zg_rlRz?s)i*PfYgFvLhaBeC=uGZ0Bd zL*@+)McobsoT2Bky=Sng1zXw*c<20g&Bd;oHp@&UEKwt5Vt+Q0PwPh>e8c5z&EF&} zWVV4AzBE@=Nb~_sHxy@U2iI_mc5w?;wJEl3g)?@SrAOZ`eEZ6cw+olR$IyV`%|yJX zSYk^y3vV7@2}=XGSe_i0rIp%Er~b*kYr(}wsU)}xXg#-37Y@0}#f!UeA#DZ0L=1=6 zu$wFKyfCSQyJzl@PeKCF=yHS~cPZn|I`u_!6bVcS__1;)=zWe#j*?&t|LX2v9_k1 zXEBzzReEKw8?&S!49I5BDGVbP-do*&ln8{?7KJh(8-_7a1PN>L8*>XoWQE&QSWcS+ z$szd25Gv#Os#;M0-=by2<1=0O;`1+7ukR{~B^I)03V1Bmt^;~IkvnFn%Q2b6#0SCn zU^Dx%2BC--i|q_ZS6sC4Yy+LzMr=`#Lj;%c32tJ@k9HX&#$*iP)8mR#DvDFPAZl)z zxG>*}zs14_jP+$a-ts~|Mk;MX4*6lyfFidxu!dXg8W$TijSo%%Lu&Flvck>6f)g+I zs7VDIYLB^vkoJ5*PF)=O`H>qrHQ_!j#^U@8o@`yY>NS=Rq_T^=#&M-NphZbWI(rW= znq@Y#)_mKsk1#IXCr~&*N=^Zp(~_Mt;LaHdhb6Invd8Xke8~9Y;}RsW7B2+y?TM1W z++rarnQ=7<^;QG?Sw*YZ$PIVGYT;w$?B_HX+;vxKrTYF~a+z~?0X~nwv9Bd4o|?<; z{nSOP)L@0rQFoslQ+b_-SYmw|&uas%aYgBI(48$Ui!Wg_09-WdOG++bZdV!UTcH~g zyTIU-vFy_m`>O>$U}(6C!HDod!Cl{8biOZa$qNa=?{HD$#Xx?m4mdfiy1GRYQ0Zhg zG#YU|Zcl(TeLCI!)SjIR!MW#C%1fQg&LCtKcD)b>wLt%{Z$|qN=650ZHX!WFzUOhD z?fzQ*sRto2#-6n_TI@a5CO!GkTGD1VFE1Gg>c>0Gs^TRUq{%Tr9D+r$J5&WTmKC|G z-`Nl9K`JVZ3oUZR3>!ZN9sq@#D)NakWSw(!0SwG8DUL;`>5M;4p82kS57l=7@Xd;R-1Os3aYb3*fKXX63?Kv)vxR}b`|HlbpWiY7%z^ciK!BJbY3pJ{519N( z=Kgm7RXoxo0n^$qJaE?pcbAzho$Pm)0r|j!^uu?exPL`S(nWNgU~6&sTPW zrtPQd2W5i5q;7LNzl!wlH+u^pTGmxqt%&aOqgZ(fVM)(E0~VAEgnYO~r7W1K=2qIO zY#bu$cE%AWU5C4}-#j>-@!jp^)g9lze0cYLmKv234BaxP`6DykKbf9c13H|S99w$# zmBaDAedY%AtD3P5`iEv8`l3P`|zuSC%3lVF{bm?%5hrv@s0mb zm$z3up9i$8FKc5&MoK*|iMIbxjd(9LEI0FjtCPAL@)fH*`ID@wk2Myvd%wJWpj9BX zTh$hYr1Rs;YIYk7YdrJWcjuke+C3q#ED{%UcVh$g`o0`+mxLF~43}6*fQNK@*sc;` z4T}Qz*gq(E7{a)!Pzmr+;-)(cozMkl-K%>LEVwuAQABo5?x{4%De0hj)s2F^#Lb&3 zdYz67AKc^|Z?`4u&66e59g7P_2E2EKbE5gT&`k%aGm3$S#fCQ&)uzQmok?Mwy>%l* zJ(6Dw{m+750;2VbOd({FLrskEsN+h5(~_%oa-gv;ee9|%`zda7Wtgv1OZCbfPOXR2 z&C-&Ne*7Bue{~Mo|9X7n=z=*a24wl5Es5@}8a=0=@ZqX_?!?ve;T$syq<}jlvfb}D zmTOBjn&-2FMa9M2>~{zlltDC>g?owThuUt+tPjJD$EeMNn1wjgl7xM;Z0h7vYOTt! zeD2`Y?r@yrP8G)T+5qO1*QK0Fg~5&FrV>L!4!hLv7**1pwef^dV0J^?L_eoCvcZzL zI{}{WoA*C&8QN-9ASK6ZbGh#z*QTIj=8ngpd1+aHG}-vdI&GkP4ah0-RaP|!LyScd zvhNqQ?caWCt-d1O5e9F0O|%8>_q|kgPC*Fq$=^TtrK+i)<`b&TKP4i5=39>E+7k49 z7(<}dqZ6L{=M)Z#Vft|k|NVoLxlR4pxp7ju@3i{-Mi(=FOpVbS_16%C2$}jzYxSzU zxnqYjuFrjQG;rcXlBj~6Zu?2>(G!>I!059s{>3R~cnz!m#2T&W+D_;~7B?p!l$XxASU9wh`o{<2Z{^466=?to(YmrpYjz$Ee}c zhVfk+r}Lj~Re8uzUhr;iz5(ljgg)6u5%depCgDOu-aE`fMz^Id#yI`CfodVUL#|-s zHUBASt5X%^2od6?W#os+Bn&$hIOnQ{>@&TH_&`>|^;+t-^4tsaaUqfPShm%_)<{tOAIs3e=kg zh&DQ-04_)dnSCY^tQZo)uo%ac0T`yKBsfZqrTsBT4q<>XAGlEKFiK>p`*))vjJ}Uz zfmByzP>kMKdkyKv%#fJHh^nux5V)EA1-|f0#+aZ0xmGG6#HkN%e0!JV3`>aoY|Ko5 zeY5gF zXS0L9Q&{v5<^s1dcS~5wzIeaXwbsG*+TnO_>qVH&-UU8Aq+l?(^Z?gA(z*yY&x3y`D7OO+)#0l-Lz6V0n+CBm?O+3ab$aBVr6$dZGZ)(F zhts=vuDo-Myu~eM^<(lHIpeQv{+SCgP9luUkiy`iyhKAtG(0tQvxLK(F2S?v)(_o^ zy4X>3jhEti>gnBplh|X^nGW#Jr?K%Pq!4(qxtP7;UdP1?XLh+}Cb>L+>d*>IVi)-n z*Z?lI3N#!71ZghA8iPw+eg1CQpMCy%?eWC5=N5J4L6;YAqb^;3e9dj^`BN`GWM8`S z@;|rSZkLyz4_vxB=09u4!&5K6bzHjkao4P!uU!85_ray>Q`ctYeLeNhe_t-$`2F83 z1jAE6p0$ZMj6y2p{UgsBiwrgmcySlA@^GgDGBl-usdS)Ev zyO&0{j~Jit>UGO=FH7RRGJV+9=Y8G1d~?fdjDcWyuYmdkT}{U zlMxn&dQ>*?)|n9Q-&!0e{X7tJ$Y4@Nuve!ChNmpv<%tEqc)yKHSTK2{#IxN1Sf*egX#=zPxOg+2g9E8G)Y zAffE)DzNYt=MRmlX*ctx@Mf`6Yo20gBz9V*rzn{%YS61;^cZsUN){VQDOQd>#_2+c zo-5HWAO|I;`#pu;z%5`LTw)vHZFAadS991WwiD*!XYSK}8{2?*cAFmGm~U`+WuxAX=6 z6VYdXJUV~<+nL?|?~`WzeERVE)WsYAA2*-<`Qq#K@7HJiwfVDtX$)^n_c`XR_8EC+ z%fIpOy#-KJ{AoY#B5OYpfGMv8VPsRY!`s=*{Yspuv99fRE17;hP7J{ub%!$z=m2kp2u zY)1EJRn zV`am7N|e}X!SRz!Jpy0sp;1N!({uGGC4zrXKOSjYdw4dLpjOzVY8LR;*cAx4k_Og; zV>3q^`f>onE|3!!p!*`_S&Y{{8}F1R?=0InTbt(O+4>YU`IOtvt!bKDZ|mFIVQ*KPg!n*8qB`ahm&@_%VN|FSK)UBPKb$}5b?!T|1ny{?NC4=N4uA_*FdV0$d= zYlA)+No}bL1L&oV2y6*{Vzd>GNPsPalm`9B#{BKDBEX|uV_K!@951;BBiIs!W39lc z-g3#~X3KpjO(;DhcuMLLu&_nLPZc)F3PR@E+ZzCAV8mW4FySa{CM6V}W`OJZ9K;)m?k zPT9X{hjrllnKUecp``t4TB|BI2~vWVO2_b|=uyDRFW$0UVZ(!1gNX8)k!`LGtA8e9 zMGjyhQY6=dtlGPj&ZCxm$f{jot?SG9Nmh*=W5{4!bF(RP9rLt+H7T$QZ(55#E{=`R zV+72_sW>s_B2~oANNKmR^29J4HKO3K{%ly+>Z&M9jj+^>EmquOA0+Jt(8>7!E5`^)yH1m!HDSDu+^JK*NDwsU-MU#cYb zm1sIB@QcKDJax7EiEaPZCg>NhN=wV0>r_VPDi@s){aP`w`fZ-nDR)y^!uGcg9dE^Z zoT|*mn`FQR6gW@=A6OYt&UIS74xcdEf9Nr8(=--(Tv`!ZT5lh+=2k>X^4kVT)yz(t z)K9Pbh!gfc0Q+$J>3zp1g3GIdH?q@T7fh_43|Ub-A-Q~F(S4`G&(adrRrTf12v^af z6sOi-Z%gr!IvtQX9p5@pcs43Mu+1iRc6wsmcr)82R?-$?^sXh&*{?dfb)vWR^2t4^ zr&>dd*N*lRcB046ootnz)IEGv>WWia(-$ey0~u}Y^GnG)XAsP^g4-Y978+or3q_=m z4@glm0wjKMB#Qx-F4=1qg6L1y$O??g7P| zX^cyz!bmHtgq(!hN8R+BYmcG~c7RhYVyK35USv*cGWTZ#MqQBKc>aQMjLQJrxUQ!% z8FDNGNdRN1@yS)2obGt^P%04G5Q3lWN{%_*86%TkqC0pEr2#(H*8_AWt#maQNQE_MVTKe}4&FFrKe6a7_qN z*o&1+Afv~3!^D|P?eBb?Ou+3_noL_RT?UvWD_zGWMDd49Ct-Rnq+0{|&5w`V#u2!q zraWrj8Dr{ngu%&-)x!q1nccInQnoPp#SyobcGN5gGJJpfz&gZH7qSX^E$JJ!fx%et zv4);h6+-?{fLiq{xfLMMNI@Gs@YB1X1v(Lb4Osmxqx#>|q zyY9(cfI`N)Bd*UU4GE_%d`Q*=JZjxhP4<%v`~dX5ZZ}=t#7pRj^IM*xKIk363|8(57R^eDZB`TR`GoN&lZI={**npE{u1=f~9gl=nkL2@b!yy~bEZ3=Ju1fR_5ony9|C&gM zL-BFIlKq4FYatizh6DS6h_x`b0tr2eESl3Xe_vF&qFI+0J@=#X6_1UX8B8y(3%bWmq1;#d`02jCMK`R=^)_p!>xO$Zbq3we3 z%7J??s=Tg!%km4t0kA{pl-&Sqn283IA;5sd`FsbZ3n8N&$FKKUXJYIo5k}o!ez?T` zD2mzn%y{d8`fLQ~5_ot8Fa`jE&s6X#bjflQ?=uxp2PgjuDX*B!Y6CDVz#%u^Gzb~j z?}*1nVnSg)wp%YAcH}s3i$=USm+nt=dilfGQ~+V<(ysl8S3>WocpJ_Oj=*F{mct_} z^Nj(JkqOW1#$iNzZNe2z>yE72Uq08=XMX1U_0JnanoBADhRB6Q((Bv7r- z4nf)wju|bKYl(vFt9X|9HNCSGQfJKo@1TP)k)25(_G3F1wrgtD7^9 znTtI=Ig#%p7Z_+o#yNqFSGrXZpq{9pj}5ux^7QyY&;OMspU+oi2@I=(uPCIa&*%Gu zD_NtySR)B%C_i~`zLl4NHV8BM-Tr*tmMz~O4fs?8m;31o4W$V~L9fEGdD%@%B^Y7; z{G33!wZxhq*!c5ujhBE0%;fu*Xp7?rr+dI(5>F$4 z-@0pa`z16j8n|5Q+16cbA))IQsYS5;WB@x(I%lBUqfFAz~MelB+C#1O0nNin$89wf+0**#fx2 z)5u<0wem{&hiAcO49y@8+bNp6SaW8H_tswzyDF0w?za{c{a=f==%8a{>ttwP?*e1j z+4aPHm*r>v_-kl`M?-f@*s%qHjVRD3bn>W}NfTU>BzG<9e4I?r>Q3 z*lEe*o#y6`to}6h)RpExSs%zar2lQw?EIjc`jH-+%nnNXZs>=LD>sD44%gcG#FaoV zE*`t$?uzD|_lvVIr!2la*FJ;!xW-2LuBr+9HPc?>ejKGb*si&`#T9 zmQmy0Yp~{vPlJAr^c>DIGj~N%Ezg@}!^jLu=rP=KHLa=0G7inBFH@apt_T?IZ)?`? z7`LzSK)42YN`=qsLt(6j!un+$;)WugaC;}-Sc^Is;nt|!E8>(5&HLx0LkR?{W^RaO zq_bk|s9(VlSlB%Ohm7EM&&RgR^D&pX*J@1{$UPV_t~o%Or&J%Xikbj0jEnX%?B(As z3C}mo0yG6CvEwMlc50~QpmSr%$T7X<@t~T>epO;sQq*U~p8q#t8zcH>rW^I(I2Cj# za%6n8)_SnWe!4-+F5av z5md>|k(VCL>p5ItoNZiGRm8JsC!gJ6TBI;oEJMp3_rH$NNr>O z!pXnZJNr9mnu&~fCrV9_h;!V!SK@4HO-v$}`v1t$GIHtIwaIF|aGZ_-l4Ai9U zvH-nBEG5Gim4^9X7^$In=K*y|VhQID|F{6X9jJ6cCdLr1g)Zlb_G~E8z;h7NB5yf< zy=a8|`^3H7dFty1Jc-dgMi3=kR3xlUC~P6m^a8Q6KvM*=5HX|-uSTg=dz!wk)H3gj zq!?V)t>xN&8b^)GtP8X}o!R171L94vn&rW-N;=zm^{F~}tE11YEx$x1VJt{LTxf-_ zfr}E%r25NBfXlHu?(@CC^r%+XJJ6cA_6IQk03?0M2~>}r#W?+gh0JgOV#sBfm7yWd zC$%L>JqbxiWpRXBM)5*F8A1~l)aY55k(-+*uf28mUNvWqvV(qi#C1NQpS+aQ* z>Ojxp7bnG>Cao$7{55l=0&CQ!&T3In^rkODtW+5}&S}6XLIrq?J9tJjBnD=Km?hKs zmQDXkXL%eic1TuuzF=X@d%(HgxmhRLB54^hVqch_V(=(`;l|SS624q%JR(~e+Xv|S z@^og(pFRAdIfZ5xOXm)}Ex|R4NpFQWeOL5HY;3I{J~=ny&C3l+a&Y&tH{uZMcMUL8 zL{JLjILVQPaK3E1_Pzx^=_mr!9|bG_*1r|%M3NbI>C+gg$%meIbu$qa>MBM8dP`(6 zPC`Y9P(qwj022Ptr+IdI2qhNRshU&{-x9EqBgn?}`6|yC_ zV}vuHyS@}RyB4tRs@!Aj7YWtE3)x6TfeFgStjxrlbpX_5LVO87AZD-v&ng_q@BTl77XvD>W`!F!h{kdtfKS#<&+l;1lV2C8Ua4hIo~bD}UtUhvuu?l|QmF>1x%M;=?=AGJ!C9*mhmP`o8EFnC!Y zU>y_V7&f%3J>x&a21bif5?hiMgCf4vZuhe7Wh>7HM9_ksAVfgw z=RY&$g0y$C69y4l$rW^j(s!n1v5(ki>NJAM{EwRQ>>-xzqc(aS`Ht+Y@qaH#V4k(? z=3RYr^zTA9!{+DDcXw!M=ie%1ZKFy*kf?)LBR zvKi6Kloe9Yq4V^-=r-wo>TILsVb=yO17DMuwq~7%qA%S zl=D}ymaPG~@OmKz+wu#sf3S&Q&u0WYJpIw6peX7ClQTow^=}s8{yd1@XJfWbxUr12 z$aZ6w7CVO}*{P7=En(xQ)_*l%^VHqk@LDBlq|YKtjxiZZFsl{`3`*Ewq>n8v>;2+F z^GzDwAY>FaE;l=(!UoUSSZG)`z4H=k4Ry_O-qz1X_xub@AJ&qir*B&85U((=ZVSy& zpLbX#)}$(-a$ir810*sr2=6%HJ0!>>43^nyWkrqseP&@|wtVAg5jX(j=QC!e*Q1A8 z;!}@o{;P8J)B`)OT*NY2U{l300VF^wfS=4Xs!9NHQecf5&_`75i(>8A;0Vktl2GH- zn3YQ&WXkG3wrmvxI6DA*DKZM-)X&79uD_0gR+2yM1e8uR!RPqI^@&iufyyz z=(UP)JkDnM&3}3n*giIY7<8?ZWxb!E#ET3TC*iyktb>~VFi?)-_TwC=9hq94>`k&--+Mt z$O`O@N_jWb$mhFH&qOq0=filp#;g(05eS$7j`<);8gdJ0qe$&SKl1wf-qWwDPT{A{ ze2Q0-fsKXtL|P-6b`9`Z#m1HIv$L9ot!cRNd#};$9q^&9QffYI3M(YFsnIDZnQTp!z;OysSTy#i zltNx~-fLMRt`Q}~7&g7+VsyD6foRC*HnvLL6#mt2dS7!@A2h|+b(%Jpyvb%0sOOis zOd^~603sAVeAzWBCzT%JGS$h>Yh{zRe##oZJCu0e-WmRf`U)3@V54NjMj1J$fftfQ z^a6eU1h9{zvudI2i)zhPg6sS@BnHQ@Pxn_kg%yhE!yjCqC6VJ1iqAs5m1>`BQd$S_ z+HCLZ_Y#W|0>K7g6s3C|K|;N4+#8d8OYL^d&!Fx+N0hT?u~vit4Ml5)tu_s$De zm`%vAVi5>wEZiE1=`uXq#%7gz-!G+7Df;Hs!5S3dCuOWe3GE_+Q=+EfUqb#k+uQLb zCp;0;C1Zth$VcE}kqBd^FrC~?%#!Jc_7{lkm?%PIsPzUkF-O+@8cP>WT3Kvz63arKjD-KqhC8rTejqlEg7x517Jv3Zq7t8*Au?6hHF(371^}L2c z(fH=D;x7+Y??h&K0${tyD7(QBMM&@Maa-8Lc-4bU#4Svipni*U+H6#dg1!w$cCrEH zU7MXSCPoGhBS};c%Vb08AHAI}Ci*AhQi`5TIAUPfKnxxAZfG1qu~`F&OA>J*$kQP; z^y?s|2H5P8gl8mJvK>8CfQg~Rcs}O1SO&>uF3*xcCSpH?XKBzKqMN?oN?%Th=Pg5^ zFG4AwO&NoU1+kRu(N$CKY-@qCbfjTXXcdz)-pl(VnMnzB# zfQdi!p9m?=)0jB?eTeDJ=-?Rb5J6%zYz&3!xnNKOYZ#rR&;Is|ZM%AZqy(lfuSlMr| za%9QxsJ=rHqS9!GRgXe!zhoXMSE!N;@eypoFWB^BVRE*>5EgBO#YQ@8e{$JFrbGQ0 zX>cciHEZ~Ldf?br_9-Qr@N%}X)kS=`cZEyr$u%N3hj7~{9cyJ{>>Oqtl|Y5zN7(Il zibK6#Qo>T*y0H5D>+0I=i!`Gn3yzaL@UJ=|hp1SqzBAY1MkoH!! z9C@8~uJxV#Bsiuv8>B*uf3?>}FZiRy?MxNc zOX9xfILToXHb=1~ajx?hCS?aK5s65T+Q6l9JS7sf@;IWKafZ(U-)>6%#1E4upab2XQU*xcCB+NmLWq{`JbvrD* zmN^WQFN+8zE_PYm`_O@iWkuXdwaG<=;V`O87?|Wm6)Wv*BEw6Zzt|{b%m@j=JKH5u zVaC(w?fhYpu9^4uY27oKq819Dbi<0BKZE1+iqzmBYKkc6+y>M7vqr6ODjxj4W2NOY zg^}>};y78`e%}-8?P(W5^Kn2gPhvG+5c`p4=Oe=Uh&qE;b-sh7Ez9nn>|Gg|Si1V> z$~npl^KAB>NMoHumz*!h)r$0t#DIV6`xvydoMSRJP!Dd;xeSm?H zwlSUk5`Qp>DK;#Hw>$iGWszaAS0XMG#deCCvJwqX0@#QhI~}(_Egf0>A`@E<LGcU==!$=-t|PX6tT~I`ZC)z{dCxOGc^V3W(6lv zj;JvnYD&Dqx_)Gb><(@QRh#{2Fu#bGs{n=rPwNqoVH6r>@BD`b|=DNt(;Fr6> z)p@AM;>>!(=>&>y2qN{d8UE=M;2^7IdtzrOYq@g|NAW?Rcl$K{B7t%GD*ksH)>lNo zY}4~XF@Y?7>A|_R{K<6>85RIt>KhmQ4zz!EmQZ(SMX+LCO&Fw=u^uSQc?~9A91qpH z(nm6r@dT^3hG1t|&=C%6476<4=-n>kt}C$`lra4oEVBgQ)xE_Q;g-q<)iVLhsMp#Wy}DA8H=KU;Ip=WyD=*fyRN$1S&2cMm98$+dt>M!^<=7rw) zusVkH<${}!nn3^Oy@vj3p&H*;Kh=Z|<<7TnETkx5&F(F!jW~)?9hXfq(N9%T9kmo zb91%-?BT^1T~$kj!6aVXj!E{SSHwfMxaGounFslcnVdQ7-_f7*7uQPWFn`39aC%Ox zjq-XgJ2%q9ILbUE-jki*x5pr&8aJbU z`8$cK!;Z&%K5Nd8D80X5&ZEt{`2K0*FVELYfCJ9%#H1F!rd&|X6(WuGE}8?3u2eF zhWooiB)ilKC2pR0-Ajszx)rlUhpEk|akI5rCGn|cXns&IFRD~;QSPBCz@$BU|NK2= zngBd;Zfji5(2_P0*<0k;gn08G50kvsOhZ8y{7RBzQpNYbi7R$C?f3BvB?K;=X-5S) za|SzAWM+t?wCuJ2_JF=xEuOvp>j9OqBnPP}wA$)R#yfsnm zKr@QFf5&yTA1a{TsMbo3ZiwPb1Kzd7f_S^2>ia9XQ$P@G2)Okj_682a0{OE<1pDLj;~A> zE7=q4FGp-Y(QcuZ&%E5I*ma5#pM4)UXrC*2_n4$N_Kk@z+$D#uQZB5o4JbTXGnnQ$ zoH4Zazm8S4SN>~UELPyHd8-c2i5hoR5?w9?F;@gd1~vV8=E|Ccu}43fJLmiRd_t!Z z0U|F2tH=*BNmYi=`7xff-)ad~@HFjthZ!`ifzo$IFW5;WZ5|CqMD zXS5`=(>USrmiAA77x{Oc53w;Z?X?exIH_;gW%snez-9Wv*Zdmj%r(%wdkKZfVe*VA-b&i!&uej_F z7e!rrZ6J3|WkvdD%}u1XhV!w#1U)g*7l*+(I6v6)qO?)(L`l%3K5y?9cat&Jp4%}e zv#T@GEFYIm7A+Dd8r&u|jv1}+ou8HEKk?x8SoW>k*S55R=IWYD5r71*K9Qhk9w5pWY& zligMs_|yodiA9|T$>#x<8q{O+5qy;zw?3QYB+2ed3Cn3T`qt?3JW0Z1L(C&cp_Lap z&|{3Bsr?--`W3$N{>I=jLRM-%-(2=bNF36kak$qyKq<9P=80q zEbk5FOW-{f>(bmg+%`mCc)!%GOms@cT@4RRh4v|rrGRjuGDtNbLy7nB(v^)AajKetMEC5_QW_9d49(4bj%FfKD+Po##Jxni7?>?!l97Q;gM2Qd~>^Lm}i zHV&p_U2T{*yxNgwhosC2ZMynmJ7lMd+~ZlGp%(TB&fND^7m9x=X$hhrpEd4S3!=p6 zdBsAzi+s$y@O=HbY^fpR7yrKvQ`Rj0lah`5GL+?P>UD9iT^}qpU@MLLb;8c6LeL>I zMi1M6;XEcz>MIJMHOLFO!!Xufr+41R3Sx2ZM=y+*U>#wE6_l_y+CoZ(Rbe zTpL=N7VB#9Ie&8WG20RiV8fMJVWI|H1bcHOPbe{vC7Ov-m3SYKJv~kaob4}SmB3gX zsEu7%66`*yGiS!VVy^O`h($9ZiO$}^dTj~P%HR2>1&Rv)&0-J{^-Q{8TvGM0HD4fFa8oGFUZ=d_cqT|(qZ{0 zL?GmSA-D+a9%!f|MHq8wt@3i7uq;uSWZEe!;@=j5tl%r^w%;#XTN`M$lL67= z+4w9G#`tP#$h^m=^DB?336(Iv09qRs?(F|4S!Cf?-d{ zVwk+}_zbqt!MrfRE@u52AO4nG0FJDNT(?04edq#%9xuZ#VsD+$5+YPvhs5MZ6$CdC zK_e8M!DkT9Z~JAty~;7)vujTAXQEbQF`M$?1Ff*a(<11QSp-i6t}{`(eeRokQiu`)7PV0?X{R| za@qy}%fAHL0${6%mWCt)0REPc6r)Y20$gc;QgMQt32ALP!$`L7;mPK>i@dhXL3`-R;2@nALAcLn{2CekNB7Kmf4F2|uJIQ{+%H z5%YaL?cYPCqy*6aJ3iASaYi)*WT~ldVOjzMYclCdV{Q9VfQbS~Z^ZOLExDYH4YtMH zW7F`hSR$V|!63!RG55!D^(tz-cwc)fW|2xt_$rk=3ZCk(-S?MCH;8+Jdd+9kiw^Dn zL@fByRb77T@ceUD({1>He6UJRYnY3R9-{QZxFsT%V+GJGr(e*L&#Ggu#o=MCo;kq1 z4rE?QTxt0h!d2SFF(?;A2Gx98hRA__i4mO$w2A1V3anLsSpk~mmquDF!~`*_HdpLO zKWD{2p)?_>k#D3CQ%u-PH%K6V{^oxPn2?<6`EN=+wqlwq=!aD~f=;Wdo;ltEXa&4Q zh}5vOGng%M;;|um6$}aZhwh@#y7Of_7U5nEOPuj0)Uc2G#0Z{Q^M*o8FX@s$s5yOo!DG9?U8Qh$j017X#H(v16^4@jMQ)-^*Dn(CL-||Glj(~_%Grz z_HJ*wv~s`3o$y|)H>LI1!^gDSH(5Q(?0R-scQoF*9Vn}y>C6L*v>?Wm($(bd$Ob$4 zw2dm?~i$2d+ZkRIY5F{ zSX1Qm8g09E1?C!qvRs9|(9!-zO_MCTZYpPwdin4-_nTcUVaWHK{ z>T!l%wh;66@?o<6fxn*+U=?)sDSdqfcHUcRjTVDhMH*5cCH(~dV3GhfV2l#SwZ~Jw z*zLTJIVUb%wukZcaP`?%2K#y2k|$<8QG}ByaVawA;;5mE9J^SS$WY_PWMrd8mxZci zU5@5>McteVpb?NR(HUS=lp!|GCYL;n;!J?m_YiuOs?&Nx*K5yDq}=c#0h|wR?T_v47b_E)d;{}(}g$GDeGa<1~@{er1pTx zLkwaZS`>jA2N6imVN$3Hw`JUdqq_VUphXD1{xYu5647oTgeW=jjf}EfhVhkGRWmL} zsE+E%Lygof7eu%W5$XFDiXp|OV=wt0Tuo7&`*xUd)um&Dmn#t^z7gqs96m8{aS}xmtWZtanz64KUd!f+3=s^t|HOQnBc{ zk9p?~ANBZ+eY_PRD{%j)^&Frk&Q?fYd%;ZI|E*;IH4%M~LBGo;?4P*UtD+44NbY<> z`2f>y@Mq$;qr!WYfCQlp!?fdUqE1L9EGU`~?I>h`eO0=XMCx-b$yKYY_;#3w5+5^e zkIShUj6=W`T0L-lHkI6#DAao^TxseApe<%H+NOeC`Xo*7A2wfwl zPphcRGK{m9@&>@O#XzEnrWKKws!L0F=AF)Qe-1pb88cnXr>uOAH9rl7fq1EiSl)8W zbwdG=N!z9+wZf$Jj5_fHj07eug*!+Mkd9rgWRUA&Qic}0<|62i%n+&>7a*9tI>|Hxm>+ak-(xy?-cMyM8(vH*O! zir@nD{r!qi#lS7z;J-yg3RgWQCxBTDQYwmhAAp&y2Aj3?`@E?hK}g!mCbaHitldS-*hyk8e7GAXE!3JW5EJWF_(0K?-PN_!lnlQO!7-Ut6FNTkX^|3t$@ilsOq z;8qdg{TZYI|B%JtT|oo^#SO{GFHPDqD`!BAJpjG2V=(|dt)-V1z=^=gX}xbo09gwd z2?2f4P~RU{T^IlkhS(ZI$D;p{be>^Nr2p5SmR?9gfB*p#YCuXTLMY+{5D*Y)Dk_Ts zK~WJSB4Wcy0cm1DP*8M3QPD+>9bI%MG!aozSr_XDLB+aQb{BVD`RDgM@A4uq=9=rC zd*(jhb3Oyv7?|H#K0ZGjiPsS~ilqrMuSDCzhfm9I zwG1-4V;j$#2i7jx)dwxYC?B=AvFO6({H6&vqWW7w_>>6%rBsk#XVv zlZ)A&TfzmbxCxU7;Qsx@c|*Zf*UT6#FAc||8XO-loT8cyG)}E})!<|3^?k!W+OPaR z@sr1N*uQ7VKN)CyH4r*k+n%cy$%%(?0vO`noG*U6nS4w}$&!s(J@aCAzbuP}_XbWV za^K#`O_-?#sVETBRr7%Hp6&Mw41k8KEPEU<@sRvG9w#_HYK{YGi^K_}%zIrR8$C5r z^fd07>|yR75F)tS_3rPGEi5}Y--zlJNEXzZ6TJp^0ED?J4+m#Lfq>wyMRw>3g&1Lb z#=D61p(_PuWp4WC$+GD<-ZEHzSl@#A$m z_a^51FSZFY{`lN5_IA$BwI`FxdD{F&9pTOMA4inXd9!8Tx4a7Ub%f7BHnM5bX$>Ld zOL%?q%4N-de$vSY1LWH*vX5cLGkSd@fE<4H(amPU-u26d8GNbd-!%&(xI=;VEbzw- zUy`th-r)d$V{ObNz?Nr`y&!A(Mzcu(`(?M!%Bhv-!6O?yxkEsdCAjqT-`28-lGA3| z9?Sje777Ev1F z4=g156?vtASO^gP1qrv8b0XZ_>_pK0&G7x!>NC&f>{L$;42Z{GgShC#dcOwbURftRBJ$btN)*ZT| z=l59}&ddk(PR{Y)#zyXrMQVg|s~ncx8=qI}vheW#mpNy6rM}sa@nU{sz@`u55AVNP zpp_Og9hVMIB(%<}b9GlZE@^j(&K?r;q7FA(t!cl?F^{vAh(qPLWR$S*XZf20l)OBp za(~*hwEq%U-DX#v5r^NCRKvBMvXMu-w-Ju?4fB7|HMKZL_A_~6R?2@b)}{U|%OhUv zH@vX8bbj~~`EEk9`rz^j-J!&sReiM>0dw#;>{ZeguHKvAiw9q32XfZ%{v{J^wj(qeiFx!M$JHsxIYT~<@(bg(2j zZ=Tb^{7>^lEwzcQ%s^g`g>#Q=7k34D(+WLTtoZ<>@DCgL1B|gHuEC^)|cXdC{!DQZn~0 zELgH~v(J2bF5kt@JpYTRg%{gMK3D55mMCg7u4UUPl8&bLF#I1#)CZFW>h+~*>U5RT zYAQUFXf)Wc_HG`R3rnT{I%cD=VD5@t0@thgwvla7&#|CKOESs)s8Oey{9j)j6_bNU zoit8IHCoQvyhgiA^yvOSYXo!3D_hJKWiJ|#?Qttu*|_n+mQ{zh<=*ynF`k8YXS64T zv(|nXTEti-X@H73xS2na_@JSWzp=~9xgq*W_GsMl0eLzS62MLm+Clm=f@!lxq_YXh zA5qAn9-}GgvmOb1(veR`_fn^mFIui@Z12{;W6{}_qor?u-FPp?|G)g<*~^vnOW$c<)+X^r`zmbCo-Ns%+rqRcWo3`{8Nm>^ zlIF2hkgf_UwrnAuJtPfBY#pfizZZ@aSaTGwikb{jp5Lw~GHntcJYA!KeTsJ(6l;0hi2-!@bfLy&8fx|d~(T2lD2+eq}UCxTJ`=_D+k%n9zUtW(f zGcoG=Ouf`|ByIZX_)%SHu~CshQTx7+Bt5|FE3&vN>_;2cZNW@WO*GS1-!%)RKa?3Iv zdDJ{YbiqlEGj5~3R$C`kju=SwFGWA~>A$#HWgqXN&Ea)%I^@OHzBr>-JD0arU@W8Qp2hxp-8j~!`qow3 zqZP&O9jMx&&FFn~quNe;?LAnXbm(p7s-V4&{XSd{6N`y-IXWbol@q3R80@DIr_&ji z!@_KfJf22h66{L%u>{+qw zTQPJ6S;~9pr(;uNCcCVQJ3u7GP`1u(g~x<}c(QE^<|A86O&TIcx;hg#HIC6yxl;1f zlDqNE$Ky#y)+{`Eg3onRn4jw4;2D$LYj9MRHZ=fb-r_6SOFo@Dzy1Ju(FTGZb)Udk(y(mnd$pO{^? z2Hv$Tb=+z3Wf!TQ1R1^GwgSLoM3H+W=4t&re?o9+EQx94Epsu@dL+*M7|oIw^*8k7 zX(}^P>n8?KaO{Ylar7PrjBf@AEEHU0q%j>IGhxT0pzBZy&_IO#vB8PCZTp!9|6fda zo+gD_CGT#iSpaY>H=ye=ecS>@mVB7s?0SWBETwnmsWlt-avN^%Fd-hQ7_7|NC$usq z%e|_+qKV-t>v7Oi`M#f0Nk3->OeDUaQgIp$?57bCm%Qvh?b@9>X18B!aMNe-AKJlK*mm^ zc$)idk7#|>!273Ohb&JnqX%Q~t~j5#xF>ML;-&WwzVtnJGDsYHdwX}=AGbHM z;YNbCWsbDG{Q&ZCg^fWw5^`o!;v%`SU;TB@e)G+`TRU>|?Fnn#WKxrtrD3c8#t6Y9 z(&)I!ftZ&+Ic#Ec^AX4-*0MEirM4OM@&LO&mI;1a1NDh3ku5K$11{wPZd5^BH-YPp_ zoo#(`_7raAw^PX(S*#&DPye#xSmKfG2}fZ6{;PvAzm)v^oAq5s4Q7#YTHf$_*>&q5 zgN9G-+`$DjFW&-Zvad}p>o9_0c4t6BdC=ADYtt2U#amh+(7EfNwrggH@eJv^wj5=_ zjwvBeB??Cg5;M{{(b5?l2=DzF2?j13!EcT_RmIOp<;@NTreLQ)!CG}xDH7VR>{Ei~ za@E{^$o(HhmJWoscmIiy{;s*%aO}a$MuO?@p98e_XQkh;=Z>Kf zIXy2DLAPmHu&~e@OjPhCNOX!yEJq?H;ejB9nGTK+A;!0dPq6a6k;jKCZBt>l6s2=p zt!;{GP73THS4GLyB0)1t4o7xCoiat(gv#3cmwS6*ZvRD-Wsrk-u7AJMO$(Z_+KFv& zl3cYYqio4HqhQ<{RUgbjC0_Nx&hforg|Ll5VP?c!w!wWfVPPyMy%q5{8d2NSJ}k&q zNC`E8N#i0=UR#cTR_akz=K6&a3aXo!UF( zeqX%%*JZE;D)A?)y+sVi@JMUH!0xlNJMUMVl_9<<3X=)2eH--QIhpE)xTaj(5EkB$ z(xZ%xx$v#!s4Uo48^SdJfs-m{onl}8O^+dvj;o?%${)KiPPrxg40jT^AjqcCNqt9Qb7y6bj0VshZtYufMIptCuWbK@7hm&Lr=etY;M z%2MC7B_nM&Z&9_XutKF^$U8t;B3t}r%5%JVzyMICZ^U}(n;7@_`B1JGK zW!@Z-nmbZux$T#!b3RrY>{s}fjdoVs-HL4MbN1pcx6Y1WEx?^n9C@dFac+Lw@U2Jo zUb@Dci$dK!Won%$F7%zs1IKngxsWc6nTSm=`?KNV7o{4xX*;Px>#yzXk6SRTU{1l& z5|vx2y<5L>hTsTeGDK{^>{L(?&?UwpbM=B7scMndG2J1eULEQ({ImN&|8=os1U}~| zP)F(D#X0vFg+m+MRNS^(8)GA{iWE;BN^b{%LE4yp1IA=jSo_4$_`yK~xY>V6=sNS> z6^NJ7Q&D*{;0W~dJ1~%}?woE1{AGxf4hX-05V4MD1Pq*C% z>nsDZ)R!u6`pVR&o?oYKhvc+tFM{vBq$lUTUnElWpmG)M%&_T*NL(r{eW&E|!1Bx> zjuC2FafTro6i3Cn_9*8{U}}`Re+T01uJ9>EJam}ZBorg)o48xSpM?D-py&BcIu1pX zRfEUR+|pxW(R_n1g(kY}lMOH@6oJ41t*sFwz%+SM3=VV1P=gdK(I}@wwP#D!;-TnM z)2%m859^DCx42nGJG3 zAG{w`50f0F5t3!%EF?Gz>_>e|Yhh8xxh=!tp*posf8QULJ;tYW=16iL=UVfBsYC7^ zQEtiC|0O+We4_e6J$EFYH--6V5$oW`_7io&BS>xCMaLqyO;F$={!~N#?L%n<2#?507%PFHIk`|9UQD^IL@jTqe|> z+cSYdRhIC+h7W7}?*kphVQJIW%7A~ot84u?|Ky2!F<$@BvA5K6dqo4XNEW`r-&n+A z1o+v?mRDhm3pV-(-oM0YGs2$Z6qSNIFLsZQ<1;QU7ZS@_W_HiY#;=F@>e_p*|9k%Q z-k<40nx#EObkr+iueaq`Qe#`o+_zqCZ^_R-l?Il3ulO8jRho3@oH|;Bg!L@KGULWH z5z5*z;i<7|%*sUriL-;y>Yv5?yqq6A-!s*z#WJ)L8IAB**4vAFrty2cwbbYA;{^kY z<~~`}Y;eC{YH2VnpA&Iv#^JM^k*e^ED}>L24)b5sX|J$9%xm<@tSN2a^zXj9&e!(n zxc0($lfnH}IYvWAwG-o`&0~9pP8v<*v{FW5+{)?7h6Vpp7Wz?A*JerkuJR6N=~P-< zkMe%QN!PaGI57fs=md+(>dRKPgei>FWtIS=bpWikm-K94)1p`Q)-|8kVl*6p;$L}W z1uXjOj_VdARfCw0u(M9BfYmSHZ)M>z7n%L1fq2Yn=u*E%2aI4j2fOZU0ZK0#gG*&4 zw&U!=Qx;n8uy6Uc+nxliBRh^cXIA;T+kh93uwq0-nbw@#5Laf#Ggfh7YYzo6Wy)xr zkXm27q#hppy314oMF`fkRH?`*94j73%6`*)n1D{au=$J3)B?0Z#fAgrCKFhsrZ{~P zWcI&S*)HX_VUw;HG!tM*ULTSuj1csb*HWFdgzhE8kd7wZTSbzXzgnQKOsm<)%gGVF zt89Mj)dJ8pKMPM1Vt9kFdwFy^7?W+pXqV`+SKFP*Iv!fS?mOUKU$SDzI51Uk`d2UR z^P)>sl2Vl&pqO*&?D39tr+7k^q{P?@SrM(slY02$Ga+7u8dfAJOUc~ z>;1SB=J)B&)%ZE?rLec|J$RzlWLgF;ln_%V73`@Gdk>etS~PwkEyjIjNv07wqHSNs zf^LSLJw9~i+q1{lqF|}+kD0`)b}PVO9+F&0nmgeW^fTyh1Wci%$olXzXJ1ya+*IdA zu5WuuwU~Tab!DK2dYX)XXVXKk4FC7Yv4*AaLLkKmmR zEmK%I=#&yo@tcBojk4T#-%I~AAKMlNd6ueD`->$4%rWw_(I$Deh`1O4c~iMOe4|qv zGy?#+=z6bxeS);le@(9p_n%8ho-EHY6fYQAGI#Bq|EkVu3M*1Nif8sqSNOcT_#QCn zP;C|=Z=h`RDAhW-+D5LV?7154zT)UlXD+Svc~a%mMp5|lTAI4RryZMYTCm`#5;Xe= zT&xgkl>Gi{mUG6eFMa%tNbzqi&eTBW+WI}u{_;Hx(8 zTebNa+bp}b;P5Jrrh!8SprKC*lZqWgkhAG;nrzjkKFneYBT9fk4Z+|9@ca369H0#; z6WTsB5??YgY%>Ym{8uNl-{@Aywp1~!N?&bWu(=@4o32?!*A;HEH3D4~#3-!c)CZdz z?;{d6Z<_YF0lfj{X^c;!VuusR5`knLR^R~t#DI_mX`xGk-)8gZ=o*Ff4)p% z+YdUB`BI+Bz5{$q1*lr=oARP(h3?WytnyJQ5daD=6KsuxY&rNj2qTJsD<(!hIh8L4 z68$%Q9V6RuRO?a@zI>Ca`)VQcG^hm<1HS<*fT(qR)^+;IY2eB)!ooTaq6quX4s3XQ zG|=#;3wG92bL#se?2ML5EHz!lQ~Os>tb0BI%Kx?KulTT3cjb-tbC{K9A)y|k1JIEd&nUN;7|gC9Do$$5y;3ccB<`YezB

%DVR^)m!K3)iHUt&d!g4@U)7ATDz`1(F9!B` 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

F3Qza_RxWrbuJHe4zXZkB1_0o)3Dz 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