Suggestions to #133393

python · erlend-aasland · Jun 6, 2025 · May 4, 2025 · May 4, 2025 · May 4, 2025
commit fd6c89ef68f4384d720abe33c256fcc51ed49e1f
@@ -12,7 +12,7 @@
 from textwrap import dedent
 from _colorize import get_theme, theme_no_color
 
-from ._completer import enable_completer
+from ._completer import completer
 
 
 def execute(c, sql, suppress_errors=True, theme=theme_no_color):
@@ -138,7 +138,7 @@ def main(*args):
             execute(con, args.sql, suppress_errors=False, theme=theme)
         else:
             # No SQL provided; start the REPL.
-            with enable_completer():
+            with completer():
                 console = SqliteInteractiveConsole(con, use_color=True)
                 console.interact(banner, exitmsg="")
     finally:

@@ -1,14 +1,16 @@
 from contextlib import contextmanager
 
+try:
+    from _sqlite3 import SQLITE_KEYWORDS
+except ImportError:
+    SQLITE_KEYWORDS = ()
+
 _completion_matches = []
 
 
 def _complete(text, state):
-    try:
-        from _sqlite3 import SQLITE_KEYWORDS
-    except ImportError:
-        SQLITE_KEYWORDS = ()
     global _completion_matches
+
     if state == 0:
         text_upper = text.upper()
         _completion_matches = [c for c in SQLITE_KEYWORDS if c.startswith(text_upper)]
@@ -19,7 +21,7 @@ def _complete(text, state):
 
 
 @contextmanager
-def enable_completer():
+def completer():
     try:
         import readline
     except ImportError:

@@ -4,7 +4,6 @@
 import textwrap
 import unittest
 
-from _sqlite3 import SQLITE_KEYWORDS
 from sqlite3.__main__ import main as cli
 from test.support.import_helper import import_module
 from test.support.os_helper import TESTFN, unlink
@@ -209,76 +208,93 @@ def test_color(self):
 
 @requires_subprocess()
 @force_not_colorized_test_class
-class CompletionTest(unittest.TestCase):
+class Completion(unittest.TestCase):
     PS1 = "sqlite> "
 
     @classmethod
     def setUpClass(cls):
+        _sqlite3 = import_module("_sqlite3")
+        if not hasattr(_sqlite3, "SQLITE_KEYWORDS"):
+            raise unittest.SkipTest("unable to determine SQLite keywords")
+
         readline = import_module("readline")
         if readline.backend == "editline":
             raise unittest.SkipTest("libedit readline is not supported")
 
-    def write_input(self, input, env=None):
+    def write_input(self, input_, env=None):
         script = textwrap.dedent("""
             import readline
+            from sqlite3.__main__ import main
+
             readline.parse_and_bind("set colored-completion-prefix off")
-            from sqlite3.__main__ import main; main()
+            main()
         """)
-        return run_pty(script, input, env)
+        return run_pty(script, input_, env)
 
-    def test_keyword_completion(self):
+    def test_complete_sql_keywords(self):
         # List candidates starting with 'S', there should be multiple matches.
-        input = b"S\t\tEL\t 1;\n.quit\n"
-        output = self.write_input(input)
+        input_ = b"S\t\tEL\t 1;\n.quit\n"
+        output = self.write_input(input_)
         self.assertIn(b"SELECT", output)
         self.assertIn(b"SET", output)
         self.assertIn(b"SAVEPOINT", output)
         self.assertIn(b"(1,)", output)
 
-        # Keywords are completed in upper case for even lower case user input
-        input = b"sel\t\t 1;\n.quit\n"
-        output = self.write_input(input)
+        # Keywords are completed in upper case for even lower case user input.
+        input_ = b"sel\t\t 1;\n.quit\n"
+        output = self.write_input(input_)
         self.assertIn(b"SELECT", output)
         self.assertIn(b"(1,)", output)
 
     @unittest.skipIf(sys.platform.startswith("freebsd"),
                     "Two actual tabs are inserted when there are no matching"
                     " completions in the pseudo-terminal opened by run_pty()"
                     " on FreeBSD")
-    def test_nothing_to_complete(self):
-        input = b"xyzzy\t\t\b\b\b\b\b\b\b.quit\n"
-        # set NO_COLOR to disable coloring for self.PS1
-        output = self.write_input(input, env={"NO_COLOR": "1"})
-        output_lines = output.decode().splitlines()
-        line_num = next((i for i, line in enumerate(output_lines, 1)
-                         if line.startswith(f"{self.PS1}xyzzy")), -1)
+    def test_complete_no_match(self):
+        input_ = b"xyzzy\t\t\b\b\b\b\b\b\b.quit\n"
+        # Set NO_COLOR to disable coloring for self.PS1.
+        output = self.write_input(input_, env={"NO_COLOR": "1"})
+        lines = output.decode().splitlines()
+        indices = (
+            i for i, line in enumerate(lines, 1)
+            if line.startswith(f"{self.PS1}xyzzy")
+        )
+        line_num = next(indices, -1)
         self.assertNotEqual(line_num, -1)
-        # completions occupy lines, assert no extra lines when there is nothing
-        # to complete
-        self.assertEqual(line_num, len(output_lines))
+        # Completions occupy lines, assert no extra lines when there is nothing
+        # to complete.
+        self.assertEqual(line_num, len(lines))
+
+    def test_complete_no_input(self):
+        from _sqlite3 import SQLITE_KEYWORDS
 
-    def test_completion_for_nothing(self):
         script = textwrap.dedent("""
             import readline
+            from sqlite3.__main__ import main
+
+            # Configure readline to ...:
+            # - hide control sequences surrounding each candidate
+            # - hide "Display all xxx possibilities? (y or n)"
+            # - hide "--More--"
+            # - show candidates one per line
             readline.parse_and_bind("set colored-completion-prefix off")
-            # hide control sequences surrounding each candidate
             readline.parse_and_bind("set colored-stats off")
-            # hide "Display all xxx possibilities? (y or n)"
             readline.parse_and_bind("set completion-query-items 0")
-            # hide "--More--"
             readline.parse_and_bind("set page-completions off")
-            # show candidates one per line
             readline.parse_and_bind("set completion-display-width 0")
-            from sqlite3.__main__ import main; main()
+
+            main()
         """)
-        input = b"\t\t.quit\n"
-        output = run_pty(script, input, env={"NO_COLOR": "1"})
-        output_lines = output.decode().splitlines()
-        indices = [i for i, line in enumerate(output_lines)
-                   if line.startswith(self.PS1)]
+        input_ = b"\t\t.quit\n"
+        output = run_pty(script, input_, env={"NO_COLOR": "1"})
+        lines = output.decode().splitlines()
+        indices = [
+            i for i, line in enumerate(lines)
+            if line.startswith(self.PS1)
+        ]
         self.assertEqual(len(indices), 2)
-        start, end = indices[0] + 1, indices[1]
-        candidates = list(map(str.strip, output_lines[start:end]))
+        start, end = indices
+        candidates = [l.strip() for l in lines[start+1:end]]
         self.assertEqual(candidates, sorted(SQLITE_KEYWORDS))
 
 

@@ -405,14 +405,14 @@ pysqlite_error_name(int rc)
     return NULL;
 }
 
-#if SQLITE_VERSION_NUMBER < 3024000
 static int
 add_keyword_tuple(PyObject *module)
 {
+#if SQLITE_VERSION_NUMBER >= 3024000
     int count = sqlite3_keyword_count();
     PyObject *keywords = PyTuple_New(count);
     if (keywords == NULL) {
-        goto error;
+        return -1;
     }
     for (int i = 0; i < count; i++) {
         const char *keyword;
@@ -427,17 +427,17 @@ add_keyword_tuple(PyObject *module)
         if (!kwd) {
             goto error;
         }
-        if (PyTuple_SetItem(keywords, i, kwd) < 0) {
-            goto error;
-        }
+        PyTuple_SET_ITEM(keywords, i, kwd);
     }
     return PyModule_Add(module, "SQLITE_KEYWORDS", keywords);
 
 error:
-    Py_XDECREF(keywords);
+    Py_DECREF(keywords);
     return -1;
-}
+#else
+    return 0;
 #endif
+}
 
 static int
 add_integer_constants(PyObject *module) {
@@ -737,11 +737,9 @@ module_exec(PyObject *module)
         goto error;
     }
 
-#if SQLITE_VERSION_NUMBER < 3024000
     if (add_keyword_tuple(module) < 0) {
         goto error;
     }
-#endif
 
     if (PyModule_AddStringConstant(module, "sqlite_version", sqlite3_libversion())) {
         goto error;