Restoring authorship annotation for Nikita Slyusarev <nslus@yandex-team.com>. Commit 1 of 2.

1 files changed, 178 insertions, 178 deletions

diff --git a/contrib/python/ipython/py2/IPython/core/oinspect.py b/contrib/python/ipython/py2/IPython/core/oinspect.py
index 55a4efe8c0..b11e24e435 100644
--- a/contrib/python/ipython/py2/IPython/core/oinspect.py
+++ b/contrib/python/ipython/py2/IPython/core/oinspect.py
@@ -17,7 +17,7 @@ __all__ = ['Inspector','InspectColors']
 # stdlib modules
 import inspect
 import linecache
-import warnings
+import warnings 
 import os
 from textwrap import dedent
 import types
@@ -42,19 +42,19 @@ from IPython.utils.wildcard import list_namespace
 from IPython.utils.coloransi import TermColors, ColorScheme, ColorSchemeTable
 from IPython.utils.py3compat import cast_unicode, string_types, PY3
 from IPython.utils.signatures import signature
-from IPython.utils.colorable import Colorable
+from IPython.utils.colorable import Colorable 
 
-from pygments import highlight
+from pygments import highlight 
 try:
     # PythonLexer was renamed to Python2Lexer in pygments 2.5
     from pygments.lexers import Python2Lexer
 except ImportError:
     from pygments.lexers import PythonLexer as Python2Lexer
-from pygments.formatters import HtmlFormatter
-
-def pylight(code):
+from pygments.formatters import HtmlFormatter 
+ 
+def pylight(code): 
     return highlight(code, Python2Lexer(), HtmlFormatter(noclasses=True))
-
+ 
 # builtin docstrings to ignore
 _func_call_docstring = types.FunctionType.__call__.__doc__
 _object_init_docstring = object.__init__.__doc__
@@ -124,8 +124,8 @@ def getdoc(obj):
 
     It also attempts to call a getdoc() method on the given object.  This
     allows objects which provide their docstrings via non-standard mechanisms
-    (like Pyro proxies) to still be inspected by ipython's ? system.
-    """
+    (like Pyro proxies) to still be inspected by ipython's ? system. 
+    """ 
     # Allow objects to offer customized documentation via a getdoc method:
     try:
         ds = obj.getdoc()
@@ -141,7 +141,7 @@ def getdoc(obj):
         return py3compat.cast_unicode(docstr, encoding=encoding)
     except Exception:
         # Harden against an inspect failure, which can occur with
-        # extensions modules.
+        # extensions modules. 
         raise
         return None
 
@@ -376,16 +376,16 @@ def find_source_lines(obj):
 
     return lineno
 
-class Inspector(Colorable):
+class Inspector(Colorable): 
 
     def __init__(self, color_table=InspectColors,
                  code_color_table=PyColorize.ANSICodeColors,
                  scheme='NoColor',
-                 str_detail_level=0,
-                 parent=None, config=None):
-        super(Inspector, self).__init__(parent=parent, config=config)
+                 str_detail_level=0, 
+                 parent=None, config=None): 
+        super(Inspector, self).__init__(parent=parent, config=config) 
         self.color_table = color_table
-        self.parser = PyColorize.Parser(out='str', parent=self, style=scheme)
+        self.parser = PyColorize.Parser(out='str', parent=self, style=scheme) 
         self.format = self.parser.format
         self.str_detail_level = str_detail_level
         self.set_active_scheme(scheme)
@@ -438,11 +438,11 @@ class Inspector(Colorable):
         if output is None:
             self.noinfo('definition header',oname)
         else:
-            print(header,self.format(output), end=' ')
+            print(header,self.format(output), end=' ') 
 
     # In Python 3, all classes are new-style, so they all have __init__.
     @skip_doctest_py3
-    def pdoc(self, obj, oname='', formatter=None):
+    def pdoc(self, obj, oname='', formatter=None): 
         """Print the docstring for any object.
 
         Optional:
@@ -480,7 +480,7 @@ class Inspector(Colorable):
         lines = []
         ds = getdoc(obj)
         if formatter:
-            ds = formatter(ds).get('plain/text', ds)
+            ds = formatter(ds).get('plain/text', ds) 
         if ds:
             lines.append(head("Class docstring:"))
             lines.append(indent(ds))
@@ -517,7 +517,7 @@ class Inspector(Colorable):
 
     def pfile(self, obj, oname=''):
         """Show the whole file where an object was defined."""
-
+ 
         lineno = find_source_lines(obj)
         if lineno is None:
             self.noinfo('file', oname)
@@ -553,184 +553,184 @@ class Inspector(Colorable):
             title_width = max(len(title) + 2 for title, _ in fields)
         for title, content in fields:
             if len(content.splitlines()) > 1:
-                title = header(title + ':') + '\n'
+                title = header(title + ':') + '\n' 
             else:
-                title = header((title + ':').ljust(title_width))
+                title = header((title + ':').ljust(title_width)) 
             out.append(cast_unicode(title) + cast_unicode(content))
         return "\n".join(out)
 
-    def _mime_format(self, text, formatter=None):
-        """Return a mime bundle representation of the input text.
-
-        - if `formatter` is None, the returned mime bundle has
-           a `text/plain` field, with the input text.
-           a `text/html` field with a `<pre>` tag containing the input text.
-
-        - if `formatter` is not None, it must be a callable transforming the
-          input text into a mime bundle. Default values for `text/plain` and
-          `text/html` representations are the ones described above.
-
-        Note:
-
-        Formatters returning strings are supported but this behavior is deprecated.
-
-        """
-        text = cast_unicode(text)
-        defaults = {
-            'text/plain': text,
-            'text/html': '<pre>' + text + '</pre>'
-        }
-
-        if formatter is None:
-            return defaults
-        else:
-            formatted = formatter(text)
-
-            if not isinstance(formatted, dict):
-                # Handle the deprecated behavior of a formatter returning
-                # a string instead of a mime bundle.
-                return {
-                    'text/plain': formatted,
-                    'text/html': '<pre>' + formatted + '</pre>'
-                }
-
-            else:
-                return dict(defaults, **formatted)
-
-
-    def format_mime(self, bundle):
-
-        text_plain = bundle['text/plain']
-
-        text = ''
-        heads, bodies = list(zip(*text_plain))
-        _len = max(len(h) for h in heads)
-
-        for head, body in zip(heads, bodies):
-            body = body.strip('\n')
-            delim = '\n' if '\n' in body else ' '
-            text += self.__head(head+':') + (_len - len(head))*' ' +delim + body +'\n'
-
-        bundle['text/plain'] = text
-        return bundle
-
-    def _get_info(self, obj, oname='', formatter=None, info=None, detail_level=0):
-        """Retrieve an info dict and format it."""
-
-        info = self._info(obj, oname=oname, info=info, detail_level=detail_level)
-
-        _mime = {
-            'text/plain': [],
-            'text/html': '',
-        }
-
-        def append_field(bundle, title, key, formatter=None):
-            field = info[key]
-            if field is not None:
-                formatted_field = self._mime_format(field, formatter)
-                bundle['text/plain'].append((title, formatted_field['text/plain']))
-                bundle['text/html'] += '<h1>' + title + '</h1>\n' + formatted_field['text/html'] + '\n'
-
-        def code_formatter(text):
-            return {
-                'text/plain': self.format(text),
-                'text/html': pylight(text)
-            }
-
+    def _mime_format(self, text, formatter=None): 
+        """Return a mime bundle representation of the input text. 
+ 
+        - if `formatter` is None, the returned mime bundle has 
+           a `text/plain` field, with the input text. 
+           a `text/html` field with a `<pre>` tag containing the input text. 
+ 
+        - if `formatter` is not None, it must be a callable transforming the 
+          input text into a mime bundle. Default values for `text/plain` and 
+          `text/html` representations are the ones described above. 
+ 
+        Note: 
+ 
+        Formatters returning strings are supported but this behavior is deprecated. 
+ 
+        """ 
+        text = cast_unicode(text) 
+        defaults = { 
+            'text/plain': text, 
+            'text/html': '<pre>' + text + '</pre>' 
+        } 
+ 
+        if formatter is None: 
+            return defaults 
+        else: 
+            formatted = formatter(text) 
+ 
+            if not isinstance(formatted, dict): 
+                # Handle the deprecated behavior of a formatter returning 
+                # a string instead of a mime bundle. 
+                return { 
+                    'text/plain': formatted, 
+                    'text/html': '<pre>' + formatted + '</pre>' 
+                } 
+ 
+            else: 
+                return dict(defaults, **formatted) 
+ 
+ 
+    def format_mime(self, bundle): 
+ 
+        text_plain = bundle['text/plain'] 
+ 
+        text = '' 
+        heads, bodies = list(zip(*text_plain)) 
+        _len = max(len(h) for h in heads) 
+ 
+        for head, body in zip(heads, bodies): 
+            body = body.strip('\n') 
+            delim = '\n' if '\n' in body else ' ' 
+            text += self.__head(head+':') + (_len - len(head))*' ' +delim + body +'\n' 
+ 
+        bundle['text/plain'] = text 
+        return bundle 
+ 
+    def _get_info(self, obj, oname='', formatter=None, info=None, detail_level=0): 
+        """Retrieve an info dict and format it.""" 
+ 
+        info = self._info(obj, oname=oname, info=info, detail_level=detail_level) 
+ 
+        _mime = { 
+            'text/plain': [], 
+            'text/html': '', 
+        } 
+ 
+        def append_field(bundle, title, key, formatter=None): 
+            field = info[key] 
+            if field is not None: 
+                formatted_field = self._mime_format(field, formatter) 
+                bundle['text/plain'].append((title, formatted_field['text/plain'])) 
+                bundle['text/html'] += '<h1>' + title + '</h1>\n' + formatted_field['text/html'] + '\n' 
+ 
+        def code_formatter(text): 
+            return { 
+                'text/plain': self.format(text), 
+                'text/html': pylight(text) 
+            } 
+ 
         if info['isalias']:
-            append_field(_mime, 'Repr', 'string_form')
+            append_field(_mime, 'Repr', 'string_form') 
 
         elif info['ismagic']:
-            if detail_level > 0:
-                append_field(_mime, 'Source', 'source', code_formatter)
+            if detail_level > 0: 
+                append_field(_mime, 'Source', 'source', code_formatter) 
             else:
-                append_field(_mime, 'Docstring', 'docstring', formatter)
-            append_field(_mime, 'File', 'file')
+                append_field(_mime, 'Docstring', 'docstring', formatter) 
+            append_field(_mime, 'File', 'file') 
 
         elif info['isclass'] or is_simple_callable(obj):
             # Functions, methods, classes
-            append_field(_mime, 'Signature', 'definition', code_formatter)
-            append_field(_mime, 'Init signature', 'init_definition', code_formatter)
+            append_field(_mime, 'Signature', 'definition', code_formatter) 
+            append_field(_mime, 'Init signature', 'init_definition', code_formatter) 
             if detail_level > 0 and info['source']:
-                append_field(_mime, 'Source', 'source', code_formatter)
+                append_field(_mime, 'Source', 'source', code_formatter) 
             else:
-                append_field(_mime, 'Docstring', 'docstring', formatter)
-                append_field(_mime, 'Init docstring', 'init_docstring', formatter)
+                append_field(_mime, 'Docstring', 'docstring', formatter) 
+                append_field(_mime, 'Init docstring', 'init_docstring', formatter) 
 
-            append_field(_mime, 'File', 'file')
-            append_field(_mime, 'Type', 'type_name')
+            append_field(_mime, 'File', 'file') 
+            append_field(_mime, 'Type', 'type_name') 
 
         else:
             # General Python objects
             append_field(_mime, 'Signature', 'definition', code_formatter)
             append_field(_mime, 'Call signature', 'call_def', code_formatter)
             
-            append_field(_mime, 'Type', 'type_name')
+            append_field(_mime, 'Type', 'type_name') 
 
             # Base class for old-style instances
             if (not py3compat.PY3) and isinstance(obj, types.InstanceType) and info['base_class']:
-                append_field(_mime, 'Base Class', 'base_class')
+                append_field(_mime, 'Base Class', 'base_class') 
 
-            append_field(_mime, 'String form', 'string_form')
+            append_field(_mime, 'String form', 'string_form') 
 
             # Namespace
             if info['namespace'] != 'Interactive':
-                append_field(_mime, 'Namespace', 'namespace')
+                append_field(_mime, 'Namespace', 'namespace') 
 
-            append_field(_mime, 'Length', 'length')
+            append_field(_mime, 'Length', 'length') 
             append_field(_mime, 'File', 'file')
             
             # Source or docstring, depending on detail level and whether
             # source found.
-            if detail_level > 0:
-                append_field(_mime, 'Source', 'source', code_formatter)
-            else:
-                append_field(_mime, 'Docstring', 'docstring', formatter)
-
-            append_field(_mime, 'Class docstring', 'class_docstring', formatter)
-            append_field(_mime, 'Init docstring', 'init_docstring', formatter)
-            append_field(_mime, 'Call docstring', 'call_docstring', formatter)
+            if detail_level > 0: 
+                append_field(_mime, 'Source', 'source', code_formatter) 
+            else: 
+                append_field(_mime, 'Docstring', 'docstring', formatter) 
+
+            append_field(_mime, 'Class docstring', 'class_docstring', formatter) 
+            append_field(_mime, 'Init docstring', 'init_docstring', formatter) 
+            append_field(_mime, 'Call docstring', 'call_docstring', formatter) 
             
-
-        return self.format_mime(_mime)
-
-    def pinfo(self, obj, oname='', formatter=None, info=None, detail_level=0, enable_html_pager=True):
+ 
+        return self.format_mime(_mime) 
+ 
+    def pinfo(self, obj, oname='', formatter=None, info=None, detail_level=0, enable_html_pager=True): 
         """Show detailed information about an object.
 
         Optional arguments:
 
         - oname: name of the variable pointing to the object.
 
-        - formatter: callable (optional)
-              A special formatter for docstrings.
-
-              The formatter is a callable that takes a string as an input
-              and returns either a formatted string or a mime type bundle
-              in the form of a dictionnary.
-
-              Although the support of custom formatter returning a string
-              instead of a mime type bundle is deprecated.
+        - formatter: callable (optional) 
+              A special formatter for docstrings. 
 
+              The formatter is a callable that takes a string as an input 
+              and returns either a formatted string or a mime type bundle 
+              in the form of a dictionnary. 
+ 
+              Although the support of custom formatter returning a string 
+              instead of a mime type bundle is deprecated. 
+ 
         - info: a structure with some information fields which may have been
           precomputed already.
 
         - detail_level: if set to 1, more information is given.
         """
-        info = self._get_info(obj, oname, formatter, info, detail_level)
-        if not enable_html_pager:
-            del info['text/html']
-        page.page(info)
-
+        info = self._get_info(obj, oname, formatter, info, detail_level) 
+        if not enable_html_pager: 
+            del info['text/html'] 
+        page.page(info) 
+ 
     def info(self, obj, oname='', formatter=None, info=None, detail_level=0):
-        """DEPRECATED. Compute a dict with detailed information about an object.
-        """
-        if formatter is not None:
-            warnings.warn('The `formatter` keyword argument to `Inspector.info`'
-                     'is deprecated as of IPython 5.0 and will have no effects.',
-                      DeprecationWarning, stacklevel=2)
-        return self._info(obj, oname=oname, info=info, detail_level=detail_level)
-
-    def _info(self, obj, oname='', info=None, detail_level=0):
+        """DEPRECATED. Compute a dict with detailed information about an object. 
+        """ 
+        if formatter is not None: 
+            warnings.warn('The `formatter` keyword argument to `Inspector.info`' 
+                     'is deprecated as of IPython 5.0 and will have no effects.', 
+                      DeprecationWarning, stacklevel=2) 
+        return self._info(obj, oname=oname, info=info, detail_level=detail_level) 
+ 
+    def _info(self, obj, oname='', info=None, detail_level=0): 
         """Compute a dict with detailed information about an object.
 
         Optional arguments:
@@ -774,7 +774,7 @@ class Inspector(Colorable):
         out = dict(name=oname, found=True, isalias=isalias, ismagic=ismagic)
 
         string_max = 200 # max size of strings to show (snipped if longer)
-        shalf = int((string_max - 5) / 2)
+        shalf = int((string_max - 5) / 2) 
 
         if ismagic:
             obj_type_name = 'Magic function'
@@ -846,43 +846,43 @@ class Inspector(Colorable):
         # Constructor docstring for classes
         if inspect.isclass(obj):
             out['isclass'] = True
-
-            # get the init signature:
+ 
+            # get the init signature: 
             try:
-                init_def = self._getdef(obj, oname)
+                init_def = self._getdef(obj, oname) 
             except AttributeError:
-                init_def = None
-
-            # get the __init__ docstring
-            try:
-                obj_init = obj.__init__
-            except AttributeError:
-                init_ds = None
+                init_def = None 
+ 
+            # get the __init__ docstring 
+            try: 
+                obj_init = obj.__init__ 
+            except AttributeError: 
+                init_ds = None 
             else:
-                if init_def is None:
-                    # Get signature from init if top-level sig failed.
-                    # Can happen for built-in types (list, etc.).
-                    try:
-                        init_def = self._getdef(obj_init, oname)
-                    except AttributeError:
-                        pass
-                init_ds = getdoc(obj_init)
+                if init_def is None: 
+                    # Get signature from init if top-level sig failed. 
+                    # Can happen for built-in types (list, etc.). 
+                    try: 
+                        init_def = self._getdef(obj_init, oname) 
+                    except AttributeError: 
+                        pass 
+                init_ds = getdoc(obj_init) 
                 # Skip Python's auto-generated docstrings
                 if init_ds == _object_init_docstring:
                     init_ds = None
 
-            if init_def:
-                out['init_definition'] = init_def
-
-            if init_ds:
-                out['init_docstring'] = init_ds
+            if init_def: 
+                out['init_definition'] = init_def 
 
+            if init_ds: 
+                out['init_docstring'] = init_ds 
+ 
         # and class docstring for instances:
         else:
             # reconstruct the function definition and print it:
             defln = self._getdef(obj, oname)
             if defln:
-                out['definition'] = defln
+                out['definition'] = defln 
 
             # First, check whether the instance docstring is identical to the
             # class one, and print it separately if they don't coincide.  In
@@ -915,10 +915,10 @@ class Inspector(Colorable):
             # Call form docstring for callable instances
             if safe_hasattr(obj, '__call__') and not is_simple_callable(obj):
                 call_def = self._getdef(obj.__call__, oname)
-                if call_def and (call_def != out.get('definition')):
+                if call_def and (call_def != out.get('definition')): 
                     # it may never be the case that call def and definition differ,
                     # but don't include the same signature twice
-                    out['call_def'] = call_def
+                    out['call_def'] = call_def 
                 call_ds = getdoc(obj.__call__)
                 # Skip Python's auto-generated docstrings
                 if call_ds == _func_call_docstring: