queryview 0.0.2__py3-none-any.whl

queryview/yamlio.py

@@ -0,0 +1,245 @@
+"""YAML export/import of predefined queries and dashboards — one entity at a
+time or a whole workspace as a single bundle. Every exported document is
+self-describing via a top-level `kind` (query | dashboard | workspace), so
+import dispatches on file content, never on the filename. Import validates the
+whole document before writing anything, then upserts (same overwrite semantics
+as gitsync restore). This module also owns the entity <-> plain-mapping codec
+and the YAML dumper that gitsync's per-entity repo files build on.
+Docs: docs/export-import.md."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import yaml
+
+from .validation import cell_view_error, presentation_error
+from .workspaces import WorkspaceRec
+
+
+class YamlIOError(Exception):
+    """Export/import failure carrying an HTTP-ish status for the API layer:
+    400 malformed document, 404 entity not found."""
+
+    def __init__(self, message: str, status: int = 400):
+        super().__init__(message)
+        self.status = status
+
+
+# --- Dumper (also used by gitsync's per-entity files) -----------------------
+
+
+def _repr_str(dumper: yaml.SafeDumper, data: str):
+    # Multiline strings (SQL, HTML, cell_view) as literal blocks for readable
+    # files and diffs.
+    style = "|" if "\n" in data else None
+    return dumper.represent_scalar("tag:yaml.org,2002:str", data, style=style)
+
+
+class _Dumper(yaml.SafeDumper):
+    pass
+
+
+_Dumper.add_representer(str, _repr_str)
+
+
+def dump_yaml(data: Any) -> str:
+    return yaml.dump(data, Dumper=_Dumper, sort_keys=False, allow_unicode=True)
+
+
+_SAFE = set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._ -")
+
+
+def slug(name: str) -> str:
+    """Filesystem-safe name: percent-encode (UTF-8) anything outside
+    [A-Za-z0-9._ -] plus a leading dot. Used for export download filenames and
+    gitsync repo paths; the canonical name lives inside the YAML — readers
+    trust the file content, never the path."""
+    out: list[str] = []
+    for i, ch in enumerate(name):
+        if ch in _SAFE and not (ch == "." and i == 0):
+            out.append(ch)
+        else:
+            out.append("".join(f"%{b:02X}" for b in ch.encode("utf-8")))
+    return "".join(out)
+
+
+# --- Entity <-> mapping codec (shared with gitsync) -------------------------
+
+
+def query_to_data(row: dict[str, Any]) -> dict[str, Any]:
+    """One predefined-query row (list_predefined_queries shape: order_by/fields
+    as JSON text) as its exported mapping. None/empty keys are omitted."""
+    data: dict[str, Any] = {"query_name": row["query_name"], "query": row["query"]}
+    if row.get("cell_view"):
+        data["cell_view"] = row["cell_view"]
+    if row.get("order_by"):
+        data["order_by"] = json.loads(row["order_by"])
+    if row.get("fields"):
+        data["fields"] = json.loads(row["fields"])
+    return data
+
+
+def _require_str(data: dict[str, Any], key: str, where: str) -> str:
+    value = data.get(key)
+    if not isinstance(value, str) or not value.strip():
+        raise YamlIOError(f"malformed {where}: {key} must be a non-empty string")
+    return value
+
+
+def query_from_data(data: Any, where: str = "query file") -> dict[str, Any]:
+    """Validate a query mapping back to the DB row shape save_predefined_query
+    takes (order_by/fields re-serialized to JSON text or None)."""
+    if not isinstance(data, dict):
+        raise YamlIOError(f"malformed {where}: expected a mapping")
+    query_name = _require_str(data, "query_name", where)
+    query = _require_str(data, "query", where)
+    cell_view = data.get("cell_view")
+    ob, fl = data.get("order_by"), data.get("fields")
+    perr = cell_view_error(cell_view) or presentation_error(ob, fl)
+    if perr is not None:
+        raise YamlIOError(f"malformed {where}: {perr}")
+    return {
+        "query_name": query_name,
+        "query": query,
+        "cell_view": cell_view or None,
+        "order_by": json.dumps(ob) if ob else None,
+        "fields": json.dumps(fl) if fl else None,
+    }
+
+
+def dashboard_to_data(d: dict[str, Any]) -> dict[str, Any]:
+    """One dashboard (get_dashboard shape) as its exported mapping. Keys are
+    listed explicitly to pin the document format independently of what the
+    store accessors happen to return."""
+    return {
+        "name": d["name"],
+        "connection": d["connection"],
+        "html": d["html"],
+        "queries": d["queries"] or {},
+    }
+
+
+def dashboard_from_data(data: Any, where: str = "dashboard file", require_html: bool = True) -> dict[str, Any]:
+    """Validate a dashboard mapping back to the upsert_dashboard shape.
+    gitsync passes require_html=False: its repo format stores the HTML as a
+    separate file that may legitimately be absent/empty."""
+    if not isinstance(data, dict):
+        raise YamlIOError(f"malformed {where}: expected a mapping")
+    name = _require_str(data, "name", where)
+    connection = _require_str(data, "connection", where)
+    html = _require_str(data, "html", where) if require_html else str(data.get("html") or "")
+    queries = data.get("queries") or {}
+    if not isinstance(queries, dict) or not all(isinstance(k, str) and isinstance(v, str) for k, v in queries.items()):
+        raise YamlIOError(f"malformed {where}: queries must be a {{name: SQL}} map")
+    return {"name": name, "connection": connection, "html": html, "queries": queries}
+
+
+# --- Import documents -------------------------------------------------------
+
+
+def _parse_query_entry(data: Any, where: str = "query document") -> dict[str, Any]:
+    """A query import entry: the shared codec row plus the `type` key export
+    documents carry (gitsync files get it from the repo path instead)."""
+    if not isinstance(data, dict):
+        raise YamlIOError(f"malformed {where}: expected a mapping")
+    return {"type": _require_str(data, "type", where), **query_from_data(data, where)}
+
+
+def parse_document(text: str) -> tuple[str, Any]:
+    """Parse + validate an import document. Returns (kind, payload): for
+    kind 'query'/'dashboard' the payload is one parsed entry; for 'workspace'
+    a {'queries': [...], 'dashboards': [...]} pair of parsed entries."""
+    try:
+        data = yaml.safe_load(text)
+    except yaml.YAMLError as e:
+        raise YamlIOError(f"malformed YAML: {e}") from e
+    if not isinstance(data, dict):
+        raise YamlIOError("malformed document: expected a YAML mapping")
+    kind = data.get("kind")
+    if kind == "query":
+        return "query", _parse_query_entry(data)
+    if kind == "dashboard":
+        return "dashboard", dashboard_from_data(data, "dashboard document")
+    if kind == "workspace":
+        raw_queries = data.get("queries") or []
+        raw_dashboards = data.get("dashboards") or []
+        if not isinstance(raw_queries, list) or not isinstance(raw_dashboards, list):
+            raise YamlIOError("malformed workspace document: queries and dashboards must be lists")
+        return "workspace", {
+            "queries": [_parse_query_entry(q, f"workspace queries[{i}]") for i, q in enumerate(raw_queries)],
+            "dashboards": [dashboard_from_data(d, f"workspace dashboards[{i}]") for i, d in enumerate(raw_dashboards)],
+        }
+    raise YamlIOError("malformed document: kind must be 'query', 'dashboard' or 'workspace'")
+
+
+# --- Services ---------------------------------------------------------------
+
+
+async def export(kind: str, name: str, conn_type: str, ws: WorkspaceRec) -> tuple[str, str]:
+    """Export dispatch shared by every caller (REST today, MCP/CLI tomorrow):
+    validates kind/name/conn_type, loads the document, and owns the
+    `{slug}.{kind}.yaml` download-filename convention. Returns (filename, text)."""
+    if kind not in ("query", "dashboard", "workspace") or (kind != "workspace" and not name):
+        raise YamlIOError("kind ('query'|'dashboard'|'workspace') and (for entities) name are required")
+    if kind == "query":
+        if not conn_type:
+            raise YamlIOError("conn_type is required for queries")
+        return f"{slug(name)}.query.yaml", await export_query(conn_type, name, ws.id)
+    if kind == "dashboard":
+        return f"{slug(name)}.dashboard.yaml", await export_dashboard(name, ws.id)
+    return f"{slug(ws.name)}.workspace.yaml", await export_workspace(ws.id)
+
+
+async def export_query(conn_type: str, name: str, workspace_id: int) -> str:
+    from .queries import get_predefined_query
+
+    row = await get_predefined_query(conn_type, name, workspace_id)
+    if row is None:
+        raise YamlIOError(f"query {name!r} not found", status=404)
+    return dump_yaml({"kind": "query", "type": conn_type, **query_to_data(row)})
+
+
+async def export_dashboard(name: str, workspace_id: int) -> str:
+    from .dashboards import get_dashboard
+
+    d = await get_dashboard(name, workspace_id)
+    if d is None:
+        raise YamlIOError(f"dashboard {name!r} not found", status=404)
+    return dump_yaml({"kind": "dashboard", **dashboard_to_data(d)})
+
+
+async def export_workspace(workspace_id: int) -> str:
+    """The whole workspace (every predefined query and dashboard) as one
+    bundle. Empty workspaces export a valid, importable empty bundle."""
+    from .dashboards import list_dashboards_full
+    from .queries import list_all_predefined_queries
+
+    queries = await list_all_predefined_queries(workspace_id)
+    dashboards = await list_dashboards_full(workspace_id)
+    return dump_yaml(
+        {
+            "kind": "workspace",
+            "queries": [{"type": r["type"], **query_to_data(r)} for r in queries],
+            "dashboards": [dashboard_to_data(d) for d in dashboards],
+        }
+    )
+
+
+async def import_text(text: str, workspace_id: int) -> dict[str, Any]:
+    """Import a document into a workspace, upserting by name. The whole
+    document is validated before the first write, so a malformed file changes
+    nothing; each entity family then writes in a single transaction. Returns
+    {'kind', 'queries', 'dashboards'} counts."""
+    from .dashboards import upsert_dashboards
+    from .queries import save_predefined_queries
+
+    kind, payload = parse_document(text)
+    queries = payload["queries"] if kind == "workspace" else [payload] if kind == "query" else []
+    dashboards = payload["dashboards"] if kind == "workspace" else [payload] if kind == "dashboard" else []
+    if queries:
+        await save_predefined_queries(queries, workspace_id=workspace_id)
+    if dashboards:
+        await upsert_dashboards(dashboards, workspace_id=workspace_id)
+    return {"kind": kind, "queries": len(queries), "dashboards": len(dashboards)}

queryview-0.0.2.dist-info/METADATA

@@ -0,0 +1,183 @@
+Metadata-Version: 2.5
+Name: queryview
+Version: 0.0.2
+Summary: QueryView: FastAPI + SQLModel backend and React SPA over the ClickHouse HTTP interface
+Project-URL: Homepage, https://github.com/kolodkin/queryview
+Project-URL: Repository, https://github.com/kolodkin/queryview
+Project-URL: Issues, https://github.com/kolodkin/queryview/issues
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: aiosqlite>=0.22.1
+Requires-Dist: alembic>=1.13
+Requires-Dist: asyncpg>=0.29
+Requires-Dist: cryptography>=42
+Requires-Dist: duckdb>=1.0
+Requires-Dist: fastapi>=0.110
+Requires-Dist: httpx>=0.27
+Requires-Dist: mcp<2,>=1.9
+Requires-Dist: pyyaml>=6
+Requires-Dist: sqlalchemy[asyncio]>=2.0
+Requires-Dist: sqlmodel>=0.0.16
+Requires-Dist: uvicorn>=0.29
+Description-Content-Type: text/markdown
+
+# QueryView
+
+Project skeleton: **Python** backend (**FastAPI + SQLModel**) + **Vite + React + TypeScript** SPA frontend with **Tailwind CSS**, plus **[Playwright](https://playwright.dev)** end-to-end tests.
+
+## Quick start
+
+Run the released package — API + bundled SPA on http://localhost:8000:
+
+```bash
+uvx queryview
+```
+
+`--port` (or the `PORT` env var) picks the listen port, default 8000:
+`uvx queryview --port 9000`.
+
+Or run the container image — every release publishes
+`ghcr.io/kolodkin/queryview` to GHCR for `linux/amd64` and `linux/arm64`, tagged
+`vX.Y.Z` and (for non-pre-releases) `latest`:
+
+```bash
+docker run -p 8000:8000 ghcr.io/kolodkin/queryview:latest
+```
+
+To serve on a different host port, remap it (the container keeps listening on
+8000, which its healthcheck probes): `docker run -p 9000:8000 ...`.
+
+State (the SQLite DB and its encryption key) lives in `/home/queryview`; mount a
+volume there to persist it across containers:
+`docker run -p 8000:8000 -v queryview-data:/home/queryview ghcr.io/kolodkin/queryview:latest`.
+
+## Layout
+
+```
+.
+├── backend/         # Python FastAPI + SQLModel app exposing /api/* (queryview package)
+├── frontend/        # Vite + React + TS + Tailwind v4 SPA (npm workspace)
+├── e2e/             # Playwright (pytest) browser tests
+├── pyproject.toml   # Backend deps + console script + e2e `test` group (uv)
+└── package.json     # npm workspace root: dev orchestration + frontend build
+```
+
+## Prerequisites
+
+- [uv](https://docs.astral.sh/uv/) — runs the Python backend and the Playwright
+  (pytest) e2e suite (it manages the Python toolchain and dependencies for you).
+- [Node.js](https://nodejs.org) 20+ (with npm) — runs the root tasks and the
+  Vite frontend.
+
+npm runs the frontend and the root task scripts; uv handles the backend's and
+e2e suite's Python virtualenv and dependencies.
+
+## Install
+
+Install the backend's Python dependencies (uv reads the root `pyproject.toml`;
+the package lives in `backend/queryview`):
+
+```bash
+uv sync
+```
+
+Install the JavaScript dependencies for the frontend workspace:
+
+```bash
+npm install
+```
+
+Install the e2e tooling (the `test` dependency group) and fetch the Playwright
+browser:
+
+```bash
+uv sync --group test
+uv run --group test playwright install chromium
+```
+
+## Run dev servers
+
+Run backend and frontend together:
+
+```bash
+npm run dev
+```
+
+Or individually:
+
+```bash
+npm run backend    # uvicorn --reload on http://localhost:8000
+npm run frontend   # http://localhost:5173
+```
+
+The Vite dev server proxies `/api/*` to the FastAPI backend, so the SPA can call the API on the same origin.
+
+## Build & preview production
+
+```bash
+npm run build      # produces frontend/dist/
+npm run start      # SERVE_STATIC=1, FastAPI serves dist/ + /api on :8000
+npm run preview    # build && start in one shot
+```
+
+In production there is no Vite — the FastAPI backend serves the bundled SPA from `frontend/dist/` and falls back to `index.html` for any unknown non-`/api` path so client-side routing works. Override the dist location with `STATIC_ROOT=/path/to/dist`.
+
+## End-to-end tests
+
+The e2e suite is [pytest-playwright](https://playwright.dev/python/docs/test-runners),
+installed via the `test` dependency group and run through `uv`.
+
+Start the dev servers (`npm run dev`) in one terminal, then in another:
+
+```bash
+uv run --group test pytest
+```
+
+Override the target URL with `BASE_URL=http://localhost:4173 uv run --group test pytest` (e.g. to test a built preview). To run the full suite against a real ClickHouse the way CI does, use `scripts/setup.sh`.
+
+## Release to PyPI
+
+The **Publish to PyPI** workflow (`.github/workflows/publish.yaml`, manual
+dispatch with a `vX.Y.Z` tag input) builds the SPA into the wheel
+(`queryview/static/`), then gates the release on the installed wheel: an HTTP
+smoke test, the packaged backend test suite (`pytest --pyargs queryview`), and
+the Playwright e2e suite driving the packaged server (skippable via the
+`skip-e2e` input for emergencies). It then publishes
+[`queryview`](https://pypi.org/project/queryview/) via PyPI trusted publishing,
+pushes the tag, and creates the GitHub release. The package version comes
+from the tag (no version bump in `pyproject.toml`).
+
+An installed wheel serves the bundled UI by default — see
+[Quick start](#quick-start).
+
+## MCP server
+
+The backend mounts a FastMCP server (Streamable HTTP) at
+`http://localhost:8000/mcp`. There is nothing extra to start — it runs inside
+the server process (`uvx queryview`, `npm run dev`, ...). Hook up an MCP client,
+e.g.:
+
+```bash
+claude mcp add --transport http queryview http://localhost:8000/mcp
+```
+
+Tools: `run_query` (read-only SQL, rows returned to the agent), `push_query`
+and `push_dashboard` (fill a live browser session), `list_queries` /
+`list_dashboards`, and `git_store` / `git_history` / `git_restore` (workspace
+git backups). The push tools target an **armed** browser session: enable
+"Allow remote control" from the agent icon next to the connection pill and use
+the session id it shows. See [docs/remote.md](docs/remote.md) for the full
+protocol.
+
+## API
+
+See [docs/api.md](docs/api.md) for the full endpoint reference.
+
+The single-page prompt UI is described in [docs/queryview.md](docs/queryview.md);
+connecting (`new <type>` / `connect <name>`), SQLite persistence, and session
+auto-connect are specified in [docs/connect.md](docs/connect.md).
+
+Connections are stored in SQLite (`backend/queryview.db`, override with
+`DB_PATH`); the backend writes that file and a local password-encryption key
+(`backend/queryview.db.key`, override with `DB_KEY_PATH`).

queryview-0.0.2.dist-info/RECORD

@@ -0,0 +1,54 @@
+queryview/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+queryview/conftest.py,sha256=TJpnXRopAQufqXpCIizcC2p-eJML9I70gaji_3MxV_k,2918
+queryview/connect.py,sha256=97r_XtBdLJ_-LqhERlxrepgP-dYYJ4_puF9Mv6S8oPQ,14724
+queryview/dashboard_queries.py,sha256=Q2DbHSjIr8h9p5Y3HMo3oNNrbbfaiGW8colBCSD5Bh8,2770
+queryview/dashboards.py,sha256=az92sJBYy6jBheyd186sqNoPVELRPoLGbmWyl0J_pQg,6075
+queryview/gitsync.py,sha256=UCHNpJPWAFnOat2nGlgq_TPM_g64ZlYcxXAVMgiSp0o,14367
+queryview/main.py,sha256=I_YyNRRAPgiFWqY_VvlolOayByWSRt4JLLoderrbDcI,27701
+queryview/mcp_server.py,sha256=E8DhTrisom7xAXJ3F-qIQzrV-gVG4Qp5Sq_7wuBHpCY,11603
+queryview/queries.py,sha256=isGYoUMShr1B9dXdwiozzqavRXfeFsIj9Mjs1U04b88,6148
+queryview/remote.py,sha256=gdt5O_3x53M0ZP3Z-gnm3zi_Jx-0BbdJHoFhNlT_FBk,5090
+queryview/test_api_db.py,sha256=6QOlyZK9OsrVm0foz7M32S4M2Qv_sdGjNHnjV3v4OC4,1897
+queryview/test_api_export_import.py,sha256=EJ32EBBoN2EXbyV-v1H0E9AumPc2qzX1EU0893dbaJY,3690
+queryview/test_api_gitsync.py,sha256=KtD3yxWQ7UyGV8S260N4Ez86l4oMg3NgQ5hxRrtVIfk,2731
+queryview/test_api_workspaces.py,sha256=yyn6ib6s3B0TnTnLCAd1T1k5ev-kBGtkWtzINfaGpEU,1700
+queryview/test_connect_flow.py,sha256=P37kTaGXDxXOAYXvR5LMbp7k2_XIacP4YcTnnIwpVT0,4454
+queryview/test_connect_store.py,sha256=lxu3Yg5rQlza4HBWsvJ7LNJYo8dB0xD_DwXMNRkoUx4,1065
+queryview/test_dashboards.py,sha256=ib9jJ-ueMF02LR3mvYIigSmdZ5N9wA_01Ww2UljskMo,8075
+queryview/test_gitsync.py,sha256=T5j4AHxMMseIKsMvdsQqWrbKgJp8qTKcq8QoTGmR78s,13053
+queryview/test_main.py,sha256=k5YuxmwfU0zemzbF2ktdCSiLes8vYUu7LPoW8gAiWHY,504
+queryview/test_mcp_gitsync.py,sha256=UU1n0ic9jY-c4jDzlV-IUZO7j9SIVIMfwOGImzQMEL8,2328
+queryview/test_migrations.py,sha256=QVPnQYBkOzLGGEowJxHeUzQVYcYlBwFq348TAzNKxLs,3380
+queryview/test_queries.py,sha256=Mm264HqBzDKZ1A0aRf_ol8aSOA5hAyzSG7nC1Ji10rk,5694
+queryview/test_remote.py,sha256=1p9J2yNdJ94rfk2rHqEZ32T4kJpaYcMEXZVVP_GNDoQ,7980
+queryview/test_validation.py,sha256=HzxpThEQ31sH35-GJZ7xN0tuuWYgjUCXexuJxZXJoSU,3221
+queryview/test_workspaces.py,sha256=uQig4cay59p_-EgHUJdn0OefLH1hAj-Vh21GHnSMt7k,3546
+queryview/test_yamlio.py,sha256=3WxqkB2ACSYXP_Xpss6bD_cdBYR_FbZFgmFmfMFR3Wk,7325
+queryview/validation.py,sha256=CtwKtRpvErdfJ4ruIC6Hlno85g_-11pBwD4JnNbjDOg,5098
+queryview/workspaces.py,sha256=FsXWBT6iM3qC8Uql2MULZDyg2CLYfZzF0G6opjY6LZo,6182
+queryview/yamlio.py,sha256=DyiiWuOWIkCGaMWu54GnPNoDEZ7T6lyCVAgYLL26Gss,10548
+queryview/drivers/__init__.py,sha256=msOh2EgJtGE-Qus1sCLbtin_cXwmNgCFz33o_C0cU3E,359
+queryview/drivers/base.py,sha256=KlL3XIqvbGB_GnDWvuRuMpdXqs0_JUpKuPNhFOEJrQ0,6626
+queryview/drivers/clickhouse.py,sha256=Lw71Ujvl5znVFzLNHlB5-N6f1k4OanwpPZPj4cxNn-w,4938
+queryview/drivers/duckdb.py,sha256=wgGamLKSlwN_egR_3osNgwk6JhKhv2T9BHoY0L3pMZU,5641
+queryview/drivers/postgres.py,sha256=NSy1_eXAR1ui0BMd2P8b1buUKo07jK2MrrI1qFZnoDI,6044
+queryview/drivers/test_base.py,sha256=VfABajT8ej4BDtv3OAoMPuPXCkdTrLAeDCvddni7Ud0,1808
+queryview/drivers/test_clickhouse.py,sha256=PqR5J275VTWRWXRmwyL1NVaFAs6o5t7HZ_0FpWA1oIY,1963
+queryview/drivers/test_contract.py,sha256=m1i6jKt7_pRiCASKA7TgNcrNgImZBMOFRlDwx0ebmJE,2671
+queryview/drivers/test_duckdb.py,sha256=Zh4Grr8lo6QYRxOzL73T8lZXp4RjjGzPpBFwfTJGloU,2565
+queryview/drivers/test_postgres.py,sha256=lnjKqbTdZq0qkZuMDLR_dCHAn2ucekNhag_Ya-YFvSQ,2534
+queryview/migrations/env.py,sha256=BLN0lYLwBT-Gl5nAGQSmlPWdEQ-NQubC8Ap6EXJuuGw,1419
+queryview/migrations/script.py.mako,sha256=I8FVdur13rxBM8AzY-PHgpIpwtuXxbgquD6QHTzSeQI,687
+queryview/migrations/versions/9a536b7c0328_initial_schema.py,sha256=UoF755Xi7usJ1ic8TArFA1FDqVE-1AnQcLC-201_2pk,3888
+queryview/migrations/versions/a1b2c3d4e5f6_connection_config_blob.py,sha256=cqulYLtwC0l3ePGELD13IRJ9IizmfQThcOPv06bGvO8,2393
+queryview/migrations/versions/b2c3d4e5f6a7_predefined_presentation.py,sha256=oIbxmPwoied62M5pPuGCszt2Ou_bn2vyyM3pNVzM9xE,942
+queryview/migrations/versions/c7d8e9f0a1b2_workspaces.py,sha256=XfO6F0ZwbKTT_JUYrAEA33OS31ohFVT2MCufAzbSZN8,3897
+queryview/static/favicon.svg,sha256=zurDhDS-ejtND2i4zYqiua54wmDWNDCHxuCV-AMc5P8,9523
+queryview/static/index.html,sha256=K1ErE6hqmLl6-5Ldg7bigRLI3_ejwSWrvniXPhreNsc,459
+queryview/static/assets/index-CvnC_D68.js,sha256=D7tm3lpnGYyfnGus3dosTWUpdhb9QRg096HPyKCGlbE,328887
+queryview/static/assets/index-Qe7bhycG.css,sha256=AGivYysIrMwIfCTxDIHFi2Okz6fzHkFf7-ErAzlZLF0,27807
+queryview-0.0.2.dist-info/METADATA,sha256=8NHQblmPmPjkCTHqKJyTdXDkrAxbxFaxIWniQpa-89E,6420
+queryview-0.0.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+queryview-0.0.2.dist-info/entry_points.txt,sha256=5Eu59D91AZfkEb76UvcXWk2Grk17Ej-QTIvl-IkGG1s,88
+queryview-0.0.2.dist-info/licenses/LICENSE,sha256=viH3V6L-xOvOuiFosKdQNQ8Xnt6bK0dnYuxhCHmQZu8,1070
+queryview-0.0.2.dist-info/RECORD,,

queryview-0.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

queryview-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+queryview = queryview.main:run
+queryview-backend = queryview.main:run

queryview-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mark kolodkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.