kaqing 2.0.60__tar.gz → 2.0.62__tar.gz

{kaqing-2.0.60 → kaqing-2.0.62}/PKG-INFO

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

{kaqing-2.0.60 → kaqing-2.0.62}/adam/sql/sql_completer.py

@@ -151,7 +151,7 @@ class SqlCompleter(Completer):
             state = f'{self.dml}_'
             text = f'{self.dml} {text}'
 
-        completer = None
+        completer: Completer = None
         stmts = sqlparse.parse(text)
         if not stmts:
             completer = TermCompleter(['select', 'insert', 'delete', 'update'])
@@ -160,136 +160,27 @@ class SqlCompleter(Completer):
             state = self.traverse_tokens(text, statement.tokens)
             if self.debug:
                 print('\n  =>', state)
+
             if state == '':
                 completer = TermCompleter(['select', 'insert', 'delete', 'update'])
 
-            elif state == 'select_':
-                completer = TermCompleter(['*'])
-            elif state == 'select_a':
-                completer = TermCompleter(['from'])
-            elif state == 'select_a_comma_':
-                completer = TermCompleter(['*'])
-            elif state == 'select_a_':
-                completer = TermCompleter(['from'])
-            elif state == "select_from_":
-                completer = TermCompleter(self.tables())
-            elif state == "select_from_x_":
-                completer = TermCompleter(['as', 'where', 'inner', 'left', 'right', 'full', 'group', 'limit'])
-            elif state == "select_from_x_as_x_":
-                completer = TermCompleter(['where', 'inner', 'left', 'right', 'full', 'group', 'limit'])
-            elif state == "select_from_x_comma_":
-                completer = TermCompleter(self.tables())
-            elif state == "select_from_x_as_":
-                completer = TermCompleter(['x', 'y', 'z'])
-            elif state == "select_from_x_as_x_comma_":
-                completer = TermCompleter(self.tables())
-            elif state == "select_where_":
-                completer = columns
-            elif state in ["select_where_a", "select_where_a_"]:
-                completer = TermCompleter(['=', '<', '<=', '>', '>=', '<>', 'like', 'not', 'in'])
-            elif state == "select_where_a_not_":
-                completer = TermCompleter(['like', 'in'])
-            elif state == "select_where_a_in":
-                completer = TermCompleter(['('])
-            elif state == "select_where_a_in_lp_":
-                completer = TermCompleter(["'", ')'])
-            elif state == "select_where_a_in_lp_a_comma_":
-                completer = TermCompleter(["'"])
-            elif state == "select_where_a_op":
-                completer = TermCompleter(["'"])
-            elif state == "select_where_sc_":
-                completer = TermCompleter(['and', 'or', 'group', 'limit'])
-            elif state == "select_where_sc_limit_":
-                completer = TermCompleter(['1'])
-            elif state == "select_group_":
-                completer = TermCompleter(['by'])
-            elif state == "select_group_by_":
-                completer = columns
-            elif state == "select_group_by_a_comma_":
-                completer = columns
-            elif state == "select_group_by_a_":
-                completer = TermCompleter(['limit'])
-            elif state == "select_group_by_a_limit_":
-                completer = TermCompleter(['1'])
-            elif state == "select_from_x_inner_":
-                completer = TermCompleter(['join'])
-            elif state in ["select_join_", "select_from_x_left_join_"]:
-                completer = TermCompleter(self.tables())
-            elif state == "select_x_join_y,":
-                completer = TermCompleter(self.tables())
-            elif state == "select_x_join_y_":
-                completer = TermCompleter(['on'])
-            elif state == "select_x_join_y_on_":
-                completer = columns
-            elif state == "select_x_join_y_on_a":
-                completer = TermCompleter(['='])
-            elif state == "select_x_join_y_on_a_op":
-                completer = columns
-            elif state == "select_x_join_y_on_a_op_b_":
-                completer = TermCompleter(['where', 'group', 'limit'])
-            elif state == "select_from_x_left_":
-                completer = TermCompleter(['outer', 'join'])
-            elif state == "select_from_x_left_outer_":
-                completer = TermCompleter(['join'])
-            elif state == "select_from_x_right_":
-                completer = TermCompleter(['outer', 'join'])
-            elif state == "select_from_x_right_outer_":
-                completer = TermCompleter(['join'])
-            elif state == "select_from_x_full_":
-                completer = TermCompleter(['outer'])
-            elif state == "select_from_x_full_outer_":
-                completer = TermCompleter(['join'])
-
-            elif state == "insert_":
-                completer = TermCompleter(['into'])
-            elif state == "insert_into_":
-                completer = TermCompleter(self.tables())
-            elif state == "insert_into_x_":
-                completer = TermCompleter(['values(', 'select'])
-            elif state == "insert_into_x_lp_":
-                completer = columns
-            elif state == "insert_into_x_lp_a_comma_":
-                completer = columns
-            elif state == "insert_into_x_lp_a_rp__":
-                completer = TermCompleter(['values(', 'select'])
-            elif state == "insert_values":
-                completer = TermCompleter(['('])
-            elif state == "insert_values_lp_":
-                completer = TermCompleter(["'"])
-
-            elif state == "update_":
-                completer = TermCompleter(self.tables())
-            elif state == "update_x_":
-                completer = TermCompleter(['set'])
-            elif state in ["update_set_", "update_set_sc_comma_"]:
-                completer = columns
-            elif state == "update_set_a":
-                completer = TermCompleter(['='])
-            elif state == "update_set_a_op":
-                completer = TermCompleter(["'"])
-            elif state == "update_set_sc_":
-                completer = TermCompleter(['where'])
-            elif state == "update_where_":
-                completer = columns
-            elif state == "update_where_a":
-                completer = TermCompleter(['='])
-            elif state == "update_where_sc_":
-                completer = TermCompleter(['and', 'or'])
-
-            elif state == "delete_":
-                completer = TermCompleter(['from'])
-            elif state == "delete_from_":
-                completer = TermCompleter(self.tables())
-            elif state == "delete_from_x_":
-                completer = TermCompleter(['where'])
-            elif state == "delete_where_":
-                completer = columns
-            elif state == "delete_where_a":
-                completer = TermCompleter(['='])
-            elif state == "delete_where_a_op":
-                completer = TermCompleter(["'"])
-            elif state == "delete_where_sc_":
-                completer = TermCompleter(['and', 'or'])
+            completers: dict[str, str] = self.machine[1]
+            if state in completers:
+                terms = []
+
+                words = completers[state]
+                for word in words.strip(' ').split(','):
+                    if word == 'tables':
+                        terms.extend(self.tables())
+                    elif word == 'single':
+                        terms.append("'")
+                    elif word == 'comma':
+                        terms.append(",")
+                    else:
+                        terms.append(word)
+
+                if terms:
+                    completer = TermCompleter(terms)
 
         if completer:
             for c in completer.get_completions(document, complete_event):
@@ -298,15 +189,15 @@ class SqlCompleter(Completer):
     def automata(self):
         y = [
             '                                > 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',
-            'select_from_                    > name             > select_from_x',
+            'select_a_comma_                 > name|*           > select_a                      ^ *',
+            'select_a_                       > from             > select_from                   ^ from',
+            'select_from_                    > name             > select_from_x                 ^ tables',
             'select_from_x                   > ,                > select_from_x_comma_',
-            'select_from_x_comma_            > name             > select_from_x',
-            'select_from_x_',
-            'select_from_x_as_x_             > ,                > select_from_x_comma_',
+            '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',
@@ -322,101 +213,94 @@ class SqlCompleter(Completer):
             '-                               > 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',
+            '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_from_x_as_x_comma_       > name             > select_from_x_as_x',
-            'select_where_                   > name             > select_where_a',
-            'select_where_a                  > comparison       > select_where_a_op',
-            'select_where_a_                 > comparison       > select_where_a_op',
+            'select_from_x_as_x_comma_       > name             > select_from_x_as_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',
+            '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      > select_where_a_in_lp_a',
-            'select_where_a_in_lp_a          > ,                > select_where_a_in_lp_a_comma_',
+            '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_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      > select_where_a_in_lp_a',
-            'select_where_a_not_op           > name|single      > select_where_sc',
-            'select_where_a_op               > name|single      > select_where_sc',
-            'select_where_sc_                > and|or           > select_where',
+            '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',
-            'select_group_by_                > name             > select_group_by_a',
+            '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_group_by_a_comma_        > name             > select_group_by_a',
-            'select_group_by_a_              > limit            > select_where_sc_limit',
-            'select_where_sc_limit           > _                > select_where_sc_limit_',
+            '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_x_inner_           > join             > select_join',
-            'select_join_                    > name             > select_x_join_y',
-            'select_from_x_left_             > join             > select_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',
-            'select_from_x_                  > left outer join  > select_join',
-            'select_from_x_right_            > join             > select_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',
-            'select_from_x_full_             > join             > select_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',
-            'select_x_join_y                 > ,                > select_x_join_y_comma_',
-            'select_x_join_y_comma_          > name             > select_x_join_y',
-            'select_x_join_y_                > on               > select_x_join_y_on',
-            'select_x_join_y_on_             > name             > select_x_join_y_on_a',
-            'select_x_join_y_on_a            > comparison       > select_x_join_y_on_a_op',
-            'select_x_join_y_on_a_op         > name|single      > select_x_join_y_on_a_op_b',
-            'select_x_join_y_on_a_op_b       > ,                > select_x_join_y_on_',
-            'select_x_join_y_on_a_op_b_      > and|or           > select_join',
-            '-                               > where            > select_where',
-            '-                               > group            > select_group',
-            '-                               > group by         > select_group_by',
-            '-                               > limit            > select_where_sc_limit',
+            'select_from_x_full_outer_       > join             > select_join                   ^ join',
+            'select_x_join_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_',
 
 
             '                                > insert           > insert',
-            'insert_                         > into             > insert_into',
-            'insert_into_                    > name             > insert_into_x',
+            '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_',
+            'insert_into_x_                  > (                > insert_into_x_lp_             ^ (,values(',
             '-                               > values           > insert_values',
-            'insert_into_x_lp_               > name             > insert_into_x_lp_a',
+            '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',
-            'insert_into_x_lp_a_rp__         > values           > insert_values',
+            '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      > insert_values_lp_v',
+            '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      > insert_values_lp_v',
+            'insert_values_lp_v_comma_       > name|single|num  > insert_values_lp_v',
 
 
             '                                > update           > update',
-            'update_                         > name             > update_x',
-            'update_x_                       > set              > update_set',
-            'update_set_                     > name             > update_set_a',
+            '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      > update_set_sc',
+            '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',
-            'update_set_sc_                  > ,                > update_set_sc_comma_',
+            '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',
+            'update_where_                   > name             > update_where_a                ^ id',
             'update_where_a                  > comparison       > update_where_a_op',
-            'update_where_a_op               > name|single      > update_where_sc',
-            'update_where_sc_                > and|or           > update_where',
+            'update_where_a_                 > comparison       > update_where_a_op             ^ =,<,<=,>,>=,<>,like,not,in',
+            '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',
-            'delete_from_                    > name             > delete_from_x',
-            'delete_from_x_                  > where            > delete_where',
-            'delete_where_                   > name             > delete_where_a',
-            'delete_where_a                  > comparison       > delete_where_a_op',
-            'delete_where_a_op               > name|single      > delete_where_sc',
-            'delete_where_sc_                > and|or           > delete_where',
+            'delete_                         > from             > delete_from                   ^ from',
+            'delete_from_                    > name             > delete_from_x                 ^ tables',
+            'delete_from_x_                  > where            > delete_where                  ^ where',
+            'delete_where_                   > name             > delete_where_a                ^ id',
+            'delete_where_a                  > comparison       > delete_where_a_op             ^ =,<,<=,>,>=,<>,like,not,in',
+            'delete_where_a_op               > name|single|num  > delete_where_sc               ^ single',
+            'delete_where_sc_                > and|or           > delete_where                  ^ and,or',
         ]
 
         def add_space_transition(from_s: str):
@@ -427,14 +311,22 @@ class SqlCompleter(Completer):
                 machine[f'{from_s[:-1]} > _'] = from_s
 
         machine: dict[str, str] = {}
+        completers: dict[str, str] = {}
 
         from_ss_to_add = []
         from_ss = ['']
         token = None
         tokens = []
         to_s = None
+        words: str = None
         for l in y:
-            tks = l.split('>')
+            t_and_w = l.split('^')
+            if len(t_and_w) > 1:
+                words = t_and_w[1]
+            else:
+                words = None
+
+            tks = t_and_w[0].strip(' ').split('>')
             if l.startswith('-'):
                 token = tks[1].strip(' ')
                 if len(tks) > 2:
@@ -449,6 +341,9 @@ class SqlCompleter(Completer):
                                 print(f'{from_s} > {t} = {to_s}')
                             machine[f'{from_s} > {t}'] = to_s
             else:
+                if words:
+                    completers[tks[0].strip(' ')] = words
+
                 if len(tks) == 1:
                     from_s = tks[0].strip(' ')
                     add_space_transition(from_s)
@@ -458,7 +353,7 @@ class SqlCompleter(Completer):
                 from_ss = []
                 from_ss.extend(from_ss_to_add)
                 from_ss_to_add = []
-                from_ss.append(f'{tks[0].strip(" ")}')
+                from_ss.append(tks[0].strip(' '))
                 for from_s in from_ss:
                     add_space_transition(from_s)
                     token = tks[1].strip(' ')
@@ -474,7 +369,7 @@ class SqlCompleter(Completer):
                                 print(f'{from_s} > {t} = {to_s}')
                             machine[f'{from_s} > {t}'] = to_s
 
-        return machine
+        return (machine, completers)
 
     def traverse_tokens(self, text: str, tokens: list[Token], state: str = '', indent=0):
         keywords = [
@@ -503,7 +398,7 @@ class SqlCompleter(Completer):
                         print(f'"{token.value}:{typ}" ', end='')
                     else:
                         print(f'{token.value}:{typ} ', end='')
-                # print("  " * indent + f"Token: {token.value}, Type: {token.ttype}@{token.ttype.__class__}")
+            # print("  " * indent + f"Token: {token.value}, Type: {token.ttype}@{token.ttype.__class__}")
 
             if token.is_group:
                 state = self.traverse_tokens(text, token.tokens, state, indent + 1)
@@ -513,8 +408,12 @@ class SqlCompleter(Completer):
                     it = t
                 elif token.ttype == T.Text.Whitespace:
                     it = '_'
-                elif token.ttype in [T.Name, T.Literal.String.Single]:
+                elif token.ttype == T.Name:
                     it = 'name'
+                elif token.ttype == T.Literal.String.Single:
+                    it = 'single'
+                elif token.ttype in [T.Literal.Number.Integer, T.Literal.Number.Float]:
+                    it = 'num'
                 elif token.ttype == T.Wildcard:
                     it = '*'
                 elif token.ttype == T.Punctuation:
@@ -528,7 +427,7 @@ class SqlCompleter(Completer):
                     it = 'comparison'
 
                 try:
-                    state = self.machine[f'{state} > {it}']
+                    state = self.machine[0][f'{state} > {it}']
                 except:
                     pass
 

kaqing-2.0.62/adam/version.py

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

{kaqing-2.0.60 → kaqing-2.0.62}/kaqing.egg-info/PKG-INFO

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

{kaqing-2.0.60 → kaqing-2.0.62}/setup.py

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

kaqing-2.0.60/adam/version.py

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