jupyter-duckdb 1.2.0.4__tar.gz → 1.2.0.5__tar.gz

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jupyter-duckdb
-Version: 1.2.0.4
+Version: 1.2.0.5
 Summary: a basic wrapper kernel for DuckDB
 Home-page: https://github.com/erictroebs/jupyter-duckdb
 Author: Eric Tröbs
@@ -262,7 +262,7 @@ magic command `RA` activates the relational algebra mode for a single cell:
 
 ```
 %RA
-π a, b (σ c = 1 (R))
+π [a, b] (σ [c = 1] (R))
 ```
 
 The supported operations are:
@@ -294,3 +294,13 @@ magic command `DC` activates the domain calculus mode for a single cell:
 %DC
 { a, b | R(a, b, c) ∧ c = 1 }
 ```
+
+### Automated Parser Selection
+
+`%ALL_RA` or `%ALL_DC` enables the corresponding parser for all subsequently
+executed cells.
+
+If the magic command `%AUTO_PARSER` is added to a cell, a parser is
+automatically selected. If `%GUESS_PARSER` is executed, the parser is
+automatically selected for all subsequent cells.
+

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/README.md

@@ -234,7 +234,7 @@ magic command `RA` activates the relational algebra mode for a single cell:
 
 ```
 %RA
-π a, b (σ c = 1 (R))
+π [a, b] (σ [c = 1] (R))
 ```
 
 The supported operations are:
@@ -266,3 +266,13 @@ magic command `DC` activates the domain calculus mode for a single cell:
 %DC
 { a, b | R(a, b, c) ∧ c = 1 }
 ```
+
+### Automated Parser Selection
+
+`%ALL_RA` or `%ALL_DC` enables the corresponding parser for all subsequently
+executed cells.
+
+If the magic command `%AUTO_PARSER` is added to a cell, a parser is
+automatically selected. If `%GUESS_PARSER` is executed, the parser is
+automatically selected for all subsequent cells.
+

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/kernel.py

@@ -12,7 +12,7 @@ from ipykernel.kernelbase import Kernel
 from .db import Connection, DatabaseError, Table
 from .db.error import *
 from .magics import *
-from .parser import RAParser, DCParser
+from .parser import RAParser, DCParser, ParserError
 from .util.ResultSetComparator import ResultSetComparator
 from .util.TestError import TestError
 from .util.formatting import row_count, rows_table, wrap_image
@@ -46,8 +46,12 @@ class DuckDBKernel(Kernel):
             MagicCommand('query_max_rows').arg('count').on(self._query_max_rows_magic),
             MagicCommand('schema').flag('td').opt('only').on(self._schema_magic),
             MagicCommand('store').arg('file').flag('noheader').result(True).on(self._store_magic),
-            MagicCommand('ra').flag('analyze').code(True).on(self._ra_magic),
-            MagicCommand('dc').code(True).on(self._dc_magic)
+            MagicCommand('ra').disable('dc', 'auto_parser').flag('analyze').code(True).on(self._ra_magic),
+            MagicCommand('all_ra').arg('value', '1').on(self._all_ra_magic),
+            MagicCommand('dc').disable('ra', 'auto_parser').code(True).on(self._dc_magic),
+            MagicCommand('all_dc').arg('value', '1').on(self._all_dc_magic),
+            MagicCommand('auto_parser').disable('ra', 'dc').code(True).on(self._auto_parser_magic),
+            MagicCommand('guess_parser').arg('value', '1').on(self._guess_parser_magic),
         )
 
         # create placeholders for database and tests
@@ -496,6 +500,15 @@ class DuckDBKernel(Kernel):
             'generated_code': sql
         }
 
+    def _all_ra_magic(self, silent: bool, value: str):
+        if value.lower() in ('1', 'on', 'true'):
+            self._magics['ra'].default(True)
+            self._magics['dc'].default(False)
+
+            self.print('All further cells are interpreted as %RA.\n')
+        else:
+            self._magics['ra'].default(False)
+
     def _dc_magic(self, silent: bool, code: str):
         if self._db is None:
             raise AssertionError('load a database first')
@@ -520,6 +533,35 @@ class DuckDBKernel(Kernel):
             'column_name_mapping': cnm
         }
 
+    def _all_dc_magic(self, silent: bool, value: str):
+        if value.lower() in ('1', 'on', 'true'):
+            self._magics['dc'].default(True)
+            self._magics['ra'].default(False)
+
+            self.print('All further cells are interpreted as %DC.\n')
+        else:
+            self._magics['dc'].default(False)
+
+    def _guess_parser_magic(self, silent: bool, value: str):
+        if value.lower() in ('1', 'on', 'true'):
+            self._magics['auto_parser'].default(True)
+            self.print('The correct parser is guessed for each subsequently executed cell.\n')
+        else:
+            self._magics['auto_parser'].default(False)
+
+    def _auto_parser_magic(self, silent: bool, code: str):
+        try:
+            return self._ra_magic(silent, code, analyze=False)
+        except ParserError as e:
+            if e.depth > 0:
+                raise e
+
+        try:
+            return self._dc_magic(silent, code)
+        except ParserError as e:
+            if e.depth > 0:
+                raise e
+
     # 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.0.4 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/magics/MagicCommand.py

@@ -1,27 +1,28 @@
-from typing import Any, List, Tuple, Callable, Dict
+from typing import Any, List, Tuple, Callable, Dict, Set
 
 
 class MagicCommand:
-    _ARG = '''([^ ]+?|'.+?'|".+?")'''
+    _ARG = '''([^ ]+?|'.+?'|".+?")?'''
 
     def __init__(self, *names: str):
-        self._names: Tuple[str] = names
+        self._names: Tuple[str, ...] = names
 
-        self._arguments: List[Tuple[str, str]] = []
+        self._arguments: List[Tuple[str, Any, str]] = []
         self._flags: List[Tuple[str, str]] = []
         self._optionals: List[Tuple[str, Any, str]] = []
-
+        self._disables: Set[str] = set()
         self._code: bool = False
         self._result: bool = False
+        self._default: bool = False
 
         self._on: List[Callable] = []
 
     @property
-    def names(self) -> Tuple[str]:
+    def names(self) -> Tuple[str, ...]:
         return self._names
 
     @property
-    def args(self) -> List[Tuple[str, str]]:
+    def args(self) -> List[Tuple[str, Any, str]]:
         return self._arguments
 
     @property
@@ -32,6 +33,10 @@ class MagicCommand:
     def optionals(self) -> List[Tuple[str, Any, str]]:
         return self._optionals
 
+    @property
+    def disables(self) -> Set[str]:
+        return self._disables
+
     @property
     def requires_code(self) -> bool:
         return self._code
@@ -40,8 +45,17 @@ class MagicCommand:
     def requires_query_result(self) -> bool:
         return self._result
 
-    def arg(self, name: str, description: str = None) -> 'MagicCommand':
-        self._arguments.append((name, description))
+    @property
+    def is_default(self) -> bool:
+        return self._default
+
+    def arg(self, name: str, default_value: Any = None, description: str = None) -> 'MagicCommand':
+        if len(self._arguments) > 0:
+            ln, ldv, _ = self._arguments[-1]
+            if ldv is not None and default_value is None:
+                raise ValueError(f'argument {name} without default value registered after argument {ln} with default value {ldv}')
+
+        self._arguments.append((name, default_value, description))
         return self
 
     def opt(self, name: str, default_value: Any = None, description: str = None) -> 'MagicCommand':
@@ -52,6 +66,12 @@ class MagicCommand:
         self._flags.append((name, description))
         return self
 
+    def disable(self, *name: str) -> 'MagicCommand':
+        for n in name:
+            self._disables.add(n)
+
+        return self
+
     def code(self, code: bool) -> 'MagicCommand':
         self._code = code
         return self
@@ -60,10 +80,14 @@ class MagicCommand:
         self._result = result
         return self
 
-    def on(self, fun: Callable):
+    def on(self, fun: Callable) -> 'MagicCommand':
         self._on.append(fun)
         return self
 
+    def default(self, default: bool) -> 'MagicCommand':
+        self._default = default
+        return self
+
     @property
     def parameters(self) -> str:
         args = ' +'.join([self._ARG] * len(self._arguments))

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/magics/MagicCommandCallback.py

@@ -1,20 +1,31 @@
 from typing import Optional, List
 
 from . import MagicCommand
+from .StringWrapper import StringWrapper
 
 
 class MagicCommandCallback:
-    def __init__(self, mc: MagicCommand, silent: bool, code: str, *args, **kwargs):
+    def __init__(self, mc: MagicCommand, silent: bool, code: StringWrapper, *args, **kwargs):
         self._mc: MagicCommand = mc
         self._silent: bool = silent
-        self._code: str = code
+        self._code: StringWrapper = code
         self._args = args
         self._kwargs = kwargs
 
+    @property
+    def magic(self) -> MagicCommand:
+        return self._mc
+
     def __call__(self, columns: Optional[List[str]] = None, rows: Optional[List[List]] = None):
         if self._mc.requires_code:
-            return self._mc(self._silent, self._code, *self._args, **self._kwargs)
+            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)
+
         else:
             return self._mc(self._silent, *self._args, **self._kwargs)

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/magics/MagicCommandHandler.py

@@ -1,7 +1,8 @@
 import re
-from typing import Dict, Tuple, List
+from typing import Dict, Tuple, List, Optional
 
 from . import MagicCommand, MagicCommandException, MagicCommandCallback
+from .StringWrapper import StringWrapper
 
 
 class MagicCommandHandler:
@@ -14,10 +15,23 @@ class MagicCommandHandler:
                 key = key.lower()
                 self._magics[key] = cmd
 
+    def __getitem__(self, key: str) -> MagicCommand:
+        return self._magics[key.lower()]
+
     def __call__(self, silent: bool, code: str) -> Tuple[str, List[MagicCommandCallback], List[MagicCommandCallback]]:
-        pre_query_callbacks = []
-        post_query_callbacks = []
+        code_wrapper = StringWrapper()
+        enabled_callbacks: List[MagicCommandCallback] = []
+
+        # enable commands with default==True
+        for magic in self._magics.values():
+            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)
 
+                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)
@@ -45,7 +59,11 @@ class MagicCommandHandler:
                 raise MagicCommandException(f'could not parse parameters for command "{command}"')
 
             # extract args
-            args = [g for g, _ in zip(match.groups(), magic.args)]
+            args = [group if group is not None else default
+                    for group, (_, default, _) in zip(match.groups(), magic.args)]
+
+            if any(arg is None for arg in args):
+                raise MagicCommandException(f'could not parse parameters for command "{command}"')
 
             i = len(args) + 1
 
@@ -73,12 +91,35 @@ class MagicCommandHandler:
                     optionals[name.lower()] = value
 
             # add to callbacks
-            callback = MagicCommandCallback(magic, silent, code, *args, **flags, **optionals)
+            callback = MagicCommandCallback(magic, silent, code_wrapper, *args, **flags, **optionals)
+            enabled_callbacks.append(callback)
+
+        # disable overwritten callbacks
+        callbacks = []
+        blacklist = set()
+
+        for callback in reversed(enabled_callbacks):
+            for name in callback.magic.names:
+                if name in blacklist:
+                    break
+            else:
+                callbacks.append(callback)
+
+                for name in callback.magic.names:
+                    blacklist.add(name)
+                for disable in callback.magic.disables:
+                    blacklist.add(disable)
+
+        # prepare callback lists
+        pre_query_callbacks = []
+        post_query_callbacks = []
 
-            if not magic.requires_query_result:
+        for callback in reversed(callbacks):
+            if not callback.magic.requires_query_result:
                 pre_query_callbacks.append(callback)
             else:
                 post_query_callbacks.append(callback)
 
         # return callbacks
+        code_wrapper.value = code
         return code, pre_query_callbacks, post_query_callbacks

jupyter_duckdb-1.2.0.5/src/duckdb_kernel/magics/StringWrapper.py

@@ -0,0 +1,3 @@
+class StringWrapper:
+    def __init__(self, value: str = None):
+        self.value: str = value

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/parser/DCParser.py

@@ -1,3 +1,4 @@
+from .ParserError import DCParserError
 from .elements import *
 from .tokenizer import *
 
@@ -18,17 +19,17 @@ class DCParser:
                 )
 
         # raise exception if query is not in the correct format
-        raise AssertionError('The expression shall be of the format "{ x1, ..., xn | f(x1, ..., xn) }".')
+        raise DCParserError('The expression shall be of the format "{ x1, ..., xn | f(x1, ..., xn) }".', 0)
 
     @staticmethod
-    def parse_projection(*tokens: Token) -> LogicOperand:
+    def parse_projection(*tokens: Token, depth: int = 0) -> LogicOperand:
         if len(tokens) == 1:
             tokens = tuple(Tokenizer.tokenize(tokens[0]))
 
         return LogicOperand(*tokens)
 
     @staticmethod
-    def parse_condition(*tokens: Token) -> LogicElement:
+    def parse_condition(*tokens: Token, depth: int = 0) -> LogicElement:
         if len(tokens) == 1:
             tokens = tuple(Tokenizer.tokenize(tokens[0]))
 
@@ -40,8 +41,8 @@ class DCParser:
                     # return the operator
                     # with left part of tokens and right part of tokens
                     return operator(
-                        DCParser.parse_condition(*tokens[:-i]),
-                        DCParser.parse_condition(*tokens[-i + 1:])
+                        DCParser.parse_condition(*tokens[:-i], depth=depth + 1),
+                        DCParser.parse_condition(*tokens[-i + 1:], depth=depth + 1)
                     )
 
         # not
@@ -56,10 +57,12 @@ class DCParser:
         elif len(tokens) == 2:
             return DCOperand(
                 tokens[0],
-                tuple(Tokenizer.tokenize(tokens[1]))
+                tuple(Tokenizer.tokenize(tokens[1])),
+                depth=depth + 1
             )
         else:
             return DCOperand(
                 tokens[0],
-                tokens[1:]
+                tokens[1:],
+                depth=depth + 1
             )

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/parser/LogicParser.py

@@ -4,12 +4,12 @@ from .tokenizer import *
 
 class LogicParser:
     @staticmethod
-    def parse_query(query: str) -> LogicElement:
+    def parse_query(query: str, depth: int = 0) -> LogicElement:
         initial_token = Token(query)
-        return LogicParser.parse_tokens(initial_token)
+        return LogicParser.parse_tokens(initial_token, depth=depth)
 
     @staticmethod
-    def parse_tokens(*tokens: Token) -> LogicElement:
+    def parse_tokens(*tokens: Token, depth: int = 0) -> LogicElement:
         if len(tokens) == 1:
             tokens = tuple(Tokenizer.tokenize(tokens[0]))
 
@@ -21,14 +21,14 @@ class LogicParser:
                     # return the operator
                     # with left part of tokens and right part of tokens
                     return operator(
-                        LogicParser.parse_tokens(*tokens[:-i]),
-                        LogicParser.parse_tokens(*tokens[-i + 1:])
+                        LogicParser.parse_tokens(*tokens[:-i], depth=depth + 1),
+                        LogicParser.parse_tokens(*tokens[-i + 1:], depth=depth + 1)
                     )
 
         # not
         if tokens[0] in LOGIC_NOT.symbols():
             return LOGIC_NOT(
-                LogicParser.parse_tokens(*tokens[1:])
+                LogicParser.parse_tokens(*tokens[1:], depth=depth + 1)
             )
 
         # ArgList

jupyter_duckdb-1.2.0.5/src/duckdb_kernel/parser/ParserError.py

@@ -0,0 +1,18 @@
+class ParserError(Exception):
+    def __init__(self, message: str, depth: int):
+        super().__init__(message)
+
+        self.message: str = message
+        self.depth: int = depth
+
+
+class RAParserError(ParserError):
+    pass
+
+
+class DCParserError(ParserError):
+    pass
+
+
+class LogicParserError(ParserError):
+    pass

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/parser/RAParser.py

@@ -1,4 +1,5 @@
 from .LogicParser import LogicParser
+from .ParserError import RAParserError
 from .elements import *
 from .tokenizer import *
 
@@ -10,10 +11,10 @@ class RAParser:
     @staticmethod
     def parse_query(query: str) -> RAElement:
         initial_token = Token(query)
-        return RAParser.parse_tokens(initial_token)
+        return RAParser.parse_tokens(initial_token, depth=0)
 
     @staticmethod
-    def parse_tokens(*tokens: Token, target: RAOperator | RAOperand = None) -> RAElement:
+    def parse_tokens(*tokens: Token, target: RAOperator | RAOperand = None, depth: int = 0) -> RAElement:
         if len(tokens) == 1:
             tokens = tuple(Tokenizer.tokenize(tokens[0]))
 
@@ -24,15 +25,15 @@ class RAParser:
                 if tokens[-i].lower() in operator.symbols():
                     # raise error if left or right operand missing
                     if i == 1:
-                        raise AssertionError(f'right operand missing after {tokens[-i]}')
+                        raise RAParserError(f'right operand missing after {tokens[-i]}', depth)
                     if i == len(tokens):
-                        raise AssertionError(f'left operand missing before {tokens[-i]}')
+                        raise RAParserError(f'left operand missing before {tokens[-i]}', depth)
 
                     # return the operator
                     # with left part of tokens and right part of tokens
                     return operator(
-                        RAParser.parse_tokens(*tokens[:-i]),
-                        RAParser.parse_tokens(*tokens[-i + 1:])
+                        RAParser.parse_tokens(*tokens[:-i], depth=depth + 1),
+                        RAParser.parse_tokens(*tokens[-i + 1:], depth=depth + 1)
                     )
 
         # unary operators
@@ -44,8 +45,8 @@ class RAParser:
                     # the last token is the operators target.
                     if target is None:
                         op = operator(
-                            RAParser.parse_tokens(tokens[-1]),
-                            LogicParser.parse_tokens(*tokens[-i + 1:-1])
+                            RAParser.parse_tokens(tokens[-1], depth=depth + 1),
+                            LogicParser.parse_tokens(*tokens[-i + 1:-1], depth=depth + 1)
                         )
 
                     # Otherwise the handed target is this operator's
@@ -53,16 +54,13 @@ class RAParser:
                     else:
                         op = operator(
                             target,
-                            LogicParser.parse_tokens(*tokens[-i + 1:])
+                            LogicParser.parse_tokens(*tokens[-i + 1:], depth=depth + 1)
                         )
 
                     # If there are any more tokens the operator is
                     # the target for the next step.
                     if i < len(tokens):
-                        return RAParser.parse_tokens(
-                            *tokens[:-i],
-                            target=op
-                        )
+                        return RAParser.parse_tokens(*tokens[:-i], target=op, depth=depth + 1)
 
                     # Otherwise the operator is the return value.
                     else:
@@ -70,6 +68,6 @@ class RAParser:
 
         # return as name
         if len(tokens) > 1:
-            raise AssertionError(f'{tokens=}')
+            raise RAParserError(f'{tokens=}', depth)
 
         return RAOperand(tokens[0])

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/parser/__init__.py

@@ -1,3 +1,4 @@
 from .DCParser import DCParser
 from .LogicParser import LogicParser
 from .RAParser import RAParser
+from .ParserError import *

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/parser/elements/DCOperand.py

@@ -1,13 +1,14 @@
 from typing import Tuple
 
 from .LogicOperand import LogicOperand
+from ..ParserError import DCParserError
 from ..tokenizer import Token
 
 
 class DCOperand(LogicOperand):
-    def __new__(cls, relation: Token, columns: Tuple[Token], skip_comma: bool = False):
+    def __new__(cls, relation: Token, columns: Tuple[Token, ...], skip_comma: bool = False, depth: int = 0):
         if not skip_comma and not all(t == ',' for i, t in enumerate(columns) if i % 2 == 1):
-            raise AssertionError('arguments must be separated by commas')
+            raise DCParserError('arguments must be separated by commas', 0)
 
         return tuple.__new__(
             cls,
@@ -18,9 +19,11 @@ class DCOperand(LogicOperand):
             ))
         )
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, relation: Token, columns: Tuple[Token, ...], skip_comma: bool = False, depth: int = 0):
         super().__init__()
-        self.invert = False
+
+        self.depth: int = depth
+        self.invert: bool = False
 
     @property
     def relation(self) -> Token:

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/parser/elements/binary/ConditionalSet.py

@@ -8,6 +8,7 @@ from ..LogicElement import LogicElement
 from ..LogicOperand import LogicOperand
 from ..LogicOperator import LogicOperator
 from ..unary import Not
+from ...ParserError import DCParserError
 from ...tokenizer import Token
 from ...util.RenamableColumnList import RenamableColumnList
 from ....db import Table
@@ -43,7 +44,10 @@ class ConditionalSet:
                 # If a constant was found, we store the value and replace it with a random attribute name.
                 constant = le.names[i]
                 new_token = Token.random(constant)
-                new_operand = DCOperand(le.relation, le.names[:i] + (new_token,) + le.names[i + 1:], skip_comma=True)
+                new_operand = DCOperand(le.relation,
+                                        le.names[:i] + (new_token,) + le.names[i + 1:],
+                                        skip_comma=True,
+                                        depth=le.depth)
 
                 # We now need an equality comparison to ensure the introduced attribute is equal to the constant.
                 equality = Equal(
@@ -121,7 +125,8 @@ class ConditionalSet:
             # Raise an exception if the given number of operands does not match
             # the number of attributes in the relation.
             if len(source_columns) != len(operand.names):
-                raise AssertionError(f'invalid number of attributes for relation {operand.relation}')
+                raise DCParserError(f'invalid number of attributes for relation {operand.relation}',
+                                    depth=operand.depth)
 
             # Create a column list for this operand.
             rcl: RenamableColumnList = RenamableColumnList.from_iter(source_columns)
@@ -215,7 +220,8 @@ class ConditionalSet:
                         if left_name != right_name:
                             break
                     else:
-                        raise AssertionError(f'could not build join for relation {left_name}')
+                        raise DCParserError(f'could not build join for relation {left_name}',
+                                            depth=left_op.depth)
 
                     join_tuple = min(left_name, right_name), max(left_name, right_name)
 
@@ -253,7 +259,7 @@ class ConditionalSet:
 
             # If no joins were discovered using this table, an exception is raised.
             if discovered_joins == 0:
-                raise AssertionError('no common attributes found for join')
+                raise DCParserError('no common attributes found for join', depth=right_op.depth)
 
         # The joins have to be sorted in a topologic order starting from t0.
         used_relations: Set[str] = {'t0'}
@@ -287,7 +293,8 @@ class ConditionalSet:
                     break
 
             else:
-                raise AssertionError('no valid topologic order found for positive joins')
+                raise DCParserError('no valid topologic order found for positive joins',
+                                    depth=min(op.depth for _, _, op in relevant_positive))
 
         all_negative_conditions: Dict[str, List[str]] = {}
         all_negative_filters: Dict[str, List[str]] = {}
@@ -317,7 +324,8 @@ class ConditionalSet:
                     used_relations.add(target_name)
                     break
             else:
-                raise AssertionError('no valid topologic order found for negative joins')
+                raise DCParserError('no valid topologic order found for negative joins',
+                                    depth=min(op.depth for _, _, op in relevant_negative))
 
         # Build the SQL statement.
         sql_select = ', '.join(select_columns[col] if col in select_columns else col

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/src/jupyter_duckdb.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jupyter-duckdb
-Version: 1.2.0.4
+Version: 1.2.0.5
 Summary: a basic wrapper kernel for DuckDB
 Home-page: https://github.com/erictroebs/jupyter-duckdb
 Author: Eric Tröbs
@@ -262,7 +262,7 @@ magic command `RA` activates the relational algebra mode for a single cell:
 
 ```
 %RA
-π a, b (σ c = 1 (R))
+π [a, b] (σ [c = 1] (R))
 ```
 
 The supported operations are:
@@ -294,3 +294,13 @@ magic command `DC` activates the domain calculus mode for a single cell:
 %DC
 { a, b | R(a, b, c) ∧ c = 1 }
 ```
+
+### Automated Parser Selection
+
+`%ALL_RA` or `%ALL_DC` enables the corresponding parser for all subsequently
+executed cells.
+
+If the magic command `%AUTO_PARSER` is added to a cell, a parser is
+automatically selected. If `%GUESS_PARSER` is executed, the parser is
+automatically selected for all subsequent cells.
+

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/src/jupyter_duckdb.egg-info/SOURCES.txt

@@ -24,9 +24,11 @@ src/duckdb_kernel/magics/MagicCommand.py
 src/duckdb_kernel/magics/MagicCommandCallback.py
 src/duckdb_kernel/magics/MagicCommandException.py
 src/duckdb_kernel/magics/MagicCommandHandler.py
+src/duckdb_kernel/magics/StringWrapper.py
 src/duckdb_kernel/magics/__init__.py
 src/duckdb_kernel/parser/DCParser.py
 src/duckdb_kernel/parser/LogicParser.py
+src/duckdb_kernel/parser/ParserError.py
 src/duckdb_kernel/parser/RAParser.py
 src/duckdb_kernel/parser/__init__.py
 src/duckdb_kernel/parser/elements/DCOperand.py

{jupyter_duckdb-1.2.0.4 → jupyter_duckdb-1.2.0.5}/test/test_ra.py

@@ -2,7 +2,7 @@ import pytest
 
 import duckdb_kernel.parser.elements.binary as BinaryOperators
 import duckdb_kernel.parser.elements.unary as UnaryOperators
-from duckdb_kernel.parser import RAParser
+from duckdb_kernel.parser import RAParser, RAParserError
 from duckdb_kernel.parser.elements import RAOperand, LogicElement
 from . import Connection
 
@@ -644,7 +644,7 @@ def test_special_queries():
     with Connection() as con:
         # Consecutive operators triggered a recursion error in a previous
         # version, leading to an infinite loop / stack overflow.
-        with pytest.raises(AssertionError, match='right operand missing after x'):
+        with pytest.raises(RAParserError, match='right operand missing after x'):
             RAParser.parse_query(r'''
                 Users x x BannedUsers
             ''')