queria 0.1.0__py3-none-any.whl

queria/__init__.py

@@ -0,0 +1,7 @@
+"""Queria — query Japanese open data (data.queria.io) from Python and the CLI."""
+
+from queria.core import DEFAULT_STORAGE, Connection, connect, version
+
+__version__ = version()
+
+__all__ = ["DEFAULT_STORAGE", "Connection", "connect", "__version__"]

queria/cli.py

@@ -0,0 +1,175 @@
+"""Command-line interface for exploring Queria's public open data."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+import sys
+from collections.abc import Sequence
+from typing import Any
+
+from queria import core
+
+FORMATS = ("table", "csv", "json", "jsonl")
+
+
+def _jsonable(value: Any) -> Any:
+    if value is None or isinstance(value, (bool, int, float, str)):
+        return value
+    return str(value)
+
+
+def _print_table(columns: Sequence[str], rows: list[tuple]) -> None:
+    text_rows = [["" if v is None else str(v) for v in row] for row in rows]
+    widths = [len(c) for c in columns]
+    for row in text_rows:
+        for i, v in enumerate(row):
+            widths[i] = max(widths[i], len(v))
+    print(" | ".join(c.ljust(w) for c, w in zip(columns, widths)))
+    print("-+-".join("-" * w for w in widths))
+    for row in text_rows:
+        print(" | ".join(v.ljust(w) for v, w in zip(row, widths)))
+    print(f"\n({len(text_rows)} rows)", file=sys.stderr)
+
+
+def _emit(conn: core.Connection, sql: str, fmt: str, out: str | None) -> None:
+    if out:
+        ext = os.path.splitext(out)[1].lower()
+        if ext not in (".csv", ".parquet"):
+            sys.exit(f"--out expects a .csv or .parquet path (got {out!r})")
+        copy_fmt = "PARQUET" if ext == ".parquet" else "CSV, HEADER"
+        # Run once first so referenced datasets get attached before COPY.
+        conn.sql(sql)
+        conn.execute(f"COPY ({sql}) TO '{out}' (FORMAT {copy_fmt})")
+        print(f"Wrote {out}", file=sys.stderr)
+        return
+
+    rel = conn.sql(sql)
+    columns = rel.columns
+    rows = rel.fetchall()
+    if fmt == "table":
+        _print_table(columns, rows)
+    elif fmt == "csv":
+        writer = csv.writer(sys.stdout)
+        writer.writerow(columns)
+        writer.writerows(rows)
+    elif fmt == "json":
+        records = [
+            {c: _jsonable(v) for c, v in zip(columns, row)} for row in rows
+        ]
+        json.dump(records, sys.stdout, ensure_ascii=False, indent=2)
+        print()
+    elif fmt == "jsonl":
+        for row in rows:
+            record = {c: _jsonable(v) for c, v in zip(columns, row)}
+            print(json.dumps(record, ensure_ascii=False))
+
+
+def _add_output_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--format",
+        choices=FORMATS,
+        default="table",
+        help="stdout format (default: table; ignored when --out is set)",
+    )
+    parser.add_argument("--out", help="write the result to a .csv or .parquet file")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="queria",
+        description="Explore Queria public open data (data.queria.io, read-only).",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"queria {core.version()}"
+    )
+    parser.add_argument(
+        "--storage-url",
+        dest="storage",
+        default=core.DEFAULT_STORAGE,
+        help=f"catalog base URL (default: {core.DEFAULT_STORAGE})",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_list = sub.add_parser("list", help="list available datasets")
+    _add_output_args(p_list)
+
+    p_search = sub.add_parser("search", help="search datasets by keyword")
+    p_search.add_argument("keyword")
+    _add_output_args(p_search)
+
+    p_schema = sub.add_parser("schema", help="list a dataset's tables")
+    p_schema.add_argument("dataset")
+    _add_output_args(p_schema)
+
+    p_columns = sub.add_parser("columns", help="list a dataset's columns")
+    p_columns.add_argument("dataset")
+    p_columns.add_argument("table", nargs="?", help="filter to one table")
+    _add_output_args(p_columns)
+
+    p_sql = sub.add_parser("sql", help="run a read-only SQL query")
+    p_sql.add_argument("query")
+    p_sql.add_argument(
+        "--datasets",
+        help="comma-separated datasets to pre-attach (usually auto-detected)",
+    )
+    _add_output_args(p_sql)
+
+    sub.add_parser("mcp", help="run the stdio MCP server")
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    args = build_parser().parse_args(argv)
+
+    if args.command == "mcp":
+        from queria import mcp
+
+        mcp.serve(args.storage)
+        return
+
+    try:
+        conn = core.connect(
+            args.storage, user_agent=f"queria-cli/{core.version()}"
+        )
+    except RuntimeError as exc:
+        sys.exit(str(exc))
+
+    try:
+        if args.command == "list":
+            _emit(conn, core.list_datasets_sql(), args.format, args.out)
+        elif args.command == "search":
+            _emit(
+                conn, core.search_datasets_sql(args.keyword), args.format, args.out
+            )
+        elif args.command == "schema":
+            _emit(conn, core.schema_sql(args.dataset), args.format, args.out)
+        elif args.command == "columns":
+            _emit(
+                conn,
+                core.columns_sql(args.dataset, args.table),
+                args.format,
+                args.out,
+            )
+        elif args.command == "sql":
+            if not core.is_read_only(args.query):
+                sys.exit(
+                    "Only read-only queries are allowed "
+                    "(SELECT/WITH/DESCRIBE/SHOW/PRAGMA/EXPLAIN/SUMMARIZE)."
+                )
+            if args.datasets:
+                for ds in args.datasets.split(","):
+                    if ds.strip():
+                        conn.attach(ds.strip())
+            _emit(conn, args.query, args.format, args.out)
+    except ValueError as exc:
+        sys.exit(str(exc))
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()

queria/core.py

@@ -0,0 +1,254 @@
+"""Core connection and catalog helpers for Queria's public DuckLake catalogs.
+
+Queria (https://data.queria.io) publishes Japanese open data as read-only
+DuckLake catalogs. This module owns the connection lifecycle: attaching the
+``catalog`` metadata dataset, auto-attaching other datasets referenced in
+queries, and building the catalog queries shared by the CLI and MCP server.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import urllib.request
+
+import duckdb
+
+DEFAULT_STORAGE = "https://data.queria.io"
+CATALOG_ALIAS = "catalog"
+MAX_AUTO_ATTACH = 8
+
+# duckdb version requirement, coupled to Queria's published DuckLake v1 format.
+# The catalog is DuckLake format 1.0; only duckdb >= 1.5.4 ships a ducklake
+# extension new enough to read it. Bump together with the pin in pyproject.toml
+# if Queria's catalog format changes.
+MIN_DUCKDB = (1, 5, 4)
+
+_IDENT_RE = re.compile(r"^[A-Za-z0-9_]+$")
+_MISSING_CATALOG_RE = re.compile(r'Catalog "?([A-Za-z0-9_]+)"? does not exist')
+
+# Advisory guard for user-supplied SQL. The real protection is the READ_ONLY
+# attach: writes to the catalogs fail at the engine level regardless. This
+# regex only catches obvious accidents early with a clearer message.
+_READONLY_RE = re.compile(
+    r"^\s*(with|select|describe|show|pragma|explain|summarize|values|table|from)\b",
+    re.IGNORECASE,
+)
+
+
+def version() -> str:
+    """Return the installed queria package version."""
+    try:
+        from importlib.metadata import version as _pkg_version
+
+        return _pkg_version("queria")
+    except Exception:
+        return "0.0.0"
+
+
+def is_read_only(sql: str) -> bool:
+    """Advisory check that ``sql`` looks like a read-only statement."""
+    return bool(_READONLY_RE.match(sql))
+
+
+def _check_duckdb_version() -> None:
+    parts = []
+    for chunk in duckdb.__version__.split(".")[:3]:
+        m = re.match(r"\d+", chunk)
+        parts.append(int(m.group()) if m else 0)
+    if tuple(parts) < MIN_DUCKDB:
+        want = ".".join(str(n) for n in MIN_DUCKDB)
+        raise RuntimeError(
+            f"duckdb >= {want} is required to read Queria's DuckLake catalogs "
+            f"(found {duckdb.__version__}). Upgrade with: "
+            f"pip install 'duckdb>={want}'"
+        )
+
+
+def _compat_hint(storage: str, exc: Exception) -> str | None:
+    """Build an actionable message from the storage compatibility manifest.
+
+    Queria publishes ``{storage}/meta.json`` describing the catalog format and
+    the minimum client versions able to read it. The manifest is consulted
+    only after an ATTACH failure, purely to improve the error message; its
+    absence (or any fetch error) is never itself an error.
+    """
+    if not storage.startswith(("http://", "https://")):
+        return None
+    try:
+        with urllib.request.urlopen(f"{storage}/meta.json", timeout=3) as res:
+            meta = json.load(res)
+    except Exception:
+        return None
+    if not isinstance(meta, dict):
+        return None
+    lines = [f"Failed to attach the Queria catalog at {storage}: {exc}"]
+    if "ducklake_format" in meta:
+        lines.append(f"The catalog uses DuckLake format {meta['ducklake_format']}.")
+    if "min_duckdb" in meta:
+        lines.append(
+            f"It requires duckdb >= {meta['min_duckdb']} "
+            f"(you have {duckdb.__version__})."
+        )
+    if "min_cli" in meta:
+        lines.append(
+            f"It requires queria >= {meta['min_cli']} (you have {version()}). "
+            "Upgrade with: pip install -U queria (or clear the uvx cache)."
+        )
+    return "\n".join(lines)
+
+
+class Connection:
+    """Read-only connection to Queria's public DuckLake catalogs.
+
+    On construction the ``catalog`` metadata dataset is attached. Other
+    datasets are attached lazily: when a query references a dataset that is
+    not attached yet, :meth:`sql` catches the missing-catalog error, attaches
+    the dataset, and retries.
+
+    Use as a context manager to make sure the underlying duckdb connection is
+    closed::
+
+        with queria.connect() as conn:
+            conn.sql("SELECT * FROM catalog.main.mart_datasets").show()
+    """
+
+    def __init__(
+        self, storage: str = DEFAULT_STORAGE, *, user_agent: str | None = None
+    ) -> None:
+        _check_duckdb_version()
+        self.storage = storage.rstrip("/")
+        config = {"custom_user_agent": user_agent or f"queria-python/{version()}"}
+        self._con = duckdb.connect(config=config)
+        self._con.execute("INSTALL ducklake; LOAD ducklake;")
+        self._con.execute("INSTALL httpfs; LOAD httpfs;")
+        # spatial: several datasets (nlftp, address_br, e_stat boundaries)
+        # expose GEOMETRY columns and ST_* functions.
+        self._con.execute("INSTALL spatial; LOAD spatial;")
+        self._attached: set[str] = set()
+        try:
+            self.attach(CATALOG_ALIAS)
+        except duckdb.Error as exc:
+            hint = _compat_hint(self.storage, exc)
+            if hint:
+                raise RuntimeError(hint) from exc
+            raise
+
+    def attach(self, dataset: str) -> None:
+        """Attach a dataset by name (idempotent)."""
+        if dataset in self._attached:
+            return
+        _validate_ident(dataset)
+        url = f"{self.storage}/{dataset}/ducklake.duckdb"
+        data_path = f"{self.storage}/{dataset}/ducklake.duckdb.files/"
+        self._con.execute(
+            f"ATTACH 'ducklake:{url}' AS {dataset} "
+            f"(READ_ONLY, DATA_PATH '{data_path}', OVERRIDE_DATA_PATH true)"
+        )
+        self._attached.add(dataset)
+
+    def sql(self, query: str) -> duckdb.DuckDBPyRelation:
+        """Run a query, auto-attaching datasets it references."""
+        for _ in range(MAX_AUTO_ATTACH):
+            try:
+                return self._con.sql(query)
+            except duckdb.Error as exc:
+                self._attach_missing(exc)
+        return self._con.sql(query)
+
+    def execute(self, query: str) -> None:
+        """Execute a statement (e.g. COPY), auto-attaching referenced datasets."""
+        for _ in range(MAX_AUTO_ATTACH):
+            try:
+                self._con.execute(query)
+                return
+            except duckdb.Error as exc:
+                self._attach_missing(exc)
+        self._con.execute(query)
+
+    def _attach_missing(self, exc: duckdb.Error) -> None:
+        """Attach the dataset named in a missing-catalog error, or re-raise."""
+        m = _MISSING_CATALOG_RE.search(str(exc))
+        if not m or m.group(1) in self._attached:
+            raise exc
+        self.attach(m.group(1))
+
+    def close(self) -> None:
+        """Close the underlying duckdb connection."""
+        self._con.close()
+
+    def __enter__(self) -> Connection:
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.close()
+
+
+def connect(
+    storage: str = DEFAULT_STORAGE, *, user_agent: str | None = None
+) -> Connection:
+    """Open a read-only connection to Queria's public catalogs.
+
+    Args:
+        storage: Base URL (or local path) of the catalog storage.
+        user_agent: HTTP user agent reported to the storage. Defaults to
+            ``queria-python/<version>``.
+    """
+    return Connection(storage, user_agent=user_agent)
+
+
+# ---- catalog queries shared by the CLI and the MCP server -------------------
+
+
+def _validate_ident(name: str) -> None:
+    if not _IDENT_RE.match(name):
+        raise ValueError(f"invalid dataset/table name: {name!r}")
+
+
+def _quote(value: str) -> str:
+    return value.replace("'", "''")
+
+
+def list_datasets_sql() -> str:
+    """SQL listing all published datasets."""
+    return (
+        "SELECT datasource, title, description "
+        f"FROM {CATALOG_ALIAS}.main.mart_datasets ORDER BY datasource"
+    )
+
+
+def search_datasets_sql(keyword: str) -> str:
+    """SQL searching datasets by keyword over title and description."""
+    kw = _quote(keyword)
+    return f"""
+        SELECT datasource, title, description
+        FROM {CATALOG_ALIAS}.main.mart_datasets
+        WHERE lower(title || ' ' || COALESCE(description, '')) LIKE lower('%{kw}%')
+        ORDER BY datasource
+    """
+
+
+def schema_sql(dataset: str) -> str:
+    """SQL listing a dataset's tables and views."""
+    _validate_ident(dataset)
+    return f"""
+        SELECT schema_name, name AS table_name, description
+        FROM {CATALOG_ALIAS}.main.mart_nodes
+        WHERE datasource = '{dataset}' AND resource_type = 'model'
+        ORDER BY schema_name, name
+    """
+
+
+def columns_sql(dataset: str, table: str | None = None) -> str:
+    """SQL listing a dataset's columns, optionally filtered to one table."""
+    _validate_ident(dataset)
+    table_filter = ""
+    if table:
+        _validate_ident(table)
+        table_filter = f"AND table_name = '{table}'"
+    return f"""
+        SELECT table_name, column_name, data_type, description
+        FROM {CATALOG_ALIAS}.main.mart_columns
+        WHERE datasource = '{dataset}' {table_filter}
+        ORDER BY table_name, column_name
+    """

queria/mcp.py

@@ -0,0 +1,132 @@
+"""Stdio MCP server exposing Queria's public open data to agents.
+
+Run with ``queria mcp`` (requires the ``mcp`` extra: ``pip install
+'queria[mcp]'`` or ``uvx --from 'queria[mcp]' queria mcp``).
+
+The ``query`` tool enforces a row and payload-size cap so a single tool call
+cannot flood an agent's context. Bulk extraction should go through the CLI's
+``--out`` option instead.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+from queria import core
+
+DEFAULT_MAX_ROWS = 100
+MAX_ROWS_LIMIT = 1000
+MAX_PAYLOAD_BYTES = 1_000_000
+
+_BULK_HINT = (
+    "Result truncated. Narrow the query (LIMIT / WHERE / aggregate), or use "
+    "the CLI for bulk export: queria sql '<query>' --out result.parquet"
+)
+
+
+def _jsonable(value: Any) -> Any:
+    if value is None or isinstance(value, (bool, int, float, str)):
+        return value
+    return str(value)
+
+
+def _relation_payload(
+    rel: Any, max_rows: int | None = None
+) -> dict[str, Any]:
+    """Convert a duckdb relation into a JSON-safe payload with caps applied.
+
+    Rows are capped at ``max_rows`` first, then dropped from the tail until
+    the serialized payload fits within ``MAX_PAYLOAD_BYTES``.
+    """
+    columns = rel.columns
+    if max_rows is None:
+        raw = rel.fetchall()
+        truncated = False
+    else:
+        raw = rel.fetchmany(max_rows + 1)
+        truncated = len(raw) > max_rows
+        raw = raw[:max_rows]
+    rows = [[_jsonable(v) for v in row] for row in raw]
+
+    payload = {"columns": columns, "rows": rows, "truncated": truncated}
+    while (
+        len(json.dumps(payload, ensure_ascii=False)) > MAX_PAYLOAD_BYTES
+        and payload["rows"]
+    ):
+        payload["rows"] = payload["rows"][: max(1, len(payload["rows"]) // 2)]
+        payload["truncated"] = True
+        if len(payload["rows"]) == 1:
+            break
+    payload["row_count"] = len(payload["rows"])
+    if payload["truncated"]:
+        payload["hint"] = _BULK_HINT
+    return payload
+
+
+def build_server(storage: str = core.DEFAULT_STORAGE) -> Any:
+    """Build the FastMCP server with all Queria tools registered."""
+    try:
+        from mcp.server.fastmcp import FastMCP
+    except ImportError:
+        sys.exit(
+            "The MCP server requires the 'mcp' extra:\n"
+            "  pip install 'queria[mcp]'\n"
+            "  # or: uvx --from 'queria[mcp]' queria mcp"
+        )
+
+    server = FastMCP(
+        "queria",
+        instructions=(
+            "Read-only access to Queria (data.queria.io), a catalog of "
+            "Japanese open data published as DuckLake. Start with "
+            "list_datasets or search_datasets, inspect tables with "
+            "get_schema / get_columns, then run DuckDB SQL with query. "
+            "Reference tables as <dataset>.<schema>.<table>."
+        ),
+    )
+    conn = core.connect(storage, user_agent=f"queria-mcp/{core.version()}")
+
+    @server.tool()
+    def list_datasets() -> dict:
+        """List all datasets published on Queria."""
+        return _relation_payload(conn.sql(core.list_datasets_sql()))
+
+    @server.tool()
+    def search_datasets(keyword: str) -> dict:
+        """Search datasets by keyword over their title and description."""
+        return _relation_payload(conn.sql(core.search_datasets_sql(keyword)))
+
+    @server.tool()
+    def get_schema(dataset: str) -> dict:
+        """List a dataset's tables and views with descriptions."""
+        return _relation_payload(conn.sql(core.schema_sql(dataset)))
+
+    @server.tool()
+    def get_columns(dataset: str, table: str | None = None) -> dict:
+        """List a dataset's columns (optionally for a single table)."""
+        return _relation_payload(conn.sql(core.columns_sql(dataset, table)))
+
+    @server.tool()
+    def query(sql: str, max_rows: int = DEFAULT_MAX_ROWS) -> dict:
+        """Run a read-only DuckDB SQL query against Queria datasets.
+
+        Reference tables as <dataset>.<schema>.<table>; datasets attach
+        automatically. Results are capped at max_rows (up to 1000) and ~1MB;
+        use the queria CLI with --out for bulk extraction.
+        """
+        if not core.is_read_only(sql):
+            raise ValueError(
+                "Only read-only queries are allowed "
+                "(SELECT/WITH/DESCRIBE/SHOW/PRAGMA/EXPLAIN/SUMMARIZE)."
+            )
+        capped = max(1, min(max_rows, MAX_ROWS_LIMIT))
+        return _relation_payload(conn.sql(sql), max_rows=capped)
+
+    return server
+
+
+def serve(storage: str = core.DEFAULT_STORAGE) -> None:
+    """Run the stdio MCP server (blocks until the client disconnects)."""
+    build_server(storage).run()

queria-0.1.0.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: queria
+Version: 0.1.0
+Summary: Query Japanese open data on Queria (data.queria.io) from the terminal, Python, and MCP
+Project-URL: Homepage, https://docs.queria.io/
+Project-URL: Documentation, https://docs.queria.io/
+Project-URL: Repository, https://github.com/queria-io/queria-cli
+Project-URL: Changelog, https://docs.queria.io/resources/changelog/
+Author: flo8s
+License-Expression: MIT
+License-File: LICENSE
+Keywords: duckdb,ducklake,japan,mcp,opendata
+Requires-Python: >=3.10
+Requires-Dist: duckdb<2.0,>=1.5.4
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.2; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# queria
+
+Query Japanese open data on [Queria](https://data.queria.io) from the terminal, Python, and MCP.
+
+[Queria](https://data.queria.io) が公開する日本のオープンデータ（e-Stat、国土数値情報、EDINET、気象庁ほか）を、ターミナル・Python・MCP から read-only で探索するクライアントです。データは DuckLake 形式で公開されており、計算はすべて手元の DuckDB で行われます。
+
+## インストール
+
+```bash
+uvx queria list          # インストール不要で実行
+pip install queria       # または通常インストール
+```
+
+Python 3.10+ が必要です。
+
+## 使い方
+
+```bash
+queria list                              # データセット一覧
+queria search 人口                        # キーワード検索
+queria schema e_stat                     # テーブル一覧
+queria columns e_stat mart_population    # カラム一覧
+queria sql "SELECT * FROM zipcode.main.zipcodes LIMIT 10"
+queria sql "SELECT * FROM zipcode.main.zipcodes" --out zipcodes.parquet
+```
+
+テーブルは `<dataset>.<schema>.<table>` で参照します。参照したデータセットは自動的に ATTACH されます。
+
+## Python API
+
+```python
+import queria
+
+with queria.connect() as conn:
+    conn.sql("SELECT * FROM catalog.main.mart_datasets").show()
+```
+
+## MCP サーバー
+
+Claude Code / Claude Desktop / Cursor などの MCP クライアントから使えます:
+
+```json
+{
+  "mcpServers": {
+    "queria": {
+      "command": "uvx",
+      "args": ["--from", "queria[mcp]", "queria", "mcp"]
+    }
+  }
+}
+```
+
+## ドキュメント
+
+https://docs.queria.io/
+
+## License
+
+MIT

queria-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+queria/__init__.py,sha256=miQ0gR1Hc-pcuZrt06tzlC_zrg89lxobJ2FE9HlnA-A,251
+queria/cli.py,sha256=HDYCDOYCn-G-GG1IXxnokAKl3rCToDNCQaxOyvrCEk0,5642
+queria/core.py,sha256=2nYXJ-3prsAlkxROtK79bBbKep7_XwyW1gzHM7MOdLs,8960
+queria/mcp.py,sha256=Dt7BpnGh5br0nF9OUp-udsHNRKjRRHRmsskDL6uZRr4,4595
+queria-0.1.0.dist-info/METADATA,sha256=Qk2AOjcwjXTN1t_EEJAOAS3mwJ9IS2dx6XOrML2WE8s,2296
+queria-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+queria-0.1.0.dist-info/entry_points.txt,sha256=zQssl32dXfYpvj1iWKrJTgj5TLaCAv1uR0pOiy4t1L4,43
+queria-0.1.0.dist-info/licenses/LICENSE,sha256=t0Of_GryPUMuBvGrtopnujMcxjgVBWMbUIyL7cCZMvk,1062
+queria-0.1.0.dist-info/RECORD,,

queria-0.1.0.dist-info/WHEEL

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

queria-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+queria = queria.cli:main

queria-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 flo8s
+
+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.