0PhJHdZddlZddlZddlmZddlmZddlmZGdd e Z Gd d e Z d Z Gd dej ZddZdS)ztThis module contains the _EstimatorPrettyPrinter class used in BaseEstimator.__repr__ for pretty-printing estimatorsN) get_config) BaseEstimator) is_scalar_nanc"eZdZdZfdZxZS) KeyValTuplez@Dummy class for correctly rendering key-value tuples from dicts.cDtS)N)super__repr__)self __class__s U/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/utils/_pprint.pyr zKeyValTuple.__repr__Psww!!!)__name__ __module__ __qualname____doc__r __classcell__rs@rr r Ms>JJ"""""""""rr ceZdZdZdS)KeyValTupleParamzEDummy class for correctly rendering key-value tuples from parameters.N)rrrrrrrrUsOODrrc |d}t|jd|j}tj|jdDfdfd|DS)zgReturn dict (param_name: value) of parameters that were given to estimator with non-default values.Fdeepdeprecated_originalc$i|] \}}||jSr)default).0nameparams r z#_changed_params..bs NNN;44NNNrc6|vrdS|tjkrdSt|tr|j|jkrdSt |t |kr&t |rt |sdSdS)NTF)inspect_empty isinstancerrreprr)kv init_paramss r has_changedz$_changed_params..has_changedds K  4 q>W^ + +4 a ' ' AK;q>;S,S,S4 77d;q>** * * +a. ) ) +.;A.>.> +4urc4i|]\}}||||Srr)r r)r*r,s rr#z#_changed_params..ss0 A A ATQ{{1a/@/@ AAq A A Ar) get_paramsgetattr__init__r% signature parametersitems) estimatorparams init_funcr,r+s @@r_changed_paramsr7[s ! !u ! - -F *,A9CUVVI#I..9KNN+:K:K:M:MNNNK      B A A AV\\^^ A A AArceZdZdZ dddddfd Zd Zd Zd Zd Zd Z dZ dZ e j jZeeej<e eej<xZS)_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_showct|||||||_|jrd|_t d|_||_dS)N)r;rprint_changed_only)r r0_indent_at_name_indent_per_levelr _changed_onlyr=) r indentwidthdepthstreamr;r<r=rs rr0z _EstimatorPrettyPrinter.__init__se vwGGG-   '%&D "'\\*>?'=###rc4t|||||jS)N changed_only) _safe_reprrB)r objectcontext maxlevelslevels rformatz_EstimatorPrettyPrinter.formats' GYD> " "FFIM7E     Src :|||||||dS)NTis_dict_format_params_or_dict_itemsr r3rFrCrWrLrNs r_format_dict_itemsz*_EstimatorPrettyPrinter._format_dict_itemss.00 669gud1   rc :|||||||dS)NFrZr\r^s rrUz&_EstimatorPrettyPrinter._format_paramss.00 669gue1   rc6|j}||jz }dd|zz} d} |j|z dzx} } t|} t | }n#t $rYdSwxYwd}d}|s6||jkr |ddS|dz }|} t | }n#t $rd }| |z} | |z} YnwxYw|jr|\}}||||}||||}|s| d }|rd nd }||z|z}t|d z}| |kr| } | r| } | |kr| |z} || d} |||| | } |rtnt}| |||||r|nd|||4dSdS)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, )rSrA_widthiternext StopIterationr=_compact_reprstriprTr r_format)r rKrFrCrWrLrNr[rSdelimnldelimrD max_widthitnext_entlastn_itemsentr)r*kreprvreprmiddlerepwclass_s rr]z4_EstimatorPrettyPrinter._format_params_or_dict_itemssQ $((#,& K&0144 &\\ BxxHH    FF $ $555g qLGC #88  # # #Y& " #} 1 1gu55 1gu55-!KK,,E!(1cfnu,HHqL199%E( 'A::QJEE%LLL EE#JJJ E%LLLE$+A[[1AF LLs VV$-EYYAwPU   E$ $ $ $ $ s#A AABB,+B,c|j}||jz }|jdkr||jdz dzdd|zz}d} |j|z dzx} } t|} t | } n#t $rYdSwxYwd}d}|s||jkr |ddS|dz }| } t | } n#t $rd }| |z} | |z} YnwxYw|jrY||||}t|d z}| |kr| } | r|} | |kr| |z} || d } |||| |} | ||||r|nd|||dSdS) 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. rrcrbrdNFrreTrri) rSrArjrkrlrmr=rnrorTrq)r r3rFrCrWrLrNrSrrrsrDrtrurvrwrxryr}r~s r _format_itemsz%_EstimatorPrettyPrinter._format_itemss  $((  !A % % E4)A-4 5 5 5#,& K&0144 %[[ BxxHH    FF  X$555g qLGC #88  # # #Y& " #} jjgu55HHqL199%E( 'A::QJEE%LLL EE#JJJ E%LLLE LLff4.FiiQQV W W W7 X X X X Xs$A,, A:9A:#B33C  C cd|\}}||||} t|tr| d} d} nd} || || ||||t | zt | z|||dS)z=Pretty printing for key-value tuples from dict or parameters.rfrhrgN)ror'rrprSrqrT) r rKrFrCrWrLrNr)r*r}r|s r_pprint_key_val_tuplez-_EstimatorPrettyPrinter._pprint_key_val_tupleKs1jjGU++ f. / / ))C..CFFF S V vvC(3v;;6 7E     r)rr:NN)rrrrr0rOrXr_rUr]rrpprint PrettyPrinter _dispatchcopyrr r rrs@rr9r9vs00h =#=======*           ===~.X.X.X`    &$.3355I(9Im$%&;Ik"#####rr9Fct|}|tjvrt|ddfSt |dd}t |t r|t jur|sdSt|}|r ||krdd||vfS||vrtj |ddfSd||<d}d} g} | j } |dz }t} t| tj} | D]I\}}| ||||| \}}}| ||||| \}}}| |d ||o|o|}|s|rd} J||=d d | z|| fSt |t r|t jus#t |t"r|t"jurt |t r|sd Sd}nt%|dkrd}n|sdSd}t|}|r||kr |dzd||vfS||vrtj |ddfSd||<d}d} g} | j } |dz }|D]-}t||||| \}}}| ||sd}|rd} .||=|d | z|| fSt |t&r9t|}|r||kr|jdd||vfS||vrtj |ddfSd||<d}d} |rt+|}n|d}g} | j } |dz }t} t| tj} | D]\\}}| ||||| \}}}| ||||| \}}}| |dd||o|o|}|s|rd} ]||=|jdd | d|| fSt|}||o|d dfS)zMSame as the builtin _safe_repr, with added support for Estimator objects.TFr N)z{}TFz{...}r)keyrHrgz{%s}ri)z[]TFz[%s]z(%s,))z()TFz(%s)z...z(...)rrfrhrQrR<)typer_builtin_scalarsr(r/ issubclassdictr id _recursionappendrJrVr3 _safe_tuplejoinlisttuplerTrrr7r.rp startswith)rKrLrMrNrItyprobjidreadable recursive componentsrsafereprr3r)r*rz kreadablekrecurr{ vreadablevrecurrOoorepr oreadableorecurr5r}s rrJrJcsc v,,C f%%%F||T5((Z&&A#tCdm!3!3 %$$6   4)++E5G#33 3 G  $V,,eT9 9  "  v||~~6+=>>> ! !DAq'/x7Iu<((( $E9f(0x7Iu<((( $E9f Fuuuee, - - -;I;)H ! ! EN *---xBB3"C!t}"4"43#5#$#6#6 c4  )((FF [[A  FF )((F6   ;)++E>5%7*:: : G  $V,,eT9 9  "   ! !A'17Iu<((( $E9f F5MMM !  ! EN *---xBB#}%%W6   C)++l)))5%72BB B G  $V,,eT9 9  3$V,,FF&&E&22F "  v||~~6+=>>> ! !DAq'/x7Iu<((( $E9f(0x7Iu<((( $E9f Fekk#....6 7 7 7;I;)H ! ! ENLLL$))J*?*?*?*?@(IVV v,,C 0S^^C0005 88r)F)rr%r_configrbaser_missingrrr rr7rr9rJrrrrs99H ######"""""%"""     {   BBB6j<j<j<j<j