a jJ@sdZddlZddlZddlmZddlmZddlmZGdd d e Z Gd d d e Z d d Z Gdddej ZdddZdS)ztThis module contains the _EstimatorPrettyPrinter class used in BaseEstimator.__repr__ for pretty-printing estimatorsN) get_config) BaseEstimator) is_scalar_nancs eZdZdZfddZZS) KeyValTuplez@Dummy class for correctly rendering key-value tuples from dicts.cs tS)N)super__repr__)self __class__;E:\soccer\ml_env\Lib\site-packages\sklearn/utils/_pprint.pyr PszKeyValTuple.__repr__)__name__ __module__ __qualname____doc__r __classcell__r r r rrMsrc@seZdZdZdS)KeyValTupleParamzEDummy class for correctly rendering key-value tuples from parameters.N)rrrrr r r rrUsrcs\|jdd}t|jd|j}t|jddDfddfdd|DS) zgReturn dict (param_name: value) of parameters that were given to estimator with non-default values.FdeepZdeprecated_originalcSsi|]\}}||jqSr )default).0nameparamr r r bz#_changed_params..csl|vr dS|tjkrdSt|tr<|j|jkr.has_changedcs i|]\}}||r||qSr r )rr!r")r$r rrsr) get_paramsgetattr__init__r signature parametersitems)Z estimatorparamsZ init_funcr )r$r#r_changed_params[s    r,cseZdZdZdddddfdd Zd d Zd d ZddZddZddZ ddZ ddZ e j jZeeej<e eej<ZS)_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. rPNFT)compactindent_at_namen_max_elements_to_showcs>tj|||||d||_|jr(d|_td|_||_dS)N)r/rZprint_changed_only)rr'_indent_at_name_indent_per_levelr _changed_onlyr1)r indentwidthdepthstreamr/r0r1r r rr's  z _EstimatorPrettyPrinter.__init__cCst|||||jdS)N changed_only) _safe_reprr4)r objectcontext maxlevelslevelr r rformats z_EstimatorPrettyPrinter.formatcCsr||jjd|jr(|t|jj7}|jr8t|}n |jdd}|t | |||d|||ddS)N(Frr)) writer rr2lenr4r,r%_format_paramssortedr*)r r<r8r5 allowancer=r?r+r r r_pprint_estimators  z)_EstimatorPrettyPrinter._pprint_estimatorc Cs|j||||||ddS)NTis_dict_format_params_or_dict_itemsr r*r8r5rGr=r?r r r_format_dict_itemssz*_EstimatorPrettyPrinter._format_dict_itemsc Cs|j||||||ddS)NFrIrKrMr r rrEsz&_EstimatorPrettyPrinter._format_paramscCs|j}||j7}dd|} d} |j|d} } t|} z t| }WntyZYdS0d}d}|s||jkr|dq|d7}|}z t| }Wn&tyd }| |8} | |8} Yn0|jr`|\}}||||}||||}|s| d }|rd nd }|||}t |d }| |kr8| } | r8| } | |kr`| |8} || d} ||qd|| | } |rvt nt }| |||||r|nd||qddS)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 . 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. ,  rNFr, ...T': =r, )rCr3_widthiternext StopIterationr1_compact_reprstriprDrr_format)r r<r8r5rGr=r?rJrCdelimnldelimr6 max_widthitnext_entlastn_itemsentr!r"kreprvreprmiddlerepwclass_r r rrLsb             z4_EstimatorPrettyPrinter._format_params_or_dict_itemscCsn|j}||j7}|jdkr,||jdddd|}d} |j|d} } t|} z t| } WntyvYdS0d}d}|sj||jkr|dqj|d7}| }z t| } Wn&tyd }| |8} | |8} Yn0|jr>||||}t |d }| |kr| } | r|} | |kr>| |8} || d } ||q|| |} | ||||r^|nd||qdS) 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. rrPrOrQNFrrRTrrV) rCr3rWrXrYrZr1r[r\rDr^)r r*r8r5rGr=r?rCr_r`r6rarbrcrdrerfrjrkr r r _format_itemssT           z%_EstimatorPrettyPrinter._format_itemsc Csp|\}}||||} t|tr0| d} d} nd} || || ||||t| t| |||dS)z=Pretty printing for key-value tuples from dict or parameters.rSrUrTN)r\rrr]rCr^rD) r r<r8r5rGr=r?r!r"rjrir r r_pprint_key_val_tupleKs    z-_EstimatorPrettyPrinter._pprint_key_val_tuple)rr.NN)rrrrr'r@rHrNrErLrmrnpprint PrettyPrinterZ _dispatchcopyrr rrr r r rr-vs(4?0  r-FcCst|}|tjvr t|ddfSt|dd}t|trD|tjurD|sLdSt|}|rn||krndd||vfS||vrt |ddfSd||<d}d} g} | j } |d7}t } t | tjd} | D]f\}}| |||||d \}}}| |||||d \}}}| d ||f|o|o|}|s$|rd} q||=d d | || fSt|tr\|tjustt|trr|tjurrt|tr|sd Sd}n"t|dkrd}n|sdSd}t|}|r||kr|dd||vfS||vrt |ddfSd||<d}d} g} | j } |d7}|D]:}t |||||d \}}}| ||sJd}|rd} q||=|d | || fSt|trt|}|r||kr|jdd||vfS||vrt |ddfSd||<d}d} |rt|}n |jdd}g} | j } |d7}t } t | tjd} | D]p\}}| |||||d \}}}| |||||d \}}}| d|d|f|oz|oz|}|s|rd} q||=d|jd | f|| fSt|}||o|d dfS)zMSame as the builtin _safe_repr, with added support for Estimator objects.TFr N)z{}TFz{...}r)keyr9z%s: %sz{%s}rV)z[]TFz[%s]z(%s,))z()TFz(%s)z...z(...)rz%s=%srSz%s(%s)<)typeroZ_builtin_scalarsr r& issubclassdictr idZ _recursionappendr;rFr*Z _safe_tuplejoinlisttuplerDrrr,r%r] startswith)r<r=r>r?r:typrZobjidreadable recursive componentsrxZsafereprr*r!r"rgZ kreadableZkrecurrhZ vreadableZvrecurr@oZoreprZ oreadableZorecurr+rjr r rr;cs                  r;)F)rrro_configrbaserZ_missingrr{rrr,rpr-r;r r r rsD   n