Upgrade code for compatibility with prompt_toolkit 3.0.

Author: jonathanslenders

Diff for: PyInquirer/__init__.py

@@ -1,12 +1,7 @@
 # -*- coding: utf-8 -*-
 
-from __future__ import absolute_import, print_function
 import os
 
-# from prompt_toolkit.token import Token
-# from prompt_toolkit.styles import style_from_dict
-# from prompt_toolkit.validation import Validator, ValidationError
-
 from .utils import print_json, format_json
 
 
@@ -21,9 +16,22 @@ class PromptParameterException(ValueError):
     def __init__(self, message, errors=None):
 
         # Call the base class constructor with the parameters it needs
-        super(PromptParameterException, self).__init__(
-            'You must provide a `%s` value' % message, errors)
+        super().__init__('You must provide a `%s` value' % message, errors)
 
 from .prompt import prompt
 from .separator import Separator
 from .prompts.common import default_style
+
+
+# The code below here is here because of backwards-compatibility. Before,
+# people were using style_from_dict and importing it from here. It's better to
+# use Style.from_dict, as recommended by prompt_toolkit now.
+from prompt_toolkit.styles import Style
+def style_from_dict(style_dict):
+    # Deprecated function. Users should use Style.from_dict instead.
+    # Keep this here for backwards-compatibility.
+    return Style.from_dict({
+        '.'.join(key).lower(): value for key, value in style_dict.items()
+    })
+from pygments.token import Token
+from prompt_toolkit.validation import Validator, ValidationError

Diff for: PyInquirer/color_print.py

@@ -2,21 +2,17 @@
 """
 provide colorized output
 """
-from __future__ import print_function, unicode_literals
 import sys
-from prompt_toolkit.shortcuts import print_tokens, style_from_dict, Token
+from prompt_toolkit.shortcuts import print_tokens
 
 
 def _print_token_factory(col):
     """Internal helper to provide color names."""
     def _helper(msg):
-        style = style_from_dict({
-            Token.Color: col,
-        })
         tokens = [
-            (Token.Color, msg)
+            ('fg:' + col, msg)
         ]
-        print_tokens(tokens, style=style)
+        print_tokens(tokens)
 
     def _helper_no_terminal(msg):
         # workaround if we have no terminal

Diff for: PyInquirer/prompt.py

@@ -1,11 +1,10 @@
 # -*- coding: utf-8 -*-
-
-from __future__ import absolute_import, print_function
-
-from prompt_toolkit.shortcuts import run_application
-
+from contextlib import contextmanager
 from . import PromptParameterException, prompts
 from .prompts import list, confirm, input, password, checkbox, rawlist, expand, editor
+from prompt_toolkit.patch_stdout import patch_stdout as pt_patch_stdout
+from prompt_toolkit.shortcuts import PromptSession
+from prompt_toolkit.application import Application
 
 
 def prompt(questions, answers=None, **kwargs):
@@ -17,7 +16,6 @@ def prompt(questions, answers=None, **kwargs):
     return_asyncio_coroutine = kwargs.pop('return_asyncio_coroutine', False)
     true_color = kwargs.pop('true_color', False)
     refresh_interval = kwargs.pop('refresh_interval', 0)
-    eventloop = kwargs.pop('eventloop', None)
     kbi_msg = kwargs.pop('keyboard_interrupt_msg', 'Cancelled by user')
     raise_kbi = kwargs.pop('raise_keyboard_interrupt', False)
 
@@ -64,16 +62,22 @@ def prompt(questions, answers=None, **kwargs):
 
             if callable(question.get('default')):
                 _kwargs['default'] = question['default'](answers)
-            
-            application = getattr(prompts, type).question(message, **_kwargs)
 
-            answer = run_application(
-                application,
-                patch_stdout=patch_stdout,
-                return_asyncio_coroutine=return_asyncio_coroutine,
-                true_color=true_color,
-                refresh_interval=refresh_interval,
-                eventloop=eventloop)
+            with pt_patch_stdout() if patch_stdout else _dummy_context_manager():
+                result = getattr(prompts, type).question(message, **_kwargs)
+
+                if isinstance(result, PromptSession):
+                    answer = result.prompt()
+                elif isinstance(result, Application):
+                    answer = result.run()
+                else:
+                    assert isinstance(answer, str)
+                    answer = result
+
+                #answer = application.run(
+                #    return_asyncio_coroutine=return_asyncio_coroutine,
+                #    true_color=true_color,
+                #    refresh_interval=refresh_interval)
 
             if answer is not None:
                 if filter:
@@ -97,6 +101,9 @@ def prompt(questions, answers=None, **kwargs):
             return {}
     return answers
 
+@contextmanager
+def _dummy_context_manager():
+    yield
 
 # TODO:
 # Bottom Bar - inquirer.ui.BottomBar

Diff for: PyInquirer/prompts/checkbox.py

@@ -2,27 +2,24 @@
 """
 `checkbox` type question
 """
-from __future__ import print_function, unicode_literals
 from prompt_toolkit.application import Application
-from prompt_toolkit.key_binding.manager import KeyBindingManager
-from prompt_toolkit.keys import Keys
-from prompt_toolkit.layout.containers import Window
+from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.filters import IsDone
-from prompt_toolkit.layout.controls import TokenListControl
+from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.layout.containers import ConditionalContainer, \
-    ScrollOffsets, HSplit
+    ScrollOffsets, HSplit, Window, WindowAlign
 from prompt_toolkit.layout.dimension import LayoutDimension as D
-from prompt_toolkit.token import Token
+from prompt_toolkit.layout import Layout
 
 from .. import PromptParameterException
 from ..separator import Separator
 from .common import setup_simple_validator, default_style, if_mousedown
 
 
-# custom control based on TokenListControl
+# custom control based on FormattedTextControl
 
 
-class InquirerControl(TokenListControl):
+class InquirerControl(FormattedTextControl):
     def __init__(self, choices, pointer_index, **kwargs):
         self.pointer_index = pointer_index
         self.pointer_sign = kwargs.pop("pointer_sign", "\u276f")
@@ -31,8 +28,7 @@ def __init__(self, choices, pointer_index, **kwargs):
         self.selected_options = []  # list of names
         self.answered = False
         self._init_choices(choices)
-        super(InquirerControl, self).__init__(self._get_choice_tokens,
-                                              **kwargs)
+        super().__init__(self._get_choice_tokens, **kwargs)
 
     def _init_choices(self, choices):
         # helper to convert from question format to internal format
@@ -57,48 +53,47 @@ def _init_choices(self, choices):
     def choice_count(self):
         return len(self.choices)
 
-    def _get_choice_tokens(self, cli):
+    def _get_choice_tokens(self):
         tokens = []
-        T = Token
 
         def append(index, line):
             if isinstance(line, Separator):
-                tokens.append((T.Separator, '  %s\n' % line))
+                tokens.append(('class:Separator', '  %s\n' % line))
             else:
                 line_name = line[0]
                 line_value = line[1]
                 selected = (line_value in self.selected_options)  # use value to check if option has been selected
                 pointed_at = (index == self.pointer_index)
 
                 @if_mousedown
-                def select_item(cli, mouse_event):
+                def select_item(mouse_event):
                     # bind option with this index to mouse event
                     if line_value in self.selected_options:
                         self.selected_options.remove(line_value)
                     else:
                         self.selected_options.append(line_value)
 
                 if pointed_at:
-                    tokens.append((T.Pointer, ' {}'.format(self.pointer_sign), select_item))  # ' >'
+                    tokens.append(('class:pointer', ' {}'.format(self.pointer_sign), select_item))  # ' >'
                 else:
-                    tokens.append((T, '  ', select_item))
+                    tokens.append(('', '  ', select_item))
                 # 'o ' - FISHEYE
                 if choice[2]:  # disabled
-                    tokens.append((T, '- %s (%s)' % (choice[0], choice[2])))
+                    tokens.append(('', '- %s (%s)' % (choice[0], choice[2])))
                 else:
                     if selected:
-                        tokens.append((T.Selected, '{} '.format(self.selected_sign), select_item))
+                        tokens.append(('class:selected', '{} '.format(self.selected_sign), select_item))
                     else:
-                        tokens.append((T, '{} '.format(self.unselected_sign), select_item))
+                        tokens.append(('', '{} '.format(self.unselected_sign), select_item))
 
                     if pointed_at:
-                        tokens.append((Token.SetCursorPosition, ''))
+                        tokens.append(('[SetCursorPosition]', ''))
 
                     if choice[3]:  # description
-                        tokens.append((T, "%s - %s" % (line_name, choice[3])))
+                        tokens.append(('', "%s - %s" % (line_name, choice[3])))
                     else:
-                        tokens.append((T, line_name, select_item))
-                tokens.append((T, '\n'))
+                        tokens.append(('', line_name, select_item))
+                tokens.append(('', '\n'))
 
         # prepare the select choices
         for i, choice in enumerate(self.choices):
@@ -142,30 +137,31 @@ def question(message, **kwargs):
     ic = InquirerControl(choices, pointer_index, **additional_parameters)
     qmark = kwargs.pop('qmark', '?')
 
-    def get_prompt_tokens(cli):
+    def get_prompt_tokens():
         tokens = []
 
-        tokens.append((Token.QuestionMark, qmark))
-        tokens.append((Token.Question, ' %s ' % message))
+        tokens.append(('class:questionmark', qmark))
+        tokens.append(('class:question', ' %s ' % message))
         if ic.answered:
             nbr_selected = len(ic.selected_options)
             if nbr_selected == 0:
-                tokens.append((Token.Answer, ' done'))
+                tokens.append(('class:answer', ' done'))
             elif nbr_selected == 1:
-                tokens.append((Token.Answer, ' [%s]' % ic.selected_options[0]))
+                tokens.append(('class:Answer', ' [%s]' % ic.selected_options[0]))
             else:
-                tokens.append((Token.Answer,
+                tokens.append(('class:answer',
                                ' done (%d selections)' % nbr_selected))
         else:
-            tokens.append((Token.Instruction,
+            tokens.append(('class:instruction',
                            ' (<up>, <down> to move, <space> to select, <a> '
                            'to toggle, <i> to invert)'))
         return tokens
 
     # assemble layout
     layout = HSplit([
         Window(height=D.exact(1),
-               content=TokenListControl(get_prompt_tokens, align_center=False)
+               content=FormattedTextControl(get_prompt_tokens),
+               align=WindowAlign.CENTER,
         ),
         ConditionalContainer(
             Window(
@@ -179,31 +175,31 @@ def get_prompt_tokens(cli):
     ])
 
     # key bindings
-    manager = KeyBindingManager.for_prompt()
+    kb = KeyBindings()
 
-    @manager.registry.add_binding(Keys.ControlQ, eager=True)
-    @manager.registry.add_binding(Keys.ControlC, eager=True)
+    @kb.add('c-q', eager=True)
+    @kb.add('c-c', eager=True)
     def _(event):
         raise KeyboardInterrupt()
-        # event.cli.set_return_value(None)
+        # event.app.exit(result=None)
 
-    @manager.registry.add_binding(' ', eager=True)
+    @kb.add(' ', eager=True)
     def toggle(event):
         pointed_choice = ic.choices[ic.pointer_index][1]  # value
         if pointed_choice in ic.selected_options:
             ic.selected_options.remove(pointed_choice)
         else:
             ic.selected_options.append(pointed_choice)
 
-    @manager.registry.add_binding('i', eager=True)
+    @kb.add('i', eager=True)
     def invert(event):
         inverted_selection = [c[1] for c in ic.choices if
                               not isinstance(c, Separator) and
                               c[1] not in ic.selected_options and
                               not c[2]]
         ic.selected_options = inverted_selection
 
-    @manager.registry.add_binding('a', eager=True)
+    @kb.add('a', eager=True)
     def all(event):
         all_selected = True  # all choices have been selected
         for c in ic.choices:
@@ -214,7 +210,7 @@ def all(event):
         if all_selected:
             ic.selected_options = []
 
-    @manager.registry.add_binding(Keys.Down, eager=True)
+    @kb.add('down', eager=True)
     def move_cursor_down(event):
         def _next():
             ic.pointer_index = ((ic.pointer_index + 1) % ic.line_count)
@@ -223,7 +219,7 @@ def _next():
                 ic.choices[ic.pointer_index][2]:
             _next()
 
-    @manager.registry.add_binding(Keys.Up, eager=True)
+    @kb.add('up', eager=True)
     def move_cursor_up(event):
         def _prev():
             ic.pointer_index = ((ic.pointer_index - 1) % ic.line_count)
@@ -232,15 +228,15 @@ def _prev():
                 ic.choices[ic.pointer_index][2]:
             _prev()
 
-    @manager.registry.add_binding(Keys.Enter, eager=True)
+    @kb.add('enter', eager=True)
     def set_answer(event):
         ic.answered = True
         # TODO use validator
-        event.cli.set_return_value(ic.get_selected_values())
+        event.app.exit(result=ic.get_selected_values())
 
     return Application(
-        layout=layout,
-        key_bindings_registry=manager.registry,
+        layout=Layout(layout),
+        key_bindings=kb,
         mouse_support=True,
         style=style
     )