U
    ½mœdTH  ã                   @   sŒ   d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl	m
Z
 G d	d
„ d
eƒZG dd„ deƒZdd„ ZG dd„ dejƒZddd„ZdS )ztThis module contains the _EstimatorPrettyPrinter class used in
BaseEstimator.__repr__ for pretty-printing estimatorsé    N)ÚOrderedDicté   )ÚBaseEstimator)Ú
get_configé   )Úis_scalar_nanc                       s    e Zd ZdZ‡ fdd„Z‡  ZS )ÚKeyValTuplez@Dummy class for correctly rendering key-value tuples from dicts.c                    s
   t ƒ  ¡ S ©N)ÚsuperÚ__repr__)Úself©Ú	__class__© úN/home/sam/Atlas/atlas_env/lib/python3.8/site-packages/sklearn/utils/_pprint.pyr   N   s    zKeyValTuple.__repr__)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   Ú__classcell__r   r   r   r   r   K   s   r   c                   @   s   e Zd ZdZdS )ÚKeyValTupleParamzEDummy class for correctly rendering key-value tuples from parameters.N)r   r   r   r   r   r   r   r   r   S   s   r   c                    s\   | j dd�}t| jd| jƒ}t |¡j‰dd„ ˆ ¡ D ƒ‰‡fdd„‰ ‡ fdd„| ¡ D ƒS )	zgReturn dict (param_name: value) of parameters that were given to
    estimator with non-default values.F©ÚdeepZdeprecated_originalc                 S   s   i | ]\}}||j “qS r   )Údefault)Ú.0ÚnameÚparamr   r   r   Ú
<dictcomp>`   s      z#_changed_params.<locals>.<dictcomp>c                    sl   | ˆ krdS ˆ |  t jkrdS t|tƒr<|jˆ |  jkr<dS t|ƒtˆ |  ƒkrhtˆ |  ƒrdt|ƒshdS dS )NTF)ÚinspectÚ_emptyÚ
isinstancer   r   Úreprr   )ÚkÚv)Úinit_paramsr   r   Úhas_changedb   s    
ÿÿz$_changed_params.<locals>.has_changedc                    s    i | ]\}}ˆ ||ƒr||“qS r   r   )r   r"   r#   )r%   r   r   r   q   s     
  )Ú
get_paramsÚgetattrÚ__init__r   Ú	signatureÚ
parametersÚitems)Z	estimatorÚparamsZ	init_funcr   )r%   r$   r   Ú_changed_paramsY   s    r-   c                       s„   e Zd ZdZdddddœ‡ fdd	„Zd
d„ Zdd„ Zdd„ Zdd„ Zdd„ Z	dd„ Z
dd„ Zejj ¡ Zeeej< eeej< ‡  ZS )Ú_EstimatorPrettyPrintera
  Pretty Printer class for estimator objects.

    This extends the pprint.PrettyPrinter class, because:
    - we need estimators to be printed with their parameters, e.g.
      Estimator(param1=value1, ...) which is not supported by default.
    - the 'compact' parameter of PrettyPrinter is ignored for dicts, which
      may lead to very long representations that we want to avoid.

    Quick overview of pprint.PrettyPrinter (see also
    https://stackoverflow.com/questions/49565047/pprint-with-hex-numbers):

    - the entry point is the _format() method which calls format() (overridden
      here)
    - format() directly calls _safe_repr() for a first try at rendering the
      object
    - _safe_repr formats the whole object recursively, only calling itself,
      not caring about line length or anything
    - back to _format(), if the output string is too long, _format() then calls
      the appropriate _pprint_TYPE() method (e.g. _pprint_list()) depending on
      the type of the object. This where the line length and the compact
      parameters are taken into account.
    - those _pprint_TYPE() methods will internally use the format() method for
      rendering the nested objects of an object (e.g. the elements of a list)

    In the end, everything has to be implemented twice: in _safe_repr and in
    the custom _pprint_TYPE methods. Unfortunately PrettyPrinter is really not
    straightforward to extend (especially when we want a compact output), so
    the code is a bit convoluted.

    This class overrides:
    - format() to support the changed_only parameter
    - _safe_repr to support printing of estimators (for when they fit on a
      single line)
    - _format_dict_items so that dict are correctly 'compacted'
    - _format_items so that ellipsis is used on long lists and tuples

    When estimators cannot be printed on a single line, the builtin _format()
    will call _pprint_estimator() because it was registered to do so (see
    _dispatch[BaseEstimator.__repr__] = _pprint_estimator).

    both _format_dict_items() and _pprint_estimator() use the
    _format_params_or_dict_items() method that will format parameters and
    key-value pairs respecting the compact parameter. This method needs another
    subroutine _pprint_key_val_tuple() used when a parameter or a key-value
    pair is too long to fit on a single line. This subroutine is called in
    _format() and is registered as well in the _dispatch dict (just like
    _pprint_estimator). We had to create the two classes KeyValTuple and
    KeyValTupleParam for this.
    r   éP   NFT)ÚcompactÚindent_at_nameÚn_max_elements_to_showc                   s>   t ƒ j|||||d� || _| jr(d| _tƒ d | _|| _d S )N)r0   r   Zprint_changed_only)r
   r(   Ú_indent_at_nameÚ_indent_per_levelr   Ú_changed_onlyr2   )r   ÚindentÚwidthÚdepthÚstreamr0   r1   r2   r   r   r   r(   §   s    z _EstimatorPrettyPrinter.__init__c                 C   s   t ||||| jd�S )N©Úchanged_only)Ú
_safe_reprr5   )r   ÚobjectÚcontextÚ	maxlevelsÚlevelr   r   r   Úformat¼   s        ÿz_EstimatorPrettyPrinter.formatc                 C   sˆ   |  |jjd ¡ | jr(|t|jjƒ7 }| jr8t|ƒ}n|jdd�}tdd„ t	| 
¡ ƒD ƒƒ}|  | 
¡ |||d ||¡ |  d¡ d S )Nú(Fr   c                 s   s   | ]\}}||fV  qd S r	   r   )r   r   Úvalr   r   r   Ú	<genexpr>Ë   s     z<_EstimatorPrettyPrinter._pprint_estimator.<locals>.<genexpr>r   ú))Úwriter   r   r3   Úlenr5   r-   r&   r   Úsortedr+   Ú_format_params)r   r=   r9   r6   Ú	allowancer>   r@   r,   r   r   r   Ú_pprint_estimatorÁ   s     
     ÿz)_EstimatorPrettyPrinter._pprint_estimatorc              	   C   s   | j ||||||dd�S )NT©Úis_dict©Ú_format_params_or_dict_items©r   r+   r9   r6   rJ   r>   r@   r   r   r   Ú_format_dict_itemsÒ   s          ÿz*_EstimatorPrettyPrinter._format_dict_itemsc              	   C   s   | j ||||||dd�S )NFrL   rN   rP   r   r   r   rI   ×   s          ÿz&_EstimatorPrettyPrinter._format_paramsc                 C   s¨  |j }|| j7 }dd|  }	d}
| j| d  }}t|ƒ}zt|ƒ}W n tk
r\   Y dS X d}d}|�s¤|| jkr‚|dƒ �q¤|d7 }|}zt|ƒ}W n( tk
rÂ   d	}||8 }||8 }Y nX | j�rf|\}}|  |||¡}|  |||¡}|�s | 	d
¡}|�r
dnd}|| | }t
|ƒd }||k �r>|}|
�r>|	}
||k�rf||8 }||
ƒ d}
||ƒ qf||
ƒ |	}
|�r|tnt}|  ||ƒ|||�r˜|nd||¡ qfdS )a-  Format dict items or parameters respecting the compact=True
        parameter. For some reason, the builtin rendering of dict items doesn't
        respect compact=True and will use one line per key-value if all cannot
        fit in a single line.
        Dict items will be rendered as <'key': value> while params will be
        rendered as <key=value>. The implementation is mostly copy/pasting from
        the builtin _format_items().
        This also adds ellipsis if the number of items is greater than
        self.n_max_elements_to_show.
        ú,
ú Ú r   NFr   ú, ...Tú'ú: ú=r   ú, )rF   r4   Ú_widthÚiterÚnextÚStopIterationr2   Ú_compactÚ_reprÚstriprG   r   r   Ú_format)r   r=   r9   r6   rJ   r>   r@   rM   rF   ÚdelimnlÚdelimr7   Ú	max_widthÚitÚnext_entÚlastÚn_itemsÚentr"   r#   ÚkreprÚvreprÚmiddleÚrepÚwÚclass_r   r   r   rO   Ü   sl    




     ÿz4_EstimatorPrettyPrinter._format_params_or_dict_itemsc                 C   sr  |j }|| j7 }| jdkr,|| jd d ƒ dd|  }d}	| j| d  }
}t|ƒ}zt|ƒ}W n tk
rx   Y dS X d}d}|�sn|| jkrž|dƒ �qn|d7 }|}zt|ƒ}W n( tk
rÞ   d	}||8 }|
|8 }
Y nX | j�rB|  |||¡}t	|ƒd
 }|
|k �r|}
|	�r|}	|
|k�rB|
|8 }
||	ƒ d}	||ƒ q‚||	ƒ |}	|  
||||�rb|nd||¡ q‚dS )zÏFormat the items of an iterable (list, tuple...). Same as the
        built-in _format_items, with support for ellipsis if the number of
        elements is greater than self.n_max_elements_to_show.
        r   rS   rR   rT   NFr   rU   Tr   rY   )rF   r4   rZ   r[   r\   r]   r2   r^   r_   rG   ra   )r   r+   r9   r6   rJ   r>   r@   rF   rb   rc   r7   rd   re   rf   rg   rh   ri   rm   rn   r   r   r   Ú_format_items  sT    




z%_EstimatorPrettyPrinter._format_itemsc                 C   sp   |\}}|   |||¡}	t|tƒr0|	 d¡}	d}
nd}
| |	¡ | |
¡ |  |||t|	ƒ t|
ƒ |||¡ dS )z=Pretty printing for key-value tuples from dict or parameters.rV   rX   rW   N)r_   r    r   r`   rF   ra   rG   )r   r=   r9   r6   rJ   r>   r@   r"   r#   rm   rl   r   r   r   Ú_pprint_key_val_tupleK  s     



     ÿz-_EstimatorPrettyPrinter._pprint_key_val_tuple)r   r/   NN)r   r   r   r   r(   rA   rK   rQ   rI   rO   rp   rq   ÚpprintÚPrettyPrinterÚ	_dispatchÚcopyr   r   r   r   r   r   r   r   r.   t   s(   4    û÷?0
r.   Fc                 C   sÈ  t | ƒ}|tjkr t| ƒddfS t|ddƒ}t|tƒ�rD|tjk�rD| sLdS t| ƒ}|rn||krndd||kfS ||kr†t 	| ¡ddfS d||< d}d}	g }
|
j
}|d7 }t}t|  ¡ tjd�}|D ]f\}}||||||d	�\}}}||||||d	�\}}}|d
||f ƒ |�o|�o|}|�s$|rÂd}	qÂ||= dd |
¡ ||	fS t|tƒ�r\|tjk�stt|tƒ�rr|tjk�rrt|tƒ�r�| �sŠdS d}n"t| ƒdk�r¤d}n| �s®dS d}t| ƒ}|�rÜ||k�rÜ|d d||kfS ||k�röt 	| ¡ddfS d||< d}d}	g }
|
j
}|d7 }| D ]:}t|||||d	�\}}}||ƒ |�sJd}|�rd}	�q||= |d |
¡ ||	fS t|tƒ�r¨t| ƒ}|�r¤||k�r¤dd||kfS ||k�r¾t 	| ¡ddfS d||< d}d}	|�rÞt| ƒ}n| jdd�}g }
|
j
}|d7 }t}t| ¡ tjd�}|D ]p\}}||||||d	�\}}}||||||d	�\}}}|d| d¡|f ƒ |�or|�or|}|�s€|�rd}	�q||= d|jd |
¡f ||	fS t| ƒ}||�oÂ| d¡ dfS )zMSame as the builtin _safe_repr, with added support for Estimator
    objects.TFr   N)z{}TFz{...}r   )Úkeyr:   z%s: %sz{%s}rY   )z[]TFz[%s]z(%s,))z()TFz(%s)z...r   z%s=%srV   z%s(%s)ú<)Útyperr   Ú_builtin_scalarsr!   r'   Ú
issubclassÚdictr   ÚidÚ
_recursionÚappendr<   rH   r+   Ú_safe_tupleÚjoinÚlistÚtuplerG   r   r-   r&   r`   r   Ú
startswith)r=   r>   r?   r@   r;   ÚtypÚrÚobjidÚreadableÚ	recursiveÚ
componentsr~   Úsafereprr+   r"   r#   rj   Ú	kreadableÚkrecurrk   Ú	vreadableÚvrecurrA   ÚoÚoreprÚ	oreadableÚorecurr,   rm   r   r   r   r<   c  sò    
    ÿ    ÿ
ÿÿ
    ÿ

    ÿ    ÿr<   )F)r   r   rr   Úcollectionsr   Úbaser   Ú_configr   rT   r   r‚   r   r   r-   rs   r.   r<   r   r   r   r   Ú<module>   s   A p