turingdb 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

turingdb/__init__.py

@@ -1,3 +1,4 @@
 from .turingdb import TuringDB, TuringDBException
+from .turingsh import main as turingsh
 
-__all__ = ["TuringDB", "TuringDBException"]
+__all__ = ["TuringDB", "TuringDBException", "turingsh"]

turingdb/__init__.pyi

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from _typeshed import Incomplete
 
 class TuringDBException(Exception):
@@ -6,13 +8,24 @@ class TuringDBException(Exception):
 class TuringDB:
     DEFAULT_HEADERS: Incomplete
     host: Incomplete
-    def __init__(self, instance_id: str = '', auth_token: str = '', host: str = 'https://engines.turingdb.ai/sdk') -> None: ...
+    def __init__(
+        self,
+        instance_id: str = "",
+        auth_token: str = "",
+        host: str = "https://engines.turingdb.ai/sdk",
+    ) -> None: ...
+    def try_reach(self, timeout: int = 5): ...
+    def warmup(self, timeout: int = 5): ...
     def list_available_graphs(self) -> list[str]: ...
     def list_loaded_graphs(self) -> list[str]: ...
+    def is_graph_loaded(self) -> bool: ...
     def load_graph(self, graph_name: str, raise_if_loaded: bool = True): ...
     def create_graph(self, graph_name: str): ...
     def query(self, query: str): ...
     def set_commit(self, commit: str): ...
     def set_change(self, change: str): ...
-    def checkout(self, change: str = 'main', commit: str = 'HEAD'): ...
+    def checkout(self, change: str = "main", commit: str = "HEAD"): ...
     def set_graph(self, graph_name: str): ...
+    def get_graph(self) -> str: ...
+    def get_query_exec_time(self) -> Optional[float]: ...
+    def get_total_exec_time(self) -> Optional[float]: ...

turingdb/turingdb.py

@@ -1,5 +1,7 @@
 from typing import Optional
 
+import time
+
 
 class TuringDBException(Exception):
     def __init__(self, message: str):
@@ -23,7 +25,16 @@ class TuringDB:
         import copy
 
         self.host = host
-        self._client = httpx.Client(auth=None, verify=False, timeout=timeout)
+        self._client = httpx.Client(
+            auth=None,
+            verify=False,
+            timeout=timeout,
+        )
+        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",
@@ -37,12 +48,25 @@ class TuringDB:
         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})
@@ -85,6 +109,9 @@ class TuringDB:
     def set_graph(self, graph_name: str):
         self._params["graph"] = graph_name
 
+    def get_graph(self) -> str:
+        return self._params["graph"]
+
     def _send_request(
         self,
         path: str,
@@ -93,6 +120,10 @@ class TuringDB:
     ):
         import orjson
 
+        self._query_exec_time = None
+        self._total_exec_time = None
+        self._t0 = time.time()
+
         if data is None:
             data = ""
 
@@ -118,37 +149,35 @@ class TuringDB:
                     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
         import numpy as np
 
-        data_header = json["header"]
-        column_names: list[str] = data_header["column_names"]
-        column_types: list[str] = data_header["column_types"]
-        dtypes: list[np.dtype] = []
         columns: list[list] = []
 
+        self._query_exec_time = json["time"]
+
         for chunk in json["data"]:
             for i, col in enumerate(chunk):
                 if i >= len(columns):
-                    match column_types[i]:
-                        case "String":
-                            dtypes.append(np.dtype(np.dtypes.StringDType))
-                        case "Int64":
-                            dtypes.append(np.dtype(np.dtypes.Int64DType))
-                        case "UInt64":
-                            dtypes.append(np.dtype(np.dtypes.UInt64DType))
-                        case "Double":
-                            dtypes.append(np.dtype(np.dtypes.Float64DType))
-                        case "Boolean":
-                            dtypes.append(np.dtype(np.dtypes.BoolDType))
-
                     columns.append([])
 
                 columns[i] = columns[i] + col
 
-        arrays = [np.array(columns[i], dtype=dtypes[i]) for i in range(len(columns))]
+        arrays = [np.array(columns[i]) for i in range(len(columns))]
+
+        self._t1 = time.time()
+        self._total_exec_time = (self._t1 - self._t0) * 1000
+
+        return pd.DataFrame(dict(zip(range(len(arrays)), arrays)), index=None)
+
+    def get_query_exec_time(self) -> Optional[float]:
+        return self._query_exec_time
 
-        return pd.DataFrame(dict(zip(column_names, arrays)), index=None)
+    def get_total_exec_time(self) -> Optional[float]:
+        return self._total_exec_time

turingdb/turingsh/__init__.py

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

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,298 @@
+"""
+TuringDB Shell Client
+"""
+
+import click
+from prompt_toolkit import prompt
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.shortcuts import print_formatted_text
+from prompt_toolkit.formatted_text import HTML
+
+from . import greeter
+from turingdb import TuringDB, TuringDBException
+
+
+class ShellException(Exception):
+    pass
+
+
+def create_completer():
+    """Create command completer"""
+    commands = [
+        # Shell keywords
+        "cd",
+        "LIST_AVAIL_GRAPHS",
+        "LIST_LOADED_GRAPHS",
+        "help",
+        "quit",
+        "status",
+        # 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)
+@click.option("--host", "-l", default="https://engines.turingdb.ai/sdk")
+@click.option("--auth-token", "-p", default="")
+@click.option("--instance-id", "-i", default="")
+@click.pass_context
+def main(ctx, host, auth_token, instance_id):
+    """TuringDB Shell - Interactive database client"""
+    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,
+    }
+
+    while True:
+        graph = client.get_graph()
+        try:
+            # Get user input with styling
+            user_input = prompt(
+                HTML(f"<b><cyan>turingdb:{graph}</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:
+                if cmd_lower == "quit":
+                    print_formatted_text(HTML("<yellow>Goodbye! 👋</yellow>"))
+                    break
+                elif cmd_lower == "help":
+                    show_help()
+                    continue
+
+            if cmd_words[0] in shell_commands:
+                try:
+                    shell_commands[cmd_words[0]](client, cmd_words)
+                except ShellException as e:
+                    print_formatted_text(HTML(f"<red>✘ {e}</red>"))
+                continue
+
+            # Execute query
+            try:
+                result = client.query(cmd)
+                print_formatted_text(HTML(f"<white>{result}</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>"))
+
+            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>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))
+
+
+def change_graph(client: TuringDB, args: list[str]):
+    """Change the current graph"""
+
+    if len(args) != 2:
+        raise ShellException(
+            "change_graph() missing 1 required positional argument: 'graph_name'"
+        )
+
+    graph_name = args[1]
+
+    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:
+        print_formatted_text(HTML(f"<red>✘ Fatal error: {e}</red>"))
+
+
+def list_available_graphs(client: TuringDB, args: list[str]):
+    """List available graphs"""
+
+    if len(args) != 1:
+        raise ShellException(
+            "list_available_graphs() missing 0 required positional argument"
+        )
+
+    try:
+        graphs = client.list_available_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>"))
+
+
+def list_loaded_graphs(client: TuringDB, args: list[str]):
+    """List loaded graphs"""
+
+    if len(args) != 1:
+        raise ShellException(
+            "list_loaded_graphs() missing 0 required positional argument"
+        )
+
+    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-0.2.5.dist-info → turingdb-0.2.6.dist-info}/METADATA

@@ -1,15 +1,17 @@
 Metadata-Version: 2.4
 Name: turingdb
-Version: 0.2.5
+Version: 0.2.6
 Summary: TuringDB python sdk
 Project-URL: Homepage, https://github.com/turing-db/turingdb-sdk-python
 Project-URL: Repository, https://github.com/turing-db/turingdb-sdk-python
 License-File: LICENSE.txt
 Requires-Python: >=3.10
+Requires-Dist: click>=8.2.1
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: orjson>=3.11.1
 Requires-Dist: pandas-stubs>=2.3.0.250703
 Requires-Dist: pandas>=2.3.1
+Requires-Dist: prompt-toolkit>=3.0.52
 Description-Content-Type: text/markdown
 
 # turingdb-sdk-python

turingdb-0.2.6.dist-info/RECORD

@@ -0,0 +1,12 @@
+turingdb/__init__.py,sha256=ZtSKfXpIh23hJSxzysSB-l3u8bhG-obVWNSvJ906_dQ,146
+turingdb/__init__.pyi,sha256=9KNytbSxto6geGA_RMdl66f_6LHE7QkO2-yNlTI8El4,1144
+turingdb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+turingdb/turingdb.py,sha256=6lZ-mha0ZcC6Rn7lUF7V5X1g-jkK2KHKjqC9mAt1m5Y,5296
+turingdb/turingsh/__init__.py,sha256=4wdl3RdVQbx-rKhI_7hDawkMtcJzRb90qG84JynT8Qo,47
+turingdb/turingsh/greeter.py,sha256=lxbfT6eS89tZmDui92ZXTFDMzWzUST_ih8a-Zrf8sxY,1570
+turingdb/turingsh/turingsh.py,sha256=vi2rQrjRZaafqF756AR5itoCiOFxTQmGkMWhm2lgmRE,8160
+turingdb-0.2.6.dist-info/METADATA,sha256=md4mpFMQSX_xKVgS6wlUvdR1akAuriMsC_OamLxfqN0,585
+turingdb-0.2.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+turingdb-0.2.6.dist-info/entry_points.txt,sha256=qbMJy64bcRtR1UOSnMV9Io5aWLZIFI8H7N4sv1mqUwA,47
+turingdb-0.2.6.dist-info/licenses/LICENSE.txt,sha256=PgwD9hjeoyWO93yZQnxCyt0s-PlhXWLgqdCPpB91GhY,1078
+turingdb-0.2.6.dist-info/RECORD,,

turingdb-0.2.6.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+turingsh = turingdb:turingsh

turingdb-0.2.5.dist-info/RECORD

@@ -1,8 +0,0 @@
-turingdb/__init__.py,sha256=zOhbnDfi_6Zf2aLn7mZho-xHIydeLd8-1TIT2_046Kg,95
-turingdb/__init__.pyi,sha256=O6ZMBGuBgXInR2anKZI3ycMZECIuhlsTUanZiHjZEqs,790
-turingdb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-turingdb/turingdb.py,sha256=xn4v-SLwjS-8v9YyriUhF7GgNBjOH1Du6cJZ42PYvzM,4808
-turingdb-0.2.5.dist-info/METADATA,sha256=YIF4mQepRtNVYst_knRfveBrTP3KoWEc7ZntECxYC7s,519
-turingdb-0.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-turingdb-0.2.5.dist-info/licenses/LICENSE.txt,sha256=PgwD9hjeoyWO93yZQnxCyt0s-PlhXWLgqdCPpB91GhY,1078
-turingdb-0.2.5.dist-info/RECORD,,