uYfD:ddlmZ ddlZddlZddlZej r ddlmZddlmZddlZdZ Gdde Z Gdd e Z e Z e ZGd d ejej ZGd d eZGddeZGddeZy))divisionN)List)Optionalc eZdZdZeZdZeZy)_NegativeIntInfinitycyNFselfxs N/var/www/highfloat_scraper/venv/lib/python3.12/site-packages/ddsketch/store.py__ge__z_NegativeIntInfinity.__ge__cyNTr r s r__lt__z_NegativeIntInfinity.__lt__$rN__name__ __module__ __qualname__r__gt__r__le__r rrrrsFFrrc eZdZdZeZdZeZy)_PositiveIntInfinitycyrr r s rrz_PositiveIntInfinity.__ge__+rrcyr r r s rrz_PositiveIntInfinity.__lt__0rrNrr rrrr*sFFrrceZdZdZdZej dZej dZej d dZ ej d dZ ej dZ y) StorezThe basic specification of a store Attributes: count (float): the sum of the counts for the bins min_key (int): the minimum key bin max_key (int): the maximum key bin c>d|_t|_t|_yNr)count _pos_infinitymin_key _neg_infinitymax_keyr s r__init__zStore.__init__Cs $ $ rcy)z%Copies the input store into this one.Nr r stores rcopyz Store.copyIrcy)Return the number of bins.Nr r*s rlengthz Store.lengthMr0rcy)ziUpdates the counter at the specified index key, growing the number of bins if necessary. Nr )r keyweights raddz Store.addRr0rcy)avReturn the key for the value at given rank. E.g., if the non-zero bins are [1, 1] for keys a, b with no offset if lower = True: key_at_rank(x) = a for x in [0, 1) key_at_rank(x) = b for x in [1, 2) if lower = False: key_at_rank(x) = a for x in (-1, 0] key_at_rank(x) = b for x in (0, 1] Nr )r ranklowers r key_at_rankzStore.key_at_rankYr0rcy)zMerge another store into this one. This should be equivalent as running the add operations that have been run on the other store on this one. Nr r-s rmergez Store.mergeir0rNg?T) rrr__doc__r+abcabstractmethodr/r3r7r;r=r rrr"r":s%  44 ))           rr"cteZdZdZeffd ZdZdZdZddZ dZ dZ dd Z d Z d Zd Zdd ZdZxZS) DenseStoreaA dense store that keeps all the bins between the bin for the min_key and the bin for the max_key. Args: chunk_size (int, optional): the number of bins to grow by Attributes: count (int): the sum of the counts for the bins min_key (int): the minimum key bin max_key (int): the maximum key bin offset (int): the difference btw the keys and the index in which they are stored bins (List[float]): the bins cTtt| ||_d|_g|_yr$)superrDr+ chunk_sizeoffsetbins)r rG __class__s rr+zDenseStore.__init__s% j$(*$  rcd}t|jD]\}}|||jzd|dz }|d|jd|jd|jz }|S)N{z: z, z }}, min_key:z , max_key:z , offset:) enumeraterIrHr'r))r repr_strisbins r__repr__zDenseStore.__repr__se + =GAt a$++ot< rSr?)rrrr@ CHUNK_SIZEr+rQr/r3r7rWrgr[rlrurqr;r= __classcell__rJs@rrDrDqsP #- #  !R 34# H "rrDcHeZdZdZeffd ZfdZdZdZdZ dZ xZ S)CollapsingLowestDenseStoreaYA dense store that keeps all the bins between the bin for the min_key and the bin for the max_key, but collapsing the left-most bins if the number of bins exceeds the bin_limit Args: bin_limit (int): the maximum number of bins chunk_size (int, optional): the number of bins to grow by Attributes: count (int): the sum of the counts for the bins min_key (int): the minimum key bin max_key (int): the maximum key bin offset (int): the difference btw the keys and the index in which they are stored bins (List[int]): the bins cFtt| ||_d|_yr )rFrr+ bin_limit is_collapsedr rrGrJs rr+z#CollapsingLowestDenseStore.__init__s  ($8:"!rcp|j|_|j|_tt||yrS)rrrFrr/r r.rJs rr/zCollapsingLowestDenseStore.copys,!.. ($4U;rc ||z dz}t|jttj||jz z|j Sr^)rjrGr`rarbrrcs rrgz*CollapsingLowestDenseStore._get_new_length#sH${2Q6 OOc$))NT__,L"MN N NN  rc||jkr+|jry|j||jr!y||jkDr|j|||jz S)rZr)r'rr[r)rHr\s rrWz%CollapsingLowestDenseStore._get_index+s_       s #   4<<    s #T[[  rc||z dz|jkDr9||jz dz}||jk\rI||_||_dg|jz|jdd|j |jd<n|j|z }|dkr|j|jz }||jz }t |j||}dg||jz z|j|||j|xx|z cc<||_|j|n||_|j|||_d|_y|j||||_||_y)Override. Adjust the bins, the offset, the min_key, and max_key, without resizing the bins, in order to try making it fit the specified range. Collapse to the left if necessary. r_riNrT) r3r)rHr'rIr%sumrurrqr rdrertcollapse_start_indexcollapse_end_indexcollapsed_counts rrlz"CollapsingLowestDenseStore._adjust:s_  $q (4;;= 8% 59Kdll*) * #ut{{}4 ! #zz !  k119+/<<$+++E()4t{{)B&&) "67IJ'OKN#dll2JDII23EFII01_D1#.DL$$U+#.DL$$U+&DL $D    k; 7&DL&DLrc&|jdk(ry|jdk(r|j|y|j|jks|j|jkDr&|j |j|j|j|j z }t |j|jdz|j z }||kDr0t|j||}|jdxx|z cc<n|}t||j z|jdzD]@}|j||j z xx|j||j z z cc<B|xj|jz c_y) Override.rNr_) r%r/r'r)r[rHrjrrIr})r r.collapse_start_idxcollapse_end_idxcollapse_countr5s rr=z CollapsingLowestDenseStore.mergees@ ;;!   ::? IIe   ==4<< '5==4<<+G   u}}emm <"]]U\\9t||U]]Q->?%,,N 0 0 ,>?O!PQN IIaLN *L1 )ELL8%--!:KL KC IIcDKK' (EJJsU\\7I,J J ( K ekk! r rrrr@r~r+r/rgrWrlr=rrs@rrrs, .8" <   !)'V"rrcHeZdZdZeffd ZfdZdZdZdZ dZ xZ S)CollapsingHighestDenseStoreaZA dense store that keeps all the bins between the bin for the min_key and the bin for the max_key, but collapsing the right-most bins if the number of bins exceeds the bin_limit Args: bin_limit (int): the maximum number of bins chunk_size (int, optional): the number of bins to grow by Attributes: count (int): the sum of the counts for the bins min_key (int): the minimum key bin max_key (int): the maximum key bin offset (int): the difference btw the keys and the index in which they are stored bins (List[int]): the bins cFtt| ||_d|_yr )rFrr+rrrs rr+z$CollapsingHighestDenseStore.__init__s  )49;"!rcp|j|_|j|_tt||yrS)rrrFrr/rs rr/z CollapsingHighestDenseStore.copys,!.. )45e?O!PQN IIbM^ +M!1 (:U\\(IJ KC IIcDKK' (EJJsU\\7I,J J ( K ekk! rrrs@rrrs, .8" =   !)'V"rr) __future__rrAratyping TYPE_CHECKINGrrsixr~r`rrr(r&with_metaclassABCMetar"rDrrr rrrs      3  3 %& $& 4 C  s{{ +4 nR"R"jw"w"tx"*x"r