jupyter-duckdb 1.2.101__tar.gz → 1.2.102__tar.gz

{jupyter_duckdb-1.2.101 → jupyter_duckdb-1.2.102}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jupyter-duckdb
-Version: 1.2.101
+Version: 1.2.102
 Summary: a basic wrapper kernel for DuckDB
 Home-page: https://github.com/erictroebs/jupyter-duckdb
 Author: Eric Tröbs

{jupyter_duckdb-1.2.101 → jupyter_duckdb-1.2.102}/setup.py

@@ -1,7 +1,7 @@
 import os
 
 # configuration
-PACKAGE_VERSION = '1.2.101'
+PACKAGE_VERSION = '1.2.102'
 DUCKDB_VERSION = '1.2.1'
 
 DEPENDENCIES = [
@@ -46,7 +46,9 @@ if __name__ == '__main__':
         include_package_data=True,
         package_data={
             'duckdb_kernel': [
-                'kernel.json'
+                'kernel.json',
+                'visualization/lib/*.css',
+                'visualization/lib/*.js',
             ]
         }
     )

{jupyter_duckdb-1.2.101 → jupyter_duckdb-1.2.102}/src/duckdb_kernel/kernel.py

@@ -10,6 +10,7 @@ from typing import Optional, Dict, List, Tuple
 from ipykernel.kernelbase import Kernel
 
 from .db import Connection, DatabaseError, Table
+from .visualization.lib import *
 from .db.error import *
 from .magics import *
 from .parser import RAParser, DCParser, ParserError
@@ -118,6 +119,7 @@ class DuckDBKernel(Kernel):
                     self._db = Postgres(host, port, username, password, database_name)
                 except ImportError:
                     self.print('psycopg could not be found', name='stderr')
+                    return False
 
             # Otherwise the provided path is used to create an
             # in-process instance.
@@ -147,7 +149,7 @@ class DuckDBKernel(Kernel):
         else:
             return False
 
-    def _execute_stmt(self, query: str, silent: bool,
+    def _execute_stmt(self, name: str, query: str, silent: bool,
                       column_name_mapping: Dict[str, str],
                       max_rows: Optional[int]) -> Tuple[Optional[List[str]], Optional[List[List]]]:
         if self._db is None:
@@ -163,52 +165,57 @@ class DuckDBKernel(Kernel):
 
         et = time.time()
 
-        # return result if silent
-        if silent:
-            return columns, rows
+        # print result if not silent
+        if not silent:
+            # print EXPLAIN queries as raw text if using DuckDB
+            if query.strip().startswith('EXPLAIN') and self._db.plain_explain():
+                for ekey, evalue in rows:
+                    html = f'<b>{ekey}</b><br><pre>{evalue}</pre>'
+                    break
 
-        # print EXPLAIN queries as raw text if using DuckDB
-        if query.strip().startswith('EXPLAIN') and self._db.plain_explain():
-            for ekey, evalue in rows:
-                self.print_data(f'<b>{ekey}</b><br><pre>{evalue}</pre>')
+                return None, None
 
-            return None, None
+            # print every other query as a table
+            else:
+                if columns is not None:
+                    # table header
+                    mapped_columns = (column_name_mapping.get(c, c) for c in columns)
+                    table_header = ''.join(f'<th>{c}</th>' for c in mapped_columns)
+
+                    # table data
+                    if max_rows is not None and len(rows) > max_rows:
+                        table_data = f'''
+                            {rows_table(rows[:math.ceil(max_rows / 2)])}
+                            <tr>
+                                <td colspan="{len(columns)}" 
+                                    style="text-align: center"
+                                    title="{row_count(len(rows) - max_rows)} omitted">
+                                    ...
+                                </td>
+                            </tr>
+                            {rows_table(rows[-math.floor(max_rows // 2):])}
+                        '''
+                    else:
+                        table_data = rows_table(rows)
+
+                    # send to client
+                    html = (f'''
+                        <table class="duckdb-query-result-table">
+                            {table_header}
+                            {table_data}
+                        </table>
+                        
+                        {row_count(len(rows))} in {et - st:.3f}s
+                    ''')
 
-        # print every other query as a table
-        else:
-            if columns is not None:
-                # table header
-                mapped_columns = (column_name_mapping.get(c, c) for c in columns)
-                table_header = ''.join(f'<th>{c}</th>' for c in mapped_columns)
-
-                # table data
-                if max_rows is not None and len(rows) > max_rows:
-                    table_data = f'''
-                        {rows_table(rows[:math.ceil(max_rows / 2)])}
-                        <tr>
-                            <td colspan="{len(columns)}" 
-                                style="text-align: center"
-                                title="{row_count(len(rows) - max_rows)} omitted">
-                                ...
-                            </td>
-                        </tr>
-                        {rows_table(rows[-math.floor(max_rows // 2):])}
-                    '''
                 else:
-                    table_data = rows_table(rows)
+                    html = f'statement executed without result in {et - st:.3f}s'
 
-                # send to client
-                self.print_data(f'''
-                    <table class="duckdb-query-result">
-                        {table_header}
-                        {table_data}
-                    </table>
-                ''')
-
-                self.print_data(f'{row_count(len(rows))} in {et - st:.3f}s')
-
-            else:
-                self.print_data(f'statement executed without result in {et - st:.3f}s')
+            self.print_data(f'''
+                <div class="duckdb-query-result {name}">
+                    {html}
+                </div>
+            ''')
 
         return columns, rows
 
@@ -498,16 +505,23 @@ class DuckDBKernel(Kernel):
         # create and show visualization
         if analyze:
             vd = RATreeDrawer(self._db, root_node, tables)
-            svg = vd.to_svg(True)
-
-            self.print_data(svg)
+            svg = vd.to_interactive_svg()
+            data = {
+                'generated_code': {
+                    node_id: node.to_sql_with_renamed_columns(tables)
+                    for node_id, node in vd.nodes.items()
+                }
+            }
 
-        # generate sql
-        sql = root_node.to_sql_with_renamed_columns(tables)
+        else:
+            svg = ''
+            data = {
+                'generated_code': root_node.to_sql_with_renamed_columns(tables)
+            }
 
-        return {
-            'generated_code': sql
-        }
+        # return data
+        self.print_data(svg)
+        return data
 
     def _all_ra_magic(self, silent: bool, value: str):
         if value.lower() in ('1', 'on', 'true'):
@@ -689,10 +703,14 @@ class DuckDBKernel(Kernel):
                 execution_args['column_name_mapping'] = {}
 
             # execute statement if needed
-            if clean_code.strip():
-                cols, rows = self._execute_stmt(clean_code, silent, **execution_args)
-            else:
-                cols, rows = None, None
+            cols, rows = None, None
+
+            if not isinstance(clean_code, dict):
+                clean_code = {'default': clean_code}
+
+            for name, code in clean_code.items():
+                if code.strip():
+                    cols, rows = self._execute_stmt(name, code, silent, **execution_args)
 
             # execute magic command here if it does depend on query results
             for callback in post_query_callbacks:

{jupyter_duckdb-1.2.101 → jupyter_duckdb-1.2.102}/src/duckdb_kernel/visualization/Plotly.py

@@ -1,22 +1,9 @@
-from decimal import Decimal
-
-PLOTLY_VERSION = '3.0.1'
-
 import json
-from uuid import uuid4
+from decimal import Decimal
 from typing import Dict, List, Optional
+from uuid import uuid4
 
-__PLOTLY_INITIALIZED = False
-
-
-def __init() -> str:
-    global __PLOTLY_INITIALIZED
-
-    if not __PLOTLY_INITIALIZED:
-        __PLOTLY_INITIALIZED = True
-        return f'<script src="https://cdn.plot.ly/plotly-{PLOTLY_VERSION}.min.js"></script>'
-    else:
-        return ''
+from .lib import init_plotly
 
 
 def __div_id() -> str:
@@ -60,7 +47,7 @@ def __fix_decimal(x: List):
 
 
 def draw_chart(title: Optional[str], traces: List[Dict] | Dict) -> str:
-    init = __init()
+    init = init_plotly()
     div_id = __div_id()
     layout = __layout(title)
     config = __config()
@@ -69,7 +56,10 @@ def draw_chart(title: Optional[str], traces: List[Dict] | Dict) -> str:
         traces = json.dumps(traces)
 
     return f'''
-        {init}
+        <script type="text/javascript">
+            {init}
+        </script>
+
         <div id="{div_id}"></div>
         <script type="text/javascript">
             Plotly.newPlot('{div_id}', {traces}, {json.dumps(layout)}, {json.dumps(config)});

{jupyter_duckdb-1.2.101 → jupyter_duckdb-1.2.102}/src/duckdb_kernel/visualization/RATreeDrawer.py

@@ -1,12 +1,14 @@
-from typing import Dict
+from typing import Dict, Optional
 
 from graphviz import Digraph
+from uuid import uuid4
 
 from duckdb_kernel.db import Table
 from duckdb_kernel.parser.elements import RAElement
 from duckdb_kernel.util.formatting import row_count
 from .Drawer import Drawer
 from ..db import Connection
+from .lib import *
 
 
 class RATreeDrawer(Drawer):
@@ -15,6 +17,9 @@ class RATreeDrawer(Drawer):
         self.root_node: RAElement = root_node
         self.tables: Dict[str, Table] = tables
 
+        self.nodes: Dict[str, RAElement] = {}
+        self.root_node_id: Optional[str] = None
+
     def to_graph(self) -> Digraph:
         # create graph
         ps = Digraph('Schema',
@@ -31,7 +36,11 @@ class RATreeDrawer(Drawer):
 
     def __add_node(self, ps: Digraph, node: RAElement) -> str:
         # use id of node object as identifier
-        node_id = f'node_{id(node)}'
+        node_id = f'node_{str(uuid4()).replace("-", "_")}'
+
+        self.nodes[node_id] = node
+        if node == self.root_node:
+            self.root_node_id = node_id
 
         # generate child nodes
         child_ids = [self.__add_node(ps, child) for child in node.children]
@@ -69,3 +78,26 @@ class RATreeDrawer(Drawer):
 
         # return node identifier to generate edges
         return node_id
+
+    def to_interactive_svg(self) -> str:
+        div_id = f'div-{str(uuid4())}'
+
+        css = init_css()
+        ra = init_ra()
+        svg = self.to_svg(True)
+
+        return f'''
+            <style type="text/css">
+                {css}
+            </style>
+            
+            <div id="{div_id}">
+                {svg}
+            </div>
+            
+            <script type="text/javascript">
+                {ra}
+                
+                animate_ra('{div_id}', '{self.root_node_id}')
+            </script>
+        '''

jupyter_duckdb-1.2.102/src/duckdb_kernel/visualization/lib/__init__.py

@@ -0,0 +1,53 @@
+import os
+
+__CSS_INITIALIZED = False
+__RA_INITIALIZED = False
+__PLOTLY_INITIALIZED = False
+
+__location = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__)))
+
+
+def init_css() -> str:
+    global __CSS_INITIALIZED
+
+    if not __CSS_INITIALIZED:
+        with open(os.path.join(__location, 'ra.css')) as ra_file:
+            css = ra_file.read()
+    else:
+        css = ''
+
+    __CSS_INITIALIZED = True
+    return css
+
+
+def init_ra() -> str:
+    global __RA_INITIALIZED
+
+    if not __RA_INITIALIZED:
+        with open(os.path.join(__location, 'ra.js')) as ra_file:
+            ra = ra_file.read()
+    else:
+        ra = ''
+
+    __RA_INITIALIZED = True
+    return ra
+
+
+def init_plotly() -> str:
+    global __PLOTLY_INITIALIZED
+
+    if not __PLOTLY_INITIALIZED:
+        with open(os.path.join(__location, 'plotly-3.0.1.min.js')) as plotly_file:
+            plotly = plotly_file.read()
+    else:
+        plotly = ''
+
+    __PLOTLY_INITIALIZED = True
+    return plotly
+
+
+__all__ = [
+    'init_css',
+    'init_ra',
+    'init_plotly',
+]