403Webshell
Server IP : 35.80.110.71  /  Your IP : 216.73.216.170
Web Server : Apache/2.4.58 (Ubuntu)
System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64
User : ubuntu ( 1000)
PHP Version : 8.3.31
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/IPython/core/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/python3/dist-packages/IPython/core/__pycache__/formatters.cpython-312.pyc
�

}�e����&�dZddlZddlZddlZddlZddlmZddlmZddlm	Z	ddl
mZdd	lm
Z
dd
lmZddlmZddlmZmZmZmZmZmZmZmZmZmZdd
lmZGd�de	�Zd�Z Gd�de!�Z"ed��Z#Gd�dejH��Z%d�Z&d�Z'e
de(d�Z)Gd�de	�Z*Gd�de*�Z+Gd�d e*�Z,Gd!�d"e*�Z-Gd#�d$e*�Z.Gd%�d&e*�Z/Gd'�d(e*�Z0Gd)�d*e*�Z1Gd+�d,e*�Z2Gd-�d.e*�Z3Gd/�d0e*�Z4Gd1�d2e*�Z5Gd3�d4e*�Z6e%joe*�e%joe+�e%joe,�e%joe-�e%joe.�e%joe/�e%joe4�e%joe0�e%joe1�e%joe2�e%joe3�e%joe5�e%joe6�d6d5�Z8y)7ziDisplay formatters.

Inheritance diagram:

.. inheritance-diagram:: IPython.core.formatters
   :parts: 3
�N)�StringIO)�	decorator)�Configurable�)�get_ipython�)�Sentinel)�get_real_method)�pretty)
�Bool�Dict�Integer�Unicode�CUnicode�
ObjectName�List�ForwardDeclaredInstance�default�observe)�Anyc��eZdZee�d��jd��Zed�d��Ze	d�d��Z
ed�Zed	�d
��Z
ed�Zed�d��Ze�Zed
�d��Zdd�Zed��Zy)�DisplayFormatterz�List of currently active mime-types to display.
        You can use this to set a white-list for formats to display.
        
        Most users will not need to change this value.
        ��helpT��config�active_typesc��|jS�N)�format_types��selfs �9/usr/lib/python3/dist-packages/IPython/core/formatters.py�_active_types_defaultz&DisplayFormatter._active_types_default,s��� � � �c�t�|jj�D]\}}||dvrd|_�d|_�y)N�newTF)�
formatters�items�enabled)r"�change�key�	formatters    r#�_active_types_changedz&DisplayFormatter._active_types_changed0s>��"�o�o�3�3�5�	*�N�C���f�U�m�#�$(�	�!�$)�	�!�		*r%�FormatterABC�ipython_display_formatterc��t|��S�N��parent)�IPythonDisplayFormatterr!s r#�_default_formatterz#DisplayFormatter._default_formatter9s
��&�d�3�3r%�mimebundle_formatterc��t|��Sr2)�MimeBundleFormatterr!s r#�_default_mime_formatterz(DisplayFormatter._default_mime_formatter>s
��"�$�/�/r%r(c
��tttttt
ttttg
}i}|D]}||��}|||j<�|S)z Activate the default formatters.r3)�PlainTextFormatter�
HTMLFormatter�MarkdownFormatter�SVGFormatter�PNGFormatter�PDFFormatter�
JPEGFormatter�LatexFormatter�
JSONFormatter�JavascriptFormatter�format_type)r"�formatter_classes�d�cls�fs     r#�_formatters_defaultz$DisplayFormatter._formatters_defaultEs_��
����������
��
��$�	!�C��4� �A� �A�a�m�m��	!��r%Nc��i}i}|j|�riifS|j|||��\}}|s|r�|rP|j�D��cic]
\}}||vs�||��}}}|j�D��cic]
\}}||vs�||��}}}|rP|j�D��cic]
\}}||vs�||��}}}|j�D��cic]
\}}||vs�||��}}}|jj�D]f\}}	||vr	|	j	|�|r||vr�#|r||vr�*d}
	|	|�}t
|t�rt|�dk(r|\}}
|�|||<|
��b|
||<�h||fScc}}wcc}}wcc}}wcc}}w#t
$rY��wxYw#�xYw)a�Return a format data dict for an object.

        By default all format types will be computed.

        The following MIME types are usually implemented:

        * text/plain
        * text/html
        * text/markdown
        * text/latex
        * application/json
        * application/javascript
        * application/pdf
        * image/png
        * image/jpeg
        * image/svg+xml

        Parameters
        ----------
        obj : object
            The Python object whose format data will be computed.
        include : list, tuple or set; optional
            A list of format type strings (MIME types) to include in the
            format data dict. If this is set *only* the format types included
            in this list will be computed.
        exclude : list, tuple or set; optional
            A list of format type string (MIME types) to exclude in the format
            data dict. If this is set all format types will be computed,
            except for those included in this argument.
            Mimetypes present in exclude will take precedence over the ones in include

        Returns
        -------
        (format_dict, metadata_dict) : tuple of two dicts
            format_dict is a dictionary of key/value pairs, one of each format that was
            generated for the object. The keys are the format types, which
            will usually be MIME type strings and the values and JSON'able
            data structure containing the raw data for the representation in
            that format.

            metadata_dict is a dictionary of metadata about each mime-type output.
            Its keys will be a strict subset of the keys in format_dict.

        Notes
        -----
            If an object implement `_repr_mimebundle_` as well as various
            `_repr_*_`, the data returned by `_repr_mimebundle_` will take
            precedence and the corresponding `_repr_*_` for this mimetype will
            not be called.

        ��include�excludeNr)	r0r7r)r(�lookup�KeyError�
isinstance�tuple�len)r"�objrNrO�format_dict�md_dict�k�vrFr-�md�datas            r#�formatzDisplayFormatter.formatZs���h�����)�)�#�.��r�6�M�#�8�8��g�W^�8�_���W��'��.9�.?�.?�.A�R�s�q��Q�'�\�q��s�R��R�*1�-�-�/�J�3�1�Q�Q�'�\�1�Q�3�J��J��.9�.?�.?�.A�V�s�q��Q�g�EU�q��s�V��V�*1�-�-�/�N�3�1�Q�Q�g�=M�1�Q�3�N��N�&*�o�o�&;�&;�&=� 	*�"�K���k�)���$�$�S�)��;�g�5���;�'�1���B�
� ��~���$��&�3�t�9��>����b���+/��K�(��~�')���$�A 	*�B�G�#�#��OS��J��V��N�� �����
��sN�
E �E �2E&�?E&�E,�)E,�E2�E2�>E8� F�8	F�F�F
c�H�t|jj��S)z>Return the format types (MIME types) of the active formatters.)�listr(�keysr!s r#r zDisplayFormatter.format_types�s���D�O�O�(�(�*�+�+r%�NN)�__name__�
__module__�__qualname__rr�tagrrr$rr.rr0r6r7r:r
r(rKr\�propertyr �r%r#rr#s�����	��
�
�S��S�
��
�^��!��!�
�^��*��*�!8�� G���
(�)�4�*�4�3�>�B���
#�$�0�%�0�
��J��\�����(f$�P�,��,r%rc�P�	t|�S#t$r}d|zcYd}~Sd}~wwxYw)zNTry to return a repr of an object

    always returns a string, at least.
    zun-repr-able object (%r)N)�repr�	Exception)rU�es  r#�
_safe_reprrk�s,��
.��C�y����.�)�A�-�-��.�s�

�	%� �%�%c��eZdZdZy)�FormatterWarningz&Warning class for errors in formattersN)rarbrc�__doc__rfr%r#rmrm�s��0r%rmc�T�	||g|��i|��}|j||d�S#t$r|jd|d�cYSt$r\tj�}t�}|�|j
|�ntj|�|jd|d�cYSwxYw)z$show traceback on failed format callNr)	�NotImplementedError�
_check_returnri�sys�exc_infor�
showtraceback�	traceback�print_exception)�methodr"�args�kwargs�rrs�ips       r#�catch_format_errorr|�s���1��4�)�$�)�&�)�����a��a��)�)���1��!�!�$��Q��0�0��1��<�<�>��
�]��
�>����X�&��%�%�x�0��!�!�$��Q��0�0�1�s�#�B'�A!B'�&B'c�<�eZdZdZdZdZejd��Zy)r/aE Abstract base class for Formatters.

    A formatter is a callable class that is responsible for computing the
    raw format data for a particular format type (MIME type). For example,
    an HTML formatter would have a format type of `text/html` and would return
    the HTML representation of the object when called.
    �
text/plainTc��t|�S)z�Return a JSON'able representation of the object.

        If the object cannot be formatted by this formatter,
        warn and return None.
        )rh)r"rUs  r#�__call__zFormatterABC.__call__�s���C�y�r%N)	rarbrcrnrFr*�abc�abstractmethodr�rfr%r#r/r/�s-����K��G������r%r/)�	metaclassc�>�t|dd�}t|dd�}||fS)zgReturn a (__module__, __name__) tuple for a type.

    Used as key in Formatter.deferred_printers.
    rbNra)�getattr)�typ�module�names   r#�
_mod_name_keyr�s*��
�S�,��
-�F��3�
�D�)�D��D�>�r%c�6�t|dd�xst|�S)z2Return the type of an instance (old and new-style)�	__class__N)r��type)rUs r#�	_get_typer�s���3��T�*�7�d�3�i�7r%�_raise_key_errorzr
Special value to raise a KeyError

Raise KeyError in `BaseFormatter.pop` if passed as the default value to `pop`
c�B�eZdZUdZed�ZeZee	d<e
d�jd��Ze
d�Ze�jd��Ze�jd��Ze�jd��Zed��Zd�Zd	�Zd
�Zd�Zdd
�Zdd�Zefd�Zd�Zy)�
BaseFormattera�A base formatter class that is configurable.

    This formatter should usually be used as the base class of all formatters.
    It is a traited :class:`Configurable` class and includes an extensible
    API for users to determine how their objects are formatted. The following
    logic is used to find a function to format an given object.

    1. The object is introspected to see if it has a method with the name
       :attr:`print_method`. If is does, that object is passed to that method
       for formatting.
    2. If no print method is found, three internal dictionaries are consulted
       to find print method: :attr:`singleton_printers`, :attr:`type_printers`
       and :attr:`deferred_printers`.

    Users should use these dictionaries to register functions that will be
    used to compute the format data for their objects (if those objects don't
    have the special print methods). The easiest way of using these
    dictionaries is through the :meth:`for_type` and :meth:`for_type_by_name`
    methods.

    If no function/callable is found to compute the format data, ``None`` is
    returned and this format type is not used.
    r~�_return_typeTr�__repr__c��|jr	|j|�}||�Sy#t$rYnwxYwt||j�}|�|�Sy)�!Compute the format for an object.N�r*rPrQr
�print_method�r"rU�printerrws    r#r�zBaseFormatter.__call__Jsg���<�<�
$��+�+�c�*���s�|�#����
��
��
%�S�$�*;�*;�<�F��!��x����(�	4�4c�F�	|j|�y#t$rYywxYw)zmap in to lookup_by_typeTF)�lookup_by_typerQ)r"r�s  r#�__contains__zBaseFormatter.__contains__]s.��	�����$����	��	�s��	 � c�$�|�At||j�s+t|t�r|rt|d|j�r|Stj|j
�dt
|��d|j�dt|���t�y)�vCheck that a return value is appropriate

        Return the value if so, None otherwise, warning if invalid.
        Nrz! formatter returned invalid type z (expected z) for object: )	rRr�rS�warnings�warnrFr�rkrm)r"rzrUs   r#rqzBaseFormatter._check_returnfsn��

�9�
�1�d�&7�&7�8�
��5�
!�a�J�q��t�T�=N�=N�,O��H��M�M��!�!�4��7�D�,=�,=�z�#��P� �
r%c��t|�}||jvr|j|S|jt|��S)aALook up the formatter for a given instance.

        Parameters
        ----------
        obj : object instance

        Returns
        -------
        f : callable
            The registered formatting callable for the type.

        Raises
        ------
        KeyError if the type has not been registered.
        )�id�singleton_printersr�r�)r"rU�obj_ids   r#rPzBaseFormatter.lookupusA��"�C����T�,�,�,��*�*�6�2�2��"�"�9�S�>�2�2r%c��t|t�rit|jdd��}||jvr1|j
D]!}t
|�|k(s�|j
|cSnY|j|Stj|�D]2}||j
vs|j|�s�#|j
|cStdj|���)abLook up the registered formatter for a type.

        Parameters
        ----------
        typ : type or '__module__.__name__' string for a type

        Returns
        -------
        f : callable
            The registered formatting callable for the type.

        Raises
        ------
        KeyError if the type has not been registered.
        �.rzNo registered printer for {0!r})rR�strrS�rsplit�deferred_printers�
type_printersr�r�_get_mro�_in_deferred_typesrQr\)r"r��typ_keyrIs    r#r�zBaseFormatter.lookup_by_type�s��� �c�3���C�J�J�s�1�-�.�G��d�4�4�4� �-�-�7�C�$�S�)�W�4�#�1�1�#�6�6�7��-�-�g�6�6����s�+�
3���$�,�,�,��0G�0G��0L��-�-�c�2�2�
3�
�8�?�?��D�E�Er%Nc���t|t�r(|jdd�\}}|j|||�S	|j	|�}|�||j|<|S#t
$rd}Y� wxYw)atAdd a format function for a given type.

        Parameters
        ----------
        typ : type or '__module__.__name__' string for a type
            The class of the object that will be formatted using `func`.

        func : callable
            A callable for computing the format data.
            `func` will be called with the object to be formatted,
            and will return the raw data in this formatter's format.
            Subclasses may use a different call signature for the
            `func` argument.

            If `func` is None or not specified, there will be no change,
            only returning the current value.

        Returns
        -------
        oldfunc : callable
            The currently registered callable.
            If you are registering a new formatter,
            this will be the previous value (to enable restoring later).
        r�rN)rRr�r��for_type_by_namer�rQr�)r"r��func�type_module�	type_name�oldfuncs      r#�for_typezBaseFormatter.for_type�s���4�c�3��%(�Z�Z��Q�%7�"�K���(�(��i��F�F�	��)�)�#�.�G���&*�D���s�#����
�	��G�	�s�A�A,�+A,c�|�||f}	|jd|z�}|�||j|<|S#t$rd}Y� wxYw)a"Add a format function for a type specified by the full dotted
        module and name of the type, rather than the type of the object.

        Parameters
        ----------
        type_module : str
            The full dotted name of the module the type is defined in, like
            ``numpy``.

        type_name : str
            The name of the type (the class name), like ``dtype``

        func : callable
            A callable for computing the format data.
            `func` will be called with the object to be formatted,
            and will return the raw data in this formatter's format.
            Subclasses may use a different call signature for the
            `func` argument.

            If `func` is None or unspecified, there will be no change,
            only returning the current value.

        Returns
        -------
        oldfunc : callable
            The currently registered callable.
            If you are registering a new formatter,
            this will be the previous value (to enable restoring later).
        z%s.%sN)r�rQr�)r"r�r�r�r,r�s      r#r�zBaseFormatter.for_type_by_name�sZ��<�I�&��	��)�)�'�C�-�8�G���*.�D�"�"�3�'�����	��G�	�s�-�;�;c��t|t�r�t|jdd��}||jvr?|j
D]-}t
|�|k(s�|j
j|�}no|}nk|jj|�}nO||j
vr|j
j|�}n%|jjt
|�|�}|turtdj|���|S)a�Pop a formatter for the given type.

        Parameters
        ----------
        typ : type or '__module__.__name__' string for a type
        default : object
            value to be returned if no formatter is registered for typ.

        Returns
        -------
        obj : object
            The last registered object for the type.

        Raises
        ------
        KeyError if the type is not registered and default is not specified.
        r�rzNo registered value for {0!r})rRr�rSr�r�r�r��popr�rQr\)r"r�rr�rI�olds      r#r�zBaseFormatter.pop�s���&�c�3���C�J�J�s�1�-�.�G��d�4�4�4� �-�-�"�C�$�S�)�W�4�"�0�0�4�4�S�9���"�
"�C��,�,�0�0��9���d�(�(�(��(�(�,�,�S�1���,�,�0�0��s�1C�W�M���"�"��:�A�A�#�F�G�G��
r%c��t|dd�}t|dd�}||f}||jvr+|jj|�}||j|<yy)z�
        Check if the given class is specified in the deferred type registry.

        Successful matches will be moved to the regular type registry for future use.
        rbNraTF)r�r�r�r�)r"rI�modr�r,r�s      r#r�z BaseFormatter._in_deferred_types(sc���c�<��.���s�J��-���D�k���$�(�(�(��,�,�0�0��5�G�&-�D���s�#��r%r)rarbrcrnrrFr�r�r�__annotations__rrdr*rr�r
r�r�r�r|r�r�rqrPr�r�r�r�r�r�rfr%r#r�r�s����0�,�'�K��L�#���4�j�n�n�D�n�)�G��j�)�L�����4��0���F�J�J�d�J�+�M���
�
�$�
�/������$�
�3�. F�D&�P'�R 0�'�Rr%r�c�(�eZdZdZed�Zed�jd��Ze	e
jd��jd��Ze
d�Zed�jd��Zed�jd��Ze	d	�jd��Zed
�jd��Zed�Zed�jd��Zed
�d��Zed�d��Zed�d��Zed�d��Zed��Zy)r<a`The default pretty-printer.

    This uses :mod:`IPython.lib.pretty` to compute the format data of
    the object. If the object cannot be pretty printed, :func:`repr` is used.
    See the documentation of :mod:`IPython.lib.pretty` for details on
    how to write pretty printers.  Here is a simple example::

        def dtype_pprinter(obj, p, cycle):
            if cycle:
                return p.text('dtype(...)')
            if hasattr(obj, 'fields'):
                if obj.fields is None:
                    p.text(repr(obj))
                else:
                    p.begin_group(7, 'dtype([')
                    for i, field in enumerate(obj.descr):
                        if i > 0:
                            p.text(',')
                            p.breakable()
                        p.pretty(field)
                    p.end_group(7, '])')
    r~TFrzTruncate large collections (lists, dicts, tuples, sets) to this size.
        
        Set to 0 to disable truncation.
        r�
_repr_pretty_�O�
�%r��float_precisionc���|d}d|vr|}	|dz||_y|rI	t|�}|dk\sJ�	d|z}d	tj
vrHddl}|j|�
�||_yd}d	tj
vrddl}|jd�
�||_y#t$r}td|z�|�d}~wwxYw#t$r}td|z�|�d}~wt$r}tdz�|�d}~wwxYw)
a�float_precision changed, set float_format accordingly.

        float_precision can be set by int or str.
        This will set float_format, after interpreting input.
        If numpy has been imported, numpy print precision will also be set.

        integer `n` sets format to '%.nf', otherwise, format set directly.

        An empty string returns to defaults (repr for float, 8 for numpy).

        This parameter can be set via the '%precision' magic.
        r'�%gn��!	@z.Precision must be int or format string, not %rNrz*int precision must be non-negative, not %rz%%.%if�numpy)�	precisionr��)	ri�
ValueError�int�AssertionErrorrr�modulesr��set_printoptions�float_format)r"r+r'�fmtrj�ir�s       r#�_float_precision_changedz+PlainTextFormatter._float_precision_changedss"���U�m���#�:��C�
^��G��2 ���-�
X���H���A�v�
�v��1�*�C��#�+�+�%���&�&��&�3� ����C��#�+�+�%���&�&��&�3�����1�
^� �!Q�RU�!U�V�\]�]��
^���
^� �!Q�RU�!U�V�\]�]��!�
X� �!M�a�!O�P�VW�W��
X�s:�B�B7�	B4� B/�/B4�7	C/�C�C/�C*�*C/r�c�>�tjj�Sr)r�_singleton_pprinters�copyr!s r#�_singleton_printers_defaultz.PlainTextFormatter._singleton_printers_default�s���*�*�/�/�1�1r%r�c���tjj�}�fd�|t<dtj
vrddl}�fd�||j<|S)Nc�@��|j�j|z�Sr��textr��rU�p�cycler"s   �r#�<lambda>z;PlainTextFormatter._type_printers_default.<locals>.<lambda>�s���q�v�v�d�.?�.?��.C�'D�r%r�rc�@��|j�j|z�Srr�r�s   �r#r�z;PlainTextFormatter._type_printers_default.<locals>.<lambda>�s���Q�V�V�D�<M�<M�PS�<S�5T�r%)r�_type_pprintersr��floatrrr�r��float64)r"rHr�s`  r#�_type_printers_defaultz)PlainTextFormatter._type_printers_default�sB����"�"�'�'�)��D��%���c�k�k�!��T�A�e�m�m���r%r�c�>�tjj�Sr)r�_deferred_type_pprintersr�r!s r#�_deferred_printers_defaultz-PlainTextFormatter._deferred_printers_default�s���.�.�3�3�5�5r%c
�l�|jst|�St�}tj||j
|j|j|j|j|j|j��}|j|�|j�|j�S)z0Compute the pretty representation of the object.)�max_seq_length�singleton_pprinters�type_pprinters�deferred_pprinters)�pprintrhrr�RepresentationPrinter�verbose�	max_width�newliner�r�r�r��flush�getvalue)r"rU�streamr�s    r#r�zPlainTextFormatter.__call__�s����{�{���9���Z�F��2�2�6�4�<�<�������#�2�2�$(�$;�$;�#�1�1�#'�#9�#9�;�G�
�N�N�3���M�M�O��?�?�$�$r%N)rarbrcrnrrFrrdr*rr�MAX_SEQ_LENGTHr�rr�r�r�r�r�r�rr�rr�rr�r�r�r|r�rfr%r#r<r<9sT���0�,�'�K��4�j�n�n�E�n�*�G��V�2�2���

�c��c����o�.�L��$�Z�^�^�4�^�
(�F��5�k�o�o�T�o�*�G������t��,�I��d�m���t��,�G��4�=�L��r�l�&�&�d�&�3�O��
��+ � �+ �\
�
!�"�2�#�2�
�_�����
�
 �!�6�"�6�
�%��%r%r<c�0�eZdZdZed�Zed�Zy)r=a�An HTML formatter.

    To define the callables that compute the HTML representation of your
    objects, define a :meth:`_repr_html_` method or use the :meth:`for_type`
    or :meth:`for_type_by_name` methods to register functions that handle
    this.

    The return value of this formatter should be a valid HTML snippet that
    could be injected into an existing DOM. It should *not* include the
    ```<html>`` or ```<body>`` tags.
    z	text/html�_repr_html_N�rarbrcrnrrFrr�rfr%r#r=r=�s��
��+�&�K��m�,�Lr%r=c�0�eZdZdZed�Zed�Zy)r>aQA Markdown formatter.

    To define the callables that compute the Markdown representation of your
    objects, define a :meth:`_repr_markdown_` method or use the :meth:`for_type`
    or :meth:`for_type_by_name` methods to register functions that handle
    this.

    The return value of this formatter should be a valid Markdown.
    z
text/markdown�_repr_markdown_Nr�rfr%r#r>r>�s����/�*�K��/�0�Lr%r>c�0�eZdZdZed�Zed�Zy)r?a�An SVG formatter.

    To define the callables that compute the SVG representation of your
    objects, define a :meth:`_repr_svg_` method or use the :meth:`for_type`
    or :meth:`for_type_by_name` methods to register functions that handle
    this.

    The return value of this formatter should be valid SVG enclosed in
    ```<svg>``` tags, that could be injected into an existing DOM. It should
    *not* include the ```<html>`` or ```<body>`` tags.
    z
image/svg+xml�
_repr_svg_Nr�rfr%r#r?r?�s��
��/�*�K��l�+�Lr%r?c�8�eZdZdZed�Zed�Zee	fZ
y)r@aXA PNG formatter.

    To define the callables that compute the PNG representation of your
    objects, define a :meth:`_repr_png_` method or use the :meth:`for_type`
    or :meth:`for_type_by_name` methods to register functions that handle
    this.

    The return value of this formatter should be raw PNG data, *not*
    base64 encoded.
    z	image/png�
_repr_png_N�rarbrcrnrrFrr��bytesr�r�rfr%r#r@r@�s&��	��+�&�K��l�+�L��3�<�Lr%r@c�8�eZdZdZed�Zed�Zee	fZ
y)rBa\A JPEG formatter.

    To define the callables that compute the JPEG representation of your
    objects, define a :meth:`_repr_jpeg_` method or use the :meth:`for_type`
    or :meth:`for_type_by_name` methods to register functions that handle
    this.

    The return value of this formatter should be raw JPEG data, *not*
    base64 encoded.
    z
image/jpeg�_repr_jpeg_Nr�rfr%r#rBrBs&��	��,�'�K��m�,�L��3�<�Lr%rBc�0�eZdZdZed�Zed�Zy)rCa�A LaTeX formatter.

    To define the callables that compute the LaTeX representation of your
    objects, define a :meth:`_repr_latex_` method or use the :meth:`for_type`
    or :meth:`for_type_by_name` methods to register functions that handle
    this.

    The return value of this formatter should be a valid LaTeX equation,
    enclosed in either ```$```, ```$$``` or another LaTeX equation
    environment.
    z
text/latex�_repr_latex_Nr�rfr%r#rCrCs��
��,�'�K��n�-�Lr%rCc�J��eZdZdZed�ZeefZe	d�Z
�fd�Z�xZS)rDa�A JSON string formatter.

    To define the callables that compute the JSONable representation of
    your objects, define a :meth:`_repr_json_` method or use the :meth:`for_type`
    or :meth:`for_type_by_name` methods to register functions that handle
    this.

    The return value of this formatter should be a JSONable list or dict.
    JSON scalars (None, number, string) are not allowed, only dict or list containers.
    zapplication/json�_repr_json_c���|�yd}t|t�r|\}}t|t�rJd��|�||f}tt|�||�S)r�Nz4JSON-as-string has been deprecated since IPython < 3)rRrSr��superrDrq)r"rzrUrZr�s    �r#rqzJSONFormatter._check_return>sj���

�9��
���a����E�A�r��
�s�
�	B�A�	B�
��>��B��A��]�D�7��3�?�?r%)
rarbrcrnrrFr^�dictr�rr�rq�
__classcell__�r�s@r#rDrD.s4���	��,�-�K��$�<�L��m�,�L�@�@r%rDc�0�eZdZdZed�Zed�Zy)rEa�A Javascript formatter.

    To define the callables that compute the Javascript representation of
    your objects, define a :meth:`_repr_javascript_` method or use the
    :meth:`for_type` or :meth:`for_type_by_name` methods to register functions
    that handle this.

    The return value of this formatter should be valid Javascript code and
    should *not* be enclosed in ```<script>``` tags.
    zapplication/javascript�_repr_javascript_Nr�rfr%r#rErETs��	��2�3�K��1�2�Lr%rEc�8�eZdZdZed�Zed�Zee	fZ
y)rAaXA PDF formatter.

    To define the callables that compute the PDF representation of your
    objects, define a :meth:`_repr_pdf_` method or use the :meth:`for_type`
    or :meth:`for_type_by_name` methods to register functions that handle
    this.

    The return value of this formatter should be raw PDF data, *not*
    base64 encoded.
    zapplication/pdf�
_repr_pdf_Nr�rfr%r#rArAds'��	��+�,�K��l�+�L��3�<�Lr%rAc�D�eZdZdZed�Zed�efZe	d��Z
y)r5a�An escape-hatch Formatter for objects that know how to display themselves.
    
    To define the callables that compute the representation of your
    objects, define a :meth:`_ipython_display_` method or use the :meth:`for_type`
    or :meth:`for_type_by_name` methods to register functions that handle
    this. Unlike mime-type displays, this method should not return anything,
    instead calling any appropriate display methods itself.
    
    This display formatter has highest priority.
    If it fires, no other display formatter will be called.

    Prior to IPython 6.1, `_ipython_display_` was the only way to display custom mime-types
    without registering a new Formatter.
    
    IPython 6.1 introduces `_repr_mimebundle_` for displaying custom mime-types,
    so `_ipython_display_` should only be used for objects that require unusual
    display patterns, such as multiple display calls.
    �_ipython_display_Nc��|jr	|j|�}||�yyy#t$rYnwxYwt||j�}|��*|�y)r�TNr�r�s    r#r�z IPythonDisplayFormatter.__call__�sj���<�<�
��+�+�c�*������"����
��
��%�S�$�*;�*;�<�F��!���s�*�	6�6)rarbrcrnrr�r��boolr�r|r�rfr%r#r5r5us4���$�1�2�L���J��%�L����r%r5c�H��eZdZdZed�ZeZ�fd�Ze	dd��Z
�xZS)r9a
A Formatter for arbitrary mime-types.

    Unlike other `_repr_<mimetype>_` methods,
    `_repr_mimebundle_` should return mime-bundle data,
    either the mime-keyed `data` dictionary or the tuple `(data, metadata)`.
    Any mime-type is valid.

    To define the callables that compute the mime-bundle representation of your
    objects, define a :meth:`_repr_mimebundle_` method or use the :meth:`for_type`
    or :meth:`for_type_by_name` methods to register functions that handle
    this.

    .. versionadded:: 6.1
    �_repr_mimebundle_c�d��tt|�||�}|�iifSt|t�s|ifS|Sr)rr9rqrRrS)r"rzrUr�s   �r#rqz!MimeBundleFormatter._check_return�s=����%�t�:�1�c�B���9��r�6�M��!�U�#��b�5�L��r%c��|jr	|j|�}||�Sy#t$rYnwxYwt||j�}|�
|||��Sy)z�Compute the format for an object.

        Identical to parent's method but we pass extra parameters to the method.

        Unlike other _repr_*_ `_repr_mimebundle_` should allow extra kwargs, in
        particular `include` and `exclude`.
        NrMr�)r"rUrNrOr�rws      r#r�zMimeBundleFormatter.__call__�sm���<�<�
$��+�+�c�*���s�|�#����
��
��
%�S�$�*;�*;�<�F��!��g�w�?�?�r�r`)rarbrcrnrr�rr�rqr|r�rrs@r#r9r9�s3���
��1�2�L��L�����r%r9c�d�ddlm}|j�jj	|||�S)a�Return a format data dict for an object.

    By default all format types will be computed.

    Parameters
    ----------
    obj : object
        The Python object whose format data will be computed.

    Returns
    -------
    format_dict : dict
        A dictionary of key/value pairs, one or each format that was
        generated for the object. The keys are the format types, which
        will usually be MIME type strings and the values and JSON'able
        data structure containing the raw data for the representation in
        that format.
    include : list or tuple, optional
        A list of format type strings (MIME types) to include in the
        format data dict. If this is set *only* the format types included
        in this list will be computed.
    exclude : list or tuple, optional
        A list of format type string (MIME types) to exclude in the format
        data dict. If this is set all format types will be computed,
        except for those included in this argument.
    r)�InteractiveShell)�interactiveshellr�instance�display_formatterr\)rUrNrOrs    r#�format_display_datar�s2��63��$�$�&�8�8�?�?�����r%r`)9rnr�rrrur��iorr�traitlets.config.configurabler�
getipythonr�utils.sentinelr	�
utils.dir2r
�libr�	traitletsrr
rrrrrrrr�typingrrrk�UserWarningrmr|�ABCMetar/r�r�rar�r�r<r=r>r?r@rBrCrDrErAr5r9�registerrrfr%r#�<module>r&s����
�����6�#�%�(������b,�|�b,�T.�1�{�1��*��*�$�S�[�[��2�8�
�.�����X�L�X�vM%��M%�`-�M�-�"1�
�1�,�=�,�" �=� �$ �M� �$.�]�.�"#@�M�#@�L
3�-�
3�  �=� �"&�m�&�R3�-�3�l
���m�$����(�)����m�$����'�(����l�#����l�#����l�#����m�$����n�%����m�$����)�*����-�.����)�*�!r%

Youez - 2016 - github.com/yon3zu
LinuXploit