Y+ d dl mZmZ d dlmZ d dlmZ d dlmZ G d d Z G d de Z
G d d
e Z G d d e Z
ej e
ej e
d
Z ei d Zi d fdZd ZdS ) )MappingHashable)chain)pvector transformc * e Zd ZdZd Zd Zd Zd ZdS )PMapViewa View type for the persistent map/dict type `PMap`.
Provides an equivalent of Python's built-in `dict_values` and `dict_items`
types that result from expreessions such as `{}.values()` and
`{}.items()`. The equivalent for `{}.keys()` is absent because the keys are
instead represented by a `PSet` object, which can be created in `O(1)` time.
The `PMapView` class is overloaded by the `PMapValues` and `PMapItems`
classes which handle the specific case of values and items, respectively
Parameters
----------
m : mapping
The mapping/dict-like object of which a view is to be created. This
should generally be a `PMap` object.
c t |t s4t |t rt | }nt d t
| d| d S )Nz"PViewMap requires a Mapping object_map)
isinstancePMapr pmap TypeErrorobject __setattr__)selfms b/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib/python3.11/site-packages/pyrsistent/_pmap.py__init__zPMapView.__init__ sb !T"" F!W%%
FGG DEEE4+++++ c * t | j S N)lenr r s r __len__zPMapView.__len__" s 49~~ r c @ t t | d )Nz
is immutable)r type)r kvs r r zPMapView.__setattr__% s T$ZZZZ9:::r c t d Nz"Persistent maps are not reversibler r s r __reversed__zPMapView.__reversed__( <===r N)__name__
__module__ __qualname____doc__r r r r$ r r r
r
sZ ", , , ; ; ;> > > > >r r
c 0 e Zd ZdZd Zd Zd Zd Zd ZdS )
PMapValuesa View type for the values of the persistent map/dict type `PMap`.
Provides an equivalent of Python's built-in `dict_values` type that result
from expreessions such as `{}.values()`. See also `PMapView`.
Parameters
----------
m : mapping
The mapping/dict-like object of which a view is to be created. This
should generally be a `PMap` object.
c 4 | j S r r
itervaluesr s r __iter__zPMapValues.__iter__7 s y##%%%r c 8 || j v S r r. )r args r __contains__zPMapValues.__contains__: s di**,,,,r c B dt t | dS Nz pmap_values()listiterr s r __str__zPMapValues.__str__> ! 1d4:: . .1111r c B dt t | dS r5 r7 r s r __repr__zPMapValues.__repr__A r; r c || u rdS dS NTFr* r xs r __eq__zPMapValues.__eq__D s
99TTUr N r& r' r( r) r0 r3 r: r= rB r* r r r, r, + si
& & &- - -2 2 22 2 2 r r, c 0 e Zd ZdZd Zd Zd Zd Zd ZdS ) PMapItemsa| View type for the items of the persistent map/dict type `PMap`.
Provides an equivalent of Python's built-in `dict_items` type that result
from expreessions such as `{}.items()`. See also `PMapView`.
Parameters
----------
m : mapping
The mapping/dict-like object of which a view is to be created. This
should generally be a `PMap` object.
c 4 | j S r )r iteritemsr s r r0 zPMapItems.__iter__V s y""$$$r c d |\ }}n# t $ r Y dS w xY w|| j v o| j | |k S )NF) Exceptionr )r r2 r r s r r3 zPMapItems.__contains__Y sB Ua&&&&DI~3$)A,!"33s
c B dt t | dS Nz pmap_items(r6 r7 r s r r: zPMapItems.__str___ ! 0T$t** - -0000r c B dt t | dS rK r7 r s r r= zPMapItems.__repr__b rL r c l || u rdS t |t | sdS | j |j k S r? )r
r r r@ s r rB zPMapItems.__eq__e s: 99TTAtDzz** )55Y!&((r NrC r* r r rE rE J si
% % %4 4 4 1 1 11 1 1) ) ) ) )r rE c R e Zd ZdZdZ fdZed Zed Zd Z ed Z
d Z e j
Z
d Zd
Zd Zd Zd
Zd Zd Zd Zd Zd Zd Zd Ze j Zd ZeZ eZ eZ d Z d Z d Z!d Z"d Z#d Z$d Z%d Z&e&Z'd Z(d Z)d Z* G d! d"e+ Z,d# Z- xZ.S )$r a
Persistent map/dict. Tries to follow the same naming conventions as the built in dict where feasible.
Do not instantiate directly, instead use the factory functions :py:func:`m` or :py:func:`pmap` to
create an instance.
Was originally written as a very close copy of the Clojure equivalent but was later rewritten to closer
re-assemble the python dict. This means that a sparse vector (a PVector) of buckets is used. The keys are
hashed and the elements inserted at position hash % len(bucket_vector). Whenever the map size exceeds 2/3 of
the containing vectors size the map is reallocated to a vector of double the size. This is done to avoid
excessive hash collisions.
This structure corresponds most closely to the built in dict type and is intended as a replacement. Where the
semantics are the same (more or less) the same function names have been used but for some cases it is not possible,
for example assignments and deletion of values.
PMap implements the Mapping protocol and is Hashable. It also supports dot-notation for
element access.
Random access and insert is log32(n) where n is the size of the map.
The following are examples of some common operations on persistent maps
>>> m1 = m(a=1, b=3)
>>> m2 = m1.set('c', 3)
>>> m3 = m2.remove('a')
>>> m1 == {'a': 1, 'b': 3}
True
>>> m2 == {'a': 1, 'b': 3, 'c': 3}
True
>>> m3 == {'b': 3, 'c': 3}
True
>>> m3['c']
3
>>> m3.c
3
)_size_buckets __weakref__ _cached_hashc t t t | | }||_ ||_ |S r )superr __new__rP rQ )clssizebucketsr __class__s r rV z PMap.__new__ s3 T3 '',,
r c X t | t | z }| | }||fS r )hashr )rY keyindexbuckets r _get_bucketzPMap._get_bucket s+ S CLL( f} r c t | | \ }}|r|D ]\ }}||k r|c S t | r )r r` KeyError)rY r] _r_ r r s r _getitemz
PMap._getitem s[ $$Wc22 6
188 HHH smmr c B t | j | S r )r rd rQ r r] s r __getitem__zPMap.__getitem__ s }}T]C000r c l t | | \ }}|r|D ]\ }}||k r dS dS dS r? )r r` )rY r] rc r_ r s r _containszPMap._contains sW $$Wc22 6
188 44 5ur c 8 | | j | S r )ri rQ rf s r r3 zPMap.__contains__ s ~~dmS111r c * | S r )iterkeysr s r r0 z
PMap.__iter__ }} r c t d r" r# r s r r$ zPMap.__reversed__ r% r c | | S # t $ r;}t d t | j | |d }~ww xY w)Nz{0} has no attribute '{1}')rb AttributeErrorformatr r& )r r] es r __getattr__zPMap.__getattr__ sa 9 ,33DJJ4GMM
s
A6A
Ac # F K | D ] \ }}|V
d S r rG )r r rc s r rl z
PMap.iterkeys 8 NN$$ DAqGGGG r c # F K | D ] \ }}|V
d S r ru )r rc r s r r/ zPMap.itervalues rv r c # > K | j D ]}|r|D ] \ }}||fV d S r )rQ )r r_ r r s r rG zPMap.iteritems sL m F
" DAqQ$JJJJ r c t | S r )r, r s r valuesz PMap.values s $ r c $ ddl m} || S )N )PSet)_psetr} )r r} s r keysz PMap.keys s" tDzzr c t | S r )rE r s r itemsz
PMap.items s r c | j S r rP r s r r z PMap.__len__ s
zr c ` d t t | S )Nz pmap({0}))rq strdictr s r r= z
PMap.__repr__ s" !!#d4jj//222r c | |u rdS t |t st S t | t | k rdS t |t rt | d r"t |d r| j |j k rdS | j |j k rdS t | t | k S t |t r%t | |k S t | t |
k S )NTFrS ) r
r NotImplementedr r hasattrrS rQ r rG r r others r rB z PMap.__eq__ s. 5==4%)) "! ! t99E
" "5 eT " " 3n--
'% 2P2P
)U-??? u}..t(())T%//2C2C-D-DD D
t
$
$ 3(())U2 2DNN$$%%ekkmm)<)<<>> m1 = m(a=1, b=2)
>>> m2 = m1.set('a', 3)
>>> m3 = m1.set('c' ,4)
>>> m1 == {'a': 1, 'b': 2}
True
>>> m2 == {'a': 3, 'b': 2}
True
>>> m3 == {'a': 1, 'b': 2, 'c': 4}
True
)evolverset
persistentr r] vals r r zPMap.set s. ||~~!!#s++66888r c t | | S )z
Return a new PMap without the element specified by key. Raises KeyError if the element
is not present.
>>> m1 = m(a=1, b=2)
>>> m1.remove('a')
pmap({'b': 2})
)r remover rf s r r z PMap.remove! s, ||~~$$S))44666r c R | | S # t $ r | cY S w xY w)a
Return a new PMap without the element specified by key. Returns reference to itself
if element is not present.
>>> m1 = m(a=1, b=2)
>>> m1.discard('a')
pmap({'b': 2})
>>> m1 is m1.discard('c')
True
)r rb rf s r discardz PMap.discard, s= ;;s## # KKK s &&c | j d g|R S )a,
Return a new PMap with the items in Mappings inserted. If the same key is present in multiple
maps the rightmost (last) value is inserted.
>>> m1 = m(a=1, b=2)
>>> m1.update(m(a=2, c=3), {'a': 17, 'd': 35}) == {'a': 17, 'b': 2, 'c': 3, 'd': 35}
True
c |S r r* )lrs r z PMap.update..E s Q r ) update_with)r mapss r updatez PMap.update< s! t 66666r c | }|D ]H}| D ]1\ }}| |||v r ||| | n| 2I| S )a%
Return a new PMap with the items in Mappings maps inserted. If the same key is present in multiple
maps the values will be merged using merge_fn going from left to right.
>>> from operator import add
>>> m1 = m(a=1, b=2)
>>> m1.update_with(add, m(a=2)) == {'a': 3, 'b': 2}
True
The reverse behaviour of the regular merge. Keep the leftmost element instead of the rightmost.
>>> m1 = m(a=1)
>>> m1.update_with(lambda l, r: l, m(a=2), {'a':3})
pmap({'a': 1})
)r r r r )r update_fnr r mapr] values r r zPMap.update_withG s ,,.. ^ ^C !iikk
^
^
U C3'>>73<!?!?!?W\]]]]
^ !!###r c , | | S r )r r s r __add__z PMap.__add__^ s {{5!!!r c 0 t t | ffS r )r r r s r
__reduce__zPMap.__reduce__c s d4jj]""r c " t | | S )a
Transform arbitrarily complex combinations of PVectors and PMaps. A transformation
consists of two parts. One match expression that specifies which elements to transform
and one transformation function that performs the actual transformation.
>>> from pyrsistent import freeze, ny
>>> news_paper = freeze({'articles': [{'author': 'Sara', 'content': 'A short article'},
... {'author': 'Steve', 'content': 'A slightly longer article'}],
... 'weather': {'temperature': '11C', 'wind': '5m/s'}})
>>> short_news = news_paper.transform(['articles', ny, 'content'], lambda c: c[:25] + '...' if len(c) > 25 else c)
>>> very_short_news = news_paper.transform(['articles', ny, 'content'], lambda c: c[:15] + '...' if len(c) > 15 else c)
>>> very_short_news.articles[0].content
'A short article'
>>> very_short_news.articles[1].content
'A slightly long...'
When nothing has been transformed the original data structure is kept
>>> short_news is news_paper
True
>>> very_short_news is news_paper
False
>>> very_short_news.articles[0] is news_paper.articles[0]
True
r )r transformationss r r zPMap.transformg s 4 ///r c | S r r* r s r copyz PMap.copy s r c T e Zd ZdZd Zd Zd Zd Zd Zd Z d Z
d Z d
Z d Z
d Zd
S )
PMap._Evolver)_buckets_evolverrP _original_pmapc h || _ |j | _ |j | _ d S r )r rQ r r rP )r
original_pmaps r r zPMap._Evolver.__init__ s/ "/D $1$:$B$B$D$DD !&,DJJJr c B t | j | S r )r rd r rf s r rg zPMap._Evolver.__getitem__ s ==!6<< z%PMap._Evolver.set.. s4 )b)b)bQWQSUWbAgg2r((B9)b)b)br r| )r r` r r rP _reallocater extend)
r r] r kvr^ r_ reallocation_requiredr
new_bucketr s
` @r r zPMap._Evolver.set se sB , ,T-BC H HME6$'(=$>$>
AR$R !
" $ $DAqCxx C<<)b)b)b)b)b[a)b)b)bJ;ED 1% 8 # ) .$$&&& 88C--- T
!!&)))/9%e,
a
( .$$&&& 88C---02t%e,
a
Kr c dt | j z }|d gz }| j }t j d |D D ]E\ }}t | |z }|| r || ||f =||fg||< Ft | _ | j | d S )N c 3 K | ]}||V d S r r* )r rA s r z,PMap._Evolver._reallocate.. s' +D+D!!+DA+D+D+D+D+D+Dr )
r r r r
from_iterabler\ appendr r r )r new_sizenew_listrY r r r^ s r r zPMap._Evolver._reallocate s 3t 4555H 4&(H+6688G ++D+Dw+D+D+DDD
/
/1 Q(*E? / UO**Aq62222()1vhHUOO %,II$5$5$7$7D ! ! ( ( 2 2 2 2 2r c 4 | j S r )r is_dirtyr s r r zPMap._Evolver.is_dirty s (1133 3r c | r1t | j | j | _ | j S r )r r rP r r r r s r r zPMap._Evolver.persistent s? }}
[&*4:t7L7W7W7Y7Y&Z&Z#& &r c | j S r r r s r r zPMap._Evolver.__len__ s
: r c B t | j | S r )r ri r rf s r r3 zPMap._Evolver.__contains__ s >>$"7== =r c 0 | | d S r )r rf s r __delitem__zPMap._Evolver.__delitem__ s KK r c . t | j \ }}|rNfd|D }t | t | k r |r|nd | j |< | xj dz c_ | S t d )Nc * g | ]\ }}|k ||fS r* r* )r r r r] s r r z(PMap._Evolver.remove.. s& F F F!QQ#XXq!fXXXr r| z{0})r r` r r rP rb rq )r r] r^ r_ r s ` r r zPMap._Evolver.remove s , ,T-BC H HME6
F F F F6 F F F
v;;Z 00AK3U::QUD)%0JJ!OJJ K5<<,,-- -r N)r& r' r( __slots__r rg r r r r r r r3 r r r* r r _Evolverr s C - - -
= = = B 3 3 3 4 4 4 ' ' ' > > >
.
.
.
.
.r r c , | | S )a-
Create a new evolver for this pmap. For a discussion on evolvers in general see the
documentation for the pvector evolver.
Create the evolver and perform various mutating updates to it:
>>> m1 = m(a=1, b=2)
>>> e = m1.evolver()
>>> e['c'] = 3
>>> len(e)
3
>>> del e['a']
The underlying pmap remains the same:
>>> m1 == {'a': 1, 'b': 2}
True
The changes are kept in the evolver. An updated pmap can be created using the
persistent() function on the evolver.
>>> m2 = e.persistent()
>>> m2 == {'b': 2, 'c': 3}
True
The new pmap will share data with the original pmap in the same way that would have
been done if only using operations on the pmap.
)r r s r r z PMap.evolver s : }}T"""r )/r& r' r( r) r rV staticmethodr` rd rg ri r3 r getr0 r$ rs rl r/ rG rz r r r r= rB __ne__r __le____gt____ge__r: r r r r r r r __or__r r r r r r
__classcell__)rZ s @r r r j s $ $J EI \
\ 1 1 1 \ 2 2 2 +C > > > 3 3 3= = =$ ^F3 3 3 F
F
F ! ! !
9 9 9 7 7 7 7 7 7$ $ $." " " F# # #0 0 08 [. [. [. [. [.6 [. [. [.z # # # # # # #r r c |r|}n( dt | z pd}n# t $ r d}Y nw xY w|d gz }t | t st | } | D ]C\ }}t
| }||z }|| }|r| ||f ;||fg||< Dt t | t
| S )Nr ) r rI r
r r r r\ r r r r ) initialpre_sizerX rY r r hr^ r_ s r _turbo_mappingr s s7||#(qDD DDD
dVmG gw ' ' w--
& &1 GGD & MM1a& ! ! ! ! !fXGENN G gii . .w 7 7 8 88s ++c @ | s
|dk rt S t | | S )a
Create new persistent map, inserts all elements in initial into the newly created map.
The optional argument pre_size may be used to specify an initial size of the underlying bucket vector. This
may have a positive performance impact in the cases where you know beforehand that a large number of elements
will be inserted into the map eventually since it will reduce the number of reallocations required.
>>> pmap({'a': 13, 'b': 14}) == {'a': 13, 'b': 14}
True
r ) _EMPTY_PMAPr )r r s r r r ) s* x1}} '8 , ,,r c t | S )z
Creates a new persistent map. Inserts all key value arguments into the newly created map.
>>> m(a=13, b=14) == {'a': 13, 'b': 14}
True
)r )kwargss r r r 9 s <<r N)collections.abcr r itertoolsr pyrsistent._pvectorr pyrsistent._transformationsr r
r, rE r r registerr r r r r* r r r s - - - - - - - - ' ' ' ' ' ' 1 1 1 1 1 1#> #> #> #> #> #> #> #>J > ) ) ) ) ) ) ) )@V# V# V# V# V#6 V# V# V#p $ 9 9 9@ nR## a
-
-
-
- r