jusi-sql 0.2.0__py3-none-any.whl

jusi_sql/__init__.py

@@ -0,0 +1,63 @@
+"""Provider-neutral SQL family primitives for Jusi 1.0.
+
+This module intentionally imports neither IPython nor a terminal application.
+Catalog discovery can therefore import it without crossing runtime boundaries.
+"""
+
+from .catalog import (
+    FAMILY_ID,
+    MAGIC_NAME,
+    SQL_CAPABILITIES,
+    SQL_PRESENTATION,
+    sql_catalog_entry,
+    sql_family_claim,
+)
+from .completion import (
+    CompletionColumn,
+    CompletionItem,
+    CompletionObject,
+    MetadataSnapshot,
+    SqlCompletionRequest,
+    complete_sql,
+    parse_query_relations,
+)
+from .config import (
+    ResolvedSqlTarget,
+    SqlConfigError,
+    SqlFamilyConfig,
+    SqlProviderIdentity,
+    SqlTarget,
+    resolve_sql_target,
+)
+from .metadata import MetadataCache, sql_cache_directory
+from .visidata import SqlSheetActions, bind_sql_actions, find_sql_actions, install_visidata_commands
+
+__all__ = [
+    "FAMILY_ID",
+    "MAGIC_NAME",
+    "SQL_CAPABILITIES",
+    "SQL_PRESENTATION",
+    "CompletionColumn",
+    "CompletionItem",
+    "CompletionObject",
+    "MetadataSnapshot",
+    "MetadataCache",
+    "ResolvedSqlTarget",
+    "SqlCompletionRequest",
+    "SqlConfigError",
+    "SqlFamilyConfig",
+    "SqlProviderIdentity",
+    "SqlSheetActions",
+    "SqlTarget",
+    "complete_sql",
+    "bind_sql_actions",
+    "find_sql_actions",
+    "install_visidata_commands",
+    "parse_query_relations",
+    "resolve_sql_target",
+    "sql_catalog_entry",
+    "sql_cache_directory",
+    "sql_family_claim",
+]
+
+__version__ = "0.2.0"

jusi_sql/catalog.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import Any, Iterable, Mapping
+
+
+FAMILY_ID = "sql"
+MAGIC_NAME = "sql"
+SQL_CAPABILITIES = ("execute", "followup", "complete", "interrupt", "editor_actions")
+SQL_PRESENTATION = {"syntax": "sql", "indent": "sql"}
+
+
+def sql_family_claim(
+    *,
+    provider_presentation: Mapping[str, str] | None = None,
+) -> dict[str, Any]:
+    """Return the one canonical catalog claim shared by every SQL provider."""
+    claim: dict[str, Any] = {
+        "family_id": FAMILY_ID,
+        "magic_name": MAGIC_NAME,
+        "capabilities": list(SQL_CAPABILITIES),
+        "presentation": dict(SQL_PRESENTATION),
+    }
+    if provider_presentation:
+        claim["provider_presentation"] = dict(provider_presentation)
+    return claim
+
+
+def sql_catalog_entry(
+    *,
+    plugin_id: str,
+    plugin_version: str,
+    distribution: str,
+    kernel_extension: str,
+    worker_entry_point: str,
+    provider_presentation: Mapping[str, str] | None = None,
+    media_types: Iterable[str] = ("text/x-ansi",),
+) -> dict[str, Any]:
+    """Build an exact-provider catalog entry without importing runtime code."""
+    return {
+        "plugin_id": _required(plugin_id, "plugin_id"),
+        "plugin_version": _required(plugin_version, "plugin_version"),
+        "distribution": _required(distribution, "distribution"),
+        "families": [sql_family_claim(provider_presentation=provider_presentation)],
+        "kernel_extensions": [_required(kernel_extension, "kernel_extension")],
+        "worker_entry_point": _required(worker_entry_point, "worker_entry_point"),
+        "media_types": list(dict.fromkeys(media_types)),
+        "interaction": "terminal_interactive",
+    }
+
+
+def _required(value: str, name: str) -> str:
+    normalized = str(value).strip()
+    if not normalized:
+        raise ValueError(f"{name} must be a non-empty string")
+    return normalized

jusi_sql/completion.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+import re
+from dataclasses import asdict, dataclass, field
+from typing import Any, Iterable, Mapping, Sequence
+
+import sqlparse
+from sqlparse.sql import Identifier, IdentifierList, TokenList
+from sqlparse.tokens import Keyword, Name
+
+
+RELATION_KEYWORDS = frozenset({"FROM", "JOIN", "INTO", "UPDATE", "TABLE", "VIEW", "DESCRIBE", "DESC"})
+_IDENTIFIER_AT_CURSOR = re.compile(
+    r'(?:(?:"[^"]*"|`[^`]*`|[A-Za-z_][A-Za-z0-9_$]*)(?:\.(?:"[^"]*"|`[^`]*`|[A-Za-z_][A-Za-z0-9_$]*))*\.?)$'
+)
+
+
+@dataclass(frozen=True)
+class CompletionObject:
+    name: str
+    schema: str = ""
+    kind: str = "table"
+    detail: str = ""
+
+
+@dataclass(frozen=True)
+class CompletionColumn:
+    table: str
+    name: str
+    schema: str = ""
+    data_type: str = ""
+
+
+@dataclass
+class MetadataSnapshot:
+    schemas: list[str] = field(default_factory=list)
+    objects: list[CompletionObject] = field(default_factory=list)
+    columns: list[CompletionColumn] = field(default_factory=list)
+    functions: list[CompletionObject] = field(default_factory=list)
+    refreshed_at: float = 0.0
+
+    @classmethod
+    def from_dict(cls, payload: Mapping[str, Any]) -> "MetadataSnapshot":
+        return cls(
+            schemas=[str(item) for item in payload.get("schemas", ()) if str(item)],
+            objects=_objects(payload.get("objects", ()), default_kind="table"),
+            columns=_columns(payload.get("columns", ())),
+            functions=_objects(payload.get("functions", ()), default_kind="function"),
+            refreshed_at=float(payload.get("refreshed_at", 0.0) or 0.0),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "schemas": list(self.schemas),
+            "objects": [asdict(item) for item in self.objects],
+            "columns": [asdict(item) for item in self.columns],
+            "functions": [asdict(item) for item in self.functions],
+            "refreshed_at": self.refreshed_at,
+        }
+
+
+@dataclass(frozen=True)
+class SqlCompletionRequest:
+    body: str
+    prefix: str
+    cursor_pos: int
+    cursor_row: int
+    cursor_col: int
+
+    @classmethod
+    def from_payload(cls, payload: Mapping[str, Any]) -> "SqlCompletionRequest":
+        body = payload.get("body")
+        prefix = payload.get("prefix")
+        cursor_pos = payload.get("cursor_pos")
+        cursor_row = payload.get("cursor_row")
+        cursor_col = payload.get("cursor_col")
+        if not isinstance(body, str) or not isinstance(prefix, str):
+            raise ValueError("SQL completion requires string body and prefix")
+        if type(cursor_pos) is not int or not 0 <= cursor_pos <= len(body):
+            raise ValueError("SQL completion cursor_pos is outside body")
+        if prefix != body[:cursor_pos]:
+            raise ValueError("SQL completion prefix does not match body before cursor")
+        expected_row = prefix.count("\n")
+        expected_col = len(prefix.rsplit("\n", 1)[-1])
+        if cursor_row != expected_row or cursor_col != expected_col:
+            raise ValueError("SQL completion cursor coordinates are inconsistent")
+        return cls(body, prefix, cursor_pos, expected_row, expected_col)
+
+
+@dataclass(frozen=True)
+class CompletionItem:
+    text: str
+    start: int
+    end: int
+    label: str = ""
+    detail: str = ""
+    documentation: str = ""
+    kind: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        item: dict[str, Any] = {"text": self.text, "start": self.start, "end": self.end}
+        for key in ("label", "detail", "documentation", "kind"):
+            value = getattr(self, key)
+            if value:
+                item[key] = value
+        return item
+
+
+@dataclass(frozen=True)
+class QueryRelation:
+    schema: str
+    table: str
+    alias: str = ""
+
+    @property
+    def completion_prefix(self) -> str:
+        return self.alias or self.table
+
+
+def complete_sql(
+    snapshot: MetadataSnapshot,
+    request: SqlCompletionRequest | Mapping[str, Any],
+    *,
+    keywords: Iterable[str] = (),
+    schema_detail: str = "schema",
+    relation_keywords: Iterable[str] = RELATION_KEYWORDS,
+) -> dict[str, list[dict[str, Any]]]:
+    """Complete SQL using provider metadata and 1.0 absolute source ranges."""
+    if not isinstance(request, SqlCompletionRequest):
+        request = SqlCompletionRequest.from_payload(request)
+    relation_words = {str(item).upper() for item in relation_keywords}
+    token, start = _token_at_cursor(request.prefix, relation_words)
+    relation_context = _after_relation_keyword(request.prefix, relation_words)
+    parts = token.split(".") if token else []
+    relations = parse_query_relations(request.prefix)
+    items: list[CompletionItem] = []
+    seen: set[tuple[str, str]] = set()
+
+    def add(
+        text: str,
+        kind: str,
+        *,
+        label: str = "",
+        detail: str = "",
+        documentation: str = "",
+    ) -> None:
+        if not _candidate_matches(text, token):
+            return
+        key = (text, kind)
+        if key in seen:
+            return
+        seen.add(key)
+        items.append(CompletionItem(text, start, request.cursor_pos, label or text, detail, documentation, kind))
+
+    if len(parts) <= 1:
+        if not relation_context:
+            for keyword in keywords:
+                add(str(keyword), "keyword", detail="keyword")
+        for schema in snapshot.schemas:
+            add(schema, "schema", detail=schema_detail)
+        for obj in snapshot.objects:
+            add(obj.name, obj.kind, detail=obj.schema or obj.detail, documentation=obj.detail)
+            if obj.schema:
+                add(f"{obj.schema}.{obj.name}", obj.kind, label=obj.name, detail=obj.schema, documentation=obj.detail)
+        if not relation_context:
+            for function in snapshot.functions:
+                add(function.name, "function", detail=function.schema, documentation=function.detail)
+            for column in snapshot.columns:
+                add(column.name, "column", detail=_column_owner(column), documentation=column.data_type)
+    elif len(parts) == 2:
+        owner = parts[0].strip('"`').lower()
+        for obj in snapshot.objects:
+            if obj.schema.lower() == owner:
+                add(f"{obj.schema}.{obj.name}", obj.kind, label=obj.name, detail=obj.schema, documentation=obj.detail)
+        if not relation_context:
+            for function in snapshot.functions:
+                if function.schema.lower() == owner:
+                    add(f"{function.schema}.{function.name}", "function", label=function.name, detail=function.schema, documentation=function.detail)
+            for column in snapshot.columns:
+                owners = {column.table.lower()}
+                owners.update(relation.completion_prefix.lower() for relation in relations if _relation_matches(column, relation))
+                if owner in owners:
+                    add(f"{parts[0]}.{column.name}", "column", label=column.name, detail=_column_owner(column), documentation=column.data_type)
+    else:
+        schema = parts[-3].strip('"`').lower()
+        table = parts[-2].strip('"`').lower()
+        for column in snapshot.columns:
+            if column.schema.lower() == schema and column.table.lower() == table:
+                add(f"{'.'.join(parts[:-1])}.{column.name}", "column", label=column.name, detail=_column_owner(column), documentation=column.data_type)
+
+    return {"items": [item.to_dict() for item in items[:500]]}
+
+
+def parse_query_relations(sql: str) -> list[QueryRelation]:
+    relations: list[QueryRelation] = []
+    for statement in sqlparse.parse(sql):
+        _collect_relations(statement, relations)
+    unique: list[QueryRelation] = []
+    seen: set[tuple[str, str, str]] = set()
+    for relation in relations:
+        key = (relation.schema.lower(), relation.table.lower(), relation.alias.lower())
+        if key not in seen:
+            seen.add(key)
+            unique.append(relation)
+    return unique
+
+
+def _candidate_matches(candidate: str, token: str) -> bool:
+    if not token:
+        return True
+    candidate_parts = candidate.lower().split(".")
+    token_parts = token.lower().split(".")
+    if len(token_parts) == 1:
+        return candidate_parts[-1].startswith(token_parts[0]) or candidate.lower().startswith(token.lower())
+    if len(candidate_parts) < len(token_parts):
+        return False
+    return candidate_parts[:-1] == token_parts[:-1] and candidate_parts[-1].startswith(token_parts[-1])
+
+
+def _token_at_cursor(prefix: str, relation_keywords: set[str]) -> tuple[str, int]:
+    if _after_relation_keyword(prefix, relation_keywords):
+        return "", len(prefix)
+    match = _IDENTIFIER_AT_CURSOR.search(prefix)
+    if match is None:
+        return "", len(prefix)
+    return match.group(0), match.start()
+
+
+def _after_relation_keyword(prefix: str, relation_keywords: set[str]) -> bool:
+    if not prefix or not prefix[-1].isspace():
+        return False
+    words = re.findall(r"[A-Za-z_][A-Za-z0-9_]*", prefix)
+    return bool(words and words[-1].upper() in relation_keywords)
+
+
+def _collect_relations(tokens: TokenList, relations: list[QueryRelation]) -> None:
+    values = list(tokens.tokens)
+    for index, token in enumerate(values):
+        if token.is_group:
+            _collect_relations(token, relations)
+        normalized = str(getattr(token, "normalized", "") or "").upper()
+        if token.ttype is not Keyword or not (normalized in {"FROM", "UPDATE", "INTO", "TABLE"} or normalized.endswith("JOIN")):
+            continue
+        next_token = _next_meaningful(values[index + 1 :])
+        if isinstance(next_token, IdentifierList):
+            for identifier in next_token.get_identifiers():
+                _append_relation(identifier, relations)
+        elif isinstance(next_token, Identifier):
+            _append_relation(next_token, relations)
+        elif next_token is not None and next_token.ttype in (Name, Keyword):
+            relations.append(QueryRelation("", str(next_token.value), ""))
+
+
+def _append_relation(identifier: Identifier, relations: list[QueryRelation]) -> None:
+    if any(token.is_group and token.value.strip().startswith("(") for token in identifier.tokens):
+        return
+    table = identifier.get_real_name() or ""
+    if table:
+        relations.append(QueryRelation(identifier.get_parent_name() or "", table, identifier.get_alias() or ""))
+
+
+def _next_meaningful(tokens: Sequence[Any]) -> Any:
+    return next((token for token in tokens if not token.is_whitespace), None)
+
+
+def _relation_matches(column: CompletionColumn, relation: QueryRelation) -> bool:
+    return column.table.lower() == relation.table.lower() and (
+        not relation.schema or column.schema.lower() == relation.schema.lower()
+    )
+
+
+def _column_owner(column: CompletionColumn) -> str:
+    return f"{column.schema}.{column.table}" if column.schema else column.table
+
+
+def _objects(values: Any, *, default_kind: str) -> list[CompletionObject]:
+    if not isinstance(values, Sequence) or isinstance(values, (str, bytes)):
+        return []
+    result: list[CompletionObject] = []
+    for item in values:
+        if isinstance(item, Mapping) and str(item.get("name", "")):
+            result.append(CompletionObject(
+                name=str(item["name"]),
+                schema=str(item.get("schema", "")),
+                kind=str(item.get("kind", default_kind)) or default_kind,
+                detail=str(item.get("detail", "")),
+            ))
+    return result
+
+
+def _columns(values: Any) -> list[CompletionColumn]:
+    if not isinstance(values, Sequence) or isinstance(values, (str, bytes)):
+        return []
+    result: list[CompletionColumn] = []
+    for item in values:
+        if isinstance(item, Mapping) and str(item.get("table", "")) and str(item.get("name", "")):
+            result.append(CompletionColumn(
+                table=str(item["table"]),
+                name=str(item["name"]),
+                schema=str(item.get("schema", "")),
+                data_type=str(item.get("data_type", "")),
+            ))
+    return result

jusi_sql/config.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Iterable, Mapping
+
+
+@dataclass(frozen=True)
+class SqlProviderIdentity:
+    plugin_id: str
+    plugin_version: str
+    selectors: tuple[str, ...]
+
+    @classmethod
+    def create(
+        cls,
+        plugin_id: str,
+        plugin_version: str,
+        selectors: Iterable[str] = (),
+    ) -> "SqlProviderIdentity":
+        normalized_id = _nonempty(plugin_id, "plugin_id")
+        normalized = tuple(dict.fromkeys(_nonempty(item, "provider selector") for item in selectors))
+        return cls(normalized_id, _nonempty(plugin_version, "plugin_version"), normalized or (normalized_id,))
+
+
+@dataclass(frozen=True)
+class SqlTarget:
+    alias: str
+    provider: str
+    options: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class ResolvedSqlTarget:
+    alias: str
+    provider: str
+    plugin_id: str
+    plugin_version: str
+    options: dict[str, Any]
+
+
+class SqlConfigError(ValueError):
+    """A secret-safe SQL family configuration error."""
+
+    def __init__(self, message: str, *, reason: str = "invalid_config") -> None:
+        self.reason = reason
+        super().__init__(message)
+
+
+@dataclass(frozen=True)
+class SqlFamilyConfig:
+    targets: dict[str, SqlTarget]
+
+    @classmethod
+    def from_mapping(cls, configuration: Mapping[str, Any] | None) -> "SqlFamilyConfig":
+        root = configuration or {}
+        if not isinstance(root, Mapping):
+            raise SqlConfigError("Jusi runtime configuration must be an object")
+        section = root.get("sql")
+        if section is None:
+            return cls({})
+        if not isinstance(section, Mapping):
+            raise SqlConfigError("[sql] must be a table")
+
+        # 1.0's canonical shape is [sql.targets.<alias>]. Direct [sql.<alias>]
+        # remains accepted so existing target files can migrate independently.
+        if "targets" in section:
+            raw_targets = section["targets"]
+            legacy = [key for key in section if key != "targets"]
+            if legacy:
+                raise SqlConfigError("Do not mix [sql.targets.*] with legacy [sql.*] targets")
+        else:
+            raw_targets = section
+        if not isinstance(raw_targets, Mapping):
+            raise SqlConfigError("[sql.targets] must be a table")
+
+        targets: dict[str, SqlTarget] = {}
+        for raw_alias, raw_target in raw_targets.items():
+            alias = str(raw_alias).strip()
+            if not alias:
+                raise SqlConfigError("SQL target aliases must be non-empty")
+            if not isinstance(raw_target, Mapping):
+                raise SqlConfigError(f"SQL target {alias!r} must be a table")
+            provider = str(raw_target.get("provider", "")).strip()
+            if not provider:
+                raise SqlConfigError(f"SQL target {alias!r} must define provider")
+            options = {
+                str(key): deepcopy(value)
+                for key, value in raw_target.items()
+                if str(key) != "provider"
+            }
+            targets[alias] = SqlTarget(alias, provider, options)
+        return cls(targets)
+
+    def resolve(
+        self,
+        alias: str,
+        providers: Iterable[SqlProviderIdentity],
+    ) -> ResolvedSqlTarget:
+        normalized = str(alias).strip()
+        if not normalized:
+            raise SqlConfigError("%%sql requires a target alias", reason="missing_alias")
+        target = self.targets.get(normalized)
+        if target is None:
+            raise SqlConfigError(f"Unknown SQL target alias {normalized!r}", reason="unknown_alias")
+        matches = [provider for provider in providers if target.provider in provider.selectors]
+        if not matches:
+            raise SqlConfigError(
+                f"SQL target {normalized!r} selects unavailable provider {target.provider!r}",
+                reason="unavailable_provider",
+            )
+        if len(matches) > 1:
+            raise SqlConfigError(
+                f"SQL target {normalized!r} selects ambiguous provider {target.provider!r}",
+                reason="ambiguous_provider",
+            )
+        provider = matches[0]
+        return ResolvedSqlTarget(
+            alias=target.alias,
+            provider=target.provider,
+            plugin_id=provider.plugin_id,
+            plugin_version=provider.plugin_version,
+            options=deepcopy(target.options),
+        )
+
+
+def resolve_sql_target(
+    alias: str,
+    configuration: Mapping[str, Any] | None,
+    providers: Iterable[SqlProviderIdentity],
+) -> ResolvedSqlTarget:
+    return SqlFamilyConfig.from_mapping(configuration).resolve(alias, providers)
+
+
+def _nonempty(value: object, name: str) -> str:
+    normalized = str(value).strip()
+    if not normalized:
+        raise ValueError(f"{name} must be a non-empty string")
+    return normalized

jusi_sql/kernel.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import shlex
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Iterable, Mapping
+
+from .catalog import FAMILY_ID, MAGIC_NAME
+from .config import SqlConfigError, SqlFamilyConfig, SqlProviderIdentity
+
+
+HANDOFF_MIME = "application/vnd.jusi.handoff.v1+json"
+_DISPATCHER_MARKER = "_jusi_sql_dispatcher_v1"
+_providers: dict[str, "SqlKernelAdapter"] = {}
+_configuration: dict[str, Any] | None = None
+
+
+@dataclass(frozen=True)
+class SqlMagicArguments:
+    alias: str
+
+
+class SqlKernelAdapter:
+    """Exact-provider adapter backed by one shared ``%%sql`` dispatcher."""
+
+    def __init__(
+        self,
+        *,
+        plugin_id: str,
+        plugin_version: str,
+        selectors: Iterable[str] = (),
+        empty_sql: str = "",
+    ) -> None:
+        self.identity = SqlProviderIdentity.create(plugin_id, plugin_version, selectors)
+        self.empty_sql = str(empty_sql)
+        self._configuration: dict[str, Any] = {}
+
+    def manifest(self) -> dict[str, Any]:
+        return {
+            "plugin_id": self.identity.plugin_id,
+            "plugin_version": self.identity.plugin_version,
+            "families": [{"family_id": FAMILY_ID, "magic_name": MAGIC_NAME}],
+        }
+
+    def configure(self, configuration: Mapping[str, Any]) -> None:
+        if not isinstance(configuration, Mapping):
+            raise TypeError("Jusi runtime configuration must be an object")
+        self._configuration = deepcopy(dict(configuration))
+
+    def load(self, ipython: Any) -> None:
+        _register_provider(self)
+        _configure_family(self._configuration)
+        _register_dispatcher(ipython)
+
+
+def parse_sql_magic_line(line: str) -> SqlMagicArguments:
+    try:
+        parts = shlex.split(line)
+    except ValueError as exc:
+        raise SqlConfigError(f"Invalid %%sql arguments: {exc}", reason="invalid_magic_line") from exc
+    if not parts:
+        raise SqlConfigError("%%sql requires a target alias", reason="missing_alias")
+    if len(parts) != 1:
+        raise SqlConfigError(
+            "%%sql accepts one target alias; put provider options in [sql.targets.<alias>]",
+            reason="invalid_magic_line",
+        )
+    return SqlMagicArguments(parts[0])
+
+
+def dispatch_sql(line: str, cell: str) -> dict[str, Any]:
+    arguments = parse_sql_magic_line(line)
+    family = SqlFamilyConfig.from_mapping(_configuration)
+    target = family.resolve(arguments.alias, (item.identity for item in _providers.values()))
+    adapter = _providers[target.plugin_id]
+    sql = str(cell)
+    if not sql.strip() and adapter.empty_sql:
+        sql = adapter.empty_sql
+    return {
+        "protocol_version": 1,
+        "kind": "plugin.handoff",
+        "plugin_id": target.plugin_id,
+        "plugin_version": target.plugin_version,
+        "family_id": FAMILY_ID,
+        "magic_name": MAGIC_NAME,
+        "payload": {
+            "alias": target.alias,
+            "sql": sql,
+            "options": target.options,
+        },
+    }
+
+
+def _register_provider(adapter: SqlKernelAdapter) -> None:
+    current = _providers.get(adapter.identity.plugin_id)
+    if current is not None and current is not adapter:
+        raise RuntimeError(f"SQL provider {adapter.identity.plugin_id!r} registered more than once")
+    for existing in _providers.values():
+        overlap = set(existing.identity.selectors) & set(adapter.identity.selectors)
+        if existing is not adapter and overlap:
+            names = ", ".join(sorted(overlap))
+            raise RuntimeError(f"SQL provider selectors are ambiguous: {names}")
+    _providers[adapter.identity.plugin_id] = adapter
+
+
+def _configure_family(configuration: Mapping[str, Any]) -> None:
+    global _configuration
+    candidate = deepcopy(dict(configuration))
+    if _configuration is not None and _configuration != candidate:
+        raise RuntimeError("SQL adapters received inconsistent runtime configuration")
+    _configuration = candidate
+
+
+def _register_dispatcher(ipython: Any) -> None:
+    if getattr(ipython, _DISPATCHER_MARKER, False):
+        return
+    cell_magics = getattr(getattr(ipython, "magics_manager", None), "magics", {}).get("cell", {})
+    if MAGIC_NAME in cell_magics:
+        raise RuntimeError("The sql cell magic is already owned by another extension")
+
+    def sql_magic(line: str, cell: str) -> None:
+        from IPython.core.error import UsageError
+        from IPython.display import display
+
+        try:
+            handoff = dispatch_sql(line, cell)
+        except SqlConfigError as exc:
+            raise UsageError(str(exc)) from exc
+        display({HANDOFF_MIME: handoff}, raw=True)
+
+    ipython.register_magic_function(sql_magic, magic_kind="cell", magic_name=MAGIC_NAME)
+    setattr(ipython, _DISPATCHER_MARKER, True)
+
+
+def _reset_runtime_for_tests() -> None:
+    global _configuration
+    _providers.clear()
+    _configuration = None

jusi_sql/metadata.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import threading
+import time
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+from .completion import MetadataSnapshot
+
+
+DEFAULT_METADATA_TTL = 60 * 60.0
+_SECRET_MARKERS = ("password", "passphrase", "secret", "token", "api_key", "private_key", "sslkey", "krb5ccname")
+
+
+class MetadataCache:
+    """Thread-safe stale-while-refresh cache shared by SQL providers."""
+
+    def __init__(
+        self,
+        cache_directory: Path,
+        loader: Callable[[], MetadataSnapshot],
+        *,
+        ttl: float = DEFAULT_METADATA_TTL,
+        on_warning: Callable[[str], None] | None = None,
+    ) -> None:
+        self.path = Path(cache_directory) / "metadata.json"
+        self.loader = loader
+        self.ttl = max(0.0, float(ttl))
+        self.on_warning = on_warning
+        self._lock = threading.Lock()
+        self._refreshing = False
+        self._thread: threading.Thread | None = None
+        self._snapshot = MetadataSnapshot.from_dict(_read_json(self.path))
+
+    def snapshot(self) -> MetadataSnapshot:
+        with self._lock:
+            return MetadataSnapshot.from_dict(self._snapshot.to_dict())
+
+    def mark_stale(self) -> None:
+        with self._lock:
+            self._snapshot.refreshed_at = 0.0
+
+    def ensure_fresh_async(self, *, force: bool = False) -> bool:
+        with self._lock:
+            age = time.time() - self._snapshot.refreshed_at if self._snapshot.refreshed_at else float("inf")
+            if self._refreshing or (not force and age < self.ttl):
+                return False
+            self._refreshing = True
+            self._thread = threading.Thread(target=self._refresh, name="jusi-sql-metadata", daemon=True)
+            self._thread.start()
+            return True
+
+    def close(self, *, timeout: float = 2.0) -> bool:
+        with self._lock:
+            thread = self._thread
+        if thread is None or not thread.is_alive():
+            return True
+        thread.join(timeout=max(0.0, timeout))
+        return not thread.is_alive()
+
+    def _refresh(self) -> None:
+        try:
+            snapshot = self.loader()
+            if not isinstance(snapshot, MetadataSnapshot):
+                raise TypeError("metadata loader must return MetadataSnapshot")
+            snapshot.refreshed_at = time.time()
+            _write_json(self.path, snapshot.to_dict())
+            with self._lock:
+                self._snapshot = snapshot
+        except Exception as exc:
+            if self.on_warning is not None:
+                self.on_warning(f"SQL metadata refresh failed: {exc.__class__.__name__}: {exc}")
+        finally:
+            with self._lock:
+                self._refreshing = False
+
+
+def sql_cache_directory(
+    provider_id: str,
+    alias: str,
+    options: Mapping[str, Any],
+    *,
+    state_home: Path | None = None,
+) -> Path:
+    """Return a stable cache path whose fingerprint never includes secret values."""
+    root = state_home or _default_state_home()
+    redacted = _redact_secrets(options)
+    encoded = json.dumps(redacted, ensure_ascii=True, sort_keys=True, separators=(",", ":"), default=str)
+    digest = hashlib.sha256(encoded.encode("utf-8")).hexdigest()[:16]
+    return root / "plugins" / _safe_segment(provider_id) / _safe_segment(alias) / digest
+
+
+def _default_state_home() -> Path:
+    override = os.environ.get("JUSI_STATE_HOME", "").strip()
+    if override:
+        return Path(os.path.expanduser(override)).resolve()
+    xdg_state = os.environ.get("XDG_STATE_HOME", "").strip()
+    if xdg_state:
+        return (Path(os.path.expanduser(xdg_state)) / "jusi").resolve()
+    return (Path.home() / ".local" / "state" / "jusi").resolve()
+
+
+def _redact_secrets(value: Any, *, key: str = "") -> Any:
+    lowered = key.lower().replace("-", "_")
+    if any(marker in lowered for marker in _SECRET_MARKERS):
+        return "<redacted>"
+    if isinstance(value, Mapping):
+        return {str(item_key): _redact_secrets(item, key=str(item_key)) for item_key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_redact_secrets(item) for item in value]
+    return deepcopy(value)
+
+
+def _safe_segment(value: object) -> str:
+    normalized = re.sub(r"[^A-Za-z0-9_.-]+", "-", str(value).strip()).strip("-._")
+    return normalized[:120] or "default"
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (FileNotFoundError, OSError, UnicodeError, json.JSONDecodeError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def _write_json(path: Path, payload: Mapping[str, Any]) -> None:
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.{threading.get_ident()}.tmp")
+    descriptor = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as stream:
+            json.dump(dict(payload), stream, ensure_ascii=True, sort_keys=True)
+            stream.write("\n")
+        temporary.replace(path)
+    except BaseException:
+        temporary.unlink(missing_ok=True)
+        raise

jusi_sql/visidata.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True)
+class SqlSheetActions:
+    """Provider-owned behavior exposed through shared VisiData commands."""
+
+    fetch_more: Callable[[int], int] | None = None
+    commit: Callable[[], None] | None = None
+    rollback: Callable[[], None] | None = None
+
+
+def bind_sql_actions(sheet: Any, actions: SqlSheetActions) -> None:
+    """Attach actions to one result sheet without a process-global session."""
+    setattr(sheet, "jusi_sql_actions", actions)
+
+
+def find_sql_actions(sheet: Any) -> SqlSheetActions | None:
+    """Find the owning result sheet from a VisiData-derived sheet chain."""
+    current = sheet
+    seen: set[int] = set()
+    while current is not None:
+        marker = id(current)
+        if marker in seen:
+            return None
+        seen.add(marker)
+        actions = getattr(current, "jusi_sql_actions", None)
+        if isinstance(actions, SqlSheetActions):
+            return actions
+        current = getattr(current, "source", None)
+    return None
+
+
+def install_visidata_commands(visidata_module: Any | None = None) -> None:
+    """Install provider-neutral fetch/transaction commands once per application."""
+    if visidata_module is None:
+        import visidata as visidata_module  # type: ignore[no-redef]
+    base_sheet = visidata_module.BaseSheet
+    vd = visidata_module.vd
+    marker = "_jusi_sql_family_commands_v1"
+    if getattr(base_sheet, marker, False):
+        return
+
+    def actions_for(sheet: Any) -> SqlSheetActions | None:
+        actions = find_sql_actions(sheet)
+        if actions is None:
+            vd.warning("No SQL result session owns this sheet")
+        return actions
+
+    for number in range(1, 10):
+        def fetch(sheet: Any, count: int = number) -> None:
+            actions = actions_for(sheet)
+            if actions is None:
+                return
+            if actions.fetch_more is None:
+                vd.warning("This SQL provider does not support incremental fetch")
+                return
+            actions.fetch_more(count)
+
+        base_sheet.command(
+            str(number),
+            f"jusi-sql-fetch-{number}",
+            f"fetch {number} more SQL rows",
+            replay=False,
+        )(fetch)
+
+    @base_sheet.command("gf", "jusi-sql-fetch-prompt", "fetch more SQL rows", replay=False)
+    def fetch_prompt(sheet: Any) -> None:
+        actions = actions_for(sheet)
+        if actions is None:
+            return
+        if actions.fetch_more is None:
+            vd.warning("This SQL provider does not support incremental fetch")
+            return
+        raw = vd.input("fetch rows (0 for all): ")
+        try:
+            count = int(str(raw).strip())
+        except ValueError:
+            vd.warning("Fetch count must be a number")
+            return
+        if count < 0:
+            vd.warning("Fetch count must be at least 0")
+            return
+        actions.fetch_more(count)
+
+    @base_sheet.command("gc", "jusi-sql-commit", "commit SQL transaction", replay=False)
+    def commit(sheet: Any) -> None:
+        actions = actions_for(sheet)
+        if actions is None:
+            return
+        if actions.commit is None:
+            vd.warning("This SQL provider does not support transactions")
+            return
+        actions.commit()
+
+    @base_sheet.command("gr", "jusi-sql-rollback", "roll back SQL transaction", replay=False)
+    def rollback(sheet: Any) -> None:
+        actions = actions_for(sheet)
+        if actions is None:
+            return
+        if actions.rollback is None:
+            vd.warning("This SQL provider does not support transactions")
+            return
+        actions.rollback()
+
+    setattr(base_sheet, marker, True)

jusi_sql/worker.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Mapping, Protocol, Union
+
+from jusi.plugin_api import OperationRejected, WorkerContext, WorkerResult
+
+from .completion import CompletionItem, SqlCompletionRequest
+
+
+@dataclass(frozen=True)
+class SqlExecuteRequest:
+    alias: str
+    sql: str
+    options: dict[str, Any]
+
+    @classmethod
+    def from_payload(cls, payload: Mapping[str, Any]) -> "SqlExecuteRequest":
+        alias = payload.get("alias")
+        sql = payload.get("sql")
+        options = payload.get("options")
+        if not isinstance(alias, str) or not alias.strip():
+            raise OperationRejected("SQL execute requires an alias", reason="invalid_request")
+        if not isinstance(sql, str):
+            raise OperationRejected("SQL execute requires string sql", reason="invalid_request")
+        if not isinstance(options, dict):
+            raise OperationRejected("SQL execute requires provider options", reason="invalid_request")
+        return cls(alias.strip(), sql, dict(options))
+
+
+class SqlSession(Protocol):
+    def execute(self, request: SqlExecuteRequest) -> Union[WorkerResult, dict[str, Any]]: ...
+    def followup(self, body: str) -> Union[WorkerResult, dict[str, Any]]: ...
+    def complete(self, request: SqlCompletionRequest) -> Any: ...
+    def interrupt(self) -> None: ...
+    def editor_action(self, action: str, selection: dict[str, Any]) -> WorkerResult: ...
+    def close(self) -> None: ...
+
+
+class SqlWorker:
+    """Composition-based 1.0 operation router for one exact SQL session."""
+
+    def __init__(
+        self,
+        context: WorkerContext,
+        session_factory: Callable[[WorkerContext], SqlSession],
+    ) -> None:
+        self.context = context
+        self._session = session_factory(context)
+        self._executed = False
+        self._closed = False
+
+    def handle(self, operation: str, payload: dict[str, Any]) -> WorkerResult:
+        if self._closed:
+            raise OperationRejected("SQL session is closed", reason="conflict")
+        if operation == "execute":
+            if self._executed:
+                raise OperationRejected("SQL session was already started", reason="conflict")
+            request = SqlExecuteRequest.from_payload(payload)
+            result = self._session.execute(request)
+            self._executed = True
+            return _worker_result(result)
+        if not self._executed:
+            raise OperationRejected("SQL session has not started", reason="conflict")
+        if operation == "followup":
+            body = payload.get("body")
+            if not isinstance(body, str):
+                raise OperationRejected("SQL followup requires string body", reason="invalid_request")
+            return _worker_result(self._session.followup(body))
+        if operation == "complete":
+            try:
+                request = SqlCompletionRequest.from_payload(payload)
+            except ValueError as exc:
+                raise OperationRejected(str(exc), reason="invalid_request") from exc
+            completed = self._session.complete(request)
+            if isinstance(completed, dict) and isinstance(completed.get("items"), list):
+                return WorkerResult(completed)
+            items = [item.to_dict() if isinstance(item, CompletionItem) else dict(item) for item in completed]
+            return WorkerResult({"items": items})
+        if operation == "editor_action":
+            action = payload.get("action")
+            selection = payload.get("selection")
+            if action not in {"copy", "open", "show_diff"} or not isinstance(selection, dict):
+                raise OperationRejected("Invalid SQL editor action", reason="invalid_request")
+            return self._session.editor_action(action, selection)
+        raise OperationRejected(f"Unsupported SQL operation {operation!r}", reason="unsupported")
+
+    def interrupt(self) -> None:
+        # Jusi invokes this concurrently. The provider hook must be prompt and
+        # thread-safe; this router deliberately takes no ordinary-operation lock.
+        if not self._closed:
+            self._session.interrupt()
+
+    def close(self) -> None:
+        if not self._closed:
+            self._closed = True
+            self._session.close()
+
+
+class StagedApplicationPayload:
+    """A private, client-owned JSON handoff for a terminal application."""
+
+    def __init__(self, payload: Mapping[str, Any], *, prefix: str = "jusi-sql-") -> None:
+        self.directory = Path(tempfile.mkdtemp(prefix=prefix))
+        self.directory.chmod(0o700)
+        self.path = self.directory / "payload.json"
+        descriptor = os.open(self.path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+        try:
+            with os.fdopen(descriptor, "w", encoding="utf-8") as stream:
+                json.dump(dict(payload), stream, ensure_ascii=False)
+        except BaseException:
+            self.close()
+            raise
+
+    def close(self) -> None:
+        shutil.rmtree(self.directory, ignore_errors=True)
+
+
+def _worker_result(value: Union[WorkerResult, dict[str, Any]]) -> WorkerResult:
+    return value if isinstance(value, WorkerResult) else WorkerResult(dict(value))

jusi_sql-0.2.0.dist-info/METADATA

@@ -0,0 +1,175 @@
+Metadata-Version: 2.5
+Name: jusi-sql
+Version: 0.2.0
+Summary: The SQL plugin-family contract and reusable provider toolkit for Jusi 1.0
+Author: Jusi contributors
+License: MIT License
+        
+        Copyright (c) 2026 notawhaleble
+        
+        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.
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: jusi<2,>=1.0
+Requires-Dist: sqlparse<0.6,>=0.5
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == 'test'
+Provides-Extra: visidata
+Requires-Dist: visidata<4,>=3; extra == 'visidata'
+Description-Content-Type: text/markdown
+
+# jusi-sql
+
+`jusi-sql` is the independently installable SQL plugin family for Jusi 1.0.
+It owns the user-facing `%%sql` contract and the provider-neutral code that
+SQLite, PostgreSQL, ClickHouse, and future database plugins should share. It is
+not an exact provider and therefore publishes no `jusi.plugins.v1` entry point.
+
+## Family contract
+
+Every exact SQL provider advertises the same catalog claim:
+
+- family `sql`, magic `sql`
+- capabilities `execute`, `followup`, `complete`, `interrupt`, and
+  `editor_actions`
+- shared `sql` syntax and indentation profiles
+- terminal-interactive presentation
+
+An exact provider may refine syntax after handoff (for example `pgsql` or
+`clickhouse`), but may not change the shared capabilities or presentation.
+Providers own connections, transactions, dialect metadata queries,
+cancellation, result rendering, selection meaning, and application IPC.
+
+The family owns target configuration and selection, deterministic ownership of
+one `%%sql` magic, the initial handoff payload, continuing-operation parsing,
+metadata-aware completion, safe cache paths, and private application staging.
+There is no process-global live-session registry. A worker and its exact
+provider session belong to one client in one notebook-runtime generation.
+
+## Configuration
+
+The canonical 1.0 shape is:
+
+```toml
+[sql.targets.warehouse]
+provider = "clickhouse"
+host = "db.internal"
+database = "analytics"
+
+[sql.targets.reporting]
+provider = "postgres"
+host = "pg.internal"
+dbname = "reports"
+```
+
+Then a cell starts with `%%sql warehouse`. The provider is resolved only inside
+the target kernel against adapters installed in that runtime. Missing, unknown,
+unavailable, and ambiguous providers fail without printing target options. The
+historical `[sql.warehouse]` shape is accepted during migration, but it cannot
+be mixed with `[sql.targets.*]`.
+
+Secrets may be provider options because the target worker needs them. They are
+never placed in catalog metadata or error messages. Prefer provider-owned
+environment or secret resolution where possible.
+
+## Exact-provider integration
+
+Catalog code stays lightweight:
+
+```python
+from jusi_sql import sql_catalog_entry
+
+def catalog_entry():
+    return sql_catalog_entry(
+        plugin_id="postgres",
+        plugin_version="1.0.0",
+        distribution="jusi-postgres",
+        kernel_extension="jusi_postgres.kernel",
+        worker_entry_point="jusi_postgres.worker:create_worker",
+        provider_presentation={"syntax": "pgsql", "indent": "sql"},
+    )
+```
+
+The exact kernel module retains its own attested identity while sharing the
+dispatcher:
+
+```python
+from jusi_sql.kernel import SqlKernelAdapter
+
+_adapter = SqlKernelAdapter(
+    plugin_id="postgres",
+    plugin_version="1.0.0",
+    selectors=("postgres", "postgresql"),
+    empty_sql="SELECT 1 WHERE false",
+)
+
+jusi_kernel_adapter_v1 = _adapter.manifest
+configure_jusi_runtime_v1 = _adapter.configure
+load_ipython_extension = _adapter.load
+```
+
+Each installed adapter registers its identity in the shared dispatcher. After
+all catalog modules attest, `%%sql` resolves the alias and emits one exact 1.0
+handoff. Registration rejects selector collisions and an unrelated extension
+already owning `%%sql`; it never relies on import order.
+
+Worker code uses composition rather than the retired handler hierarchy:
+
+```python
+from jusi_sql.worker import SqlWorker
+
+def create_worker(context):
+    return SqlWorker(context, PostgresSession)
+```
+
+`PostgresSession` implements `execute`, `followup`, `complete`, `interrupt`,
+`editor_action`, and `close`. `interrupt` is called concurrently and must be
+prompt and thread-safe. Recoverable database errors should raise
+`jusi.plugin_api.OperationRejected`; broken sessions should fail normally so
+Jusi fences the worker.
+
+## Completion and metadata
+
+`complete_sql` consumes a `MetadataSnapshot` and Jusi's full completion payload.
+It returns absolute Unicode code-point ranges, preserves suffix text, handles
+empty prefixes, and understands schema, table, alias, and column qualification.
+Exact providers only collect dialect metadata and supply keyword lists.
+
+`MetadataCache` provides stale-while-refresh snapshots.
+`sql_cache_directory` creates stable provider-scoped paths while recursively
+redacting secret values from the fingerprint.
+
+Providers using VisiData may install the optional `visidata` extra and use
+`SqlSheetActions`, `bind_sql_actions`, and `install_visidata_commands`. This
+supplies the common numeric/`gf` fetch and `gc`/`gr` transaction commands on
+result sheets and all derived sheets. Live callbacks remain attached to their
+own provider sheet; the family does not keep a global current session.
+
+## Migration from 0.x providers
+
+Remove `DisplayHandlerSpec`, `BaseSqlHandler`, `SqlSheetRuntime`, environment
+payloads, and the `jusi plugin-runtime` bootstrap. Split each provider into
+catalog, kernel adapter, worker, and terminal-application import boundaries.
+Keep VisiData and driver imports out of catalog and worker startup.
+
+PostgreSQL- and ClickHouse-specific connection, streaming, binary-value,
+Kerberos, transaction, and cancellation code remains in those packages. Their
+duplicated target parsing, magic registration, completion models, relation
+parsing, metadata cache, safe cache path, and operation dispatch should be
+deleted in favor of this family package during their 1.0 migrations.

jusi_sql-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+jusi_sql/__init__.py,sha256=a0GYuHasAO2BdL5DD8B1TobM2ApyYLxSR34PZG8PIso,1492
+jusi_sql/catalog.py,sha256=5pRzdWaOU6ukyZNus4cV2yeoxv9GczcmRdtI52oK8e8,1884
+jusi_sql/completion.py,sha256=heihwJkt9XTVDUiJA4_GXY7SL6Dgiphi7mlOCL19Qdw,12000
+jusi_sql/config.py,sha256=8XmIkLMwfe1pbTJv9pAlkGu5BFdS_BBFQF2YrO-2o7M,4854
+jusi_sql/kernel.py,sha256=HO2TybS2vTmCt4SZqJA957n0uO_15mogU2dOv8K7ib0,4888
+jusi_sql/metadata.py,sha256=8nY5Kn1YgjDB3-Rm6I8aKCcHyD-KLKFwYrn8CCfTYYA,5246
+jusi_sql/visidata.py,sha256=2xE1mvobIkUCuHxvufR2OUX2fLsM-wcQeVcnKCprdTk,3775
+jusi_sql/worker.py,sha256=PbmZNQTdFglIc3rEMTa_ODJm6bSt3QbS5MAg7ow8Y9Y,5277
+jusi_sql-0.2.0.dist-info/METADATA,sha256=eMklo1tzLiox6adl8NSck4Cm7CzfSfsp0sAY7xXPfXM,7079
+jusi_sql-0.2.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+jusi_sql-0.2.0.dist-info/licenses/LICENSE,sha256=YSDMzYJrAu4QMyHcnOSrhmjYzkD9rEKha8G2CH4p3AA,1069
+jusi_sql-0.2.0.dist-info/RECORD,,

jusi_sql-0.2.0.dist-info/WHEEL

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

jusi_sql-0.2.0.dist-info/licenses/LICENSE

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