Mpj#HSrSSKrSSKrSSKJr SSKJr SSKJr "SS\ 5r "SS \ 5r S r "S S \R5rSS jrg)ztThis module contains the _EstimatorPrettyPrinter class used in BaseEstimator.__repr__ for pretty-printing estimatorsN) get_config) BaseEstimator) is_scalar_nanc,^\rSrSrSrU4SjrSrU=r$) KeyValTupleMz@Dummy class for correctly rendering key-value tuples from dicts.c >[TU]5$)N)super__repr__)self __class__s Q/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/sklearn/utils/_pprint.pyr KeyValTuple.__repr__Psw!!)__name__ __module__ __qualname____firstlineno____doc__r __static_attributes__ __classcell__r s@rrrMsJ""rrc\rSrSrSrSrg)KeyValTupleParamUzEDummy class for correctly rendering key-value tuples from parameters.rN)rrrrrrrrrrrUsOrrc`^URSS9n[R"UR5RmTR 5VVs0sHup#X#R _M snnmU4SjnUR 5VVs0sHupVU"XV5(dMXV_M snn$s snnfs snnf)zcReturn dict (param_name: value) of parameters that were given to estimator with non-default values.Fdeepc(>UT;agTU[R:Xag[U[5(aURTUR:wag[ U5[ TU5:wa$[ TU5(a[ U5(dgg)NTF)inspect_empty isinstancerr reprr)kv init_paramss r has_changed$_changed_params..has_changedcsz K  q>W^^ + a ' 'AKK;q>;S;S,S 7d;q>* * +a. ) )mA.>.>r) get_paramsr! signature__init__ parametersitemsdefault) estimatorparamsnameparamr(r%r&r's @r_changed_paramsr4[s ! !u ! -F##I$6$67BBK:E:K:K:MN:M;44&:MNK $\\^ A^TQ{1/@DAD^ AA#O" BsB$B*B*c^\rSrSrSrSSSSS.U4SjjjrSrS rS rS r S r S r Sr \ RRR!5r\\\R$'\ \\R$'SrU=r$)_EstimatorPrettyPrinteruat 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. NFT)compactindent_at_namen_max_elements_to_showc>[TU]XX4US9 X`lUR(aSUl[ 5SUlXplg)N)r8print_changed_only)r r,_indent_at_name_indent_per_levelr _changed_onlyr:) r indentwidthdepthstreamr8r9r:r s rr, _EstimatorPrettyPrinter.__init__sH wG-   %&D "'\*>?'=#rc,[XX4URS9$)N changed_only) _safe_reprr@)r objectcontext maxlevelslevels rformat_EstimatorPrettyPrinter.formats YDlenr@r4r*_format_paramssortedr.)r rJrDrA allowancerKrMr1s r_pprint_estimator)_EstimatorPrettyPrinter._pprint_estimators V%%..45    c&**334 4F   $V,F&&E&2F  6<<> "FIM7   Src &URXX4XVSS9$)NTis_dict_format_params_or_dict_itemsr r.rDrArWrKrMs r_format_dict_items*_EstimatorPrettyPrinter._format_dict_itemss#00 6gd1  rc &URXX4XVSS9$)NFr[r]r_s rrU&_EstimatorPrettyPrinter._format_paramss#00 6ge1  rcBURnX0R- nSSU--n Sn URU- S-=p[U5n [ U 5nSnSnU(GdUUR :Xa U"S5 gUS- nUn[ U 5nUR(aUunnURUXV5nURUXV5nU(dURS 5nU(aS OS nUU-U-n[U5S -nU U:a U n U (aU n U U:aU U-n U"U 5 Sn U"U5 MU"U 5 U n U(a[O[nURU"U5X#U(aUOSXV5 U(dGMgg![ a gf=f![ a S nX-n X-n GNf=f)aFormat 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. ,  r<NFr, ...T': =, )rSr?_widthiternext StopIterationr:_compact_reprstriprTrr_format)r rJrDrArWrKrMr\rSdelimnldelimrB max_widthitnext_entlastn_itemsentr%r&kreprvreprmiddlerepwclass_s rr^4_EstimatorPrettyPrinter._format_params_or_dict_itemss (((#,& KK&0144 &\ BxH$555g qLGC #8 }}1 1g5 1g5!KK,E!(cfnu,HqL19%E 'A:QJE%L E#J %LE$+[1AF LLs V$YAw E$    ! #& " #s$ E6< F6 FFFFcURnX0R- nURS:aU"URS- S-5 SSU--nSn URU- S-=p[U5n [ U 5n SnSnU(dXR :Xa U"S5 gUS- nU n[ U 5n UR(aPURUXV5n[U5S -nU U:a U n U (aUn U U:aU U-n U"U 5 S n U"U5 MU"U 5 Un URUX#U(aUOSXV5 U(dMgg![ a gf=f![ a S nX-n X-n Nf=f) 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<rfrergNFrrhTrlrm) rSr?rnrorprqr:rrrsrTru)r r.rDrArWrKrMrSrvrwrBrxryrzr{r|r}rrs r _format_items%_EstimatorPrettyPrinter._format_itemss  (((  ! !A % 4))A-4 5#,& KK&0144 %[ BxH555g qLGC #8 }}jjg5HqL19%E 'A:QJE%L E#J %LE LLf4iQ W7$    ! #& " #s$, E" E E  E E'&E'c"UupxURXuU5n [U[5(aU RS5n Sn OSn UR U 5 UR U 5 UR XU[ U 5-[ U 5-XEU5 g)z=Pretty printing for key-value tuples from dict or parameters.rirkrjN)rsr#rrtrSrurT) r rJrDrArWrKrMr%r&rrs r_pprint_key_val_tuple-_EstimatorPrettyPrinter._pprint_key_val_tupleJs}jjU+ f. / /))C.CFF S V vC(3v;6 E r)r@r>r?r:)r<PNN)rrrrrr,rNrXr`rUr^rrpprint PrettyPrinter _dispatchcopyrr rrrrs@rr6r6us0h =#==*   =~.X`  &$$..335I(9Im$$%&;Ik""#rr6c ([U5nU[R;a[U5SS4$[ USS5n[ U[ 5(GaU[ RLaU(dg[U5nU(a X2:aSSXq;4$Xq;a[R"U5SS4$SX'SnSn /n U Rn US- n[n [UR5[RS9n U HRupU "XX#US 9unnnU "XX#US 9unnnU "U<S U<35 U=(a U=(a UnU(d U(dMPSn MT X S S RU 5-X4$[ U[ 5(aU[ RLd([ U["5(aU["RLa[ U[ 5(a U(dg SnO[%U5S:XaSnO U(dgSn[U5nU(aX2:a US-SXq;4$Xq;a[R"U5SS4$SX'SnSn /n U Rn US- nUH.n[UXX4S 9unnnU "U5 U(dSnU(dM,Sn M0 X US RU 5-X4$[ U[&5(Ga@[U5nU(aX2:aUR(S3SXq;4$Xq;a[R"U5SS4$SX'SnSn U(a [+U5nOUR-SS9n/n U Rn US- n[n [UR5[RS9n U HaupU "XX#US 9unnnU "XX#US 9unnnU "UR/S5<SU<35 U=(a U=(a UnU(d U(dM_Sn Mc X UR(<SS RU 5<S3X4$[U5nUU=(a UR1S5(+S4$)zISame as the builtin _safe_repr, with added support for Estimator objects.TFr N)z{}TFz{...}r<)keyrGrjz{%s}rm)z[]TFz[%s]z(%s,))z()TFz(%s)z...z(...)rrirkrQrR<)typer_builtin_scalarsr$getattr issubclassdictr id _recursionappendrIrVr. _safe_tuplejoinlisttuplerTrrr4r*rt startswith)rJrKrLrMrHtyprobjidreadable recursive componentsrsafereprr.r%r&r~ kreadablekrecurr vreadablevrecurrNoorepr oreadableorecurr1rs rrIrIbs v,C f%%%F|T5((Z&A#tdmm!3$6  +E5#33 3  $$V,eT9 9  ""  v||~6+=+=>DA'/I<( $E9f(0I<( $E9f ue, -;I;)H  N *--xBB3!t}}"431#6 c4 (F [A F(F6  +E>5%*:: :  $$V,eT9 9  ""  A'17u( $E9f 5M v  N *--xBB#}%%6  +ll^5)5%2BB B  $$V,eT9 9 $V,F&&E&2F ""  v||~6+=+=>DA'/I<( $E9f(0I<( $E9f ekk#.6 7;I;)H  NLL$))J*?@(VV v,C 0S^^C005 88r)F)rr!rsklearn._configr sklearn.basersklearn.utils._missingrrrrr4rr6rIrrrrsU9H &&0"%" { B4j