├── setup.cfg
├── pretty-context.png
├── .travis.yml
├── setup.py
├── disp
    ├── spark.py
    ├── __init__.py
    ├── vendor.py
    └── py3only.py
├── LICENSE
├── README.md
├── .gitignore
└── example
    └── Disp-Example-builtins.ipynb


/setup.cfg:
--------------------------------------------------------------------------------
1 | [bdist_wheel]
2 | universal=1
3 | 


--------------------------------------------------------------------------------
/pretty-context.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ipython/disp/master/pretty-context.png


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: python 
 2 | sudo: false
 3 | before_install: 
 4 |     - pip install pip --upgrade
 5 |     - pip install ipython 
 6 | script: 
 7 |     - ipython -c 'import disp; disp.install()'
 8 |     - # py.test # no test for now.
 9 |     - ipython -c 'import disp; disp.uninstall()'
10 | python:
11 |     - "nightly"
12 |     - 3.6-dev
13 |     - 3.6
14 |     - 3.5
15 |     - 2.7
16 | 
17 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup
 2 | 
 3 | description='Providing default representations of common objects in Python land',
 4 | 
 5 | try:
 6 |     import pypandoc
 7 |     description = pypandoc.convert(open('README.md','r').read(), format='markdown', to='rst')
 8 | except:
 9 |     print('Issues running or importing pypandoc. If you are publishing the package the description will be missing.')
10 | 
11 | setup(name='disp',
12 |       version='0.0.3',
13 |       description='Providing default representations of common objects in Python land',
14 |       url='http://github.com/ipython/disp',
15 |       author='IPython developers',
16 |       author_email='ipython-dev@python.org',
17 |       license='BSD',
18 |       packages=['disp'],
19 |       zip_safe=False)
20 | 


--------------------------------------------------------------------------------
/disp/spark.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | # -*- coding: utf-8 -*-
 3 | 
 4 | 
 5 | def fully_qualified_name(m):
 6 |     return (m.__module__ + "." if hasattr(m, "__module__") else "") + m.__class__.__name__
 7 | 
 8 | 
 9 | def repr_spark_context_html(sc):
10 |     '''
11 |     Carry over from the Spark 2.2.0 _repr_html_ for spark contexts
12 | 
13 |     Works on objects whose fully qualified name is 'pyspark.context.SparkContext'
14 |     '''
15 |     return """
16 |     <div>
17 |         <p><b>SparkContext</b></p>
18 | 
19 |         <p><a href="{sc.uiWebUrl}">Spark UI</a></p>
20 | 
21 |         <dl>
22 |           <dt>Version</dt>
23 |             <dd><code>v{sc.version}</code></dd>
24 |           <dt>Master</dt>
25 |             <dd><code>{sc.master}</code></dd>
26 |           <dt>AppName</dt>
27 |             <dd><code>{sc.appName}</code></dd>
28 |         </dl>
29 |     </div>
30 |     """.format(
31 |         sc=sc
32 |     )
33 | 
34 | 
35 | def repr_spark_session_html(session):
36 |     '''
37 |     Carry over from the Spark 2.2.0 _repr_html_ for spark sessions
38 | 
39 |     Works on objects whose fully qualified name is 'pyspark.sql.session.SparkSession'
40 |     '''
41 |     return """
42 |         <div>
43 |             <p><b>SparkSession - {catalogImplementation}</b></p>
44 |             {sc_HTML}
45 |         </div>
46 |     """.format(
47 |         catalogImplementation=session.conf.get("spark.sql.catalogImplementation"),
48 |         sc_HTML=repr_sc(session.sparkContext)
49 |     )
50 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | BSD 3-Clause License
 2 | 
 3 | Copyright (c) 2017, IPython
 4 | All rights reserved.
 5 | 
 6 | Redistribution and use in source and binary forms, with or without
 7 | modification, are permitted provided that the following conditions are met:
 8 | 
 9 | * Redistributions of source code must retain the above copyright notice, this
10 |   list of conditions and the following disclaimer.
11 | 
12 | * Redistributions in binary form must reproduce the above copyright notice,
13 |   this list of conditions and the following disclaimer in the documentation
14 |   and/or other materials provided with the distribution.
15 | 
16 | * Neither the name of the copyright holder nor the names of its
17 |   contributors may be used to endorse or promote products derived from
18 |   this software without specific prior written permission.
19 | 
20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Disp
 2 | 
 3 | Providing default representations of common objects in Python land
 4 | 
 5 | ![pretty-spark-context](./pretty-context.png)
 6 | 
 7 | Works in IPython when the object is the value returned by the last statement of
 8 | a cell, or when calling `display()` on it. 
 9 | 
10 | ## Install 
11 | 
12 | ```
13 | $ pip install disp
14 | $ ipython -c 'import disp; disp.install()'
15 | 💖 Installation succeeded: enjoy disp ! 💖
16 | ```
17 | 
18 | ## Uninstall
19 | 
20 | ```
21 | $ ipython -c 'import disp; disp.uninstall()'
22 | ```
23 | 
24 | ## Supported objects
25 | 
26 | The following objects will gain superpowers automatically:
27 | 
28 |  - `pyspark.context:SparkContext`
29 |  - `pyspark.sql:SparkSession`
30 | 
31 | The followings objects need to be explicitly register with
32 | `disp.activate_builtins()` and will work only on Python 3.6 and later:
33 | 
34 |  - types
35 |  - functions methods (and alike)
36 |  - modules
37 | 
38 | The following objects need to be explicitly activated individually for each
39 | type with `disp.activate_for(instance)`:
40 |  
41 |  - requests.models.Response (Python 3.6+ only)
42 | 
43 | A couple of other objects are secretly available on Python 3.6, but are still
44 | unstable so-far (dig through the source).
45 | 
46 | ## Example
47 | 
48 | See our [example notebook](http://nbviewer.jupyter.org/github/ipython/disp/blob/master/example/Disp-Example-builtins.ipynb)
49 | 
50 | ## Do you support more objects? 
51 | 
52 | Do you want to submit a Pull Request? We'll probably accept it. 🤓
53 | 
54 | # releasing
55 | 
56 | Bump version number in `setup.py`.
57 | Install `twine`
58 | 
59 | ```
60 | $ python setup.py sdist bdist_wheel
61 | $ twine upload dist/*
62 | ```
63 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | env/
 12 | build/
 13 | develop-eggs/
 14 | dist/
 15 | downloads/
 16 | eggs/
 17 | .eggs/
 18 | lib/
 19 | lib64/
 20 | parts/
 21 | sdist/
 22 | var/
 23 | wheels/
 24 | *.egg-info/
 25 | .installed.cfg
 26 | *.egg
 27 | 
 28 | # PyInstaller
 29 | #  Usually these files are written by a python script from a template
 30 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 31 | *.manifest
 32 | *.spec
 33 | 
 34 | # Installer logs
 35 | pip-log.txt
 36 | pip-delete-this-directory.txt
 37 | 
 38 | # Unit test / coverage reports
 39 | htmlcov/
 40 | .tox/
 41 | .coverage
 42 | .coverage.*
 43 | .cache
 44 | nosetests.xml
 45 | coverage.xml
 46 | *.cover
 47 | .hypothesis/
 48 | 
 49 | # Translations
 50 | *.mo
 51 | *.pot
 52 | 
 53 | # Django stuff:
 54 | *.log
 55 | local_settings.py
 56 | 
 57 | # Flask stuff:
 58 | instance/
 59 | .webassets-cache
 60 | 
 61 | # Scrapy stuff:
 62 | .scrapy
 63 | 
 64 | # Sphinx documentation
 65 | docs/_build/
 66 | 
 67 | # PyBuilder
 68 | target/
 69 | 
 70 | # Jupyter Notebook
 71 | .ipynb_checkpoints
 72 | 
 73 | # pyenv
 74 | .python-version
 75 | 
 76 | # celery beat schedule file
 77 | celerybeat-schedule
 78 | 
 79 | # SageMath parsed files
 80 | *.sage.py
 81 | 
 82 | # dotenv
 83 | .env
 84 | 
 85 | # virtualenv
 86 | .venv
 87 | venv/
 88 | ENV/
 89 | 
 90 | # Spyder project settings
 91 | .spyderproject
 92 | .spyproject
 93 | 
 94 | # Rope project settings
 95 | .ropeproject
 96 | 
 97 | # mkdocs documentation
 98 | /site
 99 | 
100 | # mypy
101 | .mypy_cache/
102 | 


--------------------------------------------------------------------------------
/disp/__init__.py:
--------------------------------------------------------------------------------
  1 | # coding: utf-8
  2 | """
  3 | Rich display for a variety of Python objects.
  4 | 
  5 | Use the followign to enable permanently.
  6 | 
  7 | >>> import disp; disp.install()
  8 | 
  9 | 
 10 | The following activate rich repr on a couple of builtins types:
 11 | 
 12 |     - functions/methods
 13 |     - types
 14 |     - modules
 15 | 
 16 | >>> import disp; disp.activate_builtins()
 17 | 
 18 | As this may have side-effect the setting does not persist across sessions
 19 | 
 20 | 
 21 | Some object are not enabled by default, you can activate with:
 22 | 
 23 | >>> import disp; disp.activate_for(something)
 24 | 
 25 | For example, a `requests`'s response. 
 26 | 
 27 | >>> import requests
 28 | >>> response = requests.get(...)
 29 | >>> disp.activate+for(response)
 30 | >>> response
 31 | 
 32 | 
 33 | """
 34 | 
 35 | import sys
 36 | import json
 37 | from os import path
 38 | 
 39 | from IPython import get_ipython, paths
 40 | from .spark import repr_spark_context_html, repr_spark_session_html
 41 | 
 42 | if sys.version_info < (3,):
 43 |     FileNotFoundError = IOError
 44 |     JSONDecodeError = ValueError
 45 | else:
 46 |     from json.decoder import JSONDecodeError
 47 | 
 48 | 
 49 | def load_ipython_extension(ipython):
 50 |     """
 51 |     Load an extension with IPython that tells it how to represent specifc
 52 |     objects.
 53 |     """
 54 |     html = ipython.display_formatter.formatters['text/html']
 55 | 
 56 |     html.for_type_by_name('pyspark.context','SparkContext', repr_spark_context_html)
 57 |     html.for_type_by_name('pyspark.sql', 'SparkSession', repr_spark_session_html)
 58 | 
 59 | 
 60 | def activate_builtins():
 61 |     """
 62 |     Install html_repr for a couple of the builtin
 63 |     """
 64 |     if sys.version_info > (3, 6):
 65 |         ipython = get_ipython()
 66 |         html = ipython.display_formatter.formatters['text/html']
 67 |         import types
 68 |         from .py3only import html_formatter_for_builtin_function_or_method, html_formatter_for_type, html_formatter_for_module
 69 |         html.for_type(types.FunctionType, html_formatter_for_builtin_function_or_method)
 70 |         html.for_type(types.BuiltinFunctionType, html_formatter_for_builtin_function_or_method)
 71 |         html.for_type(types.BuiltinMethodType, html_formatter_for_builtin_function_or_method)
 72 |         html.for_type(types.MethodType, html_formatter_for_builtin_function_or_method)
 73 |         html.for_type(types.ModuleType, html_formatter_for_module)
 74 | 
 75 |         html.for_type(type, html_formatter_for_type)
 76 | 
 77 | 
 78 | def activate_for(obj):
 79 |     ip = get_ipython()
 80 |     html = ip.display_formatter.formatters['text/html']
 81 | 
 82 |     if sys.version_info < (3,6):
 83 |         raise RuntimeError('Sorry need python 3.6 or greater')
 84 |     else:
 85 |         from . import py3only
 86 |     if type(obj) is type:
 87 |         target = obj
 88 |     else:
 89 |         target = type(obj)
 90 | 
 91 |     attr = getattr(py3only, 'html_formatter_for_'+target.__name__.replace('.', '_'))
 92 |     html.for_type(target, attr)
 93 | 
 94 | def gen_help(obj):
 95 |     ip = get_ipython()
 96 |     from . import py3only
 97 |     html = ip.display_formatter.formatters['text/html']
 98 |     html.for_type(type(obj), py3only.gen_help)
 99 | 
100 | 
101 |     
102 | 
103 | config_value = "disp"
104 | shell_key = "extensions"
105 | app_key = "InteractiveShellApp"
106 | 
107 | def get_config():
108 |     ip = get_ipython()
109 | 
110 |     if ip is None:
111 |         profile_dir = paths.locate_profile()
112 |     else:
113 |         profile_dir = ip.profile_dir.location
114 | 
115 |     json_path = path.join(profile_dir, "ipython_config.json")
116 | 
117 |     try:
118 |         with open(json_path, 'r') as f:
119 |             config = json.load(f)
120 |     except (FileNotFoundError, JSONDecodeError):
121 |         config = {}
122 |     return config, json_path
123 | 
124 | 
125 | 
126 | def install():
127 |     """Register `disp` as a default extension for IPython.
128 | 
129 |     When you run this inside IPython, the preference gets applied to the
130 |     current IPython profile. When run using plain Python, the preference gets
131 |     applied to the default profile.
132 | 
133 |     Run `uninstall()` if you ever change your mind and want to revert to the
134 |     default IPython behavior.
135 |     """
136 | 
137 |     cfg, json_path = get_config()
138 | 
139 |     installed = config_value in cfg.get(app_key, {}).get(shell_key, [])
140 | 
141 |     if installed:
142 |         print("😕 Looks like disp is already installed.😕")
143 |         return
144 | 
145 |     with open(json_path, 'w') as f:
146 |         x = cfg.get(app_key, {}).get(shell_key, [])
147 |         x.append(config_value)
148 |         cfg.update({app_key: {shell_key: x}})
149 |         json.dump(cfg, f)
150 | 
151 |     print("💖 Installation succeeded: enjoy disp ! 💖")
152 | 
153 | def uninstall():
154 |     cfg, json_path = get_config()
155 |     if config_value not in cfg.get(app_key, {}).get(shell_key, []):
156 |         print('😕 Disp is not installed. Aborting. 😕')
157 |         return
158 |     with open(json_path, 'w') as f:
159 |         cfg.get(app_key, {}).get(shell_key).remove(config_value)
160 |         json.dump(cfg, f)
161 | 
162 |     print(" 💖 Uninstalled disp. 😢")
163 | 


--------------------------------------------------------------------------------
/disp/vendor.py:
--------------------------------------------------------------------------------
  1 | 
  2 | try:
  3 |     from IPython.core import DataMetadata, RecursiveObject, ReprGetter, get_repr_mimebundle
  4 | except ImportError:
  5 |     from collections import namedtuple
  6 | 
  7 |     class RecursiveObject:
  8 |         """
  9 |         Default recursive object that provides a recursion repr if needed.
 10 | 
 11 |         You may register a formatter for this object that will be call when
 12 |         recursion is reached.
 13 |         """
 14 | 
 15 |         def __init__(self, already_seen):
 16 |             self.seen = already_seen
 17 |             pass
 18 | 
 19 |         def __repr__(self):
 20 |             return '<recursion ... {}>'.format(str(self.seen))
 21 | 
 22 |         def _repr_html_(self):
 23 |             import html
 24 |             return '&lt;recursion ... {}&gt;'.format(html.escape(str(self.seen)))
 25 | 
 26 | 
 27 | 
 28 |     DataMetadata = namedtuple('DataMetadata', ('data','metadata'))
 29 | 
 30 | 
 31 |     class ReprGetter:
 32 |         """
 33 |         Object to carry recursion state when computing formating information when
 34 |         computing rich representation.
 35 | 
 36 |         useful when computing representation concurrently of nested object that may
 37 |         refer to common resources.
 38 |         """
 39 | 
 40 |         __slots__ = ('_objs',)
 41 | 
 42 |         def __init__(self):
 43 |             self._objs = set()
 44 | 
 45 |         def get_repr_mimebundle(self, obj, include=None, exclude=None, *, on_recursion=RecursiveObject):
 46 |             """
 47 |             return the representations of an object and associated metadata.
 48 | 
 49 |             An given object can have many representation available, that can be defined
 50 |             in many ways: `_repr_*_` methods, `_repr_mimebundle_`, or user-registered
 51 |             formatter for types.
 52 | 
 53 |             When given an object, :any:`get_repr_mimebundle` will search for the
 54 |             various formatting option with their associated priority and return the
 55 |             requested representation and associated metadata.
 56 | 
 57 | 
 58 |             Parameters
 59 |             ----------
 60 |             obj : an objects
 61 |                 The Python objects to get the representation data.
 62 |             include : list, tuple or set, optional
 63 |                 A list of format type strings (MIME types) to include in the
 64 |                 format data dict. If this is set *only* the format types included
 65 |                 in this list will be computed.
 66 |             exclude : list, tuple or set, optional
 67 |                 A list of format type strings (MIME types) to exclude in the format
 68 |                 data dict. If this is set all format types will be computed,
 69 |                 except for those included in this argument.
 70 |             on_recursion: callable
 71 |                 Return an object to compute the representation when recursion is
 72 |                 detected.
 73 | 
 74 | 
 75 |             Returns
 76 |             -------
 77 |             (data, metadata) : named tuple of two dicts
 78 | 
 79 |                 - 0/.data: See :any:`DisplayFormatter.format`.
 80 |                 - 1/.metadata: See :any:`DisplayFormatter.format`
 81 | 
 82 |             Note
 83 |             ----
 84 | 
 85 |             When :any:`get_repr_mimebundle` detect it is recursively called, it will
 86 |             attempt to return the representation of :class:`RecursiveObject`. You
 87 |             may register extra formatter for :class:`RecursiveObject`.
 88 | 
 89 |             If you are computing objects representation in a concurrent way (thread,
 90 |             coroutines, ...), you should make sure to instanciate a
 91 |             :class:`ReprGetter` object and use one per task to avoid race conditions.
 92 | 
 93 |             If a specific mimetype formatter need to call `get_repr_mimebundle()`
 94 |             for another mimeformat, then it must pass the mimetypes values it desire
 95 |             to `include` in order to correctly avoid recursion  
 96 | 
 97 |             See Also
 98 |             --------
 99 |                 :func:`display`, :any:`DisplayFormatter.format`
100 | 
101 |             """
102 |             from IPython.core.interactiveshell import InteractiveShell
103 |             if isinstance(include, str):
104 |                 include = (include,)
105 |             if not include:
106 |                 keys = {(id(obj), None)}
107 |             else:
108 |                 keys = {(id(obj), f) for f in include}
109 |             fmt = InteractiveShell.instance().display_formatter.format
110 |             if id(obj) == id(object):
111 |                 return DataMetadata({'text/plain':"<class 'object'>"}, {})
112 |             if self._objs.intersection(keys):
113 |                 return DataMetadata(*fmt(on_recursion(obj), include=include, exclude=exclude))
114 |             else:
115 |                 try:
116 |                     self._objs.update(keys)
117 |                     return DataMetadata(*fmt(obj, include=include, exclude=exclude))
118 |                 finally:
119 |                     self._objs.difference_update(keys)
120 | 
121 |     # Expose this for convenience at the top level. Similar to what the random
122 |     # module in python does. If you want to avoid weird behavior from concurrency:
123 |     #   Instantiate your own.
124 |     get_repr_mimebundle = ReprGetter().get_repr_mimebundle
125 | 


--------------------------------------------------------------------------------
/disp/py3only.py:
--------------------------------------------------------------------------------
  1 | """
  2 | This submodule contains formatting utilities and formatters which will work only
  3 | on Python 3.6+. There is no inherent reasons why it would not work on earlier
  4 | version of Python, it just makes use of features that are 3.6 only – Like
  5 | f-strings – to make the code more readable. Feel free to send patches that makes
  6 | it compatible with earlier versions of python
  7 | """
  8 | 
  9 | 
 10 | from html import escape
 11 | from typing import List
 12 | from IPython.display import HTML
 13 | from .vendor import get_repr_mimebundle
 14 | 
 15 | 
 16 | text_formatter = get_ipython().display_formatter.formatters['text/plain']
 17 | 
 18 | 
 19 | def repr(o):
 20 |     """
 21 |     Alternative implementation of repr, whcih goes through IPython display system from plain-text. 
 22 | 
 23 |     We go directly though the formatter to avoid recursion complication with
 24 |     get_mime_types, ans for a tiny bit more speed.
 25 | 
 26 |     If the real repr is needed, then one need to use builtins.repr
 27 |     """
 28 |     return text_formatter(o)
 29 | 
 30 | 
 31 | # This is the CSS we want to inject before each top-level object. We should
 32 | # (try-to) make it to work with most frontend, as not all frontends do support
 33 | # CSS injection, let's try to not rely on too much customisation
 34 | 
 35 | 
 36 | thecss = """
 37 | 
 38 | /* summary::-webkit-details-marker {
 39 |   display: none;
 40 | }
 41 | 
 42 | summary {
 43 |   text-decoration-line: underline;
 44 |   text-decoration-style: dotted;
 45 |   
 46 | } */
 47 | 
 48 | .rendered_html pre, .rendered_html code {
 49 |     background-color: transparent; /* bug in notebook css */
 50 | }
 51 | 
 52 | .rendered_html .jupyter-extra-info ul{
 53 |     list-style: none;
 54 | }
 55 | 
 56 | .jupyter-extra-info {
 57 |     background-color: hsla(0, 0%, 5%, 0.07); 
 58 |     padding: 0.5em;
 59 |     border: thin solid silver;
 60 | }
 61 | dl.jupyter-inner-mapping-repr {
 62 |     padding-left: 1em;
 63 |     margin-bottom: 0;
 64 | }
 65 | 
 66 | dl.jupyter-inner-mapping-repr > dd {
 67 |     padding-left:2em;
 68 | }
 69 | 
 70 | ul.jupyter-flat-container-repr li > p{
 71 |     padding-left:2em;
 72 |     display: inline;
 73 |     padding: 0;
 74 | }
 75 | 
 76 | ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{
 77 |     list-style-type: none;   
 78 |     display: inline;
 79 |     padding-left: 0;
 80 | }
 81 | 
 82 | ul.jupyter-flat-container-repr > details {
 83 |     display: inline-block;
 84 |     margin-left: -1em;
 85 | }
 86 | 
 87 | ul.jupyter-flat-container-repr li{
 88 |     padding-left:2em;
 89 |     list-style-type: none;
 90 | }
 91 | 
 92 | summary > code {
 93 |     display: inline
 94 | }
 95 | 
 96 | ul.jupyter-flat-container-repr summary {
 97 |     margin-left: 0em;
 98 |     display: inline-block;
 99 | }
100 | 
101 | .rendered_html ul.jupyter-flat-container-repr {
102 |     padding-left: 0px;
103 |     margin-left: 0em;
104 | }
105 | 
106 | .jupyter-flat-container-repr details {
107 |     display: inline;
108 | }
109 | 
110 | .jupyter-flat-container-repr details ~ p {
111 |     margin-top: 0;
112 |     display: inline;
113 | }
114 | 
115 | .jupyter-flat-container-repr details[open] ~ p {
116 |     /*display: block;*/
117 | }
118 | 
119 | details.jupyter-details[open] ~ .jupyter-breaking-placeholder {
120 |     display: block;
121 | }
122 | 
123 | .jupyter-details ~ .jupyter-breaking-placeholder {
124 |     display: inline;
125 | }
126 | .output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {
127 |     margin-left: 1em;
128 | }
129 | """
130 | 
131 | 
132 | ##########################################################################
133 | #                    Utilities                                                  #
134 | ##########################################################################
135 | 
136 | def safe(obj):
137 |     """
138 |     Given an object (str, or html), return an HTML version. 
139 | 
140 |     That is to say, if Object is already an HTML object, return it. If it's a string, escape it. 
141 | 
142 |     """
143 |     if isinstance(obj, HTML):
144 |         return obj
145 |     else:
146 |         return HTML(htmlify_repr(obj))
147 | 
148 | 
149 | def htmlify_repr(obj)-> str:
150 |     """
151 |     Return a string which is safe to embed in html. 
152 | 
153 |     ie, if obj define rerp_html, return this, otherwise escape its text_repr
154 |     """
155 |     return get_repr_mimebundle(obj).data.get('text/html', None) or\
156 |         escape(repr(obj))
157 | 
158 | 
159 | def details(summary, details_):
160 |     if details:
161 |         rsum = safe(summary)._repr_html_()
162 |         rdetails = safe(details_)._repr_html_()
163 |         return HTML(f"<details class='jupyter-details'><summary>{rsum}</summary>{rdetails}</details>")
164 |     else:
165 |         rsum = htmlify_repr(summary)
166 |         return HTML(f"{rsum}")
167 | 
168 | 
169 | def code(string):
170 |     assert isinstance(string, str)
171 |     return HTML(f"<code>{escape(string)}</code>")
172 | 
173 | 
174 | def well(s):
175 |     s = safe(s)._repr_html_()
176 |     return HTML('<div class="jupyter-extra-info">' + s + '</div>')
177 | 
178 | 
179 | ##########################################################################
180 | #                           Formatters                                          #
181 | ##########################################################################
182 | 
183 | 
184 | def html_flat_container(container: List, delims, empty) -> str:
185 |     """Retrun an Html representation of a list with recursive HTML repr for all sub objects. 
186 | 
187 |     If an object does not define an html representation, fallback on plain-text.
188 | 
189 |     """
190 |     if not container:
191 |         return empty
192 |     x = []
193 |     for index, elem in enumerate(container):
194 |         last = (index == len(container) - 1)
195 |         rpr = htmlify_repr(elem)
196 |         pc = '<span class="post-comma">,</span>' if not last else ''
197 |         x.append('<li>{}{}</li>'.format(rpr, pc))
198 |     return f"""<ul class="jupyter-flat-container-repr">
199 |                     <details class='jupyter-details' open>
200 |                         <summary>{delims[0]}</summary>
201 |                         {''.join(x)}
202 |                     </details>
203 |                     <span class='jupyter-breaking-placeholder'></span><p>{delims[1]}</p>
204 |                 </ul>
205 | 
206 |             """
207 | 
208 | 
209 | def html_formatter_for_list(t):
210 |     return html_flat_container(t, delims='[]', empty='[]')
211 | 
212 | 
213 | def html_formatter_for_tuple(t):
214 |     return html_flat_container(t, delims='()', empty='()')
215 | 
216 | 
217 | def html_formatter_for_set(t):
218 |     return html_flat_container(t, delims='{}', empty='set({})')
219 | 
220 | 
221 | def _inner_html_formatter_for_mapping(mapping):
222 |     x = []
223 |     for key, elem in mapping.items():
224 |         mimebundle = get_repr_mimebundle(elem).data
225 |         representation = mimebundle.get(
226 |             'text/html', mimebundle.get('text/html', None)) or escape(repr(elem))
227 |         x.append(f"""<dl class='jupyter-inner-mapping-repr'>
228 |                         <dt><b>{escape(str(key))}:</b></dt>
229 |                         <dd>{representation}</dd>
230 |                     </dl>
231 |                   """)
232 |     return ''.join(x)
233 | 
234 | 
235 | def html_formatter_for_mapping(mapping, *, open=True):
236 |     if not mapping:
237 |         return 'dict({})'
238 |     delims = '{}'
239 |     op = 'open' if open else ''
240 |     return f"""
241 |             <details class='jupyter-details'  {op}>
242 |                 <summary>{delims[0]}</summary>
243 |                 {_inner_html_formatter_for_mapping(mapping)}
244 |             </details>
245 |             {delims[1]}
246 |             """
247 | 
248 | 
249 | html_formatter_for_dict = html_formatter_for_mapping
250 | 
251 | 
252 | def html_formatter_for_Response(req):
253 |     import json
254 |     attrs = None
255 | 
256 |     def in_f(k, v):
257 |         if k == 'headers':
258 |             return HTML(html_formatter_for_mapping(v, open=False))
259 |         else:
260 |             return v
261 | 
262 |     attrs = _inner_html_formatter_for_mapping(
263 |         {k: in_f(k, v) for (k, v) in vars(req).items() if not k.startswith('_')})
264 |     try:
265 |         json_content = req.json()
266 | 
267 |         return f"""
268 |             <style>
269 |                 {thecss}
270 |             </style>
271 |             <details class='jupyter-details'><summary><code>{escape(repr(req))}</code></summary>
272 |                 {attrs}
273 |                  <details class="jupyter-details">
274 |                     <summary>Content (JSON)</summary>
275 |                     {_inner_html_formatter_for_mapping(json_content)}
276 |                  </details>
277 |             </details>
278 |             """
279 | 
280 |     except json.JSONDecodeError:
281 |         return f"""
282 |             <style>
283 |                 {thecss}
284 |             </style>
285 |             <details class='jupyter-details'><summary><code>{escape(repr(req))}</code></summary>
286 |                 {attrs}
287 |             </details>
288 |                 """
289 | 
290 | 
291 | def gen_help(obj):
292 |     doc = next(filter(None, (x.__doc__ for x in type(obj).mro())))
293 |     return f"""
294 |     <code title='{escape(doc)}'>{escape(repr(obj))}<code>
295 |     """
296 | 
297 | 
298 | def general_repr(obj):
299 |     return f'<style>{thecss}</style>' +\
300 |            f'<details class="jupyter-details"><summary><code>{escape(repr(obj))}<code></summary>' +\
301 |            _inner_html_formatter_for_mapping({k: v for (k, v) in vars(obj).items() if not k.startswith('_')}) +\
302 |            '</details>'
303 | 
304 | 
305 | def html_formatter_for_type(obj):
306 |     try:
307 |         mro = obj.mro()  # [o for o in  if o is not object]
308 |     except TypeError:
309 |         mro = ()
310 |     if len(mro) > 1:
311 |         mime = get_repr_mimebundle(mro[1], include='text/html').data
312 |         return f'<style>{thecss}</style>' + \
313 |             f'<details class="jupyter-details" ><summary><code>{escape(repr(obj))}</code></summary>'\
314 |             + well(HTML(f"""
315 |                 <p><code alpha>{obj.__doc__ or ''}</code></p>
316 |                 <p> Inherit from :</p>
317 |                 <ul>
318 |                   <li>{mime.get('text/html')}</li>
319 |                 </ul>"""))._repr_html_()\
320 |             + '</details>'
321 |     else:
322 |         return f'<style>{thecss}</style>' + f'<code>{escape(repr(obj))}</code>'
323 | 
324 | 
325 | def html_formatter_for_builtin_function_or_method(obj):
326 |     ip = get_ipython()
327 |     res = {k: v for (k, v) in ip.inspector.info(obj).items() if v}
328 |     docstring = res.get('docstring')
329 |     res.pop('found')
330 |     res.pop('string_form')
331 |     res.pop('base_class')
332 |     if res.get('definition', None):
333 |         res['definition'] = code(obj.__name__ + res['definition'])
334 |     if docstring != '<no docstring>':
335 |         res['docstring'] = code(docstring)
336 |     else:
337 |         del res['docstring']
338 |     return f'<style>{thecss}</style>' + htmlify_repr(details(code(repr(obj)), well(HTML(_inner_html_formatter_for_mapping(res)))))
339 | 
340 | 
341 | def html_formatter_for_module(obj):
342 |     return f'<style>{thecss}</style>' + details(code(repr(obj)), well(code(obj.__doc__ or '')))._repr_html_()
343 | 


--------------------------------------------------------------------------------
/example/Disp-Example-builtins.ipynb:
--------------------------------------------------------------------------------
   1 | {
   2 |  "cells": [
   3 |   {
   4 |    "cell_type": "markdown",
   5 |    "metadata": {},
   6 |    "source": [
   7 |     "# Disp Example"
   8 |    ]
   9 |   },
  10 |   {
  11 |    "cell_type": "markdown",
  12 |    "metadata": {},
  13 |    "source": [
  14 |     "This is an example on how you can use disp to make the environement you use richer."
  15 |    ]
  16 |   },
  17 |   {
  18 |    "cell_type": "markdown",
  19 |    "metadata": {},
  20 |    "source": [
  21 |     "Let's have a quick look at a nor mal workflow, and how objects are show in the notebook: "
  22 |    ]
  23 |   },
  24 |   {
  25 |    "cell_type": "code",
  26 |    "execution_count": 1,
  27 |    "metadata": {},
  28 |    "outputs": [
  29 |     {
  30 |      "data": {
  31 |       "text/plain": [
  32 |        "IPython.core.interactiveshell.InteractiveShell"
  33 |       ]
  34 |      },
  35 |      "execution_count": 1,
  36 |      "metadata": {},
  37 |      "output_type": "execute_result"
  38 |     }
  39 |    ],
  40 |    "source": [
  41 |     "from IPython.terminal.interactiveshell import InteractiveShell\n",
  42 |     "import disp\n",
  43 |     "InteractiveShell"
  44 |    ]
  45 |   },
  46 |   {
  47 |    "cell_type": "code",
  48 |    "execution_count": 2,
  49 |    "metadata": {},
  50 |    "outputs": [
  51 |     {
  52 |      "data": {
  53 |       "text/plain": [
  54 |        "<function print>"
  55 |       ]
  56 |      },
  57 |      "execution_count": 2,
  58 |      "metadata": {},
  59 |      "output_type": "execute_result"
  60 |     }
  61 |    ],
  62 |    "source": [
  63 |     "print"
  64 |    ]
  65 |   },
  66 |   {
  67 |    "cell_type": "code",
  68 |    "execution_count": 3,
  69 |    "metadata": {},
  70 |    "outputs": [
  71 |     {
  72 |      "data": {
  73 |       "text/plain": [
  74 |        "<module 'disp' from '/Users/bussonniermatthias/dev/disp/disp/__init__.py'>"
  75 |       ]
  76 |      },
  77 |      "execution_count": 3,
  78 |      "metadata": {},
  79 |      "output_type": "execute_result"
  80 |     }
  81 |    ],
  82 |    "source": [
  83 |     "disp"
  84 |    ]
  85 |   },
  86 |   {
  87 |    "cell_type": "markdown",
  88 |    "metadata": {},
  89 |    "source": [
  90 |     "This is a bit boring, and not always informative. Let's enable disp for builtin types. We don't do it by default, as it can be heavily computation intensive and does nto work outside of IPython. It will also make your notebook files way larger. "
  91 |    ]
  92 |   },
  93 |   {
  94 |    "cell_type": "code",
  95 |    "execution_count": 4,
  96 |    "metadata": {},
  97 |    "outputs": [],
  98 |    "source": [
  99 |     "import disp\n",
 100 |     "disp.activate_builtins()"
 101 |    ]
 102 |   },
 103 |   {
 104 |    "cell_type": "markdown",
 105 |    "metadata": {},
 106 |    "source": [
 107 |     "Let's have a look again at previous objects:"
 108 |    ]
 109 |   },
 110 |   {
 111 |    "cell_type": "code",
 112 |    "execution_count": 5,
 113 |    "metadata": {},
 114 |    "outputs": [
 115 |     {
 116 |      "data": {
 117 |       "text/html": [
 118 |        "<style>\n",
 119 |        "\n",
 120 |        "/* summary::-webkit-details-marker {\n",
 121 |        "  display: none;\n",
 122 |        "}\n",
 123 |        "\n",
 124 |        "summary {\n",
 125 |        "  text-decoration-line: underline;\n",
 126 |        "  text-decoration-style: dotted;\n",
 127 |        "  \n",
 128 |        "} */\n",
 129 |        "\n",
 130 |        ".rendered_html pre, .rendered_html code {\n",
 131 |        "    background-color: transparent; /* bug in notebook css */\n",
 132 |        "}\n",
 133 |        "\n",
 134 |        ".rendered_html .jupyter-extra-info ul{\n",
 135 |        "    list-style: none;\n",
 136 |        "}\n",
 137 |        "\n",
 138 |        ".jupyter-extra-info {\n",
 139 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
 140 |        "    padding: 0.5em;\n",
 141 |        "    border: thin solid silver;\n",
 142 |        "}\n",
 143 |        "dl.jupyter-inner-mapping-repr {\n",
 144 |        "    padding-left: 1em;\n",
 145 |        "    margin-bottom: 0;\n",
 146 |        "}\n",
 147 |        "\n",
 148 |        "dl.jupyter-inner-mapping-repr > dd {\n",
 149 |        "    padding-left:2em;\n",
 150 |        "}\n",
 151 |        "\n",
 152 |        "ul.jupyter-flat-container-repr li > p{\n",
 153 |        "    padding-left:2em;\n",
 154 |        "    display: inline;\n",
 155 |        "    padding: 0;\n",
 156 |        "}\n",
 157 |        "\n",
 158 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
 159 |        "    list-style-type: none;   \n",
 160 |        "    display: inline;\n",
 161 |        "    padding-left: 0;\n",
 162 |        "}\n",
 163 |        "\n",
 164 |        "ul.jupyter-flat-container-repr > details {\n",
 165 |        "    display: inline-block;\n",
 166 |        "    margin-left: -1em;\n",
 167 |        "}\n",
 168 |        "\n",
 169 |        "ul.jupyter-flat-container-repr li{\n",
 170 |        "    padding-left:2em;\n",
 171 |        "    list-style-type: none;\n",
 172 |        "}\n",
 173 |        "\n",
 174 |        "summary > code {\n",
 175 |        "    display: inline\n",
 176 |        "}\n",
 177 |        "\n",
 178 |        "ul.jupyter-flat-container-repr summary {\n",
 179 |        "    margin-left: 0em;\n",
 180 |        "    display: inline-block;\n",
 181 |        "}\n",
 182 |        "\n",
 183 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
 184 |        "    padding-left: 0px;\n",
 185 |        "    margin-left: 0em;\n",
 186 |        "}\n",
 187 |        "\n",
 188 |        ".jupyter-flat-container-repr details {\n",
 189 |        "    display: inline;\n",
 190 |        "}\n",
 191 |        "\n",
 192 |        ".jupyter-flat-container-repr details ~ p {\n",
 193 |        "    margin-top: 0;\n",
 194 |        "    display: inline;\n",
 195 |        "}\n",
 196 |        "\n",
 197 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
 198 |        "    /*display: block;*/\n",
 199 |        "}\n",
 200 |        "\n",
 201 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
 202 |        "    display: block;\n",
 203 |        "}\n",
 204 |        "\n",
 205 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
 206 |        "    display: inline;\n",
 207 |        "}\n",
 208 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
 209 |        "    margin-left: 1em;\n",
 210 |        "}\n",
 211 |        "</style><details class=\"jupyter-details\" ><summary><code>IPython.core.interactiveshell.InteractiveShell</code></summary><div class=\"jupyter-extra-info\">\n",
 212 |        "                <p><code alpha>An enhanced, interactive shell for Python.</code></p>\n",
 213 |        "                <p> Inherit from :</p>\n",
 214 |        "                <ul>\n",
 215 |        "                  <li><style>\n",
 216 |        "\n",
 217 |        "/* summary::-webkit-details-marker {\n",
 218 |        "  display: none;\n",
 219 |        "}\n",
 220 |        "\n",
 221 |        "summary {\n",
 222 |        "  text-decoration-line: underline;\n",
 223 |        "  text-decoration-style: dotted;\n",
 224 |        "  \n",
 225 |        "} */\n",
 226 |        "\n",
 227 |        ".rendered_html pre, .rendered_html code {\n",
 228 |        "    background-color: transparent; /* bug in notebook css */\n",
 229 |        "}\n",
 230 |        "\n",
 231 |        ".rendered_html .jupyter-extra-info ul{\n",
 232 |        "    list-style: none;\n",
 233 |        "}\n",
 234 |        "\n",
 235 |        ".jupyter-extra-info {\n",
 236 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
 237 |        "    padding: 0.5em;\n",
 238 |        "    border: thin solid silver;\n",
 239 |        "}\n",
 240 |        "dl.jupyter-inner-mapping-repr {\n",
 241 |        "    padding-left: 1em;\n",
 242 |        "    margin-bottom: 0;\n",
 243 |        "}\n",
 244 |        "\n",
 245 |        "dl.jupyter-inner-mapping-repr > dd {\n",
 246 |        "    padding-left:2em;\n",
 247 |        "}\n",
 248 |        "\n",
 249 |        "ul.jupyter-flat-container-repr li > p{\n",
 250 |        "    padding-left:2em;\n",
 251 |        "    display: inline;\n",
 252 |        "    padding: 0;\n",
 253 |        "}\n",
 254 |        "\n",
 255 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
 256 |        "    list-style-type: none;   \n",
 257 |        "    display: inline;\n",
 258 |        "    padding-left: 0;\n",
 259 |        "}\n",
 260 |        "\n",
 261 |        "ul.jupyter-flat-container-repr > details {\n",
 262 |        "    display: inline-block;\n",
 263 |        "    margin-left: -1em;\n",
 264 |        "}\n",
 265 |        "\n",
 266 |        "ul.jupyter-flat-container-repr li{\n",
 267 |        "    padding-left:2em;\n",
 268 |        "    list-style-type: none;\n",
 269 |        "}\n",
 270 |        "\n",
 271 |        "summary > code {\n",
 272 |        "    display: inline\n",
 273 |        "}\n",
 274 |        "\n",
 275 |        "ul.jupyter-flat-container-repr summary {\n",
 276 |        "    margin-left: 0em;\n",
 277 |        "    display: inline-block;\n",
 278 |        "}\n",
 279 |        "\n",
 280 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
 281 |        "    padding-left: 0px;\n",
 282 |        "    margin-left: 0em;\n",
 283 |        "}\n",
 284 |        "\n",
 285 |        ".jupyter-flat-container-repr details {\n",
 286 |        "    display: inline;\n",
 287 |        "}\n",
 288 |        "\n",
 289 |        ".jupyter-flat-container-repr details ~ p {\n",
 290 |        "    margin-top: 0;\n",
 291 |        "    display: inline;\n",
 292 |        "}\n",
 293 |        "\n",
 294 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
 295 |        "    /*display: block;*/\n",
 296 |        "}\n",
 297 |        "\n",
 298 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
 299 |        "    display: block;\n",
 300 |        "}\n",
 301 |        "\n",
 302 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
 303 |        "    display: inline;\n",
 304 |        "}\n",
 305 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
 306 |        "    margin-left: 1em;\n",
 307 |        "}\n",
 308 |        "</style><details class=\"jupyter-details\" ><summary><code>traitlets.config.configurable.SingletonConfigurable</code></summary><div class=\"jupyter-extra-info\">\n",
 309 |        "                <p><code alpha>A configurable that only allows one instance.\n",
 310 |        "\n",
 311 |        "    This class is for classes that should only have one instance of itself\n",
 312 |        "    or *any* subclass. To create and retrieve such a class use the\n",
 313 |        "    :meth:`SingletonConfigurable.instance` method.\n",
 314 |        "    </code></p>\n",
 315 |        "                <p> Inherit from :</p>\n",
 316 |        "                <ul>\n",
 317 |        "                  <li><style>\n",
 318 |        "\n",
 319 |        "/* summary::-webkit-details-marker {\n",
 320 |        "  display: none;\n",
 321 |        "}\n",
 322 |        "\n",
 323 |        "summary {\n",
 324 |        "  text-decoration-line: underline;\n",
 325 |        "  text-decoration-style: dotted;\n",
 326 |        "  \n",
 327 |        "} */\n",
 328 |        "\n",
 329 |        ".rendered_html pre, .rendered_html code {\n",
 330 |        "    background-color: transparent; /* bug in notebook css */\n",
 331 |        "}\n",
 332 |        "\n",
 333 |        ".rendered_html .jupyter-extra-info ul{\n",
 334 |        "    list-style: none;\n",
 335 |        "}\n",
 336 |        "\n",
 337 |        ".jupyter-extra-info {\n",
 338 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
 339 |        "    padding: 0.5em;\n",
 340 |        "    border: thin solid silver;\n",
 341 |        "}\n",
 342 |        "dl.jupyter-inner-mapping-repr {\n",
 343 |        "    padding-left: 1em;\n",
 344 |        "    margin-bottom: 0;\n",
 345 |        "}\n",
 346 |        "\n",
 347 |        "dl.jupyter-inner-mapping-repr > dd {\n",
 348 |        "    padding-left:2em;\n",
 349 |        "}\n",
 350 |        "\n",
 351 |        "ul.jupyter-flat-container-repr li > p{\n",
 352 |        "    padding-left:2em;\n",
 353 |        "    display: inline;\n",
 354 |        "    padding: 0;\n",
 355 |        "}\n",
 356 |        "\n",
 357 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
 358 |        "    list-style-type: none;   \n",
 359 |        "    display: inline;\n",
 360 |        "    padding-left: 0;\n",
 361 |        "}\n",
 362 |        "\n",
 363 |        "ul.jupyter-flat-container-repr > details {\n",
 364 |        "    display: inline-block;\n",
 365 |        "    margin-left: -1em;\n",
 366 |        "}\n",
 367 |        "\n",
 368 |        "ul.jupyter-flat-container-repr li{\n",
 369 |        "    padding-left:2em;\n",
 370 |        "    list-style-type: none;\n",
 371 |        "}\n",
 372 |        "\n",
 373 |        "summary > code {\n",
 374 |        "    display: inline\n",
 375 |        "}\n",
 376 |        "\n",
 377 |        "ul.jupyter-flat-container-repr summary {\n",
 378 |        "    margin-left: 0em;\n",
 379 |        "    display: inline-block;\n",
 380 |        "}\n",
 381 |        "\n",
 382 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
 383 |        "    padding-left: 0px;\n",
 384 |        "    margin-left: 0em;\n",
 385 |        "}\n",
 386 |        "\n",
 387 |        ".jupyter-flat-container-repr details {\n",
 388 |        "    display: inline;\n",
 389 |        "}\n",
 390 |        "\n",
 391 |        ".jupyter-flat-container-repr details ~ p {\n",
 392 |        "    margin-top: 0;\n",
 393 |        "    display: inline;\n",
 394 |        "}\n",
 395 |        "\n",
 396 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
 397 |        "    /*display: block;*/\n",
 398 |        "}\n",
 399 |        "\n",
 400 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
 401 |        "    display: block;\n",
 402 |        "}\n",
 403 |        "\n",
 404 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
 405 |        "    display: inline;\n",
 406 |        "}\n",
 407 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
 408 |        "    margin-left: 1em;\n",
 409 |        "}\n",
 410 |        "</style><details class=\"jupyter-details\" ><summary><code>traitlets.config.configurable.LoggingConfigurable</code></summary><div class=\"jupyter-extra-info\">\n",
 411 |        "                <p><code alpha>A parent class for Configurables that log.\n",
 412 |        "\n",
 413 |        "    Subclasses have a log trait, and the default behavior\n",
 414 |        "    is to get the logger from the currently running Application.\n",
 415 |        "    </code></p>\n",
 416 |        "                <p> Inherit from :</p>\n",
 417 |        "                <ul>\n",
 418 |        "                  <li><style>\n",
 419 |        "\n",
 420 |        "/* summary::-webkit-details-marker {\n",
 421 |        "  display: none;\n",
 422 |        "}\n",
 423 |        "\n",
 424 |        "summary {\n",
 425 |        "  text-decoration-line: underline;\n",
 426 |        "  text-decoration-style: dotted;\n",
 427 |        "  \n",
 428 |        "} */\n",
 429 |        "\n",
 430 |        ".rendered_html pre, .rendered_html code {\n",
 431 |        "    background-color: transparent; /* bug in notebook css */\n",
 432 |        "}\n",
 433 |        "\n",
 434 |        ".rendered_html .jupyter-extra-info ul{\n",
 435 |        "    list-style: none;\n",
 436 |        "}\n",
 437 |        "\n",
 438 |        ".jupyter-extra-info {\n",
 439 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
 440 |        "    padding: 0.5em;\n",
 441 |        "    border: thin solid silver;\n",
 442 |        "}\n",
 443 |        "dl.jupyter-inner-mapping-repr {\n",
 444 |        "    padding-left: 1em;\n",
 445 |        "    margin-bottom: 0;\n",
 446 |        "}\n",
 447 |        "\n",
 448 |        "dl.jupyter-inner-mapping-repr > dd {\n",
 449 |        "    padding-left:2em;\n",
 450 |        "}\n",
 451 |        "\n",
 452 |        "ul.jupyter-flat-container-repr li > p{\n",
 453 |        "    padding-left:2em;\n",
 454 |        "    display: inline;\n",
 455 |        "    padding: 0;\n",
 456 |        "}\n",
 457 |        "\n",
 458 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
 459 |        "    list-style-type: none;   \n",
 460 |        "    display: inline;\n",
 461 |        "    padding-left: 0;\n",
 462 |        "}\n",
 463 |        "\n",
 464 |        "ul.jupyter-flat-container-repr > details {\n",
 465 |        "    display: inline-block;\n",
 466 |        "    margin-left: -1em;\n",
 467 |        "}\n",
 468 |        "\n",
 469 |        "ul.jupyter-flat-container-repr li{\n",
 470 |        "    padding-left:2em;\n",
 471 |        "    list-style-type: none;\n",
 472 |        "}\n",
 473 |        "\n",
 474 |        "summary > code {\n",
 475 |        "    display: inline\n",
 476 |        "}\n",
 477 |        "\n",
 478 |        "ul.jupyter-flat-container-repr summary {\n",
 479 |        "    margin-left: 0em;\n",
 480 |        "    display: inline-block;\n",
 481 |        "}\n",
 482 |        "\n",
 483 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
 484 |        "    padding-left: 0px;\n",
 485 |        "    margin-left: 0em;\n",
 486 |        "}\n",
 487 |        "\n",
 488 |        ".jupyter-flat-container-repr details {\n",
 489 |        "    display: inline;\n",
 490 |        "}\n",
 491 |        "\n",
 492 |        ".jupyter-flat-container-repr details ~ p {\n",
 493 |        "    margin-top: 0;\n",
 494 |        "    display: inline;\n",
 495 |        "}\n",
 496 |        "\n",
 497 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
 498 |        "    /*display: block;*/\n",
 499 |        "}\n",
 500 |        "\n",
 501 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
 502 |        "    display: block;\n",
 503 |        "}\n",
 504 |        "\n",
 505 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
 506 |        "    display: inline;\n",
 507 |        "}\n",
 508 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
 509 |        "    margin-left: 1em;\n",
 510 |        "}\n",
 511 |        "</style><details class=\"jupyter-details\" ><summary><code>traitlets.config.configurable.Configurable</code></summary><div class=\"jupyter-extra-info\">\n",
 512 |        "                <p><code alpha></code></p>\n",
 513 |        "                <p> Inherit from :</p>\n",
 514 |        "                <ul>\n",
 515 |        "                  <li><style>\n",
 516 |        "\n",
 517 |        "/* summary::-webkit-details-marker {\n",
 518 |        "  display: none;\n",
 519 |        "}\n",
 520 |        "\n",
 521 |        "summary {\n",
 522 |        "  text-decoration-line: underline;\n",
 523 |        "  text-decoration-style: dotted;\n",
 524 |        "  \n",
 525 |        "} */\n",
 526 |        "\n",
 527 |        ".rendered_html pre, .rendered_html code {\n",
 528 |        "    background-color: transparent; /* bug in notebook css */\n",
 529 |        "}\n",
 530 |        "\n",
 531 |        ".rendered_html .jupyter-extra-info ul{\n",
 532 |        "    list-style: none;\n",
 533 |        "}\n",
 534 |        "\n",
 535 |        ".jupyter-extra-info {\n",
 536 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
 537 |        "    padding: 0.5em;\n",
 538 |        "    border: thin solid silver;\n",
 539 |        "}\n",
 540 |        "dl.jupyter-inner-mapping-repr {\n",
 541 |        "    padding-left: 1em;\n",
 542 |        "    margin-bottom: 0;\n",
 543 |        "}\n",
 544 |        "\n",
 545 |        "dl.jupyter-inner-mapping-repr > dd {\n",
 546 |        "    padding-left:2em;\n",
 547 |        "}\n",
 548 |        "\n",
 549 |        "ul.jupyter-flat-container-repr li > p{\n",
 550 |        "    padding-left:2em;\n",
 551 |        "    display: inline;\n",
 552 |        "    padding: 0;\n",
 553 |        "}\n",
 554 |        "\n",
 555 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
 556 |        "    list-style-type: none;   \n",
 557 |        "    display: inline;\n",
 558 |        "    padding-left: 0;\n",
 559 |        "}\n",
 560 |        "\n",
 561 |        "ul.jupyter-flat-container-repr > details {\n",
 562 |        "    display: inline-block;\n",
 563 |        "    margin-left: -1em;\n",
 564 |        "}\n",
 565 |        "\n",
 566 |        "ul.jupyter-flat-container-repr li{\n",
 567 |        "    padding-left:2em;\n",
 568 |        "    list-style-type: none;\n",
 569 |        "}\n",
 570 |        "\n",
 571 |        "summary > code {\n",
 572 |        "    display: inline\n",
 573 |        "}\n",
 574 |        "\n",
 575 |        "ul.jupyter-flat-container-repr summary {\n",
 576 |        "    margin-left: 0em;\n",
 577 |        "    display: inline-block;\n",
 578 |        "}\n",
 579 |        "\n",
 580 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
 581 |        "    padding-left: 0px;\n",
 582 |        "    margin-left: 0em;\n",
 583 |        "}\n",
 584 |        "\n",
 585 |        ".jupyter-flat-container-repr details {\n",
 586 |        "    display: inline;\n",
 587 |        "}\n",
 588 |        "\n",
 589 |        ".jupyter-flat-container-repr details ~ p {\n",
 590 |        "    margin-top: 0;\n",
 591 |        "    display: inline;\n",
 592 |        "}\n",
 593 |        "\n",
 594 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
 595 |        "    /*display: block;*/\n",
 596 |        "}\n",
 597 |        "\n",
 598 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
 599 |        "    display: block;\n",
 600 |        "}\n",
 601 |        "\n",
 602 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
 603 |        "    display: inline;\n",
 604 |        "}\n",
 605 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
 606 |        "    margin-left: 1em;\n",
 607 |        "}\n",
 608 |        "</style><details class=\"jupyter-details\" ><summary><code>traitlets.traitlets.HasTraits</code></summary><div class=\"jupyter-extra-info\">\n",
 609 |        "                <p><code alpha></code></p>\n",
 610 |        "                <p> Inherit from :</p>\n",
 611 |        "                <ul>\n",
 612 |        "                  <li><style>\n",
 613 |        "\n",
 614 |        "/* summary::-webkit-details-marker {\n",
 615 |        "  display: none;\n",
 616 |        "}\n",
 617 |        "\n",
 618 |        "summary {\n",
 619 |        "  text-decoration-line: underline;\n",
 620 |        "  text-decoration-style: dotted;\n",
 621 |        "  \n",
 622 |        "} */\n",
 623 |        "\n",
 624 |        ".rendered_html pre, .rendered_html code {\n",
 625 |        "    background-color: transparent; /* bug in notebook css */\n",
 626 |        "}\n",
 627 |        "\n",
 628 |        ".rendered_html .jupyter-extra-info ul{\n",
 629 |        "    list-style: none;\n",
 630 |        "}\n",
 631 |        "\n",
 632 |        ".jupyter-extra-info {\n",
 633 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
 634 |        "    padding: 0.5em;\n",
 635 |        "    border: thin solid silver;\n",
 636 |        "}\n",
 637 |        "dl.jupyter-inner-mapping-repr {\n",
 638 |        "    padding-left: 1em;\n",
 639 |        "    margin-bottom: 0;\n",
 640 |        "}\n",
 641 |        "\n",
 642 |        "dl.jupyter-inner-mapping-repr > dd {\n",
 643 |        "    padding-left:2em;\n",
 644 |        "}\n",
 645 |        "\n",
 646 |        "ul.jupyter-flat-container-repr li > p{\n",
 647 |        "    padding-left:2em;\n",
 648 |        "    display: inline;\n",
 649 |        "    padding: 0;\n",
 650 |        "}\n",
 651 |        "\n",
 652 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
 653 |        "    list-style-type: none;   \n",
 654 |        "    display: inline;\n",
 655 |        "    padding-left: 0;\n",
 656 |        "}\n",
 657 |        "\n",
 658 |        "ul.jupyter-flat-container-repr > details {\n",
 659 |        "    display: inline-block;\n",
 660 |        "    margin-left: -1em;\n",
 661 |        "}\n",
 662 |        "\n",
 663 |        "ul.jupyter-flat-container-repr li{\n",
 664 |        "    padding-left:2em;\n",
 665 |        "    list-style-type: none;\n",
 666 |        "}\n",
 667 |        "\n",
 668 |        "summary > code {\n",
 669 |        "    display: inline\n",
 670 |        "}\n",
 671 |        "\n",
 672 |        "ul.jupyter-flat-container-repr summary {\n",
 673 |        "    margin-left: 0em;\n",
 674 |        "    display: inline-block;\n",
 675 |        "}\n",
 676 |        "\n",
 677 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
 678 |        "    padding-left: 0px;\n",
 679 |        "    margin-left: 0em;\n",
 680 |        "}\n",
 681 |        "\n",
 682 |        ".jupyter-flat-container-repr details {\n",
 683 |        "    display: inline;\n",
 684 |        "}\n",
 685 |        "\n",
 686 |        ".jupyter-flat-container-repr details ~ p {\n",
 687 |        "    margin-top: 0;\n",
 688 |        "    display: inline;\n",
 689 |        "}\n",
 690 |        "\n",
 691 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
 692 |        "    /*display: block;*/\n",
 693 |        "}\n",
 694 |        "\n",
 695 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
 696 |        "    display: block;\n",
 697 |        "}\n",
 698 |        "\n",
 699 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
 700 |        "    display: inline;\n",
 701 |        "}\n",
 702 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
 703 |        "    margin-left: 1em;\n",
 704 |        "}\n",
 705 |        "</style><details class=\"jupyter-details\" ><summary><code>traitlets.traitlets.HasDescriptors</code></summary><div class=\"jupyter-extra-info\">\n",
 706 |        "                <p><code alpha>The base class for all classes that have descriptors.\n",
 707 |        "    </code></p>\n",
 708 |        "                <p> Inherit from :</p>\n",
 709 |        "                <ul>\n",
 710 |        "                  <li>None</li>\n",
 711 |        "                </ul></div></details></li>\n",
 712 |        "                </ul></div></details></li>\n",
 713 |        "                </ul></div></details></li>\n",
 714 |        "                </ul></div></details></li>\n",
 715 |        "                </ul></div></details></li>\n",
 716 |        "                </ul></div></details>"
 717 |       ],
 718 |       "text/plain": [
 719 |        "IPython.core.interactiveshell.InteractiveShell"
 720 |       ]
 721 |      },
 722 |      "execution_count": 5,
 723 |      "metadata": {},
 724 |      "output_type": "execute_result"
 725 |     }
 726 |    ],
 727 |    "source": [
 728 |     "InteractiveShell"
 729 |    ]
 730 |   },
 731 |   {
 732 |    "cell_type": "markdown",
 733 |    "metadata": {},
 734 |    "source": [
 735 |     "You should see now (at least if you are in an interactive environement) a small triangle in front of `IPython.core.interactiveshell.InteractiveShell`, if you click on it, the output will expand to show you the documentation as well as the inheritence (Actually the MRO... but details for now)."
 736 |    ]
 737 |   },
 738 |   {
 739 |    "cell_type": "code",
 740 |    "execution_count": 6,
 741 |    "metadata": {},
 742 |    "outputs": [
 743 |     {
 744 |      "data": {
 745 |       "text/html": [
 746 |        "<style>\n",
 747 |        "\n",
 748 |        "/* summary::-webkit-details-marker {\n",
 749 |        "  display: none;\n",
 750 |        "}\n",
 751 |        "\n",
 752 |        "summary {\n",
 753 |        "  text-decoration-line: underline;\n",
 754 |        "  text-decoration-style: dotted;\n",
 755 |        "  \n",
 756 |        "} */\n",
 757 |        "\n",
 758 |        ".rendered_html pre, .rendered_html code {\n",
 759 |        "    background-color: transparent; /* bug in notebook css */\n",
 760 |        "}\n",
 761 |        "\n",
 762 |        ".rendered_html .jupyter-extra-info ul{\n",
 763 |        "    list-style: none;\n",
 764 |        "}\n",
 765 |        "\n",
 766 |        ".jupyter-extra-info {\n",
 767 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
 768 |        "    padding: 0.5em;\n",
 769 |        "    border: thin solid silver;\n",
 770 |        "}\n",
 771 |        "dl.jupyter-inner-mapping-repr {\n",
 772 |        "    padding-left: 1em;\n",
 773 |        "    margin-bottom: 0;\n",
 774 |        "}\n",
 775 |        "\n",
 776 |        "dl.jupyter-inner-mapping-repr > dd {\n",
 777 |        "    padding-left:2em;\n",
 778 |        "}\n",
 779 |        "\n",
 780 |        "ul.jupyter-flat-container-repr li > p{\n",
 781 |        "    padding-left:2em;\n",
 782 |        "    display: inline;\n",
 783 |        "    padding: 0;\n",
 784 |        "}\n",
 785 |        "\n",
 786 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
 787 |        "    list-style-type: none;   \n",
 788 |        "    display: inline;\n",
 789 |        "    padding-left: 0;\n",
 790 |        "}\n",
 791 |        "\n",
 792 |        "ul.jupyter-flat-container-repr > details {\n",
 793 |        "    display: inline-block;\n",
 794 |        "    margin-left: -1em;\n",
 795 |        "}\n",
 796 |        "\n",
 797 |        "ul.jupyter-flat-container-repr li{\n",
 798 |        "    padding-left:2em;\n",
 799 |        "    list-style-type: none;\n",
 800 |        "}\n",
 801 |        "\n",
 802 |        "summary > code {\n",
 803 |        "    display: inline\n",
 804 |        "}\n",
 805 |        "\n",
 806 |        "ul.jupyter-flat-container-repr summary {\n",
 807 |        "    margin-left: 0em;\n",
 808 |        "    display: inline-block;\n",
 809 |        "}\n",
 810 |        "\n",
 811 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
 812 |        "    padding-left: 0px;\n",
 813 |        "    margin-left: 0em;\n",
 814 |        "}\n",
 815 |        "\n",
 816 |        ".jupyter-flat-container-repr details {\n",
 817 |        "    display: inline;\n",
 818 |        "}\n",
 819 |        "\n",
 820 |        ".jupyter-flat-container-repr details ~ p {\n",
 821 |        "    margin-top: 0;\n",
 822 |        "    display: inline;\n",
 823 |        "}\n",
 824 |        "\n",
 825 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
 826 |        "    /*display: block;*/\n",
 827 |        "}\n",
 828 |        "\n",
 829 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
 830 |        "    display: block;\n",
 831 |        "}\n",
 832 |        "\n",
 833 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
 834 |        "    display: inline;\n",
 835 |        "}\n",
 836 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
 837 |        "    margin-left: 1em;\n",
 838 |        "}\n",
 839 |        "</style><details class='jupyter-details'><summary><code>&lt;function print&gt;</code></summary><div class=\"jupyter-extra-info\"><dl class='jupyter-inner-mapping-repr'>\n",
 840 |        "                        <dt><b>type_name:</b></dt>\n",
 841 |        "                        <dd>&#x27;builtin_function_or_method&#x27;</dd>\n",
 842 |        "                    </dl>\n",
 843 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
 844 |        "                        <dt><b>docstring:</b></dt>\n",
 845 |        "                        <dd><code>print(value, ..., sep=&#x27; &#x27;, end=&#x27;\\n&#x27;, file=sys.stdout, flush=False)\n",
 846 |        "\n",
 847 |        "Prints the values to a stream, or to sys.stdout by default.\n",
 848 |        "Optional keyword arguments:\n",
 849 |        "file:  a file-like object (stream); defaults to the current sys.stdout.\n",
 850 |        "sep:   string inserted between values, default a space.\n",
 851 |        "end:   string appended after the last value, default a newline.\n",
 852 |        "flush: whether to forcibly flush the stream.</code></dd>\n",
 853 |        "                    </dl>\n",
 854 |        "                  </div></details>"
 855 |       ],
 856 |       "text/plain": [
 857 |        "<function print>"
 858 |       ]
 859 |      },
 860 |      "execution_count": 6,
 861 |      "metadata": {},
 862 |      "output_type": "execute_result"
 863 |     }
 864 |    ],
 865 |    "source": [
 866 |     "print"
 867 |    ]
 868 |   },
 869 |   {
 870 |    "cell_type": "markdown",
 871 |    "metadata": {},
 872 |    "source": [
 873 |     "Print wil have the same treatment, with an overview of the documetation. You can still use `?`/`??` to get more information. "
 874 |    ]
 875 |   },
 876 |   {
 877 |    "cell_type": "code",
 878 |    "execution_count": 7,
 879 |    "metadata": {},
 880 |    "outputs": [
 881 |     {
 882 |      "data": {
 883 |       "text/html": [
 884 |        "<style>\n",
 885 |        "\n",
 886 |        "/* summary::-webkit-details-marker {\n",
 887 |        "  display: none;\n",
 888 |        "}\n",
 889 |        "\n",
 890 |        "summary {\n",
 891 |        "  text-decoration-line: underline;\n",
 892 |        "  text-decoration-style: dotted;\n",
 893 |        "  \n",
 894 |        "} */\n",
 895 |        "\n",
 896 |        ".rendered_html pre, .rendered_html code {\n",
 897 |        "    background-color: transparent; /* bug in notebook css */\n",
 898 |        "}\n",
 899 |        "\n",
 900 |        ".rendered_html .jupyter-extra-info ul{\n",
 901 |        "    list-style: none;\n",
 902 |        "}\n",
 903 |        "\n",
 904 |        ".jupyter-extra-info {\n",
 905 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
 906 |        "    padding: 0.5em;\n",
 907 |        "    border: thin solid silver;\n",
 908 |        "}\n",
 909 |        "dl.jupyter-inner-mapping-repr {\n",
 910 |        "    padding-left: 1em;\n",
 911 |        "    margin-bottom: 0;\n",
 912 |        "}\n",
 913 |        "\n",
 914 |        "dl.jupyter-inner-mapping-repr > dd {\n",
 915 |        "    padding-left:2em;\n",
 916 |        "}\n",
 917 |        "\n",
 918 |        "ul.jupyter-flat-container-repr li > p{\n",
 919 |        "    padding-left:2em;\n",
 920 |        "    display: inline;\n",
 921 |        "    padding: 0;\n",
 922 |        "}\n",
 923 |        "\n",
 924 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
 925 |        "    list-style-type: none;   \n",
 926 |        "    display: inline;\n",
 927 |        "    padding-left: 0;\n",
 928 |        "}\n",
 929 |        "\n",
 930 |        "ul.jupyter-flat-container-repr > details {\n",
 931 |        "    display: inline-block;\n",
 932 |        "    margin-left: -1em;\n",
 933 |        "}\n",
 934 |        "\n",
 935 |        "ul.jupyter-flat-container-repr li{\n",
 936 |        "    padding-left:2em;\n",
 937 |        "    list-style-type: none;\n",
 938 |        "}\n",
 939 |        "\n",
 940 |        "summary > code {\n",
 941 |        "    display: inline\n",
 942 |        "}\n",
 943 |        "\n",
 944 |        "ul.jupyter-flat-container-repr summary {\n",
 945 |        "    margin-left: 0em;\n",
 946 |        "    display: inline-block;\n",
 947 |        "}\n",
 948 |        "\n",
 949 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
 950 |        "    padding-left: 0px;\n",
 951 |        "    margin-left: 0em;\n",
 952 |        "}\n",
 953 |        "\n",
 954 |        ".jupyter-flat-container-repr details {\n",
 955 |        "    display: inline;\n",
 956 |        "}\n",
 957 |        "\n",
 958 |        ".jupyter-flat-container-repr details ~ p {\n",
 959 |        "    margin-top: 0;\n",
 960 |        "    display: inline;\n",
 961 |        "}\n",
 962 |        "\n",
 963 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
 964 |        "    /*display: block;*/\n",
 965 |        "}\n",
 966 |        "\n",
 967 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
 968 |        "    display: block;\n",
 969 |        "}\n",
 970 |        "\n",
 971 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
 972 |        "    display: inline;\n",
 973 |        "}\n",
 974 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
 975 |        "    margin-left: 1em;\n",
 976 |        "}\n",
 977 |        "</style><details class='jupyter-details'><summary><code>&lt;module &#x27;disp&#x27; from &#x27;/Users/bussonniermatthias/dev/disp/disp/__init__.py&#x27;&gt;</code></summary><div class=\"jupyter-extra-info\"><code>\n",
 978 |        "Rich display for a variety of Python objects.\n",
 979 |        "\n",
 980 |        "Use the followign to enable permanently.\n",
 981 |        "\n",
 982 |        "&gt;&gt;&gt; import disp; disp.install()\n",
 983 |        "\n",
 984 |        "\n",
 985 |        "The following activate rich repr on a couple of builtins types:\n",
 986 |        "\n",
 987 |        "    - functions/methods\n",
 988 |        "    - types\n",
 989 |        "    - modules\n",
 990 |        "\n",
 991 |        "&gt;&gt;&gt; import disp; disp.activate_builtins()\n",
 992 |        "\n",
 993 |        "As this may have side-effect the setting does not persist across sessions\n",
 994 |        "\n",
 995 |        "\n",
 996 |        "Some object are not enabled by default, you can activate with:\n",
 997 |        "\n",
 998 |        "&gt;&gt;&gt; import disp; disp.activate_for(something)\n",
 999 |        "\n",
1000 |        "For example, a `requests`&#x27;s response. \n",
1001 |        "\n",
1002 |        "&gt;&gt;&gt; import requests\n",
1003 |        "&gt;&gt;&gt; response = requests.get(...)\n",
1004 |        "&gt;&gt;&gt; disp.activate+for(response)\n",
1005 |        "&gt;&gt;&gt; response\n",
1006 |        "\n",
1007 |        "\n",
1008 |        "</code></div></details>"
1009 |       ],
1010 |       "text/plain": [
1011 |        "<module 'disp' from '/Users/bussonniermatthias/dev/disp/disp/__init__.py'>"
1012 |       ]
1013 |      },
1014 |      "execution_count": 7,
1015 |      "metadata": {},
1016 |      "output_type": "execute_result"
1017 |     }
1018 |    ],
1019 |    "source": [
1020 |     "disp"
1021 |    ]
1022 |   },
1023 |   {
1024 |    "cell_type": "markdown",
1025 |    "metadata": {},
1026 |    "source": [
1027 |     "If modules have docstrings, they will be shown as well. "
1028 |    ]
1029 |   },
1030 |   {
1031 |    "cell_type": "markdown",
1032 |    "metadata": {},
1033 |    "source": [
1034 |     "##  Requests"
1035 |    ]
1036 |   },
1037 |   {
1038 |    "cell_type": "markdown",
1039 |    "metadata": {},
1040 |    "source": [
1041 |     "Above are generic objects, `disp` also have special casing for some objects, example `requests` replies. "
1042 |    ]
1043 |   },
1044 |   {
1045 |    "cell_type": "code",
1046 |    "execution_count": 8,
1047 |    "metadata": {},
1048 |    "outputs": [],
1049 |    "source": [
1050 |     "import requests\n",
1051 |     "import requests_cache\n",
1052 |     "requests_cache.install_cache('tmpcache.db')\n",
1053 |     "\n",
1054 |     "res = requests.get('https://api.github.com/aoisehgd')"
1055 |    ]
1056 |   },
1057 |   {
1058 |    "cell_type": "markdown",
1059 |    "metadata": {},
1060 |    "source": [
1061 |     "`get` is still a generic function, so will show its doc:"
1062 |    ]
1063 |   },
1064 |   {
1065 |    "cell_type": "code",
1066 |    "execution_count": 9,
1067 |    "metadata": {},
1068 |    "outputs": [
1069 |     {
1070 |      "data": {
1071 |       "text/html": [
1072 |        "<style>\n",
1073 |        "\n",
1074 |        "/* summary::-webkit-details-marker {\n",
1075 |        "  display: none;\n",
1076 |        "}\n",
1077 |        "\n",
1078 |        "summary {\n",
1079 |        "  text-decoration-line: underline;\n",
1080 |        "  text-decoration-style: dotted;\n",
1081 |        "  \n",
1082 |        "} */\n",
1083 |        "\n",
1084 |        ".rendered_html pre, .rendered_html code {\n",
1085 |        "    background-color: transparent; /* bug in notebook css */\n",
1086 |        "}\n",
1087 |        "\n",
1088 |        ".rendered_html .jupyter-extra-info ul{\n",
1089 |        "    list-style: none;\n",
1090 |        "}\n",
1091 |        "\n",
1092 |        ".jupyter-extra-info {\n",
1093 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
1094 |        "    padding: 0.5em;\n",
1095 |        "    border: thin solid silver;\n",
1096 |        "}\n",
1097 |        "dl.jupyter-inner-mapping-repr {\n",
1098 |        "    padding-left: 1em;\n",
1099 |        "    margin-bottom: 0;\n",
1100 |        "}\n",
1101 |        "\n",
1102 |        "dl.jupyter-inner-mapping-repr > dd {\n",
1103 |        "    padding-left:2em;\n",
1104 |        "}\n",
1105 |        "\n",
1106 |        "ul.jupyter-flat-container-repr li > p{\n",
1107 |        "    padding-left:2em;\n",
1108 |        "    display: inline;\n",
1109 |        "    padding: 0;\n",
1110 |        "}\n",
1111 |        "\n",
1112 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
1113 |        "    list-style-type: none;   \n",
1114 |        "    display: inline;\n",
1115 |        "    padding-left: 0;\n",
1116 |        "}\n",
1117 |        "\n",
1118 |        "ul.jupyter-flat-container-repr > details {\n",
1119 |        "    display: inline-block;\n",
1120 |        "    margin-left: -1em;\n",
1121 |        "}\n",
1122 |        "\n",
1123 |        "ul.jupyter-flat-container-repr li{\n",
1124 |        "    padding-left:2em;\n",
1125 |        "    list-style-type: none;\n",
1126 |        "}\n",
1127 |        "\n",
1128 |        "summary > code {\n",
1129 |        "    display: inline\n",
1130 |        "}\n",
1131 |        "\n",
1132 |        "ul.jupyter-flat-container-repr summary {\n",
1133 |        "    margin-left: 0em;\n",
1134 |        "    display: inline-block;\n",
1135 |        "}\n",
1136 |        "\n",
1137 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
1138 |        "    padding-left: 0px;\n",
1139 |        "    margin-left: 0em;\n",
1140 |        "}\n",
1141 |        "\n",
1142 |        ".jupyter-flat-container-repr details {\n",
1143 |        "    display: inline;\n",
1144 |        "}\n",
1145 |        "\n",
1146 |        ".jupyter-flat-container-repr details ~ p {\n",
1147 |        "    margin-top: 0;\n",
1148 |        "    display: inline;\n",
1149 |        "}\n",
1150 |        "\n",
1151 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
1152 |        "    /*display: block;*/\n",
1153 |        "}\n",
1154 |        "\n",
1155 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
1156 |        "    display: block;\n",
1157 |        "}\n",
1158 |        "\n",
1159 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
1160 |        "    display: inline;\n",
1161 |        "}\n",
1162 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
1163 |        "    margin-left: 1em;\n",
1164 |        "}\n",
1165 |        "</style><details class='jupyter-details'><summary><code>&lt;function requests.api.get&gt;</code></summary><div class=\"jupyter-extra-info\"><dl class='jupyter-inner-mapping-repr'>\n",
1166 |        "                        <dt><b>type_name:</b></dt>\n",
1167 |        "                        <dd>&#x27;function&#x27;</dd>\n",
1168 |        "                    </dl>\n",
1169 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1170 |        "                        <dt><b>file:</b></dt>\n",
1171 |        "                        <dd>&#x27;~/anaconda/lib/python3.6/site-packages/requests/api.py&#x27;</dd>\n",
1172 |        "                    </dl>\n",
1173 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1174 |        "                        <dt><b>definition:</b></dt>\n",
1175 |        "                        <dd><code>get(url, params=None, **kwargs)</code></dd>\n",
1176 |        "                    </dl>\n",
1177 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1178 |        "                        <dt><b>docstring:</b></dt>\n",
1179 |        "                        <dd><code>Sends a GET request.\n",
1180 |        "\n",
1181 |        ":param url: URL for the new :class:`Request` object.\n",
1182 |        ":param params: (optional) Dictionary or bytes to be sent in the query string for the :class:`Request`.\n",
1183 |        ":param \\*\\*kwargs: Optional arguments that ``request`` takes.\n",
1184 |        ":return: :class:`Response &lt;Response&gt;` object\n",
1185 |        ":rtype: requests.Response</code></dd>\n",
1186 |        "                    </dl>\n",
1187 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1188 |        "                        <dt><b>argspec:</b></dt>\n",
1189 |        "                        <dd>{&#x27;annotations&#x27;: {},\n",
1190 |        " &#x27;args&#x27;: [&#x27;url&#x27;, &#x27;params&#x27;],\n",
1191 |        " &#x27;defaults&#x27;: (None,),\n",
1192 |        " &#x27;kwonlyargs&#x27;: [],\n",
1193 |        " &#x27;kwonlydefaults&#x27;: None,\n",
1194 |        " &#x27;varargs&#x27;: None,\n",
1195 |        " &#x27;varkw&#x27;: &#x27;kwargs&#x27;}</dd>\n",
1196 |        "                    </dl>\n",
1197 |        "                  </div></details>"
1198 |       ],
1199 |       "text/plain": [
1200 |        "<function requests.api.get>"
1201 |       ]
1202 |      },
1203 |      "execution_count": 9,
1204 |      "metadata": {},
1205 |      "output_type": "execute_result"
1206 |     }
1207 |    ],
1208 |    "source": [
1209 |     "requests.get # this is a function, alerady covered by activate_builtins()"
1210 |    ]
1211 |   },
1212 |   {
1213 |    "cell_type": "markdown",
1214 |    "metadata": {},
1215 |    "source": [
1216 |     "By default again the repr is not enabled:"
1217 |    ]
1218 |   },
1219 |   {
1220 |    "cell_type": "code",
1221 |    "execution_count": 10,
1222 |    "metadata": {},
1223 |    "outputs": [
1224 |     {
1225 |      "data": {
1226 |       "text/plain": [
1227 |        "<Response [404]>"
1228 |       ]
1229 |      },
1230 |      "execution_count": 10,
1231 |      "metadata": {},
1232 |      "output_type": "execute_result"
1233 |     }
1234 |    ],
1235 |    "source": [
1236 |     "res"
1237 |    ]
1238 |   },
1239 |   {
1240 |    "cell_type": "code",
1241 |    "execution_count": 11,
1242 |    "metadata": {},
1243 |    "outputs": [
1244 |     {
1245 |      "data": {
1246 |       "text/html": [
1247 |        "<style>\n",
1248 |        "\n",
1249 |        "/* summary::-webkit-details-marker {\n",
1250 |        "  display: none;\n",
1251 |        "}\n",
1252 |        "\n",
1253 |        "summary {\n",
1254 |        "  text-decoration-line: underline;\n",
1255 |        "  text-decoration-style: dotted;\n",
1256 |        "  \n",
1257 |        "} */\n",
1258 |        "\n",
1259 |        ".rendered_html pre, .rendered_html code {\n",
1260 |        "    background-color: transparent; /* bug in notebook css */\n",
1261 |        "}\n",
1262 |        "\n",
1263 |        ".rendered_html .jupyter-extra-info ul{\n",
1264 |        "    list-style: none;\n",
1265 |        "}\n",
1266 |        "\n",
1267 |        ".jupyter-extra-info {\n",
1268 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
1269 |        "    padding: 0.5em;\n",
1270 |        "    border: thin solid silver;\n",
1271 |        "}\n",
1272 |        "dl.jupyter-inner-mapping-repr {\n",
1273 |        "    padding-left: 1em;\n",
1274 |        "    margin-bottom: 0;\n",
1275 |        "}\n",
1276 |        "\n",
1277 |        "dl.jupyter-inner-mapping-repr > dd {\n",
1278 |        "    padding-left:2em;\n",
1279 |        "}\n",
1280 |        "\n",
1281 |        "ul.jupyter-flat-container-repr li > p{\n",
1282 |        "    padding-left:2em;\n",
1283 |        "    display: inline;\n",
1284 |        "    padding: 0;\n",
1285 |        "}\n",
1286 |        "\n",
1287 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
1288 |        "    list-style-type: none;   \n",
1289 |        "    display: inline;\n",
1290 |        "    padding-left: 0;\n",
1291 |        "}\n",
1292 |        "\n",
1293 |        "ul.jupyter-flat-container-repr > details {\n",
1294 |        "    display: inline-block;\n",
1295 |        "    margin-left: -1em;\n",
1296 |        "}\n",
1297 |        "\n",
1298 |        "ul.jupyter-flat-container-repr li{\n",
1299 |        "    padding-left:2em;\n",
1300 |        "    list-style-type: none;\n",
1301 |        "}\n",
1302 |        "\n",
1303 |        "summary > code {\n",
1304 |        "    display: inline\n",
1305 |        "}\n",
1306 |        "\n",
1307 |        "ul.jupyter-flat-container-repr summary {\n",
1308 |        "    margin-left: 0em;\n",
1309 |        "    display: inline-block;\n",
1310 |        "}\n",
1311 |        "\n",
1312 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
1313 |        "    padding-left: 0px;\n",
1314 |        "    margin-left: 0em;\n",
1315 |        "}\n",
1316 |        "\n",
1317 |        ".jupyter-flat-container-repr details {\n",
1318 |        "    display: inline;\n",
1319 |        "}\n",
1320 |        "\n",
1321 |        ".jupyter-flat-container-repr details ~ p {\n",
1322 |        "    margin-top: 0;\n",
1323 |        "    display: inline;\n",
1324 |        "}\n",
1325 |        "\n",
1326 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
1327 |        "    /*display: block;*/\n",
1328 |        "}\n",
1329 |        "\n",
1330 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
1331 |        "    display: block;\n",
1332 |        "}\n",
1333 |        "\n",
1334 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
1335 |        "    display: inline;\n",
1336 |        "}\n",
1337 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
1338 |        "    margin-left: 1em;\n",
1339 |        "}\n",
1340 |        "</style><details class=\"jupyter-details\" ><summary><code>requests.models.Response</code></summary><div class=\"jupyter-extra-info\">\n",
1341 |        "                <p><code alpha>The :class:`Response <Response>` object, which contains a\n",
1342 |        "    server's response to an HTTP request.\n",
1343 |        "    </code></p>\n",
1344 |        "                <p> Inherit from :</p>\n",
1345 |        "                <ul>\n",
1346 |        "                  <li>None</li>\n",
1347 |        "                </ul></div></details>"
1348 |       ],
1349 |       "text/plain": [
1350 |        "requests.models.Response"
1351 |       ]
1352 |      },
1353 |      "execution_count": 11,
1354 |      "metadata": {},
1355 |      "output_type": "execute_result"
1356 |     }
1357 |    ],
1358 |    "source": [
1359 |     "type(res) # this is a type, already cover by activate_builtins()"
1360 |    ]
1361 |   },
1362 |   {
1363 |    "cell_type": "markdown",
1364 |    "metadata": {},
1365 |    "source": [
1366 |     "let's activate it:"
1367 |    ]
1368 |   },
1369 |   {
1370 |    "cell_type": "code",
1371 |    "execution_count": 12,
1372 |    "metadata": {},
1373 |    "outputs": [],
1374 |    "source": [
1375 |     "disp.activate_for(res) # install for res (actually for type(res), but we infer that if what is given is an instance)"
1376 |    ]
1377 |   },
1378 |   {
1379 |    "cell_type": "code",
1380 |    "execution_count": 13,
1381 |    "metadata": {
1382 |     "scrolled": false
1383 |    },
1384 |    "outputs": [
1385 |     {
1386 |      "data": {
1387 |       "text/html": [
1388 |        "\n",
1389 |        "            <style>\n",
1390 |        "                \n",
1391 |        "\n",
1392 |        "/* summary::-webkit-details-marker {\n",
1393 |        "  display: none;\n",
1394 |        "}\n",
1395 |        "\n",
1396 |        "summary {\n",
1397 |        "  text-decoration-line: underline;\n",
1398 |        "  text-decoration-style: dotted;\n",
1399 |        "  \n",
1400 |        "} */\n",
1401 |        "\n",
1402 |        ".rendered_html pre, .rendered_html code {\n",
1403 |        "    background-color: transparent; /* bug in notebook css */\n",
1404 |        "}\n",
1405 |        "\n",
1406 |        ".rendered_html .jupyter-extra-info ul{\n",
1407 |        "    list-style: none;\n",
1408 |        "}\n",
1409 |        "\n",
1410 |        ".jupyter-extra-info {\n",
1411 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
1412 |        "    padding: 0.5em;\n",
1413 |        "    border: thin solid silver;\n",
1414 |        "}\n",
1415 |        "dl.jupyter-inner-mapping-repr {\n",
1416 |        "    padding-left: 1em;\n",
1417 |        "    margin-bottom: 0;\n",
1418 |        "}\n",
1419 |        "\n",
1420 |        "dl.jupyter-inner-mapping-repr > dd {\n",
1421 |        "    padding-left:2em;\n",
1422 |        "}\n",
1423 |        "\n",
1424 |        "ul.jupyter-flat-container-repr li > p{\n",
1425 |        "    padding-left:2em;\n",
1426 |        "    display: inline;\n",
1427 |        "    padding: 0;\n",
1428 |        "}\n",
1429 |        "\n",
1430 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
1431 |        "    list-style-type: none;   \n",
1432 |        "    display: inline;\n",
1433 |        "    padding-left: 0;\n",
1434 |        "}\n",
1435 |        "\n",
1436 |        "ul.jupyter-flat-container-repr > details {\n",
1437 |        "    display: inline-block;\n",
1438 |        "    margin-left: -1em;\n",
1439 |        "}\n",
1440 |        "\n",
1441 |        "ul.jupyter-flat-container-repr li{\n",
1442 |        "    padding-left:2em;\n",
1443 |        "    list-style-type: none;\n",
1444 |        "}\n",
1445 |        "\n",
1446 |        "summary > code {\n",
1447 |        "    display: inline\n",
1448 |        "}\n",
1449 |        "\n",
1450 |        "ul.jupyter-flat-container-repr summary {\n",
1451 |        "    margin-left: 0em;\n",
1452 |        "    display: inline-block;\n",
1453 |        "}\n",
1454 |        "\n",
1455 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
1456 |        "    padding-left: 0px;\n",
1457 |        "    margin-left: 0em;\n",
1458 |        "}\n",
1459 |        "\n",
1460 |        ".jupyter-flat-container-repr details {\n",
1461 |        "    display: inline;\n",
1462 |        "}\n",
1463 |        "\n",
1464 |        ".jupyter-flat-container-repr details ~ p {\n",
1465 |        "    margin-top: 0;\n",
1466 |        "    display: inline;\n",
1467 |        "}\n",
1468 |        "\n",
1469 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
1470 |        "    /*display: block;*/\n",
1471 |        "}\n",
1472 |        "\n",
1473 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
1474 |        "    display: block;\n",
1475 |        "}\n",
1476 |        "\n",
1477 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
1478 |        "    display: inline;\n",
1479 |        "}\n",
1480 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
1481 |        "    margin-left: 1em;\n",
1482 |        "}\n",
1483 |        "\n",
1484 |        "            </style>\n",
1485 |        "            <details class='jupyter-details'><summary><code>&lt;Response [404]&gt;</code></summary>\n",
1486 |        "                <dl class='jupyter-inner-mapping-repr'>\n",
1487 |        "                        <dt><b>status_code:</b></dt>\n",
1488 |        "                        <dd>404</dd>\n",
1489 |        "                    </dl>\n",
1490 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1491 |        "                        <dt><b>headers:</b></dt>\n",
1492 |        "                        <dd>\n",
1493 |        "            <details class='jupyter-details'  >\n",
1494 |        "                <summary>{</summary>\n",
1495 |        "                <dl class='jupyter-inner-mapping-repr'>\n",
1496 |        "                        <dt><b>Date:</b></dt>\n",
1497 |        "                        <dd>&#x27;Mon, 19 Jun 2017 18:49:54 GMT&#x27;</dd>\n",
1498 |        "                    </dl>\n",
1499 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1500 |        "                        <dt><b>Content-Type:</b></dt>\n",
1501 |        "                        <dd>&#x27;application/json; charset=utf-8&#x27;</dd>\n",
1502 |        "                    </dl>\n",
1503 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1504 |        "                        <dt><b>Transfer-Encoding:</b></dt>\n",
1505 |        "                        <dd>&#x27;chunked&#x27;</dd>\n",
1506 |        "                    </dl>\n",
1507 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1508 |        "                        <dt><b>Server:</b></dt>\n",
1509 |        "                        <dd>&#x27;GitHub.com&#x27;</dd>\n",
1510 |        "                    </dl>\n",
1511 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1512 |        "                        <dt><b>Status:</b></dt>\n",
1513 |        "                        <dd>&#x27;404 Not Found&#x27;</dd>\n",
1514 |        "                    </dl>\n",
1515 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1516 |        "                        <dt><b>X-RateLimit-Limit:</b></dt>\n",
1517 |        "                        <dd>&#x27;60&#x27;</dd>\n",
1518 |        "                    </dl>\n",
1519 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1520 |        "                        <dt><b>X-RateLimit-Remaining:</b></dt>\n",
1521 |        "                        <dd>&#x27;51&#x27;</dd>\n",
1522 |        "                    </dl>\n",
1523 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1524 |        "                        <dt><b>X-RateLimit-Reset:</b></dt>\n",
1525 |        "                        <dd>&#x27;1497900396&#x27;</dd>\n",
1526 |        "                    </dl>\n",
1527 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1528 |        "                        <dt><b>X-GitHub-Media-Type:</b></dt>\n",
1529 |        "                        <dd>&#x27;github.v3; format=json&#x27;</dd>\n",
1530 |        "                    </dl>\n",
1531 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1532 |        "                        <dt><b>Access-Control-Expose-Headers:</b></dt>\n",
1533 |        "                        <dd>&#x27;ETag, Link, X-GitHub-OTP, X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset, X-OAuth-Scopes, X-Accepted-OAuth-Scopes, X-Poll-Interval&#x27;</dd>\n",
1534 |        "                    </dl>\n",
1535 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1536 |        "                        <dt><b>Access-Control-Allow-Origin:</b></dt>\n",
1537 |        "                        <dd>&#x27;*&#x27;</dd>\n",
1538 |        "                    </dl>\n",
1539 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1540 |        "                        <dt><b>Content-Security-Policy:</b></dt>\n",
1541 |        "                        <dd>&quot;default-src &#x27;none&#x27;&quot;</dd>\n",
1542 |        "                    </dl>\n",
1543 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1544 |        "                        <dt><b>Strict-Transport-Security:</b></dt>\n",
1545 |        "                        <dd>&#x27;max-age=31536000; includeSubdomains; preload&#x27;</dd>\n",
1546 |        "                    </dl>\n",
1547 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1548 |        "                        <dt><b>X-Content-Type-Options:</b></dt>\n",
1549 |        "                        <dd>&#x27;nosniff&#x27;</dd>\n",
1550 |        "                    </dl>\n",
1551 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1552 |        "                        <dt><b>X-Frame-Options:</b></dt>\n",
1553 |        "                        <dd>&#x27;deny&#x27;</dd>\n",
1554 |        "                    </dl>\n",
1555 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1556 |        "                        <dt><b>X-XSS-Protection:</b></dt>\n",
1557 |        "                        <dd>&#x27;1; mode=block&#x27;</dd>\n",
1558 |        "                    </dl>\n",
1559 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1560 |        "                        <dt><b>X-Runtime-rack:</b></dt>\n",
1561 |        "                        <dd>&#x27;0.039253&#x27;</dd>\n",
1562 |        "                    </dl>\n",
1563 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1564 |        "                        <dt><b>Content-Encoding:</b></dt>\n",
1565 |        "                        <dd>&#x27;gzip&#x27;</dd>\n",
1566 |        "                    </dl>\n",
1567 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1568 |        "                        <dt><b>X-GitHub-Request-Id:</b></dt>\n",
1569 |        "                        <dd>&#x27;A624:B330:A1C5E3:CA86F4:59481CD1&#x27;</dd>\n",
1570 |        "                    </dl>\n",
1571 |        "                  \n",
1572 |        "            </details>\n",
1573 |        "            }\n",
1574 |        "            </dd>\n",
1575 |        "                    </dl>\n",
1576 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1577 |        "                        <dt><b>raw:</b></dt>\n",
1578 |        "                        <dd>&lt;requests.packages.urllib3.response.HTTPResponse at 0x10c4ac630&gt;</dd>\n",
1579 |        "                    </dl>\n",
1580 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1581 |        "                        <dt><b>url:</b></dt>\n",
1582 |        "                        <dd>&#x27;https://api.github.com/aoisehgd&#x27;</dd>\n",
1583 |        "                    </dl>\n",
1584 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1585 |        "                        <dt><b>encoding:</b></dt>\n",
1586 |        "                        <dd>&#x27;utf-8&#x27;</dd>\n",
1587 |        "                    </dl>\n",
1588 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1589 |        "                        <dt><b>history:</b></dt>\n",
1590 |        "                        <dd>[]</dd>\n",
1591 |        "                    </dl>\n",
1592 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1593 |        "                        <dt><b>reason:</b></dt>\n",
1594 |        "                        <dd>&#x27;Not Found&#x27;</dd>\n",
1595 |        "                    </dl>\n",
1596 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1597 |        "                        <dt><b>cookies:</b></dt>\n",
1598 |        "                        <dd>&lt;RequestsCookieJar[]&gt;</dd>\n",
1599 |        "                    </dl>\n",
1600 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1601 |        "                        <dt><b>elapsed:</b></dt>\n",
1602 |        "                        <dd>datetime.timedelta(0, 0, 926297)</dd>\n",
1603 |        "                    </dl>\n",
1604 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1605 |        "                        <dt><b>request:</b></dt>\n",
1606 |        "                        <dd>&lt;PreparedRequest [GET]&gt;</dd>\n",
1607 |        "                    </dl>\n",
1608 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1609 |        "                        <dt><b>connection:</b></dt>\n",
1610 |        "                        <dd>&lt;requests.adapters.HTTPAdapter at 0x10c478588&gt;</dd>\n",
1611 |        "                    </dl>\n",
1612 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1613 |        "                        <dt><b>from_cache:</b></dt>\n",
1614 |        "                        <dd>False</dd>\n",
1615 |        "                    </dl>\n",
1616 |        "                  \n",
1617 |        "                 <details class=\"jupyter-details\">\n",
1618 |        "                    <summary>Content (JSON)</summary>\n",
1619 |        "                    <dl class='jupyter-inner-mapping-repr'>\n",
1620 |        "                        <dt><b>message:</b></dt>\n",
1621 |        "                        <dd>&#x27;Not Found&#x27;</dd>\n",
1622 |        "                    </dl>\n",
1623 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1624 |        "                        <dt><b>documentation_url:</b></dt>\n",
1625 |        "                        <dd>&#x27;https://developer.github.com/v3&#x27;</dd>\n",
1626 |        "                    </dl>\n",
1627 |        "                  \n",
1628 |        "                 </details>\n",
1629 |        "            </details>\n",
1630 |        "            "
1631 |       ],
1632 |       "text/plain": [
1633 |        "<Response [404]>"
1634 |       ]
1635 |      },
1636 |      "execution_count": 13,
1637 |      "metadata": {},
1638 |      "output_type": "execute_result"
1639 |     }
1640 |    ],
1641 |    "source": [
1642 |     "res"
1643 |    ]
1644 |   },
1645 |   {
1646 |    "cell_type": "markdown",
1647 |    "metadata": {},
1648 |    "source": [
1649 |     "We know have 1 click access to the content (if json), neatly formatted, and collapsible. we also have special cased the header field."
1650 |    ]
1651 |   },
1652 |   {
1653 |    "cell_type": "markdown",
1654 |    "metadata": {},
1655 |    "source": [
1656 |     "##  Beta feature"
1657 |    ]
1658 |   },
1659 |   {
1660 |    "cell_type": "markdown",
1661 |    "metadata": {},
1662 |    "source": [
1663 |     "you can actually activate rich display for arbitrary container (making them collapsible), though this can have nasty side effects, so use at your own risk:"
1664 |    ]
1665 |   },
1666 |   {
1667 |    "cell_type": "code",
1668 |    "execution_count": 14,
1669 |    "metadata": {},
1670 |    "outputs": [],
1671 |    "source": [
1672 |     "from IPython.display import HTML"
1673 |    ]
1674 |   },
1675 |   {
1676 |    "cell_type": "code",
1677 |    "execution_count": 15,
1678 |    "metadata": {},
1679 |    "outputs": [
1680 |     {
1681 |      "data": {
1682 |       "text/plain": [
1683 |        "({},\n",
1684 |        " <function print>,\n",
1685 |        " IPython.display.HTML,\n",
1686 |        " [{'This is a key': 'and its value', 'hello': 'world'}, 123456789],\n",
1687 |        " <IPython.display.HTML object>,\n",
1688 |        " set())"
1689 |       ]
1690 |      },
1691 |      "execution_count": 15,
1692 |      "metadata": {},
1693 |      "output_type": "execute_result"
1694 |     }
1695 |    ],
1696 |    "source": [
1697 |     "ex = ({}, print, HTML, [{'hello':'world','This is a key':'and its value'}, 123456789], HTML('<b>BOLD</b>'), set())\n",
1698 |     "ex"
1699 |    ]
1700 |   },
1701 |   {
1702 |    "cell_type": "code",
1703 |    "execution_count": 16,
1704 |    "metadata": {},
1705 |    "outputs": [],
1706 |    "source": [
1707 |     "disp.activate_for(list)\n",
1708 |     "disp.activate_for(tuple)\n",
1709 |     "disp.activate_for(set)\n",
1710 |     "disp.activate_for(dict)"
1711 |    ]
1712 |   },
1713 |   {
1714 |    "cell_type": "code",
1715 |    "execution_count": 17,
1716 |    "metadata": {},
1717 |    "outputs": [
1718 |     {
1719 |      "data": {
1720 |       "text/html": [
1721 |        "<ul class=\"jupyter-flat-container-repr\">\n",
1722 |        "                    <details class='jupyter-details' open>\n",
1723 |        "                        <summary>(</summary>\n",
1724 |        "                        <li>dict({})<span class=\"post-comma\">,</span></li><li><style>\n",
1725 |        "\n",
1726 |        "/* summary::-webkit-details-marker {\n",
1727 |        "  display: none;\n",
1728 |        "}\n",
1729 |        "\n",
1730 |        "summary {\n",
1731 |        "  text-decoration-line: underline;\n",
1732 |        "  text-decoration-style: dotted;\n",
1733 |        "  \n",
1734 |        "} */\n",
1735 |        "\n",
1736 |        ".rendered_html pre, .rendered_html code {\n",
1737 |        "    background-color: transparent; /* bug in notebook css */\n",
1738 |        "}\n",
1739 |        "\n",
1740 |        ".rendered_html .jupyter-extra-info ul{\n",
1741 |        "    list-style: none;\n",
1742 |        "}\n",
1743 |        "\n",
1744 |        ".jupyter-extra-info {\n",
1745 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
1746 |        "    padding: 0.5em;\n",
1747 |        "    border: thin solid silver;\n",
1748 |        "}\n",
1749 |        "dl.jupyter-inner-mapping-repr {\n",
1750 |        "    padding-left: 1em;\n",
1751 |        "    margin-bottom: 0;\n",
1752 |        "}\n",
1753 |        "\n",
1754 |        "dl.jupyter-inner-mapping-repr > dd {\n",
1755 |        "    padding-left:2em;\n",
1756 |        "}\n",
1757 |        "\n",
1758 |        "ul.jupyter-flat-container-repr li > p{\n",
1759 |        "    padding-left:2em;\n",
1760 |        "    display: inline;\n",
1761 |        "    padding: 0;\n",
1762 |        "}\n",
1763 |        "\n",
1764 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
1765 |        "    list-style-type: none;   \n",
1766 |        "    display: inline;\n",
1767 |        "    padding-left: 0;\n",
1768 |        "}\n",
1769 |        "\n",
1770 |        "ul.jupyter-flat-container-repr > details {\n",
1771 |        "    display: inline-block;\n",
1772 |        "    margin-left: -1em;\n",
1773 |        "}\n",
1774 |        "\n",
1775 |        "ul.jupyter-flat-container-repr li{\n",
1776 |        "    padding-left:2em;\n",
1777 |        "    list-style-type: none;\n",
1778 |        "}\n",
1779 |        "\n",
1780 |        "summary > code {\n",
1781 |        "    display: inline\n",
1782 |        "}\n",
1783 |        "\n",
1784 |        "ul.jupyter-flat-container-repr summary {\n",
1785 |        "    margin-left: 0em;\n",
1786 |        "    display: inline-block;\n",
1787 |        "}\n",
1788 |        "\n",
1789 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
1790 |        "    padding-left: 0px;\n",
1791 |        "    margin-left: 0em;\n",
1792 |        "}\n",
1793 |        "\n",
1794 |        ".jupyter-flat-container-repr details {\n",
1795 |        "    display: inline;\n",
1796 |        "}\n",
1797 |        "\n",
1798 |        ".jupyter-flat-container-repr details ~ p {\n",
1799 |        "    margin-top: 0;\n",
1800 |        "    display: inline;\n",
1801 |        "}\n",
1802 |        "\n",
1803 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
1804 |        "    /*display: block;*/\n",
1805 |        "}\n",
1806 |        "\n",
1807 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
1808 |        "    display: block;\n",
1809 |        "}\n",
1810 |        "\n",
1811 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
1812 |        "    display: inline;\n",
1813 |        "}\n",
1814 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
1815 |        "    margin-left: 1em;\n",
1816 |        "}\n",
1817 |        "</style><details class='jupyter-details'><summary><code>&lt;function print&gt;</code></summary><div class=\"jupyter-extra-info\"><dl class='jupyter-inner-mapping-repr'>\n",
1818 |        "                        <dt><b>type_name:</b></dt>\n",
1819 |        "                        <dd>&#x27;builtin_function_or_method&#x27;</dd>\n",
1820 |        "                    </dl>\n",
1821 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
1822 |        "                        <dt><b>docstring:</b></dt>\n",
1823 |        "                        <dd><code>print(value, ..., sep=&#x27; &#x27;, end=&#x27;\\n&#x27;, file=sys.stdout, flush=False)\n",
1824 |        "\n",
1825 |        "Prints the values to a stream, or to sys.stdout by default.\n",
1826 |        "Optional keyword arguments:\n",
1827 |        "file:  a file-like object (stream); defaults to the current sys.stdout.\n",
1828 |        "sep:   string inserted between values, default a space.\n",
1829 |        "end:   string appended after the last value, default a newline.\n",
1830 |        "flush: whether to forcibly flush the stream.</code></dd>\n",
1831 |        "                    </dl>\n",
1832 |        "                  </div></details><span class=\"post-comma\">,</span></li><li><style>\n",
1833 |        "\n",
1834 |        "/* summary::-webkit-details-marker {\n",
1835 |        "  display: none;\n",
1836 |        "}\n",
1837 |        "\n",
1838 |        "summary {\n",
1839 |        "  text-decoration-line: underline;\n",
1840 |        "  text-decoration-style: dotted;\n",
1841 |        "  \n",
1842 |        "} */\n",
1843 |        "\n",
1844 |        ".rendered_html pre, .rendered_html code {\n",
1845 |        "    background-color: transparent; /* bug in notebook css */\n",
1846 |        "}\n",
1847 |        "\n",
1848 |        ".rendered_html .jupyter-extra-info ul{\n",
1849 |        "    list-style: none;\n",
1850 |        "}\n",
1851 |        "\n",
1852 |        ".jupyter-extra-info {\n",
1853 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
1854 |        "    padding: 0.5em;\n",
1855 |        "    border: thin solid silver;\n",
1856 |        "}\n",
1857 |        "dl.jupyter-inner-mapping-repr {\n",
1858 |        "    padding-left: 1em;\n",
1859 |        "    margin-bottom: 0;\n",
1860 |        "}\n",
1861 |        "\n",
1862 |        "dl.jupyter-inner-mapping-repr > dd {\n",
1863 |        "    padding-left:2em;\n",
1864 |        "}\n",
1865 |        "\n",
1866 |        "ul.jupyter-flat-container-repr li > p{\n",
1867 |        "    padding-left:2em;\n",
1868 |        "    display: inline;\n",
1869 |        "    padding: 0;\n",
1870 |        "}\n",
1871 |        "\n",
1872 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
1873 |        "    list-style-type: none;   \n",
1874 |        "    display: inline;\n",
1875 |        "    padding-left: 0;\n",
1876 |        "}\n",
1877 |        "\n",
1878 |        "ul.jupyter-flat-container-repr > details {\n",
1879 |        "    display: inline-block;\n",
1880 |        "    margin-left: -1em;\n",
1881 |        "}\n",
1882 |        "\n",
1883 |        "ul.jupyter-flat-container-repr li{\n",
1884 |        "    padding-left:2em;\n",
1885 |        "    list-style-type: none;\n",
1886 |        "}\n",
1887 |        "\n",
1888 |        "summary > code {\n",
1889 |        "    display: inline\n",
1890 |        "}\n",
1891 |        "\n",
1892 |        "ul.jupyter-flat-container-repr summary {\n",
1893 |        "    margin-left: 0em;\n",
1894 |        "    display: inline-block;\n",
1895 |        "}\n",
1896 |        "\n",
1897 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
1898 |        "    padding-left: 0px;\n",
1899 |        "    margin-left: 0em;\n",
1900 |        "}\n",
1901 |        "\n",
1902 |        ".jupyter-flat-container-repr details {\n",
1903 |        "    display: inline;\n",
1904 |        "}\n",
1905 |        "\n",
1906 |        ".jupyter-flat-container-repr details ~ p {\n",
1907 |        "    margin-top: 0;\n",
1908 |        "    display: inline;\n",
1909 |        "}\n",
1910 |        "\n",
1911 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
1912 |        "    /*display: block;*/\n",
1913 |        "}\n",
1914 |        "\n",
1915 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
1916 |        "    display: block;\n",
1917 |        "}\n",
1918 |        "\n",
1919 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
1920 |        "    display: inline;\n",
1921 |        "}\n",
1922 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
1923 |        "    margin-left: 1em;\n",
1924 |        "}\n",
1925 |        "</style><details class=\"jupyter-details\" ><summary><code>IPython.display.HTML</code></summary><div class=\"jupyter-extra-info\">\n",
1926 |        "                <p><code alpha></code></p>\n",
1927 |        "                <p> Inherit from :</p>\n",
1928 |        "                <ul>\n",
1929 |        "                  <li><style>\n",
1930 |        "\n",
1931 |        "/* summary::-webkit-details-marker {\n",
1932 |        "  display: none;\n",
1933 |        "}\n",
1934 |        "\n",
1935 |        "summary {\n",
1936 |        "  text-decoration-line: underline;\n",
1937 |        "  text-decoration-style: dotted;\n",
1938 |        "  \n",
1939 |        "} */\n",
1940 |        "\n",
1941 |        ".rendered_html pre, .rendered_html code {\n",
1942 |        "    background-color: transparent; /* bug in notebook css */\n",
1943 |        "}\n",
1944 |        "\n",
1945 |        ".rendered_html .jupyter-extra-info ul{\n",
1946 |        "    list-style: none;\n",
1947 |        "}\n",
1948 |        "\n",
1949 |        ".jupyter-extra-info {\n",
1950 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
1951 |        "    padding: 0.5em;\n",
1952 |        "    border: thin solid silver;\n",
1953 |        "}\n",
1954 |        "dl.jupyter-inner-mapping-repr {\n",
1955 |        "    padding-left: 1em;\n",
1956 |        "    margin-bottom: 0;\n",
1957 |        "}\n",
1958 |        "\n",
1959 |        "dl.jupyter-inner-mapping-repr > dd {\n",
1960 |        "    padding-left:2em;\n",
1961 |        "}\n",
1962 |        "\n",
1963 |        "ul.jupyter-flat-container-repr li > p{\n",
1964 |        "    padding-left:2em;\n",
1965 |        "    display: inline;\n",
1966 |        "    padding: 0;\n",
1967 |        "}\n",
1968 |        "\n",
1969 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
1970 |        "    list-style-type: none;   \n",
1971 |        "    display: inline;\n",
1972 |        "    padding-left: 0;\n",
1973 |        "}\n",
1974 |        "\n",
1975 |        "ul.jupyter-flat-container-repr > details {\n",
1976 |        "    display: inline-block;\n",
1977 |        "    margin-left: -1em;\n",
1978 |        "}\n",
1979 |        "\n",
1980 |        "ul.jupyter-flat-container-repr li{\n",
1981 |        "    padding-left:2em;\n",
1982 |        "    list-style-type: none;\n",
1983 |        "}\n",
1984 |        "\n",
1985 |        "summary > code {\n",
1986 |        "    display: inline\n",
1987 |        "}\n",
1988 |        "\n",
1989 |        "ul.jupyter-flat-container-repr summary {\n",
1990 |        "    margin-left: 0em;\n",
1991 |        "    display: inline-block;\n",
1992 |        "}\n",
1993 |        "\n",
1994 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
1995 |        "    padding-left: 0px;\n",
1996 |        "    margin-left: 0em;\n",
1997 |        "}\n",
1998 |        "\n",
1999 |        ".jupyter-flat-container-repr details {\n",
2000 |        "    display: inline;\n",
2001 |        "}\n",
2002 |        "\n",
2003 |        ".jupyter-flat-container-repr details ~ p {\n",
2004 |        "    margin-top: 0;\n",
2005 |        "    display: inline;\n",
2006 |        "}\n",
2007 |        "\n",
2008 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
2009 |        "    /*display: block;*/\n",
2010 |        "}\n",
2011 |        "\n",
2012 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
2013 |        "    display: block;\n",
2014 |        "}\n",
2015 |        "\n",
2016 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
2017 |        "    display: inline;\n",
2018 |        "}\n",
2019 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
2020 |        "    margin-left: 1em;\n",
2021 |        "}\n",
2022 |        "</style><details class=\"jupyter-details\" ><summary><code>IPython.display.TextDisplayObject</code></summary><div class=\"jupyter-extra-info\">\n",
2023 |        "                <p><code alpha>Validate that display data is text</code></p>\n",
2024 |        "                <p> Inherit from :</p>\n",
2025 |        "                <ul>\n",
2026 |        "                  <li><style>\n",
2027 |        "\n",
2028 |        "/* summary::-webkit-details-marker {\n",
2029 |        "  display: none;\n",
2030 |        "}\n",
2031 |        "\n",
2032 |        "summary {\n",
2033 |        "  text-decoration-line: underline;\n",
2034 |        "  text-decoration-style: dotted;\n",
2035 |        "  \n",
2036 |        "} */\n",
2037 |        "\n",
2038 |        ".rendered_html pre, .rendered_html code {\n",
2039 |        "    background-color: transparent; /* bug in notebook css */\n",
2040 |        "}\n",
2041 |        "\n",
2042 |        ".rendered_html .jupyter-extra-info ul{\n",
2043 |        "    list-style: none;\n",
2044 |        "}\n",
2045 |        "\n",
2046 |        ".jupyter-extra-info {\n",
2047 |        "    background-color: hsla(0, 0%, 5%, 0.07); \n",
2048 |        "    padding: 0.5em;\n",
2049 |        "    border: thin solid silver;\n",
2050 |        "}\n",
2051 |        "dl.jupyter-inner-mapping-repr {\n",
2052 |        "    padding-left: 1em;\n",
2053 |        "    margin-bottom: 0;\n",
2054 |        "}\n",
2055 |        "\n",
2056 |        "dl.jupyter-inner-mapping-repr > dd {\n",
2057 |        "    padding-left:2em;\n",
2058 |        "}\n",
2059 |        "\n",
2060 |        "ul.jupyter-flat-container-repr li > p{\n",
2061 |        "    padding-left:2em;\n",
2062 |        "    display: inline;\n",
2063 |        "    padding: 0;\n",
2064 |        "}\n",
2065 |        "\n",
2066 |        "ul.jupyter-flat-container-repr, ul.jupyter-flat-container-repr ul , ul.jupyter-flat-container-repr ul il{\n",
2067 |        "    list-style-type: none;   \n",
2068 |        "    display: inline;\n",
2069 |        "    padding-left: 0;\n",
2070 |        "}\n",
2071 |        "\n",
2072 |        "ul.jupyter-flat-container-repr > details {\n",
2073 |        "    display: inline-block;\n",
2074 |        "    margin-left: -1em;\n",
2075 |        "}\n",
2076 |        "\n",
2077 |        "ul.jupyter-flat-container-repr li{\n",
2078 |        "    padding-left:2em;\n",
2079 |        "    list-style-type: none;\n",
2080 |        "}\n",
2081 |        "\n",
2082 |        "summary > code {\n",
2083 |        "    display: inline\n",
2084 |        "}\n",
2085 |        "\n",
2086 |        "ul.jupyter-flat-container-repr summary {\n",
2087 |        "    margin-left: 0em;\n",
2088 |        "    display: inline-block;\n",
2089 |        "}\n",
2090 |        "\n",
2091 |        ".rendered_html ul.jupyter-flat-container-repr {\n",
2092 |        "    padding-left: 0px;\n",
2093 |        "    margin-left: 0em;\n",
2094 |        "}\n",
2095 |        "\n",
2096 |        ".jupyter-flat-container-repr details {\n",
2097 |        "    display: inline;\n",
2098 |        "}\n",
2099 |        "\n",
2100 |        ".jupyter-flat-container-repr details ~ p {\n",
2101 |        "    margin-top: 0;\n",
2102 |        "    display: inline;\n",
2103 |        "}\n",
2104 |        "\n",
2105 |        ".jupyter-flat-container-repr details[open] ~ p {\n",
2106 |        "    /*display: block;*/\n",
2107 |        "}\n",
2108 |        "\n",
2109 |        "details.jupyter-details[open] ~ .jupyter-breaking-placeholder {\n",
2110 |        "    display: block;\n",
2111 |        "}\n",
2112 |        "\n",
2113 |        ".jupyter-details ~ .jupyter-breaking-placeholder {\n",
2114 |        "    display: inline;\n",
2115 |        "}\n",
2116 |        ".output_subarea > ul.jupyter-flat-container-repr, .output_subarea > ul.jupyter-flat-container-repr > p {\n",
2117 |        "    margin-left: 1em;\n",
2118 |        "}\n",
2119 |        "</style><details class=\"jupyter-details\" ><summary><code>IPython.display.DisplayObject</code></summary><div class=\"jupyter-extra-info\">\n",
2120 |        "                <p><code alpha>An object that wraps data to be displayed.</code></p>\n",
2121 |        "                <p> Inherit from :</p>\n",
2122 |        "                <ul>\n",
2123 |        "                  <li>None</li>\n",
2124 |        "                </ul></div></details></li>\n",
2125 |        "                </ul></div></details></li>\n",
2126 |        "                </ul></div></details><span class=\"post-comma\">,</span></li><li><ul class=\"jupyter-flat-container-repr\">\n",
2127 |        "                    <details class='jupyter-details' open>\n",
2128 |        "                        <summary>[</summary>\n",
2129 |        "                        <li>\n",
2130 |        "            <details class='jupyter-details'  open>\n",
2131 |        "                <summary>{</summary>\n",
2132 |        "                <dl class='jupyter-inner-mapping-repr'>\n",
2133 |        "                        <dt><b>hello:</b></dt>\n",
2134 |        "                        <dd>&#x27;world&#x27;</dd>\n",
2135 |        "                    </dl>\n",
2136 |        "                  <dl class='jupyter-inner-mapping-repr'>\n",
2137 |        "                        <dt><b>This is a key:</b></dt>\n",
2138 |        "                        <dd>&#x27;and its value&#x27;</dd>\n",
2139 |        "                    </dl>\n",
2140 |        "                  \n",
2141 |        "            </details>\n",
2142 |        "            }\n",
2143 |        "            <span class=\"post-comma\">,</span></li><li>123456789</li>\n",
2144 |        "                    </details>\n",
2145 |        "                    <span class='jupyter-breaking-placeholder'></span><p>]</p>\n",
2146 |        "                </ul>\n",
2147 |        "\n",
2148 |        "            <span class=\"post-comma\">,</span></li><li><b>BOLD</b><span class=\"post-comma\">,</span></li><li>set({})</li>\n",
2149 |        "                    </details>\n",
2150 |        "                    <span class='jupyter-breaking-placeholder'></span><p>)</p>\n",
2151 |        "                </ul>\n",
2152 |        "\n",
2153 |        "            "
2154 |       ],
2155 |       "text/plain": [
2156 |        "({},\n",
2157 |        " <function print>,\n",
2158 |        " IPython.display.HTML,\n",
2159 |        " [{'This is a key': 'and its value', 'hello': 'world'}, 123456789],\n",
2160 |        " <IPython.display.HTML object>,\n",
2161 |        " set())"
2162 |       ]
2163 |      },
2164 |      "execution_count": 17,
2165 |      "metadata": {},
2166 |      "output_type": "execute_result"
2167 |     }
2168 |    ],
2169 |    "source": [
2170 |     "ex"
2171 |    ]
2172 |   }
2173 |  ],
2174 |  "metadata": {
2175 |   "kernel_info": {
2176 |    "name": "pythonroot"
2177 |   },
2178 |   "kernelspec": {
2179 |    "display_name": "PythonRoot",
2180 |    "language": "python",
2181 |    "name": "pythonroot"
2182 |   },
2183 |   "language_info": {
2184 |    "codemirror_mode": {
2185 |     "name": "ipython",
2186 |     "version": 3
2187 |    },
2188 |    "file_extension": ".py",
2189 |    "mimetype": "text/x-python",
2190 |    "name": "python",
2191 |    "nbconvert_exporter": "python",
2192 |    "pygments_lexer": "ipython3",
2193 |    "version": "3.6.0"
2194 |   }
2195 |  },
2196 |  "nbformat": 4,
2197 |  "nbformat_minor": 2
2198 | }
2199 | 


--------------------------------------------------------------------------------