Upgrade to prompt_toolkit 3.0.

- Drop Python <3.5 support and prompt_toolkit 2.
- Code formatting with black.
- Sorted imports with isort.
- Added type annotations.
- Separate event loop for reading user input.

Author: jonathanslenders

.travis.yml

@@ -4,18 +4,17 @@ language: python
 matrix:
   include:
       - python: 3.6
-      - python: 3.5
-      - python: 3.4
-      - python: 3.3
-      - python: 2.7
-      - python: 2.6
-      - python: pypy
-      - python: pypy3
+      - python: 3.7
 
 install:
-  - travis_retry pip install . pytest
+  - travis_retry pip install . pytest isort black
   - pip list
 
 script:
   - echo "$TRAVIS_PYTHON_VERSION"
   - ./tests/run_tests.py
+
+  # Check wheather the imports were sorted correctly.
+  - isort -c -rc ptpython tests setup.py examples
+
+  - black --check ptpython setup.py examples

examples/asyncio-python-embed.py

@@ -12,10 +12,11 @@
 prompt.
 """
 from __future__ import unicode_literals
-from ptpython.repl import embed
 
 import asyncio
 
+from ptpython.repl import embed
+
 loop = asyncio.get_event_loop()
 counter = [0]
 
@@ -26,7 +27,7 @@ def print_counter():
     Coroutine that prints counters and saves it in a global variable.
     """
     while True:
-        print('Counter: %i' % counter[0])
+        print("Counter: %i" % counter[0])
         counter[0] += 1
         yield from asyncio.sleep(3)
 
@@ -37,9 +38,13 @@ def interactive_shell():
     Coroutine that starts a Python REPL from which we can access the global
     counter variable.
     """
-    print('You should be able to read and update the "counter[0]" variable from this shell.')
+    print(
+        'You should be able to read and update the "counter[0]" variable from this shell.'
+    )
     try:
-        yield from embed(globals=globals(), return_asyncio_coroutine=True, patch_stdout=True)
+        yield from embed(
+            globals=globals(), return_asyncio_coroutine=True, patch_stdout=True
+        )
     except EOFError:
         # Stop the loop when quitting the repl. (Ctrl-D press.)
         loop.stop()
@@ -53,5 +58,5 @@ def main():
     loop.close()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

examples/asyncio-ssh-python-embed.py

@@ -6,9 +6,10 @@
 Run this example and then SSH to localhost, port 8222.
 """
 import asyncio
-import asyncssh
 import logging
 
+import asyncssh
+
 from ptpython.contrib.asyncssh_repl import ReplSSHServerSession
 
 logging.basicConfig()
@@ -19,6 +20,7 @@ class MySSHServer(asyncssh.SSHServer):
     """
     Server without authentication, running `ReplSSHServerSession`.
     """
+
     def __init__(self, get_namespace):
         self.get_namespace = get_namespace
 
@@ -37,22 +39,24 @@ def main(port=8222):
     loop = asyncio.get_event_loop()
 
     # Namespace exposed in the REPL.
-    environ = {'hello': 'world'}
+    environ = {"hello": "world"}
 
     # Start SSH server.
     def create_server():
         return MySSHServer(lambda: environ)
 
-    print('Listening on :%i' % port)
+    print("Listening on :%i" % port)
     print('To connect, do "ssh localhost -p %i"' % port)
 
     loop.run_until_complete(
-        asyncssh.create_server(create_server, '', port,
-                               server_host_keys=['/etc/ssh/ssh_host_dsa_key']))
+        asyncssh.create_server(
+            create_server, "", port, server_host_keys=["/etc/ssh/ssh_host_dsa_key"]
+        )
+    )
 
     # Run eventloop.
     loop.run_forever()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

examples/ptpython_config/config.py

@@ -4,16 +4,15 @@
 Copy this file to $XDG_CONFIG_HOME/ptpython/config.py
 """
 from __future__ import unicode_literals
+
 from prompt_toolkit.filters import ViInsertMode
 from prompt_toolkit.key_binding.key_processor import KeyPress
 from prompt_toolkit.keys import Keys
 from pygments.token import Token
 
 from ptpython.layout import CompletionVisualisation
 
-__all__ = (
-    'configure',
-)
+__all__ = ("configure",)
 
 
 def configure(repl):
@@ -50,7 +49,7 @@ def configure(repl):
 
     # Swap light/dark colors on or off
     repl.swap_light_and_dark = False
-    
+
     # Highlight matching parethesis.
     repl.highlight_matching_parenthesis = True
 
@@ -75,7 +74,7 @@ def configure(repl):
     repl.paste_mode = False
 
     # Use the classic prompt. (Display '>>>' instead of 'In [1]'.)
-    repl.prompt_style = 'classic'  # 'classic' or 'ipython'
+    repl.prompt_style = "classic"  # 'classic' or 'ipython'
 
     # Don't insert a blank line after the output.
     repl.insert_blank_line_after_output = False
@@ -108,14 +107,14 @@ def configure(repl):
     repl.enable_input_validation = True
 
     # Use this colorscheme for the code.
-    repl.use_code_colorscheme('pastie')
+    repl.use_code_colorscheme("pastie")
 
     # Set color depth (keep in mind that not all terminals support true color).
 
-    #repl.color_depth = 'DEPTH_1_BIT'  # Monochrome.
-    #repl.color_depth = 'DEPTH_4_BIT'  # ANSI colors only.
-    repl.color_depth = 'DEPTH_8_BIT'  # The default, 256 colors.
-    #repl.color_depth = 'DEPTH_24_BIT'  # True color.
+    # repl.color_depth = 'DEPTH_1_BIT'  # Monochrome.
+    # repl.color_depth = 'DEPTH_4_BIT'  # ANSI colors only.
+    repl.color_depth = "DEPTH_8_BIT"  # The default, 256 colors.
+    # repl.color_depth = 'DEPTH_24_BIT'  # True color.
 
     # Syntax.
     repl.enable_syntax_highlighting = True
@@ -142,7 +141,6 @@ def _(event):
         event.current_buffer.validate_and_handle()
     """
 
-
     # Typing 'jj' in Vi Insert mode, should send escape. (Go back to navigation
     # mode.)
     """
@@ -178,8 +176,7 @@ def _(event):
 # `ptpython/style.py` for all possible tokens.
 _custom_ui_colorscheme = {
     # Blue prompt.
-    Token.Layout.Prompt:                          'bg:#eeeeff #000000 bold',
-
+    Token.Layout.Prompt: "bg:#eeeeff #000000 bold",
     # Make the status toolbar red.
-    Token.Toolbar.Status:                         'bg:#ff0000 #000000',
+    Token.Toolbar.Status: "bg:#ff0000 #000000",
 }

examples/python-embed-with-custom-prompt.py

@@ -4,10 +4,11 @@
 """
 from __future__ import unicode_literals
 
-from ptpython.repl import embed
-from ptpython.prompt_style import PromptStyle
 from pygments.token import Token
 
+from ptpython.prompt_style import PromptStyle
+from ptpython.repl import embed
+
 
 def configure(repl):
     # There are several ways to override the prompt.
@@ -18,25 +19,23 @@ def configure(repl):
     class CustomPrompt(PromptStyle):
         def in_tokens(self, cli):
             return [
-                (Token.In, 'Input['),
-                (Token.In.Number, '%s' % repl.current_statement_index),
-                (Token.In, '] >>: '),
+                (Token.In, "Input["),
+                (Token.In.Number, "%s" % repl.current_statement_index),
+                (Token.In, "] >>: "),
             ]
 
         def in2_tokens(self, cli, width):
-           return [
-                (Token.In, '...: '.rjust(width)),
-            ]
+            return [(Token.In, "...: ".rjust(width))]
 
         def out_tokens(self, cli):
             return [
-                (Token.Out, 'Result['),
-                (Token.Out.Number, '%s' % repl.current_statement_index),
-                (Token.Out, ']: '),
+                (Token.Out, "Result["),
+                (Token.Out.Number, "%s" % repl.current_statement_index),
+                (Token.Out, "]: "),
             ]
 
-    repl.all_prompt_styles['custom'] = CustomPrompt()
-    repl.prompt_style = 'custom'
+    repl.all_prompt_styles["custom"] = CustomPrompt()
+    repl.prompt_style = "custom"
 
     # 2. Assign a new callable to `get_input_prompt_tokens`. This will always take effect.
     ## repl.get_input_prompt_tokens = lambda cli: [(Token.In, '[hello] >>> ')]
@@ -52,5 +51,5 @@ def main():
     embed(globals(), locals(), configure=configure)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

examples/python-embed.py

@@ -10,5 +10,5 @@ def main():
     embed(globals(), locals(), vi_mode=False)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

examples/python-input.py

@@ -10,8 +10,8 @@ def main():
     prompt = PythonInput()
 
     text = prompt.app.run()
-    print('You said: ' + text)
+    print("You said: " + text)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

ptpython/__main__.py

@@ -1,7 +1,6 @@
 """
 Make `python -m ptpython` an alias for running `./ptpython`.
 """
-from __future__ import unicode_literals
 from .entry_points.run_ptpython import run
 
 run()

ptpython/completer.py

@@ -1,27 +1,33 @@
-from __future__ import unicode_literals
+import ast
+import keyword
+import re
+from typing import TYPE_CHECKING, Iterable
 
-from prompt_toolkit.completion import Completer, Completion, PathCompleter
+from prompt_toolkit.completion import (
+    CompleteEvent,
+    Completer,
+    Completion,
+    PathCompleter,
+)
 from prompt_toolkit.contrib.regular_languages.compiler import compile as compile_grammar
 from prompt_toolkit.contrib.regular_languages.completion import GrammarCompleter
+from prompt_toolkit.document import Document
 
 from ptpython.utils import get_jedi_script_from_document
 
-import keyword
-import ast
-import re
-import six
+if TYPE_CHECKING:
+    from prompt_toolkit.contrib.regular_languages.compiler import _CompiledGrammar
 
-__all__ = (
-    'PythonCompleter',
-)
+__all__ = ["PythonCompleter"]
 
 
 class PythonCompleter(Completer):
     """
     Completer for Python code.
     """
+
     def __init__(self, get_globals, get_locals, get_enable_dictionary_completion):
-        super(PythonCompleter, self).__init__()
+        super().__init__()
 
         self.get_globals = get_globals
         self.get_locals = get_locals
@@ -33,17 +39,19 @@ def __init__(self, get_globals, get_locals, get_enable_dictionary_completion):
         self._path_completer_grammar_cache = None
 
     @property
-    def _path_completer(self):
+    def _path_completer(self) -> GrammarCompleter:
         if self._path_completer_cache is None:
             self._path_completer_cache = GrammarCompleter(
-                self._path_completer_grammar, {
-                    'var1': PathCompleter(expanduser=True),
-                    'var2': PathCompleter(expanduser=True),
-                })
+                self._path_completer_grammar,
+                {
+                    "var1": PathCompleter(expanduser=True),
+                    "var2": PathCompleter(expanduser=True),
+                },
+            )
         return self._path_completer_cache
 
     @property
-    def _path_completer_grammar(self):
+    def _path_completer_grammar(self) -> "_CompiledGrammar":
         """
         Return the grammar for matching paths inside strings inside Python
         code.
@@ -54,15 +62,15 @@ def _path_completer_grammar(self):
             self._path_completer_grammar_cache = self._create_path_completer_grammar()
         return self._path_completer_grammar_cache
 
-    def _create_path_completer_grammar(self):
-        def unwrapper(text):
-            return re.sub(r'\\(.)', r'\1', text)
+    def _create_path_completer_grammar(self) -> "_CompiledGrammar":
+        def unwrapper(text: str) -> str:
+            return re.sub(r"\\(.)", r"\1", text)
 
-        def single_quoted_wrapper(text):
-            return text.replace('\\', '\\\\').replace("'", "\\'")
+        def single_quoted_wrapper(text: str) -> str:
+            return text.replace("\\", "\\\\").replace("'", "\\'")
 
-        def double_quoted_wrapper(text):
-            return text.replace('\\', '\\\\').replace('"', '\\"')
+        def double_quoted_wrapper(text: str) -> str:
+            return text.replace("\\", "\\\\").replace('"', '\\"')
 
         grammar = r"""
                 # Text before the current string.
@@ -91,40 +99,45 @@ def double_quoted_wrapper(text):
 
         return compile_grammar(
             grammar,
-            escape_funcs={
-                'var1': single_quoted_wrapper,
-                'var2': double_quoted_wrapper,
-            },
-            unescape_funcs={
-                'var1': unwrapper,
-                'var2': unwrapper,
-            })
-
-    def _complete_path_while_typing(self, document):
+            escape_funcs={"var1": single_quoted_wrapper, "var2": double_quoted_wrapper},
+            unescape_funcs={"var1": unwrapper, "var2": unwrapper},
+        )
+
+    def _complete_path_while_typing(self, document: Document) -> bool:
         char_before_cursor = document.char_before_cursor
-        return document.text and (
-            char_before_cursor.isalnum() or char_before_cursor in '/.~')
+        return bool(
+            document.text
+            and (char_before_cursor.isalnum() or char_before_cursor in "/.~")
+        )
 
-    def _complete_python_while_typing(self, document):
+    def _complete_python_while_typing(self, document: Document) -> bool:
         char_before_cursor = document.char_before_cursor
-        return document.text and (
-            char_before_cursor.isalnum() or char_before_cursor in '_.')
+        return bool(
+            document.text
+            and (char_before_cursor.isalnum() or char_before_cursor in "_.")
+        )
 
-    def get_completions(self, document, complete_event):
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
         """
         Get Python completions.
         """
         # Do dictionary key completions.
         if self.get_enable_dictionary_completion():
             has_dict_completions = False
-            for c in self.dictionary_completer.get_completions(document, complete_event):
+            for c in self.dictionary_completer.get_completions(
+                document, complete_event
+            ):
                 has_dict_completions = True
                 yield c
             if has_dict_completions:
                 return
 
         # Do Path completions (if there were no dictionary completions).
-        if complete_event.completion_requested or self._complete_path_while_typing(document):
+        if complete_event.completion_requested or self._complete_path_while_typing(
+            document
+        ):
             for c in self._path_completer.get_completions(document, complete_event):
                 yield c
 
@@ -133,8 +146,12 @@ def get_completions(self, document, complete_event):
             return
 
         # Do Jedi Python completions.
-        if complete_event.completion_requested or self._complete_python_while_typing(document):
-            script = get_jedi_script_from_document(document, self.get_locals(), self.get_globals())
+        if complete_event.completion_requested or self._complete_python_while_typing(
+            document
+        ):
+            script = get_jedi_script_from_document(
+                document, self.get_locals(), self.get_globals()
+            )
 
             if script:
                 try:
@@ -178,9 +195,11 @@ def get_completions(self, document, complete_event):
                 else:
                     for c in completions:
                         yield Completion(
-                            c.name_with_symbols, len(c.complete) - len(c.name_with_symbols),
+                            c.name_with_symbols,
+                            len(c.complete) - len(c.name_with_symbols),
                             display=c.name_with_symbols,
-                            style=_get_style_for_name(c.name_with_symbols))
+                            style=_get_style_for_name(c.name_with_symbols),
+                        )
 
 
 class DictionaryCompleter(Completer):
@@ -191,14 +210,15 @@ class DictionaryCompleter(Completer):
              bracket, which is potentially dangerous. It doesn't match on
              function calls, so it only triggers attribute access.
     """
+
     def __init__(self, get_globals, get_locals):
-        super(DictionaryCompleter, self).__init__()
+        super().__init__()
 
         self.get_globals = get_globals
         self.get_locals = get_locals
 
         self.pattern = re.compile(
-            r'''
+            r"""
                 # Any expression safe enough to eval while typing.
                 # No operators, except dot, and only other dict lookups.
                 # Technically, this can be unsafe of course, if bad code runs
@@ -227,11 +247,13 @@ def __init__(self, get_globals, get_locals):
                 # string).
                 \[
                 \s* ([a-zA-Z0-9_'"]*)$
-            ''',
-            re.VERBOSE
+            """,
+            re.VERBOSE,
         )
 
-    def get_completions(self, document, complete_event):
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
         match = self.pattern.search(document.text_before_cursor)
         if match is not None:
             object_var, key = match.groups()
@@ -240,7 +262,7 @@ def get_completions(self, document, complete_event):
             # Do lookup of `object_var` in the context.
             try:
                 result = eval(object_var, self.get_globals(), self.get_locals())
-            except BaseException as e:
+            except BaseException:
                 return  # Many exception, like NameError can be thrown here.
 
             # If this object is a dictionary, complete the keys.
@@ -256,28 +278,26 @@ def get_completions(self, document, complete_event):
                         break
 
                 for k in result:
-                    if six.text_type(k).startswith(key_obj):
-                        yield Completion(
-                            six.text_type(repr(k)),
-                            - len(key),
-                            display=six.text_type(repr(k))
-                        )
+                    if str(k).startswith(key_obj):
+                        yield Completion(str(repr(k)), -len(key), display=str(repr(k)))
+
 
 try:
     import builtins
+
     _builtin_names = dir(builtins)
 except ImportError:  # Python 2.
     _builtin_names = []
 
 
-def _get_style_for_name(name):
+def _get_style_for_name(name: str) -> str:
     """
     Return completion style to use for this name.
     """
     if name in _builtin_names:
-        return 'class:completion.builtin'
+        return "class:completion.builtin"
 
     if keyword.iskeyword(name):
-        return 'class:completion.keyword'
+        return "class:completion.keyword"
 
-    return ''
+    return ""

ptpython/contrib/asyncssh_repl.py

@@ -6,22 +6,18 @@
 should make sure not to use Python 3-only syntax, because this
 package should be installable in Python 2 as well!
 """
-from __future__ import unicode_literals
-
 import asyncio
-import asyncssh
+from typing import Optional, TextIO, cast
 
-from prompt_toolkit.input import PipeInput
-from prompt_toolkit.interface import CommandLineInterface
-from prompt_toolkit.layout.screen import Size
-from prompt_toolkit.shortcuts import create_asyncio_eventloop
-from prompt_toolkit.terminal.vt100_output import Vt100_Output
+import asyncssh
+from prompt_toolkit.data_structures import Size
+from prompt_toolkit.input import create_pipe_input
+from prompt_toolkit.output.vt100 import Vt100_Output
 
+from ptpython.python_input import _GetNamespace
 from ptpython.repl import PythonRepl
 
-__all__ = (
-    'ReplSSHServerSession',
-)
+__all__ = ["ReplSSHServerSession"]
 
 
 class ReplSSHServerSession(asyncssh.SSHServerSession):
@@ -31,51 +27,47 @@ class ReplSSHServerSession(asyncssh.SSHServerSession):
     :param get_globals: callable that returns the current globals.
     :param get_locals: (optional) callable that returns the current locals.
     """
-    def __init__(self, get_globals, get_locals=None):
-        assert callable(get_globals)
-        assert get_locals is None or callable(get_locals)
 
+    def __init__(
+        self, get_globals: _GetNamespace, get_locals: Optional[_GetNamespace] = None
+    ) -> None:
         self._chan = None
 
-        def _globals():
+        def _globals() -> dict:
             data = get_globals()
-            data.setdefault('print', self._print)
+            data.setdefault("print", self._print)
             return data
 
-        repl = PythonRepl(get_globals=_globals,
-                          get_locals=get_locals or _globals)
-
-        # Disable open-in-editor and system prompt. Because it would run and
-        # display these commands on the server side, rather than in the SSH
-        # client.
-        repl.enable_open_in_editor = False
-        repl.enable_system_bindings = False
-
         # PipInput object, for sending input in the CLI.
         # (This is something that we can use in the prompt_toolkit event loop,
         # but still write date in manually.)
-        self._input_pipe = PipeInput()
+        self._input_pipe = create_pipe_input()
 
         # Output object. Don't render to the real stdout, but write everything
         # in the SSH channel.
-        class Stdout(object):
-            def write(s, data):
+        class Stdout:
+            def write(s, data: str) -> None:
                 if self._chan is not None:
-                    self._chan.write(data.replace('\n', '\r\n'))
+                    data = data.replace("\n", "\r\n")
+                    self._chan.write(data)
 
-            def flush(s):
+            def flush(s) -> None:
                 pass
 
-        # Create command line interface.
-        self.cli = CommandLineInterface(
-            application=repl.create_application(),
-            eventloop=create_asyncio_eventloop(),
+        self.repl = PythonRepl(
+            get_globals=_globals,
+            get_locals=get_locals or _globals,
             input=self._input_pipe,
-            output=Vt100_Output(Stdout(), self._get_size))
+            output=Vt100_Output(cast(TextIO, Stdout()), self._get_size),
+        )
 
-        self._callbacks = self.cli.create_eventloop_callbacks()
+        # Disable open-in-editor and system prompt. Because it would run and
+        # display these commands on the server side, rather than in the SSH
+        # client.
+        self.repl.enable_open_in_editor = False
+        self.repl.enable_system_bindings = False
 
-    def _get_size(self):
+    def _get_size(self) -> Size:
         """
         Callable that returns the current `Size`, required by Vt100_Output.
         """
@@ -92,42 +84,36 @@ def connection_made(self, chan):
         self._chan = chan
 
         # Run REPL interface.
-        f = asyncio.ensure_future(self.cli.run_async())
+        f = asyncio.ensure_future(self.repl.run_async())
 
         # Close channel when done.
-        def done(_):
+        def done(_) -> None:
             chan.close()
             self._chan = None
+
         f.add_done_callback(done)
 
-    def shell_requested(self):
+    def shell_requested(self) -> bool:
         return True
 
     def terminal_size_changed(self, width, height, pixwidth, pixheight):
         """
         When the terminal size changes, report back to CLI.
         """
-        self._callbacks.terminal_size_changed()
+        self.repl.app._on_resize()
 
     def data_received(self, data, datatype):
         """
         When data is received, send to inputstream of the CLI and repaint.
         """
         self._input_pipe.send(data)
 
-    def _print(self, *data, **kw):
+    def _print(self, *data, sep=" ", end="\n", file=None) -> None:
         """
-        _print(self, *data, sep=' ', end='\n', file=None)
-
         Alternative 'print' function that prints back into the SSH channel.
         """
         # Pop keyword-only arguments. (We cannot use the syntax from the
         # signature. Otherwise, Python2 will give a syntax error message when
         # installing.)
-        sep = kw.pop('sep', ' ')
-        end = kw.pop('end', '\n')
-        _ = kw.pop('file', None)
-        assert not kw, 'Too many keyword-only arguments'
-
         data = sep.join(map(str, data))
         self._chan.write(data + end)

ptpython/entry_points/run_ptipython.py

@@ -1,70 +1,37 @@
 #!/usr/bin/env python
-"""
-ptipython: IPython interactive shell with the `prompt_toolkit` front-end.
-Usage:
-    ptpython [ --vi ]
-             [ --config-dir=<directory> ] [ --interactive=<filename> ]
-             [--] [ <arg>... ]
-    ptpython -h | --help
-
-Options:
-    --vi                     : Use Vi keybindings instead of Emacs bindings.
-    --config-dir=<directory> : Pass config directory. By default '$XDG_CONFIG_HOME/ptpython'.
-    -i, --interactive=<filename> : Start interactive shell after executing this file.
-"""
-from __future__ import absolute_import, unicode_literals, print_function
-
-import appdirs
-import docopt
 import os
-import six
 import sys
 
+from .run_ptpython import create_parser, get_config_and_history_file
 
-def run(user_ns=None):
-    a = docopt.docopt(__doc__)
-
-    vi_mode = bool(a['--vi'])
-
-    config_dir = appdirs.user_config_dir('ptpython', 'prompt_toolkit')
-    data_dir = appdirs.user_data_dir('ptpython', 'prompt_toolkit')
 
-    if a['--config-dir']:
-        # Override config_dir.
-        config_dir = os.path.expanduser(a['--config-dir'])
-    else:
-        # Warn about the legacy directory.
-        legacy_dir = os.path.expanduser('~/.ptpython')
-        if os.path.isdir(legacy_dir):
-            print('{0} is deprecated, migrate your configuration to {1}'.format(legacy_dir, config_dir))
+def run(user_ns=None):
+    a = create_parser().parse_args()
 
-    # Create directories.
-    for d in (config_dir, data_dir):
-        if not os.path.isdir(d) and not os.path.islink(d):
-            os.mkdir(d)
+    config_file, history_file = get_config_and_history_file(a)
 
     # If IPython is not available, show message and exit here with error status
     # code.
     try:
         import IPython
     except ImportError:
-        print('IPython not found. Please install IPython (pip install ipython).')
+        print("IPython not found. Please install IPython (pip install ipython).")
         sys.exit(1)
     else:
         from ptpython.ipython import embed
         from ptpython.repl import run_config, enable_deprecation_warnings
 
     # Add the current directory to `sys.path`.
-    if sys.path[0] != '':
-        sys.path.insert(0, '')
+    if sys.path[0] != "":
+        sys.path.insert(0, "")
 
     # When a file has been given, run that, otherwise start the shell.
-    if a['<arg>'] and not a['--interactive']:
-        sys.argv = a['<arg>']
-        path = a['<arg>'][0]
-        with open(path, 'rb') as f:
-            code = compile(f.read(), path, 'exec')
-            six.exec_(code)
+    if a.args and not a.interactive:
+        sys.argv = a.args
+        path = a.args[0]
+        with open(path, "rb") as f:
+            code = compile(f.read(), path, "exec")
+            exec(code, {})
     else:
         enable_deprecation_warnings()
 
@@ -76,37 +43,38 @@ def run(user_ns=None):
 
         # Startup path
         startup_paths = []
-        if 'PYTHONSTARTUP' in os.environ:
-            startup_paths.append(os.environ['PYTHONSTARTUP'])
+        if "PYTHONSTARTUP" in os.environ:
+            startup_paths.append(os.environ["PYTHONSTARTUP"])
 
         # --interactive
-        if a['--interactive']:
-            startup_paths.append(a['--interactive'])
-            sys.argv = [a['--interactive']] + a['<arg>']
+        if a.interactive:
+            startup_paths.append(a.args[0])
+            sys.argv = a.args
 
         # exec scripts from startup paths
         for path in startup_paths:
             if os.path.exists(path):
-                with open(path, 'rb') as f:
-                    code = compile(f.read(), path, 'exec')
-                    six.exec_(code, user_ns, user_ns)
+                with open(path, "rb") as f:
+                    code = compile(f.read(), path, "exec")
+                    exec(code, user_ns, user_ns)
             else:
-                print('File not found: {}\n\n'.format(path))
+                print("File not found: {}\n\n".format(path))
                 sys.exit(1)
 
         # Apply config file
         def configure(repl):
-            path = os.path.join(config_dir, 'config.py')
-            if os.path.exists(path):
-                run_config(repl, path)
+            if os.path.exists(config_file):
+                run_config(repl, config_file)
 
         # Run interactive shell.
-        embed(vi_mode=vi_mode,
-              history_filename=os.path.join(data_dir, 'history'),
-              configure=configure,
-              user_ns=user_ns,
-              title='IPython REPL (ptipython)')
+        embed(
+            vi_mode=a.vi,
+            history_filename=history_file,
+            configure=configure,
+            user_ns=user_ns,
+            title="IPython REPL (ptipython)",
+        )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run()

ptpython/entry_points/run_ptpython.py

@@ -15,81 +15,158 @@
 Other environment variables:
 PYTHONSTARTUP: file executed on interactive startup (no default)
 """
-from __future__ import absolute_import, unicode_literals, print_function
-
-import appdirs
-import docopt
+import argparse
 import os
-import six
 import sys
+from typing import Tuple
 
-from ptpython.repl import embed, enable_deprecation_warnings, run_config
-
-
-def run():
-    a = docopt.docopt(__doc__)
-
-    vi_mode = bool(a['--vi'])
+import appdirs
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.shortcuts import print_formatted_text
 
-    config_dir = appdirs.user_config_dir('ptpython', 'prompt_toolkit')
-    data_dir = appdirs.user_data_dir('ptpython', 'prompt_toolkit')
+from ptpython.repl import embed, enable_deprecation_warnings, run_config
 
-    if a['--config-dir']:
-        # Override config_dir.
-        config_dir = os.path.expanduser(a['--config-dir'])
-    else:
-        # Warn about the legacy directory.
-        legacy_dir = os.path.expanduser('~/.ptpython')
-        if os.path.isdir(legacy_dir):
-            print('{0} is deprecated, migrate your configuration to {1}'.format(legacy_dir, config_dir))
+__all__ = ["create_parser", "get_config_and_history_file", "run"]
+
+
+class _Parser(argparse.ArgumentParser):
+    def print_help(self):
+        super().print_help()
+        print("Other environment variables:")
+        print("PYTHONSTARTUP: file executed on interactive startup (no default)")
+
+
+def create_parser() -> _Parser:
+    parser = _Parser(description="ptpython: Interactive Python shell.")
+    parser.add_argument("--vi", action="store_true", help="Enable Vi key bindings")
+    parser.add_argument(
+        "-i",
+        "--interactive",
+        action="store_true",
+        help="Start interactive shell after executing this file.",
+    )
+    parser.add_argument(
+        "--config-file", type=str, help="Location of configuration file."
+    )
+    parser.add_argument("--history-file", type=str, help="Location of history file.")
+    parser.add_argument(
+        "-V", "--version", action="store_true", help="Print version and exit."
+    )
+    parser.add_argument("args", nargs="*", help="Script and arguments")
+    return parser
+
+
+def get_config_and_history_file(namespace: argparse.Namespace) -> Tuple[str, str]:
+    """
+    Check which config/history files to use, ensure that the directories for
+    these files exist, and return the config and history path.
+    """
+    config_dir = appdirs.user_config_dir("ptpython", "prompt_toolkit")
+    data_dir = appdirs.user_data_dir("ptpython", "prompt_toolkit")
 
     # Create directories.
     for d in (config_dir, data_dir):
         if not os.path.isdir(d) and not os.path.islink(d):
             os.mkdir(d)
 
+    # Determine config file to be used.
+    config_file = os.path.join(config_dir, "config.py")
+    legacy_config_file = os.path.join(os.path.expanduser("~/.ptpython"), "config.py")
+
+    warnings = []
+
+    # Config file
+    if namespace.config_file:
+        # Override config_file.
+        config_file = os.path.expanduser(namespace.config_file)
+
+    elif os.path.isfile(legacy_config_file):
+        # Warn about the legacy configuration file.
+        warnings.append(
+            HTML(
+                "    <i>~/.ptpython/config.py</i> is deprecated, move your configuration to <i>%s</i>\n"
+            )
+            % config_file
+        )
+        config_file = legacy_config_file
+
+    # Determine history file to be used.
+    history_file = os.path.join(data_dir, "history")
+    legacy_history_file = os.path.join(os.path.expanduser("~/.ptpython"), "history")
+
+    if namespace.history_file:
+        # Override history_file.
+        history_file = os.path.expanduser(namespace.history_file)
+
+    elif os.path.isfile(legacy_history_file):
+        # Warn about the legacy history file.
+        warnings.append(
+            HTML(
+                "    <i>~/.ptpython/history</i> is deprecated, move your history to <i>%s</i>\n"
+            )
+            % history_file
+        )
+        history_file = legacy_history_file
+
+    # Print warnings.
+    if warnings:
+        print_formatted_text(HTML("<u>Warning:</u>"))
+        for w in warnings:
+            print_formatted_text(w)
+
+    return config_file, history_file
+
+
+def run() -> None:
+    a = create_parser().parse_args()
+
+    config_file, history_file = get_config_and_history_file(a)
+
     # Startup path
     startup_paths = []
-    if 'PYTHONSTARTUP' in os.environ:
-        startup_paths.append(os.environ['PYTHONSTARTUP'])
+    if "PYTHONSTARTUP" in os.environ:
+        startup_paths.append(os.environ["PYTHONSTARTUP"])
 
     # --interactive
-    if a['--interactive']:
-        startup_paths.append(a['--interactive'])
-        sys.argv = [a['--interactive']] + a['<arg>']
+    if a.interactive and a.args:
+        startup_paths.append(a.args[0])
+        sys.argv = a.args
 
     # Add the current directory to `sys.path`.
-    if sys.path[0] != '':
-        sys.path.insert(0, '')
+    if sys.path[0] != "":
+        sys.path.insert(0, "")
 
     # When a file has been given, run that, otherwise start the shell.
-    if a['<arg>'] and not a['--interactive']:
-        sys.argv = a['<arg>']
-        path = a['<arg>'][0]
-        with open(path, 'rb') as f:
-            code = compile(f.read(), path, 'exec')
+    if a.args and not a.interactive:
+        sys.argv = a.args
+        path = a.args[0]
+        with open(path, "rb") as f:
+            code = compile(f.read(), path, "exec")
             # NOTE: We have to pass an empty dictionary as namespace. Omitting
             #       this argument causes imports to not be found. See issue #326.
-            six.exec_(code, {})
+            exec(code, {})
 
     # Run interactive shell.
     else:
         enable_deprecation_warnings()
 
         # Apply config file
-        def configure(repl):
-            path = os.path.join(config_dir, 'config.py')
-            if os.path.exists(path):
-                run_config(repl, path)
+        def configure(repl) -> None:
+            if os.path.exists(config_file):
+                run_config(repl, config_file)
 
         import __main__
-        embed(vi_mode=vi_mode,
-              history_filename=os.path.join(data_dir, 'history'),
-              configure=configure,
-              locals=__main__.__dict__,
-              globals=__main__.__dict__,
-              startup_paths=startup_paths,
-              title='Python REPL (ptpython)')
-
-if __name__ == '__main__':
+
+        embed(
+            vi_mode=a.vi,
+            history_filename=history_file,
+            configure=configure,
+            locals=__main__.__dict__,
+            globals=__main__.__dict__,
+            startup_paths=startup_paths,
+            title="Python REPL (ptpython)",
+        )
+
+
+if __name__ == "__main__":
     run()

ptpython/eventloop.py

@@ -10,9 +10,7 @@
 import sys
 import time
 
-__all__ = (
-    'inputhook',
-)
+__all__ = ["inputhook"]
 
 
 def _inputhook_tk(inputhook_context):
@@ -22,7 +20,8 @@ def _inputhook_tk(inputhook_context):
     """
     # Get the current TK application.
     import _tkinter  # Keep this imports inline!
-    from six.moves import tkinter
+    import tkinter
+
     root = tkinter._default_root
 
     def wait_using_filehandler():
@@ -33,6 +32,7 @@ def wait_using_filehandler():
         # Add a handler that sets the stop flag when `prompt-toolkit` has input
         # to process.
         stop = [False]
+
         def done(*a):
             stop[0] = True
 
@@ -52,19 +52,19 @@ def wait_using_polling():
         """
         while not inputhook_context.input_is_ready():
             while root.dooneevent(_tkinter.ALL_EVENTS | _tkinter.DONT_WAIT):
-                 pass
+                pass
             # Sleep to make the CPU idle, but not too long, so that the UI
             # stays responsive.
-            time.sleep(.01)
+            time.sleep(0.01)
 
     if root is not None:
-        if hasattr(root, 'createfilehandler'):
+        if hasattr(root, "createfilehandler"):
             wait_using_filehandler()
         else:
             wait_using_polling()
 
 
 def inputhook(inputhook_context):
     # Only call the real input hook when the 'Tkinter' library was loaded.
-    if 'Tkinter' in sys.modules or 'tkinter' in sys.modules:
+    if "Tkinter" in sys.modules or "tkinter" in sys.modules:
         _inputhook_tk(inputhook_context)

ptpython/filters.py

@@ -1,38 +1,36 @@
-from __future__ import unicode_literals
+from typing import TYPE_CHECKING
 
 from prompt_toolkit.filters import Filter
 
-__all__ = (
-    'HasSignature',
-    'ShowSidebar',
-    'ShowSignature',
-    'ShowDocstring',
-)
+if TYPE_CHECKING:
+    from .python_input import PythonInput
+
+__all__ = ["HasSignature", "ShowSidebar", "ShowSignature", "ShowDocstring"]
 
 
 class PythonInputFilter(Filter):
-    def __init__(self, python_input):
+    def __init__(self, python_input: "PythonInput") -> None:
         self.python_input = python_input
 
-    def __call__(self):
+    def __call__(self) -> bool:
         raise NotImplementedError
 
 
 class HasSignature(PythonInputFilter):
-    def __call__(self):
+    def __call__(self) -> bool:
         return bool(self.python_input.signatures)
 
 
 class ShowSidebar(PythonInputFilter):
-    def __call__(self):
+    def __call__(self) -> bool:
         return self.python_input.show_sidebar
 
 
 class ShowSignature(PythonInputFilter):
-    def __call__(self):
+    def __call__(self) -> bool:
         return self.python_input.show_signature
 
 
 class ShowDocstring(PythonInputFilter):
-    def __call__(self):
+    def __call__(self) -> bool:
         return self.python_input.show_docstring

ptpython/history_browser.py

@@ -8,10 +8,12 @@
 offer.
 
 """
-from __future__ import unicode_literals, print_function
-
-from prompt_toolkit.completion import Completion, Completer
-from prompt_toolkit.completion import PathCompleter, WordCompleter
+from prompt_toolkit.completion import (
+    Completer,
+    Completion,
+    PathCompleter,
+    WordCompleter,
+)
 from prompt_toolkit.contrib.completers import SystemCompleter
 from prompt_toolkit.contrib.regular_languages.compiler import compile
 from prompt_toolkit.contrib.regular_languages.completion import GrammarCompleter
@@ -20,27 +22,25 @@
 from prompt_toolkit.formatted_text import PygmentsTokens
 from prompt_toolkit.lexers import PygmentsLexer, SimpleLexer
 from prompt_toolkit.styles import Style
+from pygments.lexers import BashLexer, PythonLexer
 
-from .python_input import PythonInput, PythonValidator, PythonCompleter
-from .style import default_ui_style
-
-from IPython.terminal.embed import InteractiveShellEmbed as _InteractiveShellEmbed
-from IPython.terminal.ipapp import load_default_config
 from IPython import utils as ipy_utils
 from IPython.core.inputsplitter import IPythonInputSplitter
-
-from pygments.lexers import PythonLexer, BashLexer
+from IPython.terminal.embed import InteractiveShellEmbed as _InteractiveShellEmbed
+from IPython.terminal.ipapp import load_default_config
 from ptpython.prompt_style import PromptStyle
 
-__all__ = (
-    'embed',
-)
+from .python_input import PythonCompleter, PythonInput, PythonValidator
+from .style import default_ui_style
+
+__all__ = ["embed"]
 
 
 class IPythonPrompt(PromptStyle):
     """
     Style for IPython >5.0, use the prompt_toolkit tokens directly.
     """
+
     def __init__(self, prompts):
         self.prompts = prompts
 
@@ -68,7 +68,8 @@ def create_ipython_grammar():
     """
     Return compiled IPython grammar.
     """
-    return compile(r"""
+    return compile(
+        r"""
         \s*
         (
             (?P<percent>%)(
@@ -87,24 +88,37 @@ def create_ipython_grammar():
             (?![%!]) (?P<python>.+)
         )
         \s*
-    """)
+    """
+    )
 
 
-def create_completer(get_globals, get_locals, magics_manager, alias_manager,
-                     get_enable_dictionary_completion):
+def create_completer(
+    get_globals,
+    get_locals,
+    magics_manager,
+    alias_manager,
+    get_enable_dictionary_completion,
+):
     g = create_ipython_grammar()
 
-    return GrammarCompleter(g, {
-        'python': PythonCompleter(get_globals, get_locals, get_enable_dictionary_completion),
-        'magic': MagicsCompleter(magics_manager),
-        'alias_name': AliasCompleter(alias_manager),
-        'pdb_arg': WordCompleter(['on', 'off'], ignore_case=True),
-        'autocall_arg': WordCompleter(['0', '1', '2'], ignore_case=True),
-        'py_filename': PathCompleter(only_directories=False, file_filter=lambda name: name.endswith('.py')),
-        'filename': PathCompleter(only_directories=False),
-        'directory': PathCompleter(only_directories=True),
-        'system': SystemCompleter(),
-    })
+    return GrammarCompleter(
+        g,
+        {
+            "python": PythonCompleter(
+                get_globals, get_locals, get_enable_dictionary_completion
+            ),
+            "magic": MagicsCompleter(magics_manager),
+            "alias_name": AliasCompleter(alias_manager),
+            "pdb_arg": WordCompleter(["on", "off"], ignore_case=True),
+            "autocall_arg": WordCompleter(["0", "1", "2"], ignore_case=True),
+            "py_filename": PathCompleter(
+                only_directories=False, file_filter=lambda name: name.endswith(".py")
+            ),
+            "filename": PathCompleter(only_directories=False),
+            "directory": PathCompleter(only_directories=True),
+            "system": SystemCompleter(),
+        },
+    )
 
 
 def create_lexer():
@@ -113,12 +127,13 @@ def create_lexer():
     return GrammarLexer(
         g,
         lexers={
-            'percent': SimpleLexer('class:pygments.operator'),
-            'magic': SimpleLexer('class:pygments.keyword'),
-            'filename': SimpleLexer('class:pygments.name'),
-            'python': PygmentsLexer(PythonLexer),
-            'system': PygmentsLexer(BashLexer),
-        })
+            "percent": SimpleLexer("class:pygments.operator"),
+            "magic": SimpleLexer("class:pygments.keyword"),
+            "filename": SimpleLexer("class:pygments.name"),
+            "python": PygmentsLexer(PythonLexer),
+            "system": PygmentsLexer(BashLexer),
+        },
+    )
 
 
 class MagicsCompleter(Completer):
@@ -128,9 +143,9 @@ def __init__(self, magics_manager):
     def get_completions(self, document, complete_event):
         text = document.text_before_cursor.lstrip()
 
-        for m in sorted(self.magics_manager.magics['line']):
+        for m in sorted(self.magics_manager.magics["line"]):
             if m.startswith(text):
-                yield Completion('%s' % m, -len(text))
+                yield Completion("%s" % m, -len(text))
 
 
 class AliasCompleter(Completer):
@@ -139,48 +154,50 @@ def __init__(self, alias_manager):
 
     def get_completions(self, document, complete_event):
         text = document.text_before_cursor.lstrip()
-        #aliases = [a for a, _ in self.alias_manager.aliases]
+        # aliases = [a for a, _ in self.alias_manager.aliases]
         aliases = self.alias_manager.aliases
 
         for a, cmd in sorted(aliases, key=lambda a: a[0]):
             if a.startswith(text):
-                yield Completion('%s' % a, -len(text),
-                                 display_meta=cmd)
+                yield Completion("%s" % a, -len(text), display_meta=cmd)
 
 
 class IPythonInput(PythonInput):
     """
     Override our `PythonCommandLineInterface` to add IPython specific stuff.
     """
+
     def __init__(self, ipython_shell, *a, **kw):
-        kw['_completer'] = create_completer(kw['get_globals'], kw['get_globals'],
-                                            ipython_shell.magics_manager,
-                                            ipython_shell.alias_manager,
-                                            lambda: self.enable_dictionary_completion)
-        kw['_lexer'] = create_lexer()
-        kw['_validator'] = IPythonValidator(
-            get_compiler_flags=self.get_compiler_flags)
-
-        super(IPythonInput, self).__init__(*a, **kw)
+        kw["_completer"] = create_completer(
+            kw["get_globals"],
+            kw["get_globals"],
+            ipython_shell.magics_manager,
+            ipython_shell.alias_manager,
+            lambda: self.enable_dictionary_completion,
+        )
+        kw["_lexer"] = create_lexer()
+        kw["_validator"] = IPythonValidator(get_compiler_flags=self.get_compiler_flags)
+
+        super().__init__(*a, **kw)
         self.ipython_shell = ipython_shell
 
-        self.all_prompt_styles['ipython'] = IPythonPrompt(ipython_shell.prompts)
-        self.prompt_style = 'ipython'
+        self.all_prompt_styles["ipython"] = IPythonPrompt(ipython_shell.prompts)
+        self.prompt_style = "ipython"
 
         # UI style for IPython. Add tokens that are used by IPython>5.0
         style_dict = {}
         style_dict.update(default_ui_style)
-        style_dict.update({
-            'pygments.prompt':        '#009900',
-            'pygments.prompt-num':     '#00ff00 bold',
-            'pygments.out-prompt':     '#990000',
-            'pygments.out-prompt-num':  '#ff0000 bold',
-        })
+        style_dict.update(
+            {
+                "pygments.prompt": "#009900",
+                "pygments.prompt-num": "#00ff00 bold",
+                "pygments.out-prompt": "#990000",
+                "pygments.out-prompt-num": "#ff0000 bold",
+            }
+        )
 
-        self.ui_styles = {
-            'default': Style.from_dict(style_dict),
-        }
-        self.use_ui_colorscheme('default')
+        self.ui_styles = {"default": Style.from_dict(style_dict)}
+        self.use_ui_colorscheme("default")
 
 
 class InteractiveShellEmbed(_InteractiveShellEmbed):
@@ -190,31 +207,34 @@ class InteractiveShellEmbed(_InteractiveShellEmbed):
 
     :param configure: Callable for configuring the repl.
     """
+
     def __init__(self, *a, **kw):
-        vi_mode = kw.pop('vi_mode', False)
-        history_filename = kw.pop('history_filename', None)
-        configure = kw.pop('configure', None)
-        title = kw.pop('title', None)
+        vi_mode = kw.pop("vi_mode", False)
+        history_filename = kw.pop("history_filename", None)
+        configure = kw.pop("configure", None)
+        title = kw.pop("title", None)
 
         # Don't ask IPython to confirm for exit. We have our own exit prompt.
         self.confirm_exit = False
 
-        super(InteractiveShellEmbed, self).__init__(*a, **kw)
+        super().__init__(*a, **kw)
 
         def get_globals():
             return self.user_ns
 
         python_input = IPythonInput(
             self,
-            get_globals=get_globals, vi_mode=vi_mode,
-            history_filename=history_filename)
+            get_globals=get_globals,
+            vi_mode=vi_mode,
+            history_filename=history_filename,
+        )
 
         if title:
             python_input.terminal_title = title
 
         if configure:
             configure(python_input)
-            python_input.prompt_style = 'ipython'  # Don't take from config.
+            python_input.prompt_style = "ipython"  # Don't take from config.
 
         self.python_input = python_input
 
@@ -223,7 +243,7 @@ def prompt_for_code(self):
             return self.python_input.app.run()
         except KeyboardInterrupt:
             self.python_input.default_buffer.document = Document()
-            return ''
+            return ""
 
 
 def initialize_extensions(shell, extensions):
@@ -240,22 +260,24 @@ def initialize_extensions(shell, extensions):
                 shell.extension_manager.load_extension(ext)
             except:
                 ipy_utils.warn.warn(
-                    "Error in loading extension: %s" % ext +
-                    "\nCheck your config files in %s" % ipy_utils.path.get_ipython_dir())
+                    "Error in loading extension: %s" % ext
+                    + "\nCheck your config files in %s"
+                    % ipy_utils.path.get_ipython_dir()
+                )
                 shell.showtraceback()
 
 
 def embed(**kwargs):
     """
     Copied from `IPython/terminal/embed.py`, but using our `InteractiveShellEmbed` instead.
     """
-    config = kwargs.get('config')
-    header = kwargs.pop('header', u'')
-    compile_flags = kwargs.pop('compile_flags', None)
+    config = kwargs.get("config")
+    header = kwargs.pop("header", "")
+    compile_flags = kwargs.pop("compile_flags", None)
     if config is None:
         config = load_default_config()
         config.InteractiveShellEmbed = config.TerminalInteractiveShell
-        kwargs['config'] = config
+        kwargs["config"] = config
     shell = InteractiveShellEmbed.instance(**kwargs)
-    initialize_extensions(shell, config['InteractiveShellApp']['extensions'])
+    initialize_extensions(shell, config["InteractiveShellApp"]["extensions"])
     shell(header=header, stack_depth=2, compile_flags=compile_flags)

ptpython/ipython.py

@@ -1,18 +1,24 @@
-from __future__ import unicode_literals
-
+from prompt_toolkit.application import get_app
 from prompt_toolkit.document import Document
 from prompt_toolkit.enums import DEFAULT_BUFFER
-from prompt_toolkit.filters import has_selection, has_focus, Condition, vi_insert_mode, emacs_insert_mode, emacs_mode
+from prompt_toolkit.filters import (
+    Condition,
+    emacs_insert_mode,
+    emacs_mode,
+    has_focus,
+    has_selection,
+    vi_insert_mode,
+)
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.keys import Keys
-from prompt_toolkit.application import get_app
+
 from .utils import document_is_multiline_python
 
-__all__ = (
-    'load_python_bindings',
-    'load_sidebar_bindings',
-    'load_confirm_exit_bindings',
-)
+__all__ = [
+    "load_python_bindings",
+    "load_sidebar_bindings",
+    "load_confirm_exit_bindings",
+]
 
 
 @Condition
@@ -40,22 +46,22 @@ def load_python_bindings(python_input):
     sidebar_visible = Condition(lambda: python_input.show_sidebar)
     handle = bindings.add
 
-    @handle('c-l')
+    @handle("c-l")
     def _(event):
         """
         Clear whole screen and render again -- also when the sidebar is visible.
         """
         event.app.renderer.clear()
 
-    @handle('c-z')
+    @handle("c-z")
     def _(event):
         """
         Suspend.
         """
         if python_input.enable_system_bindings:
             event.app.suspend_to_background()
 
-    @handle('f2')
+    @handle("f2")
     def _(event):
         """
         Show/hide sidebar.
@@ -66,42 +72,49 @@ def _(event):
         else:
             event.app.layout.focus_last()
 
-    @handle('f3')
+    @handle("f3")
     def _(event):
         """
         Select from the history.
         """
         python_input.enter_history()
 
-    @handle('f4')
+    @handle("f4")
     def _(event):
         """
         Toggle between Vi and Emacs mode.
         """
         python_input.vi_mode = not python_input.vi_mode
 
-    @handle('f6')
+    @handle("f6")
     def _(event):
         """
         Enable/Disable paste mode.
         """
         python_input.paste_mode = not python_input.paste_mode
 
-    @handle('tab', filter= ~sidebar_visible & ~has_selection & tab_should_insert_whitespace)
+    @handle(
+        "tab", filter=~sidebar_visible & ~has_selection & tab_should_insert_whitespace
+    )
     def _(event):
         """
         When tab should insert whitespace, do that instead of completion.
         """
-        event.app.current_buffer.insert_text('    ')
+        event.app.current_buffer.insert_text("    ")
 
     @Condition
     def is_multiline():
         return document_is_multiline_python(python_input.default_buffer.document)
 
-    @handle('enter', filter= ~sidebar_visible & ~has_selection &
-            (vi_insert_mode | emacs_insert_mode) &
-            has_focus(DEFAULT_BUFFER) & ~is_multiline)
-    @handle(Keys.Escape, Keys.Enter, filter= ~sidebar_visible & emacs_mode)
+    @handle(
+        "enter",
+        filter=~sidebar_visible
+        & ~has_selection
+        & (vi_insert_mode | emacs_insert_mode)
+        & has_focus(DEFAULT_BUFFER)
+        & ~is_multiline,
+    )
+    @handle(Keys.Escape, Keys.Enter, filter=~sidebar_visible & emacs_mode)
     def _(event):
         """
         Accept input (for single line input).
@@ -112,14 +125,19 @@ def _(event):
             # When the cursor is at the end, and we have an empty line:
             # drop the empty lines, but return the value.
             b.document = Document(
-                text=b.text.rstrip(),
-                cursor_position=len(b.text.rstrip()))
+                text=b.text.rstrip(), cursor_position=len(b.text.rstrip())
+            )
 
             b.validate_and_handle()
 
-    @handle('enter', filter= ~sidebar_visible & ~has_selection &
-            (vi_insert_mode | emacs_insert_mode) &
-            has_focus(DEFAULT_BUFFER) & is_multiline)
+    @handle(
+        "enter",
+        filter=~sidebar_visible
+        & ~has_selection
+        & (vi_insert_mode | emacs_insert_mode)
+        & has_focus(DEFAULT_BUFFER)
+        & is_multiline,
+    )
     def _(event):
         """
         Behaviour of the Enter key.
@@ -134,30 +152,36 @@ def at_the_end(b):
             """ we consider the cursor at the end when there is no text after
             the cursor, or only whitespace. """
             text = b.document.text_after_cursor
-            return text == '' or (text.isspace() and not '\n' in text)
+            return text == "" or (text.isspace() and not "\n" in text)
 
         if python_input.paste_mode:
             # In paste mode, always insert text.
-            b.insert_text('\n')
+            b.insert_text("\n")
 
-        elif at_the_end(b) and b.document.text.replace(' ', '').endswith(
-                    '\n' * (empty_lines_required - 1)):
+        elif at_the_end(b) and b.document.text.replace(" ", "").endswith(
+            "\n" * (empty_lines_required - 1)
+        ):
             # When the cursor is at the end, and we have an empty line:
             # drop the empty lines, but return the value.
             if b.validate():
                 b.document = Document(
-                    text=b.text.rstrip(),
-                    cursor_position=len(b.text.rstrip()))
+                    text=b.text.rstrip(), cursor_position=len(b.text.rstrip())
+                )
 
                 b.validate_and_handle()
         else:
             auto_newline(b)
 
-    @handle('c-d', filter=~sidebar_visible &
-            has_focus(python_input.default_buffer) &
-            Condition(lambda:
-                # The current buffer is empty.
-                not get_app().current_buffer.text))
+    @handle(
+        "c-d",
+        filter=~sidebar_visible
+        & has_focus(python_input.default_buffer)
+        & Condition(
+            lambda:
+            # The current buffer is empty.
+            not get_app().current_buffer.text
+        ),
+    )
     def _(event):
         """
         Override Control-D exit, to ask for confirmation.
@@ -167,10 +191,10 @@ def _(event):
         else:
             event.app.exit(exception=EOFError)
 
-    @handle('c-c', filter=has_focus(python_input.default_buffer))
+    @handle("c-c", filter=has_focus(python_input.default_buffer))
     def _(event):
         " Abort when Control-C has been pressed. "
-        event.app.exit(exception=KeyboardInterrupt, style='class:aborting')
+        event.app.exit(exception=KeyboardInterrupt, style="class:aborting")
 
     return bindings
 
@@ -184,42 +208,44 @@ def load_sidebar_bindings(python_input):
     handle = bindings.add
     sidebar_visible = Condition(lambda: python_input.show_sidebar)
 
-    @handle('up', filter=sidebar_visible)
-    @handle('c-p', filter=sidebar_visible)
-    @handle('k', filter=sidebar_visible)
+    @handle("up", filter=sidebar_visible)
+    @handle("c-p", filter=sidebar_visible)
+    @handle("k", filter=sidebar_visible)
     def _(event):
         " Go to previous option. "
         python_input.selected_option_index = (
-            (python_input.selected_option_index - 1) % python_input.option_count)
+            python_input.selected_option_index - 1
+        ) % python_input.option_count
 
-    @handle('down', filter=sidebar_visible)
-    @handle('c-n', filter=sidebar_visible)
-    @handle('j', filter=sidebar_visible)
+    @handle("down", filter=sidebar_visible)
+    @handle("c-n", filter=sidebar_visible)
+    @handle("j", filter=sidebar_visible)
     def _(event):
         " Go to next option. "
         python_input.selected_option_index = (
-            (python_input.selected_option_index + 1) % python_input.option_count)
+            python_input.selected_option_index + 1
+        ) % python_input.option_count
 
-    @handle('right', filter=sidebar_visible)
-    @handle('l', filter=sidebar_visible)
-    @handle(' ', filter=sidebar_visible)
+    @handle("right", filter=sidebar_visible)
+    @handle("l", filter=sidebar_visible)
+    @handle(" ", filter=sidebar_visible)
     def _(event):
         " Select next value for current option. "
         option = python_input.selected_option
         option.activate_next()
 
-    @handle('left', filter=sidebar_visible)
-    @handle('h', filter=sidebar_visible)
+    @handle("left", filter=sidebar_visible)
+    @handle("h", filter=sidebar_visible)
     def _(event):
         " Select previous value for current option. "
         option = python_input.selected_option
         option.activate_previous()
 
-    @handle('c-c', filter=sidebar_visible)
-    @handle('c-d', filter=sidebar_visible)
-    @handle('c-d', filter=sidebar_visible)
-    @handle('enter', filter=sidebar_visible)
-    @handle('escape', filter=sidebar_visible)
+    @handle("c-c", filter=sidebar_visible)
+    @handle("c-d", filter=sidebar_visible)
+    @handle("c-d", filter=sidebar_visible)
+    @handle("enter", filter=sidebar_visible)
+    @handle("escape", filter=sidebar_visible)
     def _(event):
         " Hide sidebar. "
         python_input.show_sidebar = False
@@ -237,15 +263,15 @@ def load_confirm_exit_bindings(python_input):
     handle = bindings.add
     confirmation_visible = Condition(lambda: python_input.show_exit_confirmation)
 
-    @handle('y', filter=confirmation_visible)
-    @handle('Y', filter=confirmation_visible)
-    @handle('enter', filter=confirmation_visible)
-    @handle('c-d', filter=confirmation_visible)
+    @handle("y", filter=confirmation_visible)
+    @handle("Y", filter=confirmation_visible)
+    @handle("enter", filter=confirmation_visible)
+    @handle("c-d", filter=confirmation_visible)
     def _(event):
         """
         Really quit.
         """
-        event.app.exit(exception=EOFError, style='class:exiting')
+        event.app.exit(exception=EOFError, style="class:exiting")
 
     @handle(Keys.Any, filter=confirmation_visible)
     def _(event):
@@ -265,14 +291,14 @@ def auto_newline(buffer):
 
     if buffer.document.current_line_after_cursor:
         # When we are in the middle of a line. Always insert a newline.
-        insert_text('\n')
+        insert_text("\n")
     else:
         # Go to new line, but also add indentation.
         current_line = buffer.document.current_line_before_cursor.rstrip()
-        insert_text('\n')
+        insert_text("\n")
 
         # Unident if the last line ends with 'pass', remove four spaces.
-        unindent = current_line.rstrip().endswith(' pass')
+        unindent = current_line.rstrip().endswith(" pass")
 
         # Copy whitespace from current line
         current_line2 = current_line[4:] if unindent else current_line
@@ -284,6 +310,6 @@ def auto_newline(buffer):
                 break
 
         # If the last line ends with a colon, add four extra spaces.
-        if current_line[-1:] == ':':
+        if current_line[-1:] == ":":
             for x in range(4):
-                insert_text(' ')
+                insert_text(" ")

ptpython/key_bindings.py

@@ -1,25 +1,26 @@
-from __future__ import unicode_literals
 from abc import ABCMeta, abstractmethod
-from six import with_metaclass
+from typing import TYPE_CHECKING
 
-__all__ = (
-    'PromptStyle',
-    'IPythonPrompt',
-    'ClassicPrompt',
-)
+from prompt_toolkit.formatted_text import StyleAndTextTuples
 
+if TYPE_CHECKING:
+    from .python_input import PythonInput
 
-class PromptStyle(with_metaclass(ABCMeta, object)):
+__all__ = ["PromptStyle", "IPythonPrompt", "ClassicPrompt"]
+
+
+class PromptStyle(metaclass=ABCMeta):
     """
     Base class for all prompts.
     """
+
     @abstractmethod
-    def in_prompt(self):
+    def in_prompt(self) -> StyleAndTextTuples:
         " Return the input tokens. "
         return []
 
     @abstractmethod
-    def in2_prompt(self, width):
+    def in2_prompt(self, width: int) -> StyleAndTextTuples:
         """
         Tokens for every following input line.
 
@@ -29,7 +30,7 @@ def in2_prompt(self, width):
         return []
 
     @abstractmethod
-    def out_prompt(self):
+    def out_prompt(self) -> StyleAndTextTuples:
         " Return the output tokens. "
         return []
 
@@ -38,39 +39,39 @@ class IPythonPrompt(PromptStyle):
     """
     A prompt resembling the IPython prompt.
     """
-    def __init__(self, python_input):
+
+    def __init__(self, python_input: "PythonInput") -> None:
         self.python_input = python_input
 
-    def in_prompt(self):
+    def in_prompt(self) -> StyleAndTextTuples:
         return [
-            ('class:in', 'In ['),
-            ('class:in.number', '%s' % self.python_input.current_statement_index),
-            ('class:in', ']: '),
+            ("class:in", "In ["),
+            ("class:in.number", "%s" % self.python_input.current_statement_index),
+            ("class:in", "]: "),
         ]
 
-    def in2_prompt(self, width):
-        return [
-            ('class:in', '...: '.rjust(width)),
-        ]
+    def in2_prompt(self, width: int) -> StyleAndTextTuples:
+        return [("class:in", "...: ".rjust(width))]
 
-    def out_prompt(self):
+    def out_prompt(self) -> StyleAndTextTuples:
         return [
-            ('class:out', 'Out['),
-            ('class:out.number', '%s' % self.python_input.current_statement_index),
-            ('class:out', ']:'),
-            ('', ' '),
+            ("class:out", "Out["),
+            ("class:out.number", "%s" % self.python_input.current_statement_index),
+            ("class:out", "]:"),
+            ("", " "),
         ]
 
 
 class ClassicPrompt(PromptStyle):
     """
     The classic Python prompt.
     """
-    def in_prompt(self):
-        return [('class:prompt', '>>> ')]
 
-    def in2_prompt(self, width):
-        return [('class:prompt.dots', '...')]
+    def in_prompt(self) -> StyleAndTextTuples:
+        return [("class:prompt", ">>> ")]
+
+    def in2_prompt(self, width: int) -> StyleAndTextTuples:
+        return [("class:prompt.dots", "...")]
 
-    def out_prompt(self):
+    def out_prompt(self) -> StyleAndTextTuples:
         return []

ptpython/layout.py

@@ -1,174 +1,151 @@
-from __future__ import unicode_literals
+from typing import Dict
 
-from prompt_toolkit.styles import Style, merge_styles
+from prompt_toolkit.styles import BaseStyle, Style, merge_styles
 from prompt_toolkit.styles.pygments import style_from_pygments_cls
-from prompt_toolkit.utils import is_windows, is_conemu_ansi, is_windows_vt100_supported
-from pygments.styles import get_style_by_name, get_all_styles
+from prompt_toolkit.utils import is_conemu_ansi, is_windows, is_windows_vt100_supported
+from pygments.styles import get_all_styles, get_style_by_name
 
-__all__ = (
-    'get_all_code_styles',
-    'get_all_ui_styles',
-    'generate_style',
-)
+__all__ = ["get_all_code_styles", "get_all_ui_styles", "generate_style"]
 
 
-def get_all_code_styles():
+def get_all_code_styles() -> Dict[str, BaseStyle]:
     """
     Return a mapping from style names to their classes.
     """
-    result = dict((name, style_from_pygments_cls(get_style_by_name(name))) for name in get_all_styles())
-    result['win32'] = Style.from_dict(win32_code_style)
+    result: Dict[str, BaseStyle] = {
+        name: style_from_pygments_cls(get_style_by_name(name))
+        for name in get_all_styles()
+    }
+    result["win32"] = Style.from_dict(win32_code_style)
     return result
 
 
-def get_all_ui_styles():
+def get_all_ui_styles() -> Dict[str, BaseStyle]:
     """
     Return a dict mapping {ui_style_name -> style_dict}.
     """
     return {
-        'default': Style.from_dict(default_ui_style),
-        'blue': Style.from_dict(blue_ui_style),
+        "default": Style.from_dict(default_ui_style),
+        "blue": Style.from_dict(blue_ui_style),
     }
 
 
-def generate_style(python_style, ui_style):
+def generate_style(python_style: BaseStyle, ui_style: BaseStyle) -> BaseStyle:
     """
     Generate Pygments Style class from two dictionaries
     containing style rules.
     """
-    return merge_styles([
-        python_style,
-        ui_style
-    ])
+    return merge_styles([python_style, ui_style])
 
 
 # Code style for Windows consoles. They support only 16 colors,
 # so we choose a combination that displays nicely.
 win32_code_style = {
-    'pygments.comment':                   "#00ff00",
-    'pygments.keyword':                   '#44ff44',
-    'pygments.number':                    '',
-    'pygments.operator':                  '',
-    'pygments.string':                    '#ff44ff',
-
-    'pygments.name':                      '',
-    'pygments.name.decorator':            '#ff4444',
-    'pygments.name.class':                '#ff4444',
-    'pygments.name.function':             '#ff4444',
-    'pygments.name.builtin':              '#ff4444',
-
-    'pygments.name.attribute':            '',
-    'pygments.name.constant':             '',
-    'pygments.name.entity':               '',
-    'pygments.name.exception':            '',
-    'pygments.name.label':                '',
-    'pygments.name.namespace':            '',
-    'pygments.name.tag':                  '',
-    'pygments.name.variable':             '',
+    "pygments.comment": "#00ff00",
+    "pygments.keyword": "#44ff44",
+    "pygments.number": "",
+    "pygments.operator": "",
+    "pygments.string": "#ff44ff",
+    "pygments.name": "",
+    "pygments.name.decorator": "#ff4444",
+    "pygments.name.class": "#ff4444",
+    "pygments.name.function": "#ff4444",
+    "pygments.name.builtin": "#ff4444",
+    "pygments.name.attribute": "",
+    "pygments.name.constant": "",
+    "pygments.name.entity": "",
+    "pygments.name.exception": "",
+    "pygments.name.label": "",
+    "pygments.name.namespace": "",
+    "pygments.name.tag": "",
+    "pygments.name.variable": "",
 }
 
 
 default_ui_style = {
-    'control-character':    'ansiblue',
-
+    "control-character": "ansiblue",
     # Classic prompt.
-    'prompt':                                 'bold',
-    'prompt.dots':                            'noinherit',
-
+    "prompt": "bold",
+    "prompt.dots": "noinherit",
     # (IPython <5.0) Prompt: "In [1]:"
-    'in':                                     'bold #008800',
-    'in.number':                              '',
-
+    "in": "bold #008800",
+    "in.number": "",
     # Return value.
-    'out':                                    '#ff0000',
-    'out.number':                             '#ff0000',
-
+    "out": "#ff0000",
+    "out.number": "#ff0000",
     # Completions.
-    'completion.builtin':                     '',
-    'completion.keyword':                     'fg:#008800',
-
-    'completion.keyword fuzzymatch.inside':   'fg:#008800',
-    'completion.keyword fuzzymatch.outside':  'fg:#44aa44',
-
+    "completion.builtin": "",
+    "completion.keyword": "fg:#008800",
+    "completion.keyword fuzzymatch.inside": "fg:#008800",
+    "completion.keyword fuzzymatch.outside": "fg:#44aa44",
     # Separator between windows. (Used above docstring.)
-    'separator':                              '#bbbbbb',
-
+    "separator": "#bbbbbb",
     # System toolbar
-    'system-toolbar':                         '#22aaaa noinherit',
-
+    "system-toolbar": "#22aaaa noinherit",
     # "arg" toolbar.
-    'arg-toolbar':                            '#22aaaa noinherit',
-    'arg-toolbar.text':                       'noinherit',
-
+    "arg-toolbar": "#22aaaa noinherit",
+    "arg-toolbar.text": "noinherit",
     # Signature toolbar.
-    'signature-toolbar':                      'bg:#44bbbb #000000',
-    'signature-toolbar.currentname':          'bg:#008888 #ffffff bold',
-    'signature-toolbar.operator':             '#000000 bold',
-
-    'docstring':                              '#888888',
-
+    "signature-toolbar": "bg:#44bbbb #000000",
+    "signature-toolbar.currentname": "bg:#008888 #ffffff bold",
+    "signature-toolbar.operator": "#000000 bold",
+    "docstring": "#888888",
     # Validation toolbar.
-    'validation-toolbar':                     'bg:#440000 #aaaaaa',
-
+    "validation-toolbar": "bg:#440000 #aaaaaa",
     # Status toolbar.
-    'status-toolbar':                         'bg:#222222 #aaaaaa',
-    'status-toolbar.title':                   'underline',
-    'status-toolbar.inputmode':               'bg:#222222 #ffffaa',
-    'status-toolbar.key':                     'bg:#000000 #888888',
-    'status-toolbar.pastemodeon':             'bg:#aa4444 #ffffff',
-    'status-toolbar.pythonversion':           'bg:#222222 #ffffff bold',
-    'status-toolbar paste-mode-on':           'bg:#aa4444 #ffffff',
-    'record':                                 'bg:#884444 white',
-    'status-toolbar.input-mode':              '#ffff44',
-
+    "status-toolbar": "bg:#222222 #aaaaaa",
+    "status-toolbar.title": "underline",
+    "status-toolbar.inputmode": "bg:#222222 #ffffaa",
+    "status-toolbar.key": "bg:#000000 #888888",
+    "status-toolbar.pastemodeon": "bg:#aa4444 #ffffff",
+    "status-toolbar.pythonversion": "bg:#222222 #ffffff bold",
+    "status-toolbar paste-mode-on": "bg:#aa4444 #ffffff",
+    "record": "bg:#884444 white",
+    "status-toolbar.input-mode": "#ffff44",
     # The options sidebar.
-    'sidebar':                                'bg:#bbbbbb #000000',
-    'sidebar.title':                          'bg:#668866 #ffffff',
-    'sidebar.label':                          'bg:#bbbbbb #222222',
-    'sidebar.status':                         'bg:#dddddd #000011',
-    'sidebar.label selected':                 'bg:#222222 #eeeeee',
-    'sidebar.status selected':                'bg:#444444 #ffffff bold',
-
-    'sidebar.separator':                      'underline',
-    'sidebar.key':                            'bg:#bbddbb #000000 bold',
-    'sidebar.key.description':                'bg:#bbbbbb #000000',
-    'sidebar.helptext':                       'bg:#fdf6e3 #000011',
-
-#        # Styling for the history layout.
-#        history.line:                          '',
-#        history.line.selected:                 'bg:#008800  #000000',
-#        history.line.current:                  'bg:#ffffff #000000',
-#        history.line.selected.current:         'bg:#88ff88 #000000',
-#        history.existinginput:                  '#888888',
-
+    "sidebar": "bg:#bbbbbb #000000",
+    "sidebar.title": "bg:#668866 #ffffff",
+    "sidebar.label": "bg:#bbbbbb #222222",
+    "sidebar.status": "bg:#dddddd #000011",
+    "sidebar.label selected": "bg:#222222 #eeeeee",
+    "sidebar.status selected": "bg:#444444 #ffffff bold",
+    "sidebar.separator": "underline",
+    "sidebar.key": "bg:#bbddbb #000000 bold",
+    "sidebar.key.description": "bg:#bbbbbb #000000",
+    "sidebar.helptext": "bg:#fdf6e3 #000011",
+    #        # Styling for the history layout.
+    #        history.line:                          '',
+    #        history.line.selected:                 'bg:#008800  #000000',
+    #        history.line.current:                  'bg:#ffffff #000000',
+    #        history.line.selected.current:         'bg:#88ff88 #000000',
+    #        history.existinginput:                  '#888888',
     # Help Window.
-    'window-border':                          '#aaaaaa',
-    'window-title':                           'bg:#bbbbbb #000000',
-
+    "window-border": "#aaaaaa",
+    "window-title": "bg:#bbbbbb #000000",
     # Meta-enter message.
-    'accept-message':                          'bg:#ffff88 #444444',
-
+    "accept-message": "bg:#ffff88 #444444",
     # Exit confirmation.
-    'exit-confirmation':                       'bg:#884444 #ffffff',
+    "exit-confirmation": "bg:#884444 #ffffff",
 }
 
 
 # Some changes to get a bit more contrast on Windows consoles.
 # (They only support 16 colors.)
 if is_windows() and not is_conemu_ansi() and not is_windows_vt100_supported():
-    default_ui_style.update({
-        'sidebar.title':                          'bg:#00ff00 #ffffff',
-        'exitconfirmation':                       'bg:#ff4444 #ffffff',
-        'toolbar.validation':                     'bg:#ff4444 #ffffff',
-
-        'menu.completions.completion':            'bg:#ffffff #000000',
-        'menu.completions.completion.current':    'bg:#aaaaaa #000000',
-    })
+    default_ui_style.update(
+        {
+            "sidebar.title": "bg:#00ff00 #ffffff",
+            "exitconfirmation": "bg:#ff4444 #ffffff",
+            "toolbar.validation": "bg:#ff4444 #ffffff",
+            "menu.completions.completion": "bg:#ffffff #000000",
+            "menu.completions.completion.current": "bg:#aaaaaa #000000",
+        }
+    )
 
 
 blue_ui_style = {}
 blue_ui_style.update(default_ui_style)
-#blue_ui_style.update({
+# blue_ui_style.update({
 #        # Line numbers.
 #        Token.LineNumber:                             '#aa6666',
 #
@@ -192,4 +169,4 @@ def generate_style(python_style, ui_style):
 #        Token.Menu.Completions.Meta.Current:          'bg:#00aaaa #000000',
 #        Token.Menu.Completions.ProgressBar:           'bg:#aaaaaa',
 #        Token.Menu.Completions.ProgressButton:        'bg:#000000',
-#})
+# })

ptpython/prompt_style.py

@@ -1,37 +1,39 @@
 """
 For internal use only.
 """
-from __future__ import unicode_literals
-
-from prompt_toolkit.mouse_events import MouseEventType
 import re
+from typing import Callable, TypeVar, cast
+
+from prompt_toolkit.mouse_events import MouseEvent, MouseEventType
 
-__all__ = (
-    'has_unclosed_brackets',
-    'get_jedi_script_from_document',
-    'document_is_multiline_python',
-)
+__all__ = [
+    "has_unclosed_brackets",
+    "get_jedi_script_from_document",
+    "document_is_multiline_python",
+]
 
 
-def has_unclosed_brackets(text):
+def has_unclosed_brackets(text: str) -> bool:
     """
     Starting at the end of the string. If we find an opening bracket
     for which we didn't had a closing one yet, return True.
     """
     stack = []
 
     # Ignore braces inside strings
-    text = re.sub(r'''('[^']*'|"[^"]*")''', '', text)  # XXX: handle escaped quotes.!
+    text = re.sub(r"""('[^']*'|"[^"]*")""", "", text)  # XXX: handle escaped quotes.!
 
     for c in reversed(text):
-        if c in '])}':
+        if c in "])}":
             stack.append(c)
 
-        elif c in '[({':
+        elif c in "[({":
             if stack:
-                if ((c == '[' and stack[-1] == ']') or
-                        (c == '{' and stack[-1] == '}') or
-                        (c == '(' and stack[-1] == ')')):
+                if (
+                    (c == "[" and stack[-1] == "]")
+                    or (c == "{" and stack[-1] == "}")
+                    or (c == "(" and stack[-1] == ")")
+                ):
                     stack.pop()
             else:
                 # Opening bracket for which we didn't had a closing one.
@@ -42,15 +44,17 @@ def has_unclosed_brackets(text):
 
 def get_jedi_script_from_document(document, locals, globals):
     import jedi  # We keep this import in-line, to improve start-up time.
-                 # Importing Jedi is 'slow'.
+
+    # Importing Jedi is 'slow'.
 
     try:
         return jedi.Interpreter(
             document.text,
             column=document.cursor_position_col,
             line=document.cursor_position_row + 1,
-            path='input-text',
-            namespaces=[locals, globals])
+            path="input-text",
+            namespaces=[locals, globals],
+        )
     except ValueError:
         # Invalid cursor position.
         # ValueError('`column` parameter is not in a valid range.')
@@ -70,14 +74,15 @@ def get_jedi_script_from_document(document, locals, globals):
         return None
 
 
-_multiline_string_delims = re.compile('''[']{3}|["]{3}''')
+_multiline_string_delims = re.compile("""[']{3}|["]{3}""")
 
 
 def document_is_multiline_python(document):
     """
     Determine whether this is a multiline Python document.
     """
-    def ends_in_multiline_string():
+
+    def ends_in_multiline_string() -> bool:
         """
         ``True`` if we're inside a multiline string at the end of the text.
         """
@@ -90,38 +95,47 @@ def ends_in_multiline_string():
                 opening = None
         return bool(opening)
 
-    if '\n' in document.text or ends_in_multiline_string():
+    if "\n" in document.text or ends_in_multiline_string():
         return True
 
-    def line_ends_with_colon():
-        return document.current_line.rstrip()[-1:] == ':'
+    def line_ends_with_colon() -> bool:
+        return document.current_line.rstrip()[-1:] == ":"
 
     # If we just typed a colon, or still have open brackets, always insert a real newline.
-    if line_ends_with_colon() or \
-            (document.is_cursor_at_the_end and
-             has_unclosed_brackets(document.text_before_cursor)) or \
-            document.text.startswith('@'):
+    if (
+        line_ends_with_colon()
+        or (
+            document.is_cursor_at_the_end
+            and has_unclosed_brackets(document.text_before_cursor)
+        )
+        or document.text.startswith("@")
+    ):
         return True
 
     # If the character before the cursor is a backslash (line continuation
     # char), insert a new line.
-    elif document.text_before_cursor[-1:] == '\\':
+    elif document.text_before_cursor[-1:] == "\\":
         return True
 
     return False
 
 
-def if_mousedown(handler):
+_T = TypeVar("_T", bound=Callable[[MouseEvent], None])
+
+
+def if_mousedown(handler: _T) -> _T:
     """
     Decorator for mouse handlers.
     Only handle event when the user pressed mouse down.
 
     (When applied to a token list. Scroll events will bubble up and are handled
     by the Window.)
     """
-    def handle_if_mouse_down(mouse_event):
+
+    def handle_if_mouse_down(mouse_event: MouseEvent):
         if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
             return handler(mouse_event)
         else:
             return NotImplemented
-    return handle_if_mouse_down
+
+    return cast(_T, handle_if_mouse_down)

ptpython/python_input.py

@@ -1,10 +1,7 @@
-from __future__ import unicode_literals
+from prompt_toolkit.validation import ValidationError, Validator
 
-from prompt_toolkit.validation import Validator, ValidationError
+__all__ = ["PythonValidator"]
 
-__all__ = (
-    'PythonValidator',
-)
 
 class PythonValidator(Validator):
     """
@@ -13,6 +10,7 @@ class PythonValidator(Validator):
     :param get_compiler_flags: Callable that returns the currently
         active compiler flags.
     """
+
     def __init__(self, get_compiler_flags=None):
         self.get_compiler_flags = get_compiler_flags
 
@@ -22,7 +20,7 @@ def validate(self, document):
         """
         # When the input starts with Ctrl-Z, always accept. This means EOF in a
         # Python REPL.
-        if document.text.startswith('\x1a'):
+        if document.text.startswith("\x1a"):
             return
 
         try:
@@ -31,17 +29,19 @@ def validate(self, document):
             else:
                 flags = 0
 
-            compile(document.text, '<input>', 'exec', flags=flags, dont_inherit=True)
+            compile(document.text, "<input>", "exec", flags=flags, dont_inherit=True)
         except SyntaxError as e:
             # Note, the 'or 1' for offset is required because Python 2.7
             # gives `None` as offset in case of '4=4' as input. (Looks like
             # fixed in Python 3.)
-            index = document.translate_row_col_to_index(e.lineno - 1,  (e.offset or 1) - 1)
-            raise ValidationError(index, 'Syntax Error')
+            index = document.translate_row_col_to_index(
+                e.lineno - 1, (e.offset or 1) - 1
+            )
+            raise ValidationError(index, "Syntax Error")
         except TypeError as e:
             # e.g. "compile() expected string without null bytes"
             raise ValidationError(0, str(e))
         except ValueError as e:
             # In Python 2, compiling "\x9" (an invalid escape sequence) raises
             # ValueError instead of SyntaxError.
-            raise ValidationError(0, 'Syntax Error: %s' % e)
+            raise ValidationError(0, "Syntax Error: %s" % e)

ptpython/repl.py

@@ -0,0 +1,13 @@
+[tool.black]
+target-version = ['py36']
+
+
+[tool.isort]
+# isort configuration that is compatible with Black.
+multi_line_output = 3
+include_trailing_comma = true
+known_first_party = "ptpython"
+known_third_party = "prompt_toolkit,pygments,asyncssh"
+force_grid_wrap = 0
+use_parentheses = true
+line_length = 88

ptpython/style.py

@@ -1,43 +1,48 @@
 #!/usr/bin/env python
 import os
 import sys
-from setuptools import setup, find_packages
 
-with open(os.path.join(os.path.dirname(__file__), 'README.rst')) as f:
+from setuptools import find_packages, setup
+
+with open(os.path.join(os.path.dirname(__file__), "README.rst")) as f:
     long_description = f.read()
 
 
 setup(
-    name='ptpython',
-    author='Jonathan Slenders',
-    version='2.0.5',
-    url='https://github.com/jonathanslenders/ptpython',
-    description='Python REPL build on top of prompt_toolkit',
+    name="ptpython",
+    author="Jonathan Slenders",
+    version="2.0.5",
+    url="https://github.com/prompt-toolkit/ptpython",
+    description="Python REPL build on top of prompt_toolkit",
     long_description=long_description,
-    packages=find_packages('.'),
-    install_requires = [
-        'appdirs',
-        'docopt',
-        'jedi>=0.9.0',
-        'prompt_toolkit>=2.0.8,<2.1.0',
-        'pygments',
+    packages=find_packages("."),
+    install_requires=[
+        "appdirs",
+        "jedi>=0.9.0",
+        "prompt_toolkit>=3.0.0,<3.1.0",
+        "pygments",
     ],
+    python_requires=">=3.6",
     classifiers=[
-        'Programming Language :: Python',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 2',
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3 :: Only",
+        "Programming Language :: Python",
     ],
     entry_points={
-        'console_scripts': [
-            'ptpython = ptpython.entry_points.run_ptpython:run',
-            'ptipython = ptpython.entry_points.run_ptipython:run',
-            'ptpython%s = ptpython.entry_points.run_ptpython:run' % sys.version_info[0],
-            'ptpython%s.%s = ptpython.entry_points.run_ptpython:run' % sys.version_info[:2],
-            'ptipython%s = ptpython.entry_points.run_ptipython:run' % sys.version_info[0],
-            'ptipython%s.%s = ptpython.entry_points.run_ptipython:run' % sys.version_info[:2],
+        "console_scripts": [
+            "ptpython = ptpython.entry_points.run_ptpython:run",
+            "ptipython = ptpython.entry_points.run_ptipython:run",
+            "ptpython%s = ptpython.entry_points.run_ptpython:run" % sys.version_info[0],
+            "ptpython%s.%s = ptpython.entry_points.run_ptpython:run"
+            % sys.version_info[:2],
+            "ptipython%s = ptpython.entry_points.run_ptipython:run"
+            % sys.version_info[0],
+            "ptipython%s.%s = ptpython.entry_points.run_ptipython:run"
+            % sys.version_info[:2],
         ]
     },
-    extras_require={
-        'ptipython':  ['ipython'] # For ptipython, we need to have IPython
-    }
+    extras_require={"ptipython": ["ipython"]},  # For ptipython, we need to have IPython
 )

ptpython/utils.py

@@ -1,17 +1,9 @@
 #!/usr/bin/env python
-from __future__ import unicode_literals
-
 import unittest
 
-
-# For now there are no tests here.
-# However this is sufficient for Travis to do at least a syntax check.
-# That way we are at least sure to restrict to the Python 2.6 syntax.
-
 import ptpython.completer
-import ptpython.filters
-#import ptpython.ipython
 import ptpython.eventloop
+import ptpython.filters
 import ptpython.history_browser
 import ptpython.key_bindings
 import ptpython.layout
@@ -21,6 +13,10 @@
 import ptpython.utils
 import ptpython.validator
 
+# For now there are no tests here.
+# However this is sufficient for Travis to do at least a syntax check.
+# That way we are at least sure to restrict to the Python 2.6 syntax.
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()