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

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

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

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

@@ -1,7 +1,7 @@
 import os
 
 # configuration
-PACKAGE_VERSION = '1.2.100'
+PACKAGE_VERSION = '1.2.101'
 DUCKDB_VERSION = '1.2.1'
 
 DEPENDENCIES = [

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

@@ -54,6 +54,8 @@ class DuckDBKernel(Kernel):
             MagicCommand('all_dc').arg('value', '1').on(self._all_dc_magic),
             MagicCommand('auto_parser').disable('sql', 'ra', 'dc').code(True).on(self._auto_parser_magic),
             MagicCommand('guess_parser').arg('value', '1').on(self._guess_parser_magic),
+            MagicCommand('plotly').arg('type').arg('mapping').opt('title').result(True).on(self._plotly_magic),
+            MagicCommand('plotly_raw').opt('title').result(True).on(self._plotly_raw_magic)
         )
 
         # create placeholders for database and tests
@@ -577,6 +579,90 @@ class DuckDBKernel(Kernel):
             if e.depth > 0:
                 raise e
 
+    def _plotly_magic(self, silent: bool, cols: List, rows: List[Tuple], type: str, mapping: str, title: str = None):
+        # split mapping and handle asterisks
+        mapping = [m.strip() for m in mapping.split(',')]
+
+        for i in range(len(mapping)):
+            if mapping[i] == '*':
+                mapping = mapping[:i] + cols + mapping[i+1:]
+
+        # convert all column names to lower case
+        lower_cols = [c.lower() for c in cols]
+        lower_mapping = [m.lower() for m in mapping]
+
+        # map desired columns to indices
+        mapped_indices = {}
+        for ok, lk in zip(mapping, lower_mapping):
+            for i in range(len(lower_cols)):
+                if lk == lower_cols[i]:
+                    mapped_indices[ok] = i
+                    break
+            else:
+                raise ValueError(f'unknown column {ok}')
+
+        # map desired columns to value lists
+        mapped_values = {
+            m: [r[i] for r in rows]
+            for m, i in mapped_indices.items()
+        }
+        mapped_keys = iter(mapped_values.keys())
+
+        # get required chart type
+        match type.lower():
+            case 'scatter':
+                if len(lower_mapping) < 2: raise ValueError('scatter requires at least x and y values')
+                html = draw_scatter_chart(title,
+                                          mapped_values[next(mapped_keys)],
+                                          **{k: mapped_values[k] for k in mapped_keys})
+            case 'line':
+                if len(lower_mapping) < 2: raise ValueError('lines requires at least x and y values')
+                html = draw_line_chart(title,
+                                       mapped_values[next(mapped_keys)],
+                                       **{k: mapped_values[k] for k in mapped_keys})
+
+            case 'bar':
+                if len(lower_mapping) < 2: raise ValueError('bar requires at least x and y values')
+                html = draw_bar_chart(title,
+                                      mapped_values[next(mapped_keys)],
+                                      **{k: mapped_values[k] for k in mapped_keys})
+
+            case 'pie':
+                if len(lower_mapping) != 2: raise ValueError('pie requires labels and values')
+                html = draw_pie_chart(title,
+                                      mapped_values[next(mapped_keys)],
+                                      mapped_values[next(mapped_keys)])
+
+            case 'bubble':
+                if len(lower_mapping) != 4: raise ValueError('bubble requires x, y, size and color')
+                html = draw_bubble_chart(title,
+                                         mapped_values[next(mapped_keys)],
+                                         mapped_values[next(mapped_keys)],
+                                         mapped_values[next(mapped_keys)],
+                                         mapped_values[next(mapped_keys)])
+
+            case 'heatmap':
+                if len(lower_mapping) != 3: raise ValueError('heatmap requires x, y and z values')
+                html = draw_heatmap_chart(title,
+                                          mapped_values[next(mapped_keys)],
+                                          mapped_values[next(mapped_keys)],
+                                          mapped_values[next(mapped_keys)])
+
+            case _:
+                raise ValueError(f'unknown type: {type}')
+
+        # finally print the code
+        self.print_data(html, mime='text/html')
+
+    def _plotly_raw_magic(self, silent: bool, cols: List, rows: List[Tuple], title: str = None):
+        if len(cols) != 1 and len(rows) != 1:
+            raise ValueError(f'expected exactly one column and one row')
+
+        self.print_data(
+            draw_chart(title, rows[0][0]),
+            mime='text/html'
+        )
+
     # jupyter related functions
     def do_execute(self, code: str, silent: bool,
                    store_history: bool = True, user_expressions: dict = None, allow_stdin: bool = False,

{jupyter_duckdb-1.2.100 → jupyter_duckdb-1.2.101}/src/duckdb_kernel/magics/MagicCommandHandler.py

@@ -1,5 +1,5 @@
 import re
-from typing import Dict, Tuple, List, Optional
+from typing import Dict, Tuple, List
 
 from . import MagicCommand, MagicCommandException, MagicCommandCallback
 from .StringWrapper import StringWrapper
@@ -62,6 +62,11 @@ class MagicCommandHandler:
             args = [group if group is not None else default
                     for group, (_, default, _) in zip(match.groups(), magic.args)]
 
+            args = [arg[1:-1]
+                    if arg is not None and (arg[0] == '"' and arg[-1] == '"' or arg[0] == "'" and arg[-1] == "'")
+                    else arg
+                    for arg in args]
+
             if any(arg is None for arg in args):
                 raise MagicCommandException(f'could not parse parameters for command "{command}"')
 
@@ -87,6 +92,9 @@ class MagicCommandHandler:
                 value = match.group(i + 2)
                 i += 3
 
+                if value is not None and (value[0] == '"' and value[-1] == '"' or value[0] == "'" and value[-1] == "'"):
+                    value = value[1:-1]
+
                 if name is not None:
                     optionals[name.lower()] = value
 

jupyter_duckdb-1.2.101/src/duckdb_kernel/visualization/Plotly.py

@@ -0,0 +1,154 @@
+from decimal import Decimal
+
+PLOTLY_VERSION = '3.0.1'
+
+import json
+from uuid import uuid4
+from typing import Dict, List, Optional
+
+__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 ''
+
+
+def __div_id() -> str:
+    return f'div-{str(uuid4())}'
+
+
+def __layout(title: Optional[str]):
+    layout = {
+        'dragmode': False,
+        'xaxis': {
+            'rangeselector': {
+                'visible': False
+            }
+        }
+    }
+
+    if title is not None:
+        layout['title'] = {
+            'text': title,
+            'font': {
+                'family': 'sans-serif',
+                'size': 32,
+                'color': 'rgb(0, 0, 0)'
+            },
+            'xanchor': 'center'
+        }
+
+    return layout
+
+
+def __config():
+    return {
+        'displayModeBar': False,
+        'scrollZoom': False
+    }
+
+
+def __fix_decimal(x: List):
+    return [float(x) if isinstance(x, Decimal) else x
+            for x in x]
+
+
+def draw_chart(title: Optional[str], traces: List[Dict] | Dict) -> str:
+    init = __init()
+    div_id = __div_id()
+    layout = __layout(title)
+    config = __config()
+
+    if not isinstance(traces, str):
+        traces = json.dumps(traces)
+
+    return f'''
+        {init}
+        <div id="{div_id}"></div>
+        <script type="text/javascript">
+            Plotly.newPlot('{div_id}', {traces}, {json.dumps(layout)}, {json.dumps(config)});
+        </script>
+    '''
+
+
+def draw_scatter_chart(title: Optional[str], x, **ys) -> str:
+    return draw_chart(title, [
+        {
+            'x': __fix_decimal(x),
+            'y': __fix_decimal(y),
+            'mode': 'markers',
+            'type': 'scatter',
+            'name': name
+        }
+        for name, y in ys.items()
+    ])
+
+
+def draw_line_chart(title: Optional[str], x, **ys) -> str:
+    return draw_chart(title, [
+        {
+            'x': __fix_decimal(x),
+            'y': __fix_decimal(y),
+            'mode': 'lines+markers',
+            'name': name
+        }
+        for name, y in ys.items()
+    ])
+
+
+def draw_bar_chart(title: Optional[str], x, **ys) -> str:
+    return draw_chart(title, [
+        {
+            'x': __fix_decimal(x),
+            'y': __fix_decimal(y),
+            'type': 'bar',
+            'name': name
+        }
+        for name, y in ys.items()
+    ])
+
+
+def draw_pie_chart(title: Optional[str], x, y) -> str:
+    return draw_chart(title, [{
+        'values': __fix_decimal(y),
+        'labels': __fix_decimal(x),
+        'type': 'pie'
+    }])
+
+
+def draw_bubble_chart(title: Optional[str], x, y, s, c) -> str:
+    return draw_chart(title, [{
+        'x': __fix_decimal(x),
+        'y': __fix_decimal(y),
+        'mode': 'markers',
+        'marker': {
+            'size': __fix_decimal(s),
+            'color': __fix_decimal(c)
+        }
+    }])
+
+
+def draw_heatmap_chart(title: Optional[str], x, y, z) -> str:
+    return draw_chart(title, [{
+        'x': __fix_decimal(x[0]),
+        'y': __fix_decimal(y[0]),
+        'z': [__fix_decimal(v) for v in z[0]],
+        'type': 'heatmap'
+    }])
+
+
+__all__ = [
+    'draw_chart',
+    'draw_scatter_chart',
+    'draw_line_chart',
+    'draw_bar_chart',
+    'draw_pie_chart',
+    'draw_bubble_chart',
+    'draw_heatmap_chart',
+]

{jupyter_duckdb-1.2.100 → jupyter_duckdb-1.2.101}/src/duckdb_kernel/visualization/__init__.py

@@ -1,2 +1,3 @@
+from .Plotly import *
 from .RATreeDrawer import RATreeDrawer
 from .SchemaDrawer import SchemaDrawer

{jupyter_duckdb-1.2.100 → jupyter_duckdb-1.2.101}/src/jupyter_duckdb.egg-info/PKG-INFO

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

{jupyter_duckdb-1.2.100 → jupyter_duckdb-1.2.101}/src/jupyter_duckdb.egg-info/SOURCES.txt

@@ -87,6 +87,7 @@ src/duckdb_kernel/util/TestError.py
 src/duckdb_kernel/util/__init__.py
 src/duckdb_kernel/util/formatting.py
 src/duckdb_kernel/visualization/Drawer.py
+src/duckdb_kernel/visualization/Plotly.py
 src/duckdb_kernel/visualization/RATreeDrawer.py
 src/duckdb_kernel/visualization/SchemaDrawer.py
 src/duckdb_kernel/visualization/__init__.py