anywidget-vector 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

anywidget_vector/backends/qdrant/__init__.py

@@ -0,0 +1,26 @@
+"""Qdrant backend adapter.
+
+Query Format (JSON):
+    # Similarity search
+    {"vector": [0.1, 0.2, 0.3], "limit": 10}
+
+    # With filter
+    {
+        "vector": [0.1, 0.2, 0.3],
+        "filter": {"must": [{"key": "category", "match": {"value": "tech"}}]},
+        "limit": 10
+    }
+
+    # Recommend by ID
+    {"recommend": {"positive": ["point_123"]}, "limit": 10}
+
+    # Get by IDs
+    {"ids": ["point_1", "point_2"]}
+
+    # Scroll/filter only
+    {"filter": {"must": [...]}, "limit": 100}
+"""
+
+from anywidget_vector.backends.qdrant.converter import build_filter, to_points
+
+__all__ = ["to_points", "build_filter"]

anywidget_vector/backends/qdrant/client.js

@@ -0,0 +1,61 @@
+// Qdrant browser-side client
+
+export async function executeQuery(query, config) {
+  const { url, apiKey, collection } = config;
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers["api-key"] = apiKey;
+
+  const parsed = typeof query === "string" ? JSON.parse(query) : query;
+  let endpoint, body;
+
+  if (parsed.ids) {
+    endpoint = `${url}/collections/${collection}/points`;
+    body = { ids: parsed.ids, with_payload: true, with_vectors: true };
+  } else if (parsed.recommend) {
+    endpoint = `${url}/collections/${collection}/points/recommend`;
+    body = {
+      positive: parsed.recommend.positive || [],
+      negative: parsed.recommend.negative || [],
+      limit: parsed.limit || 10,
+      with_payload: true,
+      with_vectors: true,
+    };
+  } else if (parsed.vector) {
+    endpoint = `${url}/collections/${collection}/points/search`;
+    body = {
+      vector: parsed.vector,
+      filter: parsed.filter,
+      limit: parsed.limit || 10,
+      with_payload: true,
+      with_vectors: true,
+      score_threshold: parsed.score_threshold,
+    };
+  } else if (parsed.filter) {
+    endpoint = `${url}/collections/${collection}/points/scroll`;
+    body = {
+      filter: parsed.filter,
+      limit: parsed.limit || 100,
+      with_payload: true,
+      with_vectors: true,
+    };
+  } else {
+    throw new Error("Invalid query: need vector, ids, recommend, or filter");
+  }
+
+  const resp = await fetch(endpoint, { method: "POST", headers, body: JSON.stringify(body) });
+  if (!resp.ok) throw new Error(`Qdrant error: ${await resp.text()}`);
+  return await resp.json();
+}
+
+export function toPoints(response) {
+  const results = response.result || response.points || [];
+  return results.map(r => ({
+    id: String(r.id),
+    score: r.score,
+    x: r.vector?.[0] ?? r.payload?.x ?? 0,
+    y: r.vector?.[1] ?? r.payload?.y ?? 0,
+    z: r.vector?.[2] ?? r.payload?.z ?? 0,
+    vector: r.vector,
+    ...r.payload,
+  }));
+}

anywidget_vector/backends/qdrant/converter.py

@@ -0,0 +1,83 @@
+"""Qdrant result conversion and filter building."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def to_points(response: dict[str, Any]) -> list[dict[str, Any]]:
+    """Convert Qdrant response to points format.
+
+    Args:
+        response: Qdrant API response
+
+    Returns:
+        List of point dicts with id, x, y, z, and metadata
+    """
+    results = response.get("result") or response.get("points") or []
+
+    points = []
+    for r in results:
+        point: dict[str, Any] = {"id": str(r.get("id", ""))}
+
+        if "score" in r:
+            point["score"] = r["score"]
+
+        vector = r.get("vector")
+        payload = r.get("payload", {})
+
+        if vector:
+            point["x"] = float(vector[0]) if len(vector) > 0 else 0
+            point["y"] = float(vector[1]) if len(vector) > 1 else 0
+            point["z"] = float(vector[2]) if len(vector) > 2 else 0
+            point["vector"] = vector
+        else:
+            point["x"] = float(payload.get("x", 0))
+            point["y"] = float(payload.get("y", 0))
+            point["z"] = float(payload.get("z", 0))
+
+        point.update(payload)
+        points.append(point)
+
+    return points
+
+
+def build_filter(conditions: list[tuple[str, str, Any]]) -> dict[str, Any]:
+    """Build Qdrant filter from conditions.
+
+    Args:
+        conditions: List of (field, operator, value) tuples
+            Operators: =, !=, >, >=, <, <=, ~, :
+
+    Returns:
+        Qdrant filter dict
+
+    Example:
+        >>> build_filter([("category", "=", "tech"), ("year", ">", 2020)])
+        {"must": [
+            {"key": "category", "match": {"value": "tech"}},
+            {"key": "year", "range": {"gt": 2020}}
+        ]}
+    """
+    must = []
+
+    for field, op, value in conditions:
+        if op == "=":
+            must.append({"key": field, "match": {"value": value}})
+        elif op == "!=":
+            # Qdrant doesn't have direct != so we use must_not
+            continue  # Handle separately
+        elif op == ">":
+            must.append({"key": field, "range": {"gt": value}})
+        elif op == ">=":
+            must.append({"key": field, "range": {"gte": value}})
+        elif op == "<":
+            must.append({"key": field, "range": {"lt": value}})
+        elif op == "<=":
+            must.append({"key": field, "range": {"lte": value}})
+        elif op == "~":
+            must.append({"key": field, "match": {"text": value}})
+        elif op == ":":
+            must.append({"key": field, "match": {"any": [value]}})
+
+    return {"must": must} if must else {}

anywidget_vector/backends/weaviate/__init__.py

@@ -0,0 +1,33 @@
+"""Weaviate backend adapter.
+
+Query Format (GraphQL):
+    # Get all with limit
+    { Get { Article(limit: 10) { title _additional { id vector } } } }
+
+    # Near vector search
+    {
+      Get {
+        Article(nearVector: {vector: [0.1, 0.2, ...]}, limit: 10) {
+          title
+          _additional { id vector distance }
+        }
+      }
+    }
+
+    # With where filter
+    {
+      Get {
+        Article(
+          where: {path: ["category"], operator: Equal, valueText: "tech"}
+          limit: 10
+        ) { title _additional { id } }
+      }
+    }
+
+    # Near text (requires text2vec module)
+    { Get { Article(nearText: {concepts: ["AI"]}, limit: 10) { ... } } }
+"""
+
+from anywidget_vector.backends.weaviate.converter import build_where, to_points
+
+__all__ = ["to_points", "build_where"]

anywidget_vector/backends/weaviate/client.js

@@ -0,0 +1,50 @@
+// Weaviate browser-side client
+
+export async function executeQuery(query, config) {
+  const { url, apiKey } = config;
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+
+  // Query is GraphQL string
+  const graphql = typeof query === "string" ? query : JSON.stringify(query);
+
+  const resp = await fetch(`${url}/v1/graphql`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ query: graphql }),
+  });
+
+  if (!resp.ok) throw new Error(`Weaviate error: ${await resp.text()}`);
+  const data = await resp.json();
+
+  if (data.errors) {
+    throw new Error(`GraphQL error: ${data.errors[0].message}`);
+  }
+
+  return data;
+}
+
+export function toPoints(response, className) {
+  const data = response?.data?.Get?.[className] || [];
+
+  return data.map((item, i) => {
+    const additional = item._additional || {};
+    const vector = additional.vector || [];
+
+    const point = {
+      id: additional.id || `point_${i}`,
+      score: additional.distance ? 1 - additional.distance : undefined,
+      x: vector[0] ?? item.x ?? 0,
+      y: vector[1] ?? item.y ?? 0,
+      z: vector[2] ?? item.z ?? 0,
+      vector: vector.length ? vector : undefined,
+    };
+
+    // Add other fields
+    for (const [k, v] of Object.entries(item)) {
+      if (k !== "_additional") point[k] = v;
+    }
+
+    return point;
+  });
+}

anywidget_vector/backends/weaviate/converter.py

@@ -0,0 +1,81 @@
+"""Weaviate result conversion and filter building."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def to_points(response: dict[str, Any], class_name: str) -> list[dict[str, Any]]:
+    """Convert Weaviate GraphQL response to points format."""
+    data = response.get("data", {}).get("Get", {}).get(class_name, [])
+
+    points = []
+    for i, item in enumerate(data):
+        additional = item.get("_additional", {})
+        point: dict[str, Any] = {"id": additional.get("id", f"point_{i}")}
+
+        if "distance" in additional:
+            point["score"] = 1 - additional["distance"]
+
+        vector = additional.get("vector", [])
+        if vector:
+            point["x"] = float(vector[0]) if len(vector) > 0 else 0
+            point["y"] = float(vector[1]) if len(vector) > 1 else 0
+            point["z"] = float(vector[2]) if len(vector) > 2 else 0
+            point["vector"] = vector
+
+        # Add all other fields except _additional
+        for k, v in item.items():
+            if k != "_additional":
+                point[k] = v
+
+        points.append(point)
+
+    return points
+
+
+def build_where(conditions: list[tuple[str, str, Any]]) -> dict[str, Any]:
+    """Build Weaviate where filter from conditions.
+
+    Weaviate operators: Equal, NotEqual, GreaterThan, GreaterThanEqual,
+                        LessThan, LessThanEqual, Like, ContainsAny
+    """
+    op_map = {
+        "=": "Equal",
+        "!=": "NotEqual",
+        ">": "GreaterThan",
+        ">=": "GreaterThanEqual",
+        "<": "LessThan",
+        "<=": "LessThanEqual",
+        "~": "Like",
+        ":": "ContainsAny",
+    }
+
+    if len(conditions) == 0:
+        return {}
+
+    if len(conditions) == 1:
+        field, op, value = conditions[0]
+        return _single_condition(field, op_map.get(op, "Equal"), value)
+
+    # Multiple conditions: AND them together
+    operands = [_single_condition(f, op_map.get(o, "Equal"), v) for f, o, v in conditions]
+    return {"operator": "And", "operands": operands}
+
+
+def _single_condition(field: str, operator: str, value: Any) -> dict[str, Any]:
+    """Build single where condition."""
+    result = {"path": [field], "operator": operator}
+
+    if isinstance(value, str):
+        result["valueText"] = value
+    elif isinstance(value, bool):
+        result["valueBoolean"] = value
+    elif isinstance(value, int):
+        result["valueInt"] = value
+    elif isinstance(value, float):
+        result["valueNumber"] = value
+    elif isinstance(value, list):
+        result["valueText"] = value  # For ContainsAny
+
+    return result

anywidget_vector/static/icons.js

@@ -0,0 +1,14 @@
+// SVG Icons for anywidget-vector UI
+export const ICONS = {
+  play: '<svg viewBox="0 0 24 24" fill="currentColor"><polygon points="5,3 19,12 5,21"/></svg>',
+  settings: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="3"/><path d="M12 1v4M12 19v4M4.22 4.22l2.83 2.83M16.95 16.95l2.83 2.83M1 12h4M19 12h4M4.22 19.78l2.83-2.83M16.95 7.05l2.83-2.83"/></svg>',
+  close: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>',
+  search: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>',
+  vector: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 2L2 7l10 5 10-5-10-5zM2 17l10 5 10-5M2 12l10 5 10-5"/></svg>',
+  filter: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polygon points="22,3 2,3 10,12.46 10,19 14,21 14,12.46"/></svg>',
+  id: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="4" width="18" height="16" rx="2"/><line x1="7" y1="9" x2="17" y2="9"/><line x1="7" y1="13" x2="13" y2="13"/></svg>',
+  text: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="4,7 4,4 20,4 20,7"/><line x1="9" y1="20" x2="15" y2="20"/><line x1="12" y1="4" x2="12" y2="20"/></svg>',
+  loader: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10" stroke-dasharray="31.4" stroke-dashoffset="10"/></svg>',
+  cube: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><polyline points="3.27,6.96 12,12.01 20.73,6.96"/><line x1="12" y1="22.08" x2="12" y2="12"/></svg>',
+  reset: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/><path d="M3 3v5h5"/></svg>',
+};

anywidget_vector/traitlets.py

@@ -0,0 +1,84 @@
+"""Traitlet definitions for VectorSpace widget."""
+
+from __future__ import annotations
+
+import traitlets
+
+
+class VectorSpaceTraits(traitlets.HasTraits):
+    """All traitlets for the VectorSpace widget, grouped logically."""
+
+    # === Data ===
+    points = traitlets.List(trait=traitlets.Dict()).tag(sync=True)
+
+    # === Display ===
+    width = traitlets.Int(default_value=800).tag(sync=True)
+    height = traitlets.Int(default_value=600).tag(sync=True)
+    background = traitlets.Unicode(default_value="#1a1a2e").tag(sync=True)
+
+    # === Axes and Grid ===
+    show_axes = traitlets.Bool(default_value=True).tag(sync=True)
+    show_grid = traitlets.Bool(default_value=True).tag(sync=True)
+    axis_labels = traitlets.Dict(default_value={"x": "X", "y": "Y", "z": "Z"}).tag(sync=True)
+    grid_divisions = traitlets.Int(default_value=10).tag(sync=True)
+
+    # === Color Mapping ===
+    color_field = traitlets.Unicode(default_value=None, allow_none=True).tag(sync=True)
+    color_scale = traitlets.Unicode(default_value="viridis").tag(sync=True)
+    color_domain = traitlets.List(default_value=None, allow_none=True).tag(sync=True)
+
+    # === Size Mapping ===
+    size_field = traitlets.Unicode(default_value=None, allow_none=True).tag(sync=True)
+    size_range = traitlets.List(default_value=[0.02, 0.1]).tag(sync=True)
+
+    # === Shape Mapping ===
+    shape_field = traitlets.Unicode(default_value=None, allow_none=True).tag(sync=True)
+    shape_map = traitlets.Dict(default_value={}).tag(sync=True)
+
+    # === Camera ===
+    camera_position = traitlets.List(default_value=[2, 2, 2]).tag(sync=True)
+    camera_target = traitlets.List(default_value=[0, 0, 0]).tag(sync=True)
+
+    # === Interaction ===
+    selected_points = traitlets.List(default_value=[]).tag(sync=True)
+    hovered_point = traitlets.Dict(default_value=None, allow_none=True).tag(sync=True)
+    selection_mode = traitlets.Unicode(default_value="click").tag(sync=True)
+
+    # === Tooltip ===
+    show_tooltip = traitlets.Bool(default_value=True).tag(sync=True)
+    tooltip_fields = traitlets.List(default_value=["label", "x", "y", "z"]).tag(sync=True)
+
+    # === Performance ===
+    use_instancing = traitlets.Bool(default_value=True).tag(sync=True)
+    point_budget = traitlets.Int(default_value=100000).tag(sync=True)
+
+    # === Distance Metrics and Connections ===
+    distance_metric = traitlets.Unicode(default_value="euclidean").tag(sync=True)
+    show_connections = traitlets.Bool(default_value=False).tag(sync=True)
+    k_neighbors = traitlets.Int(default_value=0).tag(sync=True)
+    distance_threshold = traitlets.Float(default_value=None, allow_none=True).tag(sync=True)
+    reference_point = traitlets.Unicode(default_value=None, allow_none=True).tag(sync=True)
+    connection_color = traitlets.Unicode(default_value="#ffffff").tag(sync=True)
+    connection_opacity = traitlets.Float(default_value=0.3).tag(sync=True)
+
+    # === UI Visibility ===
+    show_toolbar = traitlets.Bool(default_value=False).tag(sync=True)
+    show_settings = traitlets.Bool(default_value=False).tag(sync=True)
+    show_properties = traitlets.Bool(default_value=False).tag(sync=True)
+
+    # === Backend Configuration ===
+    backend = traitlets.Unicode(default_value="qdrant").tag(sync=True)
+    backend_config = traitlets.Dict(default_value={}).tag(sync=True)
+    connection_status = traitlets.Unicode(default_value="disconnected").tag(sync=True)
+
+    # === Query Parameters ===
+    query_type = traitlets.Unicode(default_value="text").tag(sync=True)
+    query_input = traitlets.Unicode(default_value="").tag(sync=True)
+    query_limit = traitlets.Int(default_value=100).tag(sync=True)
+    query_error = traitlets.Unicode(default_value=None, allow_none=True).tag(sync=True)
+
+    # === Embedding Configuration ===
+    embedding_config = traitlets.Dict(default_value={}).tag(sync=True)
+
+    # === Internal Triggers ===
+    _execute_query = traitlets.Int(default_value=0).tag(sync=True)

anywidget_vector/ui/__init__.py

@@ -0,0 +1,206 @@
+"""UI module aggregation - loads CSS and JS components."""
+
+from pathlib import Path
+
+_UI_DIR = Path(__file__).parent
+_STATIC_DIR = _UI_DIR.parent / "static"
+_BACKENDS_DIR = _UI_DIR.parent / "backends"
+
+
+def _read_file(path: Path) -> str:
+    """Read file contents."""
+    return path.read_text(encoding="utf-8")
+
+
+def get_css() -> str:
+    """Get aggregated CSS."""
+    return _read_file(_UI_DIR / "styles.css")
+
+
+def get_esm() -> str:
+    """Get aggregated ESM JavaScript.
+
+    Combines all UI components into a single module.
+    """
+    # Read component files
+    icons_js = _read_file(_STATIC_DIR / "icons.js")
+    constants_js = _read_file(_UI_DIR / "constants.js")
+    toolbar_js = _read_file(_UI_DIR / "toolbar.js")
+    settings_js = _read_file(_UI_DIR / "settings.js")
+    properties_js = _read_file(_UI_DIR / "properties.js")
+    canvas_js = _read_file(_UI_DIR / "canvas.js")
+
+    # Read browser-side backend clients
+    qdrant_client = _read_file(_BACKENDS_DIR / "qdrant" / "client.js")
+    pinecone_client = _read_file(_BACKENDS_DIR / "pinecone" / "client.js")
+    weaviate_client = _read_file(_BACKENDS_DIR / "weaviate" / "client.js")
+
+    # Build combined ESM
+    esm = f"""
+// === Auto-generated ESM bundle for anywidget-vector ===
+import * as THREE from "https://esm.sh/three@0.160.0";
+import {{ OrbitControls }} from "https://esm.sh/three@0.160.0/addons/controls/OrbitControls.js";
+
+// === Icons ===
+{_strip_imports_exports(icons_js)}
+
+// === Constants ===
+{_strip_imports_exports(constants_js)}
+
+// === Backend Clients ===
+// Qdrant
+{_rename_functions(qdrant_client, "qdrant")}
+
+// Pinecone
+{_rename_functions(pinecone_client, "pinecone")}
+
+// Weaviate
+{_rename_functions(weaviate_client, "weaviate")}
+
+// Unified query executor
+async function executeBackendQuery(model) {{
+  const backend = model.get("backend");
+  const query = model.get("query_input");
+  const config = model.get("backend_config") || {{}};
+
+  let response, points;
+
+  if (backend === "qdrant") {{
+    response = await qdrantExecute(query, config);
+    points = qdrantToPoints(response);
+  }} else if (backend === "pinecone") {{
+    response = await pineconeExecute(query, config);
+    points = pineconeToPoints(response);
+  }} else if (backend === "weaviate") {{
+    const className = config.className || config.class || "Vector";
+    response = await weaviateExecute(query, config);
+    points = weaviateToPoints(response, className);
+  }} else {{
+    throw new Error(`Browser backend not supported: ${{backend}}`);
+  }}
+
+  return points;
+}}
+
+// === Toolbar ===
+{_strip_imports_exports(toolbar_js)}
+
+// === Settings Panel ===
+{_strip_imports_exports(settings_js)}
+
+// === Properties Panel ===
+{_strip_imports_exports(properties_js)}
+
+// === Canvas (Three.js) ===
+{_strip_imports_exports(canvas_js)}
+
+// === Main Render Function ===
+function render({{ model, el }}) {{
+  const wrapper = document.createElement("div");
+  wrapper.className = "avs-wrapper";
+  wrapper.style.width = model.get("width") + "px";
+  el.appendChild(wrapper);
+
+  let settingsPanel = null;
+  let propertiesPanel = null;
+  let toolbarUI = null;
+
+  if (model.get("show_toolbar")) {{
+    toolbarUI = createToolbar(model, {{
+      onRunQuery: () => runQuery(),
+      onToggleSettings: () => settingsPanel?.toggle(),
+      onToggleProperties: () => propertiesPanel?.toggle(),
+    }});
+    wrapper.appendChild(toolbarUI.element);
+  }}
+
+  const main = document.createElement("div");
+  main.className = "avs-main";
+  main.style.height = model.get("height") + "px";
+  wrapper.appendChild(main);
+
+  const canvasContainer = document.createElement("div");
+  canvasContainer.className = "avs-canvas-container";
+  canvasContainer.style.width = "100%";
+  canvasContainer.style.height = "100%";
+  main.appendChild(canvasContainer);
+
+  if (model.get("show_settings")) {{
+    settingsPanel = createSettingsPanel(model, {{
+      onClose: () => settingsPanel?.close(),
+    }});
+    main.appendChild(settingsPanel.element);
+  }}
+
+  if (model.get("show_properties")) {{
+    propertiesPanel = createPropertiesPanel(model, {{
+      onClose: () => propertiesPanel?.close(),
+    }});
+    main.appendChild(propertiesPanel.element);
+  }}
+
+  const canvas = createCanvas(model, canvasContainer, {{}});
+
+  async function runQuery() {{
+    if (toolbarUI) toolbarUI.setLoading(true);
+
+    try {{
+      model.set("query_error", null);
+      model.set("connection_status", "connecting");
+      model.save_changes();
+
+      const backend = model.get("backend");
+      const backendInfo = BACKENDS[backend];
+
+      if (backendInfo && backendInfo.side === "browser") {{
+        const points = await executeBackendQuery(model);
+        model.set("points", points);
+        model.set("connection_status", "connected");
+        model.save_changes();
+      }} else {{
+        model.set("_execute_query", Date.now());
+        model.save_changes();
+      }}
+    }} catch (err) {{
+      model.set("query_error", err.message);
+      model.set("connection_status", "error");
+      model.save_changes();
+      console.error("Query error:", err);
+    }} finally {{
+      if (toolbarUI) toolbarUI.setLoading(false);
+    }}
+  }}
+
+  return () => {{ canvas.cleanup(); }};
+}}
+
+export default {{ render }};
+"""
+    return esm
+
+
+def _strip_imports_exports(code: str) -> str:
+    """Remove import and export statements from JS code."""
+    lines = []
+    for line in code.split("\n"):
+        stripped = line.strip()
+        if stripped.startswith("import "):
+            continue
+        if stripped.startswith("export function "):
+            line = line.replace("export function ", "function ")
+        elif stripped.startswith("export async function "):
+            line = line.replace("export async function ", "async function ")
+        elif stripped.startswith("export const "):
+            line = line.replace("export const ", "const ")
+        elif stripped.startswith("export default"):
+            continue
+        lines.append(line)
+    return "\n".join(lines)
+
+
+def _rename_functions(code: str, prefix: str) -> str:
+    """Strip imports/exports and rename functions with prefix."""
+    code = _strip_imports_exports(code)
+    code = code.replace("function executeQuery", f"async function {prefix}Execute")
+    code = code.replace("function toPoints", f"function {prefix}ToPoints")
+    return code