turingdb 1.16.1.dev7__cp311-cp311-manylinux_2_35_x86_64.whl

turingdb/turingdb.py

@@ -0,0 +1,242 @@
+import time
+from typing import Literal, Optional
+
+from .exceptions import TuringDBException
+from .s3 import S3Client
+
+
+class TuringDB:
+    DEFAULT_HEADERS = {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+    }
+
+    def __init__(
+        self,
+        instance_id: str = "",
+        auth_token: str = "",
+        host: str = "http://localhost:6666",
+        timeout: Optional[int] = None,
+    ):
+        import copy
+
+        import httpx
+
+        self.host = host
+        self._client = httpx.Client(
+            auth=None,
+            verify=False,
+            timeout=timeout,
+        )
+        self._s3_client: Optional[S3Client] = None
+        self._query_exec_time: Optional[float] = None
+        self._total_exec_time: Optional[float] = None
+        self._t0: float = 0
+        self._t1: float = 0
+        self._timeout = timeout
+
+        self._params = {
+            "graph": "default",
+        }
+
+        self._headers = copy.deepcopy(TuringDB.DEFAULT_HEADERS)
+
+        if instance_id != "":
+            self._headers["Turing-Instance-Id"] = instance_id
+
+        if auth_token != "":
+            self._headers["Authorization"] = f"Bearer {auth_token}"
+
+    def try_reach(self, timeout: int = 5):
+        self._client.timeout = timeout
+        self.list_available_graphs()
+        self._client.timeout = self._timeout
+
+    def warmup(self, timeout: int = 5):
+        self._client.timeout = timeout
+        self.query("LIST GRAPH")
+        self._client.timeout = self._timeout
+
+    def list_available_graphs(self) -> list[str]:
+        return self._send_request("list_avail_graphs")["data"]
+
+    def list_loaded_graphs(self) -> list[str]:
+        return self._send_request("list_loaded_graphs")["data"][0][0]
+
+    def is_graph_loaded(self) -> bool:
+        return self._send_request(
+            "is_graph_loaded", params={"graph": self.get_graph()}
+        )["data"]
+
+    def load_graph(self, graph_name: str, raise_if_loaded: bool = True):
+        try:
+            return self._send_request("load_graph", params={"graph": graph_name})
+        except TuringDBException as e:
+            if raise_if_loaded or e.__str__() != "GRAPH_ALREADY_EXISTS":
+                raise e
+
+    def create_graph(self, graph_name: str):
+        return self.query(f"create graph {graph_name}")
+
+    def query(self, query: str):
+        json = self._send_request("query", data=query, params=self._params)
+
+        if not isinstance(json, dict):
+            raise TuringDBException("Invalid response from the server")
+
+        return self._parse_chunks(json)
+
+    def set_commit(self, commit: str):
+        self._params["commit"] = commit
+
+    def set_change(self, change: int | str):
+        if isinstance(change, int):
+            change = f"{change:x}"
+        self._params["change"] = change
+
+    def checkout(self, change: int | Literal["main"] = "main", commit: str = "HEAD"):
+        if change == "main":
+            if "change" in self._params:
+                del self._params["change"]
+        else:
+            self.set_change(change)
+
+        if commit == "HEAD":
+            if "commit" in self._params:
+                del self._params["commit"]
+        else:
+            self.set_commit(commit)
+
+    def new_change(self) -> int:
+        if self._params.get("change") is not None:
+            raise TuringDBException("Cannot create a new change while working on one")
+
+        if self._params.get("commit") is not None:
+            raise TuringDBException("Cannot create a new change while working on a commit")
+
+        res = self.query("CHANGE NEW")
+        self._params["change"] = res.loc[0, "changeID"]
+        change_id = int(self._params["change"])
+        return change_id
+
+
+    def set_graph(self, graph_name: str):
+        self._params["graph"] = graph_name
+
+    def get_graph(self) -> str:
+        return self._params["graph"]
+
+    def s3_connect(
+        self,
+        bucket_name: str,
+        access_key: Optional[str] = None,
+        secret_key: Optional[str] = None,
+        region: Optional[str] = None,
+        use_scratch: bool = True,
+    ):
+        from .s3 import S3Client
+
+        self._s3_client = S3Client(
+            bucket_name, access_key, secret_key, region, use_scratch
+        )
+        self._s3_client.connect(self)
+
+    def transfer(self, src: str, dst: str):
+        if self._s3_client is None:
+            raise TuringDBException("S3 client is not connected")
+
+        self._s3_client.transfer(src, dst)
+
+    def _send_request(
+        self,
+        path: str,
+        data: Optional[dict | str] = None,
+        params: Optional[dict] = None,
+    ):
+        import orjson
+
+        self._query_exec_time = None
+        self._total_exec_time = None
+        self._t0 = time.time()
+
+        if data is None:
+            data = ""
+
+        url = f"{self.host}/{path}"
+
+        if isinstance(data, dict):
+            response = self._client.post(
+                url, json=data, params=params, headers=self._headers
+            )
+        else:
+            response = self._client.post(
+                url, content=data, params=params, headers=self._headers
+            )
+        response.raise_for_status()
+
+        json = orjson.loads(response.text)
+
+        if isinstance(json, dict):
+            err = json.get("error")
+            if err is not None:
+                details = json.get("error_details")
+                if details is not None:
+                    err = f"{err}: {details}"
+                raise TuringDBException(err)
+
+        self._t1 = time.time()
+        self._total_exec_time = (self._t1 - self._t0) * 1000
+
+        return json
+
+    def _parse_chunks(self, json: dict):
+        import pandas as pd
+
+        self._query_exec_time = json["time"]
+
+        header = json["header"]
+        column_names = header["column_names"]
+        column_types = header["column_types"]
+
+        if len(column_names) != len(column_types):
+            raise Exception("Query response column names and types do not match")
+
+        dtype_map = {
+            "String": "string",
+            "Int64": "Int64",
+            "UInt64": "UInt64",
+            "Double": "float64",
+            "Bool": "boolean",
+        }
+
+        df = pd.DataFrame()
+
+        for chunk in json["data"]:
+            df_chunk = pd.DataFrame({
+                cname: pd.Series(col, dtype=dtype_map.get(ctype, "object"))
+                for (cname, ctype), col in zip(zip(column_names, column_types), chunk)
+            })
+            df = pd.concat([df, df_chunk], ignore_index=True)
+
+        self._t1 = time.time()
+        self._total_exec_time = (self._t1 - self._t0) * 1000
+
+        return df
+
+    def get_query_exec_time(self) -> Optional[float]:
+        return self._query_exec_time
+
+    def get_total_exec_time(self) -> Optional[float]:
+        return self._total_exec_time
+
+    @property
+    def current_graph(self) -> str:
+        return self._params["graph"]
+
+    @property
+    def current_commit(self) -> str:
+        return self._params.get("commit") or "HEAD"
+   
+    @property
+    def current_change(self) -> str:
+        return self._params.get("change") or "main"

turingdb/turingsh/__init__.py

@@ -0,0 +1,3 @@
+from .turingsh import main
+
+__all__ = ["main"]

turingdb/turingsh/command.py

@@ -0,0 +1,24 @@
+from functools import wraps
+
+from click import ClickException
+
+
+def shell_command(click_cmd):
+    """
+    Decorator that wraps a Click command to be callable from a shell
+    with exception handling instead of sys.exit().
+    """
+
+    @wraps(click_cmd)
+    def wrapper(client, *args, **kwargs):
+        try:
+            return click_cmd.main(
+                args=list(args),
+                prog_name=click_cmd.name,
+                obj=client,
+                standalone_mode=False,
+            )
+        except ClickException as e:
+            raise RuntimeError(e.format_message()) from e
+
+    return wrapper

turingdb/turingsh/greeter.py

@@ -0,0 +1,42 @@
+import re
+
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.shortcuts import print_formatted_text
+
+
+def get_visible_width(text):
+    """Remove HTML-like tags and get actual visible character count"""
+    return len(re.sub(r"<[^>]*>", "", text)) - 2
+
+
+def center_with_html(text, total_width):
+    """Center text accounting for HTML markup"""
+    visible_width = get_visible_width(text)
+    padding = (total_width - visible_width) // 2
+    return " " * padding + text + " " * (total_width - visible_width - padding)
+
+
+def greet():
+
+    topbar = (
+        "<skyblue>╔═════════════════════════════════════════════════════╗</skyblue>\n"
+    )
+    botbar = (
+        "<skyblue>╚═════════════════════════════════════════════════════╝</skyblue>"
+    )
+    delimiter = "<skyblue>║</skyblue>"
+    title = "<b>TuringDB Interactive Shell</b>"
+    help_msg = "Type <i>help</i> for help"
+    quit_msg = "Type <i>quit</i> or press <i>Ctrl+D</i> to quit"
+
+    box_content_width = 51
+
+    print_formatted_text(
+        HTML(
+            f"{topbar}"
+            f"{delimiter}{center_with_html(title, box_content_width)}{delimiter}\n"
+            f"{delimiter}{center_with_html(help_msg, box_content_width)}{delimiter}\n"
+            f"{delimiter}{center_with_html(quit_msg, box_content_width)}{delimiter}\n"
+            f"{botbar}"
+        )
+    )

turingdb/turingsh/turingsh.py

@@ -0,0 +1,367 @@
+"""
+TuringDB Shell Client
+"""
+
+import traceback
+from html import escape
+
+import click
+from prompt_toolkit import prompt
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.shortcuts import print_formatted_text
+
+from turingdb import TuringDB, TuringDBException
+from turingdb.turingsh.command import shell_command
+
+from . import greeter
+
+CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
+
+
+class ShellException(Exception):
+    pass
+
+
+def create_completer():
+    """Create command completer"""
+    commands = [
+        # Shell keywords
+        "cd",
+        "LIST_AVAIL_GRAPHS",
+        "LIST_LOADED_GRAPHS",
+        "help",
+        "quit",
+        "checkout",
+        # Query keywords
+        "DESCENDING",
+        "CONSTRAINT",
+        "MANDATORY",
+        "ASCENDING",
+        "OPTIONAL",
+        "CONTAINS",
+        "DISTINCT",
+        "EXTRACT",
+        "REQUIRE",
+        "COLLECT",
+        "STARTS",
+        "UNIQUE",
+        "FILTER",
+        "SINGLE",
+        "SCALAR",
+        "UNWIND",
+        "REMOVE",
+        "RETURN",
+        "CREATE",
+        "DELETE",
+        "DETACH",
+        "EXISTS",
+        "IS NOT",
+        "LIMIT",
+        "YIELD",
+        "MATCH",
+        "MERGE",
+        "ORDER",
+        "WHERE",
+        "UNION",
+        "FALSE",
+        "COUNT",
+        "DESC",
+        "CALL",
+        "NULL",
+        "TRUE",
+        "WHEN",
+        "NONE",
+        "THEN",
+        "ELSE",
+        "CASE",
+        "ENDS",
+        "DROP",
+        "SKIP",
+        "WITH",
+        "ANY",
+        "SET",
+        "ALL",
+        "ASC",
+        "NOT",
+        "END",
+        "XOR",
+        "FOR",
+        "ADD",
+        "AND",
+        "OR",
+        "IN",
+        "IS",
+        "BY",
+        "DO",
+        "OF",
+        "ON",
+        "IF",
+        "AS",
+    ]
+    return WordCompleter(commands, ignore_case=True)
+
+
+@click.group(invoke_without_command=True, context_settings=CONTEXT_SETTINGS)
+@click.option(
+    "--host",
+    "-l",
+    default="https://engines.turingdb.ai/sdk",
+    help="Change the address host",
+)
+@click.option("--local", "-L", is_flag=True, default=False, help="Use a local instance")
+@click.option("--auth-token", "-p", default="", help="Authentication token")
+@click.option("--instance-id", "-i", default="", help="Instance ID")
+@click.pass_context
+def main(ctx, host, local, auth_token, instance_id):
+    """TuringDB Shell - Interactive database client"""
+    if host == "https://engines.turingdb.ai/sdk":
+        # Host was not specified, use default
+        if local:
+            host = "http://localhost:6666"
+        else:
+            if auth_token == "" or instance_id == "":
+                print_formatted_text(
+                    HTML("<red>✘ Missing authentication information</red>")
+                )
+                print_formatted_text(
+                    HTML("<red>✘ Provide --auth-token and --instance-id</red>")
+                )
+                print()
+                exit(1)
+
+    client = TuringDB(
+        host=host,
+        auth_token=auth_token,
+        instance_id=instance_id,
+    )
+
+    start_shell(client)
+
+
+def start_shell(client: TuringDB):
+    """Start the interactive shell"""
+    history = InMemoryHistory()
+    completer = create_completer()
+
+    # Welcome message
+    greeter.greet()
+
+    try:
+        client.try_reach()
+        client.warmup()
+    except Exception as e:
+        print_formatted_text(HTML(f"<red>✘ Could not connect to TuringDB.\n{e}</red>"))
+        print()
+        return
+
+    print_formatted_text(HTML("<green>✓ Connected to TuringDB</green>"))
+    print()
+
+    shell_commands = {
+        "cd": change_graph,
+        "list_avail_graphs": list_available_graphs,
+        "list_loaded_graphs": list_loaded_graphs,
+        "checkout": checkout,
+    }
+
+    while True:
+        graph = client.get_graph()
+        checkedout = ""
+
+        if client.current_commit != "HEAD":
+            checkedout = f"@{client.current_commit}"
+        elif client.current_change != "main":
+            checkedout = f"@change-{client.current_change}"
+
+        try:
+            # Get user input with styling
+            user_input = prompt(
+                HTML(
+                    f"<b><cyan>turingdb:{graph}{checkedout}</cyan></b><gray>></gray> "
+                ),
+                completer=completer,
+                history=history,
+                multiline=False,
+            )
+
+            # Handle commands
+            cmd = user_input.strip()
+
+            if not cmd:
+                continue
+
+            cmd_lower = cmd.lower()
+            cmd_words = cmd_lower.split()
+
+            if len(cmd_words) == 0:
+                continue
+
+            if len(cmd_words) == 1:
+                match cmd_lower:
+                    case "quit":
+                        print_formatted_text(HTML("<yellow>Goodbye! 👋</yellow>"))
+                        break
+                    case "help":
+                        show_help()
+                        continue
+
+            if cmd_words[0] in shell_commands:
+                try:
+                    shell_commands[cmd_words[0]](client, *cmd_words[1:])
+                except ShellException as e:
+                    print_formatted_text(HTML(f"<red>✘ {e}</red>"))
+                except Exception as e:
+                    content = f"{e}\n{traceback.format_exc()}"
+                    print_formatted_text(
+                        HTML(f"<red>✘ Fatal error: {escape(str(content))}</red>")
+                    )
+                continue
+
+            # Execute query
+            try:
+                result = client.query(cmd)
+                print_formatted_text(HTML(f"<white>{escape(str(result))}</white>"))
+            except TuringDBException as e:
+                content = f"{e}"
+                print_formatted_text(HTML(f"<red>✘ {escape(str(content))}</red>"))
+                if "CHANGE_NOT_FOUND" in str(e):
+                    print_formatted_text(
+                        HTML("<yellow>⚠ Checking out to the latest commit...</yellow>")
+                    )
+                    checkout(client)
+
+            except Exception as e:
+                content = f"{e}\n{traceback.format_exc()}"
+                print_formatted_text(
+                    HTML(f"<red>✘ Fatal error: {escape(str(content))}</red>")
+                )
+
+            exec_time = client.get_total_exec_time()
+            if exec_time is not None:
+                print_formatted_text(
+                    HTML(
+                        f"<white>Total execution time: <yellow>{exec_time:.3f}</yellow> milliseconds</white>"
+                    )
+                )
+            query_time = client.get_query_exec_time()
+            if query_time is not None:
+                print_formatted_text(
+                    HTML(
+                        f"<white>Including query execution time: <yellow>{query_time:.3f}</yellow> milliseconds</white>"
+                    )
+                )
+
+            print()  # Add spacing
+
+        except KeyboardInterrupt:
+            print_formatted_text(
+                HTML('\n<yellow>Use "quit" or Ctrl+D to quit</yellow>')
+            )
+            continue
+        except EOFError:
+            print_formatted_text(HTML("\n<yellow>Goodbye! 👋</yellow>"))
+            break
+
+
+def show_help():
+    """Display help information"""
+    help_text = """<b>Available Commands:</b>
+    <cyan>cd my_graph</cyan>                - Change active graph
+    <cyan>checkout --change change-0</cyan> - Checkout to a specific change
+    <cyan>checkout --commit a2daef1f</cyan> - Checkout to a specific commit
+    <cyan>checkout</cyan>                   - Checkout to the latest commit
+    <cyan>LIST_AVAIL_GRAPHS</cyan>          - List available graphs
+    <cyan>LIST_LOADED_GRAPHS</cyan>         - List loaded graphs
+    <cyan>help</cyan>                       - Show this help
+    <cyan>EXIT</cyan> or <cyan>\\q</cyan>   - Quit shell
+
+<b>Example queries:</b>
+    <cyan>LOAD GRAPH my_graph</cyan>        - Load graph
+    <cyan>MATCH (n) RETURN n.name</cyan>    - Return all node names
+    
+<b>Tips:</b>
+    • Use <i>Tab</i> for command completion
+    • Use <i>↑/↓</i> arrows for command history"""
+
+    print_formatted_text(HTML(help_text))
+
+
+@shell_command
+@click.command()
+@click.option("--commit", default="HEAD", help="Commit hash or 'HEAD'")
+@click.option("--change", help="ID of the change")
+@click.pass_obj
+def checkout(client, commit: str, change: int):
+    """Checkout a commit or a change"""
+    try:
+        client.checkout(change=change or "main", commit=commit)
+        client.query("CALL db.history()")
+    except TuringDBException as e:
+        content = f"{e}"
+        print_formatted_text(HTML(f"<red>✘ {escape(str(content))}</red>"))
+        client.checkout()
+
+
+@shell_command
+@click.command()
+@click.argument("graph-name", default="default")
+@click.pass_obj
+def change_graph(client: TuringDB, graph_name: str):
+    """Change the current graph"""
+
+    try:
+        client.set_graph(graph_name)
+        if not client.is_graph_loaded():
+            print_formatted_text(
+                HTML(
+                    f"<red>✘ Graph {graph_name} needs to be loaded with 'load graph \"{graph_name}\"'</red>"
+                )
+            )
+            client.set_graph("default")
+        else:
+            print_formatted_text(
+                HTML(f"<green>✓ Changed graph to {graph_name}</green>")
+            )
+    except TuringDBException as e:
+        print_formatted_text(HTML(f"<red>✘ {e}</red>"))
+    except Exception as e:
+        content = f"{e}\n{traceback.format_exc()}"
+        print_formatted_text(HTML(f"<red>✘ Fatal error: {escape(str(content))}</red>"))
+
+
+@shell_command
+@click.command()
+@click.pass_obj
+def list_available_graphs(client: TuringDB):
+    """List available graphs"""
+
+    try:
+        graphs = client.list_available_graphs()
+        print_formatted_text(HTML(f"<white>{graphs}</white>"))
+    except TuringDBException as e:
+        content = f"{e}"
+        print_formatted_text(HTML(f"<red>✘ {escape(str(content))}</red>"))
+    except Exception as e:
+        content = f"{e}\n{traceback.format_exc()}"
+        print_formatted_text(HTML(f"<red>✘ Fatal error: {escape(str(content))}</red>"))
+
+
+@shell_command
+@click.command()
+@click.pass_obj
+def list_loaded_graphs(client: TuringDB):
+    """List loaded graphs"""
+
+    try:
+        graphs = client.list_loaded_graphs()
+        print_formatted_text(HTML(f"<white>{graphs}</white>"))
+    except TuringDBException as e:
+        print_formatted_text(HTML(f"<red>✘ {e}</red>"))
+    except Exception as e:
+        print_formatted_text(HTML(f"<red>✘ Fatal error: {e}</red>"))
+
+
+if __name__ == "__main__":
+    main()

turingdb-1.16.1.dev7.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.2
+Name: turingdb
+Version: 1.16.1.dev7
+Classifier: Operating System :: POSIX :: Linux
+Project-URL: Homepage, https://github.com/turing-db/turingdb-python
+Project-URL: Repository, https://github.com/turing-db/turingdb-python
+Requires-Python: >=3.10
+Requires-Dist: auditwheel>=6.6.0
+Requires-Dist: boto3>=1.42.22
+Requires-Dist: boto3-stubs>=1.42.22
+Requires-Dist: click>=8.3.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: mypy>=1.19.1
+Requires-Dist: orjson>=3.11.5
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: pandas-stubs>=2.3.3.251219
+Requires-Dist: patchelf>=0.17.2.4
+Requires-Dist: prompt-toolkit>=3.0.52
+