U
    9%eTH                     @   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   )
get_config)BaseEstimator   )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__ T/var/www/html/Darija-Ai-API/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|| qdS )zFormat 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rt	| 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$|rd}	q||= dd|
 ||	fS t|tr\|tjkstt|trr|tjkrrt|tr| sdS d}n"t| dkrd}n| sdS d}t| }|r||kr|d d||kfS ||krt	| ddfS d||< d}d}	g }
|
j
}|d7 }| D ]:}t|||||d	\}}}|| |sJd}|rd}	q||= |d|
 ||	fS t|trt| }|r||krdd||kfS ||krt	| ddfS d||< d}d}	|rt| }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   _configr   baser   rT   r   r   r   r   r-   rs   r.   r<   r   r   r   r   <module>   s   A p