revit-api-docs 0.1.0__py3-none-any.whl

revit_api_docs/embedder/providers/openai.py

@@ -0,0 +1,58 @@
+"""OpenAI-compatible embedding provider (OpenAI, OpenRouter or any compatible base_url)."""
+from .base import BaseEmbedding
+from ...config import get_api_key, get_proxy_url
+
+
+class OpenAIEmbedding(BaseEmbedding):
+
+    def __init__(self, model: str = "openai/text-embedding-3-large", dimension: int = 3072,
+                 api_key_env: str = "OPENROUTER_API_KEY", base_url: str = "https://openrouter.ai/api/v1",
+                 timeout: float = 30.0):
+        from openai import OpenAI
+        import httpx
+
+        self._model = model
+        self._dimension = dimension
+
+        proxy = get_proxy_url()
+        self._http_client = httpx.Client(proxy=proxy) if proxy else None
+
+        # One retry and a short timeout: a bad key or a down endpoint must not
+        # stall a query for long; the retriever falls back to keyword search.
+        self._client = OpenAI(
+            api_key=get_api_key(api_key_env),
+            base_url=base_url,
+            http_client=self._http_client,
+            max_retries=1,
+            timeout=timeout,
+        )
+
+    def close(self) -> None:
+        """Close the underlying httpx.Client, if any."""
+        if self._http_client is not None:
+            try:
+                self._http_client.close()
+            except Exception:
+                pass
+
+    def __enter__(self) -> "OpenAIEmbedding":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()
+
+    @property
+    def model_name(self) -> str:
+        return self._model
+
+    @property
+    def dimension(self) -> int:
+        return self._dimension
+
+    def embed_texts(self, texts: list[str]) -> list[list[float]]:
+        response = self._client.embeddings.create(model=self._model, input=texts)
+        return [item.embedding for item in response.data]
+
+    def embed_query(self, query: str) -> list[float]:
+        response = self._client.embeddings.create(model=self._model, input=[query])
+        return response.data[0].embedding

revit_api_docs/llm_client.py

@@ -0,0 +1,288 @@
+"""Minimal chat-completions client (OpenAI-compatible, used through OpenRouter).
+
+Used by the offline pipeline tools (SDK summarisation, quality agents) and by
+the optional query rewriting in the retriever. Configuration comes from the
+`llm` section of the config; the key from the environment variable named in
+`api_key_env`. The MCP server never needs it.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from typing import Any, Generator
+
+import time
+
+import httpx
+
+# SDK summarisation calls run long; use a generous timeout.
+_DEFAULT_TIMEOUT = 120.0
+
+# Transient statuses (OpenRouter / upstream hiccups) that are retried.
+# 403 has been observed as a transient refusal from Anthropic via OpenRouter.
+_RETRYABLE_STATUS = frozenset({403, 408, 409, 429, 500, 502, 503, 504, 529})
+_MAX_RETRIES = 4          # total attempts = 1 + retries
+_BACKOFF_BASE = 1.5       # backoff base in seconds: 1.5, 3.0, 4.5 ...
+_MAX_403_RETRIES = 1      # 403 is usually permissions/quota: retry once, then give up
+
+
+class LLMClient:
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        model: str,
+        temperature: float = 0.3,
+        max_tokens: int = 4096,
+        timeout: float = _DEFAULT_TIMEOUT,
+        proxy: str | None = None,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+
+        # Configure HTTP proxy if provided (helps with Gemini routing in restricted networks)
+        if proxy:
+            self._client = httpx.Client(
+                timeout=timeout,
+                proxy=proxy,
+            )
+        else:
+            self._client = httpx.Client(timeout=timeout)
+
+    def close(self) -> None:
+        """Close the underlying httpx.Client and its connection pool."""
+        try:
+            self._client.close()
+        except Exception:
+            pass
+
+    def __enter__(self) -> "LLMClient":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()
+
+    def _build_request(
+        self,
+        prompt: str,
+        system_prompt: str | None = None,
+        stream: bool = False,
+        messages: list[dict] | None = None,
+    ) -> tuple[str, dict, dict]:
+        """Build request URL, headers, and payload.
+
+        If `messages` is provided it is used verbatim as the chat messages array
+        (structured multi-turn: system + per-role turns). Otherwise a simple
+        [system, user] pair is built from `system_prompt` / `prompt`.
+        """
+        url = f"{self.base_url}/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "X-Title": "revit-api-docs",
+        }
+
+        if messages is not None:
+            msgs = messages
+        else:
+            _system = system_prompt or (
+                "You are an expert assistant for summarizing Revit SDK C# sample code. "
+                "Always respond in English."
+            )
+            msgs = [
+                {"role": "system", "content": _system},
+                {"role": "user", "content": prompt},
+            ]
+
+        payload: dict[str, Any] = {
+            "model": self.model,
+            "messages": msgs,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+            "stream": stream,
+        }
+        return url, headers, payload
+
+    def generate_text(self, prompt: str, system_prompt: str | None = None) -> str:
+        """Chat-completions call; returns the first message's content.
+
+        Retries transient statuses with a short backoff (see _RETRYABLE_STATUS).
+        """
+        url, headers, payload = self._build_request(prompt, system_prompt, stream=False)
+
+        import logging
+        _llm_log = logging.getLogger("revit_api_docs.llm_client")
+
+        resp = None
+        last_err: Exception | None = None
+        consecutive_403 = 0
+        for attempt in range(1, _MAX_RETRIES + 1):
+            try:
+                resp = self._client.post(url, headers=headers, json=payload)
+                if resp.status_code in _RETRYABLE_STATUS and attempt < _MAX_RETRIES:
+                    # 403 circuit breaker: stop after _MAX_403_RETRIES so a lasting
+                    # permission/quota error is not retried as if transient.
+                    if resp.status_code == 403:
+                        consecutive_403 += 1
+                        if consecutive_403 > _MAX_403_RETRIES:
+                            _llm_log.warning(
+                                f"[generate_text] {self.model} HTTP 403 x{consecutive_403} "
+                                "— circuit break, no more retries."
+                            )
+                            resp.raise_for_status()
+                    else:
+                        consecutive_403 = 0
+                    body = resp.text[:300].replace("\n", " ")
+                    wait = _BACKOFF_BASE * attempt
+                    _llm_log.warning(
+                        f"[generate_text] {self.model} HTTP {resp.status_code} "
+                        f"(attempt {attempt}/{_MAX_RETRIES}) — retrying in {wait:.1f}s. Body: {body}"
+                    )
+                    time.sleep(wait)
+                    continue
+                resp.raise_for_status()
+                break
+            except (httpx.TransportError, httpx.TimeoutException) as e:
+                # transport-level hiccup: retry as well
+                last_err = e
+                if attempt < _MAX_RETRIES:
+                    wait = _BACKOFF_BASE * attempt
+                    _llm_log.warning(
+                        f"[generate_text] {self.model} transport error "
+                        f"(attempt {attempt}/{_MAX_RETRIES}): {e} — retrying in {wait:.1f}s"
+                    )
+                    time.sleep(wait)
+                    continue
+                raise
+            except httpx.HTTPStatusError as e:
+                # non-retryable status or retries exhausted: raise with the body for diagnosis
+                body = e.response.text[:500] if e.response is not None else ""
+                raise httpx.HTTPStatusError(
+                    f"{e} | OpenRouter response: {body}",
+                    request=e.request, response=e.response,
+                ) from None
+
+        if resp is None:  # unreachable in practice
+            raise last_err or RuntimeError("generate_text: no response")
+
+        data = resp.json()
+
+        choices = data.get("choices") or []
+        if not choices:
+            return ""
+
+        choice = choices[0]
+        finish_reason = choice.get("finish_reason", "unknown")
+        message = choice.get("message") or {}
+        content = message.get("content") or ""
+
+        _llm_log.info(
+            f"[generate_text] finish_reason={finish_reason} "
+            f"content_len={len(content)} max_tokens={self.max_tokens}"
+        )
+        if finish_reason == "length":
+            _llm_log.warning(
+                f"[generate_text] RESPONSE TRUNCATED — hit max_tokens={self.max_tokens}. "
+                f"Increase max_tokens in config."
+            )
+
+        return str(content)
+
+    def generate_stream(
+        self, prompt: str, system_prompt: str | None = None,
+        messages: list[dict] | None = None,
+    ) -> Generator[str, None, None]:
+        """Stream tokens over SSE. `messages` may carry a structured multi-turn
+        conversation (system + per-role entries) instead of `prompt`."""
+        url, headers, payload = self._build_request(
+            prompt, system_prompt, stream=True, messages=messages,
+        )
+
+        with self._client.stream("POST", url, headers=headers, json=payload) as resp:
+            resp.raise_for_status()
+            for line in resp.iter_lines():
+                if not line or not line.startswith("data: "):
+                    continue
+                data_str = line[6:]  # strip "data: "
+                if data_str.strip() == "[DONE]":
+                    break
+                try:
+                    chunk = json.loads(data_str)
+                    delta = chunk.get("choices", [{}])[0].get("delta", {})
+                    token = delta.get("content", "")
+                    if token:
+                        yield token
+                except (json.JSONDecodeError, IndexError):
+                    continue
+
+    def stream_print(
+        self, prompt: str, system_prompt: str | None = None
+    ) -> str:
+        """Stream to stdout as tokens arrive; return the full text."""
+        full_text = []
+        for token in self.generate_stream(prompt, system_prompt):
+            print(token, end="", flush=True)
+            full_text.append(token)
+        print()  # final newline
+        return "".join(full_text)
+
+
+def create_llm_client(config: dict[str, Any], provider_override: str | None = None) -> LLMClient:
+    """Build an LLMClient from config["llm"].
+
+    Args:
+        config:            the loaded config dict
+        provider_override: use this llm.models entry instead of llm.provider
+    """
+    llm_cfg = config.get("llm", {})
+    provider = provider_override or llm_cfg.get("provider", "claude")
+    models_cfg = llm_cfg.get("models", {})
+    model_cfg = models_cfg.get(provider, {})
+
+    if not model_cfg:
+        available = list(models_cfg.keys())
+        raise RuntimeError(
+            f"no llm.models entry for provider={provider!r} in the config; "
+            f"available: {available}"
+        )
+
+    model = model_cfg.get("model")
+    base_url = model_cfg.get("base_url") or config.get("openrouter", {}).get("base_url")
+    api_key_env = (
+        model_cfg.get("api_key_env")
+        or config.get("openrouter", {}).get("api_key_env", "OPENROUTER_API_KEY")
+    )
+    api_key = os.getenv(api_key_env, "")
+
+    if not model:
+        raise RuntimeError(f"llm.models.{provider}.model is not set in the config")
+    if not base_url:
+        raise RuntimeError(f"llm.models.{provider}.base_url is not set in the config")
+    if not api_key:
+        raise RuntimeError(
+            f"environment variable {api_key_env} is not set; it must hold the API key "
+            f"for the {provider} model"
+        )
+
+    temperature = llm_cfg.get("temperature", 0.3)
+    max_tokens  = llm_cfg.get("max_tokens", 4096)
+
+    # Proxy: model-level override > global proxy config
+    proxy_cfg   = config.get("proxy", {})
+    proxy_url: str | None = None
+    if proxy_cfg.get("enabled", False):
+        proxy_url = proxy_cfg.get("https") or proxy_cfg.get("http")
+
+    return LLMClient(
+        base_url=base_url,
+        api_key=api_key,
+        model=model,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        proxy=proxy_url,
+    )
+

revit_api_docs/prompts/__init__.py

@@ -0,0 +1,5 @@
+"""Prompt templates used by the retriever (query rewriting) and the pipeline tools."""
+
+from .loader import load_prompt
+
+__all__ = ["load_prompt"]

revit_api_docs/prompts/loader.py

@@ -0,0 +1,20 @@
+"""Prompt template loader.
+
+Prompt text lives in this package so prompts can be reviewed and tuned without
+digging through runtime code.
+"""
+from __future__ import annotations
+
+from functools import lru_cache
+from pathlib import Path
+
+_PROMPT_DIR = Path(__file__).resolve().parent
+
+
+@lru_cache(maxsize=None)
+def load_prompt(name: str) -> str:
+    """Load a prompt template by filename from the prompts directory."""
+    if "/" in name or "\\" in name or name.startswith("."):
+        raise ValueError(f"Invalid prompt name: {name!r}")
+    path = _PROMPT_DIR / name
+    return path.read_text(encoding="utf-8")

revit_api_docs/prompts/pipeline.api_quality_stage1_no_html.md

@@ -0,0 +1,28 @@
+Audit the following parsed Revit API record for data quality.
+
+No raw HTML is available. Be conservative: without HTML you cannot know if missing fields are parser failures or absent source documentation. Only deduct for clearly detectable issues.
+
+## Score Criteria
+- -0.5 name/full_id indicates a constructor (`#ctor` or `Constructor`) -> noise.
+- -0.3 summary or info is clearly generic boilerplate.
+- -0.25 parameters field is empty but syntax shows the method takes arguments with actual parameter names.
+- -0.1 any field contains raw HTML tags, garbled text, or excessive whitespace.
+
+Do not deduct for empty summary/info, missing syntax, or missing parameters when source absence is plausible.
+
+Parsed record:
+  name        : {name}
+  full_id     : {full_id}
+  syntax      : {syntax}
+  summary     : {summary}
+  info        : {info}
+  parameters  : {parameters}
+
+Return ONLY a JSON object:
+{{
+  "quality_score": 0.8,
+  "issues": [],
+  "needs_rewrite": false
+}}
+
+Use threshold {threshold}. JSON only. No markdown. No explanation.

revit_api_docs/prompts/pipeline.api_quality_stage1_system.md

@@ -0,0 +1 @@
+You are a data-quality auditor for Revit API documentation records. You measure parse quality: how well the parser captured information that exists in the HTML. Always reply with a single valid JSON object and nothing else.

revit_api_docs/prompts/pipeline.api_quality_stage1_with_html.md

@@ -0,0 +1,35 @@
+Audit the following parsed Revit API record by comparing it against the raw HTML source.
+
+## Principle
+Measure parse quality, not documentation completeness. Only deduct points when the HTML source contains information that the parsed record is missing or captured incorrectly. If the HTML lacks a field, an empty parsed field is correct.
+
+## Score Criteria
+Cumulative deductions from 1.0, only when HTML evidence exists:
+- -0.5 name/full_id indicates a constructor (`#ctor` or `Constructor`) -> noise record.
+- -0.4 summary and info are both empty but HTML contains a real description.
+- -0.3 summary/info is generic boilerplate while HTML has a real description.
+- -0.25 parameters field is empty but HTML shows method parameters with descriptions.
+- -0.2 syntax/C# signature is missing but HTML contains a public C# signature.
+- -0.2 important HTML content such as description or return value is absent from parsed fields.
+- -0.15 all parameter types are `Unknown Type` but HTML has actual type information.
+- -0.1 any field contains raw HTML tags, garbled unicode, or excessive whitespace.
+
+Parsed record:
+  name        : {name}
+  full_id     : {full_id}
+  syntax      : {syntax}
+  summary     : {summary}
+  info        : {info}
+  parameters  : {parameters}
+
+Raw HTML excerpt:
+{html_excerpt}
+
+Return ONLY a JSON object:
+{{
+  "quality_score": 0.0,
+  "issues": ["short English issue strings"],
+  "needs_rewrite": true
+}}
+
+Use threshold {threshold}. JSON only. No markdown. No explanation.

revit_api_docs/prompts/pipeline.api_quality_stage2.md

@@ -0,0 +1,33 @@
+The following Revit API record has quality issues. Use the raw HTML as ground truth to produce corrected fields.
+
+Identified issues:
+{issues}
+
+Original parsed record:
+  name        : {name}
+  full_id     : {full_id}
+  syntax      : {syntax}
+  summary     : {summary}
+  info        : {info}
+  parameters  : {parameters}
+  remark      : {remark}
+
+Raw HTML excerpt:
+{html_excerpt}
+
+## Rules
+- Only include fields where you can make a genuine improvement based on HTML evidence.
+- If the original field already matches the HTML, do not include it.
+- If a field is empty in both the record and the HTML, omit it.
+- Do not fabricate content.
+- Keep output concise.
+
+Return ONLY a JSON object with improved fields:
+{{
+  "summary": "clear one-sentence English description",
+  "parameters": "one parameter per line, or empty string if none",
+  "syntax": "correct C# public signature from HTML",
+  "info": "concise description if summary is missing"
+}}
+
+Omit unchanged fields. JSON only. No markdown. No explanation.

revit_api_docs/prompts/pipeline.api_quality_stage2_system.md

@@ -0,0 +1 @@
+You are an expert Revit API documentation writer. Repair and improve incomplete or garbled API records using raw HTML as the authoritative reference. Always reply with a single valid JSON object and nothing else.

revit_api_docs/prompts/pipeline.rewrite_query.md

@@ -0,0 +1,21 @@
+You are a Revit API expert. Given a user query, possibly in Chinese, extract all relevant Revit API class names, method names, properties, enums, and English technical keywords.
+
+## Rules
+1. Translate non-English domain terms to exact Revit API equivalents.
+2. Entity nouns are primary search targets. Action verbs are secondary qualifiers.
+3. Strip natural-language filler words and focus on API entities.
+4. Be exhaustive: include parent classes, related interfaces, relevant enum types, BuiltInParameter, and BuiltInCategory names.
+5. Include full namespace paths when useful, for example `Autodesk.Revit.DB.Wall`.
+6. Include method signatures, property names, and likely overload terms.
+7. Think about what a developer would search for when implementing this feature.
+8. Output ONLY a JSON object.
+
+## Examples
+- "结构柱" -> {{"keywords": "structural column FamilyInstance BuiltInCategory.OST_StructuralColumns NewFamilyInstance StructuralType", "api_terms": ["FamilyInstance", "FamilySymbol", "NewFamilyInstance", "StructuralType", "BuiltInCategory.OST_StructuralColumns", "Level", "XYZ"]}}
+- "创建墙体" -> {{"keywords": "create wall Wall.Create WallType Level Line CurveLoop", "api_terms": ["Wall", "Wall.Create", "WallType", "WallUtils", "CurtainGrid", "Line.CreateBound", "Level"]}}
+- "i want get wall created api" -> {{"keywords": "Wall Wall.Create WallType Level Line", "api_terms": ["Wall", "Wall.Create", "WallType", "WallUtils", "Line.CreateBound", "Level", "FilteredElementCollector"]}}
+- "获取房间面积" -> {{"keywords": "room area Room get_Area SpatialElement BoundarySegment", "api_terms": ["Room", "SpatialElement", "Area", "Room.Area", "Room.get_BoundarySegments", "SpatialElementBoundaryOptions"]}}
+- "修改墙类型" -> {{"keywords": "change wall type WallType ChangeTypeId Element.ChangeTypeId GetTypeId", "api_terms": ["Element.ChangeTypeId", "Element.GetTypeId", "WallType", "FilteredElementCollector", "Wall"]}}
+- "Part" -> {{"keywords": "Part PartUtils PartMaker CreateParts DivideParts PartType", "api_terms": ["Part", "PartUtils", "PartMaker", "PartUtils.CreateParts", "PartUtils.AreElementsValidForCreateParts"]}}
+
+User query: {query}

revit_api_docs/prompts/pipeline.rewrite_query_system.md

@@ -0,0 +1 @@
+You are a Revit API keyword extractor. Output JSON only.

revit_api_docs/prompts/pipeline.sdk_extract_readme_system.md

@@ -0,0 +1 @@
+You are an AI assistant specializing in codebase analysis and extracting structured data from technical documentation.

revit_api_docs/prompts/pipeline.sdk_extract_readme_user.md

@@ -0,0 +1,22 @@
+# Role
+You are an AI assistant specializing in codebase analysis and extracting structured data from technical documentation.
+
+# Goal
+Parse the provided ReadMe text to extract key identifiers for code. Output will be used programmatically by an automated code retrieval system.
+
+# Instructions
+1. Carefully analyze the text provided.
+2. Extract:
+   - `target_files`: all project source filenames explicitly mentioned.
+   - `key_classes_and_methods`: custom class or method names responsible for core functionality.
+   - `mentioned_apis`: key API classes from external frameworks such as `Autodesk.Revit.DB.View`.
+3. Return a single strict JSON object.
+4. If no information is found for a field, use an empty list `[]`.
+5. Output only raw JSON. No markdown. No explanation.
+
+# Example
+Input: "This tool is in `Processor.cs`. Core logic is in `DataParser` using `Autodesk.Revit.DB.Transaction`."
+Output: {{"target_files": ["Processor.cs"], "key_classes_and_methods": ["DataParser"], "mentioned_apis": ["Autodesk.Revit.DB.Transaction"]}}
+
+# README Content
+{readme_text}

revit_api_docs/prompts/pipeline.sdk_golden_code.md

@@ -0,0 +1,32 @@
+# Role
+You are an expert C# software architect and technical writer specializing in the Autodesk Revit API.
+
+# Goal
+Analyze the ReadMe context and raw C# code details. Identify the single most relevant code block representing the core functionality described in the ReadMe, then synthesize it into a clean, reusable, documented Golden Code Snippet for a RAG knowledge base.
+
+# Context
+<ReadMeContext>
+{readme_summary}
+</ReadMeContext>
+
+<RawCodeDetails>
+{detail_code_analysis}
+</RawCodeDetails>
+
+# Instructions
+1. Read `<ReadMeContext>` to understand the project's main purpose and key APIs.
+2. Examine `<RawCodeDetails>` and select the one method or block that most directly implements the core functionality.
+3. Remove UI interaction code, logging/debugging, generic file I/O unless core, and `IExternalCommand.Execute` boilerplate.
+4. Refactor for reuse with a clear method signature, typed parameters, and hardcoded values converted to parameters.
+5. Keep Transaction handling appropriate for standalone SDK examples.
+6. Generate XML documentation comments.
+7. Output one complete syntactically correct C# method block.
+
+# Output
+Return ONLY a JSON object:
+{{
+  "summary": "One sentence English description of what this code demonstrates and which Revit APIs it uses.",
+  "content": "The complete clean C# method with XML documentation comments."
+}}
+
+JSON only. No markdown. No explanation outside JSON.

revit_api_docs/prompts/pipeline.sdk_golden_code_system.md

@@ -0,0 +1 @@
+You are an expert C# software architect and technical writer specializing in the Autodesk Revit API. You identify core logic and refactor it into clear, concise, educational code examples. Always reply with a single valid JSON object and nothing else.

revit_api_docs/prompts/pipeline.sdk_quality_file_batch.md

@@ -0,0 +1,17 @@
+Analyze these C# files from the Revit SDK project "{project_name}".
+
+Project context: {project_summary}
+
+{file_sections}
+
+Return a JSON array with one object per file in the same order:
+[
+  {{
+    "filename": "exact filename",
+    "file_purpose": "1-sentence English description of what this file does",
+    "key_classes": ["ClassName1", "ClassName2"],
+    "key_methods": ["MethodName1 - brief description", "MethodName2 - brief description"]
+  }}
+]
+
+JSON array only. No markdown. No explanation.

revit_api_docs/prompts/pipeline.sdk_quality_file_system.md

@@ -0,0 +1 @@
+You are a Revit SDK code analyst. Analyze C# source files and extract metadata. Always reply with a single valid JSON array and nothing else.

revit_api_docs/prompts/pipeline.sdk_quality_project.md

@@ -0,0 +1,20 @@
+Analyze this Revit SDK sample project.
+
+Project name: {project_name}
+Number of C# files: {file_count}
+
+README content:
+{readme}
+
+File listing with code previews:
+{file_previews}
+
+Return a JSON object with:
+{{
+  "project_summary": "2-3 sentence English description of what this project demonstrates",
+  "api_classes_used": ["main Revit API classes/types used"],
+  "key_patterns": ["design patterns demonstrated"],
+  "use_case_category": "geometry|family|view|structure|mep|annotation|export|utility|ui|analysis|database|other"
+}}
+
+JSON only. No markdown. No explanation.

revit_api_docs/prompts/pipeline.sdk_quality_project_system.md

@@ -0,0 +1 @@
+You are a Revit SDK code analyst. Analyze C# sample projects that demonstrate Revit API usage patterns. Always reply with a single valid JSON object and nothing else.