provisa 0.1.0a244__py3-none-any.whl

buenavista/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2026 Kenneth Stott
+# Canary: 6112eecd-1577-4f0f-a632-ecd48ca18735
+#
+# This source code is licensed under the Business Source License 1.1
+# found in the LICENSE file in the root directory of this source tree.
+#
+# NOTICE: Use of this software for training artificial intelligence or
+# machine learning models is strictly prohibited without explicit written
+# permission from the copyright holder.

buenavista/bv_dialects.py

@@ -0,0 +1,123 @@
+# Copyright (c) 2026 Kenneth Stott
+# Canary: 59df7f5e-dd95-4eae-ba68-bfe4f163ec1b
+#
+# This source code is licensed under the Business Source License 1.1
+# found in the LICENSE file in the root directory of this source tree.
+#
+# NOTICE: Use of this software for training artificial intelligence or
+# machine learning models is strictly prohibited without explicit written
+# permission from the copyright holder.
+
+from sqlglot import exp
+from sqlglot.dialects import DuckDB, Postgres, Trino
+from sqlglot.tokens import TokenType
+
+
+# Additional expressions I need
+class ToISO8601(exp.Func):
+    pass
+
+
+class BVPostgres(Postgres):
+    pass
+
+
+# Trino-specific modifications
+class BVTrino(Trino):
+    class Tokenizer(Trino.Tokenizer):
+        KEYWORDS = {
+            **Trino.Tokenizer.KEYWORDS,
+            "DEALLOCATE": TokenType.COMMAND,
+        }
+
+    class Parser(Trino.Parser):
+        FUNCTIONS = {
+            **Trino.Parser.FUNCTIONS,
+            "TO_ISO8601": ToISO8601.from_arg_list,
+        }
+
+
+# DuckDB-specific modifications
+def _duckdb_command_handler(self, expression):
+    cmd = expression.this.upper()
+    if cmd == "PREPARE":
+        literal = expression.expression.this
+        tokens = literal.split()
+        stmt = tokens[0]
+        if tokens[1].upper() not in ("FROM", "AS"):
+            raise Exception("Badness badness")
+        res = " ".join(tokens[2:])
+        rest = BVDuckDB().generate(BVTrino().parse(res)[0])
+        return f"PREPARE {stmt} AS " + rest
+    elif cmd == "SHOW":
+        literal = expression.expression.this
+        tokens = literal.split()
+        entity = tokens[0].upper()
+        if entity == "CATALOGS":
+            q = "SELECT DISTINCT catalog_name as Catalog FROM information_schema.schemata"
+            if len(tokens) >= 3:
+                if len(tokens) == 5:
+                    like = tokens[2].replace(tokens[4], "")
+                else:
+                    like = tokens[2]
+                q += " WHERE catalog_name LIKE " + like
+            else:
+                return q
+        elif entity == "SCHEMAS":
+            q = "SELECT DISTINCT schema_name as Schema FROM information_schema.schemata"
+            if len(tokens) > 1 and tokens[1].upper() == "FROM":
+                q += f" WHERE catalog_name = '{tokens[2]}'"
+                if len(tokens) >= 5:
+                    if len(tokens) == 7:
+                        like = tokens[4].replace(tokens[6], "")
+                    else:
+                        like = tokens[4]
+                    q += " AND schema_name LIKE " + like
+            else:
+                q += " WHERE catalog_name IN (SELECT current_database())"
+                if len(tokens) >= 3:
+                    if len(tokens) == 5:
+                        like = tokens[2].replace(tokens[4], "")
+                    else:
+                        like = tokens[2]
+                    q += " AND schema_name LIKE " + like
+            return q
+        elif entity == "TABLES":
+            q = "SELECT DISTINCT table_name as Table from information_schema.tables"
+            if len(tokens) > 1 and tokens[1].upper() == "FROM":
+                q += f" WHERE table_schema = '{tokens[2]}'"
+                if len(tokens) >= 5:
+                    if len(tokens) == 7:
+                        like = tokens[4].replace(tokens[6], "")
+                    else:
+                        like = tokens[4]
+                    q += " AND table_name LIKE " + like
+            else:
+                q += " WHERE table_schema IN (SELECT current_schema())"
+                if len(tokens) >= 3:
+                    if len(tokens) == 5:
+                        like = tokens[2].replace(tokens[4], "")
+                    else:
+                        like = tokens[2]
+                    q += " AND table_name LIKE " + like
+            return q
+        elif entity == "COLUMNS" and tokens[1].upper() == "FROM":
+            return f"DESCRIBE {tokens[2]}"
+        elif entity == "TRANSACTION":
+            return "SELECT 'read committed' as transaction_isolation"
+        elif entity == "STANDARD_CONFORMING_STRINGS":
+            return "SELECT 'on' as standard_conforming_strings"
+        else:
+            raise Exception("Unhandled SHOW command: " + literal)
+
+    return expression.sql()
+
+
+class BVDuckDB(DuckDB):
+    class Generator(DuckDB.Generator):
+        TRANSFORMS = {
+            **DuckDB.Generator.TRANSFORMS,
+            exp.CurrentTimestamp: lambda *_: "CURRENT_TIMESTAMP",
+            ToISO8601: lambda self, e: f"STRFTIME({self.sql(e, 'this')}, '%Y-%m-%dT%H:%M:%S.%f%z')",
+            exp.Command: _duckdb_command_handler,
+        }

buenavista/core.py

@@ -0,0 +1,150 @@
+# Copyright (c) 2026 Kenneth Stott
+# Canary: cf04da0e-7202-4517-8d77-047866a039f2
+#
+# This source code is licensed under the Business Source License 1.1
+# found in the LICENSE file in the root directory of this source tree.
+#
+# NOTICE: Use of this software for training artificial intelligence or
+# machine learning models is strictly prohibited without explicit written
+# permission from the copyright holder.
+
+import enum
+import json
+import re
+import uuid
+from typing import Any, Dict, Iterator, List, Optional, Tuple
+
+
+class BVType(enum.Enum):
+    NULL = 0
+    BIGINT = 1
+    BOOL = 2
+    BYTES = 3
+    DATE = 4
+    FLOAT = 5
+    INTEGER = 6
+    INTERVAL = 7
+    JSON = 8
+    DECIMAL = 9
+    TEXT = 10
+    TIME = 11
+    TIMESTAMP = 12
+    UNKNOWN = 13
+    ARRAY = 14
+    INTEGERARRAY = 15
+    STRINGARRAY = 16
+
+
+class QueryResult:
+    """The BV representation of a result of a query."""
+
+    def __init__(self):
+        self.result_format = None
+
+    def has_results(self) -> bool:
+        raise NotImplementedError
+
+    def column_count(self):
+        raise NotImplementedError
+
+    def column(self, index: int) -> Tuple[str, BVType]:
+        raise NotImplementedError
+
+    def rows(self) -> Iterator[List]:
+        raise NotImplementedError
+
+    def status(self) -> str:
+        raise NotImplementedError
+
+
+class Session:
+    def __init__(self):
+        self.id = uuid.uuid4()
+
+    def cursor(self):
+        raise NotImplementedError
+
+    def close(self):
+        raise NotImplementedError
+
+    def execute_sql(self, sql: str, params=None) -> QueryResult:
+        raise NotImplementedError
+
+    def in_transaction(self) -> bool:
+        raise NotImplementedError
+
+    def load_df_function(self, table: str):
+        raise NotImplementedError
+
+
+class Connection:
+    """Translation layer from an upstream data source into the BV representation of a query result."""
+
+    def __init__(self):
+        self._sessions = {}
+
+    def create_session(self) -> Session:
+        sess = self.new_session()
+        self._sessions[sess.id] = sess
+        return sess
+
+    def get_session(self, id: int) -> Optional[Session]:
+        return self._sessions.get(id)
+
+    def close_session(self, session: Session):
+        if session and session.id in self._sessions:
+            del self._sessions[session.id]
+            session.close()
+
+    def new_session(self) -> Session:
+        raise NotImplementedError
+
+    def parameters(self) -> Dict[str, str]:
+        return {}
+
+
+class Extension:
+    @classmethod
+    def check_json(cls, payload: str) -> Optional[dict]:
+        is_json = False
+        if payload[-1] == "}":
+            is_json = True
+        elif payload[-1] == ";" and payload[-2] == "}":
+            is_json = True
+        # Strip any SQL comments
+        if is_json:
+            payload = re.sub(r"\/\*.*\*\/", "", payload)
+            return json.loads(payload)
+        return None
+
+    def type(self) -> str:
+        raise NotImplementedError
+
+    def apply(self, params: dict, session: Session) -> QueryResult:
+        raise NotImplementedError
+
+
+class SimpleQueryResult(QueryResult):
+    def __init__(self, name: str, value: Any, type: BVType):
+        super().__init__()
+        self.name = name
+        self.value = str(value)
+        self.type = type
+
+    def has_results(self):
+        return True
+
+    def column_count(self):
+        return 1
+
+    def column(self, index: int) -> Tuple[str, BVType]:
+        if index == 0:
+            return (self.name, self.type)
+        else:
+            raise IndexError
+
+    def rows(self) -> Iterator[List]:
+        return iter([[self.value]])
+
+    def status(self) -> str:
+        return ""