J-jOdZddlmZmZmZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl mZmZ[[[dZdZdZdZd Zd Zd Zd Zd ZdZdZdZd>dZd?dZd?dZdZdZ dZ!dZ" d@dZ#dZ$dZ%e jLe'Z( dAdZ) dBdZ* dBdZ+dCdZ,dDdZ-dEd Z.dFd!Z/Gd"d#e0Z1Gd$d%e2Z3Gd&d'e2Z4Gd(d)ejjZ6Gd*d+e6Z7Gd,d-e jLZ8Gd.d/e9Z:Gd0d1e0Z;Gd2d3e0Z<Gd4d5e2Z=Gd6d7e9Z>Gd8d9e0Z?Gd:d;e9Z@Gd<d=e0ZAy)Gz-various utilities not related to optimization)absolute_importdivisionprint_functionN)abcrangec|SN)xargskwargss a/Users/jameslopez/projects/TradingBot25/.venv/lib/python3.12/site-packages/cma/utilities/utils.py_idrs HcP t|rdSdS#t$r |rdcYSdcYSwxYw)aintuitive handling of variable truth value also for `numpy` arrays. Return `True` for any non-empty container, otherwise the truth value of the scalar `var`. Caveat of the most unintuitive case: [0] evaluates to True, like [0, 0]. >>> import numpy as np >>> from cma.utilities.utils import is_ >>> is_({}) or is_(()) or is_(0) or is_(None) or is_(np.array(0)) False >>> is_({0:0}) and is_((0,)) and is_(np.array([0])) True TF)len TypeErrorvars ris_rs4 &3xt*U* &t%%&s  %%%cptjtj|dk(S#|dk(cYSxYw)z&return True if var == 1 or ones vectorr)npallasarrayrs ris_oner2s+rzz#!+, ,3!8Os*,5ct| S)z see `is_`rrs ris_notr6s3x<rc&td|DS)z(return ``any(is_(v) for v in var_list)``c32K|]}t|ywr r.0rs r zis_any..;,8Cs3x8)anyvar_lists ris_anyr*9 ,8, ,,rc&td|DS)z(return ``all(is_(v) for v in var_list)``c32K|]}t|ywr rr"s rr$zis_all..>r%r&)rr(s ris_allr.<r+rct|dS)z`bytes` (in Python 3) also fit the bill. >>> from cma.utilities.utils import is_str >>> assert is_str(b'a') * is_str('a') * is_str(u'a') * is_str(r'b') >>> assert not is_str([1]) and not is_str(1) startswith)hasattrrs ris_strr2?s 3 %%rcL tj|S#t$rYywxYw)z;return ``np.isnan(var)`` or `False` if `var` is not numericF)risnanrrs ris_nanr5Hs'xx} s  ##cH tj|ddS#YyxYw)zmake an educated guess whether ``x`` is a list of vectors. >>> from cma.utilities.utils import is_vector_list as ivl >>> assert ivl([[0], [0]]) and not ivl([1,2,3]) rF)risscalarr s ris_vector_listr9Os({{1Q47##s!c.t|r|dfS|gdfS)a\a tool to handle a vector or a list of vectors in the same way, return a list of vectors and a function to revert the "list making". Useful when we might either have a single solution vector or a set/list/population of vectors to deal with. Namely, this function allows to replace a slightly more verbose:: was_list = utils.is_vector_list(X) X = X if was_list else [X] # work work work on X, e.g. res = [x[0] + 1 for x in X] res = res if was_list else res[0] with:: X, revert = utils.as_vector_list(X) # work work work on X, e.g. res = [x[0] + 2 for x in X] res, ... = revert(res, ...) # also allows to revert X, if desired Testing: >>> from cma.utilities import utils >>> X = [3] # a single vector >>> X, revert_vlist = utils.as_vector_list(X) # BEGIN >>> assert X == [[3]] # a list with one element >>> # work work work on X as a list of vectors, e.g. >>> res = [x[0] + 1 for x in X] >>> X, res = revert_vlist(X, res) # END >>> assert res == 4 >>> assert X[0] == 3 c|Sr r r8s rz as_vector_list..sArc@t|dk(r|ddSd|DS)Nrrc3&K|] }|d yw)rNr )r#args rr$z3as_vector_list....sE<6:sCFdsr)r s rr<z as_vector_list..s/D Q$q'!*#<E<6:E<#rc t|}| t|}||k(r|S||kr|d|S||kDr+tjt |||z |dgzzSy#t$r|cYSwxYw#t$r|dcYSwxYw)zreturn ``vec`` with the last element recycled to ``dim`` if ``len(vec)`` doesn't fail, else ``vec``. If ``dim`` is not given, ``len(as_)`` is used if available, else a scalar is returned. Nr)rrrrlist)vecdimas_len_s rrecycledrNs3x { c(C d{ t4Cy tzz$s)sTzc"gY&>>??     q6M s" A A. A+*A+.A?>A?cVttt||j|S)zreturn index list to get `a` in order, ie ``a[argsort(a)[i]] == sorted(a)[i]``, which leads to unexpected results with `np.nan` entries, because any comparison with `np.nan` is `False`. )keyreverse)sortedrr __getitem__)arQs rargsortrUs %A-Q]]G DDrct|}tt|Dcgc]5}|r t|dz |j|z n|j|7c}Scc}w)zreturn ranks of entries starting with zero based on Pythons `sorted`. This leads to unreasonable results with `np.nan` values. r)rUrrindex)rTrQidxis rranksrZs^ !*C3s8_ &$,3CHqL399Q< ' ! D$ && &s:AcJ|D]}tj||||<|S)zPmodify ``a[i]`` to ``round(a[i])`` for i in `indices` and return `a`, never used)rround)rTindicesrYs r round_indicesr^s& xx!~! HrcX |jS#t$rt|cYSwxYw)z@return ``a.tolist()`` if applicable else ``list(a)``, never used)tolistAttributeErrorrI)rTs rr`r`s+xxz Aws ))c#Kd}|t|kr]||dk(r@|}|t|kr$||dk(r|dz }|t|kr ||dk(r||f|dz}n|dz }|t|kr\yyw)agenerate increasing index pairs ``(i, j)`` with ``all(diffs[i:j] == 0)`` and ``diffs[j] != 0 or j == len(diffs)``, thereby identifying "flat spots/areas" in `diffs`. Returns the respective generator type. Not anymore used to smoothen ECDFs. Example: >>> from cma.utilities.utils import zero_values_indices >>> for i, j in zero_values_indices([0, 0.1, 0, 0, 3.2, 0, 2.1]): ... print((i, j)) (0, 1) (2, 4) (5, 6) rrNr@)diffsrYjs rzero_values_indicesres( A c%j. 8q=Ac%j.U1X]Qc%j.U1X]Q$JAA FA c%j.sA A1A1/A1c p ddl}|j|y#t$rt|trkt d|j D]@\}}t t ||k(rd|zdzn|dt ||k(rd|zdzn|dBt dYyt d t |YywxYw) znicely formated printrN{': )sep}z5could not import pprint module, appling regular print)pprint ImportError isinstancedictprintitemsstr) to_be_printedppkvs rrmrms! -  ! mT * #J%++-1s1v{cAgm'*1v{cAgm. #J I J -  !sBB5B54B5c |dk(ry|dkDstdt|z|dk}|}ttj|}t tj tj|} d|dz | z z} tj| |z| z } | dz|k\r,tt |r| ntj|} nt| } d} | t| kr"| | dvr| dz } | t| kr| | dvr| |z| jd| kDz}|| k7r"t| |kr| d|t| z zz } || k(r|r| ddk(r| dd} | ddk(r| ddk(r| dd} |rd nd | z}d t|dz zd z|z} tj| |k(rO| jddkDr;| jd dkDr'| jd d } | jd dkDr'| jdd } | jdd } | jddkDr'| jdd } | jddkDr'| jddkDr'| jdd} | jddkDr'| dd k(r| dd} |rd nd | z}t|t|ks;|jdd|dzzzdkDstj| d|dzzk\r|}n|}|rpd }t||kr`t|t|krI|}t|||zt|z ||||d}t||krt|t|krI|S)areturns the shortest string representation. Generally, display either ``significant_digits`` digits or its true value, whichever is shorter. ``force_rounding`` shows no more than the desired number of significant digits, which means, e.g., ``12345`` becomes ``12000``. ``remove_trailing_zeros`` removes zeros, if and only if the value is exactly. ``desired_length`` adds digits up to the desired length. >>> from cma.utilities import utils >>> print([utils.num2str(val) for val in [12345, 1234.5, 123.45, ... 12.345, 1.2345, .12345, .012345, .0012345]]) ['12345', '1234', '123', '12', '1.2', '0.12', '0.012', '1.2e-3'] r0zneed significant_digits=%s > 0 r)-ry.r|rHr{rjz%.e0ez.eze+e0ze-0ze-Nz0.)desired_length) ValueErrorrsfloatrabsintfloorlog10r\rfindast literal_evalreplacenum2str)valsignificant_digitsforce_roundingmax_predecimal_digitsmax_postdecimal_leading_zerosremove_trailing_zerosr is_negativeoriginal_valueorder_of_magnitudefac val_roundedsidx1idx2s_floats_exps_rets_olds rrrs, ax  !91234 4'KN s CRXXbhhsm45 !A%(:: ;C((39%+K A!33 >Krxx}E F  SVm$? : AIDSVm$? :((AFF3K$,>? + 1v}SD3q6M** + "7B%3,aGB%3, R5C<!BA!srQ.G &*+ +c 1S8A c!affSkAoffTlQ $$AffTlQ $A $A &&,  IIdC  &&,  &&-!  IIeT " &&-! u| crFSR1 ,E E S\! TC#@1#DEEFK {r$9A$=>>%j>)c%j3u:.EEN)N:SZG%,4,&* ,E%j>)c%j3u:.E Lrct|jd|jdD]7\}}t|t|kryt|t|kDs7yy)z.return -1 if v1 < v2 else +1 if v1 > v2 else 0r|rHrr)zipsplitr)v1v2n1n2s r version_diffrTsRbhhsmRXXc]3B r7SW  r7SW  4 rcddlm}|jtjj dd|j j_y)z'created a new figure without the headerrNgЈBF) matplotlib.pyplotpyplotfigurerrandomrandintgcfcanvasheader_visible)plts rrr]s4#JJryy  %&&+CGGI#rc t|t}|/t|xxdz cc<t||kDryt||k(r|dz }|dk\rztj|dj t j ddz|rdt|zndz|rd t|zndz|rd t|zndzd zfi|yy) z+Poor man's maxwarns: msg must match exactlyNr& (further warnings will be suppressed) (time={} class=%srj method=%s iteration=%s))global_verbositywarnings_counterwarningswarnformattimeasctimers)msg method_name class_name iterationverbosemaxwarnskwargs_for_warns r print_warningres"" C 8 +  C H , ; ;C"} cK..t||~ab/ABB0:{S_,D2=|c+..2G4=Y/"F  &%  &rc8|/t|xxdz cc<t||kDryt||k(r|dz }|djtjddz|rdt |zndz|rdt |zndz|rd t |zzd zSdzd zS) a~Poor man's maxwarns: msg must match exactly. Copy-paste of `print_warning` to get better location information than `print_warning`. Calling `warnings.warn` here makes the warning location information meaningless, hence we format only a string here. Usage could be like:: m = utils.format_warning(some_message ); m and warnings.warn(m) Nrrjrrrrrrr)rrrrrs)rrrrrs rformat_warningrvs" C 8 + C H , ; ;C +$$T\\^AB%78 8.8[3z? *b B0;\C , , E2;_s9~ - D   AC D   rc|t}|dk\rItd|rdt|zndz|rdt|zndz|dt|zndzdz|yy)NrzNOTE (module=cmaz, class=rjz , method=z , iteration=z): )rrqrs)rrrrrs r print_messagersz"!|  /9zC O+rC1<{S--"F3<2G~I.RQ   rc|r|dj|jz}d}d|dzz}t|D]*\}}||z}|dk(s||dzkDs|dvs|dz|dzz}|},|dz}|S)z)put line breaks and trailing white spacesz [iteration={0}]rz   F)r)r countiter enumerate)resspacesrdrrYcs rformat_messagers &--bll;; A#A#1 E 9AF qEzD6C<'AA  DA Hrc|r7t|||jt||jdd|j D]\}}|dk7s t|||y)a@assign, for example, all arguments given to an ``__init__`` method to attributes in ``self`` or ``self.params`` or ``self.args``. If ``initial_params_dict_name`` is given, ``dict_`` is also copied into an attribute of ``self`` with name ``initial_params_dict_name``:: setattr(self, initial_params_dict_name, dict_.copy()) and the ``self`` key is removed from the copied `dict` if present. >>> from cma.utilities.utils import set_attributes_from_dict >>> class C(object): ... def __init__(self, arg1, arg2, arg3=None): ... assert len(locals()) == 4 # arguments are locally visible ... set_attributes_from_dict(self, locals()) >>> c = C(1, 22) >>> assert c.arg1 == 1 and c.arg2 == 22 and c.arg3 is None >>> assert len(c.__dict__) == 3 and not hasattr(c, 'self') Details: - The entry ``dict_['self']`` is always ignored. - Alternatively:: self.args = locals().copy() self.args.pop('self', None) # not strictly necessary puts all arguments into ``self.args: dict``. selfN)setattrcopygetattrpoprr)rdict_initial_params_dict_namerPrs rset_attributes_from_dictrsZ@ . =./33FDAKKMS &= D#s #"rcBddl}|,|jtjjd}t tjj ||d5}|j|j|jdddy#1swYyxYw)NrrHwb) urllib2rospathrkopenjoinwriteurlopenread)url target_dir target_namerfs r download_filerskii ,R0 bggll:{3T :a $))+, ; : :s /BBc ddl}d}|+|jj|j|yddl}|jj|j||j t jj||t jj||jt jjd|j|y)z(filename must be a valid path in the tarrNz._tmp_rH) tarfileTarFilegzopen extractallshutilcopy2rrrrrkrmtree)tarnamefilenamerrtmp_dirrs r extract_targzrsGw'22:>w'227; RWW\\'84WW\\*hnnRWW[[.I".MN P grceZdZdZy) BlancClassaeblanc container class to have a collection of attributes. For rapid shell- or prototyping. In the process of improving the code this class might/can/will at some point be replaced with a more tailored class. Usage: >>> from cma.utilities.utils import BlancClass >>> p = BlancClass() >>> p.value1 = 0 >>> p.value2 = 1 N)__name__ __module__ __qualname____doc__r rrrrs rrceZdZdZdZdZy) DictClassaA class wrapped over `dict` to use class .-notation. Not clear whether tab completion works? >>> from cma.utilities.utils import DictClass >>> dict_ = dict((2 * char, char) for char in 'abcd') >>> d = DictClass(dict_) >>> assert d.__dict__ == dict_ == d >>> assert d.aa == 'a' and len(d) == 4 >>> d.new = 33 >>> assert 'new' in d >>> d['nnew'] = 44 >>> assert d.nnew == 44 >>> assert len(d) == 6 cDtj|g|i|||_yr )rp__init____dict__)rr rs rrzDictClass.__init__s d,T,V, rc"|jSr )keysrs r__dir__zDictClass.__dir__syy{rN)rrrrrrr rrrrs rrceZdZdZdZy) DictClass2a A dictionary that allows `.` attribute read access of its entries. Assigning an attribute instead of the dictionary entry does not assign (or create) a dictionary value and separates the attribute value from the dictionary value permanently (in contrast to `DictClass`). This may be useful to let the dictionary entry store the initial value and work with the attribute value only, to access the current and possibly changed value. If neither the attribute nor the dictionary entry exist, an attempted attribute access raises an `AttributeError` as to be expected. By design, this class DOES NOT HAVE INTERACTIVE TAB COMPLETION for attributes derived from the dictionary!? Implementation detail: this class is less "intrusive" than `DictClass` and should be entirely safe from under-the-hood surprises. It only relies on the behavior of `__getattr__`: access of a nonexisting attribute triggers (by Python convention) a call of `__getattr__` which is here defined to return the dictionary entry value. >>> from cma.utilities.utils import DictClass2 >>> d = DictClass2((2 * char, char) for char in 'abcd') >>> list(d) ['aa', 'bb', 'cc', 'dd'] >>> assert d.aa == 'a' and len(d) == 4, (list(d.values()), d.__dict__) >>> d.new = 33 # does not go in the dict >>> assert 'new' not in d and len(d) == 4, (list(d.values()), d.__dict__) >>> d['new'] = 55 >>> assert (d.new, d['new']) == (33, 55) >>> d['nnew'] = 44 >>> assert d.nnew == 44 >>> assert len(d) == 6 c\||vr$tdj|t|||S)z8called when ``self.name`` would raise an attribute errorz-`{0}` is not an attribute. Attributes are {1})rarrI)rnames r __getattr__zDictClass2.__getattr__,s4 t  !P"(&tDz":< <DzrN)rrrrr r rrr r s "Frr cFeZdZdZfdZdZdZdZdZdZ dZ xZ S) DerivedDictBaseasfor conveniently adding methods/functionality to a dictionary. The actual dictionary is in ``self.data``. Derive from this class and copy-paste and modify setitem, getitem, and delitem, if necessary. Details: This is the clean way to subclass the build-in dict, however it depends on `MutableMapping` (since 2.6 but has significantly evolved). ctt| tjdk\rt |i||_y tj|_|j jtj|i|y#t$r6t |_|j jt |i|YywxYw)N)) superrrsys version_inforpdata collections OrderedDictupdate Exceptionrr r __class__s rrzDerivedDictBase.__init__>s ot-/   v %d-f-DI 8'335    !8!8$!I&!IJ 8 F    t!6v!67 8sAB>> import cma.utilities.utils as utils, numpy as np >>> d = utils.SolutionDict() >>> x = np.array([1,2,4]) >>> d[x] = {'f': sum(x**2), 'iteration': 1} >>> assert d[x]['iteration'] == 1 >>> assert d.get(x) == (d[x] if d.key(x) in d.keys() else None) >>> y = [1,2,4] >>> d[y] = {'f': sum([n ** 2 for n in y]), 'iteration': 1} >>> assert d[y]['iteration'] == 1 >>> assert d.get(y) == (d[y] if d.key(y) in d.keys() else None) >>> d[2] = 3 >>> assert d[2] == 3 `data_with_same_key` behaves (in contrast to the order of ``keys()``) like a stack (see setitem and delitem). Thereby the last assignment ``self[key] = ...`` determines, as to be expected, the value of ``self[key]`` even when ``self.data_with_same_key[key]`` is not empty. If the attribute `behave_as_queue` is set to True, it behaves like a queue (FIFO). Technical detail: after a same-key item was removed, ``self[key]`` returns the stacked (or queued) previous value, however ``self._unhashed_keys[key]`` still returns the last unhashed key which could be a different object than the previous but with the same hash key. However, the object has most likely the correct content because the hash was the same. This happens because only the last unhashed key is kept. As long as the content of ``self._unhashed_keys[key]`` is not changed, this should be fine. TODO: in `.truncate`, the iteration key is used to clean up without error management. cdtt| |i|i|_i|_d|_d|_y)NrF)rr1rdata_with_same_key_unhashed_keyslast_iterationbehave_as_queuers rrzSolutionDict.__init__s7 lD*D;F;"$ $rc|t|tr|St|tjr t |j S t |S#t $r<|jdkrt t|cYSt t|cYSwxYw#t$rt t|cYSwxYw)zcompute key of ``x``g@) rorrndarrayhashtobytesrasizetuplebytesr)rr s rrPzSolutionDict.keys a H 2:: & *AIIK(( &Aw" *66C<a>)a>)  * &E!H~% &s)A B,BBBB;:B;cHtt| |j|Sr )rr1r"rP)rrPrs rr"zSolutionDict.__contains__s\45dhhsmDDrc||j|}}||j|<|jr]||jvr||j|<y||jvr|g|j|<y|j|j d|y||jvr&|j|xx|j|gz cc<n+||jvr|j|g|j|<||j|<y)r'rN)rPr4r6rr3insert)rrPr( unhashed_keys rr)zSolutionDict.__setitem__s#c #/C   $))#!& #D33305w'','',33Au=d---'',30@@, !04 #/?'',"DIIcNrc>|j|j|Sr+)rrPr!s rrSzSolutionDict.__getitem__syy#''rc|j|}||jvrst|j|dk(r,|jj|d|j|<y|j|jd|j|<y||jvr)||j vr |j |=|j|=yy)z9remove only most current key-entry of list with same keysrrrHN)rPr3rrrr4r!s rr-zSolutionDict.__delitem__shhsm $)) )4**3/0A5!%!8!8! max_len``. Only truncate entries with ``'iteration'`` key smaller than `min_iter` if given. This looks overdesigned given the `dict` is ordered and chunk deletion is not available. See also `truncate_to`. NrrrE)rmax_lenmin_iterrvs rtruncatezSolutionDict.truncatesk t9   a< JJL diik"A47;#7(#BG4y7Q;& #rr ) rrrrrrPr"r)rSr-rGrLr.r/s@rr1r1Zs2&N%&&E#"(  rr1c:eZdZdZd dZdZdZefdZdZ dZ y) DataDictza dictionary of lists (of data)c6||_tjj|tt j j|jr|jytdj|j|jy)Nzcreating file {0}) rr defaultdictrrIrrexistsloadrqrsave)rrs rrzDataDict.__init__s]  ((t4 77>>$-- ( IIK %,,T]]; < IIKrct|jd5}tj|j }ddd|j |S#1swYxYw)zelement-wise append/merge data of loaded `dict` to self, by calling `update`. To load cleanly without merge use `clear` + `load` or the class constructor with a new `filename`. rtN)rrrrrr)rrdds rrRz DataDict.loadsH$-- &!!!!&&(+B' B ' &s $AAc4|D]}||xx||z cc<|S)z4append data of entries in `dict_` to entries in selfr )rrrvs rrzDataDict.updates#A GuQx G rcz|D]5}tt||D]}|||||||||<7|S)zreplace all entries with the return value of `replace_function`. The `replace_function` gets the original value, the key, and the list index as arguments. )rPrWrD)rreplace_functionrvrYs rrzDataDict.replacesJ A3tAw<(-d1gajaqIQ ) rct|jd5}|jtt |dddy#1swYyxYw)Nwt)rrrreprrp)rrs rrSz DataDict.saves3 $-- &! GGDd$ %' & &s $AA c@|Dcgc]}|c}D]}||=|Scc}wr r )rrvrPs rrFzDataDict.clear s,#$t!At$CS % %s N)z_data.py) rrrrrrRrrrrSrFr rrrNrNs()  (+ &rrNceZdZdZdZy)ExclusionListOfVectorsz'For delayed selective mirrored samplingc |D]l}dtj||ttj|dzttj|dzzdzz cxkrdksjyny)Ngv?rIg?g0D?TF)rdotsumr)rrJrws rr"z#ExclusionListOfVectors.__contains__shA"&&C.C 1 q0@,AC SVYZHZD[,[^a+aaldllmrN)rrrrr"r rrr_r_s 1rr_cjeZdZdZd dZdZdZdZedZ edZ edZ ed Z y ) ElapsedWCTimeameasure elapsed cumulative time while not paused since creation. To control the timer, use attribute `tic` and methods `pause` () and `reset` (). To see timing results, use attributes `toc` (since last `tic`) and `elapsed` (since creation). >>> import cma >>> e = cma.utilities.utils.ElapsedWCTime().pause() # (re)start later >>> assert e.paused and e.elapsed == e.toc < 0.1 >>> assert e.toc == e.tic < 0.1 # timer starts here >>> assert e.toc <= e.tic # toc is usually a few microseconds smaller >>> assert not e.paused # the timer is now running due to tic Details: the attribute ``paused`` equals to the time [s] when paused or to zero when the timer is running. cT||_|j|j|_y)z+add time offset in seconds and start timingN) _time_offsetreset_time_at_reset_time_at_creation)r time_offsets rrzElapsedWCTime.__init__*s!' !%!4!4rc|j|_d|_ tj|_|j|_|j|_|S)z'reset to initial state and start timingr)rfcum_timepausedrlast_tic _last_tocrhrs rrgzElapsedWCTime.reset/sB))  1  "mm rcP|jstj|_|S)zpause timer, resume with `tic`)rmrrs rpausezElapsedWCTime.pause8s{{))+DK rct)zFdepreciated return elapsed time (for backwards compatibility) )DeprecationWarningelapsedrs r__call__zElapsedWCTime.__call__=s !""rc|j}|jr}|j|jkr7td|j|jfzdd|j|_|xj|j|jz z c_n4|xjt j |jz z c_d|_t j |_|S)zgreturn `toc` and restart tic/toc last-round-timer. In case, also resume from `pause`. z~paused time=%f < last_tic=%f, which should never happen, but has been observed at least once. ticrdr)tocrmrnrrlr)rreturn_s rrwzElapsedWCTime.ticBs (( ;;{{T]]*{{DMM23$_6#mm MMT[[4==8 8M MMTYY[4==8 8M   rc4|j|jzS)zhelapsed time since last `reset` while not paused. Details: this triggers a `toc` call. )rlrxrs rrtzElapsedWCTime.elapsedVs }}txx''rctj|_|jr|j|jz S|j|jz S)z-elapsed time since last `tic` or `pause` call)rrormrnrs rrxzElapsedWCTime.toc]s> ;;;;. .~~ --rc4|j|jz S)zOnever used: time between last `reset` and last `toc` (i.e. last usage) )rorhrs r wallclockzElapsedWCTime.wallclockds~~ 3 333rN)r) rrrrrrgrqrupropertyrwrtrxr}r rrrdrdsk 5   &(( .. 44rrdceZdZdZdZdZy) TimingWrapperzwrap a timer around a callable. Attribute ``timer`` collects the timing data in an `ElapsedWCTime` class instance, in particular the overall elapsed time in ``timer.elapsed`` and the time of the last call in ``timer.toc``. cL||_tj|_y)z7``callable_`` is the `callable` to be timed when calledN) _callablerdrqtimer)r callable_s rrzTimingWrapper.__init__qs""_**, rc|jj|j|i|}|jj|Sr )rrwrrq)rr rress rruzTimingWrapper.__call__us7 dnnd-f-  rNrrrrrrur rrrrjs -rrcneZdZdZfdZ d fd ZedZdZedZ edZ dZ xZ S) DictFromTagsInStringaread from a string or file all key-value pairs within all ``...`` tags and return a `dict`. Within the tags valid Python code is expected: either a list of key-value pairs ``[[key1, value1], [key2, value2], ...]`` or a dictionary ``{ key1: value1, key2: value2, ...}``. A key can be any immutable object, while it is often a string or a number. The `as_python_tag` attribute provides the respective (tagged) string. The ``tag_string`` attribute defines the tag identifier, 'python' by default, and can be change if desired at any time. >>> from cma.utilities.utils import DictFromTagsInString >>> s = ' [[33, 44], ["annotations", [None, 2]]] ' >>> s += ' {"annotations": [2, 3]} ' >>> d = DictFromTagsInString(s) >>> # now d.update can be used to read more tagged strings/files/... >>> assert d.tag_string == 'python' # can be set to any other value >>> d.tag_string = 'pyt' >>> # now 'pyt' tags can/will be read (only) >>> assert str(d).startswith('{') and str(d).endswith('}') >>> assert len(d) == 2 and d[33] == 44 and d['annotations'] == [2, 3] When the same key appears several times, its value is overwritten. ctt| d|_t |s t |r|j |i|yy)z#for input args see `update` method.pythonN)rrr tag_stringrrrs rrzDictFromTagsInString.__init__s= "D24" t9F DKK ( ($rcRd|du|duz|duz|duzz }|s td|dkDr td|||_|t|dj}n*||j}n|tt |||Stt ||j||S)zonly one of the first four arguments is accepted at a time, return ``self``. If the first argument has no keyword, it is assumed to be a string to be parsed for tags. rNznothing to updaterzs use either string_ or filename or file_ or dict_ as input, but not several of themr)rrrrrrr_eval_python_tag)rstring_rfile_rrr rs rrzDictFromTagsInString.updatesW_T)9: "'4-1245 5 !823 3  !(DO  8S)..0G  jjlG   & $ K " 009: rc^|jtt|z|jzSr )_startr\rp_endrs r as_python_tagz"DictFromTagsInString.as_python_tags#{{T$t*-- 99rc|jSr )rrs r__repr__zDictFromTagsInString.__repr__s!!!rc&d|jzdzS)N<>rrs rrzDictFromTagsInString._startsT__$s**rc&d|jzdzS)Nz`` tags in ``str_`` and return a `dict`. >>> from cma.utilities.utils import DictFromTagsInString >>> s = ' [[33, 44], ["annotations", []]] ' >>> s += '[["annotations", [1,2,3]]] ' >>> d = DictFromTagsInString() >>> assert len(d) == 0 >>> d.update(s) # still empty as default tag is not {} >>> assert len(d) == 0 >>> d.tag_string = "py" # set desired tag >>> d.update(s) # doctest:+ELLIPSIS {... >>> assert len(d) == 2 >>> assert d[33] == 44 and len(d["annotations"]) == 3 rr) lowerrrrrrrrstrip)rstr_values str_lowerstartends rrz%DictFromTagsInString._eval_python_tags&JJL t{{+qj S% %E..E2C MM#**4c?+@+@+BC DNN4;; :E qj  rNNNNN) rrrrrrr~rrrrrr.r/s@rrr{s^2) EI<::" ++ ,,rrceZdZdZdZdZy) MoreToWritez0make sure that this list does not grow unboundedcg|_yr )_lenhistrs rrzMoreToWrite.__init__s  rc|xjt|gz c_t|jdkDr8ttj|jdkDr|dd=g|_yy)Nrr)rrrrdiffrs rcheckzMoreToWrite.checksT #d)$ t}}  !2774==)A-.GDM "rN)rrrrrrr rrrrs:rrc(eZdZdZdZdZdZdZy)DefaultSettingsaresembling somewhat `types.SimpleNamespace` from Python >=3.3 but with instantiation and resembling even more the `dataclass` decorator from Python >=3.7. ``MyClassSettings(DefaultSettings)`` is preferably used by assigning a settings attribute in ``__init__`` like: >>> class MyClass: ... def __init__(self, a, b=None, param1=None, c=3): ... self.settings = MyClassSettings(locals(), 1, self) The `1` signals, purely for consistency checking, that one parameter defined in ``MyClassSettings`` is to be set from ``locals()``. ``MyClassSettings`` doesn't use any names which are already defined in ``self.__dict__``. The settings are defined in a derived parameter class like >>> from cma.fitness_models import DefaultSettings >>> class MyClassSettings(DefaultSettings): ... param1 = 123 ... val2 = False ... another_par = None # we need to assign at least None always The main purpose is, with the least effort, (i) to separate parameters/settings of a class from its remaining attributes, and (ii) to be flexible as to which of these parameters are arguments to ``__init__``. Parameters can always be modified after instantiation. Further advantages are (a) no typing of ``self.`` to assign the default value or the passed parameter value (the latter are assigned "automatically") and (b) no confusing name change between the passed option and attribute name is possible. The class does not allow to overwrite the default value with `None`. Now any of these parameters can be used or re-assigned like >>> c = MyClass(0.1) >>> c.settings.param1 == 123 True >>> c = MyClass(2, param1=False) >>> c.settings.param1 is False True ct||_||_||_|jj dd|j |j y)aOverwrite default settings in case. :param params: A dictionary (usually locals()) containing the parameters to set/overwrite :param number_of_params: Number of parameters to set/overwrite :param obj: elements of obj.__dict__ are in the ignore list. rN)rpinparams_number_of_paramsobjr_set_from_defaults_set_from_input)rparamsnumber_of_paramsrs rrzDefaultSettings.__init__sJV  !1 &$' ! rcZddjd|jDzdzS)Nrgrc3TK|] \}}t|dt|"yw)riN)rs)r#rvrws rr$z*DefaultSettings.__str__..(s"VASVSV <s&(rl)rrrrs r__str__zDefaultSettings.__str__&s(diiVVVVY\\]rc|jjdt|jjDy)z,defaults are taken from the class attributesc3LK|]\}}|jds||fyw)_N)r0)r#rPrs rr$z5DefaultSettings._set_from_defaults..,s,:0K*3%(^^C%8 #Cj0Ks"$N)rrtyperrrs rrz"DefaultSettings._set_from_defaults*s4 :04T 0C0C0I0I0K: ;rc i}t|jD]q}||jvs||jjvr|jj |||<H|j|Xt |||j|st |j|jk7rTtjdtt||jt|jt|fzt|dy)aQOnly existing parameters/attributes and non-None values are set. The number of parameters is cross-checked. Remark: we could select only the last arguments of obj.__init__.__func__.__code__.co_varnames which have defaults obj.__init__.__func__.__defaults__ (we do not need the defaults) Nz8%s: %d parameters desired; remaining: %s; discarded: %s r) rIrrrrrrrrrrsrdelattr)r discardedrPs rrzDefaultSettings._set_from_input/s  &C$--'3$((2C2C+C!%!2!23!7 #s#/c4==#56 ' t}} !7!7 7 MMT d_d.D.Dc$--FX ^-- . erN)rrrrrrrrr rrrrs*V ^; rrceZdZdZdZdZy)ListOfCallablesalA `list` of callables that can be called like a single `callable`. The simplest usecase of this minitool is single-shot usage like:: res = ListOfCallables(callable_or_list_of_callables)(args) as a one-line simplification of either:: if callable(callable_or_list_of_callables): res = [callable_or_list_of_callables(args)] else: res = [c(args) for c in callable_or_list_of_callables] or:: try: res = [c(args) for c in callable_or_list_of_callables] except TypeError: res = [callable_or_list_of_callables(args)] c||_|g}t|r|g} |D]$}t|rtdt|z t j ||y#t$rtdt|zwxYw)areturn a list of callables as a `callable` itself. ``callback`` can be a `callable` or a `list` (or iterable) of callables. Otherwise a `ValueError` exception is raised. Possible usecase: termination callback(s) of CMA-ES:: self.opts['termination_callback'](self) becomes:: ListOfCallables(self.opts['termination_callback'])(self) Nz rrc:eZdZdZdZddZ d dZd dZdZy) ShowInFoldera*callable instance to save and show figures from `matplotlib`. Saves figures to a folder ``'figs-...'`` with incremental filenames allowing to conveniently view and compare these figures. Each call of the instance saves the current `matplotlib` figure and switches the focus to the save folder by calling the `open_path` method. Example:: >> import cma, matplotlib.pyplot as plt >> show = cma.utilities.utils.ShowInline('01') # use './figs-01' folder >> >> plt.plot([1,2,3]) >> show() # save current plot with a unique name in figs-01 folder >> # and switch focus to the folder Under macOS, `open_path` invokes Finder where the figures can be conveniently explored and compared using the space and up/down keys. zfigs-c tj|z|_ |_d|_ ||_ ||j d<d|_ tjj|jr]tfdtj|jD}|r)t|djdzd|_yyy)zsave figures to folder ``'figs-' + name``. pdf are smaller than png and not pixeliated. The type can be changed at any time be reassigning the `type` attribute. `dpi` and `kwargs` are passed to `plt.savefig`. z{0:04d}.dpirc3K|]A}|dtdDcgc] }t|c}vr|jdzr|Cycc}ww)rrzr|N)rrsendswith)r#nrYrs rr$z(ShowInFolder.__init__..sPW#8atb : 1A ::qzz#PT*?U#8:sAA $ArHr|N) r folder_prefixrr format_stringrnumberrrQrRlistdirrr)rr rrrlss ` rrzShowInFolder.__init__s"//$6   '$ '  E @ 77>>$)) $W2::dii#8WWB!"R&,,sTz":1"=>  %rNc|rddlm}tjj |jsi|j dk7r;t j|jdj|j ztj|j|G|xj dz c_|jj|j |jz}tjj|j|}|rJ|jj} |jj||| dz| dz |j |fddi|j"||_|xs|j'|xr|j)|j r|r|j+||S)zsave current figure and show folder and/or image in notebook. Uses `IPython.display.Image` to show the image in the notebook. r)rz= not found even though number={0} (which should ever happen).r bbox_inchestight) matplotlibrrrrQrrrrmkdirrrrrget_size_inchesset_size_inchessavefigr _last_savedclose open_pathshow_in_notebook) rkeeprshow_in_folderrS width_save width_showr rold_sizes rruzShowInFolder.__call__sZ  077>>$)),;;!#MM$))/X#)6$++#6#78#| q ))00= I77<< 40D779446 ))**4x{*BXa[*PR CKK A' AT[[ A#D   CIIK+4>>+ ;;+  ! !* - rc ddl}|jj|jfd|i|S#t dj |jYyxYw)z=display last saved figure in notebook (doesn't work with pdf)rNwidthz{0} could not be displayed)IPython.displaydisplayImagerrqr)rr kwargs_showIPythons rrzShowInFolder.show_in_notebooksT I "(7??(()9)9VV+V V I .55d6F6FG Hs ,/&AcHtjd|jzy)Nzopen )rsystemrrs rrzShowInFolder.open_paths 'DII%&r)pdfi)TFTTNNNr ) rrrrrrrurrr rrrrs2*M?2.3+/-1 DI'rr)NN)F)rIFrTNr)NNNN)Nr )r|N)Nr|)Br __future__rrrrrrrrnumpyrr python3for2rrrrrrrr*r.r2r5r9rBrFrNrUrZr^r`rermrrrrPrrrrrrrrrobjectrrprr MutableMappingrr1rNrIr_rdrrrrrrr rrrs3 #X~ &(--& '!(7