Reformat all files that woudl lead to less than 4 lines changed.

IPython/core/prompts.py

@@ -1,21 +1,23
 # -*- coding: utf-8 -*-
 """Being removed
 """
 
+
 class LazyEvaluate(object):
     """This is used for formatting strings with values that need to be updated
     at that time, such as the current time or working directory."""
+
     def __init__(self, func, *args, **kwargs):
         self.func = func
         self.args = args
         self.kwargs = kwargs
 
     def __call__(self, **kwargs):
         self.kwargs.update(kwargs)
         return self.func(*self.args, **self.kwargs)
 
     def __str__(self):
         return str(self())
     
     def __format__(self, format_spec):
         return format(self(), format_spec)

IPython/core/tests/nonascii2.py

@@ -1,4 +1,4
 # coding: iso-8859-5
 # (Unlikely to be the default encoding for most testers.)
 # БЖџрстуфхцчшщъыьэюя <- Cyrillic characters
-'Ўт№Ф'
+"Ўт№Ф"

IPython/utils/_process_cli.py

@@ -1,69 +1,71
 """cli-specific implementation of process utilities.
 
 cli - Common Language Infrastructure for IronPython. Code
       can run on any operating system. Check os.name for os-
       specific settings.
 
 This file is only meant to be imported by process.py, not by end-users.
 
 This file is largely untested. To become a full drop-in process
 interface for IronPython will probably require you to help fill
 in the details. 
 """
 
 # Import cli libraries:
 import clr
 import System
 
 # Import Python libraries:
 import os
 
 # Import IPython libraries:
 from ._process_common import arg_split
 
 
 def system(cmd):
     """
     system(cmd) should work in a cli environment on Mac OSX, Linux,
     and Windows
     """
     psi = System.Diagnostics.ProcessStartInfo(cmd)
     psi.RedirectStandardOutput = True
     psi.RedirectStandardError = True
     psi.WindowStyle = System.Diagnostics.ProcessWindowStyle.Normal
     psi.UseShellExecute = False
     # Start up process:
     reg = System.Diagnostics.Process.Start(psi)
 
+
 def getoutput(cmd):
     """
     getoutput(cmd) should work in a cli environment on Mac OSX, Linux,
     and Windows
     """
     psi = System.Diagnostics.ProcessStartInfo(cmd)
     psi.RedirectStandardOutput = True
     psi.RedirectStandardError = True
     psi.WindowStyle = System.Diagnostics.ProcessWindowStyle.Normal
     psi.UseShellExecute = False
     # Start up process:
     reg = System.Diagnostics.Process.Start(psi)
     myOutput = reg.StandardOutput
     output = myOutput.ReadToEnd()
     myError = reg.StandardError
     error = myError.ReadToEnd()
     return output
 
+
 def check_pid(pid):
     """
     Check if a process with the given PID (pid) exists
     """
     try:
         System.Diagnostics.Process.GetProcessById(pid)
         # process with given pid is running
         return True
     except System.InvalidOperationException:
         # process wasn't started by this object (but is running)
         return True
     except System.ArgumentException:
         # process with given pid isn't running
         return False 

IPython/utils/dir2.py

@@ -1,84 +1,84
 # encoding: utf-8
 """A fancy version of Python's builtin :func:`dir` function.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import inspect
 import types
 
 
 def safe_hasattr(obj, attr):
     """In recent versions of Python, hasattr() only catches AttributeError.
     This catches all errors.
     """
     try:
         getattr(obj, attr)
         return True
     except:
         return False
 
 
 def dir2(obj):
     """dir2(obj) -> list of strings
 
     Extended version of the Python builtin dir(), which does a few extra
     checks.
 
     This version is guaranteed to return only a list of true strings, whereas
     dir() returns anything that objects inject into themselves, even if they
     are later not really valid for attribute access (many extension libraries
     have such bugs).
     """
 
     # Start building the attribute list via dir(), and then complete it
     # with a few extra special-purpose calls.
 
     try:
         words = set(dir(obj))
     except Exception:
         # TypeError: dir(obj) does not return a list
         words = set()
 
-    if safe_hasattr(obj, '__class__'):
+    if safe_hasattr(obj, "__class__"):
         words |= set(dir(obj.__class__))
 
     # filter out non-string attributes which may be stuffed by dir() calls
     # and poor coding in third-party modules
 
     words = [w for w in words if isinstance(w, str)]
     return sorted(words)
 
 
 def get_real_method(obj, name):
     """Like getattr, but with a few extra sanity checks:
 
     - If obj is a class, ignore everything except class methods
     - Check if obj is a proxy that claims to have all attributes
     - Catch attribute access failing with any exception
     - Check that the attribute is a callable object
 
     Returns the method or None.
     """
     try:
-        canary = getattr(obj, '_ipython_canary_method_should_not_exist_', None)
+        canary = getattr(obj, "_ipython_canary_method_should_not_exist_", None)
     except Exception:
         return None
 
     if canary is not None:
         # It claimed to have an attribute it should never have
         return None
 
     try:
         m = getattr(obj, name, None)
     except Exception:
         return None
 
     if inspect.isclass(obj) and not isinstance(m, types.MethodType):
         return None
 
     if callable(m):
         return m
 
     return None