mcpscraper-memory-sdk 0.28.0__tar.gz → 0.28.2__tar.gz

{mcpscraper_memory_sdk-0.28.0 → mcpscraper_memory_sdk-0.28.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mcpscraper-memory-sdk
-Version: 0.28.0
+Version: 0.28.2
 Summary: Official Python clients for all 259 mcpscraper.dev MCP tools and the direct 114-tool memory API
 Project-URL: Repository, https://github.com/VilovietaSEO/mcpscraper-sdk
 License-Expression: MIT

{mcpscraper_memory_sdk-0.28.0 → mcpscraper_memory_sdk-0.28.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcpscraper-memory-sdk"
-version = "0.28.0"
+version = "0.28.2"
 description = "Official Python clients for all 259 mcpscraper.dev MCP tools and the direct 114-tool memory API"
 readme = "README.md"
 license = "MIT"
@@ -25,3 +25,6 @@ build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/mcpscraper_memory"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/mcpscraper_memory", "README.md", "pyproject.toml"]

{mcpscraper_memory_sdk-0.28.0 → mcpscraper_memory_sdk-0.28.2}/src/mcpscraper_memory/mcp_client.py

@@ -37,7 +37,7 @@ class McpToolsClient(GeneratedMcpToolsClient):
         session: requests.Session | None = None,
         list_retries: int = 2,
         retry_delay_s: float = 0.25,
-        request_timeout: float = 300.0,
+        request_timeout: float = 590.0,
     ) -> None:
         self._api_key = api_key
         self._base_url = base_url.rstrip("/")
@@ -74,7 +74,7 @@ class McpToolsClient(GeneratedMcpToolsClient):
                 envelope = {
                     "error_code": "mcp_request_timeout",
                     "error_type": "timeout",
-                    "message": f"MCP request exceeded {self._request_timeout:g}s and was cancelled client-side. The operation may still be running.",
+                    "message": f"The client stopped waiting after {self._request_timeout:g}s. This does not prove server-side work stopped; poll a known job when one exists.",
                     "retryable": True,
                 }
                 raise McpToolError(envelope["message"], http_status=408, tool_error=envelope) from error

{mcpscraper_memory_sdk-0.28.0 → mcpscraper_memory_sdk-0.28.2}/src/mcpscraper_memory/mcp_models/harvest_paa.py

@@ -11,7 +11,7 @@ class HarvestPaaInput(BaseModel):
     gl: str | None = Field(None, alias="gl", description="Google country code inferred from location or user language.")
     hl: str | None = Field(None, alias="hl", description="Google interface/content language inferred from the user request.")
     device: Literal['desktop', 'mobile'] | None = Field(None, alias="device", description="SERP device context. Use mobile only for mobile rankings.")
-    idempotency_key: str | None = Field(None, alias="idempotencyKey", description="Retry key: reuse after a timeout to avoid re-billing. New key per harvest.")
+    idempotency_key: str | None = Field(None, alias="idempotencyKey", description="Optional duplicate-start key. Reuse it only after an uncertain or lost response to the same logical call; use a new key for an intentional retry after a terminal failure. This is not the run identifier.")
     serp_identity: str | None = Field(None, alias="serpIdentity", description="Optional persistent SERP identity created with serp_identity_create. Reuses the same saved browser state and fixed network address across calls.")
     include_all_serp_features: bool | None = Field(None, alias="includeAllSerpFeatures", description="Capture every optional same-page SERP surface: local pack, forums, videos, AI Overview/AI Mode, and What People Are Saying.")
     include_local_pack: bool | None = Field(None, alias="includeLocalPack", description="Include Google local/map-pack businesses and merge their entity IDs.")

mcpscraper_memory_sdk-0.28.0/scripts/generate_models.py

@@ -1,156 +0,0 @@
-import json
-import keyword
-import re
-import shutil
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parents[3]
-MANIFEST_PATH = REPO_ROOT / "contracts" / "memory.tools.json"
-PACKAGE_ROOT = Path(__file__).resolve().parents[1]
-MODELS_DIR = PACKAGE_ROOT / "src" / "mcpscraper_memory" / "models"
-CLIENT_GENERATED_PATH = PACKAGE_ROOT / "src" / "mcpscraper_memory" / "_generated_client.py"
-
-CATEGORIES = [
-    "access", "capture", "channels", "facts", "graph", "library", "memory", "recall",
-    "schedule", "storage", "tables", "tags", "vaults", "video", "webhooks",
-]
-
-
-def to_snake_case(value: str) -> str:
-    value = re.sub(r"[-\s]+", "_", value)
-    value = re.sub(r"(?<!^)(?=[A-Z])", "_", value)
-    snake = value.lower().strip("_")
-    return f"{snake}_" if keyword.iskeyword(snake) else snake
-
-
-def derive_method_name(legacy_id: str, category: str) -> str:
-    for candidate in (category, category.rstrip("s")):
-        prefix = f"{candidate}-"
-        if legacy_id.startswith(prefix) and len(legacy_id) > len(prefix):
-            return to_snake_case(legacy_id[len(prefix):])
-    return to_snake_case(legacy_id)
-
-
-def to_pascal_case(value: str) -> str:
-    parts = re.split(r"[-_\s]+", value)
-    return "".join(p[0].upper() + p[1:] for p in parts if p)
-
-
-def json_type_to_python(schema: dict, class_name_hint: str) -> str:
-    if "enum" in schema:
-        literal_values = ", ".join(json.dumps(v) for v in schema["enum"])
-        return f"Literal[{literal_values}]"
-    json_type = schema.get("type")
-    if json_type == "string":
-        return "str"
-    if json_type == "integer":
-        return "int"
-    if json_type == "number":
-        return "float"
-    if json_type == "boolean":
-        return "bool"
-    if json_type == "array":
-        item_schema = schema.get("items", {})
-        item_type = json_type_to_python(item_schema, class_name_hint)
-        return f"list[{item_type}]"
-    if json_type == "object" or "properties" in schema:
-        return "dict[str, Any]"
-    return "Any"
-
-
-def field_definition(name: str, schema: dict, required: bool, class_name_hint: str) -> str:
-    py_type = json_type_to_python(schema, class_name_hint)
-    if not required:
-        py_type = f"{py_type} | None"
-    description = schema.get("description", "").replace('"', '\\"')
-    default = "None" if not required else "..."
-    return f'    {to_snake_case(name)}: {py_type} = Field({default}, alias="{name}", description="{description}")'
-
-
-def render_model(class_name: str, schema: dict) -> str:
-    properties = schema.get("properties", {}) or {}
-    required = set(schema.get("required", []) or [])
-    if not properties:
-        return f"class {class_name}(BaseModel):\n    model_config = ConfigDict(populate_by_name=True, extra=\"allow\")\n"
-    lines = [f"class {class_name}(BaseModel):", '    model_config = ConfigDict(populate_by_name=True, extra="allow")', ""]
-    for prop_name, prop_schema in properties.items():
-        lines.append(field_definition(prop_name, prop_schema, prop_name in required, class_name))
-    return "\n".join(lines) + "\n"
-
-
-def main() -> None:
-    manifest = json.loads(MANIFEST_PATH.read_text())
-    tools = manifest["tools"]
-
-    shutil.rmtree(MODELS_DIR, ignore_errors=True)
-    MODELS_DIR.mkdir(parents=True, exist_ok=True)
-    (MODELS_DIR / "__init__.py").write_text("")
-
-    by_category: dict[str, list[dict]] = {}
-    for tool in tools:
-        by_category.setdefault(tool["category"], []).append(tool)
-
-    for tool in tools:
-        legacy = tool["legacyId"]
-        module_name = to_snake_case(legacy)
-        input_class = to_pascal_case(legacy) + "Input"
-        output_class = to_pascal_case(legacy) + "Output"
-
-        content = [
-            "from typing import Any, Literal",
-            "from pydantic import BaseModel, ConfigDict, Field",
-            "",
-            "",
-            render_model(input_class, tool["inputSchema"]),
-            "",
-            render_model(output_class, tool["outputSchema"]),
-        ]
-        (MODELS_DIR / f"{module_name}.py").write_text("\n".join(content))
-
-    namespace_blocks = []
-    import_lines = []
-    for category in CATEGORIES:
-        class_name = to_pascal_case(category) + "Namespace"
-        method_blocks = []
-        used_names: set[str] = set()
-        for tool in by_category.get(category, []):
-            legacy = tool["legacyId"]
-            wire_name = tool["name"]
-            module_name = to_snake_case(legacy)
-            input_class = to_pascal_case(legacy) + "Input"
-            output_class = to_pascal_case(legacy) + "Output"
-            method_name = derive_method_name(legacy, category)
-            if method_name in used_names:
-                method_name = to_snake_case(legacy)
-            used_names.add(method_name)
-
-            import_lines.append(
-                f"from .models.{module_name} import {input_class}, {output_class}"
-            )
-            method_blocks.append(
-                f'    def {method_name}(self, **kwargs: Any) -> {output_class}:\n'
-                f'        payload = {input_class}(**kwargs).model_dump(by_alias=True, exclude_none=True)\n'
-                f'        result = self._call_tool("{wire_name}", payload)\n'
-                f'        return {output_class}.model_validate(result)\n'
-            )
-        namespace_blocks.append(
-            f"class {class_name}:\n"
-            f"    def __init__(self, call_tool):\n"
-            f"        self._call_tool = call_tool\n\n"
-            + "\n".join(method_blocks)
-        )
-
-    generated = (
-        "from typing import Any, Callable\n\n"
-        + "\n".join(sorted(set(import_lines)))
-        + "\n\n\n"
-        + "\n\n".join(namespace_blocks)
-        + "\n"
-    )
-    CLIENT_GENERATED_PATH.write_text(generated)
-
-    print(f"Generated {len(tools)} tool model pairs across {len(by_category)} categories.")
-
-
-if __name__ == "__main__":
-    main()

mcpscraper_memory_sdk-0.28.0/tests/test_client.py

@@ -1,263 +0,0 @@
-import json
-
-import pytest
-import responses
-
-from mcpscraper_memory import MemoryClient, MemoryApiError, McpToolsClient
-from mcpscraper_memory._mcp_generated_client import MCP_TOOL_BINDINGS, MCP_TOOL_COUNT
-from mcpscraper_memory.models.create_scheduled_action import (
-    CreateScheduledActionInput,
-    CreateScheduledActionOutput,
-)
-from mcpscraper_memory.mcp_models.update_scheduled_action import (
-    UpdateScheduledActionInput as UnifiedUpdateScheduledActionInput,
-)
-from mcpscraper_memory.models.get_schedule_link import GetScheduleLinkOutput
-from mcpscraper_memory.models.get_schedule_status import GetScheduleStatusOutput
-from mcpscraper_memory.models.resume_scheduled_action import ResumeScheduledActionOutput
-from mcpscraper_memory.models.set_schedule_entitlement import SetScheduleEntitlementInput
-
-BASE_URL = "https://memory.mcpscraper.dev"
-
-
-@responses.activate
-def test_memory_search_sends_correct_wire_tool_name_and_parses_structured_content():
-    captured = {}
-
-    def handler(request):
-        captured["body"] = json.loads(request.body)
-        return (
-            200,
-            {},
-            json.dumps(
-                {
-                    "jsonrpc": "2.0",
-                    "id": captured["body"]["id"],
-                    "result": {"structuredContent": {"ok": True, "results": [{"text": "hello", "source": "note:a", "score": 0.9}]}},
-                }
-            ),
-        )
-
-    responses.add_callback(responses.POST, f"{BASE_URL}/mcp", callback=handler, content_type="application/json")
-
-    client = MemoryClient(api_key="mk_test")
-    result = client.memory.search(query="hello world")
-
-    assert captured["body"]["method"] == "tools/call"
-    assert captured["body"]["params"]["name"] == "searchTool"
-    assert captured["body"]["params"]["arguments"] == {"query": "hello world"}
-    assert result.ok is True
-    assert result.results[0]["text"] == "hello"
-
-
-@responses.activate
-def test_mcp_tools_client_preserves_native_image_content():
-    responses.add(
-        responses.POST,
-        "https://mcpscraper.dev/mcp",
-        json={
-            "jsonrpc": "2.0",
-            "id": 1,
-            "result": {
-                "content": [
-                    {"type": "text", "text": "# Creative"},
-                    {"type": "image", "data": "iVBORw0KGgo=", "mimeType": "image/png"},
-                ],
-                "structuredContent": {"ok": True},
-            },
-        },
-        status=200,
-    )
-    result = McpToolsClient(api_key="sk_test").call_tool_result(
-        "meta_ad_creative_media", {"connectionId": "conn_1", "adId": "12345"}
-    )
-    assert result["content"][1]["type"] == "image"
-    assert result["content"][1]["data"] == "iVBORw0KGgo="
-
-
-@responses.activate
-def test_access_headers_include_accept_and_authorization():
-    captured = {}
-
-    def handler(request):
-        captured["headers"] = dict(request.headers)
-        captured["body"] = json.loads(request.body)
-        vault = {"vault": "Ideas", "handle": "Ideas", "role": "owner", "notes": 3, "bytes": 1024, "kind": "notes"}
-        return (200, {}, json.dumps({"jsonrpc": "2.0", "id": 1, "result": {"structuredContent": {"ok": True, "vaults": [vault]}}}))
-
-    responses.add_callback(responses.POST, f"{BASE_URL}/mcp", callback=handler, content_type="application/json")
-
-    client = MemoryClient(api_key="mk_test")
-    result = client.vaults.list_vaults()
-
-    assert captured["headers"]["accept"] == "application/json, text/event-stream"
-    assert captured["headers"]["authorization"] == "Bearer mk_test"
-    assert captured["body"]["params"]["name"] == "listVaultsTool"
-    assert result.ok is True
-
-
-@responses.activate
-def test_json_rpc_error_raises_memory_api_error():
-    responses.add(
-        responses.POST,
-        f"{BASE_URL}/mcp",
-        json={"jsonrpc": "2.0", "id": 1, "error": {"code": -32602, "message": "Invalid params"}},
-        status=200,
-    )
-
-    client = MemoryClient(api_key="mk_test")
-    with pytest.raises(MemoryApiError, match="Invalid params"):
-        client.memory.search(query="x")
-
-
-@responses.activate
-def test_mcp_tool_level_is_error_raises_memory_api_error():
-    responses.add(
-        responses.POST,
-        f"{BASE_URL}/mcp",
-        json={
-            "jsonrpc": "2.0",
-            "id": 1,
-            "result": {"content": [{"type": "text", "text": json.dumps({"message": "vault not found"})}], "isError": True},
-        },
-        status=200,
-    )
-
-    client = MemoryClient(api_key="mk_test")
-    with pytest.raises(MemoryApiError, match="vault not found"):
-        client.vaults.list_vaults()
-
-
-@responses.activate
-def test_non_2xx_http_response_raises_memory_api_error():
-    responses.add(responses.POST, f"{BASE_URL}/mcp", body="server error", status=500)
-
-    client = MemoryClient(api_key="mk_test")
-    with pytest.raises(MemoryApiError) as exc_info:
-        client.memory.search(query="x")
-    assert exc_info.value.http_status == 500
-
-
-def test_unified_bindings_contain_every_contract_tool():
-    assert MCP_TOOL_COUNT == len(MCP_TOOL_BINDINGS)
-    names = {binding["name"] for binding in MCP_TOOL_BINDINGS}
-    assert len(set(names)) == MCP_TOOL_COUNT
-    assert {
-        "export_connected_service_data",
-        "export_search_console_table_data",
-        "renew_connected_data_download",
-        "describe_service_connection_tool",
-        "import_service_connection_to_memory",
-        "archive_read",
-        "list_scheduled_runs",
-        "create_artifact_template",
-        "create_scheduled_run_view_link",
-    } <= names
-
-
-def test_direct_scheduling_models_match_the_credit_metered_contract():
-    create_input = CreateScheduledActionInput(
-        description="Sync Drive",
-        vault="Knowledge",
-        cadence="daily",
-        executionMode="connection_sync",
-    )
-    assert create_input.execution_mode == "connection_sync"
-
-    create_output = CreateScheduledActionOutput(
-        ok=True,
-        executionMode="agent",
-        artifactSelection={"mode": "none"},
-    )
-    assert create_output.execution_mode == "agent"
-    assert "code" in CreateScheduledActionOutput.model_fields
-    assert "code" in GetScheduleLinkOutput.model_fields
-    assert "code" in GetScheduleStatusOutput.model_fields
-    assert "code" in ResumeScheduledActionOutput.model_fields
-    assert {
-        "billing_mode",
-        "run_base_credits",
-        "llm_cost_multiplier",
-        "default_timezone",
-    } <= set(GetScheduleStatusOutput.model_fields)
-
-    entitlement = SetScheduleEntitlementInput(granteeIdentity="owner@example.com")
-    assert entitlement.enabled is None
-
-    pinned_update = UnifiedUpdateScheduledActionInput(
-        id="schedule_1",
-        artifactSelection={
-            "mode": "saved_template",
-            "templateId": "00000000-0000-4000-8000-000000000001",
-            "templateVersionId": "00000000-0000-4000-8000-000000000002",
-        },
-    )
-    assert pinned_update.artifact_selection["mode"] == "saved_template"
-
-
-@responses.activate
-def test_scheduled_results_and_templates_use_exact_unified_wire_names():
-    captured = []
-
-    def handler(request):
-        body = json.loads(request.body)
-        captured.append(body)
-        if body["params"]["name"] == "list_scheduled_runs":
-            result = {"ok": True, "items": [], "nextCursor": None}
-        else:
-            result = {"ok": True, "presets": [], "templates": []}
-        return (
-            200,
-            {},
-            json.dumps(
-                {
-                    "jsonrpc": "2.0",
-                    "id": body["id"],
-                    "result": {"structuredContent": result},
-                }
-            ),
-        )
-
-    responses.add_callback(
-        responses.POST,
-        "https://mcpscraper.dev/mcp",
-        callback=handler,
-        content_type="application/json",
-    )
-
-    client = McpToolsClient(api_key="sk_test")
-    runs = client.schedule.list_scheduled_runs(view="inbox", limit=30)
-    templates = client.schedule.list_artifact_templates(status="all")
-
-    assert captured[0]["params"] == {
-        "name": "list_scheduled_runs",
-        "arguments": {"view": "inbox", "limit": 30},
-    }
-    assert captured[1]["params"] == {
-        "name": "list_artifact_templates",
-        "arguments": {"status": "all"},
-    }
-    assert runs.next_cursor is None
-    assert templates.templates == []
-
-
-@responses.activate
-def test_memory_package_unified_client_calls_scraper_and_memory_tools():
-    session_result = {
-        "ok": True,
-        "tool": "browser_list_sessions",
-        "session_id": None,
-        "sessions": [],
-        "count": 0,
-    }
-    responses.add(
-        responses.POST,
-        "https://mcpscraper.dev/mcp",
-        json={"jsonrpc": "2.0", "id": 1, "result": {"structuredContent": session_result}},
-        status=200,
-    )
-    client = McpToolsClient(api_key="sk_test")
-    result = client.browser.list_sessions()
-    sent_body = json.loads(responses.calls[0].request.body)
-    assert sent_body["params"]["name"] == "browser_list_sessions"
-    assert result.model_dump(by_alias=True) == session_result