FM / pyrsistent

/snap/core20/2769/usr/lib/python3/dist-packages/pyrsistent/

/snap/core20/2769/usr/lib/python3/dist-packages/pyrsistent

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
py.typed	0	0644	edit dl rm
typing.py	1728	0644	edit dl rm
typing.pyi	10385	0644	edit dl rm
_checked_types.py	18358	0644	edit dl rm
_compat.py	521	0644	edit dl rm
_field_common.py	11452	0644	edit dl rm
_helpers.py	2475	0644	edit dl rm
_immutable.py	3559	0644	edit dl rm
_pbag.py	6754	0644	edit dl rm
_pclass.py	9722	0644	edit dl rm
_pdeque.py	12184	0644	edit dl rm
_plist.py	8282	0644	edit dl rm
_pmap.py	14643	0644	edit dl rm
_precord.py	7019	0644	edit dl rm
_pset.py	5718	0644	edit dl rm
_pvector.py	22715	0644	edit dl rm
_toolz.py	3427	0644	edit dl rm
_transformations.py	3910	0644	edit dl rm
__init__.py	1479	0644	edit dl rm
__init__.pyi	7253	0644	edit dl rm

Edit: /snap/core20/2769/usr/lib/python3/dist-packages/pyrsistent/_helpers.py (2475B)

from functools import wraps
import six
from pyrsistent._pmap import PMap, pmap
from pyrsistent._pset import PSet, pset
from pyrsistent._pvector import PVector, pvector

def freeze(o):
    """
    Recursively convert simple Python containers into pyrsistent versions
    of those containers.

- list is converted to pvector, recursively
    - dict is converted to pmap, recursively on values (but not keys)
    - set is converted to pset, but not recursively
    - tuple is converted to tuple, recursively.

Sets and dict keys are not recursively frozen because they do not contain
    mutable data by convention. The main exception to this rule is that
    dict keys and set elements are often instances of mutable objects that
    support hash-by-id, which this function can't convert anyway.

>>> freeze(set([1, 2]))
    pset([1, 2])
    >>> freeze([1, {'a': 3}])
    pvector([1, pmap({'a': 3})])
    >>> freeze((1, []))
    (1, pvector([]))
    """
    typ = type(o)
    if typ is dict:
        return pmap(dict((k, freeze(v)) for k, v in six.iteritems(o)))
    if typ is list:
        return pvector(map(freeze, o))
    if typ is tuple:
        return tuple(map(freeze, o))
    if typ is set:
        return pset(o)
    return o

def thaw(o):
    """
    Recursively convert pyrsistent containers into simple Python containers.

- pvector is converted to list, recursively
    - pmap is converted to dict, recursively on values (but not keys)
    - pset is converted to set, but not recursively
    - tuple is converted to tuple, recursively.

>>> from pyrsistent import s, m, v
    >>> thaw(s(1, 2))
    set([1, 2])
    >>> thaw(v(1, m(a=3)))
    [1, {'a': 3}]
    >>> thaw((1, v()))
    (1, [])
    """
    if isinstance(o, PVector):
        return list(map(thaw, o))
    if isinstance(o, PMap):
        return dict((k, thaw(v)) for k, v in o.iteritems())
    if isinstance(o, PSet):
        return set(o)
    if type(o) is tuple:
        return tuple(map(thaw, o))
    return o

def mutant(fn):
    """
    Convenience decorator to isolate mutation to within the decorated function (with respect
    to the input arguments).

All arguments to the decorated function will be frozen so that they are guaranteed not to change.
    The return value is also frozen.
    """
    @wraps(fn)
    def inner_f(*args, **kwargs):
        return freeze(fn(*[freeze(e) for e in args], **dict(freeze(item) for item in kwargs.items())))

return inner_f

cmd: