MAINT: run black on files that ends up in a single line change.

If running black on a file change one line of less, let just make it
black Compliant

IPython/core/tests/print_argv.py

@@ -1,2 +1,3 b''
 import sys
+
 print(sys.argv[1:])

IPython/core/tests/test_autocall.py

@@ -1,66 +1,67 b''
 """These kinds of tests are less than ideal, but at least they run.
 
 This was an old test that was being run interactively in the top-level tests/
 directory, which we are removing.  For now putting this here ensures at least
 we do run the test, though ultimately this functionality should all be tested
 with better-isolated tests that don't rely on the global instance in iptest.
 """
 from IPython.core.splitinput import LineInfo
 from IPython.core.prefilter import AutocallChecker
 
+
 def doctest_autocall():
     """
     In [1]: def f1(a,b,c):
        ...:     return a+b+c
        ...:
 
     In [2]: def f2(a):
        ...:     return a + a
        ...:
 
     In [3]: def r(x):
        ...:     return True
        ...:
 
     In [4]: ;f2 a b c
     Out[4]: 'a b ca b c'
 
     In [5]: assert _ == "a b ca b c"
 
     In [6]: ,f1 a b c
     Out[6]: 'abc'
 
     In [7]: assert _ == 'abc'
 
     In [8]: print(_)
     abc
 
     In [9]: /f1 1,2,3
     Out[9]: 6
 
     In [10]: assert _ == 6
 
     In [11]: /f2 4
     Out[11]: 8
 
     In [12]: assert _ == 8
 
     In [12]: del f1, f2
 
     In [13]: ,r a
     Out[13]: True
 
     In [14]: assert _ == True
 
     In [15]: r'a'
     Out[15]: 'a'
 
     In [16]: assert _ == 'a'
     """
 
 
 def test_autocall_should_ignore_raw_strings():
     line_info = LineInfo("r'a'")
     pm = ip.prefilter_manager
     ac = AutocallChecker(shell=pm.shell, prefilter_manager=pm, config=pm.config)
     assert ac.check(line_info) is None

IPython/core/tests/test_splitinput.py

@@ -1,38 +1,39 b''
 # coding: utf-8
 
 from IPython.core.splitinput import split_user_input, LineInfo
 from IPython.testing import tools as tt
 
 tests = [
     ("x=1", ("", "", "x", "=1")),
     ("?", ("", "?", "", "")),
     ("??", ("", "??", "", "")),
     (" ?", (" ", "?", "", "")),
     (" ??", (" ", "??", "", "")),
     ("??x", ("", "??", "x", "")),
     ("?x=1", ("", "?", "x", "=1")),
     ("!ls", ("", "!", "ls", "")),
     ("  !ls", ("  ", "!", "ls", "")),
     ("!!ls", ("", "!!", "ls", "")),
     ("  !!ls", ("  ", "!!", "ls", "")),
     (",ls", ("", ",", "ls", "")),
     (";ls", ("", ";", "ls", "")),
     ("  ;ls", ("  ", ";", "ls", "")),
     ("f.g(x)", ("", "", "f.g", "(x)")),
     ("f.g (x)", ("", "", "f.g", "(x)")),
     ("?%hist1", ("", "?", "%hist1", "")),
     ("?%%hist2", ("", "?", "%%hist2", "")),
     ("??%hist3", ("", "??", "%hist3", "")),
     ("??%%hist4", ("", "??", "%%hist4", "")),
     ("?x*", ("", "?", "x*", "")),
 ]
 tests.append(("Pérez Fernando", ("", "", "Pérez", "Fernando")))
 
 
 def test_split_user_input():
     return tt.check_pairs(split_user_input, tests)
 
+
 def test_LineInfo():
     """Simple test for LineInfo construction and str()"""
     linfo = LineInfo("  %cd /home")
     assert str(linfo) == "LineInfo [  |%|cd|/home]"

IPython/lib/tests/test_clipboard.py

@@ -1,19 +1,20 b''
 from IPython.core.error import TryNext
 from IPython.lib.clipboard import ClipboardEmpty
 from IPython.testing.decorators import skip_if_no_x11
 
+
 @skip_if_no_x11
 def test_clipboard_get():
     # Smoketest for clipboard access - we can't easily guarantee that the
     # clipboard is accessible and has something on it, but this tries to
     # exercise the relevant code anyway.
     try:
         a = get_ipython().hooks.clipboard_get()
     except ClipboardEmpty:
         # Nothing in clipboard to get
         pass
     except TryNext:
         # No clipboard access API available
         pass
     else:
         assert isinstance(a, str)

IPython/utils/contexts.py

@@ -1,60 +1,61 b''
 # encoding: utf-8
 """Miscellaneous context managers.
 """
 
 import warnings
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
+
 class preserve_keys(object):
     """Preserve a set of keys in a dictionary.
 
     Upon entering the context manager the current values of the keys
     will be saved. Upon exiting, the dictionary will be updated to
     restore the original value of the preserved keys. Preserved keys
     which did not exist when entering the context manager will be
     deleted.
 
     Examples
     --------
 
     >>> d = {'a': 1, 'b': 2, 'c': 3}
     >>> with preserve_keys(d, 'b', 'c', 'd'):
     ...     del d['a']
     ...     del d['b']      # will be reset to 2
     ...     d['c'] = None   # will be reset to 3
     ...     d['d'] = 4      # will be deleted
     ...     d['e'] = 5
     ...     print(sorted(d.items()))
     ...
     [('c', None), ('d', 4), ('e', 5)]
     >>> print(sorted(d.items()))
     [('b', 2), ('c', 3), ('e', 5)]
     """
 
     def __init__(self, dictionary, *keys):
         self.dictionary = dictionary
         self.keys = keys
 
     def __enter__(self):
         # Actions to perform upon exiting.
         to_delete = []
         to_update = {}
 
         d = self.dictionary
         for k in self.keys:
             if k in d:
                 to_update[k] = d[k]
             else:
                 to_delete.append(k)
 
         self.to_delete = to_delete
         self.to_update = to_update
 
     def __exit__(self, *exc_info):
         d = self.dictionary
 
         for k in self.to_delete:
             d.pop(k, None)
         d.update(self.to_update)

IPython/utils/eventful.py

@@ -1,6 +1,5 b''
-
 from warnings import warn
 
 warn("IPython.utils.eventful has moved to traitlets.eventful", stacklevel=2)
 
 from traitlets.eventful import *

IPython/utils/log.py

@@ -1,6 +1,5 b''
-
 from warnings import warn
 
 warn("IPython.utils.log has moved to traitlets.log", stacklevel=2)
 
 from traitlets.log import *

IPython/utils/tempdir.py

@@ -1,58 +1,59 b''
 """ This module contains classes - NamedFileInTemporaryDirectory, TemporaryWorkingDirectory.
 
 These classes add extra features such as creating a named file in temporary directory and
 creating a context manager for the working directory which is also temporary.
 """
 
 import os as _os
 from pathlib import Path
 from tempfile import TemporaryDirectory
 
 
 class NamedFileInTemporaryDirectory(object):
     def __init__(self, filename, mode="w+b", bufsize=-1, add_to_syspath=False, **kwds):
         """
         Open a file named `filename` in a temporary directory.
 
         This context manager is preferred over `NamedTemporaryFile` in
         stdlib `tempfile` when one needs to reopen the file.
 
         Arguments `mode` and `bufsize` are passed to `open`.
         Rest of the arguments are passed to `TemporaryDirectory`.
 
         """
         self._tmpdir = TemporaryDirectory(**kwds)
         path = Path(self._tmpdir.name) / filename
         encoding = None if "b" in mode else "utf-8"
         self.file = open(path, mode, bufsize, encoding=encoding)
 
     def cleanup(self):
         self.file.close()
         self._tmpdir.cleanup()
 
     __del__ = cleanup
 
     def __enter__(self):
         return self.file
 
     def __exit__(self, type, value, traceback):
         self.cleanup()
 
 
 class TemporaryWorkingDirectory(TemporaryDirectory):
     """
     Creates a temporary directory and sets the cwd to that directory.
     Automatically reverts to previous cwd upon cleanup.
     Usage example:
 
         with TemporaryWorkingDirectory() as tmpdir:
             ...
     """
+
     def __enter__(self):
         self.old_wd = Path.cwd()
         _os.chdir(self.name)
         return super(TemporaryWorkingDirectory, self).__enter__()
 
     def __exit__(self, exc, value, tb):
         _os.chdir(self.old_wd)
         return super(TemporaryWorkingDirectory, self).__exit__(exc, value, tb)