# uncompyle6 version 3.9.2
# Python bytecode version base 3.7.0 (3394)
# Decompiled from: Python 3.8.19 (default, Mar 20 2024, 15:27:52) 
# [Clang 14.0.6 ]
# Embedded file name: /var/user/app/device_supervisorbak/device_supervisor/lib/pyrsistent/_transformations.py
# Compiled at: 2024-04-18 03:12:57
# Size of source mod 2**32: 3910 bytes
import re, six
try:
    from inspect import Parameter, signature
except ImportError:
    signature = None
    try:
        from inspect import getfullargspec as getargspec
    except ImportError:
        from inspect import getargspec

_EMPTY_SENTINEL = object()

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


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


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:
        if callable(command):
            return command(structure)
        return command
    kvs = _get_keys_and_values(structure, path[0])
    return _update_structure(structure, kvs, path[1[:None]], command)


def _items(structure):
    try:
        return structure.items()
    except AttributeError:
        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):
    if callable(key_spec):
        arity = _get_arity(key_spec)
        if arity == 1:
            return [(k, v) for k, v in _items(structure) if key_spec(k)]
        if arity == 2:
            return [(k, v) for k, v in _items(structure) if key_spec(k, v)]
        raise ValueError("callable in transform path must take 1 or 2 arguments")
    return [
     (
      key_spec, _get(structure, key_spec, _EMPTY_SENTINEL))]


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 if p.kind in (Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD)))


def _update_structure(structure, kvs, path, command):
    from pyrsistent._pmap import pmap
    e = structure.evolver()
    if (path or command) is discard:
        for k, v in reversed(kvs):
            discard(e, k)

    else:
        for k, v in kvs:
            is_empty = False
            if v is _EMPTY_SENTINEL:
                is_empty = True
                v = pmap()
            result = _do_to_path(v, path, command)
            if result is not v or is_empty:
                e[k] = result

    return e.persistent()