U
    -e                     @   s  U d Z ddgZddlmZ ddlmZ ddlmZ ddlZddl	Z	ddlZddl
ZddlZddlZddlZddlZddlZddlmZmZmZmZmZmZ ejd	krdd
lmZ ndd
lmZ ddlmZ ddlmZ ddlm Z  ddl!m"Z" ddl!m#Z# ddl$m%Z% ddl&m'Z' ddl(m)Z) ddl*m+Z+ ddl*m,Z, ddl-m.Z.m/Z/m0Z0 ddl1m2Z2 ddl3m4Z4 ddl5m6Z6 ddl7m8Z8 ddl9m:Z: ddl;m<Z< dZ=ee>eee>e>f  f Z?ee@d< ee>e>f ZAee@d< eG dd  d ZBd!d" ZCejDjEj ZFeGjHj ZId#d$ ejJejKejDeLfD ZMeNeOZPeNe>jQZRe.ZSe"jTZUd%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7gZVd8d9 ZWd:d; ZXee>df d<d=d>ZYdTee>df d<d@dAZZdBdC Z[e6dDdE Z\e6dFdG Z]e6dUdIdJZ^dKdL Z_e>d<dMdNZ`dOdP ZaG dQd de4Zbe>d<dRdSZcdS )VzTools for inspecting Python objects.

Uses syntax highlighting for presenting the various information elements.

Similar in spirit to the inspect module, but all calls take a name argument to
reference the name under which an object is being read.
	InspectorInspectColors    )	dataclass)	signature)dedentN)AnyOptionalDictUnionListTuple)   
   )	TypeAlias)page)pretty)skip_doctest)
PyColorize)openpy)safe_hasattr)compress_user)indent)list_namespace)typestr2type)
TermColorsColorSchemeColorSchemeTable)cast_unicode)	Colorable)undoc)	highlight)PythonLexer)HtmlFormatterZ__custom_documentations__UnformattedBundleBundlec                   @   sJ   e Zd ZU eed< eed< eed< ee ed< eed< eed< dd Zd	S )
OInfoismagicisaliasfound	namespaceparentobjc                 C   s
   t | |S )zGet a field from the object for backward compatibility with before 8.12

        see https://github.com/h5py/h5py/issues/2253
        )getattr)selffield r/   V/var/www/html/Darija-Ai-Train/env/lib/python3.8/site-packages/IPython/core/oinspect.pygetH   s    z	OInfo.getN)	__name__
__module____qualname__bool__annotations__r   strr   r1   r/   r/   r/   r0   r%   ?   s   
r%   c                 C   s   t | t tddS )NT)Z	noclasses)r    r!   r"   )coder/   r/   r0   pylightY   s    r9   c                 C   s   h | ]}t |qS r/   )inspectgetdoc).0tr/   r/   r0   	<setcomp>_   s    r>   	type_name
base_classstring_formr)   lengthfile
definition	docstringsourceinit_definitionclass_docstringinit_docstringcall_defcall_docstringr&   r'   isclassr(   namec                  K   s   dd t D }||  |S )z1Make an object info dict with all fields present.c                 S   s   i | ]
}|d qS Nr/   )r<   kr/   r/   r0   
<dictcomp>~   s      zobject_info.<locals>.<dictcomp>)info_fieldsupdate)kwZinfodictr/   r/   r0   object_info|   s    
rT   c              	   C   sb   t | }|dkrdS |dr"dS tj|s2dS t|d}t|j	\}}W 5 Q R X |S dS )znGet encoding for python source file defining obj

    Returns None if obj is not defined in a sourcefile.
    Nz.soz.dllz.pydrb)
	find_fileendswithospathisfile	stdlib_ioopenr   detect_encodingreadline)r+   ofilebufferencodinglinesr/   r/   r0   get_encoding   s    
rd   returnc                 C   sD   z|   }W n tk
r    Y nX t|tr6t|S t | }|S )a=  Stable wrapper around inspect.getdoc.

    This can't crash because of attribute problems.

    It also attempts to call a getdoc() method on the given object.  This
    allows objects which provide their docstrings via non-standard mechanisms
    (like Pyro proxies) to still be inspected by ipython's ? system.
    )r;   	Exception
isinstancer7   r:   cleandoc)r+   dsZdocstrr/   r/   r0   r;      s    



r;    c           	      C   s&  t | trg }dD ]}t| |}|dk	rt|}|r<d| nd}|dd||f t|r|t|}|r|t	| q|d||t
|f  q|rd|S dS nxt| } zt| }W n\ tk
r   zt| j}W n ttfk
r    Y Y dS X Y n tk
r   Y dS X |S dS )al  Wrapper around inspect.getsource.

    This can be modified by other projects to provide customized source
    extraction.

    Parameters
    ----------
    obj : object
        an object whose source code we will attempt to extract
    oname : str
        (optional) a name under which the object is known

    Returns
    -------
    src : unicode or None

    )fgetfsetfdelNz%s.rk   z# z
%s%s = %s

)rh   propertyr,   rd   appendjoinr:   
isfunction	getsourcer   r   _get_wrapped	TypeError	__class__OSError)	r+   onamesourcesattrnamefnrb   Zoname_prefixZ_srcsrcr/   r/   r0   rt      s:    



rt   c                 C   s(   t | p&t | p&t| tp&t| tS )zTrue if obj is a function ())r:   rs   ismethodrh   _builtin_func_type_builtin_meth_typer+   r/   r/   r0   is_simple_callable   s
    r   c                 C   s2   t jdtdd t| dr(t| s(| j} t| S )zWrapper around :func:`inspect.getfullargspec`

    In addition to functions and methods, this can also handle objects with a
    ``__call__`` attribute.

    DEPRECATED: Deprecated since 7.10. Do not use, will be removed.
    z]`getargspec` function is deprecated as of IPython 7.10and will be removed in future versions.   
stacklevel__call__)warningswarnDeprecationWarningr   r   r   r:   getfullargspecr   r/   r/   r0   
getargspec   s    
 r   c                 C   s0   t jdtdd t| d | d | d | d S )a  Format argspect, convenience wrapper around inspect's.

    This takes a dict instead of ordered arguments and calls
    inspect.format_argspec with the arguments in the necessary order.

    DEPRECATED (since 7.10): Do not use; will be removed in future versions.
    za`format_argspec` function is deprecated as of IPython 7.10and will be removed in future versions.r   r   argsvarargsvarkwdefaults)r   r   r   r:   formatargspec)argspecr/   r/   r0   format_argspec  s    
  r   Tc              	   C   s   t jdtdd | d}|dkr(d}nVz|d d dk}W n ttfk
rT   Y nX |rn|d d	d |d< | d
 t| }| d}|dkr| d}|dkr| dd}||fS )z?DEPRECATED since 6.0. Extract call tip data from an oinfo dict.zZ`call_tip` function is deprecated as of IPython 6.0and will be removed in future versions.r   r   r   Nr   r   r-      rM   rK   rI   rE   rk   )r   r   r   r1   KeyError
IndexErrorr   )ZoinfoZformat_callr   Z	call_lineZhas_selfdocr/   r/   r0   call_tip  s*    


r   c                 C   s2   | }d}t | dr.| j} |d7 }|dkr|S q| S )aN  Get the original object if wrapped in one or more @decorators

    Some objects automatically construct similar objects on any unrecognised
    attribute access (e.g. unittest.mock.call). To protect against infinite loops,
    this will arbitrarily cut off after 100 levels of obj.__wrapped__
    attribute access. --TK, Jan 2016
    r   __wrapped__r   d   )r   r   )r+   Zorig_objir/   r/   r0   ru   <  s    
ru   c                 C   st   t | } d}zt| }W nP tk
rX   zt| j}W n ttfk
rR   Y nX Y n tk
rj   Y nX t|S )a^  Find the absolute path to the file where an object was defined.

    This is essentially a robust wrapper around `inspect.getabsfile`.

    Returns None if no file can be found.

    Parameters
    ----------
    obj : any Python object

    Returns
    -------
    fname : str
        The absolute path to the file where the object was defined.
    N)ru   r:   
getabsfilerv   rw   rx   r   )r+   fnamer/   r/   r0   rW   N  s    
rW   c                 C   sz   t | } zt| d }W nZ tk
r`   zt| jd }W n ttfk
rZ   Y Y dS X Y n tk
rt   Y dS X |S )aW  Find the line number in a file where an object was defined.

    This is essentially a robust wrapper around `inspect.getsourcelines`.

    Returns None if no file can be found.

    Parameters
    ----------
    obj : any Python object

    Returns
    -------
    lineno : int
        The line number where the object definition starts.
    r   N)ru   r:   getsourcelinesrv   rw   rx   )r+   linenor/   r/   r0   find_source_linesq  s    r   c                       sB  e Zd Zeejddddf fdd	Zd4eedf dddZ	edd	d
Z
dd Zdd Zd5ddZed6ddZd7ddZd8ddZd9eedddZeedddZeeedddZedd d!Zd:eeee ed#d$d%Zd;ee d'd(d)Zd<d*d+Zd=eeef dd,d-Z e!d.d/ Z"g d0d0fd0d1d2d3Z#  Z$S )>r   Nr   c                    sJ   t t| j||d || _tjd| |d| _| jj| _|| _| 	| d S )N)r*   configr7   )outr*   style)
superr   __init__color_tabler   Parserparserformatstr_detail_levelset_active_scheme)r-   r   Zcode_color_tableschemer   r*   r   rw   r/   r0   r     s    
zInspector.__init__rk   re   c                 C   s$   zt t||W S    Y dS X dS )zReturn the call signature for any callable object.

        If any exception is generated, None is returned instead and the
        exception is suppressed.N)_render_signaturer   )r-   r+   ry   r/   r/   r0   _getdef  s    zInspector._getdefc                 C   s   d| j jj|| j jjf S )z*Return a header string with proper colors.z%s%s%s)r   Zactive_colorsheadernormal)r-   hr/   r/   r0   Z__head  s    zInspector.__headc                 C   s&   |d k	r"| j | | jj | d S rN   )r   r   r   )r-   r   r/   r/   r0   r     s    zInspector.set_active_schemec                 C   s,   t d| dd |r"t d|  nt   dS )z-Generic message when no information is found.zNo %s found endzfor %sN)print)r-   msgry   r/   r/   r0   noinfo  s    zInspector.noinfoc                 C   sf   t |std dS d}t|r,| d}| ||}|dkrN| d| nt|| |dd dS )zwPrint the call signature for any callable object.

        If the object is a class, print the constructor information.zObject is not callable.Nrk   zClass constructor information:
zdefinition headerr   r   )callabler   r:   rL   _Inspector__headr   r   r   )r-   r+   ry   r   outputr/   r/   r0   pdef  s    

zInspector.pdefc           	      C   s   | j }g }t|}|r&||d|}|rF||d |t| t|rt|drt|j}|dk	r||d |t| n4t|drt|j	}|r||d |t| |s| 
d| ntd	| dS )
a  Print the docstring for any object.

        Optional:
        -formatter: a function to run the docstring through for specially
        formatted docstrings.

        Examples
        --------
        In [1]: class NoInit:
           ...:     pass

        In [2]: class NoDoc:
           ...:     def __init__(self):
           ...:         pass

        In [3]: %pdoc NoDoc
        No documentation found for NoDoc

        In [4]: %pdoc NoInit
        No documentation found for NoInit

        In [5]: obj = NoInit()

        In [6]: %pdoc obj
        No documentation found for obj

        In [5]: obj2 = NoDoc()

        In [6]: %pdoc obj2
        No documentation found for obj2
        z
plain/textzClass docstring:r   NzInit docstring:r   zCall docstring:Zdocumentationro   )r   r;   r1   rq   r   r:   rL   hasattrr   r   r   r   rr   )	r-   r+   ry   	formatterheadrc   rj   init_dscall_dsr/   r/   r0   pdoc  s*    "


zInspector.pdocc                 C   s\   t   zt||d}W n tk
r0   d}Y nX |dkrH| d| nt| | dS )z$Print the source code for an object.)ry   NrF   )	linecache
checkcachert   rg   r   r   r   )r-   r+   ry   r}   r/   r/   r0   psource
  s    
zInspector.psourcec                 C   s~   t |}|dkr | d| dS t|}|dr@td|  n:tj|sZtd|  n t| 	t
j|dd|d  dS )	z0Show the whole file where an object was defined.NrC   rU   z File %r is binary, not printing.z%File %r does not exist, not printing.F)Zskip_encoding_cookier   )r   r   rW   rX   r   rY   rZ   r[   r   r   r   Zread_py_file)r-   r+   ry   r   r`   r/   r/   r0   pfile  s    
zInspector.pfile)textrf   c                 C   sX   |dt | dd}|dkr$|S ||}t|tsH|d| ddS t|f|S dS )aR  Return a mime bundle representation of the input text.

        - if `formatter` is None, the returned mime bundle has
           a ``text/plain`` field, with the input text.
           a ``text/html`` field with a ``<pre>`` tag containing the input text.

        - if ``formatter`` is not None, it must be a callable transforming the
          input text into a mime bundle. Default values for ``text/plain`` and
          ``text/html`` representations are the ones described above.

        Note:

        Formatters returning strings are supported but this behavior is deprecated.

        z<pre>z</pre>
text/plain	text/htmlN)htmlescaperh   dict)r-   r   r   r   	formattedr/   r/   r0   _mime_format0  s    
zInspector._mime_format)bundlerf   c           
      C   sJ  t |d tst|d D ]}t |tstqi }g }tdd |d D }|d D ]R\}}|d}d|krrdnd}|| |d  |t| d  | |  qTd	||d< d|krt |d tst|d D ]}t |tstqt |d ttfrd	dd |d D |d< |
 D ]}	|	d	kr:q&n||	 }q&|S )
zRFormat a mimebundle being created by _make_info_unformatted into a real mimebundler   c                 s   s   | ]\}}t |V  qd S rN   len)r<   r   _r/   r/   r0   	<genexpr>[  s     z(Inspector.format_mime.<locals>.<genexpr>ro   r   :r   c                 s   s"   | ]\}}d | d| V  qdS )z<h1>z</h1>
Nr/   )r<   r   bodyr/   r/   r0   r   n  s     )r   r   )rh   listAssertionErrortuplemaxstriprq   r   r   rr   keys)
r-   r   itemZnew_brc   _lenr   r   delimrO   r/   r/   r0   format_mimeR  s4    
(

zInspector.format_mimer   titlekeyc           	      C   s`   ||ks||krdS || }|dk	r\|  ||}|d ||d f |d ||d f dS )z^Append an info value to the unformatted mimebundle being constructed by _make_info_unformattedNr   r   )r   rq   )	r-   r   r   r   infoomit_sectionsr   r.   Zformatted_fieldr/   r/   r0   _append_info_fieldx  s    
zInspector._append_info_fieldc           	         s  g g d}d+t ttd fdd}tdfdd} d	 rP||d
d n d r|dkrp||dd| n||dd| ||dd nR d st|r||dd| ||dd| ||dd| |dkr d r||dd| n||dd| ||dd ||dd ||dd n||dd| ||dd | ||dd ||d!d  d" d#krl||d$d" ||d%d& ||dd |dkr d r||dd| n||dd| ||d'd(| ||dd| ||d)d*| |S ),z;Assemble the mimebundle as unformatted lists of informationr   Nr   c                    s   j | || |d d S )N)r   r   r   r   r   )r   )r   r   r   r   r   r   r-   r/   r0   append_field  s    z6Inspector._make_info_unformatted.<locals>.append_fieldre   c                    s     | t| dS )Nr   )r   r9   )r   )r-   r/   r0   code_formatter  s    z8Inspector._make_info_unformatted.<locals>.code_formatterr'   ReprrA   r&   r   ZSourcerF   Z	DocstringrE   FilerC   rL   	SignaturerD   zInit signaturerG   zInit docstringrI   Typer?   Z
Subclasses
subclasseszCall signaturerJ   zString formr)   Interactive	NamespaceZLengthrB   zClass docstringrH   zCall docstringrK   )N)r#   r7   r$   r   )	r-   r+   r   r   detail_levelr   r   r   r   r/   r   r0   _make_info_unformatted  sT       z Inspector._make_info_unformattedr/   )r+   ry   r   rf   c           	      C   s0   | j ||||d}| j|||||d}| |S )a9  Retrieve an info dict and format it.

        Parameters
        ----------
        obj : any
            Object to inspect and return info from
        oname : str (default: ''):
            Name of the variable pointing to `obj`.
        formatter : callable
        info
            already computed information
        detail_level : integer
            Granularity of detail level, if set to 1, give more information.
        omit_sections : container[str]
            Titles or keys to omit from output (can be set, tuple, etc., anything supporting `in`)
        ry   r   r   )r   r   )r   r   r   )	r-   r+   ry   r   r   r   r   Z	info_dictr   r/   r/   r0   	_get_info  s    zInspector._get_infoT)r   c           	      C   s:   |dk	st | j||||||d}|s,|d= t| dS )a   Show detailed information about an object.

        Optional arguments:

        - oname: name of the variable pointing to the object.

        - formatter: callable (optional)
              A special formatter for docstrings.

              The formatter is a callable that takes a string as an input
              and returns either a formatted string or a mime type bundle
              in the form of a dictionary.

              Although the support of custom formatter returning a string
              instead of a mime type bundle is deprecated.

        - info: a structure with some information fields which may have been
          precomputed already.

        - detail_level: if set to 1, more information is given.

        - omit_sections: set of section keys and titles to omit
        N)r   r   )r   r   r   )	r-   r+   ry   r   r   r   Zenable_html_pagerr   Zinfo_br/   r/   r0   pinfo  s    !     zInspector.pinfoc                 C   s"   t jdtdd | j||||dS )z
        Inspector.info() was likely improperly marked as deprecated
        while only a parameter was deprecated. We "un-deprecate" it.
        zThe `Inspector.info()` method has been un-deprecated as of 8.0 and the `formatter=` keyword removed. `Inspector._info` is now an alias, and you can just call `.info()` directly.r   r   r   )r   r   r   r   )r-   r+   ry   r   r   r/   r/   r0   _info&  s    zInspector._infoc           !      C   sD  |dkrd}d}d}n|j }|j}|j}|dd }d}	d}
|rp|jdk	rpt|jtrpt|jt}||d}	t	|d||dd}|	r|	}nt|rt
|szd|d	  }W q   d
t| }Y qX n dt| }|jr|d|j 7 }nt|}|dkrd}n|}|
| }d}t|d d }|r,d|d< n|r<d|d< nt|j|d< z|j}t||d< W n   Y nX || jkrztt|}d}|st||kr|d| d || d  }ddt|   dd |dD }|||< W n   Y nX |r
||d< ztt||d< W n tk
r4   Y nX d}t|}|dkrRd}n.|drdd}n|drtd}t||d < |rt  z:t|ts|st||}|dk	r| }||d!< W n tk
r   Y nX |r|  |d!|s||d"< t!"|rd|d#< z| #||}W n t$k
r@   d}Y nX z
|j%}W n t$k
rf   d}Y nJX |dkrz| #||}W n t$k
r   Y nX t|}|t&krd}|r||d$< |r||d%< d&d' t'|D }t|d(k rd)|}nd)|dd( d*g }||d+< n| #||}|r8||d,< |rzt|d-}W n   d}Y n
X t|}|t(krtd}|r||kr||d.< zt|j%}|t&krd}W n t$k
r   d}Y nX |r||d%< t)|d/r:t*|s:| #|j+|}|r||d,kr||d0< t|j+} | t,kr,d} | r:| |d1< t-f |S )2a  Compute a dict with detailed information about an object.

        Parameters
        ----------
        obj : any
            An object to find information about
        oname : str (default: '')
            Name of the variable pointing to `obj`.
        info : (default: None)
            A struct (dict like with attr access) with some information fields
            which may have been precomputed already.
        detail_level : int (default:0)
            If set to 1, more information is given.

        Returns
        -------
        An object info dict with known fields from `info_fields`. Keys are
        strings, values are string or None.
        NFrk   .T)rM   r(   r'   r&   r   z!Alias to the system command:
  %sr   zAlias: z	Alias to z
Docstring:
z<no docstring>      r   zMagic functionr?   zSystem aliasr@   rA   z <...> ro   r   c                 s   s   | ]}|  V  qd S rN   )r   )r<   qr/   r/   r0   r     s     z!Inspector.info.<locals>.<genexpr>r)   rB   rU   z<string>z9Dynamically generated function. No source code available.rC   rF   rE   rL   rG   rI   c                 S   s   g | ]
}|j qS r/   )r2   )r<   subr/   r/   r0   
<listcomp>  s     z"Inspector.info.<locals>.<listcomp>r   , z...r   rD   rw   rH   r   rJ   rK   ).r&   r'   r)   splitr*   r   	HOOK_NAMEr,   r1   r   r   r7   __doc__r;   inttyper2   rw   r   r   
expandtabsrr   rg   rW   rX   r   r   r   rh   rp   rt   rstrip_source_contains_docstringr:   rL   r   AttributeErrorr   _object_init_docstring__subclasses___builtin_type_docstringsr   r   r   _func_call_docstringrT   )!r-   r+   ry   r   r   r&   r'   ZospaceZatt_nameZparents_docsZpreludeZparents_docs_dictr   rj   Z
ds_or_NoneZ
string_maxZshalfZbclassZostrZstr_headbinary_filer   r}   Zinit_defZobj_initr   namesZ	all_namesZdeflnclsZclass_dsrJ   r   r/   r/   r0   r   5  s"       
















zInspector.infoc                 C   s>   z"t t| j\}t ||kW S  tk
r8   Y dS X dS )z
        Check whether the source *src* contains the docstring *doc*.

        This is is helper function to skip displaying the docstring if the
        source already contains it, avoiding repetition of information.
        FN)astparser   r   get_docstringrg   )r}   r   Zdef_noder/   r/   r0   r    s
    z$Inspector._source_contains_docstringF)
list_typesc                C   s   d}d}|r$t  dtt dS | }	t|	}
|
dkrF|	d }n|
dkrX|	\}}ntd| |D ] }||krhtd	|| f qht t  }}|D ]D}|| }t	||krq|
t	| t|||||d
}|| qt  dt| dS )a  Search namespaces with wildcards for objects.

        Arguments:

        - pattern: string containing shell-like wildcards to use in namespace
          searches and optionally a type specification to narrow the search to
          objects of that type.

        - ns_table: dict of name->namespaces for search.

        Optional arguments:

          - ns_search: list of namespace names to include in search.

          - ignore_case(False): make the search case-insensitive.

          - show_all(False): show all names, including those starting with
            underscores.

          - list_types(False): list all available object types for object matching.
        allrk   ro   Nr   r   r   z)invalid argument string for psearch: <%s>z'invalid namespace <%s>. Valid names: %s)ignore_caseshow_all)r   rr   sortedr   r   r   
ValueErrorr   setidaddr   rR   )r-   patternZns_tableZ	ns_searchr  r  r  Ztype_patternfilterZcmdsZlen_cmdsrM   Zsearch_resultZnamespaces_seenZns_namensZtmp_resr/   r/   r0   psearch(  s>    


 zInspector.psearch)rk   )rk   )rk   N)rk   )rk   )N)rk   NNr   r/   )rk   NNr   Tr/   )rk   Nr   )rk   Nr   )%r2   r3   r4   r   r   ANSICodeColorsr   r
   r7   r   r   r   r   r   r   r   r   r   r   r   r#   r$   r   r   r   r   r   r%   r   r   r   r	   r   staticmethodr  r  __classcell__r/   r/   r   r0   r     sn    

9

"(R     '      )
 c
 c                 C   s  g }d}d}| j  D ]l}|jtjjkr.d}n|r@|d d}|jtjjkrTd}n |jtjjkrt|rt|d d}|t	| q|r|d t
|tdd |D  dkrd|d	d
d |D }nd|d|}| jtjk	rt| j}|d|7 }|S )z
    This was mostly taken from inspect.Signature.__str__.
    Look there for the comments.
    The only change is to add linebreaks when this gets too long.
    FT/*c                 s   s   | ]}t |d  V  qdS )r   Nr   r<   rr/   r/   r0   r     s     z$_render_signature.<locals>.<genexpr>K   z{}(
{})rk   c                 s   s   | ]}d  |V  qdS )z    {},
N)r   r#  r/   r/   r0   r     s    z{}({})r   z -> {})
parametersvalueskindr:   	ParameterPOSITIONAL_ONLYrq   VAR_POSITIONALKEYWORD_ONLYr7   r   sumr   rr   return_annotation_emptyformatannotation)Zobj_signatureobj_nameresultZpos_onlykw_onlyparamrenderedannor/   r/   r0   r   k  s4    


r   )rk   )T)dr   __all__dataclassesr   r:   r   textwrapr   r  r   ior\   r   rY   systypesr   typingr   r   r	   r
   r   r   version_infoZtyping_extensionsr   ZIPython.corer   ZIPython.lib.prettyr   ZIPython.testing.skipdoctestr   ZIPython.utilsr   r   ZIPython.utils.dir2r   ZIPython.utils.pathr   ZIPython.utils.textr   ZIPython.utils.wildcardr   r   ZIPython.utils.coloransir   r   r   ZIPython.utils.py3compatr   ZIPython.utils.colorabler   ZIPython.utils.decoratorsr   pygmentsr    Zpygments.lexersr!   Zpygments.formattersr"   r   r7   r#   r6   r$   r%   r9   FunctionTyper   r
  objectr   r  
ModuleType
MethodTyperp   r	  r  r  r   upperr   ZColorsr  r   rQ   rT   rd   r;   rt   r   r   r   r   ru   rW   r   r   r   r/   r/   r/   r0   <module>   s    
 
 
           
?

%#     `