FM / pyrsistent

/opt/alt/python37/lib64/python3.7/site-packages/pyrsistent/

/opt/alt/python37/lib64/python3.7/site-packages/pyrsistent

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
py.typed	0	0644	edit dl rm
typing.py	1415	0644	edit dl rm
typing.pyi	7030	0644	edit dl rm
_checked_types.py	18312	0644	edit dl rm
_compat.py	521	0644	edit dl rm
_field_common.py	10804	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	9398	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	6574	0644	edit dl rm
_pset.py	5718	0644	edit dl rm
_pvector.py	22731	0644	edit dl rm
_toolz.py	3427	0644	edit dl rm
_transformations.py	3583	0644	edit dl rm
__init__.py	1479	0644	edit dl rm
__init__.pyi	5046	0644	edit dl rm

Edit: /opt/alt/python37/lib64/python3.7/site-packages/pyrsistent/_transformations.py (3583B)

import re
import six
try:
    from inspect import Parameter, signature
except ImportError:
    signature = None
    try:
        from inspect import getfullargspec as getargspec
    except ImportError:
        from inspect import getargspec

def inc(x):
    """ Add one to the current value """
    return x + 1

def dec(x):
    """ Subtract one from the current value """
    return x - 1

def discard(evolver, key):
    """ Discard the element and returns a structure without the discarded elements """
    try:
        del evolver[key]
    except KeyError:
        pass

# Matchers
def rex(expr):
    """ Regular expression matcher to use together with transform functions """
    r = re.compile(expr)
    return lambda key: isinstance(key, six.string_types) and r.match(key)

def ny(_):
    """ Matcher that matches any value """
    return True

# Support functions
def _chunks(l, n):
    for i in range(0, len(l), n):
        yield l[i:i + n]

def transform(structure, transformations):
    r = structure
    for path, command in _chunks(transformations, 2):
        r = _do_to_path(r, path, command)
    return r

def _do_to_path(structure, path, command):
    if not path:
        return command(structure) if callable(command) else command

kvs = _get_keys_and_values(structure, path[0])
    return _update_structure(structure, kvs, path[1:], command)

def _items(structure):
    try:
        return structure.items()
    except AttributeError:
        # Support wider range of structures by adding a transform_items() or similar?
        return list(enumerate(structure))

def _get(structure, key, default):
    try:
        if hasattr(structure, '__getitem__'):
            return structure[key]

return getattr(structure, key)

except (IndexError, KeyError):
        return default

def _get_keys_and_values(structure, key_spec):
    from pyrsistent._pmap import pmap
    if callable(key_spec):
        # Support predicates as callable objects in the path
        arity = _get_arity(key_spec)
        if arity == 1:
            # Unary predicates are called with the "key" of the path
            # - eg a key in a mapping, an index in a sequence.
            return [(k, v) for k, v in _items(structure) if key_spec(k)]
        elif arity == 2:
            # Binary predicates are called with the key and the corresponding
            # value.
            return [(k, v) for k, v in _items(structure) if key_spec(k, v)]
        else:
            # Other arities are an error.
            raise ValueError(
                "callable in transform path must take 1 or 2 arguments"
            )

# Non-callables are used as-is as a key.
    return [(key_spec, _get(structure, key_spec, pmap()))]

if signature is None:
    def _get_arity(f):
        argspec = getargspec(f)
        return len(argspec.args) - len(argspec.defaults or ())
else:
    def _get_arity(f):
        return sum(
            1
            for p
            in signature(f).parameters.values()
            if p.default is Parameter.empty
            and p.kind in (Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD)
        )

def _update_structure(structure, kvs, path, command):
    e = structure.evolver()
    if not path and command is discard:
        # Do this in reverse to avoid index problems with vectors. See #92.
        for k, v in reversed(kvs):
            discard(e, k)
    else:
        for k, v in kvs:
            result = _do_to_path(v, path, command)
            if result is not v:
                e[k] = result

return e.persistent()

cmd: