jupyter-duckdb 1.2.101__py3-none-any.whl → 1.2.103__py3-none-any.whl

duckdb_kernel/magics/MagicCommandCallback.py

@@ -1,14 +1,13 @@
 from typing import Optional, List
 
-from . import MagicCommand
-from .StringWrapper import StringWrapper
+from . import MagicCommand, MagicState
 
 
 class MagicCommandCallback:
-    def __init__(self, mc: MagicCommand, silent: bool, code: StringWrapper, *args, **kwargs):
+    def __init__(self, mc: MagicCommand, silent: bool, state: MagicState, *args, **kwargs):
         self._mc: MagicCommand = mc
         self._silent: bool = silent
-        self._code: StringWrapper = code
+        self._state: MagicState = state
         self._args = args
         self._kwargs = kwargs
 
@@ -18,14 +17,8 @@ class MagicCommandCallback:
 
     def __call__(self, columns: Optional[List[str]] = None, rows: Optional[List[List]] = None):
         if self._mc.requires_code:
-            result = self._mc(self._silent, self._code.value, *self._args, **self._kwargs)
-            if 'generated_code' in result:
-                self._code.value = result['generated_code']
-
-            return result
-
-        if self._mc.requires_query_result:
-            return self._mc(self._silent, columns, rows, *self._args, **self._kwargs)
-
+            self._mc(self._silent, self._state, *self._args, **self._kwargs)
+        elif self._mc.requires_query_result:
+            self._mc(self._silent, self._state, columns, rows, *self._args, **self._kwargs)
         else:
-            return self._mc(self._silent, *self._args, **self._kwargs)
+            self._mc(self._silent, self._state, *self._args, **self._kwargs)

duckdb_kernel/magics/MagicCommandHandler.py

@@ -2,7 +2,8 @@ import re
 from typing import Dict, Tuple, List
 
 from . import MagicCommand, MagicCommandException, MagicCommandCallback
-from .StringWrapper import StringWrapper
+from .MagicState import MagicState
+from ..db import Connection
 
 
 class MagicCommandHandler:
@@ -18,8 +19,8 @@ class MagicCommandHandler:
     def __getitem__(self, key: str) -> MagicCommand:
         return self._magics[key.lower()]
 
-    def __call__(self, silent: bool, code: str) -> Tuple[str, List[MagicCommandCallback], List[MagicCommandCallback]]:
-        code_wrapper = StringWrapper()
+    def __call__(self, silent: bool, state: MagicState) \
+            -> Tuple[List[MagicCommandCallback], List[MagicCommandCallback]]:
         enabled_callbacks: List[MagicCommandCallback] = []
 
         # enable commands with default==True
@@ -27,21 +28,21 @@ class MagicCommandHandler:
             if magic.is_default:
                 flags = {name: False for name, _ in magic.flags}
                 optionals = {name: default for name, default, _ in magic.optionals}
-                callback = MagicCommandCallback(magic, silent, code_wrapper, **flags, **optionals)
+                callback = MagicCommandCallback(magic, silent, state, **flags, **optionals)
 
                 enabled_callbacks.append(callback)
 
         # search for magic commands in code
         while True:
             # ensure code starts with '%' or '%%' but not with '%%%'
-            match = re.match(r'^%{1,2}([^% ]+?)([ \t]*$| .+?$)', code, re.MULTILINE | re.IGNORECASE)
+            match = re.match(r'^%{1,2}([^% ]+?)([ \t]*$| .+?$)', state.code, re.MULTILINE | re.IGNORECASE)
 
             if match is None:
                 break
 
             # remove magic command from code
             start, end = match.span()
-            code = code[:start] + code[end + 1:]
+            state.code = state.code[:start] + state.code[end + 1:]
 
             # extract command
             command = match.group(1).lower()
@@ -99,7 +100,7 @@ class MagicCommandHandler:
                     optionals[name.lower()] = value
 
             # add to callbacks
-            callback = MagicCommandCallback(magic, silent, code_wrapper, *args, **flags, **optionals)
+            callback = MagicCommandCallback(magic, silent, state, *args, **flags, **optionals)
             enabled_callbacks.append(callback)
 
         # disable overwritten callbacks
@@ -129,5 +130,4 @@ class MagicCommandHandler:
                 post_query_callbacks.append(callback)
 
         # return callbacks
-        code_wrapper.value = code
-        return code, pre_query_callbacks, post_query_callbacks
+        return pre_query_callbacks, post_query_callbacks

duckdb_kernel/magics/MagicState.py

@@ -0,0 +1,11 @@
+from typing import Union, Dict, Optional
+
+from ..db import Connection
+
+
+class MagicState:
+    def __init__(self, db: Connection, code: str, max_rows: Optional[int]):
+        self.db: Connection = db
+        self.code: Union[str, Dict] = code
+        self.max_rows: Optional[int] = max_rows
+        self.column_name_mapping: Dict[str, str] = {}

duckdb_kernel/magics/__init__.py

@@ -2,3 +2,4 @@ from .MagicCommand import MagicCommand
 from .MagicCommandCallback import MagicCommandCallback
 from .MagicCommandException import MagicCommandException
 from .MagicCommandHandler import MagicCommandHandler
+from .MagicState import MagicState

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)});

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>
+        '''

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',
+]