kaqing 2.0.71__tar.gz → 2.0.72__tar.gz

{kaqing-2.0.71 → kaqing-2.0.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.71
+Version: 2.0.72
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.71 → kaqing-2.0.72}/adam/sql/sql_completer.py

@@ -4,7 +4,7 @@ from prompt_toolkit.document import Document
 import sqlparse
 from sqlparse.sql import Statement
 
-from adam.sql.state_machine import StateMachine
+from adam.sql.state_machine import StateMachine, StateTo
 from adam.sql.term_completer import TermCompleter
 
 __all__ = [
@@ -36,17 +36,17 @@ class SqlCompleter(Completer):
             completer = DML_COMPLETER
         else:
             statement: Statement = stmts[0]
-            state = self.machine.traverse_tokens(statement.tokens, state)
+            state: StateTo = self.machine.traverse_tokens(statement.tokens, StateTo(state))
             if self.debug:
-                print('\n  =>', state)
+                print('\n  =>', state.to_s if isinstance(state, StateTo) else '')
 
-            if not state:
+            if not state or not state.to_s:
                 completer = DML_COMPLETER
 
-            if state in self.machine.suggestions:
+            if state and state.to_s in self.machine.suggestions:
                 terms = []
 
-                for word in self.machine.suggestions[state].strip(' ').split(','):
+                for word in self.machine.suggestions[state.to_s].strip(' ').split(','):
                     if word == 'tables':
                         terms.extend(self.tables())
                     elif word == 'single':

{kaqing-2.0.71 → kaqing-2.0.72}/adam/sql/state_machine.py

@@ -130,24 +130,19 @@ __all__ = [
 
 SPEC = [
     '                                > select           > select',
-    'select_                         > name|*           > select_a                      ^ *',
+    'select_                         > name|*           > select_a                                ^ *',
     'select_a                        > ,                > select_a_comma_',
-    'select_a_comma_                 > name|*           > select_a                      ^ *',
-    'select_a_                       > from             > select_from                   ^ from',
-    'select_from_                    > name             > select_from_x                 ^ (select,tables',
-    '-                               > {                > select_from_x_lp_',
-    'select_from_x_lp_               > select           > select',
+    'select_a_comma_                 > name|*           > select_a                                ^ *',
+    'select_a_                       > from             > select_from                             ^ from',
+    'select_from_                    > name             > select_from_x                           ^ (select,tables',
+    '-                               > (                > select_from_lp_',
+    '-                               < )                > select_from_ns',
+    'select_from_lp_                 > select           > select',
     'select_from_x                   > ,                > select_from_x_comma_',
-    '-                               > }                > select_from_x_rp_',
-    '-                               > ]                > select_from_x_rb_',
-    'select_from_x_rp__              > as               > select_from_x_as              ^ as',
-    'select_from_x_rb__              > and|or           > select_where_                 ^ and,or,group by,limit',
-    '-                               > group            > select_group',
-    '-                               > group by         > select_group_by',
-    '-                               > limit            > select_where_sc_limit',
-    'select_from_x_comma_            > name             > select_from_x                 ^ tables',
-    'select_from_x_                                                                     ^ as,where,inner join,left outer join,right outer join,full outer join,group by,limit',
-    'select_from_x_as_x_             > ,                > select_from_x_comma_          ^ where,inner join,left outer join,right outer join,full outer join,group by,limit',
+    'select_from_ns_                 > as               > select_from_x_as                        ^ as',
+    'select_from_x_comma_            > name             > select_from_x                           ^ tables',
+    'select_from_x_                                                                               ^ as,where,inner join,left outer join,right outer join,full outer join,group by,limit',
+    'select_from_x_as_x_             > ,                > select_from_x_comma_                    ^ where,inner join,left outer join,right outer join,full outer join,group by,limit',
     '-                               > as               > select_from_x_as',
     '-                               > where            > select_where',
     '-                               > limit            > select_where_sc_limit',
@@ -163,122 +158,108 @@ SPEC = [
     '-                               > right outer join > select_join',
     '-                               > full             > select_from_x_full',
     '-                               > full outer join  > select_join',
-    'select_from_x_as_               > name             > select_from_x_as_x            ^ x,y,z',
+    'select_from_x_as_               > name             > select_from_x_as_x                      ^ x,y,z',
     'select_from_x_as_x              > ,                > select_from_x_as_x_comma_',
-    '-                               > }                > select_where_sc_re_',
-    'select_from_x_as_x_comma_       > name             > select_from_x                 ^ tables',
-    'select_where_                   > name             > select_where_a                ^ id,x.,y.,z.',
-    'select_where_a                  > comparison       > select_where_a_op             ^ =,<,<=,>,>=,<>,like,not,in',
-    'select_where_a_                 > comparison       > select_where_a_op             ^ =,<,<=,>,>=,<>,like,not,in',
+    'select_from_x_as_x_comma_       > name             > select_from_x                           ^ tables',
+    'select_where_                   > name             > select_where_a                          ^ id,x.,y.,z.',
+    'select_where_a                  > comparison       > select_where_a_op                       ^ =,<,<=,>,>=,<>,like,not,in',
+    'select_where_a_                 > comparison       > select_where_a_op                       ^ =,<,<=,>,>=,<>,like,not,in',
     '-                               > not              > select_where_a_not',
     '-                               > in               > select_where_a_in',
-    'select_where_a_not_             > comparison       > select_where_a_not_op         ^ like,in',
+    'select_where_a_not_             > comparison       > select_where_a_not_op                   ^ like,in',
     '-                               > in               > select_where_a_in',
-    'select_where_a_in               > [                > select_where_a_in_lp_         ^ (',
-    'select_where_a_in_lp_           > name|single|num  > select_where_a_in_lp_a        ^ single,select',
+    'select_where_a_in               > (                > select_where_a_in_lp_                   ^ (',
+    '-                               < )                > select_where_sc',
+    'select_where_a_in_lp_           > name|single|num  > select_where_a_in_lp_a                  ^ single,select',
     '-                               > select           > select_where_a_in_lp_select',
-    'select_where_a_in_lp_select_    > name             > select_a                      ^ id',
-    'select_where_a_in_lp_a          > ,                > select_where_a_in_lp_a_comma_ ^ comma,)',
-    '-                               > ]                > select_where_sc',
-    'select_where_a_in_lp_a_comma_   > name|single|num  > select_where_a_in_lp_a        ^ single',
-    'select_where_a_not_op           > name|single|num  > select_where_sc               ^ single',
-    'select_where_a_op               > name|single|num  > select_where_sc               ^ single',
-    'select_where_sc                 > )                > select_where_sc_rp_',
-    'select_where_sc                 > }                > select_where_sc_re_',
-    'select_where_sc_re__            > as               > select_from_x_as              ^ as',
-    'select_where_sc_rp_             > }                > select_where_sc_re_',
-    'select_where_sc_rp__            > as               > select_from_x_as              ^ and,or,group by,limit',
-    '-                               > and|or           > select_where',
-    '-                               > group            > select_group',
-    '-                               > group by         > select_group_by',
-    '-                               > limit            > select_where_sc_limit',
-    '-                               > }                > select_where_sc_re_',
-    'select_where_sc_                > and|or           > select_where                  ^ and,or,group by,limit',
+    'select_where_a_in_lp_select_    > name             > select_a                                ^ id',
+    'select_where_a_in_lp_a          > ,                > select_where_a_in_lp_a_comma_           ^ comma,)',
+    'select_where_a_in_lp_a_comma_   > name|single|num  > select_where_a_in_lp_a                  ^ single',
+    'select_where_a_not_op           > name|single|num  > select_where_sc                         ^ single',
+    'select_where_a_op               > name|single|num  > select_where_sc                         ^ single',
+    'select_where_sc_                > and|or           > select_where                            ^ and,or,group by,limit',
     '-                               > group            > select_group',
     '-                               > group by         > select_group_by',
     '-                               > limit            > select_where_sc_limit',
-    'select_group_                   > by               > select_group_by               ^ by',
-    'select_group_by_                > name             > select_group_by_a             ^ id,x.,y.,z.',
+    'select_group_                   > by               > select_group_by                         ^ by',
+    'select_group_by_                > name             > select_group_by_a                       ^ id,x.,y.,z.',
     'select_group_by_a               > ,                > select_group_by_a_comma_',
-    '-                               > }                > select_where_sc_re_',
-    'select_group_by_a_comma_        > name             > select_group_by_a             ^ id,x.,y.,z.',
-    'select_group_by_a_              > limit            > select_where_sc_limit         ^ limit',
-    'select_where_sc_limit_          > num              > select_where_sc_limit_num     ^ 1',
-    'select_where_sc_limit_num       > )                > select_where_sc_limit_num_rp_',
-    'select_where_sc_limit_num_rp__  > as               > select_from_x_as              ^ as',
+    'select_group_by_a_comma_        > name             > select_group_by_a                       ^ id,x.,y.,z.',
+    'select_group_by_a_              > limit            > select_where_sc_limit                   ^ limit',
+    'select_where_sc_limit_          > num              > select_where_sc_limit_num               ^ 1',
+    'select_where_sc_limit_num_rp__  > as               > select_from_x_as                        ^ as',
     'select_where_x_inner_           > join             > select_join',
-    'select_join_                    > name             > select_x_join_y               ^ tables',
-    'select_from_x_left_             > join             > select_join                   ^ outer join',
+    'select_join_                    > name             > select_x_join_y                         ^ tables',
+    'select_from_x_left_             > join             > select_join                             ^ outer join',
     '-                               > outer            > select_from_x_left_outer',
-    'select_from_x_left_outer_       > join             > select_join                   ^ join',
-    'select_from_x_right_            > join             > select_join                   ^ outer join',
+    'select_from_x_left_outer_       > join             > select_join                             ^ join',
+    'select_from_x_right_            > join             > select_join                             ^ outer join',
     '-                               > outer            > select_from_x_right_outer',
-    'select_from_x_right_outer_      > join             > select_join                   ^ join',
-    'select_from_x_full_             > join             > select_join                   ^ outer join',
+    'select_from_x_right_outer_      > join             > select_join                             ^ join',
+    'select_from_x_full_             > join             > select_join                             ^ outer join',
     '-                               > outer            > select_from_x_full_outer',
-    'select_from_x_full_outer_       > join             > select_join                   ^ join',
-    'select_x_join_y_                > as               > select_x_join_y_as            ^ as,on',
-    '-                               > on               > select_x_join_y_on            ^ as,on',
-    'select_x_join_y_as_             > name             > select_x_join_y_as_y          ^ x,y,z',
-    'select_x_join_y_as_y_           > on               > select_x_join_y_on            ^ on',
-    'select_x_join_y_on_             > name             > select_x_join_y_on_a          ^ id,x.,y.,z.',
-    'select_x_join_y_on_a            > comparison       > select_x_join_y_on_a_op       ^ =',
-    'select_x_join_y_on_a_op         > name             > select_x_join_y_on_a_op_b     ^ id,x.,y.,z.',
+    'select_from_x_full_outer_       > join             > select_join                             ^ join',
+    'select_x_join_y_                > as               > select_x_join_y_as                      ^ as,on',
+    '-                               > on               > select_x_join_y_on                      ^ as,on',
+    'select_x_join_y_as_             > name             > select_x_join_y_as_y                    ^ x,y,z',
+    'select_x_join_y_as_y_           > on               > select_x_join_y_on                      ^ on',
+    'select_x_join_y_on_             > name             > select_x_join_y_on_a                    ^ id,x.,y.,z.',
+    'select_x_join_y_on_a            > comparison       > select_x_join_y_on_a_op                 ^ =',
+    'select_x_join_y_on_a_op         > name             > select_x_join_y_on_a_op_b               ^ id,x.,y.,z.',
     'select_x_join_y_on_a_op_b       > _                > select_from_x_as_x_',
-    '-                               > }                > select_where_sc_re_',
 
 
     '                                > insert           > insert',
-    'insert_                         > into             > insert_into                   ^ into',
-    'insert_into_                    > name             > insert_into_x                 ^ tables',
+    'insert_                         > into             > insert_into                             ^ into',
+    'insert_into_                    > name             > insert_into_x                           ^ tables',
     'insert_into_x                   > (                > insert_into_x_lp_',
-    'insert_into_x_                  > (                > insert_into_x_lp_             ^ (,values(',
+    'insert_into_x_                  > (                > insert_into_x_lp_                       ^ (,values(',
     '-                               > values           > insert_values',
-    'insert_into_x_lp_               > name             > insert_into_x_lp_a            ^ id',
+    'insert_into_x_lp_               > name             > insert_into_x_lp_a                      ^ id',
     'insert_into_x_lp_a              > ,                > insert_into_x_lp_a_comma_',
     '-                               > )                > insert_into_x_lp_a_rp_',
-    'insert_into_x_lp_a_comma_       > name             > insert_into_x_lp_a            ^ id',
-    'insert_into_x_lp_a_rp__         > values           > insert_values                 ^ values(,select',
+    'insert_into_x_lp_a_comma_       > name             > insert_into_x_lp_a                      ^ id',
+    'insert_into_x_lp_a_rp__         > values           > insert_values                           ^ values(,select',
     '-                               > select           > select',
     'insert_values                   > (                > insert_values_lp_',
-    'insert_values_lp_               > name|single|num  > insert_values_lp_v            ^ single',
+    'insert_values_lp_               > name|single|num  > insert_values_lp_v                      ^ single',
     'insert_values_lp_v              > ,                > insert_values_lp_v_comma_',
     'insert_values_lp_v_comma_       > name|single|num  > insert_values_lp_v',
 
 
     '                                > update           > update',
-    'update_                         > name             > update_x                      ^ tables',
-    'update_x_                       > set              > update_set                    ^ set',
-    'update_set_                     > name             > update_set_a                  ^ id',
+    'update_                         > name             > update_x                                ^ tables',
+    'update_x_                       > set              > update_set                              ^ set',
+    'update_set_                     > name             > update_set_a                            ^ id',
     'update_set_a                    > comparison       > update_set_a_op',
-    'update_set_a_op                 > name|single|num  > update_set_sc                 ^ single',
+    'update_set_a_op                 > name|single|num  > update_set_sc                           ^ single',
     'update_set_sc                   > ,                > update_set_sc_comma_',
-    'update_set_sc_comma_            > name             > update_set_a                  ^ id',
-    'update_set_sc_                  > ,                > update_set_sc_comma_          ^ where',
+    'update_set_sc_comma_            > name             > update_set_a                            ^ id',
+    'update_set_sc_                  > ,                > update_set_sc_comma_                    ^ where',
     '-                               > where            > update_where',
-    'update_where_                   > name             > update_where_a                ^ id',
+    'update_where_                   > name             > update_where_a                          ^ id',
     'update_where_a                  > comparison       > update_where_a_op',
-    'update_where_a_                 > comparison       > update_where_a_op             ^ =,<,<=,>,>=,<>,like,not,in',
+    'update_where_a_                 > comparison       > update_where_a_op                       ^ =,<,<=,>,>=,<>,like,not,in',
     '-                               > not              > update_where_a_not',
     '-                               > in               > update_where_a_in',
-    'update_where_a_not_             > comparison       > update_where_a_not_op         ^ like,in',
+    'update_where_a_not_             > comparison       > update_where_a_not_op                   ^ like,in',
     '-                               > in               > update_where_a_in',
-    'update_where_a_in               > (                > update_where_a_in_lp_         ^ (',
-    'update_where_a_in_lp_           > name|single|num  > update_where_a_in_lp_a        ^ single,select',
+    'update_where_a_in               > (                > update_where_a_in_lp_                   ^ (',
+    '-                               < )                > update_where_sc',
+    'update_where_a_in_lp_           > name|single|num  > update_where_a_in_lp_a                  ^ single,select',
     '-                               > select           > update_where_a_in_lp_select',
-    'update_where_a_in_lp_select_    > name             > select_a                      ^ id',
-    'update_where_a_in_lp_a          > ,                > update_where_a_in_lp_a_comma_ ^ comma,)',
-    '-                               > )                > update_where_sc',
-    'update_where_a_in_lp_a_comma_   > name|single|num  > update_where_a_in_lp_a        ^ single',
-    'update_where_a_not_op           > name|single|num  > update_where_sc               ^ single',
-    'update_where_a_op               > name|single|num  > update_where_sc               ^ single',
-    'update_where_sc_                > and|or           > update_where                  ^ and,or',
+    'update_where_a_in_lp_select_    > name             > select_a                                ^ id',
+    'update_where_a_in_lp_a          > ,                > update_where_a_in_lp_a_comma_           ^ comma,)',
+    'update_where_a_in_lp_a_comma_   > name|single|num  > update_where_a_in_lp_a                  ^ single',
+    'update_where_a_not_op           > name|single|num  > update_where_sc                         ^ single',
+    'update_where_a_op               > name|single|num  > update_where_sc                         ^ single',
+    'update_where_sc_                > and|or           > update_where                            ^ and,or',
 
 
     '                                > delete           > delete',
-    'delete_                         > from             > delete_from                   ^ from',
-    'delete_from_                    > name             > delete_from_x                 ^ tables',
-    'delete_from_x_                  > where            > update_where                  ^ where',
+    'delete_                         > from             > delete_from                             ^ from',
+    'delete_from_                    > name             > delete_from_x                           ^ tables',
+    'delete_from_x_                  > where            > update_where                            ^ where',
 ]
 
 KEYWORDS = [
@@ -286,37 +267,32 @@ KEYWORDS = [
     'and', 'or', 'group', 'by', 'group by', 'limit',
     'inner join', 'on', 'left', 'right', 'full', 'outer', 'left outer join',
     'left join', 'right outer join', 'right join', 'full join', 'full outer join',
-
     'insert', 'into', 'values',
-
     'update', 'where', 'set',
-
     'delete'
 ]
 
+class StateTo:
+    def __init__(self, to_s: str, comeback_token: str = None, comeback_state: str = None):
+        self.to_s = to_s
+        self.comeback_token = comeback_token
+        self.comeback_state = comeback_state
+
+    def __str__(self):
+        return f'{self.to_s} comeback[{self.comeback_token} {self.comeback_state}]'
+
 class StateMachine:
-    def __init__(self, indent=0, lp_level = 0, le_levels_to_match: set = set(), lb_levels_to_match: set = set(), debug = False):
-        self.states: dict[str, str] = {}
+    def __init__(self, indent=0, lp_level = 0, debug = False):
+        self.states: dict[str, StateTo] = {}
         self.suggestions: dict[str, str] = {}
 
-        def add_whitespace_transition(from_s: str):
-            # add whitespace transition if a state with trailing whitespace is found from from states, for example, select > _ > select_
-            if from_s.endswith('_') and not from_s.endswith('_comma_') and not from_s.endswith('_lp_') and not from_s.endswith('_rp_'):
-                if self.debug:
-                    print(f'{from_s[:-1]} > _ = {to_s}')
-                self.states[f'{from_s[:-1]} > _'] = from_s
-
         self.indent = indent
         self.lp_level = lp_level
-        self.le_levels_to_match = le_levels_to_match
-        self.lb_levels_to_match = lb_levels_to_match
+        self.comebacks: dict[int, str] = {}
         self.debug = debug
 
         from_ss_to_add = []
         from_ss = ['']
-        token = None
-        tokens = []
-        to_s = None
         words: str = None
         for l in SPEC:
             t_and_w = l.split('^')
@@ -326,68 +302,72 @@ class StateMachine:
                 words = None
 
             tks = t_and_w[0].strip(' ').split('>')
-            if l.startswith('-'):
-                token = tks[1].strip(' ')
-                if len(tks) > 2:
-                    to_s = tks[2].strip(' ')
-                    for from_s in from_ss:
-                        tokens = [token]
-                        if '|' in token:
-                            tokens = token.strip(' ').split('|')
-
-                        for t in tokens:
-                            if self.debug:
-                                print(f'{from_s} > {t} = {to_s}')
-                            self.states[f'{from_s} > {t}'] = to_s
-            else:
+            if not l.startswith('-'):
                 if words:
                     self.suggestions[tks[0].strip(' ')] = words
 
                 if len(tks) == 1:
-                    from_s = tks[0].strip(' ')
-                    add_whitespace_transition(from_s)
-                    from_ss_to_add.append(f'{from_s}')
+                    from_ss_to_add.append(tks[0].strip(' '))
                     continue
 
                 from_ss = []
                 from_ss.extend(from_ss_to_add)
                 from_ss_to_add = []
                 from_ss.append(tks[0].strip(' '))
+
+            self.add_transitions(from_ss, tks)
+
+    def add_transitions(self, from_ss: list[str], tks: list[str]):
+        token = tks[1].strip(' ')
+        if len(tks) > 2:
+            to_s = tks[2].strip(' ')
+            for from_s in from_ss:
+                self.add_whitespace_transition(from_s, to_s)
+                self.add_transition(from_s, token, to_s)
+        elif '<' in tks[0]:
+            from_and_token = tks[0].split('<')
+            if len(from_and_token) > 1:
                 for from_s in from_ss:
-                    add_whitespace_transition(from_s)
-                    token = tks[1].strip(' ')
-                    tokens = [token]
-                    if len(tks) > 2:
-                        to_s = tks[2].strip(' ')
-
-                        if '|' in token:
-                            tokens = token.split('|')
-
-                        for t in tokens:
-                            if self.debug:
-                                print(f'{from_s} > {t} = {to_s}')
-                            self.states[f'{from_s} > {t}'] = to_s
-
-    def traverse_tokens(self, tokens: list[Token], state: str = ''):
-        def is_opening_embrace():
-            if f'{state} > ' + '{' in self.states:
-                self.le_levels_to_match.add(self.lp_level)
-                return '{'
-            elif f'{state} > ' + '[' in self.states:
-                self.lb_levels_to_match.add(self.lp_level)
-                return '['
-
-            return '('
-
-        def is_closing_embrace():
-            if f'{state} > ' + '}' in self.states and self.lp_level in self.le_levels_to_match:
-                self.le_levels_to_match.remove(self.lp_level)
-                return '}'
-            elif f'{state} > ' + ']' in self.states and self.lp_level in self.lb_levels_to_match:
-                self.lb_levels_to_match.remove(self.lp_level)
-                return ']'
-
-            return ')'
+                    self.add_comeback_transition(from_s, from_and_token[1], tks[1].strip(' '))
+
+    def add_whitespace_transition(self, from_s: str, to_s: str):
+        # add whitespace transition if a state with trailing whitespace is found from from states, for example, select > _ > select_
+        if from_s.endswith('_') and not from_s.endswith('_comma_') and not from_s.endswith('_lp_') and not from_s.endswith('_rp_'):
+            if self.debug:
+                print(f'{from_s[:-1]} > _ = {to_s}')
+            self.states[f'{from_s[:-1]} > _'] = StateTo(from_s)
+
+    def add_transition(self, from_s: str, token: str, to_s: str):
+        tokens = [token]
+        if '|' in token:
+            tokens = token.split('|')
+
+        for t in tokens:
+            if self.debug:
+                print(f'{from_s} > {t} = {to_s}')
+            self.states[f'{from_s} > {t}'] = StateTo(to_s)
+
+    def add_comeback_transition(self, from_s: str, token: str, to_s: str):
+        orig = self.states[f'{from_s} > (']
+        orig.comeback_token = token
+        orig.comeback_state = to_s
+        self.states[f'{from_s} > ('] = orig
+
+    def traverse_tokens(self, tokens: list[Token], state: StateTo = StateTo('')):
+        def handle_opening_parenthesis():
+            if f'{state.to_s} > {it}' in self.states:
+                state_test = self.states[f'{state.to_s} > {it}']
+                if state_test.comeback_token:
+                    self.comebacks[self.lp_level] = state_test.comeback_state
+
+        def handle_closing_parenthesis():
+            if self.lp_level in self.comebacks:
+                try:
+                    return StateTo(self.comebacks[self.lp_level])
+                finally:
+                    del self.comebacks[self.lp_level]
+
+            return None
 
         for token in tokens:
             if self.debug:
@@ -407,6 +387,8 @@ class StateMachine:
             if token.is_group:
                 state = self.traverse_tokens(token.tokens, state)
             else:
+                comeback_state = None
+
                 it = ''
                 if (t := token.value.lower()) in KEYWORDS:
                     it = t
@@ -421,21 +403,24 @@ class StateMachine:
                 elif token.ttype == T.Wildcard:
                     it = '*'
                 elif token.ttype == T.Punctuation:
-                    if token.value == ',':
-                        it = ','
-                    elif token.value == '(':
-                        it = is_opening_embrace()
+                    it = token.value
+
+                    if it == '(':
+                        handle_opening_parenthesis()
                         self.lp_level += 1
-                    elif token.value == ')':
+                    elif it == ')':
                         self.lp_level -= 1
-                        it = is_closing_embrace()
+                        comeback_state = handle_closing_parenthesis()
 
                 elif token.ttype == T.Operator.Comparison:
                     it = 'comparison'
 
                 try:
-                    # print(f'{state} > {it} > ', end='')
-                    state = self.states[f'{state} > {it}']
+                    # print(f'\n{state.to_s} > {it} > ', end='')
+                    if comeback_state:
+                        state = comeback_state
+                    else:
+                        state = self.states[f'{state.to_s} > {it}']
                     # print(state)
                 except:
                     pass

kaqing-2.0.72/adam/version.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+__version__ = "2.0.72"  #: the working version
+__release__ = "1.0.0"  #: the release version

{kaqing-2.0.71 → kaqing-2.0.72}/kaqing.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.71
+Version: 2.0.72
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.71 → kaqing-2.0.72}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='kaqing',
-    version='2.0.71',
+    version='2.0.72',
     packages=find_packages(),
     entry_points={
         'console_scripts': [

kaqing-2.0.71/adam/version.py

@@ -1,5 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-__version__ = "2.0.71"  #: the working version
-__release__ = "1.0.0"  #: the release version