# Copyright (c) 2018, 2021, Oracle and/or its affiliates. All rights reserved.

# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

#

# The Universal Permissive License (UPL), Version 1.0

#

# Subject to the condition set forth below, permission is hereby granted to any

# person obtaining a copy of this software, associated documentation and/or

# data (collectively the "Software"), free of charge and under any and all

# copyright rights in the Software, and any and all patent rights owned or

# freely licensable by each licensor hereunder covering either (i) the

# unmodified Software as contributed to or provided by such licensor, or (ii)

# the Larger Works (as defined below), to deal in both

#

# (a) the Software, and

#

# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if

# one is included with the Software each a "Larger Work" to which the Software

# is contributed by such licensors),

#

# without restriction, including without limitation the rights to copy, create

# derivative works of, display, perform, and distribute the Software and make,

# use, sell, offer for sale, import, export, have made, and have sold the

# Software and the Larger Work(s), and to sublicense the foregoing rights on

# either these or other terms.

#

# This license is subject to the following condition:

#

# The above copyright notice and either this complete permission notice or at a

# minimum a reference to the UPL must be included in all copies or substantial

# portions of the Software.

#

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

# SOFTWARE.

from _thread import get_ident

def recursive_repr(fillvalue='...'):

'Decorator to make a repr function return fillvalue for a recursive call'

def decorating_function(user_function):

repr_running = set()

def wrapper(self):

key = id(self), get_ident()

if key in repr_running:

return fillvalue

repr_running.add(key)

try:

result = user_function(self)

finally:

repr_running.discard(key)

return result

# Can't use functools.wraps() here because of bootstrap issues

wrapper.__module__ = getattr(user_function, '__module__')

wrapper.__doc__ = getattr(user_function, '__doc__')

wrapper.__name__ = getattr(user_function, '__name__')

wrapper.__qualname__ = getattr(user_function, '__qualname__')

wrapper.__annotations__ = getattr(user_function, '__annotations__', {})

return wrapper

return decorating_function

_initial_missing = object()

@__graalpython__.builtin

def reduce(function, sequence, initial=_initial_missing):

it = iter(sequence)

if initial is _initial_missing:

try:

value = next(it)

except StopIteration:

raise TypeError("reduce() of empty sequence with no initial value") from None

else:

value = initial

for element in it:

value = function(value, element)

return value

@__graalpython__.builtin

def cmp_to_key(mycmp):

"""Convert a cmp= function into a key= function"""

class K(object):

__slots__ = ['obj']

def __init__(self, obj):

self.obj = obj

def __lt__(self, other):

return mycmp(self.obj, other.obj) < 0

def __gt__(self, other):

return mycmp(self.obj, other.obj) > 0

def __eq__(self, other):

return mycmp(self.obj, other.obj) == 0

def __le__(self, other):

return mycmp(self.obj, other.obj) <= 0

def __ge__(self, other):

return mycmp(self.obj, other.obj) >= 0

__hash__ = None

return K

# tweaked version from functool.py:

# - hidden 'func', 'args' and 'keywords' attributes behind a property to make them read only

# - __delattr__ impl to prevent __dict__ deletion

class partial:

"""New function with partial application of the given arguments

and keywords.

"""

__slots__ = "_func", "_args", "_keywords", "__dict__", "__weakref__"

def __new__(cls, func, /, *args, **keywords):

if not callable(func):

raise TypeError("the first argument must be callable")

if hasattr(func, "func"):

args = func.args + args

keywords = {**func.keywords, **keywords}

func = func.func

self = super(partial, cls).__new__(cls)

self._func = func

self._args = args

self._keywords = keywords

return self

def __call__(self, /, *args, **keywords):

keywords = {**self._keywords, **keywords}

return self._func(*self._args, *args, **keywords)

def __delattr__(self, name):

if name == "__dict__":

raise TypeError("cannot delete __dict__")

type.__delattr__(self, name)

@recursive_repr()

def __repr__(self):

qualname = type(self).__qualname__

args = [repr(self._func)]

args.extend(repr(x) for x in self._args)

args.extend(f"{k}={v!r}" for (k, v) in self._keywords.items())

if type(self).__module__ == "_functools":

return f"functools.{qualname}({', '.join(args)})"

return f"{qualname}({', '.join(args)})"

def __reduce__(self):

return type(self), (self._func,), (self._func, self._args,

self._keywords or None, self.__dict__ or None)

def __setstate__(self, state):

if not isinstance(state, tuple):

raise TypeError("argument to __setstate__ must be a tuple")

if len(state) != 4:

raise TypeError(f"expected 4 items in state, got {len(state)}")

func, args, kwds, namespace = state

if (not callable(func) or not isinstance(args, tuple) or

(kwds is not None and not isinstance(kwds, dict)) or

(namespace is not None and not isinstance(namespace, dict))):

raise TypeError("invalid partial state")

args = tuple(args) # just in case it's a subclass

if kwds is None:

kwds = {}

elif type(kwds) is not dict: # XXX does it need to be *exactly* dict?

kwds = dict(kwds)

if namespace is None:

namespace = {}

self.__dict__ = namespace

self._func = func

self._args = args

self._keywords = kwds

def set_xxx(self, value):

raise AttributeError("readonly attribute")

def get_func(self):

return self._func

partial.func = descriptor(fget=get_func, fset=set_xxx, name="func", owner=partial)

def get_args(self):

return self._args

partial.args = descriptor(fget=get_args, fset=set_xxx, name="args", owner=partial)

def get_keywords(self):

return self._keywords

partial.keywords = descriptor(fget=get_keywords, fset=set_xxx, name="keywords", owner=partial)