Add files using upload-large-folder tool

shared/package-files/16/1604a69d2d60921502b375a8af0d662702abe625987b773637a34c09c76a8a25/functools.py

@@ -0,0 +1,992 @@
+"""functools.py - Tools for working with functions and callable objects
+"""
+# Python module wrapper for _functools C module
+# to allow utilities written in Python to be added
+# to the functools module.
+# Written by Nick Coghlan <ncoghlan at gmail.com>,
+# Raymond Hettinger <python at rcn.com>,
+# and Łukasz Langa <lukasz at langa.pl>.
+#   Copyright (C) 2006-2013 Python Software Foundation.
+# See C source code for _functools credits/copyright
+
+__all__ = ['update_wrapper', 'wraps', 'WRAPPER_ASSIGNMENTS', 'WRAPPER_UPDATES',
+           'total_ordering', 'cache', 'cmp_to_key', 'lru_cache', 'reduce',
+           'partial', 'partialmethod', 'singledispatch', 'singledispatchmethod',
+           'cached_property']
+
+from abc import get_cache_token
+from collections import namedtuple
+# import types, weakref  # Deferred to single_dispatch()
+from reprlib import recursive_repr
+from _thread import RLock
+from types import GenericAlias
+
+
+################################################################################
+### update_wrapper() and wraps() decorator
+################################################################################
+
+# update_wrapper() and wraps() are tools to help write
+# wrapper functions that can handle naive introspection
+
+WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__doc__',
+                       '__annotations__')
+WRAPPER_UPDATES = ('__dict__',)
+def update_wrapper(wrapper,
+                   wrapped,
+                   assigned = WRAPPER_ASSIGNMENTS,
+                   updated = WRAPPER_UPDATES):
+    """Update a wrapper function to look like the wrapped function
+
+       wrapper is the function to be updated
+       wrapped is the original function
+       assigned is a tuple naming the attributes assigned directly
+       from the wrapped function to the wrapper function (defaults to
+       functools.WRAPPER_ASSIGNMENTS)
+       updated is a tuple naming the attributes of the wrapper that
+       are updated with the corresponding attribute from the wrapped
+       function (defaults to functools.WRAPPER_UPDATES)
+    """
+    for attr in assigned:
+        try:
+            value = getattr(wrapped, attr)
+        except AttributeError:
+            pass
+        else:
+            setattr(wrapper, attr, value)
+    for attr in updated:
+        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
+    # Issue #17482: set __wrapped__ last so we don't inadvertently copy it
+    # from the wrapped function when updating __dict__
+    wrapper.__wrapped__ = wrapped
+    # Return the wrapper so this can be used as a decorator via partial()
+    return wrapper
+
+def wraps(wrapped,
+          assigned = WRAPPER_ASSIGNMENTS,
+          updated = WRAPPER_UPDATES):
+    """Decorator factory to apply update_wrapper() to a wrapper function
+
+       Returns a decorator that invokes update_wrapper() with the decorated
+       function as the wrapper argument and the arguments to wraps() as the
+       remaining arguments. Default arguments are as for update_wrapper().
+       This is a convenience function to simplify applying partial() to
+       update_wrapper().
+    """
+    return partial(update_wrapper, wrapped=wrapped,
+                   assigned=assigned, updated=updated)
+
+
+################################################################################
+### total_ordering class decorator
+################################################################################
+
+# The total ordering functions all invoke the root magic method directly
+# rather than using the corresponding operator.  This avoids possible
+# infinite recursion that could occur when the operator dispatch logic
+# detects a NotImplemented result and then calls a reflected method.
+
+def _gt_from_lt(self, other, NotImplemented=NotImplemented):
+    'Return a > b.  Computed by @total_ordering from (not a < b) and (a != b).'
+    op_result = type(self).__lt__(self, other)
+    if op_result is NotImplemented:
+        return op_result
+    return not op_result and self != other
+
+def _le_from_lt(self, other, NotImplemented=NotImplemented):
+    'Return a <= b.  Computed by @total_ordering from (a < b) or (a == b).'
+    op_result = type(self).__lt__(self, other)
+    if op_result is NotImplemented:
+        return op_result
+    return op_result or self == other
+
+def _ge_from_lt(self, other, NotImplemented=NotImplemented):
+    'Return a >= b.  Computed by @total_ordering from (not a < b).'
+    op_result = type(self).__lt__(self, other)
+    if op_result is NotImplemented:
+        return op_result
+    return not op_result
+
+def _ge_from_le(self, other, NotImplemented=NotImplemented):
+    'Return a >= b.  Computed by @total_ordering from (not a <= b) or (a == b).'
+    op_result = type(self).__le__(self, other)
+    if op_result is NotImplemented:
+        return op_result
+    return not op_result or self == other
+
+def _lt_from_le(self, other, NotImplemented=NotImplemented):
+    'Return a < b.  Computed by @total_ordering from (a <= b) and (a != b).'
+    op_result = type(self).__le__(self, other)
+    if op_result is NotImplemented:
+        return op_result
+    return op_result and self != other
+
+def _gt_from_le(self, other, NotImplemented=NotImplemented):
+    'Return a > b.  Computed by @total_ordering from (not a <= b).'
+    op_result = type(self).__le__(self, other)
+    if op_result is NotImplemented:
+        return op_result
+    return not op_result
+
+def _lt_from_gt(self, other, NotImplemented=NotImplemented):
+    'Return a < b.  Computed by @total_ordering from (not a > b) and (a != b).'
+    op_result = type(self).__gt__(self, other)
+    if op_result is NotImplemented:
+        return op_result
+    return not op_result and self != other
+
+def _ge_from_gt(self, other, NotImplemented=NotImplemented):
+    'Return a >= b.  Computed by @total_ordering from (a > b) or (a == b).'
+    op_result = type(self).__gt__(self, other)
+    if op_result is NotImplemented:
+        return op_result
+    return op_result or self == other
+
+def _le_from_gt(self, other, NotImplemented=NotImplemented):
+    'Return a <= b.  Computed by @total_ordering from (not a > b).'
+    op_result = type(self).__gt__(self, other)
+    if op_result is NotImplemented:
+        return op_result
+    return not op_result
+
+def _le_from_ge(self, other, NotImplemented=NotImplemented):
+    'Return a <= b.  Computed by @total_ordering from (not a >= b) or (a == b).'
+    op_result = type(self).__ge__(self, other)
+    if op_result is NotImplemented:
+        return op_result
+    return not op_result or self == other
+
+def _gt_from_ge(self, other, NotImplemented=NotImplemented):
+    'Return a > b.  Computed by @total_ordering from (a >= b) and (a != b).'
+    op_result = type(self).__ge__(self, other)
+    if op_result is NotImplemented:
+        return op_result
+    return op_result and self != other
+
+def _lt_from_ge(self, other, NotImplemented=NotImplemented):
+    'Return a < b.  Computed by @total_ordering from (not a >= b).'
+    op_result = type(self).__ge__(self, other)
+    if op_result is NotImplemented:
+        return op_result
+    return not op_result
+
+_convert = {
+    '__lt__': [('__gt__', _gt_from_lt),
+               ('__le__', _le_from_lt),
+               ('__ge__', _ge_from_lt)],
+    '__le__': [('__ge__', _ge_from_le),
+               ('__lt__', _lt_from_le),
+               ('__gt__', _gt_from_le)],
+    '__gt__': [('__lt__', _lt_from_gt),
+               ('__ge__', _ge_from_gt),
+               ('__le__', _le_from_gt)],
+    '__ge__': [('__le__', _le_from_ge),
+               ('__gt__', _gt_from_ge),
+               ('__lt__', _lt_from_ge)]
+}
+
+def total_ordering(cls):
+    """Class decorator that fills in missing ordering methods"""
+    # Find user-defined comparisons (not those inherited from object).
+    roots = {op for op in _convert if getattr(cls, op, None) is not getattr(object, op, None)}
+    if not roots:
+        raise ValueError('must define at least one ordering operation: < > <= >=')
+    root = max(roots)       # prefer __lt__ to __le__ to __gt__ to __ge__
+    for opname, opfunc in _convert[root]:
+        if opname not in roots:
+            opfunc.__name__ = opname
+            setattr(cls, opname, opfunc)
+    return cls
+
+
+################################################################################
+### cmp_to_key() function converter
+################################################################################
+
+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
+
+try:
+    from _functools import cmp_to_key
+except ImportError:
+    pass
+
+
+################################################################################
+### reduce() sequence to a single item
+################################################################################
+
+_initial_missing = object()
+
+def reduce(function, sequence, initial=_initial_missing):
+    """
+    reduce(function, iterable[, initial]) -> value
+
+    Apply a function of two arguments cumulatively to the items of a sequence
+    or iterable, from left to right, so as to reduce the iterable to a single
+    value.  For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
+    ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
+    of the iterable in the calculation, and serves as a default when the
+    iterable is empty.
+    """
+
+    it = iter(sequence)
+
+    if initial is _initial_missing:
+        try:
+            value = next(it)
+        except StopIteration:
+            raise TypeError(
+                "reduce() of empty iterable with no initial value") from None
+    else:
+        value = initial
+
+    for element in it:
+        value = function(value, element)
+
+    return value
+
+try:
+    from _functools import reduce
+except ImportError:
+    pass
+
+
+################################################################################
+### partial() argument application
+################################################################################
+
+# Purely functional, no descriptor behaviour
+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)
+
+    @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
+
+try:
+    from _functools import partial
+except ImportError:
+    pass
+
+# Descriptor version
+class partialmethod(object):
+    """Method descriptor with partial application of the given arguments
+    and keywords.
+
+    Supports wrapping existing descriptors and handles non-descriptor
+    callables as instance methods.
+    """
+
+    def __init__(self, func, /, *args, **keywords):
+        if not callable(func) and not hasattr(func, "__get__"):
+            raise TypeError("{!r} is not callable or a descriptor"
+                                 .format(func))
+
+        # func could be a descriptor like classmethod which isn't callable,
+        # so we can't inherit from partial (it verifies func is callable)
+        if isinstance(func, partialmethod):
+            # flattening is mandatory in order to place cls/self before all
+            # other arguments
+            # it's also more efficient since only one function will be called
+            self.func = func.func
+            self.args = func.args + args
+            self.keywords = {**func.keywords, **keywords}
+        else:
+            self.func = func
+            self.args = args
+            self.keywords = keywords
+
+    def __repr__(self):
+        args = ", ".join(map(repr, self.args))
+        keywords = ", ".join("{}={!r}".format(k, v)
+                                 for k, v in self.keywords.items())
+        format_string = "{module}.{cls}({func}, {args}, {keywords})"
+        return format_string.format(module=self.__class__.__module__,
+                                    cls=self.__class__.__qualname__,
+                                    func=self.func,
+                                    args=args,
+                                    keywords=keywords)
+
+    def _make_unbound_method(self):
+        def _method(cls_or_self, /, *args, **keywords):
+            keywords = {**self.keywords, **keywords}
+            return self.func(cls_or_self, *self.args, *args, **keywords)
+        _method.__isabstractmethod__ = self.__isabstractmethod__
+        _method._partialmethod = self
+        return _method
+
+    def __get__(self, obj, cls=None):
+        get = getattr(self.func, "__get__", None)
+        result = None
+        if get is not None:
+            new_func = get(obj, cls)
+            if new_func is not self.func:
+                # Assume __get__ returning something new indicates the
+                # creation of an appropriate callable
+                result = partial(new_func, *self.args, **self.keywords)
+                try:
+                    result.__self__ = new_func.__self__
+                except AttributeError:
+                    pass
+        if result is None:
+            # If the underlying descriptor didn't do anything, treat this
+            # like an instance method
+            result = self._make_unbound_method().__get__(obj, cls)
+        return result
+
+    @property
+    def __isabstractmethod__(self):
+        return getattr(self.func, "__isabstractmethod__", False)
+
+    __class_getitem__ = classmethod(GenericAlias)
+
+
+# Helper functions
+
+def _unwrap_partial(func):
+    while isinstance(func, partial):
+        func = func.func
+    return func
+
+################################################################################
+### LRU Cache function decorator
+################################################################################
+
+_CacheInfo = namedtuple("CacheInfo", ["hits", "misses", "maxsize", "currsize"])
+
+class _HashedSeq(list):
+    """ This class guarantees that hash() will be called no more than once
+        per element.  This is important because the lru_cache() will hash
+        the key multiple times on a cache miss.
+
+    """
+
+    __slots__ = 'hashvalue'
+
+    def __init__(self, tup, hash=hash):
+        self[:] = tup
+        self.hashvalue = hash(tup)
+
+    def __hash__(self):
+        return self.hashvalue
+
+def _make_key(args, kwds, typed,
+             kwd_mark = (object(),),
+             fasttypes = {int, str},
+             tuple=tuple, type=type, len=len):
+    """Make a cache key from optionally typed positional and keyword arguments
+
+    The key is constructed in a way that is flat as possible rather than
+    as a nested structure that would take more memory.
+
+    If there is only a single argument and its data type is known to cache
+    its hash value, then that argument is returned without a wrapper.  This
+    saves space and improves lookup speed.
+
+    """
+    # All of code below relies on kwds preserving the order input by the user.
+    # Formerly, we sorted() the kwds before looping.  The new way is *much*
+    # faster; however, it means that f(x=1, y=2) will now be treated as a
+    # distinct call from f(y=2, x=1) which will be cached separately.
+    key = args
+    if kwds:
+        key += kwd_mark
+        for item in kwds.items():
+            key += item
+    if typed:
+        key += tuple(type(v) for v in args)
+        if kwds:
+            key += tuple(type(v) for v in kwds.values())
+    elif len(key) == 1 and type(key[0]) in fasttypes:
+        return key[0]
+    return _HashedSeq(key)
+
+def lru_cache(maxsize=128, typed=False):
+    """Least-recently-used cache decorator.
+
+    If *maxsize* is set to None, the LRU features are disabled and the cache
+    can grow without bound.
+
+    If *typed* is True, arguments of different types will be cached separately.
+    For example, f(3.0) and f(3) will be treated as distinct calls with
+    distinct results.
+
+    Arguments to the cached function must be hashable.
+
+    View the cache statistics named tuple (hits, misses, maxsize, currsize)
+    with f.cache_info().  Clear the cache and statistics with f.cache_clear().
+    Access the underlying function with f.__wrapped__.
+
+    See:  https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)
+
+    """
+
+    # Users should only access the lru_cache through its public API:
+    #       cache_info, cache_clear, and f.__wrapped__
+    # The internals of the lru_cache are encapsulated for thread safety and
+    # to allow the implementation to change (including a possible C version).
+
+    if isinstance(maxsize, int):
+        # Negative maxsize is treated as 0
+        if maxsize < 0:
+            maxsize = 0
+    elif callable(maxsize) and isinstance(typed, bool):
+        # The user_function was passed in directly via the maxsize argument
+        user_function, maxsize = maxsize, 128
+        wrapper = _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo)
+        wrapper.cache_parameters = lambda : {'maxsize': maxsize, 'typed': typed}
+        return update_wrapper(wrapper, user_function)
+    elif maxsize is not None:
+        raise TypeError(
+            'Expected first argument to be an integer, a callable, or None')
+
+    def decorating_function(user_function):
+        wrapper = _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo)
+        wrapper.cache_parameters = lambda : {'maxsize': maxsize, 'typed': typed}
+        return update_wrapper(wrapper, user_function)
+
+    return decorating_function
+
+def _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo):
+    # Constants shared by all lru cache instances:
+    sentinel = object()          # unique object used to signal cache misses
+    make_key = _make_key         # build a key from the function arguments
+    PREV, NEXT, KEY, RESULT = 0, 1, 2, 3   # names for the link fields
+
+    cache = {}
+    hits = misses = 0
+    full = False
+    cache_get = cache.get    # bound method to lookup a key or return None
+    cache_len = cache.__len__  # get cache size without calling len()
+    lock = RLock()           # because linkedlist updates aren't threadsafe
+    root = []                # root of the circular doubly linked list
+    root[:] = [root, root, None, None]     # initialize by pointing to self
+
+    if maxsize == 0:
+
+        def wrapper(*args, **kwds):
+            # No caching -- just a statistics update
+            nonlocal misses
+            misses += 1
+            result = user_function(*args, **kwds)
+            return result
+
+    elif maxsize is None:
+
+        def wrapper(*args, **kwds):
+            # Simple caching without ordering or size limit
+            nonlocal hits, misses
+            key = make_key(args, kwds, typed)
+            result = cache_get(key, sentinel)
+            if result is not sentinel:
+                hits += 1
+                return result
+            misses += 1
+            result = user_function(*args, **kwds)
+            cache[key] = result
+            return result
+
+    else:
+
+        def wrapper(*args, **kwds):
+            # Size limited caching that tracks accesses by recency
+            nonlocal root, hits, misses, full
+            key = make_key(args, kwds, typed)
+            with lock:
+                link = cache_get(key)
+                if link is not None:
+                    # Move the link to the front of the circular queue
+                    link_prev, link_next, _key, result = link
+                    link_prev[NEXT] = link_next
+                    link_next[PREV] = link_prev
+                    last = root[PREV]
+                    last[NEXT] = root[PREV] = link
+                    link[PREV] = last
+                    link[NEXT] = root
+                    hits += 1
+                    return result
+                misses += 1
+            result = user_function(*args, **kwds)
+            with lock:
+                if key in cache:
+                    # Getting here means that this same key was added to the
+                    # cache while the lock was released.  Since the link
+                    # update is already done, we need only return the
+                    # computed result and update the count of misses.
+                    pass
+                elif full:
+                    # Use the old root to store the new key and result.
+                    oldroot = root
+                    oldroot[KEY] = key
+                    oldroot[RESULT] = result
+                    # Empty the oldest link and make it the new root.
+                    # Keep a reference to the old key and old result to
+                    # prevent their ref counts from going to zero during the
+                    # update. That will prevent potentially arbitrary object
+                    # clean-up code (i.e. __del__) from running while we're
+                    # still adjusting the links.
+                    root = oldroot[NEXT]
+                    oldkey = root[KEY]
+                    oldresult = root[RESULT]
+                    root[KEY] = root[RESULT] = None
+                    # Now update the cache dictionary.
+                    del cache[oldkey]
+                    # Save the potentially reentrant cache[key] assignment
+                    # for last, after the root and links have been put in
+                    # a consistent state.
+                    cache[key] = oldroot
+                else:
+                    # Put result in a new link at the front of the queue.
+                    last = root[PREV]
+                    link = [last, root, key, result]
+                    last[NEXT] = root[PREV] = cache[key] = link
+                    # Use the cache_len bound method instead of the len() function
+                    # which could potentially be wrapped in an lru_cache itself.
+                    full = (cache_len() >= maxsize)
+            return result
+
+    def cache_info():
+        """Report cache statistics"""
+        with lock:
+            return _CacheInfo(hits, misses, maxsize, cache_len())
+
+    def cache_clear():
+        """Clear the cache and cache statistics"""
+        nonlocal hits, misses, full
+        with lock:
+            cache.clear()
+            root[:] = [root, root, None, None]
+            hits = misses = 0
+            full = False
+
+    wrapper.cache_info = cache_info
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+try:
+    from _functools import _lru_cache_wrapper
+except ImportError:
+    pass
+
+
+################################################################################
+### cache -- simplified access to the infinity cache
+################################################################################
+
+def cache(user_function, /):
+    'Simple lightweight unbounded cache.  Sometimes called "memoize".'
+    return lru_cache(maxsize=None)(user_function)
+
+
+################################################################################
+### singledispatch() - single-dispatch generic function decorator
+################################################################################
+
+def _c3_merge(sequences):
+    """Merges MROs in *sequences* to a single MRO using the C3 algorithm.
+
+    Adapted from https://www.python.org/download/releases/2.3/mro/.
+
+    """
+    result = []
+    while True:
+        sequences = [s for s in sequences if s]   # purge empty sequences
+        if not sequences:
+            return result
+        for s1 in sequences:   # find merge candidates among seq heads
+            candidate = s1[0]
+            for s2 in sequences:
+                if candidate in s2[1:]:
+                    candidate = None
+                    break      # reject the current head, it appears later
+            else:
+                break
+        if candidate is None:
+            raise RuntimeError("Inconsistent hierarchy")
+        result.append(candidate)
+        # remove the chosen candidate
+        for seq in sequences:
+            if seq[0] == candidate:
+                del seq[0]
+
+def _c3_mro(cls, abcs=None):
+    """Computes the method resolution order using extended C3 linearization.
+
+    If no *abcs* are given, the algorithm works exactly like the built-in C3
+    linearization used for method resolution.
+
+    If given, *abcs* is a list of abstract base classes that should be inserted
+    into the resulting MRO. Unrelated ABCs are ignored and don't end up in the
+    result. The algorithm inserts ABCs where their functionality is introduced,
+    i.e. issubclass(cls, abc) returns True for the class itself but returns
+    False for all its direct base classes. Implicit ABCs for a given class
+    (either registered or inferred from the presence of a special method like
+    __len__) are inserted directly after the last ABC explicitly listed in the
+    MRO of said class. If two implicit ABCs end up next to each other in the
+    resulting MRO, their ordering depends on the order of types in *abcs*.
+
+    """
+    for i, base in enumerate(reversed(cls.__bases__)):
+        if hasattr(base, '__abstractmethods__'):
+            boundary = len(cls.__bases__) - i
+            break   # Bases up to the last explicit ABC are considered first.
+    else:
+        boundary = 0
+    abcs = list(abcs) if abcs else []
+    explicit_bases = list(cls.__bases__[:boundary])
+    abstract_bases = []
+    other_bases = list(cls.__bases__[boundary:])
+    for base in abcs:
+        if issubclass(cls, base) and not any(
+                issubclass(b, base) for b in cls.__bases__
+            ):
+            # If *cls* is the class that introduces behaviour described by
+            # an ABC *base*, insert said ABC to its MRO.
+            abstract_bases.append(base)
+    for base in abstract_bases:
+        abcs.remove(base)
+    explicit_c3_mros = [_c3_mro(base, abcs=abcs) for base in explicit_bases]
+    abstract_c3_mros = [_c3_mro(base, abcs=abcs) for base in abstract_bases]
+    other_c3_mros = [_c3_mro(base, abcs=abcs) for base in other_bases]
+    return _c3_merge(
+        [[cls]] +
+        explicit_c3_mros + abstract_c3_mros + other_c3_mros +
+        [explicit_bases] + [abstract_bases] + [other_bases]
+    )
+
+def _compose_mro(cls, types):
+    """Calculates the method resolution order for a given class *cls*.
+
+    Includes relevant abstract base classes (with their respective bases) from
+    the *types* iterable. Uses a modified C3 linearization algorithm.
+
+    """
+    bases = set(cls.__mro__)
+    # Remove entries which are already present in the __mro__ or unrelated.
+    def is_related(typ):
+        return (typ not in bases and hasattr(typ, '__mro__')
+                                 and not isinstance(typ, GenericAlias)
+                                 and issubclass(cls, typ))
+    types = [n for n in types if is_related(n)]
+    # Remove entries which are strict bases of other entries (they will end up
+    # in the MRO anyway.
+    def is_strict_base(typ):
+        for other in types:
+            if typ != other and typ in other.__mro__:
+                return True
+        return False
+    types = [n for n in types if not is_strict_base(n)]
+    # Subclasses of the ABCs in *types* which are also implemented by
+    # *cls* can be used to stabilize ABC ordering.
+    type_set = set(types)
+    mro = []
+    for typ in types:
+        found = []
+        for sub in typ.__subclasses__():
+            if sub not in bases and issubclass(cls, sub):
+                found.append([s for s in sub.__mro__ if s in type_set])
+        if not found:
+            mro.append(typ)
+            continue
+        # Favor subclasses with the biggest number of useful bases
+        found.sort(key=len, reverse=True)
+        for sub in found:
+            for subcls in sub:
+                if subcls not in mro:
+                    mro.append(subcls)
+    return _c3_mro(cls, abcs=mro)
+
+def _find_impl(cls, registry):
+    """Returns the best matching implementation from *registry* for type *cls*.
+
+    Where there is no registered implementation for a specific type, its method
+    resolution order is used to find a more generic implementation.
+
+    Note: if *registry* does not contain an implementation for the base
+    *object* type, this function may return None.
+
+    """
+    mro = _compose_mro(cls, registry.keys())
+    match = None
+    for t in mro:
+        if match is not None:
+            # If *match* is an implicit ABC but there is another unrelated,
+            # equally matching implicit ABC, refuse the temptation to guess.
+            if (t in registry and t not in cls.__mro__
+                              and match not in cls.__mro__
+                              and not issubclass(match, t)):
+                raise RuntimeError("Ambiguous dispatch: {} or {}".format(
+                    match, t))
+            break
+        if t in registry:
+            match = t
+    return registry.get(match)
+
+def singledispatch(func):
+    """Single-dispatch generic function decorator.
+
+    Transforms a function into a generic function, which can have different
+    behaviours depending upon the type of its first argument. The decorated
+    function acts as the default implementation, and additional
+    implementations can be registered using the register() attribute of the
+    generic function.
+    """
+    # There are many programs that use functools without singledispatch, so we
+    # trade-off making singledispatch marginally slower for the benefit of
+    # making start-up of such applications slightly faster.
+    import types, weakref
+
+    registry = {}
+    dispatch_cache = weakref.WeakKeyDictionary()
+    cache_token = None
+
+    def dispatch(cls):
+        """generic_func.dispatch(cls) -> <function implementation>
+
+        Runs the dispatch algorithm to return the best available implementation
+        for the given *cls* registered on *generic_func*.
+
+        """
+        nonlocal cache_token
+        if cache_token is not None:
+            current_token = get_cache_token()
+            if cache_token != current_token:
+                dispatch_cache.clear()
+                cache_token = current_token
+        try:
+            impl = dispatch_cache[cls]
+        except KeyError:
+            try:
+                impl = registry[cls]
+            except KeyError:
+                impl = _find_impl(cls, registry)
+            dispatch_cache[cls] = impl
+        return impl
+
+    def _is_valid_dispatch_type(cls):
+        return isinstance(cls, type) and not isinstance(cls, GenericAlias)
+
+    def register(cls, func=None):
+        """generic_func.register(cls, func) -> func
+
+        Registers a new implementation for the given *cls* on a *generic_func*.
+
+        """
+        nonlocal cache_token
+        if _is_valid_dispatch_type(cls):
+            if func is None:
+                return lambda f: register(cls, f)
+        else:
+            if func is not None:
+                raise TypeError(
+                    f"Invalid first argument to `register()`. "
+                    f"{cls!r} is not a class."
+                )
+            ann = getattr(cls, '__annotations__', {})
+            if not ann:
+                raise TypeError(
+                    f"Invalid first argument to `register()`: {cls!r}. "
+                    f"Use either `@register(some_class)` or plain `@register` "
+                    f"on an annotated function."
+                )
+            func = cls
+
+            # only import typing if annotation parsing is necessary
+            from typing import get_type_hints
+            argname, cls = next(iter(get_type_hints(func).items()))
+            if not _is_valid_dispatch_type(cls):
+                raise TypeError(
+                    f"Invalid annotation for {argname!r}. "
+                    f"{cls!r} is not a class."
+                )
+
+        registry[cls] = func
+        if cache_token is None and hasattr(cls, '__abstractmethods__'):
+            cache_token = get_cache_token()
+        dispatch_cache.clear()
+        return func
+
+    def wrapper(*args, **kw):
+        if not args:
+            raise TypeError(f'{funcname} requires at least '
+                            '1 positional argument')
+
+        return dispatch(args[0].__class__)(*args, **kw)
+
+    funcname = getattr(func, '__name__', 'singledispatch function')
+    registry[object] = func
+    wrapper.register = register
+    wrapper.dispatch = dispatch
+    wrapper.registry = types.MappingProxyType(registry)
+    wrapper._clear_cache = dispatch_cache.clear
+    update_wrapper(wrapper, func)
+    return wrapper
+
+
+# Descriptor version
+class singledispatchmethod:
+    """Single-dispatch generic method descriptor.
+
+    Supports wrapping existing descriptors and handles non-descriptor
+    callables as instance methods.
+    """
+
+    def __init__(self, func):
+        if not callable(func) and not hasattr(func, "__get__"):
+            raise TypeError(f"{func!r} is not callable or a descriptor")
+
+        self.dispatcher = singledispatch(func)
+        self.func = func
+
+    def register(self, cls, method=None):
+        """generic_method.register(cls, func) -> func
+
+        Registers a new implementation for the given *cls* on a *generic_method*.
+        """
+        return self.dispatcher.register(cls, func=method)
+
+    def __get__(self, obj, cls=None):
+        def _method(*args, **kwargs):
+            method = self.dispatcher.dispatch(args[0].__class__)
+            return method.__get__(obj, cls)(*args, **kwargs)
+
+        _method.__isabstractmethod__ = self.__isabstractmethod__
+        _method.register = self.register
+        update_wrapper(_method, self.func)
+        return _method
+
+    @property
+    def __isabstractmethod__(self):
+        return getattr(self.func, '__isabstractmethod__', False)
+
+
+################################################################################
+### cached_property() - computed once per instance, cached as attribute
+################################################################################
+
+_NOT_FOUND = object()
+
+
+class cached_property:
+    def __init__(self, func):
+        self.func = func
+        self.attrname = None
+        self.__doc__ = func.__doc__
+        self.lock = RLock()
+
+    def __set_name__(self, owner, name):
+        if self.attrname is None:
+            self.attrname = name
+        elif name != self.attrname:
+            raise TypeError(
+                "Cannot assign the same cached_property to two different names "
+                f"({self.attrname!r} and {name!r})."
+            )
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if self.attrname is None:
+            raise TypeError(
+                "Cannot use cached_property instance without calling __set_name__ on it.")
+        try:
+            cache = instance.__dict__
+        except AttributeError:  # not all objects have __dict__ (e.g. class defines slots)
+            msg = (
+                f"No '__dict__' attribute on {type(instance).__name__!r} "
+                f"instance to cache {self.attrname!r} property."
+            )
+            raise TypeError(msg) from None
+        val = cache.get(self.attrname, _NOT_FOUND)
+        if val is _NOT_FOUND:
+            with self.lock:
+                # check if another thread filled cache while we awaited lock
+                val = cache.get(self.attrname, _NOT_FOUND)
+                if val is _NOT_FOUND:
+                    val = self.func(instance)
+                    try:
+                        cache[self.attrname] = val
+                    except TypeError:
+                        msg = (
+                            f"The '__dict__' attribute on {type(instance).__name__!r} instance "
+                            f"does not support item assignment for caching {self.attrname!r} property."
+                        )
+                        raise TypeError(msg) from None
+        return val
+
+    __class_getitem__ = classmethod(GenericAlias)

shared/package-files/17/170374feae76894ea274b359357a34d3680f369570ffdc6bc4b89f1672bfb2cc/preview.py

@@ -0,0 +1,390 @@
+import os
+from os.path import join
+import shutil
+import tempfile
+
+try:
+    from subprocess import STDOUT, CalledProcessError, check_output
+except ImportError:
+    pass
+
+from sympy.utilities.decorator import doctest_depends_on
+from sympy.utilities.misc import debug
+from .latex import latex
+
+__doctest_requires__ = {('preview',): ['pyglet']}
+
+
+def _check_output_no_window(*args, **kwargs):
+    # Avoid showing a cmd.exe window when running this
+    # on Windows
+    if os.name == 'nt':
+        creation_flag = 0x08000000 # CREATE_NO_WINDOW
+    else:
+        creation_flag = 0 # Default value
+    return check_output(*args, creationflags=creation_flag, **kwargs)
+
+
+def system_default_viewer(fname, fmt):
+    """ Open fname with the default system viewer.
+
+    In practice, it is impossible for python to know when the system viewer is
+    done. For this reason, we ensure the passed file will not be deleted under
+    it, and this function does not attempt to block.
+    """
+    # copy to a new temporary file that will not be deleted
+    with tempfile.NamedTemporaryFile(prefix='sympy-preview-',
+                                     suffix=os.path.splitext(fname)[1],
+                                     delete=False) as temp_f:
+        with open(fname, 'rb') as f:
+            shutil.copyfileobj(f, temp_f)
+
+    import platform
+    if platform.system() == 'Darwin':
+        import subprocess
+        subprocess.call(('open', temp_f.name))
+    elif platform.system() == 'Windows':
+        os.startfile(temp_f.name)
+    else:
+        import subprocess
+        subprocess.call(('xdg-open', temp_f.name))
+
+
+def pyglet_viewer(fname, fmt):
+    try:
+        from pyglet import window, image, gl
+        from pyglet.window import key
+        from pyglet.image.codecs import ImageDecodeException
+    except ImportError:
+        raise ImportError("pyglet is required for preview.\n visit https://pyglet.org/")
+
+    try:
+        img = image.load(fname)
+    except ImageDecodeException:
+        raise ValueError("pyglet preview does not work for '{}' files.".format(fmt))
+
+    offset = 25
+
+    config = gl.Config(double_buffer=False)
+    win = window.Window(
+        width=img.width + 2*offset,
+        height=img.height + 2*offset,
+        caption="SymPy",
+        resizable=False,
+        config=config
+    )
+
+    win.set_vsync(False)
+
+    try:
+        def on_close():
+            win.has_exit = True
+
+        win.on_close = on_close
+
+        def on_key_press(symbol, modifiers):
+            if symbol in [key.Q, key.ESCAPE]:
+                on_close()
+
+        win.on_key_press = on_key_press
+
+        def on_expose():
+            gl.glClearColor(1.0, 1.0, 1.0, 1.0)
+            gl.glClear(gl.GL_COLOR_BUFFER_BIT)
+
+            img.blit(
+                (win.width - img.width) / 2,
+                (win.height - img.height) / 2
+            )
+
+        win.on_expose = on_expose
+
+        while not win.has_exit:
+            win.dispatch_events()
+            win.flip()
+    except KeyboardInterrupt:
+        pass
+
+    win.close()
+
+
+def _get_latex_main(expr, *, preamble=None, packages=(), extra_preamble=None,
+                    euler=True, fontsize=None, **latex_settings):
+    """
+    Generate string of a LaTeX document rendering ``expr``.
+    """
+    if preamble is None:
+        actual_packages = packages + ("amsmath", "amsfonts")
+        if euler:
+            actual_packages += ("euler",)
+        package_includes = "\n" + "\n".join(["\\usepackage{%s}" % p
+                                             for p in actual_packages])
+        if extra_preamble:
+            package_includes += extra_preamble
+
+        if not fontsize:
+            fontsize = "12pt"
+        elif isinstance(fontsize, int):
+            fontsize = "{}pt".format(fontsize)
+        preamble = r"""\documentclass[varwidth,%s]{standalone}
+%s
+
+\begin{document}
+""" % (fontsize, package_includes)
+    else:
+        if packages or extra_preamble:
+            raise ValueError("The \"packages\" or \"extra_preamble\" keywords"
+                             "must not be set if a "
+                             "custom LaTeX preamble was specified")
+
+    if isinstance(expr, str):
+        latex_string = expr
+    else:
+        latex_string = ('$\\displaystyle ' +
+                        latex(expr, mode='plain', **latex_settings) +
+                        '$')
+
+    return preamble + '\n' + latex_string + '\n\n' + r"\end{document}"
+
+
+@doctest_depends_on(exe=('latex', 'dvipng'), modules=('pyglet',),
+            disable_viewers=('evince', 'gimp', 'superior-dvi-viewer'))
+def preview(expr, output='png', viewer=None, euler=True, packages=(),
+            filename=None, outputbuffer=None, preamble=None, dvioptions=None,
+            outputTexFile=None, extra_preamble=None, fontsize=None,
+            **latex_settings):
+    r"""
+    View expression or LaTeX markup in PNG, DVI, PostScript or PDF form.
+
+    If the expr argument is an expression, it will be exported to LaTeX and
+    then compiled using the available TeX distribution.  The first argument,
+    'expr', may also be a LaTeX string.  The function will then run the
+    appropriate viewer for the given output format or use the user defined
+    one. By default png output is generated.
+
+    By default pretty Euler fonts are used for typesetting (they were used to
+    typeset the well known "Concrete Mathematics" book). For that to work, you
+    need the 'eulervm.sty' LaTeX style (in Debian/Ubuntu, install the
+    texlive-fonts-extra package). If you prefer default AMS fonts or your
+    system lacks 'eulervm' LaTeX package then unset the 'euler' keyword
+    argument.
+
+    To use viewer auto-detection, lets say for 'png' output, issue
+
+    >>> from sympy import symbols, preview, Symbol
+    >>> x, y = symbols("x,y")
+
+    >>> preview(x + y, output='png')
+
+    This will choose 'pyglet' by default. To select a different one, do
+
+    >>> preview(x + y, output='png', viewer='gimp')
+
+    The 'png' format is considered special. For all other formats the rules
+    are slightly different. As an example we will take 'dvi' output format. If
+    you would run
+
+    >>> preview(x + y, output='dvi')
+
+    then 'view' will look for available 'dvi' viewers on your system
+    (predefined in the function, so it will try evince, first, then kdvi and
+    xdvi). If nothing is found, it will fall back to using a system file
+    association (via ``open`` and ``xdg-open``). To always use your system file
+    association without searching for the above readers, use
+
+    >>> from sympy.printing.preview import system_default_viewer
+    >>> preview(x + y, output='dvi', viewer=system_default_viewer)
+
+    If this still does not find the viewer you want, it can be set explicitly.
+
+    >>> preview(x + y, output='dvi', viewer='superior-dvi-viewer')
+
+    This will skip auto-detection and will run user specified
+    'superior-dvi-viewer'. If ``view`` fails to find it on your system it will
+    gracefully raise an exception.
+
+    You may also enter ``'file'`` for the viewer argument. Doing so will cause
+    this function to return a file object in read-only mode, if ``filename``
+    is unset. However, if it was set, then 'preview' writes the generated
+    file to this filename instead.
+
+    There is also support for writing to a ``io.BytesIO`` like object, which
+    needs to be passed to the ``outputbuffer`` argument.
+
+    >>> from io import BytesIO
+    >>> obj = BytesIO()
+    >>> preview(x + y, output='png', viewer='BytesIO',
+    ...         outputbuffer=obj)
+
+    The LaTeX preamble can be customized by setting the 'preamble' keyword
+    argument. This can be used, e.g., to set a different font size, use a
+    custom documentclass or import certain set of LaTeX packages.
+
+    >>> preamble = "\\documentclass[10pt]{article}\n" \
+    ...            "\\usepackage{amsmath,amsfonts}\\begin{document}"
+    >>> preview(x + y, output='png', preamble=preamble)
+
+    It is also possible to use the standard preamble and provide additional
+    information to the preamble using the ``extra_preamble`` keyword argument.
+
+    >>> from sympy import sin
+    >>> extra_preamble = "\\renewcommand{\\sin}{\\cos}"
+    >>> preview(sin(x), output='png', extra_preamble=extra_preamble)
+
+    If the value of 'output' is different from 'dvi' then command line
+    options can be set ('dvioptions' argument) for the execution of the
+    'dvi'+output conversion tool. These options have to be in the form of a
+    list of strings (see ``subprocess.Popen``).
+
+    Additional keyword args will be passed to the :func:`~sympy.printing.latex.latex` call,
+    e.g., the ``symbol_names`` flag.
+
+    >>> phidd = Symbol('phidd')
+    >>> preview(phidd, symbol_names={phidd: r'\ddot{\varphi}'})
+
+    For post-processing the generated TeX File can be written to a file by
+    passing the desired filename to the 'outputTexFile' keyword
+    argument. To write the TeX code to a file named
+    ``"sample.tex"`` and run the default png viewer to display the resulting
+    bitmap, do
+
+    >>> preview(x + y, outputTexFile="sample.tex")
+
+
+    """
+    # pyglet is the default for png
+    if viewer is None and output == "png":
+        try:
+            import pyglet  # noqa: F401
+        except ImportError:
+            pass
+        else:
+            viewer = pyglet_viewer
+
+    # look up a known application
+    if viewer is None:
+        # sorted in order from most pretty to most ugly
+        # very discussable, but indeed 'gv' looks awful :)
+        candidates = {
+            "dvi": [ "evince", "okular", "kdvi", "xdvi" ],
+            "ps": [ "evince", "okular", "gsview", "gv" ],
+            "pdf": [ "evince", "okular", "kpdf", "acroread", "xpdf", "gv" ],
+        }
+
+        for candidate in candidates.get(output, []):
+            path = shutil.which(candidate)
+            if path is not None:
+                viewer = path
+                break
+
+    # otherwise, use the system default for file association
+    if viewer is None:
+        viewer = system_default_viewer
+
+    if viewer == "file":
+        if filename is None:
+            raise ValueError("filename has to be specified if viewer=\"file\"")
+    elif viewer == "BytesIO":
+        if outputbuffer is None:
+            raise ValueError("outputbuffer has to be a BytesIO "
+                             "compatible object if viewer=\"BytesIO\"")
+    elif not callable(viewer) and not shutil.which(viewer):
+        raise OSError("Unrecognized viewer: %s" % viewer)
+
+    latex_main = _get_latex_main(expr, preamble=preamble, packages=packages,
+                                 euler=euler, extra_preamble=extra_preamble,
+                                 fontsize=fontsize, **latex_settings)
+
+    debug("Latex code:")
+    debug(latex_main)
+    with tempfile.TemporaryDirectory() as workdir:
+        with open(join(workdir, 'texput.tex'), 'w', encoding='utf-8') as fh:
+            fh.write(latex_main)
+
+        if outputTexFile is not None:
+            shutil.copyfile(join(workdir, 'texput.tex'), outputTexFile)
+
+        if not shutil.which('latex'):
+            raise RuntimeError("latex program is not installed")
+
+        try:
+            _check_output_no_window(
+                ['latex', '-halt-on-error', '-interaction=nonstopmode',
+                 'texput.tex'],
+                cwd=workdir,
+                stderr=STDOUT)
+        except CalledProcessError as e:
+            raise RuntimeError(
+                "'latex' exited abnormally with the following output:\n%s" %
+                e.output)
+
+        src = "texput.%s" % (output)
+
+        if output != "dvi":
+            # in order of preference
+            commandnames = {
+                "ps": ["dvips"],
+                "pdf": ["dvipdfmx", "dvipdfm", "dvipdf"],
+                "png": ["dvipng"],
+                "svg": ["dvisvgm"],
+            }
+            try:
+                cmd_variants = commandnames[output]
+            except KeyError:
+                raise ValueError("Invalid output format: %s" % output) from None
+
+            # find an appropriate command
+            for cmd_variant in cmd_variants:
+                cmd_path = shutil.which(cmd_variant)
+                if cmd_path:
+                    cmd = [cmd_path]
+                    break
+            else:
+                if len(cmd_variants) > 1:
+                    raise RuntimeError("None of %s are installed" % ", ".join(cmd_variants))
+                else:
+                    raise RuntimeError("%s is not installed" % cmd_variants[0])
+
+            defaultoptions = {
+                "dvipng": ["-T", "tight", "-z", "9", "--truecolor"],
+                "dvisvgm": ["--no-fonts"],
+            }
+
+            commandend = {
+                "dvips": ["-o", src, "texput.dvi"],
+                "dvipdf": ["texput.dvi", src],
+                "dvipdfm": ["-o", src, "texput.dvi"],
+                "dvipdfmx": ["-o", src, "texput.dvi"],
+                "dvipng": ["-o", src, "texput.dvi"],
+                "dvisvgm": ["-o", src, "texput.dvi"],
+            }
+
+            if dvioptions is not None:
+                cmd.extend(dvioptions)
+            else:
+                cmd.extend(defaultoptions.get(cmd_variant, []))
+            cmd.extend(commandend[cmd_variant])
+
+            try:
+                _check_output_no_window(cmd, cwd=workdir, stderr=STDOUT)
+            except CalledProcessError as e:
+                raise RuntimeError(
+                    "'%s' exited abnormally with the following output:\n%s" %
+                    (' '.join(cmd), e.output))
+
+
+        if viewer == "file":
+            shutil.move(join(workdir, src), filename)
+        elif viewer == "BytesIO":
+            with open(join(workdir, src), 'rb') as fh:
+                outputbuffer.write(fh.read())
+        elif callable(viewer):
+            viewer(join(workdir, src), fmt=output)
+        else:
+            try:
+                _check_output_no_window(
+                    [viewer, src], cwd=workdir, stderr=STDOUT)
+            except CalledProcessError as e:
+                raise RuntimeError(
+                    "'%s %s' exited abnormally with the following output:\n%s" %
+                    (viewer, src, e.output))

shared/package-files/17/17042ba9d09eb176e0910f1b7d83e57f72df2be49dbee77da47102dad0a7c10d/test_align.py

@@ -0,0 +1,484 @@
+from datetime import timezone
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestDataFrameAlign:
+    def test_align_asfreq_method_raises(self):
+        df = DataFrame({"A": [1, np.nan, 2]})
+        msg = "Invalid fill method"
+        msg2 = "The 'method', 'limit', and 'fill_axis' keywords"
+        with pytest.raises(ValueError, match=msg):
+            with tm.assert_produces_warning(FutureWarning, match=msg2):
+                df.align(df.iloc[::-1], method="asfreq")
+
+    def test_frame_align_aware(self):
+        idx1 = date_range("2001", periods=5, freq="h", tz="US/Eastern")
+        idx2 = date_range("2001", periods=5, freq="2h", tz="US/Eastern")
+        df1 = DataFrame(np.random.default_rng(2).standard_normal((len(idx1), 3)), idx1)
+        df2 = DataFrame(np.random.default_rng(2).standard_normal((len(idx2), 3)), idx2)
+        new1, new2 = df1.align(df2)
+        assert df1.index.tz == new1.index.tz
+        assert df2.index.tz == new2.index.tz
+
+        # different timezones convert to UTC
+
+        # frame with frame
+        df1_central = df1.tz_convert("US/Central")
+        new1, new2 = df1.align(df1_central)
+        assert new1.index.tz is timezone.utc
+        assert new2.index.tz is timezone.utc
+
+        # frame with Series
+        new1, new2 = df1.align(df1_central[0], axis=0)
+        assert new1.index.tz is timezone.utc
+        assert new2.index.tz is timezone.utc
+
+        df1[0].align(df1_central, axis=0)
+        assert new1.index.tz is timezone.utc
+        assert new2.index.tz is timezone.utc
+
+    def test_align_float(self, float_frame, using_copy_on_write):
+        af, bf = float_frame.align(float_frame)
+        assert af._mgr is not float_frame._mgr
+
+        af, bf = float_frame.align(float_frame, copy=False)
+        if not using_copy_on_write:
+            assert af._mgr is float_frame._mgr
+        else:
+            assert af._mgr is not float_frame._mgr
+
+        # axis = 0
+        other = float_frame.iloc[:-5, :3]
+        af, bf = float_frame.align(other, axis=0, fill_value=-1)
+
+        tm.assert_index_equal(bf.columns, other.columns)
+
+        # test fill value
+        join_idx = float_frame.index.join(other.index)
+        diff_a = float_frame.index.difference(join_idx)
+        diff_a_vals = af.reindex(diff_a).values
+        assert (diff_a_vals == -1).all()
+
+        af, bf = float_frame.align(other, join="right", axis=0)
+        tm.assert_index_equal(bf.columns, other.columns)
+        tm.assert_index_equal(bf.index, other.index)
+        tm.assert_index_equal(af.index, other.index)
+
+        # axis = 1
+        other = float_frame.iloc[:-5, :3].copy()
+        af, bf = float_frame.align(other, axis=1)
+        tm.assert_index_equal(bf.columns, float_frame.columns)
+        tm.assert_index_equal(bf.index, other.index)
+
+        # test fill value
+        join_idx = float_frame.index.join(other.index)
+        diff_a = float_frame.index.difference(join_idx)
+        diff_a_vals = af.reindex(diff_a).values
+
+        assert (diff_a_vals == -1).all()
+
+        af, bf = float_frame.align(other, join="inner", axis=1)
+        tm.assert_index_equal(bf.columns, other.columns)
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = float_frame.align(other, join="inner", axis=1, method="pad")
+        tm.assert_index_equal(bf.columns, other.columns)
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = float_frame.align(
+                other.iloc[:, 0], join="inner", axis=1, method=None, fill_value=None
+            )
+        tm.assert_index_equal(bf.index, Index([]).astype(bf.index.dtype))
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = float_frame.align(
+                other.iloc[:, 0], join="inner", axis=1, method=None, fill_value=0
+            )
+        tm.assert_index_equal(bf.index, Index([]).astype(bf.index.dtype))
+
+        # Try to align DataFrame to Series along bad axis
+        msg = "No axis named 2 for object type DataFrame"
+        with pytest.raises(ValueError, match=msg):
+            float_frame.align(af.iloc[0, :3], join="inner", axis=2)
+
+    def test_align_frame_with_series(self, float_frame):
+        # align dataframe to series with broadcast or not
+        idx = float_frame.index
+        s = Series(range(len(idx)), index=idx)
+
+        left, right = float_frame.align(s, axis=0)
+        tm.assert_index_equal(left.index, float_frame.index)
+        tm.assert_index_equal(right.index, float_frame.index)
+        assert isinstance(right, Series)
+
+        msg = "The 'broadcast_axis' keyword in DataFrame.align is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            left, right = float_frame.align(s, broadcast_axis=1)
+        tm.assert_index_equal(left.index, float_frame.index)
+        expected = {c: s for c in float_frame.columns}
+        expected = DataFrame(
+            expected, index=float_frame.index, columns=float_frame.columns
+        )
+        tm.assert_frame_equal(right, expected)
+
+    def test_align_series_condition(self):
+        # see gh-9558
+        df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        result = df[df["a"] == 2]
+        expected = DataFrame([[2, 5]], index=[1], columns=["a", "b"])
+        tm.assert_frame_equal(result, expected)
+
+        result = df.where(df["a"] == 2, 0)
+        expected = DataFrame({"a": [0, 2, 0], "b": [0, 5, 0]})
+        tm.assert_frame_equal(result, expected)
+
+    def test_align_int(self, int_frame):
+        # test other non-float types
+        other = DataFrame(index=range(5), columns=["A", "B", "C"])
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = int_frame.align(other, join="inner", axis=1, method="pad")
+        tm.assert_index_equal(bf.columns, other.columns)
+
+    def test_align_mixed_type(self, float_string_frame):
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = float_string_frame.align(
+                float_string_frame, join="inner", axis=1, method="pad"
+            )
+        tm.assert_index_equal(bf.columns, float_string_frame.columns)
+
+    def test_align_mixed_float(self, mixed_float_frame):
+        # mixed floats/ints
+        other = DataFrame(index=range(5), columns=["A", "B", "C"])
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = mixed_float_frame.align(
+                other.iloc[:, 0], join="inner", axis=1, method=None, fill_value=0
+            )
+        tm.assert_index_equal(bf.index, Index([]))
+
+    def test_align_mixed_int(self, mixed_int_frame):
+        other = DataFrame(index=range(5), columns=["A", "B", "C"])
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            af, bf = mixed_int_frame.align(
+                other.iloc[:, 0], join="inner", axis=1, method=None, fill_value=0
+            )
+        tm.assert_index_equal(bf.index, Index([]))
+
+    @pytest.mark.parametrize(
+        "l_ordered,r_ordered,expected",
+        [
+            [True, True, pd.CategoricalIndex],
+            [True, False, Index],
+            [False, True, Index],
+            [False, False, pd.CategoricalIndex],
+        ],
+    )
+    def test_align_categorical(self, l_ordered, r_ordered, expected):
+        # GH-28397
+        df_1 = DataFrame(
+            {
+                "A": np.arange(6, dtype="int64"),
+                "B": Series(list("aabbca")).astype(
+                    pd.CategoricalDtype(list("cab"), ordered=l_ordered)
+                ),
+            }
+        ).set_index("B")
+        df_2 = DataFrame(
+            {
+                "A": np.arange(5, dtype="int64"),
+                "B": Series(list("babca")).astype(
+                    pd.CategoricalDtype(list("cab"), ordered=r_ordered)
+                ),
+            }
+        ).set_index("B")
+
+        aligned_1, aligned_2 = df_1.align(df_2)
+        assert isinstance(aligned_1.index, expected)
+        assert isinstance(aligned_2.index, expected)
+        tm.assert_index_equal(aligned_1.index, aligned_2.index)
+
+    def test_align_multiindex(self):
+        # GH#10665
+        # same test cases as test_align_multiindex in test_series.py
+
+        midx = pd.MultiIndex.from_product(
+            [range(2), range(3), range(2)], names=("a", "b", "c")
+        )
+        idx = Index(range(2), name="b")
+        df1 = DataFrame(np.arange(12, dtype="int64"), index=midx)
+        df2 = DataFrame(np.arange(2, dtype="int64"), index=idx)
+
+        # these must be the same results (but flipped)
+        res1l, res1r = df1.align(df2, join="left")
+        res2l, res2r = df2.align(df1, join="right")
+
+        expl = df1
+        tm.assert_frame_equal(expl, res1l)
+        tm.assert_frame_equal(expl, res2r)
+        expr = DataFrame([0, 0, 1, 1, np.nan, np.nan] * 2, index=midx)
+        tm.assert_frame_equal(expr, res1r)
+        tm.assert_frame_equal(expr, res2l)
+
+        res1l, res1r = df1.align(df2, join="right")
+        res2l, res2r = df2.align(df1, join="left")
+
+        exp_idx = pd.MultiIndex.from_product(
+            [range(2), range(2), range(2)], names=("a", "b", "c")
+        )
+        expl = DataFrame([0, 1, 2, 3, 6, 7, 8, 9], index=exp_idx)
+        tm.assert_frame_equal(expl, res1l)
+        tm.assert_frame_equal(expl, res2r)
+        expr = DataFrame([0, 0, 1, 1] * 2, index=exp_idx)
+        tm.assert_frame_equal(expr, res1r)
+        tm.assert_frame_equal(expr, res2l)
+
+    def test_align_series_combinations(self):
+        df = DataFrame({"a": [1, 3, 5], "b": [1, 3, 5]}, index=list("ACE"))
+        s = Series([1, 2, 4], index=list("ABD"), name="x")
+
+        # frame + series
+        res1, res2 = df.align(s, axis=0)
+        exp1 = DataFrame(
+            {"a": [1, np.nan, 3, np.nan, 5], "b": [1, np.nan, 3, np.nan, 5]},
+            index=list("ABCDE"),
+        )
+        exp2 = Series([1, 2, np.nan, 4, np.nan], index=list("ABCDE"), name="x")
+
+        tm.assert_frame_equal(res1, exp1)
+        tm.assert_series_equal(res2, exp2)
+
+        # series + frame
+        res1, res2 = s.align(df)
+        tm.assert_series_equal(res1, exp2)
+        tm.assert_frame_equal(res2, exp1)
+
+    def test_multiindex_align_to_series_with_common_index_level(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 2], name="bar")
+
+        series = Series([1, 2], index=bar_index, name="foo_series")
+        df = DataFrame(
+            {"col": np.arange(6)},
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+
+        expected_r = Series([1, 2] * 3, index=df.index, name="foo_series")
+        result_l, result_r = df.align(series, axis=0)
+
+        tm.assert_frame_equal(result_l, df)
+        tm.assert_series_equal(result_r, expected_r)
+
+    def test_multiindex_align_to_series_with_common_index_level_missing_in_left(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 2], name="bar")
+
+        series = Series(
+            [1, 2, 3, 4], index=Index([1, 2, 3, 4], name="bar"), name="foo_series"
+        )
+        df = DataFrame(
+            {"col": np.arange(6)},
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+
+        expected_r = Series([1, 2] * 3, index=df.index, name="foo_series")
+        result_l, result_r = df.align(series, axis=0)
+
+        tm.assert_frame_equal(result_l, df)
+        tm.assert_series_equal(result_r, expected_r)
+
+    def test_multiindex_align_to_series_with_common_index_level_missing_in_right(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 2, 3, 4], name="bar")
+
+        series = Series([1, 2], index=Index([1, 2], name="bar"), name="foo_series")
+        df = DataFrame(
+            {"col": np.arange(12)},
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+
+        expected_r = Series(
+            [1, 2, np.nan, np.nan] * 3, index=df.index, name="foo_series"
+        )
+        result_l, result_r = df.align(series, axis=0)
+
+        tm.assert_frame_equal(result_l, df)
+        tm.assert_series_equal(result_r, expected_r)
+
+    def test_multiindex_align_to_series_with_common_index_level_missing_in_both(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 3, 4], name="bar")
+
+        series = Series(
+            [1, 2, 3], index=Index([1, 2, 4], name="bar"), name="foo_series"
+        )
+        df = DataFrame(
+            {"col": np.arange(9)},
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+
+        expected_r = Series([1, np.nan, 3] * 3, index=df.index, name="foo_series")
+        result_l, result_r = df.align(series, axis=0)
+
+        tm.assert_frame_equal(result_l, df)
+        tm.assert_series_equal(result_r, expected_r)
+
+    def test_multiindex_align_to_series_with_common_index_level_non_unique_cols(self):
+        #  GH-46001
+        foo_index = Index([1, 2, 3], name="foo")
+        bar_index = Index([1, 2], name="bar")
+
+        series = Series([1, 2], index=bar_index, name="foo_series")
+        df = DataFrame(
+            np.arange(18).reshape(6, 3),
+            index=pd.MultiIndex.from_product([foo_index, bar_index]),
+        )
+        df.columns = ["cfoo", "cbar", "cfoo"]
+
+        expected = Series([1, 2] * 3, index=df.index, name="foo_series")
+        result_left, result_right = df.align(series, axis=0)
+
+        tm.assert_series_equal(result_right, expected)
+        tm.assert_index_equal(result_left.columns, df.columns)
+
+    def test_missing_axis_specification_exception(self):
+        df = DataFrame(np.arange(50).reshape((10, 5)))
+        series = Series(np.arange(5))
+
+        with pytest.raises(ValueError, match=r"axis=0 or 1"):
+            df.align(series)
+
+    @pytest.mark.parametrize("method", ["pad", "bfill"])
+    @pytest.mark.parametrize("axis", [0, 1, None])
+    @pytest.mark.parametrize("fill_axis", [0, 1])
+    @pytest.mark.parametrize("how", ["inner", "outer", "left", "right"])
+    @pytest.mark.parametrize(
+        "left_slice",
+        [
+            [slice(4), slice(10)],
+            [slice(0), slice(0)],
+        ],
+    )
+    @pytest.mark.parametrize(
+        "right_slice",
+        [
+            [slice(2, None), slice(6, None)],
+            [slice(0), slice(0)],
+        ],
+    )
+    @pytest.mark.parametrize("limit", [1, None])
+    def test_align_fill_method(
+        self, how, method, axis, fill_axis, float_frame, left_slice, right_slice, limit
+    ):
+        frame = float_frame
+        left = frame.iloc[left_slice[0], left_slice[1]]
+        right = frame.iloc[right_slice[0], right_slice[1]]
+
+        msg = (
+            "The 'method', 'limit', and 'fill_axis' keywords in DataFrame.align "
+            "are deprecated"
+        )
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            aa, ab = left.align(
+                right,
+                axis=axis,
+                join=how,
+                method=method,
+                limit=limit,
+                fill_axis=fill_axis,
+            )
+
+        join_index, join_columns = None, None
+
+        ea, eb = left, right
+        if axis is None or axis == 0:
+            join_index = left.index.join(right.index, how=how)
+            ea = ea.reindex(index=join_index)
+            eb = eb.reindex(index=join_index)
+
+        if axis is None or axis == 1:
+            join_columns = left.columns.join(right.columns, how=how)
+            ea = ea.reindex(columns=join_columns)
+            eb = eb.reindex(columns=join_columns)
+
+        msg = "DataFrame.fillna with 'method' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            ea = ea.fillna(axis=fill_axis, method=method, limit=limit)
+            eb = eb.fillna(axis=fill_axis, method=method, limit=limit)
+
+        tm.assert_frame_equal(aa, ea)
+        tm.assert_frame_equal(ab, eb)
+
+    def test_align_series_check_copy(self):
+        # GH#
+        df = DataFrame({0: [1, 2]})
+        ser = Series([1], name=0)
+        expected = ser.copy()
+        result, other = df.align(ser, axis=1)
+        ser.iloc[0] = 100
+        tm.assert_series_equal(other, expected)
+
+    def test_align_identical_different_object(self):
+        # GH#51032
+        df = DataFrame({"a": [1, 2]})
+        ser = Series([3, 4])
+        result, result2 = df.align(ser, axis=0)
+        tm.assert_frame_equal(result, df)
+        tm.assert_series_equal(result2, ser)
+        assert df is not result
+        assert ser is not result2
+
+    def test_align_identical_different_object_columns(self):
+        # GH#51032
+        df = DataFrame({"a": [1, 2]})
+        ser = Series([1], index=["a"])
+        result, result2 = df.align(ser, axis=1)
+        tm.assert_frame_equal(result, df)
+        tm.assert_series_equal(result2, ser)
+        assert df is not result
+        assert ser is not result2

shared/package-files/17/1707a57215415ca7f79dcefc52003d4b225b1ed6b710c76b2e7422cc8c52e521/thingsdb.py

@@ -0,0 +1,116 @@
+"""
+    pygments.lexers.thingsdb
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the ThingsDB language.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include, bygroups
+from pygments.token import Comment, Keyword, Name, Number, String, Text, \
+    Operator, Punctuation, Whitespace
+
+__all__ = ['ThingsDBLexer']
+
+
+class ThingsDBLexer(RegexLexer):
+    """
+    Lexer for the ThingsDB programming language.
+
+    .. versionadded:: 2.9
+    """
+    name = 'ThingsDB'
+    aliases = ['ti', 'thingsdb']
+    filenames = ['*.ti']
+
+    tokens = {
+        'root': [
+            include('expression'),
+        ],
+        'expression': [
+            include('comments'),
+            include('whitespace'),
+
+            # numbers
+            (r'[-+]?0b[01]+', Number.Bin),
+            (r'[-+]?0o[0-8]+', Number.Oct),
+            (r'([-+]?0x[0-9a-fA-F]+)', Number.Hex),
+            (r'[-+]?[0-9]+', Number.Integer),
+            (r'[-+]?((inf|nan)([^0-9A-Za-z_]|$)|[0-9]*\.[0-9]+(e[+-][0-9]+)?)',
+            Number.Float),
+
+            # strings
+            (r'(?:"(?:[^"]*)")+', String.Double),
+            (r"(?:'(?:[^']*)')+", String.Single),
+
+            # literals
+            (r'(true|false|nil)\b', Keyword.Constant),
+
+            # regular expressions
+            (r'(/[^/\\]*(?:\\.[^/\\]*)*/i?)', String.Regex),
+
+            # thing id's
+            (r'#[0-9]+', Comment.Preproc),
+
+            # name, assignments and functions
+            include('names'),
+
+            (r'[(){}\[\],;]', Punctuation),
+            (r'[+\-*/%&|<>^!~@=:?]', Operator),
+        ],
+        'names': [
+            (r'(\.)'
+             r'(add|call|contains|del|endswith|extend|filter|find|findindex|'
+             r'get|has|id|indexof|keys|len|lower|map|pop|push|remove|set|sort|'
+             r'splice|startswith|test|unwrap|upper|values|wrap)'
+             r'(\()',
+             bygroups(Name.Function, Name.Function, Punctuation), 'arguments'),
+            (r'(array|assert|assert_err|auth_err|backup_info|backups_info|'
+             r'bad_data_err|bool|closure|collection_info|collections_info|'
+             r'counters|deep|del_backup|del_collection|del_expired|del_node|'
+             r'del_procedure|del_token|del_type|del_user|err|float|'
+             r'forbidden_err|grant|int|isarray|isascii|isbool|isbytes|iserr|'
+             r'isfloat|isinf|isint|islist|isnan|isnil|israw|isset|isstr|'
+             r'isthing|istuple|isutf8|lookup_err|max_quota_err|mod_type|new|'
+             r'new_backup|new_collection|new_node|new_procedure|new_token|'
+             r'new_type|new_user|node_err|node_info|nodes_info|now|'
+             r'num_arguments_err|operation_err|overflow_err|procedure_doc|'
+             r'procedure_info|procedures_info|raise|refs|rename_collection|'
+             r'rename_user|reset_counters|return|revoke|run|set_log_level|set|'
+             r'set_quota|set_type|shutdown|str|syntax_err|thing|try|type|'
+             r'type_err|type_count|type_info|types_info|user_info|users_info|'
+             r'value_err|wse|zero_div_err)'
+             r'(\()',
+             bygroups(Name.Function, Punctuation),
+             'arguments'),
+            (r'(\.[A-Za-z_][0-9A-Za-z_]*)'
+             r'(\s*)(=)',
+             bygroups(Name.Attribute, Text, Operator)),
+            (r'\.[A-Za-z_][0-9A-Za-z_]*', Name.Attribute),
+            (r'([A-Za-z_][0-9A-Za-z_]*)(\s*)(=)',
+            bygroups(Name.Variable, Text, Operator)),
+            (r'[A-Za-z_][0-9A-Za-z_]*', Name.Variable),
+        ],
+        'whitespace': [
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+        ],
+        'comments': [
+            (r'//(.*?)\n', Comment.Single),
+            (r'/\*', Comment.Multiline, 'comment'),
+        ],
+        'comment': [
+            (r'[^*/]+', Comment.Multiline),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[*/]', Comment.Multiline),
+        ],
+        'arguments': [
+            include('expression'),
+            (',', Punctuation),
+            (r'\(', Punctuation, '#push'),
+            (r'\)', Punctuation, '#pop'),
+        ],
+    }

shared/package-files/17/170a22363b185e20ae6054f7dc54d41455bffa88d2ef1819c020bf1ec1d3f5d1/_colorconv.py

@@ -0,0 +1,222 @@
+### ------------ vendored from skimage.color.colorconv -------------
+# This is a small chunk of code from the skimage package. It is reproduced
+# here because all we need is a couple color conversion routines (lab2rgb, lch2lab)
+# and adding all of skimage as dependency is really heavy.
+
+
+# Copyright: 2009-2022 the scikit-image team
+# All rights reserved.
+
+# License: BSD-3-Clause
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+# 3. Neither the name of the University nor the names of its contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+# .
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE HOLDERS OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from warnings import warn
+
+import numpy as np
+from scipy import linalg
+
+
+def _prepare_colorarray(arr, *, channel_axis=-1):
+    """Check the shape of the array and convert it to
+    floating point representation.
+    """
+    arr = np.asanyarray(arr)
+
+    if arr.shape[channel_axis] != 3:
+        msg = f"the input array must have size 3 along `channel_axis`, got {arr.shape}"
+        raise ValueError(msg)
+
+    return arr.astype(np.float64)
+
+
+xyz_from_rgb = np.array(
+    [
+        [0.412453, 0.357580, 0.180423],
+        [0.212671, 0.715160, 0.072169],
+        [0.019334, 0.119193, 0.950227],
+    ]
+)
+
+rgb_from_xyz = linalg.inv(xyz_from_rgb)
+
+
+def _convert(matrix, arr):
+    """Do the color space conversion.
+
+    Parameters
+    ----------
+    matrix : array_like
+        The 3x3 matrix to use.
+    arr : (..., C=3, ...) array_like
+        The input array. By default, the final dimension denotes
+        channels.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The converted array. Same dimensions as input.
+    """
+    arr = _prepare_colorarray(arr)
+
+    return arr @ matrix.T.astype(arr.dtype)
+
+
+def xyz2rgb(xyz):
+    """XYZ to RGB color space conversion.
+
+    Parameters
+    ----------
+    xyz : (..., C=3, ...) array_like
+        The image in XYZ format. By default, the final dimension denotes
+        channels.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in RGB format. Same dimensions as input.
+
+    """
+    # Follow the algorithm from http://www.easyrgb.com/index.php
+    # except we don't multiply/divide by 100 in the conversion
+    arr = _convert(rgb_from_xyz, xyz)
+    mask = arr > 0.0031308
+    arr[mask] = 1.055 * np.power(arr[mask], 1 / 2.4) - 0.055
+    arr[~mask] *= 12.92
+    np.clip(arr, 0, 1, out=arr)
+    return arr
+
+
+def _lab2xyz(lab):
+    """Convert CIE-LAB to XYZ color space.
+
+    Internal function for :func:`~.lab2xyz` and others. In addition to the
+    converted image, return the number of invalid pixels in the Z channel for
+    correct warning propagation.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in XYZ format. Same dimensions as input.
+    n_invalid : int
+        Number of invalid pixels in the Z channel after conversion.
+    """
+    arr = _prepare_colorarray(lab, channel_axis=-1).copy()
+
+    L, a, b = arr[..., 0], arr[..., 1], arr[..., 2]
+    y = (L + 16.0) / 116.0
+    x = (a / 500.0) + y
+    z = y - (b / 200.0)
+
+    invalid = np.atleast_1d(z < 0).nonzero()
+    n_invalid = invalid[0].size
+    if n_invalid != 0:
+        # Warning should be emitted by caller
+        if z.ndim > 0:
+            z[invalid] = 0
+        else:
+            z = 0
+
+    out = np.stack([x, y, z], axis=-1)
+
+    mask = out > 0.2068966
+    out[mask] = np.power(out[mask], 3.0)
+    out[~mask] = (out[~mask] - 16.0 / 116.0) / 7.787
+
+    # rescale to the reference white (illuminant)
+    xyz_ref_white = np.array([0.95047, 1.0, 1.08883])
+    out *= xyz_ref_white
+    return out, n_invalid
+
+
+def lab2rgb(lab):
+    """Convert image in CIE-LAB to sRGB color space.
+
+    Parameters
+    ----------
+    lab : (..., C=3, ...) array_like
+        The input image in CIE-LAB color space.
+        Unless `channel_axis` is set, the final dimension denotes the CIE-LAB
+        channels.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in sRGB color space, of same shape as input.
+
+    Raises
+    ------
+    ValueError
+        If `lab` is not at least 2-D with shape (..., C=3, ...).
+    """
+    xyz, n_invalid = _lab2xyz(lab)
+    if n_invalid != 0:
+        warn(
+            "Conversion from CIE-LAB, via XYZ to sRGB color space resulted in "
+            f"{n_invalid} negative Z values that have been clipped to zero",
+            stacklevel=3,
+        )
+    return xyz2rgb(xyz)
+
+
+def lch2lab(lch):
+    """Convert image in CIE-LCh to CIE-LAB color space.
+
+    CIE-LCh is the cylindrical representation of the CIE-LAB (Cartesian) color
+    space.
+
+    Parameters
+    ----------
+    lch : (..., C=3, ...) array_like
+        The input image in CIE-LCh color space.
+        Unless `channel_axis` is set, the final dimension denotes the CIE-LAB
+        channels.
+        The L* values range from 0 to 100;
+        the C values range from 0 to 100;
+        the h values range from 0 to ``2*pi``.
+
+    Returns
+    -------
+    out : (..., C=3, ...) ndarray
+        The image in CIE-LAB format, of same shape as input.
+    """
+    lch = _prepare_lab_array(lch)
+
+    c, h = lch[..., 1], lch[..., 2]
+    lch[..., 1], lch[..., 2] = c * np.cos(h), c * np.sin(h)
+    return lch
+
+
+def _prepare_lab_array(arr):
+    """Ensure input for lab2lch and lch2lab is well-formed.
+
+    Input array must be in floating point and have at least 3 elements in the
+    last dimension. Returns a new array by default.
+    """
+    arr = np.asarray(arr, dtype=np.float64)
+    shape = arr.shape
+    if shape[-1] < 3:
+        raise ValueError("Input image has less than 3 channels.")
+    return arr

shared/package-files/17/172d4e30d85b5513614db7549a2ca7dce0b6eb304067f8d3b2133d92b8d3993a/compare.py

@@ -0,0 +1,320 @@
+"""Display class to aggregate and print the results of many measurements."""
+import collections
+import enum
+import itertools as it
+from typing import DefaultDict, List, Optional, Tuple
+
+from torch.utils.benchmark.utils import common
+from torch import tensor as _tensor
+
+__all__ = ["Colorize", "Compare"]
+
+BEST = "\033[92m"
+GOOD = "\033[34m"
+BAD = "\033[2m\033[91m"
+VERY_BAD = "\033[31m"
+BOLD = "\033[1m"
+TERMINATE = "\033[0m"
+
+
+class Colorize(enum.Enum):
+    NONE = "none"
+    COLUMNWISE = "columnwise"
+    ROWWISE = "rowwise"
+
+
+# Classes to separate internal bookkeeping from what is rendered.
+class _Column:
+    def __init__(
+        self,
+        grouped_results: List[Tuple[Optional[common.Measurement], ...]],
+        time_scale: float,
+        time_unit: str,
+        trim_significant_figures: bool,
+        highlight_warnings: bool,
+    ):
+        self._grouped_results = grouped_results
+        self._flat_results = list(it.chain(*grouped_results))
+        self._time_scale = time_scale
+        self._time_unit = time_unit
+        self._trim_significant_figures = trim_significant_figures
+        self._highlight_warnings = (
+            highlight_warnings
+            and any(r.has_warnings for r in self._flat_results if r)
+        )
+        leading_digits = [
+            int(_tensor(r.median / self._time_scale).log10().ceil()) if r else None
+            for r in self._flat_results
+        ]
+        unit_digits = max(d for d in leading_digits if d is not None)
+        decimal_digits = min(
+            max(m.significant_figures - digits, 0)
+            for digits, m in zip(leading_digits, self._flat_results)
+            if (m is not None) and (digits is not None)
+        ) if self._trim_significant_figures else 1
+        length = unit_digits + decimal_digits + (1 if decimal_digits else 0)
+        self._template = f"{{:>{length}.{decimal_digits}f}}{{:>{7 if self._highlight_warnings else 0}}}"
+
+    def get_results_for(self, group):
+        return self._grouped_results[group]
+
+    def num_to_str(self, value: Optional[float], estimated_sigfigs: int, spread: Optional[float]):
+        if value is None:
+            return " " * len(self.num_to_str(1, estimated_sigfigs, None))
+
+        if self._trim_significant_figures:
+            value = common.trim_sigfig(value, estimated_sigfigs)
+
+        return self._template.format(
+            value,
+            f" (! {spread * 100:.0f}%)" if self._highlight_warnings and spread is not None else "")
+
+
+def optional_min(seq):
+    l = list(seq)
+    return None if len(l) == 0 else min(l)
+
+
+class _Row:
+    def __init__(self, results, row_group, render_env, env_str_len,
+                 row_name_str_len, time_scale, colorize, num_threads=None):
+        super().__init__()
+        self._results = results
+        self._row_group = row_group
+        self._render_env = render_env
+        self._env_str_len = env_str_len
+        self._row_name_str_len = row_name_str_len
+        self._time_scale = time_scale
+        self._colorize = colorize
+        self._columns: Tuple[_Column, ...] = ()
+        self._num_threads = num_threads
+
+    def register_columns(self, columns: Tuple[_Column, ...]):
+        self._columns = columns
+
+    def as_column_strings(self):
+        concrete_results = [r for r in self._results if r is not None]
+        env = f"({concrete_results[0].env})" if self._render_env else ""
+        env = env.ljust(self._env_str_len + 4)
+        output = ["  " + env + concrete_results[0].as_row_name]
+        for m, col in zip(self._results, self._columns or ()):
+            if m is None:
+                output.append(col.num_to_str(None, 1, None))
+            else:
+                output.append(col.num_to_str(
+                    m.median / self._time_scale,
+                    m.significant_figures,
+                    m.iqr / m.median if m.has_warnings else None
+                ))
+        return output
+
+    @staticmethod
+    def color_segment(segment, value, best_value):
+        if value <= best_value * 1.01 or value <= best_value + 100e-9:
+            return BEST + BOLD + segment + TERMINATE * 2
+        if value <= best_value * 1.1:
+            return GOOD + BOLD + segment + TERMINATE * 2
+        if value >= best_value * 5:
+            return VERY_BAD + BOLD + segment + TERMINATE * 2
+        if value >= best_value * 2:
+            return BAD + segment + TERMINATE * 2
+
+        return segment
+
+    def row_separator(self, overall_width):
+        return (
+            [f"{self._num_threads} threads: ".ljust(overall_width, "-")]
+            if self._num_threads is not None else []
+        )
+
+    def finalize_column_strings(self, column_strings, col_widths):
+        best_values = [-1 for _ in column_strings]
+        if self._colorize == Colorize.ROWWISE:
+            row_min = min(r.median for r in self._results if r is not None)
+            best_values = [row_min for _ in column_strings]
+        elif self._colorize == Colorize.COLUMNWISE:
+            best_values = [
+                optional_min(r.median for r in column.get_results_for(self._row_group) if r is not None)
+                for column in (self._columns or ())
+            ]
+
+        row_contents = [column_strings[0].ljust(col_widths[0])]
+        for col_str, width, result, best_value in zip(column_strings[1:], col_widths[1:], self._results, best_values):
+            col_str = col_str.center(width)
+            if self._colorize != Colorize.NONE and result is not None and best_value is not None:
+                col_str = self.color_segment(col_str, result.median, best_value)
+            row_contents.append(col_str)
+        return row_contents
+
+
+class Table:
+    def __init__(
+            self,
+            results: List[common.Measurement],
+            colorize: Colorize,
+            trim_significant_figures: bool,
+            highlight_warnings: bool
+    ):
+        assert len({r.label for r in results}) == 1
+
+        self.results = results
+        self._colorize = colorize
+        self._trim_significant_figures = trim_significant_figures
+        self._highlight_warnings = highlight_warnings
+        self.label = results[0].label
+        self.time_unit, self.time_scale = common.select_unit(
+            min(r.median for r in results)
+        )
+
+        self.row_keys = common.ordered_unique([self.row_fn(i) for i in results])
+        self.row_keys.sort(key=lambda args: args[:2])  # preserve stmt order
+        self.column_keys = common.ordered_unique([self.col_fn(i) for i in results])
+        self.rows, self.columns = self.populate_rows_and_columns()
+
+    @staticmethod
+    def row_fn(m: common.Measurement) -> Tuple[int, Optional[str], str]:
+        return m.num_threads, m.env, m.as_row_name
+
+    @staticmethod
+    def col_fn(m: common.Measurement) -> Optional[str]:
+        return m.description
+
+    def populate_rows_and_columns(self) -> Tuple[Tuple[_Row, ...], Tuple[_Column, ...]]:
+        rows: List[_Row] = []
+        columns: List[_Column] = []
+        ordered_results: List[List[Optional[common.Measurement]]] = [
+            [None for _ in self.column_keys]
+            for _ in self.row_keys
+        ]
+        row_position = {key: i for i, key in enumerate(self.row_keys)}
+        col_position = {key: i for i, key in enumerate(self.column_keys)}
+        for r in self.results:
+            i = row_position[self.row_fn(r)]
+            j = col_position[self.col_fn(r)]
+            ordered_results[i][j] = r
+
+        unique_envs = {r.env for r in self.results}
+        render_env = len(unique_envs) > 1
+        env_str_len = max(len(i) for i in unique_envs) if render_env else 0
+
+        row_name_str_len = max(len(r.as_row_name) for r in self.results)
+
+        prior_num_threads = -1
+        prior_env = ""
+        row_group = -1
+        rows_by_group: List[List[List[Optional[common.Measurement]]]] = []
+        for (num_threads, env, _), row in zip(self.row_keys, ordered_results):
+            thread_transition = (num_threads != prior_num_threads)
+            if thread_transition:
+                prior_num_threads = num_threads
+                prior_env = ""
+                row_group += 1
+                rows_by_group.append([])
+            rows.append(
+                _Row(
+                    results=row,
+                    row_group=row_group,
+                    render_env=(render_env and env != prior_env),
+                    env_str_len=env_str_len,
+                    row_name_str_len=row_name_str_len,
+                    time_scale=self.time_scale,
+                    colorize=self._colorize,
+                    num_threads=num_threads if thread_transition else None,
+                )
+            )
+            rows_by_group[-1].append(row)
+            prior_env = env
+
+        for i in range(len(self.column_keys)):
+            grouped_results = [tuple(row[i] for row in g) for g in rows_by_group]
+            column = _Column(
+                grouped_results=grouped_results,
+                time_scale=self.time_scale,
+                time_unit=self.time_unit,
+                trim_significant_figures=self._trim_significant_figures,
+                highlight_warnings=self._highlight_warnings,)
+            columns.append(column)
+
+        rows_tuple, columns_tuple = tuple(rows), tuple(columns)
+        for ri in rows_tuple:
+            ri.register_columns(columns_tuple)
+        return rows_tuple, columns_tuple
+
+    def render(self) -> str:
+        string_rows = [[""] + self.column_keys]
+        for r in self.rows:
+            string_rows.append(r.as_column_strings())
+        num_cols = max(len(i) for i in string_rows)
+        for sr in string_rows:
+            sr.extend(["" for _ in range(num_cols - len(sr))])
+
+        col_widths = [max(len(j) for j in i) for i in zip(*string_rows)]
+        finalized_columns = ["  |  ".join(i.center(w) for i, w in zip(string_rows[0], col_widths))]
+        overall_width = len(finalized_columns[0])
+        for string_row, row in zip(string_rows[1:], self.rows):
+            finalized_columns.extend(row.row_separator(overall_width))
+            finalized_columns.append("  |  ".join(row.finalize_column_strings(string_row, col_widths)))
+
+        newline = "\n"
+        has_warnings = self._highlight_warnings and any(ri.has_warnings for ri in self.results)
+        return f"""
+[{(' ' + (self.label or '') + ' ').center(overall_width - 2, '-')}]
+{newline.join(finalized_columns)}
+
+Times are in {common.unit_to_english(self.time_unit)}s ({self.time_unit}).
+{'(! XX%) Measurement has high variance, where XX is the IQR / median * 100.' + newline if has_warnings else ""}"""[1:]
+
+
+class Compare:
+    def __init__(self, results: List[common.Measurement]):
+        self._results: List[common.Measurement] = []
+        self.extend_results(results)
+        self._trim_significant_figures = False
+        self._colorize = Colorize.NONE
+        self._highlight_warnings = False
+
+    def __str__(self):
+        return "\n".join(self._render())
+
+    def extend_results(self, results):
+        for r in results:
+            if not isinstance(r, common.Measurement):
+                raise ValueError(
+                    "Expected an instance of `Measurement`, " f"got {type(r)} instead."
+                )
+        self._results.extend(results)
+
+    def trim_significant_figures(self):
+        self._trim_significant_figures = True
+
+    def colorize(self, rowwise=False):
+        self._colorize = Colorize.ROWWISE if rowwise else Colorize.COLUMNWISE
+
+    def highlight_warnings(self):
+        self._highlight_warnings = True
+
+    def print(self):
+        print(str(self))
+
+    def _render(self):
+        results = common.Measurement.merge(self._results)
+        grouped_results = self._group_by_label(results)
+        output = []
+        for group in grouped_results.values():
+            output.append(self._layout(group))
+        return output
+
+    def _group_by_label(self, results: List[common.Measurement]):
+        grouped_results: DefaultDict[str, List[common.Measurement]] = collections.defaultdict(list)
+        for r in results:
+            grouped_results[r.label].append(r)
+        return grouped_results
+
+    def _layout(self, results: List[common.Measurement]):
+        table = Table(
+            results,
+            self._colorize,
+            self._trim_significant_figures,
+            self._highlight_warnings
+        )
+        return table.render()

shared/package-files/17/173208235bca43da20ef09451c72d42de5fd82f3b183884873a93c7a74da1094/slow_conv3d.h

@@ -0,0 +1,91 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/slow_conv3d_ops.h>
+
+namespace at {
+
+
+// aten::slow_conv3d.out(Tensor self, Tensor weight, SymInt[3] kernel_size, Tensor? bias=None, SymInt[3] stride=1, SymInt[3] padding=0, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & slow_conv3d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0) {
+    return at::_ops::slow_conv3d_out::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor & slow_conv3d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0) {
+    return at::_ops::slow_conv3d_out::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), out);
+  }
+}
+
+// aten::slow_conv3d.out(Tensor self, Tensor weight, SymInt[3] kernel_size, Tensor? bias=None, SymInt[3] stride=1, SymInt[3] padding=0, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & slow_conv3d_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::Tensor & out) {
+    return at::_ops::slow_conv3d_out::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor & slow_conv3d_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::Tensor & out) {
+    return at::_ops::slow_conv3d_out::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), out);
+  }
+}
+
+// aten::slow_conv3d.out(Tensor self, Tensor weight, SymInt[3] kernel_size, Tensor? bias=None, SymInt[3] stride=1, SymInt[3] padding=0, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & slow_conv3d_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0)) {
+    return at::_ops::slow_conv3d_out::call(self, weight, kernel_size, bias, stride, padding, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor & slow_conv3d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0)) {
+    return at::_ops::slow_conv3d_out::call(self, weight, kernel_size, bias, stride, padding, out);
+  }
+}
+
+// aten::slow_conv3d.out(Tensor self, Tensor weight, SymInt[3] kernel_size, Tensor? bias=None, SymInt[3] stride=1, SymInt[3] padding=0, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & slow_conv3d_symint_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, at::Tensor & out) {
+    return at::_ops::slow_conv3d_out::call(self, weight, kernel_size, bias, stride, padding, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor & slow_conv3d_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, at::Tensor & out) {
+    return at::_ops::slow_conv3d_out::call(self, weight, kernel_size, bias, stride, padding, out);
+  }
+}
+
+// aten::slow_conv3d(Tensor self, Tensor weight, SymInt[3] kernel_size, Tensor? bias=None, SymInt[3] stride=1, SymInt[3] padding=0) -> Tensor
+inline at::Tensor slow_conv3d(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0) {
+    return at::_ops::slow_conv3d::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding));
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor slow_conv3d(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0) {
+    return at::_ops::slow_conv3d::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding));
+  }
+}
+
+// aten::slow_conv3d(Tensor self, Tensor weight, SymInt[3] kernel_size, Tensor? bias=None, SymInt[3] stride=1, SymInt[3] padding=0) -> Tensor
+inline at::Tensor slow_conv3d_symint(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0)) {
+    return at::_ops::slow_conv3d::call(self, weight, kernel_size, bias, stride, padding);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor slow_conv3d(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional<at::Tensor> & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0)) {
+    return at::_ops::slow_conv3d::call(self, weight, kernel_size, bias, stride, padding);
+  }
+}
+
+}

shared/package-files/17/1735c710532f1b6f39dbdcd58183eabc85159a0bb86fa22d2479b22c339c8ec5/loader.pyi

@@ -0,0 +1,31 @@
+from typing import Any, Dict, Optional, Sequence, Set, Tuple, Union
+
+from django.db.migrations.migration import Migration
+from django.db.migrations.state import ProjectState
+
+MIGRATIONS_MODULE_NAME: str
+
+class MigrationLoader:
+    connection: Any = ...
+    disk_migrations: Dict[Tuple[str, str], Migration] = ...
+    applied_migrations: Set[Tuple[str, str]] = ...
+    ignore_no_migrations: bool = ...
+    def __init__(self, connection: Any, load: bool = ..., ignore_no_migrations: bool = ...) -> None: ...
+    @classmethod
+    def migrations_module(cls, app_label: str) -> Tuple[Optional[str], bool]: ...
+    unmigrated_apps: Set[str] = ...
+    migrated_apps: Set[str] = ...
+    def load_disk(self) -> None: ...
+    def get_migration(self, app_label: str, name_prefix: str) -> Migration: ...
+    def get_migration_by_prefix(self, app_label: str, name_prefix: str) -> Migration: ...
+    def check_key(self, key: Tuple[str, str], current_app: str) -> Optional[Tuple[str, str]]: ...
+    def add_internal_dependencies(self, key: Tuple[str, str], migration: Migration) -> None: ...
+    def add_external_dependencies(self, key: Tuple[str, str], migration: Migration) -> None: ...
+    graph: Any = ...
+    replacements: Any = ...
+    def build_graph(self) -> None: ...
+    def check_consistent_history(self, connection: Any) -> None: ...
+    def detect_conflicts(self) -> Dict[str, Set[str]]: ...
+    def project_state(
+        self, nodes: Optional[Union[Tuple[str, str], Sequence[Tuple[str, str]]]] = ..., at_end: bool = ...
+    ) -> ProjectState: ...

shared/package-files/17/173f35914e71d60e8e9cd991adae8f45aacfa6ae47118b80f175f4b11ff2e8b2/test_base_indexer.py

@@ -0,0 +1,519 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+    concat,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.api.indexers import (
+    BaseIndexer,
+    FixedForwardWindowIndexer,
+)
+from pandas.core.indexers.objects import (
+    ExpandingIndexer,
+    FixedWindowIndexer,
+    VariableOffsetWindowIndexer,
+)
+
+from pandas.tseries.offsets import BusinessDay
+
+
+def test_bad_get_window_bounds_signature():
+    class BadIndexer(BaseIndexer):
+        def get_window_bounds(self):
+            return None
+
+    indexer = BadIndexer()
+    with pytest.raises(ValueError, match="BadIndexer does not implement"):
+        Series(range(5)).rolling(indexer)
+
+
+def test_expanding_indexer():
+    s = Series(range(10))
+    indexer = ExpandingIndexer()
+    result = s.rolling(indexer).mean()
+    expected = s.expanding().mean()
+    tm.assert_series_equal(result, expected)
+
+
+def test_indexer_constructor_arg():
+    # Example found in computation.rst
+    use_expanding = [True, False, True, False, True]
+    df = DataFrame({"values": range(5)})
+
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+            start = np.empty(num_values, dtype=np.int64)
+            end = np.empty(num_values, dtype=np.int64)
+            for i in range(num_values):
+                if self.use_expanding[i]:
+                    start[i] = 0
+                    end[i] = i + 1
+                else:
+                    start[i] = i
+                    end[i] = i + self.window_size
+            return start, end
+
+    indexer = CustomIndexer(window_size=1, use_expanding=use_expanding)
+    result = df.rolling(indexer).sum()
+    expected = DataFrame({"values": [0.0, 1.0, 3.0, 3.0, 10.0]})
+    tm.assert_frame_equal(result, expected)
+
+
+def test_indexer_accepts_rolling_args():
+    df = DataFrame({"values": range(5)})
+
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+            start = np.empty(num_values, dtype=np.int64)
+            end = np.empty(num_values, dtype=np.int64)
+            for i in range(num_values):
+                if (
+                    center
+                    and min_periods == 1
+                    and closed == "both"
+                    and step == 1
+                    and i == 2
+                ):
+                    start[i] = 0
+                    end[i] = num_values
+                else:
+                    start[i] = i
+                    end[i] = i + self.window_size
+            return start, end
+
+    indexer = CustomIndexer(window_size=1)
+    result = df.rolling(
+        indexer, center=True, min_periods=1, closed="both", step=1
+    ).sum()
+    expected = DataFrame({"values": [0.0, 1.0, 10.0, 3.0, 4.0]})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "func,np_func,expected,np_kwargs",
+    [
+        ("count", len, [3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 2.0, np.nan], {}),
+        ("min", np.min, [0.0, 1.0, 2.0, 3.0, 4.0, 6.0, 6.0, 7.0, 8.0, np.nan], {}),
+        (
+            "max",
+            np.max,
+            [2.0, 3.0, 4.0, 100.0, 100.0, 100.0, 8.0, 9.0, 9.0, np.nan],
+            {},
+        ),
+        (
+            "std",
+            np.std,
+            [
+                1.0,
+                1.0,
+                1.0,
+                55.71654452,
+                54.85739087,
+                53.9845657,
+                1.0,
+                1.0,
+                0.70710678,
+                np.nan,
+            ],
+            {"ddof": 1},
+        ),
+        (
+            "var",
+            np.var,
+            [
+                1.0,
+                1.0,
+                1.0,
+                3104.333333,
+                3009.333333,
+                2914.333333,
+                1.0,
+                1.0,
+                0.500000,
+                np.nan,
+            ],
+            {"ddof": 1},
+        ),
+        (
+            "median",
+            np.median,
+            [1.0, 2.0, 3.0, 4.0, 6.0, 7.0, 7.0, 8.0, 8.5, np.nan],
+            {},
+        ),
+    ],
+)
+def test_rolling_forward_window(
+    frame_or_series, func, np_func, expected, np_kwargs, step
+):
+    # GH 32865
+    values = np.arange(10.0)
+    values[5] = 100.0
+
+    indexer = FixedForwardWindowIndexer(window_size=3)
+
+    match = "Forward-looking windows can't have center=True"
+    with pytest.raises(ValueError, match=match):
+        rolling = frame_or_series(values).rolling(window=indexer, center=True)
+        getattr(rolling, func)()
+
+    match = "Forward-looking windows don't support setting the closed argument"
+    with pytest.raises(ValueError, match=match):
+        rolling = frame_or_series(values).rolling(window=indexer, closed="right")
+        getattr(rolling, func)()
+
+    rolling = frame_or_series(values).rolling(window=indexer, min_periods=2, step=step)
+    result = getattr(rolling, func)()
+
+    # Check that the function output matches the explicitly provided array
+    expected = frame_or_series(expected)[::step]
+    tm.assert_equal(result, expected)
+
+    # Check that the rolling function output matches applying an alternative
+    # function to the rolling window object
+    expected2 = frame_or_series(rolling.apply(lambda x: np_func(x, **np_kwargs)))
+    tm.assert_equal(result, expected2)
+
+    # Check that the function output matches applying an alternative function
+    # if min_periods isn't specified
+    # GH 39604: After count-min_periods deprecation, apply(lambda x: len(x))
+    # is equivalent to count after setting min_periods=0
+    min_periods = 0 if func == "count" else None
+    rolling3 = frame_or_series(values).rolling(window=indexer, min_periods=min_periods)
+    result3 = getattr(rolling3, func)()
+    expected3 = frame_or_series(rolling3.apply(lambda x: np_func(x, **np_kwargs)))
+    tm.assert_equal(result3, expected3)
+
+
+def test_rolling_forward_skewness(frame_or_series, step):
+    values = np.arange(10.0)
+    values[5] = 100.0
+
+    indexer = FixedForwardWindowIndexer(window_size=5)
+    rolling = frame_or_series(values).rolling(window=indexer, min_periods=3, step=step)
+    result = rolling.skew()
+
+    expected = frame_or_series(
+        [
+            0.0,
+            2.232396,
+            2.229508,
+            2.228340,
+            2.229091,
+            2.231989,
+            0.0,
+            0.0,
+            np.nan,
+            np.nan,
+        ]
+    )[::step]
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "func,expected",
+    [
+        ("cov", [2.0, 2.0, 2.0, 97.0, 2.0, -93.0, 2.0, 2.0, np.nan, np.nan]),
+        (
+            "corr",
+            [
+                1.0,
+                1.0,
+                1.0,
+                0.8704775290207161,
+                0.018229084250926637,
+                -0.861357304646493,
+                1.0,
+                1.0,
+                np.nan,
+                np.nan,
+            ],
+        ),
+    ],
+)
+def test_rolling_forward_cov_corr(func, expected):
+    values1 = np.arange(10).reshape(-1, 1)
+    values2 = values1 * 2
+    values1[5, 0] = 100
+    values = np.concatenate([values1, values2], axis=1)
+
+    indexer = FixedForwardWindowIndexer(window_size=3)
+    rolling = DataFrame(values).rolling(window=indexer, min_periods=3)
+    # We are interested in checking only pairwise covariance / correlation
+    result = getattr(rolling, func)().loc[(slice(None), 1), 0]
+    result = result.reset_index(drop=True)
+    expected = Series(expected).reset_index(drop=True)
+    expected.name = result.name
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "closed,expected_data",
+    [
+        ["right", [0.0, 1.0, 2.0, 3.0, 7.0, 12.0, 6.0, 7.0, 8.0, 9.0]],
+        ["left", [0.0, 0.0, 1.0, 2.0, 5.0, 9.0, 5.0, 6.0, 7.0, 8.0]],
+    ],
+)
+def test_non_fixed_variable_window_indexer(closed, expected_data):
+    index = date_range("2020", periods=10)
+    df = DataFrame(range(10), index=index)
+    offset = BusinessDay(1)
+    indexer = VariableOffsetWindowIndexer(index=index, offset=offset)
+    result = df.rolling(indexer, closed=closed).sum()
+    expected = DataFrame(expected_data, index=index)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_variableoffsetwindowindexer_not_dti():
+    # GH 54379
+    with pytest.raises(ValueError, match="index must be a DatetimeIndex."):
+        VariableOffsetWindowIndexer(index="foo", offset=BusinessDay(1))
+
+
+def test_variableoffsetwindowindexer_not_offset():
+    # GH 54379
+    idx = date_range("2020", periods=10)
+    with pytest.raises(ValueError, match="offset must be a DateOffset-like object."):
+        VariableOffsetWindowIndexer(index=idx, offset="foo")
+
+
+def test_fixed_forward_indexer_count(step):
+    # GH: 35579
+    df = DataFrame({"b": [None, None, None, 7]})
+    indexer = FixedForwardWindowIndexer(window_size=2)
+    result = df.rolling(window=indexer, min_periods=0, step=step).count()
+    expected = DataFrame({"b": [0.0, 0.0, 1.0, 1.0]})[::step]
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    ("end_value", "values"), [(1, [0.0, 1, 1, 3, 2]), (-1, [0.0, 1, 0, 3, 1])]
+)
+@pytest.mark.parametrize(("func", "args"), [("median", []), ("quantile", [0.5])])
+def test_indexer_quantile_sum(end_value, values, func, args):
+    # GH 37153
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+            start = np.empty(num_values, dtype=np.int64)
+            end = np.empty(num_values, dtype=np.int64)
+            for i in range(num_values):
+                if self.use_expanding[i]:
+                    start[i] = 0
+                    end[i] = max(i + end_value, 1)
+                else:
+                    start[i] = i
+                    end[i] = i + self.window_size
+            return start, end
+
+    use_expanding = [True, False, True, False, True]
+    df = DataFrame({"values": range(5)})
+
+    indexer = CustomIndexer(window_size=1, use_expanding=use_expanding)
+    result = getattr(df.rolling(indexer), func)(*args)
+    expected = DataFrame({"values": values})
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "indexer_class", [FixedWindowIndexer, FixedForwardWindowIndexer, ExpandingIndexer]
+)
+@pytest.mark.parametrize("window_size", [1, 2, 12])
+@pytest.mark.parametrize(
+    "df_data",
+    [
+        {"a": [1, 1], "b": [0, 1]},
+        {"a": [1, 2], "b": [0, 1]},
+        {"a": [1] * 16, "b": [np.nan, 1, 2, np.nan] + list(range(4, 16))},
+    ],
+)
+def test_indexers_are_reusable_after_groupby_rolling(
+    indexer_class, window_size, df_data
+):
+    # GH 43267
+    df = DataFrame(df_data)
+    num_trials = 3
+    indexer = indexer_class(window_size=window_size)
+    original_window_size = indexer.window_size
+    for i in range(num_trials):
+        df.groupby("a")["b"].rolling(window=indexer, min_periods=1).mean()
+        assert indexer.window_size == original_window_size
+
+
+@pytest.mark.parametrize(
+    "window_size, num_values, expected_start, expected_end",
+    [
+        (1, 1, [0], [1]),
+        (1, 2, [0, 1], [1, 2]),
+        (2, 1, [0], [1]),
+        (2, 2, [0, 1], [2, 2]),
+        (5, 12, range(12), list(range(5, 12)) + [12] * 5),
+        (12, 5, range(5), [5] * 5),
+        (0, 0, np.array([]), np.array([])),
+        (1, 0, np.array([]), np.array([])),
+        (0, 1, [0], [0]),
+    ],
+)
+def test_fixed_forward_indexer_bounds(
+    window_size, num_values, expected_start, expected_end, step
+):
+    # GH 43267
+    indexer = FixedForwardWindowIndexer(window_size=window_size)
+    start, end = indexer.get_window_bounds(num_values=num_values, step=step)
+
+    tm.assert_numpy_array_equal(
+        start, np.array(expected_start[::step]), check_dtype=False
+    )
+    tm.assert_numpy_array_equal(end, np.array(expected_end[::step]), check_dtype=False)
+    assert len(start) == len(end)
+
+
+@pytest.mark.parametrize(
+    "df, window_size, expected",
+    [
+        (
+            DataFrame({"b": [0, 1, 2], "a": [1, 2, 2]}),
+            2,
+            Series(
+                [0, 1.5, 2.0],
+                index=MultiIndex.from_arrays([[1, 2, 2], range(3)], names=["a", None]),
+                name="b",
+                dtype=np.float64,
+            ),
+        ),
+        (
+            DataFrame(
+                {
+                    "b": [np.nan, 1, 2, np.nan] + list(range(4, 18)),
+                    "a": [1] * 7 + [2] * 11,
+                    "c": range(18),
+                }
+            ),
+            12,
+            Series(
+                [
+                    3.6,
+                    3.6,
+                    4.25,
+                    5.0,
+                    5.0,
+                    5.5,
+                    6.0,
+                    12.0,
+                    12.5,
+                    13.0,
+                    13.5,
+                    14.0,
+                    14.5,
+                    15.0,
+                    15.5,
+                    16.0,
+                    16.5,
+                    17.0,
+                ],
+                index=MultiIndex.from_arrays(
+                    [[1] * 7 + [2] * 11, range(18)], names=["a", None]
+                ),
+                name="b",
+                dtype=np.float64,
+            ),
+        ),
+    ],
+)
+def test_rolling_groupby_with_fixed_forward_specific(df, window_size, expected):
+    # GH 43267
+    indexer = FixedForwardWindowIndexer(window_size=window_size)
+    result = df.groupby("a")["b"].rolling(window=indexer, min_periods=1).mean()
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "group_keys",
+    [
+        (1,),
+        (1, 2),
+        (2, 1),
+        (1, 1, 2),
+        (1, 2, 1),
+        (1, 1, 2, 2),
+        (1, 2, 3, 2, 3),
+        (1, 1, 2) * 4,
+        (1, 2, 3) * 5,
+    ],
+)
+@pytest.mark.parametrize("window_size", [1, 2, 3, 4, 5, 8, 20])
+def test_rolling_groupby_with_fixed_forward_many(group_keys, window_size):
+    # GH 43267
+    df = DataFrame(
+        {
+            "a": np.array(list(group_keys)),
+            "b": np.arange(len(group_keys), dtype=np.float64) + 17,
+            "c": np.arange(len(group_keys), dtype=np.int64),
+        }
+    )
+
+    indexer = FixedForwardWindowIndexer(window_size=window_size)
+    result = df.groupby("a")["b"].rolling(window=indexer, min_periods=1).sum()
+    result.index.names = ["a", "c"]
+
+    groups = df.groupby("a")[["a", "b", "c"]]
+    manual = concat(
+        [
+            g.assign(
+                b=[
+                    g["b"].iloc[i : i + window_size].sum(min_count=1)
+                    for i in range(len(g))
+                ]
+            )
+            for _, g in groups
+        ]
+    )
+    manual = manual.set_index(["a", "c"])["b"]
+
+    tm.assert_series_equal(result, manual)
+
+
+def test_unequal_start_end_bounds():
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+            return np.array([1]), np.array([1, 2])
+
+    indexer = CustomIndexer()
+    roll = Series(1).rolling(indexer)
+    match = "start"
+    with pytest.raises(ValueError, match=match):
+        roll.mean()
+
+    with pytest.raises(ValueError, match=match):
+        next(iter(roll))
+
+    with pytest.raises(ValueError, match=match):
+        roll.corr(pairwise=True)
+
+    with pytest.raises(ValueError, match=match):
+        roll.cov(pairwise=True)
+
+
+def test_unequal_bounds_to_object():
+    # GH 44470
+    class CustomIndexer(BaseIndexer):
+        def get_window_bounds(self, num_values, min_periods, center, closed, step):
+            return np.array([1]), np.array([2])
+
+    indexer = CustomIndexer()
+    roll = Series([1, 1]).rolling(indexer)
+    match = "start and end"
+    with pytest.raises(ValueError, match=match):
+        roll.mean()
+
+    with pytest.raises(ValueError, match=match):
+        next(iter(roll))
+
+    with pytest.raises(ValueError, match=match):
+        roll.corr(pairwise=True)
+
+    with pytest.raises(ValueError, match=match):
+        roll.cov(pairwise=True)

shared/package-files/17/1745088ef9845a0e712982696a64a0fc9eb238f1f4c24a719fb5fa3a87c42f05/objects.py

@@ -0,0 +1,49 @@
+"""
+A declarative, object-oriented interface for creating statistical graphics.
+
+The seaborn.objects namespace contains a number of classes that can be composed
+together to build a customized visualization.
+
+The main object is :class:`Plot`, which is the starting point for all figures.
+Pass :class:`Plot` a dataset and specify assignments from its variables to
+roles in the plot. Build up the visualization by calling its methods.
+
+There are four other general types of objects in this interface:
+
+- :class:`Mark` subclasses, which create matplotlib artists for visualization
+- :class:`Stat` subclasses, which apply statistical transforms before plotting
+- :class:`Move` subclasses, which make further adjustments to reduce overplotting
+
+These classes are passed to :meth:`Plot.add` to define a layer in the plot.
+Each layer has a :class:`Mark` and optional :class:`Stat` and/or :class:`Move`.
+Plots can have multiple layers.
+
+The other general type of object is a :class:`Scale` subclass, which provide an
+interface for controlling the mappings between data values and visual properties.
+Pass :class:`Scale` objects to :meth:`Plot.scale`.
+
+See the documentation for other :class:`Plot` methods to learn about the many
+ways that a plot can be enhanced and customized.
+
+"""
+from seaborn._core.plot import Plot  # noqa: F401
+
+from seaborn._marks.base import Mark  # noqa: F401
+from seaborn._marks.area import Area, Band  # noqa: F401
+from seaborn._marks.bar import Bar, Bars  # noqa: F401
+from seaborn._marks.dot import Dot, Dots  # noqa: F401
+from seaborn._marks.line import Dash, Line, Lines, Path, Paths, Range  # noqa: F401
+from seaborn._marks.text import Text  # noqa: F401
+
+from seaborn._stats.base import Stat  # noqa: F401
+from seaborn._stats.aggregation import Agg, Est  # noqa: F401
+from seaborn._stats.counting import Count, Hist  # noqa: F401
+from seaborn._stats.density import KDE  # noqa: F401
+from seaborn._stats.order import Perc  # noqa: F401
+from seaborn._stats.regression import PolyFit  # noqa: F401
+
+from seaborn._core.moves import Dodge, Jitter, Norm, Shift, Stack, Move  # noqa: F401
+
+from seaborn._core.scales import (  # noqa: F401
+    Boolean, Continuous, Nominal, Temporal, Scale
+)

shared/package-files/17/174d76b7c7645faf65fed700bf67998ff201afbb327c00ee635a5837dd871c6b/anchor.py

@@ -0,0 +1,20 @@
+# coding: utf-8
+if False:  # MYPY
+    from typing import Any, Dict, Optional, List, Union, Optional, Iterator  # NOQA
+
+anchor_attrib = '_yaml_anchor'
+
+
+class Anchor:
+    __slots__ = 'value', 'always_dump'
+    attrib = anchor_attrib
+
+    def __init__(self):
+        # type: () -> None
+        self.value = None
+        self.always_dump = False
+
+    def __repr__(self):
+        # type: () -> Any
+        ad = ', (always dump)' if self.always_dump else ""
+        return 'Anchor({!r}{})'.format(self.value, ad)

shared/package-files/17/17cf0752407210fe07e9c27f213bc87b46bf4f5047d8939d472b0c0aed57227d/test_defchararray.py

@@ -0,0 +1,686 @@
+import pytest
+
+import numpy as np
+from numpy.core.multiarray import _vec_string
+from numpy.testing import (
+    assert_, assert_equal, assert_array_equal, assert_raises,
+    assert_raises_regex
+    )
+
+kw_unicode_true = {'unicode': True}  # make 2to3 work properly
+kw_unicode_false = {'unicode': False}
+
+class TestBasic:
+    def test_from_object_array(self):
+        A = np.array([['abc', 2],
+                      ['long   ', '0123456789']], dtype='O')
+        B = np.char.array(A)
+        assert_equal(B.dtype.itemsize, 10)
+        assert_array_equal(B, [[b'abc', b'2'],
+                               [b'long', b'0123456789']])
+
+    def test_from_object_array_unicode(self):
+        A = np.array([['abc', 'Sigma \u03a3'],
+                      ['long   ', '0123456789']], dtype='O')
+        assert_raises(ValueError, np.char.array, (A,))
+        B = np.char.array(A, **kw_unicode_true)
+        assert_equal(B.dtype.itemsize, 10 * np.array('a', 'U').dtype.itemsize)
+        assert_array_equal(B, [['abc', 'Sigma \u03a3'],
+                               ['long', '0123456789']])
+
+    def test_from_string_array(self):
+        A = np.array([[b'abc', b'foo'],
+                      [b'long   ', b'0123456789']])
+        assert_equal(A.dtype.type, np.bytes_)
+        B = np.char.array(A)
+        assert_array_equal(B, A)
+        assert_equal(B.dtype, A.dtype)
+        assert_equal(B.shape, A.shape)
+        B[0, 0] = 'changed'
+        assert_(B[0, 0] != A[0, 0])
+        C = np.char.asarray(A)
+        assert_array_equal(C, A)
+        assert_equal(C.dtype, A.dtype)
+        C[0, 0] = 'changed again'
+        assert_(C[0, 0] != B[0, 0])
+        assert_(C[0, 0] == A[0, 0])
+
+    def test_from_unicode_array(self):
+        A = np.array([['abc', 'Sigma \u03a3'],
+                      ['long   ', '0123456789']])
+        assert_equal(A.dtype.type, np.str_)
+        B = np.char.array(A)
+        assert_array_equal(B, A)
+        assert_equal(B.dtype, A.dtype)
+        assert_equal(B.shape, A.shape)
+        B = np.char.array(A, **kw_unicode_true)
+        assert_array_equal(B, A)
+        assert_equal(B.dtype, A.dtype)
+        assert_equal(B.shape, A.shape)
+
+        def fail():
+            np.char.array(A, **kw_unicode_false)
+
+        assert_raises(UnicodeEncodeError, fail)
+
+    def test_unicode_upconvert(self):
+        A = np.char.array(['abc'])
+        B = np.char.array(['\u03a3'])
+        assert_(issubclass((A + B).dtype.type, np.str_))
+
+    def test_from_string(self):
+        A = np.char.array(b'abc')
+        assert_equal(len(A), 1)
+        assert_equal(len(A[0]), 3)
+        assert_(issubclass(A.dtype.type, np.bytes_))
+
+    def test_from_unicode(self):
+        A = np.char.array('\u03a3')
+        assert_equal(len(A), 1)
+        assert_equal(len(A[0]), 1)
+        assert_equal(A.itemsize, 4)
+        assert_(issubclass(A.dtype.type, np.str_))
+
+class TestVecString:
+    def test_non_existent_method(self):
+
+        def fail():
+            _vec_string('a', np.bytes_, 'bogus')
+
+        assert_raises(AttributeError, fail)
+
+    def test_non_string_array(self):
+
+        def fail():
+            _vec_string(1, np.bytes_, 'strip')
+
+        assert_raises(TypeError, fail)
+
+    def test_invalid_args_tuple(self):
+
+        def fail():
+            _vec_string(['a'], np.bytes_, 'strip', 1)
+
+        assert_raises(TypeError, fail)
+
+    def test_invalid_type_descr(self):
+
+        def fail():
+            _vec_string(['a'], 'BOGUS', 'strip')
+
+        assert_raises(TypeError, fail)
+
+    def test_invalid_function_args(self):
+
+        def fail():
+            _vec_string(['a'], np.bytes_, 'strip', (1,))
+
+        assert_raises(TypeError, fail)
+
+    def test_invalid_result_type(self):
+
+        def fail():
+            _vec_string(['a'], np.int_, 'strip')
+
+        assert_raises(TypeError, fail)
+
+    def test_broadcast_error(self):
+
+        def fail():
+            _vec_string([['abc', 'def']], np.int_, 'find', (['a', 'd', 'j'],))
+
+        assert_raises(ValueError, fail)
+
+
+class TestWhitespace:
+    def setup_method(self):
+        self.A = np.array([['abc ', '123  '],
+                           ['789 ', 'xyz ']]).view(np.chararray)
+        self.B = np.array([['abc', '123'],
+                           ['789', 'xyz']]).view(np.chararray)
+
+    def test1(self):
+        assert_(np.all(self.A == self.B))
+        assert_(np.all(self.A >= self.B))
+        assert_(np.all(self.A <= self.B))
+        assert_(not np.any(self.A > self.B))
+        assert_(not np.any(self.A < self.B))
+        assert_(not np.any(self.A != self.B))
+
+class TestChar:
+    def setup_method(self):
+        self.A = np.array('abc1', dtype='c').view(np.chararray)
+
+    def test_it(self):
+        assert_equal(self.A.shape, (4,))
+        assert_equal(self.A.upper()[:2].tobytes(), b'AB')
+
+class TestComparisons:
+    def setup_method(self):
+        self.A = np.array([['abc', '123'],
+                           ['789', 'xyz']]).view(np.chararray)
+        self.B = np.array([['efg', '123  '],
+                           ['051', 'tuv']]).view(np.chararray)
+
+    def test_not_equal(self):
+        assert_array_equal((self.A != self.B), [[True, False], [True, True]])
+
+    def test_equal(self):
+        assert_array_equal((self.A == self.B), [[False, True], [False, False]])
+
+    def test_greater_equal(self):
+        assert_array_equal((self.A >= self.B), [[False, True], [True, True]])
+
+    def test_less_equal(self):
+        assert_array_equal((self.A <= self.B), [[True, True], [False, False]])
+
+    def test_greater(self):
+        assert_array_equal((self.A > self.B), [[False, False], [True, True]])
+
+    def test_less(self):
+        assert_array_equal((self.A < self.B), [[True, False], [False, False]])
+
+    def test_type(self):
+        out1 = np.char.equal(self.A, self.B)
+        out2 = np.char.equal('a', 'a')
+        assert_(isinstance(out1, np.ndarray))
+        assert_(isinstance(out2, np.ndarray))
+
+class TestComparisonsMixed1(TestComparisons):
+    """Ticket #1276"""
+
+    def setup_method(self):
+        TestComparisons.setup_method(self)
+        self.B = np.array([['efg', '123  '],
+                           ['051', 'tuv']], np.str_).view(np.chararray)
+
+class TestComparisonsMixed2(TestComparisons):
+    """Ticket #1276"""
+
+    def setup_method(self):
+        TestComparisons.setup_method(self)
+        self.A = np.array([['abc', '123'],
+                           ['789', 'xyz']], np.str_).view(np.chararray)
+
+class TestInformation:
+    def setup_method(self):
+        self.A = np.array([[' abc ', ''],
+                           ['12345', 'MixedCase'],
+                           ['123 \t 345 \0 ', 'UPPER']]).view(np.chararray)
+        self.B = np.array([[' \u03a3 ', ''],
+                           ['12345', 'MixedCase'],
+                           ['123 \t 345 \0 ', 'UPPER']]).view(np.chararray)
+
+    def test_len(self):
+        assert_(issubclass(np.char.str_len(self.A).dtype.type, np.integer))
+        assert_array_equal(np.char.str_len(self.A), [[5, 0], [5, 9], [12, 5]])
+        assert_array_equal(np.char.str_len(self.B), [[3, 0], [5, 9], [12, 5]])
+
+    def test_count(self):
+        assert_(issubclass(self.A.count('').dtype.type, np.integer))
+        assert_array_equal(self.A.count('a'), [[1, 0], [0, 1], [0, 0]])
+        assert_array_equal(self.A.count('123'), [[0, 0], [1, 0], [1, 0]])
+        # Python doesn't seem to like counting NULL characters
+        # assert_array_equal(self.A.count('\0'), [[0, 0], [0, 0], [1, 0]])
+        assert_array_equal(self.A.count('a', 0, 2), [[1, 0], [0, 0], [0, 0]])
+        assert_array_equal(self.B.count('a'), [[0, 0], [0, 1], [0, 0]])
+        assert_array_equal(self.B.count('123'), [[0, 0], [1, 0], [1, 0]])
+        # assert_array_equal(self.B.count('\0'), [[0, 0], [0, 0], [1, 0]])
+
+    def test_endswith(self):
+        assert_(issubclass(self.A.endswith('').dtype.type, np.bool_))
+        assert_array_equal(self.A.endswith(' '), [[1, 0], [0, 0], [1, 0]])
+        assert_array_equal(self.A.endswith('3', 0, 3), [[0, 0], [1, 0], [1, 0]])
+
+        def fail():
+            self.A.endswith('3', 'fdjk')
+
+        assert_raises(TypeError, fail)
+
+    def test_find(self):
+        assert_(issubclass(self.A.find('a').dtype.type, np.integer))
+        assert_array_equal(self.A.find('a'), [[1, -1], [-1, 6], [-1, -1]])
+        assert_array_equal(self.A.find('3'), [[-1, -1], [2, -1], [2, -1]])
+        assert_array_equal(self.A.find('a', 0, 2), [[1, -1], [-1, -1], [-1, -1]])
+        assert_array_equal(self.A.find(['1', 'P']), [[-1, -1], [0, -1], [0, 1]])
+
+    def test_index(self):
+
+        def fail():
+            self.A.index('a')
+
+        assert_raises(ValueError, fail)
+        assert_(np.char.index('abcba', 'b') == 1)
+        assert_(issubclass(np.char.index('abcba', 'b').dtype.type, np.integer))
+
+    def test_isalnum(self):
+        assert_(issubclass(self.A.isalnum().dtype.type, np.bool_))
+        assert_array_equal(self.A.isalnum(), [[False, False], [True, True], [False, True]])
+
+    def test_isalpha(self):
+        assert_(issubclass(self.A.isalpha().dtype.type, np.bool_))
+        assert_array_equal(self.A.isalpha(), [[False, False], [False, True], [False, True]])
+
+    def test_isdigit(self):
+        assert_(issubclass(self.A.isdigit().dtype.type, np.bool_))
+        assert_array_equal(self.A.isdigit(), [[False, False], [True, False], [False, False]])
+
+    def test_islower(self):
+        assert_(issubclass(self.A.islower().dtype.type, np.bool_))
+        assert_array_equal(self.A.islower(), [[True, False], [False, False], [False, False]])
+
+    def test_isspace(self):
+        assert_(issubclass(self.A.isspace().dtype.type, np.bool_))
+        assert_array_equal(self.A.isspace(), [[False, False], [False, False], [False, False]])
+
+    def test_istitle(self):
+        assert_(issubclass(self.A.istitle().dtype.type, np.bool_))
+        assert_array_equal(self.A.istitle(), [[False, False], [False, False], [False, False]])
+
+    def test_isupper(self):
+        assert_(issubclass(self.A.isupper().dtype.type, np.bool_))
+        assert_array_equal(self.A.isupper(), [[False, False], [False, False], [False, True]])
+
+    def test_rfind(self):
+        assert_(issubclass(self.A.rfind('a').dtype.type, np.integer))
+        assert_array_equal(self.A.rfind('a'), [[1, -1], [-1, 6], [-1, -1]])
+        assert_array_equal(self.A.rfind('3'), [[-1, -1], [2, -1], [6, -1]])
+        assert_array_equal(self.A.rfind('a', 0, 2), [[1, -1], [-1, -1], [-1, -1]])
+        assert_array_equal(self.A.rfind(['1', 'P']), [[-1, -1], [0, -1], [0, 2]])
+
+    def test_rindex(self):
+
+        def fail():
+            self.A.rindex('a')
+
+        assert_raises(ValueError, fail)
+        assert_(np.char.rindex('abcba', 'b') == 3)
+        assert_(issubclass(np.char.rindex('abcba', 'b').dtype.type, np.integer))
+
+    def test_startswith(self):
+        assert_(issubclass(self.A.startswith('').dtype.type, np.bool_))
+        assert_array_equal(self.A.startswith(' '), [[1, 0], [0, 0], [0, 0]])
+        assert_array_equal(self.A.startswith('1', 0, 3), [[0, 0], [1, 0], [1, 0]])
+
+        def fail():
+            self.A.startswith('3', 'fdjk')
+
+        assert_raises(TypeError, fail)
+
+
+class TestMethods:
+    def setup_method(self):
+        self.A = np.array([[' abc ', ''],
+                           ['12345', 'MixedCase'],
+                           ['123 \t 345 \0 ', 'UPPER']],
+                          dtype='S').view(np.chararray)
+        self.B = np.array([[' \u03a3 ', ''],
+                           ['12345', 'MixedCase'],
+                           ['123 \t 345 \0 ', 'UPPER']]).view(np.chararray)
+
+    def test_capitalize(self):
+        tgt = [[b' abc ', b''],
+               [b'12345', b'Mixedcase'],
+               [b'123 \t 345 \0 ', b'Upper']]
+        assert_(issubclass(self.A.capitalize().dtype.type, np.bytes_))
+        assert_array_equal(self.A.capitalize(), tgt)
+
+        tgt = [[' \u03c3 ', ''],
+               ['12345', 'Mixedcase'],
+               ['123 \t 345 \0 ', 'Upper']]
+        assert_(issubclass(self.B.capitalize().dtype.type, np.str_))
+        assert_array_equal(self.B.capitalize(), tgt)
+
+    def test_center(self):
+        assert_(issubclass(self.A.center(10).dtype.type, np.bytes_))
+        C = self.A.center([10, 20])
+        assert_array_equal(np.char.str_len(C), [[10, 20], [10, 20], [12, 20]])
+
+        C = self.A.center(20, b'#')
+        assert_(np.all(C.startswith(b'#')))
+        assert_(np.all(C.endswith(b'#')))
+
+        C = np.char.center(b'FOO', [[10, 20], [15, 8]])
+        tgt = [[b'   FOO    ', b'        FOO         '],
+               [b'      FOO      ', b'  FOO   ']]
+        assert_(issubclass(C.dtype.type, np.bytes_))
+        assert_array_equal(C, tgt)
+
+    def test_decode(self):
+        A = np.char.array([b'\\u03a3'])
+        assert_(A.decode('unicode-escape')[0] == '\u03a3')
+
+    def test_encode(self):
+        B = self.B.encode('unicode_escape')
+        assert_(B[0][0] == str(' \\u03a3 ').encode('latin1'))
+
+    def test_expandtabs(self):
+        T = self.A.expandtabs()
+        assert_(T[2, 0] == b'123      345 \0')
+
+    def test_join(self):
+        # NOTE: list(b'123') == [49, 50, 51]
+        #       so that b','.join(b'123') results to an error on Py3
+        A0 = self.A.decode('ascii')
+
+        A = np.char.join([',', '#'], A0)
+        assert_(issubclass(A.dtype.type, np.str_))
+        tgt = np.array([[' ,a,b,c, ', ''],
+                        ['1,2,3,4,5', 'M#i#x#e#d#C#a#s#e'],
+                        ['1,2,3, ,\t, ,3,4,5, ,\x00, ', 'U#P#P#E#R']])
+        assert_array_equal(np.char.join([',', '#'], A0), tgt)
+
+    def test_ljust(self):
+        assert_(issubclass(self.A.ljust(10).dtype.type, np.bytes_))
+
+        C = self.A.ljust([10, 20])
+        assert_array_equal(np.char.str_len(C), [[10, 20], [10, 20], [12, 20]])
+
+        C = self.A.ljust(20, b'#')
+        assert_array_equal(C.startswith(b'#'), [
+                [False, True], [False, False], [False, False]])
+        assert_(np.all(C.endswith(b'#')))
+
+        C = np.char.ljust(b'FOO', [[10, 20], [15, 8]])
+        tgt = [[b'FOO       ', b'FOO                 '],
+               [b'FOO            ', b'FOO     ']]
+        assert_(issubclass(C.dtype.type, np.bytes_))
+        assert_array_equal(C, tgt)
+
+    def test_lower(self):
+        tgt = [[b' abc ', b''],
+               [b'12345', b'mixedcase'],
+               [b'123 \t 345 \0 ', b'upper']]
+        assert_(issubclass(self.A.lower().dtype.type, np.bytes_))
+        assert_array_equal(self.A.lower(), tgt)
+
+        tgt = [[' \u03c3 ', ''],
+               ['12345', 'mixedcase'],
+               ['123 \t 345 \0 ', 'upper']]
+        assert_(issubclass(self.B.lower().dtype.type, np.str_))
+        assert_array_equal(self.B.lower(), tgt)
+
+    def test_lstrip(self):
+        tgt = [[b'abc ', b''],
+               [b'12345', b'MixedCase'],
+               [b'123 \t 345 \0 ', b'UPPER']]
+        assert_(issubclass(self.A.lstrip().dtype.type, np.bytes_))
+        assert_array_equal(self.A.lstrip(), tgt)
+
+        tgt = [[b' abc', b''],
+               [b'2345', b'ixedCase'],
+               [b'23 \t 345 \x00', b'UPPER']]
+        assert_array_equal(self.A.lstrip([b'1', b'M']), tgt)
+
+        tgt = [['\u03a3 ', ''],
+               ['12345', 'MixedCase'],
+               ['123 \t 345 \0 ', 'UPPER']]
+        assert_(issubclass(self.B.lstrip().dtype.type, np.str_))
+        assert_array_equal(self.B.lstrip(), tgt)
+
+    def test_partition(self):
+        P = self.A.partition([b'3', b'M'])
+        tgt = [[(b' abc ', b'', b''), (b'', b'', b'')],
+               [(b'12', b'3', b'45'), (b'', b'M', b'ixedCase')],
+               [(b'12', b'3', b' \t 345 \0 '), (b'UPPER', b'', b'')]]
+        assert_(issubclass(P.dtype.type, np.bytes_))
+        assert_array_equal(P, tgt)
+
+    def test_replace(self):
+        R = self.A.replace([b'3', b'a'],
+                           [b'##########', b'@'])
+        tgt = [[b' abc ', b''],
+               [b'12##########45', b'MixedC@se'],
+               [b'12########## \t ##########45 \x00', b'UPPER']]
+        assert_(issubclass(R.dtype.type, np.bytes_))
+        assert_array_equal(R, tgt)
+
+    def test_rjust(self):
+        assert_(issubclass(self.A.rjust(10).dtype.type, np.bytes_))
+
+        C = self.A.rjust([10, 20])
+        assert_array_equal(np.char.str_len(C), [[10, 20], [10, 20], [12, 20]])
+
+        C = self.A.rjust(20, b'#')
+        assert_(np.all(C.startswith(b'#')))
+        assert_array_equal(C.endswith(b'#'),
+                           [[False, True], [False, False], [False, False]])
+
+        C = np.char.rjust(b'FOO', [[10, 20], [15, 8]])
+        tgt = [[b'       FOO', b'                 FOO'],
+               [b'            FOO', b'     FOO']]
+        assert_(issubclass(C.dtype.type, np.bytes_))
+        assert_array_equal(C, tgt)
+
+    def test_rpartition(self):
+        P = self.A.rpartition([b'3', b'M'])
+        tgt = [[(b'', b'', b' abc '), (b'', b'', b'')],
+               [(b'12', b'3', b'45'), (b'', b'M', b'ixedCase')],
+               [(b'123 \t ', b'3', b'45 \0 '), (b'', b'', b'UPPER')]]
+        assert_(issubclass(P.dtype.type, np.bytes_))
+        assert_array_equal(P, tgt)
+
+    def test_rsplit(self):
+        A = self.A.rsplit(b'3')
+        tgt = [[[b' abc '], [b'']],
+               [[b'12', b'45'], [b'MixedCase']],
+               [[b'12', b' \t ', b'45 \x00 '], [b'UPPER']]]
+        assert_(issubclass(A.dtype.type, np.object_))
+        assert_equal(A.tolist(), tgt)
+
+    def test_rstrip(self):
+        assert_(issubclass(self.A.rstrip().dtype.type, np.bytes_))
+
+        tgt = [[b' abc', b''],
+               [b'12345', b'MixedCase'],
+               [b'123 \t 345', b'UPPER']]
+        assert_array_equal(self.A.rstrip(), tgt)
+
+        tgt = [[b' abc ', b''],
+               [b'1234', b'MixedCase'],
+               [b'123 \t 345 \x00', b'UPP']
+               ]
+        assert_array_equal(self.A.rstrip([b'5', b'ER']), tgt)
+
+        tgt = [[' \u03a3', ''],
+               ['12345', 'MixedCase'],
+               ['123 \t 345', 'UPPER']]
+        assert_(issubclass(self.B.rstrip().dtype.type, np.str_))
+        assert_array_equal(self.B.rstrip(), tgt)
+
+    def test_strip(self):
+        tgt = [[b'abc', b''],
+               [b'12345', b'MixedCase'],
+               [b'123 \t 345', b'UPPER']]
+        assert_(issubclass(self.A.strip().dtype.type, np.bytes_))
+        assert_array_equal(self.A.strip(), tgt)
+
+        tgt = [[b' abc ', b''],
+               [b'234', b'ixedCas'],
+               [b'23 \t 345 \x00', b'UPP']]
+        assert_array_equal(self.A.strip([b'15', b'EReM']), tgt)
+
+        tgt = [['\u03a3', ''],
+               ['12345', 'MixedCase'],
+               ['123 \t 345', 'UPPER']]
+        assert_(issubclass(self.B.strip().dtype.type, np.str_))
+        assert_array_equal(self.B.strip(), tgt)
+
+    def test_split(self):
+        A = self.A.split(b'3')
+        tgt = [
+               [[b' abc '], [b'']],
+               [[b'12', b'45'], [b'MixedCase']],
+               [[b'12', b' \t ', b'45 \x00 '], [b'UPPER']]]
+        assert_(issubclass(A.dtype.type, np.object_))
+        assert_equal(A.tolist(), tgt)
+
+    def test_splitlines(self):
+        A = np.char.array(['abc\nfds\nwer']).splitlines()
+        assert_(issubclass(A.dtype.type, np.object_))
+        assert_(A.shape == (1,))
+        assert_(len(A[0]) == 3)
+
+    def test_swapcase(self):
+        tgt = [[b' ABC ', b''],
+               [b'12345', b'mIXEDcASE'],
+               [b'123 \t 345 \0 ', b'upper']]
+        assert_(issubclass(self.A.swapcase().dtype.type, np.bytes_))
+        assert_array_equal(self.A.swapcase(), tgt)
+
+        tgt = [[' \u03c3 ', ''],
+               ['12345', 'mIXEDcASE'],
+               ['123 \t 345 \0 ', 'upper']]
+        assert_(issubclass(self.B.swapcase().dtype.type, np.str_))
+        assert_array_equal(self.B.swapcase(), tgt)
+
+    def test_title(self):
+        tgt = [[b' Abc ', b''],
+               [b'12345', b'Mixedcase'],
+               [b'123 \t 345 \0 ', b'Upper']]
+        assert_(issubclass(self.A.title().dtype.type, np.bytes_))
+        assert_array_equal(self.A.title(), tgt)
+
+        tgt = [[' \u03a3 ', ''],
+               ['12345', 'Mixedcase'],
+               ['123 \t 345 \0 ', 'Upper']]
+        assert_(issubclass(self.B.title().dtype.type, np.str_))
+        assert_array_equal(self.B.title(), tgt)
+
+    def test_upper(self):
+        tgt = [[b' ABC ', b''],
+               [b'12345', b'MIXEDCASE'],
+               [b'123 \t 345 \0 ', b'UPPER']]
+        assert_(issubclass(self.A.upper().dtype.type, np.bytes_))
+        assert_array_equal(self.A.upper(), tgt)
+
+        tgt = [[' \u03a3 ', ''],
+               ['12345', 'MIXEDCASE'],
+               ['123 \t 345 \0 ', 'UPPER']]
+        assert_(issubclass(self.B.upper().dtype.type, np.str_))
+        assert_array_equal(self.B.upper(), tgt)
+
+    def test_isnumeric(self):
+
+        def fail():
+            self.A.isnumeric()
+
+        assert_raises(TypeError, fail)
+        assert_(issubclass(self.B.isnumeric().dtype.type, np.bool_))
+        assert_array_equal(self.B.isnumeric(), [
+                [False, False], [True, False], [False, False]])
+
+    def test_isdecimal(self):
+
+        def fail():
+            self.A.isdecimal()
+
+        assert_raises(TypeError, fail)
+        assert_(issubclass(self.B.isdecimal().dtype.type, np.bool_))
+        assert_array_equal(self.B.isdecimal(), [
+                [False, False], [True, False], [False, False]])
+
+
+class TestOperations:
+    def setup_method(self):
+        self.A = np.array([['abc', '123'],
+                           ['789', 'xyz']]).view(np.chararray)
+        self.B = np.array([['efg', '456'],
+                           ['051', 'tuv']]).view(np.chararray)
+
+    def test_add(self):
+        AB = np.array([['abcefg', '123456'],
+                       ['789051', 'xyztuv']]).view(np.chararray)
+        assert_array_equal(AB, (self.A + self.B))
+        assert_(len((self.A + self.B)[0][0]) == 6)
+
+    def test_radd(self):
+        QA = np.array([['qabc', 'q123'],
+                       ['q789', 'qxyz']]).view(np.chararray)
+        assert_array_equal(QA, ('q' + self.A))
+
+    def test_mul(self):
+        A = self.A
+        for r in (2, 3, 5, 7, 197):
+            Ar = np.array([[A[0, 0]*r, A[0, 1]*r],
+                           [A[1, 0]*r, A[1, 1]*r]]).view(np.chararray)
+
+            assert_array_equal(Ar, (self.A * r))
+
+        for ob in [object(), 'qrs']:
+            with assert_raises_regex(ValueError,
+                                     'Can only multiply by integers'):
+                A*ob
+
+    def test_rmul(self):
+        A = self.A
+        for r in (2, 3, 5, 7, 197):
+            Ar = np.array([[A[0, 0]*r, A[0, 1]*r],
+                           [A[1, 0]*r, A[1, 1]*r]]).view(np.chararray)
+            assert_array_equal(Ar, (r * self.A))
+
+        for ob in [object(), 'qrs']:
+            with assert_raises_regex(ValueError,
+                                     'Can only multiply by integers'):
+                ob * A
+
+    def test_mod(self):
+        """Ticket #856"""
+        F = np.array([['%d', '%f'], ['%s', '%r']]).view(np.chararray)
+        C = np.array([[3, 7], [19, 1]])
+        FC = np.array([['3', '7.000000'],
+                       ['19', '1']]).view(np.chararray)
+        assert_array_equal(FC, F % C)
+
+        A = np.array([['%.3f', '%d'], ['%s', '%r']]).view(np.chararray)
+        A1 = np.array([['1.000', '1'], ['1', '1']]).view(np.chararray)
+        assert_array_equal(A1, (A % 1))
+
+        A2 = np.array([['1.000', '2'], ['3', '4']]).view(np.chararray)
+        assert_array_equal(A2, (A % [[1, 2], [3, 4]]))
+
+    def test_rmod(self):
+        assert_(("%s" % self.A) == str(self.A))
+        assert_(("%r" % self.A) == repr(self.A))
+
+        for ob in [42, object()]:
+            with assert_raises_regex(
+                    TypeError, "unsupported operand type.* and 'chararray'"):
+                ob % self.A
+
+    def test_slice(self):
+        """Regression test for https://github.com/numpy/numpy/issues/5982"""
+
+        arr = np.array([['abc ', 'def '], ['geh ', 'ijk ']],
+                       dtype='S4').view(np.chararray)
+        sl1 = arr[:]
+        assert_array_equal(sl1, arr)
+        assert_(sl1.base is arr)
+        assert_(sl1.base.base is arr.base)
+
+        sl2 = arr[:, :]
+        assert_array_equal(sl2, arr)
+        assert_(sl2.base is arr)
+        assert_(sl2.base.base is arr.base)
+
+        assert_(arr[0, 0] == b'abc')
+
+
+def test_empty_indexing():
+    """Regression test for ticket 1948."""
+    # Check that indexing a chararray with an empty list/array returns an
+    # empty chararray instead of a chararray with a single empty string in it.
+    s = np.chararray((4,))
+    assert_(s[[]].size == 0)
+
+
+@pytest.mark.parametrize(["dt1", "dt2"],
+        [("S", "U"), ("U", "S"), ("S", "O"), ("U", "O"),
+         ("S", "d"), ("S", "V")])
+def test_add_types(dt1, dt2):
+    arr1 = np.array([1234234], dtype=dt1)
+    # If the following fails, e.g. use a number and test "V" explicitly
+    arr2 = np.array([b"423"], dtype=dt2)
+    with pytest.raises(TypeError,
+            match=f".*same dtype kind.*{arr1.dtype}.*{arr2.dtype}"):
+        np.char.add(arr1, arr2)

shared/package-files/17/17de9f3d36c6ccbd97ed4ca15a908ad06663a84aa5d485714b202db7fe8e171a/dylib.py

@@ -0,0 +1,63 @@
+"""
+Generic dylib path manipulation
+"""
+
+import re
+
+__all__ = ['dylib_info']
+
+DYLIB_RE = re.compile(r"""(?x)
+(?P<location>^.*)(?:^|/)
+(?P<name>
+    (?P<shortname>\w+?)
+    (?:\.(?P<version>[^._]+))?
+    (?:_(?P<suffix>[^._]+))?
+    \.dylib$
+)
+""")
+
+def dylib_info(filename):
+    """
+    A dylib name can take one of the following four forms:
+        Location/Name.SomeVersion_Suffix.dylib
+        Location/Name.SomeVersion.dylib
+        Location/Name_Suffix.dylib
+        Location/Name.dylib
+
+    returns None if not found or a mapping equivalent to:
+        dict(
+            location='Location',
+            name='Name.SomeVersion_Suffix.dylib',
+            shortname='Name',
+            version='SomeVersion',
+            suffix='Suffix',
+        )
+
+    Note that SomeVersion and Suffix are optional and may be None
+    if not present.
+    """
+    is_dylib = DYLIB_RE.match(filename)
+    if not is_dylib:
+        return None
+    return is_dylib.groupdict()
+
+
+def test_dylib_info():
+    def d(location=None, name=None, shortname=None, version=None, suffix=None):
+        return dict(
+            location=location,
+            name=name,
+            shortname=shortname,
+            version=version,
+            suffix=suffix
+        )
+    assert dylib_info('completely/invalid') is None
+    assert dylib_info('completely/invalide_debug') is None
+    assert dylib_info('P/Foo.dylib') == d('P', 'Foo.dylib', 'Foo')
+    assert dylib_info('P/Foo_debug.dylib') == d('P', 'Foo_debug.dylib', 'Foo', suffix='debug')
+    assert dylib_info('P/Foo.A.dylib') == d('P', 'Foo.A.dylib', 'Foo', 'A')
+    assert dylib_info('P/Foo_debug.A.dylib') == d('P', 'Foo_debug.A.dylib', 'Foo_debug', 'A')
+    assert dylib_info('P/Foo.A_debug.dylib') == d('P', 'Foo.A_debug.dylib', 'Foo', 'A', 'debug')
+
+if __name__ == '__main__':
+    test_dylib_info()

shared/package-files/98/980d45c9423cf89d78c99d557f949ed0e796daee27bfdfb5b34afd78e98ec671/test_round.py

@@ -0,0 +1,383 @@
+from hypothesis import (
+    given,
+    strategies as st,
+)
+import numpy as np
+import pytest
+import pytz
+
+from pandas._libs import lib
+from pandas._libs.tslibs import (
+    NaT,
+    OutOfBoundsDatetime,
+    Timedelta,
+    Timestamp,
+    iNaT,
+    to_offset,
+)
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
+
+import pandas._testing as tm
+
+
+class TestTimestampRound:
+    def test_round_division_by_zero_raises(self):
+        ts = Timestamp("2016-01-01")
+
+        msg = "Division by zero in rounding"
+        with pytest.raises(ValueError, match=msg):
+            ts.round("0ns")
+
+    @pytest.mark.parametrize(
+        "timestamp, freq, expected",
+        [
+            ("20130101 09:10:11", "D", "20130101"),
+            ("20130101 19:10:11", "D", "20130102"),
+            ("20130201 12:00:00", "D", "20130202"),
+            ("20130104 12:00:00", "D", "20130105"),
+            ("2000-01-05 05:09:15.13", "D", "2000-01-05 00:00:00"),
+            ("2000-01-05 05:09:15.13", "h", "2000-01-05 05:00:00"),
+            ("2000-01-05 05:09:15.13", "s", "2000-01-05 05:09:15"),
+        ],
+    )
+    def test_round_frequencies(self, timestamp, freq, expected):
+        dt = Timestamp(timestamp)
+        result = dt.round(freq)
+        expected = Timestamp(expected)
+        assert result == expected
+
+    def test_round_tzaware(self):
+        dt = Timestamp("20130101 09:10:11", tz="US/Eastern")
+        result = dt.round("D")
+        expected = Timestamp("20130101", tz="US/Eastern")
+        assert result == expected
+
+        dt = Timestamp("20130101 09:10:11", tz="US/Eastern")
+        result = dt.round("s")
+        assert result == dt
+
+    def test_round_30min(self):
+        # round
+        dt = Timestamp("20130104 12:32:00")
+        result = dt.round("30Min")
+        expected = Timestamp("20130104 12:30:00")
+        assert result == expected
+
+    def test_round_subsecond(self):
+        # GH#14440 & GH#15578
+        result = Timestamp("2016-10-17 12:00:00.0015").round("ms")
+        expected = Timestamp("2016-10-17 12:00:00.002000")
+        assert result == expected
+
+        result = Timestamp("2016-10-17 12:00:00.00149").round("ms")
+        expected = Timestamp("2016-10-17 12:00:00.001000")
+        assert result == expected
+
+        ts = Timestamp("2016-10-17 12:00:00.0015")
+        for freq in ["us", "ns"]:
+            assert ts == ts.round(freq)
+
+        result = Timestamp("2016-10-17 12:00:00.001501031").round("10ns")
+        expected = Timestamp("2016-10-17 12:00:00.001501030")
+        assert result == expected
+
+    def test_round_nonstandard_freq(self):
+        with tm.assert_produces_warning(False):
+            Timestamp("2016-10-17 12:00:00.001501031").round("1010ns")
+
+    def test_round_invalid_arg(self):
+        stamp = Timestamp("2000-01-05 05:09:15.13")
+        with pytest.raises(ValueError, match=INVALID_FREQ_ERR_MSG):
+            stamp.round("foo")
+
+    @pytest.mark.parametrize(
+        "test_input, rounder, freq, expected",
+        [
+            ("2117-01-01 00:00:45", "floor", "15s", "2117-01-01 00:00:45"),
+            ("2117-01-01 00:00:45", "ceil", "15s", "2117-01-01 00:00:45"),
+            (
+                "2117-01-01 00:00:45.000000012",
+                "floor",
+                "10ns",
+                "2117-01-01 00:00:45.000000010",
+            ),
+            (
+                "1823-01-01 00:00:01.000000012",
+                "ceil",
+                "10ns",
+                "1823-01-01 00:00:01.000000020",
+            ),
+            ("1823-01-01 00:00:01", "floor", "1s", "1823-01-01 00:00:01"),
+            ("1823-01-01 00:00:01", "ceil", "1s", "1823-01-01 00:00:01"),
+            ("NaT", "floor", "1s", "NaT"),
+            ("NaT", "ceil", "1s", "NaT"),
+        ],
+    )
+    def test_ceil_floor_edge(self, test_input, rounder, freq, expected):
+        dt = Timestamp(test_input)
+        func = getattr(dt, rounder)
+        result = func(freq)
+
+        if dt is NaT:
+            assert result is NaT
+        else:
+            expected = Timestamp(expected)
+            assert result == expected
+
+    @pytest.mark.parametrize(
+        "test_input, freq, expected",
+        [
+            ("2018-01-01 00:02:06", "2s", "2018-01-01 00:02:06"),
+            ("2018-01-01 00:02:00", "2min", "2018-01-01 00:02:00"),
+            ("2018-01-01 00:04:00", "4min", "2018-01-01 00:04:00"),
+            ("2018-01-01 00:15:00", "15min", "2018-01-01 00:15:00"),
+            ("2018-01-01 00:20:00", "20min", "2018-01-01 00:20:00"),
+            ("2018-01-01 03:00:00", "3h", "2018-01-01 03:00:00"),
+        ],
+    )
+    @pytest.mark.parametrize("rounder", ["ceil", "floor", "round"])
+    def test_round_minute_freq(self, test_input, freq, expected, rounder):
+        # Ensure timestamps that shouldn't round dont!
+        # GH#21262
+
+        dt = Timestamp(test_input)
+        expected = Timestamp(expected)
+        func = getattr(dt, rounder)
+        result = func(freq)
+        assert result == expected
+
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+    def test_ceil(self, unit):
+        dt = Timestamp("20130101 09:10:11").as_unit(unit)
+        result = dt.ceil("D")
+        expected = Timestamp("20130102")
+        assert result == expected
+        assert result._creso == dt._creso
+
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+    def test_floor(self, unit):
+        dt = Timestamp("20130101 09:10:11").as_unit(unit)
+        result = dt.floor("D")
+        expected = Timestamp("20130101")
+        assert result == expected
+        assert result._creso == dt._creso
+
+    @pytest.mark.parametrize("method", ["ceil", "round", "floor"])
+    @pytest.mark.parametrize(
+        "unit",
+        ["ns", "us", "ms", "s"],
+    )
+    def test_round_dst_border_ambiguous(self, method, unit):
+        # GH 18946 round near "fall back" DST
+        ts = Timestamp("2017-10-29 00:00:00", tz="UTC").tz_convert("Europe/Madrid")
+        ts = ts.as_unit(unit)
+        #
+        result = getattr(ts, method)("h", ambiguous=True)
+        assert result == ts
+        assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
+
+        result = getattr(ts, method)("h", ambiguous=False)
+        expected = Timestamp("2017-10-29 01:00:00", tz="UTC").tz_convert(
+            "Europe/Madrid"
+        )
+        assert result == expected
+        assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
+
+        result = getattr(ts, method)("h", ambiguous="NaT")
+        assert result is NaT
+
+        msg = "Cannot infer dst time"
+        with pytest.raises(pytz.AmbiguousTimeError, match=msg):
+            getattr(ts, method)("h", ambiguous="raise")
+
+    @pytest.mark.parametrize(
+        "method, ts_str, freq",
+        [
+            ["ceil", "2018-03-11 01:59:00-0600", "5min"],
+            ["round", "2018-03-11 01:59:00-0600", "5min"],
+            ["floor", "2018-03-11 03:01:00-0500", "2h"],
+        ],
+    )
+    @pytest.mark.parametrize(
+        "unit",
+        ["ns", "us", "ms", "s"],
+    )
+    def test_round_dst_border_nonexistent(self, method, ts_str, freq, unit):
+        # GH 23324 round near "spring forward" DST
+        ts = Timestamp(ts_str, tz="America/Chicago").as_unit(unit)
+        result = getattr(ts, method)(freq, nonexistent="shift_forward")
+        expected = Timestamp("2018-03-11 03:00:00", tz="America/Chicago")
+        assert result == expected
+        assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
+
+        result = getattr(ts, method)(freq, nonexistent="NaT")
+        assert result is NaT
+
+        msg = "2018-03-11 02:00:00"
+        with pytest.raises(pytz.NonExistentTimeError, match=msg):
+            getattr(ts, method)(freq, nonexistent="raise")
+
+    @pytest.mark.parametrize(
+        "timestamp",
+        [
+            "2018-01-01 0:0:0.124999360",
+            "2018-01-01 0:0:0.125000367",
+            "2018-01-01 0:0:0.125500",
+            "2018-01-01 0:0:0.126500",
+            "2018-01-01 12:00:00",
+            "2019-01-01 12:00:00",
+        ],
+    )
+    @pytest.mark.parametrize(
+        "freq",
+        [
+            "2ns",
+            "3ns",
+            "4ns",
+            "5ns",
+            "6ns",
+            "7ns",
+            "250ns",
+            "500ns",
+            "750ns",
+            "1us",
+            "19us",
+            "250us",
+            "500us",
+            "750us",
+            "1s",
+            "2s",
+            "3s",
+            "1D",
+        ],
+    )
+    def test_round_int64(self, timestamp, freq):
+        # check that all rounding modes are accurate to int64 precision
+        # see GH#22591
+        dt = Timestamp(timestamp).as_unit("ns")
+        unit = to_offset(freq).nanos
+
+        # test floor
+        result = dt.floor(freq)
+        assert result._value % unit == 0, f"floor not a {freq} multiple"
+        assert 0 <= dt._value - result._value < unit, "floor error"
+
+        # test ceil
+        result = dt.ceil(freq)
+        assert result._value % unit == 0, f"ceil not a {freq} multiple"
+        assert 0 <= result._value - dt._value < unit, "ceil error"
+
+        # test round
+        result = dt.round(freq)
+        assert result._value % unit == 0, f"round not a {freq} multiple"
+        assert abs(result._value - dt._value) <= unit // 2, "round error"
+        if unit % 2 == 0 and abs(result._value - dt._value) == unit // 2:
+            # round half to even
+            assert result._value // unit % 2 == 0, "round half to even error"
+
+    def test_round_implementation_bounds(self):
+        # See also: analogous test for Timedelta
+        result = Timestamp.min.ceil("s")
+        expected = Timestamp(1677, 9, 21, 0, 12, 44)
+        assert result == expected
+
+        result = Timestamp.max.floor("s")
+        expected = Timestamp.max - Timedelta(854775807)
+        assert result == expected
+
+        msg = "Cannot round 1677-09-21 00:12:43.145224193 to freq=<Second>"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp.min.floor("s")
+
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp.min.round("s")
+
+        msg = "Cannot round 2262-04-11 23:47:16.854775807 to freq=<Second>"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp.max.ceil("s")
+
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            Timestamp.max.round("s")
+
+    @given(val=st.integers(iNaT + 1, lib.i8max))
+    @pytest.mark.parametrize(
+        "method", [Timestamp.round, Timestamp.floor, Timestamp.ceil]
+    )
+    def test_round_sanity(self, val, method):
+        cls = Timestamp
+        err_cls = OutOfBoundsDatetime
+
+        val = np.int64(val)
+        ts = cls(val)
+
+        def checker(ts, nanos, unit):
+            # First check that we do raise in cases where we should
+            if nanos == 1:
+                pass
+            else:
+                div, mod = divmod(ts._value, nanos)
+                diff = int(nanos - mod)
+                lb = ts._value - mod
+                assert lb <= ts._value  # i.e. no overflows with python ints
+                ub = ts._value + diff
+                assert ub > ts._value  # i.e. no overflows with python ints
+
+                msg = "without overflow"
+                if mod == 0:
+                    # We should never be raising in this
+                    pass
+                elif method is cls.ceil:
+                    if ub > cls.max._value:
+                        with pytest.raises(err_cls, match=msg):
+                            method(ts, unit)
+                        return
+                elif method is cls.floor:
+                    if lb < cls.min._value:
+                        with pytest.raises(err_cls, match=msg):
+                            method(ts, unit)
+                        return
+                elif mod >= diff:
+                    if ub > cls.max._value:
+                        with pytest.raises(err_cls, match=msg):
+                            method(ts, unit)
+                        return
+                elif lb < cls.min._value:
+                    with pytest.raises(err_cls, match=msg):
+                        method(ts, unit)
+                    return
+
+            res = method(ts, unit)
+
+            td = res - ts
+            diff = abs(td._value)
+            assert diff < nanos
+            assert res._value % nanos == 0
+
+            if method is cls.round:
+                assert diff <= nanos / 2
+            elif method is cls.floor:
+                assert res <= ts
+            elif method is cls.ceil:
+                assert res >= ts
+
+        nanos = 1
+        checker(ts, nanos, "ns")
+
+        nanos = 1000
+        checker(ts, nanos, "us")
+
+        nanos = 1_000_000
+        checker(ts, nanos, "ms")
+
+        nanos = 1_000_000_000
+        checker(ts, nanos, "s")
+
+        nanos = 60 * 1_000_000_000
+        checker(ts, nanos, "min")
+
+        nanos = 60 * 60 * 1_000_000_000
+        checker(ts, nanos, "h")
+
+        nanos = 24 * 60 * 60 * 1_000_000_000
+        checker(ts, nanos, "D")

shared/package-files/98/98178982f59c0d90663c54ad0cd12397379963768c0cc0875a88fb7429a0ba04/_constants.py

@@ -0,0 +1,42 @@
+"""
+Statistics-related constants.
+
+"""
+import numpy as np
+
+
+# The smallest representable positive number such that 1.0 + _EPS != 1.0.
+_EPS = np.finfo(float).eps
+
+# The largest [in magnitude] usable floating value.
+_XMAX = np.finfo(float).max
+
+# The log of the largest usable floating value; useful for knowing
+# when exp(something) will overflow
+_LOGXMAX = np.log(_XMAX)
+
+# The smallest [in magnitude] usable (i.e. not subnormal) double precision
+# floating value.
+_XMIN = np.finfo(float).tiny
+
+# The log of the smallest [in magnitude] usable (i.e not subnormal)
+# double precision floating value.
+_LOGXMIN = np.log(_XMIN)
+
+# -special.psi(1)
+_EULER = 0.577215664901532860606512090082402431042
+
+# special.zeta(3, 1)  Apery's constant
+_ZETA3 = 1.202056903159594285399738161511449990765
+
+# sqrt(pi)
+_SQRT_PI = 1.772453850905516027298167483341145182798
+
+# sqrt(2/pi)
+_SQRT_2_OVER_PI = 0.7978845608028654
+
+# log(pi)
+_LOG_PI = 1.1447298858494002
+
+# log(sqrt(2/pi))
+_LOG_SQRT_2_OVER_PI = -0.22579135264472744

shared/package-files/98/9853cf796c52df2ab9b35b415405289e71e7baddefe1b177653f78a612cf4cf0/nan_to_num_ops.h

@@ -0,0 +1,50 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API nan_to_num {
+  using schema = at::Tensor (const at::Tensor &, c10::optional<double>, c10::optional<double>, c10::optional<double>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::nan_to_num")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "nan_to_num(Tensor self, float? nan=None, float? posinf=None, float? neginf=None) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, c10::optional<double> nan, c10::optional<double> posinf, c10::optional<double> neginf);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::optional<double> nan, c10::optional<double> posinf, c10::optional<double> neginf);
+};
+
+struct TORCH_API nan_to_num_ {
+  using schema = at::Tensor & (at::Tensor &, c10::optional<double>, c10::optional<double>, c10::optional<double>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::nan_to_num_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "nan_to_num_(Tensor(a!) self, float? nan=None, float? posinf=None, float? neginf=None) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, c10::optional<double> nan, c10::optional<double> posinf, c10::optional<double> neginf);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, c10::optional<double> nan, c10::optional<double> posinf, c10::optional<double> neginf);
+};
+
+struct TORCH_API nan_to_num_out {
+  using schema = at::Tensor & (const at::Tensor &, c10::optional<double>, c10::optional<double>, c10::optional<double>, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::nan_to_num")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "nan_to_num.out(Tensor self, float? nan=None, float? posinf=None, float? neginf=None, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, c10::optional<double> nan, c10::optional<double> posinf, c10::optional<double> neginf, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::optional<double> nan, c10::optional<double> posinf, c10::optional<double> neginf, at::Tensor & out);
+};
+
+}} // namespace at::_ops

shared/package-files/98/9856346efdad114b43a74ca909e955abf460b5b81403f1d6ee68a452ae9ad3ef/LazyIr.h

@@ -0,0 +1,19 @@
+#pragma once
+
+// This file contains autogenerated LazyTensor IR nodes
+${lazy_ir_sysinc}
+${lazy_ir_inc}
+
+${namespace_prologue}
+using at::operator<<;
+
+// kNullValue is used to contribute a static hash value any time
+// a node has an Optional<Value> input that is nullopt.  It is important
+// to differentiate between HASH(nullopt, something) and HASH(something, nullopt),
+// and using kNullValue in the hash function in the order of arguments
+// serves this purpose.
+static const torch::lazy::Value kNullValue = torch::lazy::Value();
+
+${ir_declarations}
+
+${namespace_epilogue}

shared/package-files/98/987ff0da1e11da62c5fc63ff754af982106f33ae54f2d564fa00b9a4c6125506/conftest.py

@@ -0,0 +1,2065 @@
+"""
+This file is very long and growing, but it was decided to not split it yet, as
+it's still manageable (2020-03-17, ~1.1k LoC). See gh-31989
+
+Instead of splitting it was decided to define sections here:
+- Configuration / Settings
+- Autouse fixtures
+- Common arguments
+- Missing values & co.
+- Classes
+- Indices
+- Series'
+- DataFrames
+- Operators & Operations
+- Data sets/files
+- Time zones
+- Dtypes
+- Misc
+"""
+from __future__ import annotations
+
+from collections import abc
+from datetime import (
+    date,
+    datetime,
+    time,
+    timedelta,
+    timezone,
+)
+from decimal import Decimal
+import operator
+import os
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+)
+
+from dateutil.tz import (
+    tzlocal,
+    tzutc,
+)
+import hypothesis
+from hypothesis import strategies as st
+import numpy as np
+import pytest
+from pytz import (
+    FixedOffset,
+    utc,
+)
+
+from pandas._config.config import _get_option
+
+import pandas.util._test_decorators as td
+
+from pandas.core.dtypes.dtypes import (
+    DatetimeTZDtype,
+    IntervalDtype,
+)
+
+import pandas as pd
+from pandas import (
+    CategoricalIndex,
+    DataFrame,
+    Interval,
+    IntervalIndex,
+    Period,
+    RangeIndex,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+    period_range,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.core import ops
+from pandas.core.indexes.api import (
+    Index,
+    MultiIndex,
+)
+from pandas.util.version import Version
+
+if TYPE_CHECKING:
+    from collections.abc import (
+        Hashable,
+        Iterator,
+    )
+
+try:
+    import pyarrow as pa
+except ImportError:
+    has_pyarrow = False
+else:
+    del pa
+    has_pyarrow = True
+
+import zoneinfo
+
+try:
+    zoneinfo.ZoneInfo("UTC")
+except zoneinfo.ZoneInfoNotFoundError:
+    zoneinfo = None  # type: ignore[assignment]
+
+
+# ----------------------------------------------------------------
+# Configuration / Settings
+# ----------------------------------------------------------------
+# pytest
+
+
+def pytest_addoption(parser) -> None:
+    parser.addoption(
+        "--no-strict-data-files",
+        action="store_false",
+        help="Don't fail if a test is skipped for missing data file.",
+    )
+
+
+def ignore_doctest_warning(item: pytest.Item, path: str, message: str) -> None:
+    """Ignore doctest warning.
+
+    Parameters
+    ----------
+    item : pytest.Item
+        pytest test item.
+    path : str
+        Module path to Python object, e.g. "pandas.core.frame.DataFrame.append". A
+        warning will be filtered when item.name ends with in given path. So it is
+        sufficient to specify e.g. "DataFrame.append".
+    message : str
+        Message to be filtered.
+    """
+    if item.name.endswith(path):
+        item.add_marker(pytest.mark.filterwarnings(f"ignore:{message}"))
+
+
+def pytest_collection_modifyitems(items, config) -> None:
+    is_doctest = config.getoption("--doctest-modules") or config.getoption(
+        "--doctest-cython", default=False
+    )
+
+    # Warnings from doctests that can be ignored; place reason in comment above.
+    # Each entry specifies (path, message) - see the ignore_doctest_warning function
+    ignored_doctest_warnings = [
+        ("is_int64_dtype", "is_int64_dtype is deprecated"),
+        ("is_interval_dtype", "is_interval_dtype is deprecated"),
+        ("is_period_dtype", "is_period_dtype is deprecated"),
+        ("is_datetime64tz_dtype", "is_datetime64tz_dtype is deprecated"),
+        ("is_categorical_dtype", "is_categorical_dtype is deprecated"),
+        ("is_sparse", "is_sparse is deprecated"),
+        ("DataFrameGroupBy.fillna", "DataFrameGroupBy.fillna is deprecated"),
+        ("NDFrame.replace", "The 'method' keyword"),
+        ("NDFrame.replace", "Series.replace without 'value'"),
+        ("NDFrame.clip", "Downcasting behavior in Series and DataFrame methods"),
+        ("Series.idxmin", "The behavior of Series.idxmin"),
+        ("Series.idxmax", "The behavior of Series.idxmax"),
+        ("SeriesGroupBy.fillna", "SeriesGroupBy.fillna is deprecated"),
+        ("SeriesGroupBy.idxmin", "The behavior of Series.idxmin"),
+        ("SeriesGroupBy.idxmax", "The behavior of Series.idxmax"),
+        # Docstring divides by zero to show behavior difference
+        ("missing.mask_zero_div_zero", "divide by zero encountered"),
+        (
+            "to_pydatetime",
+            "The behavior of DatetimeProperties.to_pydatetime is deprecated",
+        ),
+        (
+            "pandas.core.generic.NDFrame.bool",
+            "(Series|DataFrame).bool is now deprecated and will be removed "
+            "in future version of pandas",
+        ),
+        (
+            "pandas.core.generic.NDFrame.first",
+            "first is deprecated and will be removed in a future version. "
+            "Please create a mask and filter using `.loc` instead",
+        ),
+        (
+            "Resampler.fillna",
+            "DatetimeIndexResampler.fillna is deprecated",
+        ),
+        (
+            "DataFrameGroupBy.fillna",
+            "DataFrameGroupBy.fillna with 'method' is deprecated",
+        ),
+        (
+            "DataFrameGroupBy.fillna",
+            "DataFrame.fillna with 'method' is deprecated",
+        ),
+        ("read_parquet", "Passing a BlockManager to DataFrame is deprecated"),
+    ]
+
+    if is_doctest:
+        for item in items:
+            for path, message in ignored_doctest_warnings:
+                ignore_doctest_warning(item, path, message)
+
+
+hypothesis_health_checks = [hypothesis.HealthCheck.too_slow]
+if Version(hypothesis.__version__) >= Version("6.83.2"):
+    hypothesis_health_checks.append(hypothesis.HealthCheck.differing_executors)
+
+# Hypothesis
+hypothesis.settings.register_profile(
+    "ci",
+    # Hypothesis timing checks are tuned for scalars by default, so we bump
+    # them from 200ms to 500ms per test case as the global default.  If this
+    # is too short for a specific test, (a) try to make it faster, and (b)
+    # if it really is slow add `@settings(deadline=...)` with a working value,
+    # or `deadline=None` to entirely disable timeouts for that test.
+    # 2022-02-09: Changed deadline from 500 -> None. Deadline leads to
+    # non-actionable, flaky CI failures (# GH 24641, 44969, 45118, 44969)
+    deadline=None,
+    suppress_health_check=tuple(hypothesis_health_checks),
+)
+hypothesis.settings.load_profile("ci")
+
+# Registering these strategies makes them globally available via st.from_type,
+# which is use for offsets in tests/tseries/offsets/test_offsets_properties.py
+for name in "MonthBegin MonthEnd BMonthBegin BMonthEnd".split():
+    cls = getattr(pd.tseries.offsets, name)
+    st.register_type_strategy(
+        cls, st.builds(cls, n=st.integers(-99, 99), normalize=st.booleans())
+    )
+
+for name in "YearBegin YearEnd BYearBegin BYearEnd".split():
+    cls = getattr(pd.tseries.offsets, name)
+    st.register_type_strategy(
+        cls,
+        st.builds(
+            cls,
+            n=st.integers(-5, 5),
+            normalize=st.booleans(),
+            month=st.integers(min_value=1, max_value=12),
+        ),
+    )
+
+for name in "QuarterBegin QuarterEnd BQuarterBegin BQuarterEnd".split():
+    cls = getattr(pd.tseries.offsets, name)
+    st.register_type_strategy(
+        cls,
+        st.builds(
+            cls,
+            n=st.integers(-24, 24),
+            normalize=st.booleans(),
+            startingMonth=st.integers(min_value=1, max_value=12),
+        ),
+    )
+
+
+# ----------------------------------------------------------------
+# Autouse fixtures
+# ----------------------------------------------------------------
+
+
+# https://github.com/pytest-dev/pytest/issues/11873
+# Would like to avoid autouse=True, but cannot as of pytest 8.0.0
+@pytest.fixture(autouse=True)
+def add_doctest_imports(doctest_namespace) -> None:
+    """
+    Make `np` and `pd` names available for doctests.
+    """
+    doctest_namespace["np"] = np
+    doctest_namespace["pd"] = pd
+
+
+@pytest.fixture(autouse=True)
+def configure_tests() -> None:
+    """
+    Configure settings for all tests and test modules.
+    """
+    pd.set_option("chained_assignment", "raise")
+
+
+# ----------------------------------------------------------------
+# Common arguments
+# ----------------------------------------------------------------
+@pytest.fixture(params=[0, 1, "index", "columns"], ids=lambda x: f"axis={repr(x)}")
+def axis(request):
+    """
+    Fixture for returning the axis numbers of a DataFrame.
+    """
+    return request.param
+
+
+axis_frame = axis
+
+
+@pytest.fixture(params=[1, "columns"], ids=lambda x: f"axis={repr(x)}")
+def axis_1(request):
+    """
+    Fixture for returning aliases of axis 1 of a DataFrame.
+    """
+    return request.param
+
+
+@pytest.fixture(params=[True, False, None])
+def observed(request):
+    """
+    Pass in the observed keyword to groupby for [True, False]
+    This indicates whether categoricals should return values for
+    values which are not in the grouper [False / None], or only values which
+    appear in the grouper [True]. [None] is supported for future compatibility
+    if we decide to change the default (and would need to warn if this
+    parameter is not passed).
+    """
+    return request.param
+
+
+@pytest.fixture(params=[True, False, None])
+def ordered(request):
+    """
+    Boolean 'ordered' parameter for Categorical.
+    """
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def skipna(request):
+    """
+    Boolean 'skipna' parameter.
+    """
+    return request.param
+
+
+@pytest.fixture(params=["first", "last", False])
+def keep(request):
+    """
+    Valid values for the 'keep' parameter used in
+    .duplicated or .drop_duplicates
+    """
+    return request.param
+
+
+@pytest.fixture(params=["both", "neither", "left", "right"])
+def inclusive_endpoints_fixture(request):
+    """
+    Fixture for trying all interval 'inclusive' parameters.
+    """
+    return request.param
+
+
+@pytest.fixture(params=["left", "right", "both", "neither"])
+def closed(request):
+    """
+    Fixture for trying all interval closed parameters.
+    """
+    return request.param
+
+
+@pytest.fixture(params=["left", "right", "both", "neither"])
+def other_closed(request):
+    """
+    Secondary closed fixture to allow parametrizing over all pairs of closed.
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        None,
+        "gzip",
+        "bz2",
+        "zip",
+        "xz",
+        "tar",
+        pytest.param("zstd", marks=td.skip_if_no("zstandard")),
+    ]
+)
+def compression(request):
+    """
+    Fixture for trying common compression types in compression tests.
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        "gzip",
+        "bz2",
+        "zip",
+        "xz",
+        "tar",
+        pytest.param("zstd", marks=td.skip_if_no("zstandard")),
+    ]
+)
+def compression_only(request):
+    """
+    Fixture for trying common compression types in compression tests excluding
+    uncompressed case.
+    """
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def writable(request):
+    """
+    Fixture that an array is writable.
+    """
+    return request.param
+
+
+@pytest.fixture(params=["inner", "outer", "left", "right"])
+def join_type(request):
+    """
+    Fixture for trying all types of join operations.
+    """
+    return request.param
+
+
+@pytest.fixture(params=["nlargest", "nsmallest"])
+def nselect_method(request):
+    """
+    Fixture for trying all nselect methods.
+    """
+    return request.param
+
+
+# ----------------------------------------------------------------
+# Missing values & co.
+# ----------------------------------------------------------------
+@pytest.fixture(params=tm.NULL_OBJECTS, ids=lambda x: type(x).__name__)
+def nulls_fixture(request):
+    """
+    Fixture for each null type in pandas.
+    """
+    return request.param
+
+
+nulls_fixture2 = nulls_fixture  # Generate cartesian product of nulls_fixture
+
+
+@pytest.fixture(params=[None, np.nan, pd.NaT])
+def unique_nulls_fixture(request):
+    """
+    Fixture for each null type in pandas, each null type exactly once.
+    """
+    return request.param
+
+
+# Generate cartesian product of unique_nulls_fixture:
+unique_nulls_fixture2 = unique_nulls_fixture
+
+
+@pytest.fixture(params=tm.NP_NAT_OBJECTS, ids=lambda x: type(x).__name__)
+def np_nat_fixture(request):
+    """
+    Fixture for each NaT type in numpy.
+    """
+    return request.param
+
+
+# Generate cartesian product of np_nat_fixture:
+np_nat_fixture2 = np_nat_fixture
+
+
+# ----------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------
+
+
+@pytest.fixture(params=[DataFrame, Series])
+def frame_or_series(request):
+    """
+    Fixture to parametrize over DataFrame and Series.
+    """
+    return request.param
+
+
+@pytest.fixture(params=[Index, Series], ids=["index", "series"])
+def index_or_series(request):
+    """
+    Fixture to parametrize over Index and Series, made necessary by a mypy
+    bug, giving an error:
+
+    List item 0 has incompatible type "Type[Series]"; expected "Type[PandasObject]"
+
+    See GH#29725
+    """
+    return request.param
+
+
+# Generate cartesian product of index_or_series fixture:
+index_or_series2 = index_or_series
+
+
+@pytest.fixture(params=[Index, Series, pd.array], ids=["index", "series", "array"])
+def index_or_series_or_array(request):
+    """
+    Fixture to parametrize over Index, Series, and ExtensionArray
+    """
+    return request.param
+
+
+@pytest.fixture(params=[Index, Series, DataFrame, pd.array], ids=lambda x: x.__name__)
+def box_with_array(request):
+    """
+    Fixture to test behavior for Index, Series, DataFrame, and pandas Array
+    classes
+    """
+    return request.param
+
+
+box_with_array2 = box_with_array
+
+
+@pytest.fixture
+def dict_subclass() -> type[dict]:
+    """
+    Fixture for a dictionary subclass.
+    """
+
+    class TestSubDict(dict):
+        def __init__(self, *args, **kwargs) -> None:
+            dict.__init__(self, *args, **kwargs)
+
+    return TestSubDict
+
+
+@pytest.fixture
+def non_dict_mapping_subclass() -> type[abc.Mapping]:
+    """
+    Fixture for a non-mapping dictionary subclass.
+    """
+
+    class TestNonDictMapping(abc.Mapping):
+        def __init__(self, underlying_dict) -> None:
+            self._data = underlying_dict
+
+        def __getitem__(self, key):
+            return self._data.__getitem__(key)
+
+        def __iter__(self) -> Iterator:
+            return self._data.__iter__()
+
+        def __len__(self) -> int:
+            return self._data.__len__()
+
+    return TestNonDictMapping
+
+
+# ----------------------------------------------------------------
+# Indices
+# ----------------------------------------------------------------
+@pytest.fixture
+def multiindex_year_month_day_dataframe_random_data():
+    """
+    DataFrame with 3 level MultiIndex (year, month, day) covering
+    first 100 business days from 2000-01-01 with random data
+    """
+    tdf = DataFrame(
+        np.random.default_rng(2).standard_normal((100, 4)),
+        columns=Index(list("ABCD")),
+        index=date_range("2000-01-01", periods=100, freq="B"),
+    )
+    ymd = tdf.groupby([lambda x: x.year, lambda x: x.month, lambda x: x.day]).sum()
+    # use int64 Index, to make sure things work
+    ymd.index = ymd.index.set_levels([lev.astype("i8") for lev in ymd.index.levels])
+    ymd.index.set_names(["year", "month", "day"], inplace=True)
+    return ymd
+
+
+@pytest.fixture
+def lexsorted_two_level_string_multiindex() -> MultiIndex:
+    """
+    2-level MultiIndex, lexsorted, with string names.
+    """
+    return MultiIndex(
+        levels=[["foo", "bar", "baz", "qux"], ["one", "two", "three"]],
+        codes=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3], [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]],
+        names=["first", "second"],
+    )
+
+
+@pytest.fixture
+def multiindex_dataframe_random_data(
+    lexsorted_two_level_string_multiindex,
+) -> DataFrame:
+    """DataFrame with 2 level MultiIndex with random data"""
+    index = lexsorted_two_level_string_multiindex
+    return DataFrame(
+        np.random.default_rng(2).standard_normal((10, 3)),
+        index=index,
+        columns=Index(["A", "B", "C"], name="exp"),
+    )
+
+
+def _create_multiindex():
+    """
+    MultiIndex used to test the general functionality of this object
+    """
+
+    # See Also: tests.multi.conftest.idx
+    major_axis = Index(["foo", "bar", "baz", "qux"])
+    minor_axis = Index(["one", "two"])
+
+    major_codes = np.array([0, 0, 1, 2, 3, 3])
+    minor_codes = np.array([0, 1, 0, 1, 0, 1])
+    index_names = ["first", "second"]
+    return MultiIndex(
+        levels=[major_axis, minor_axis],
+        codes=[major_codes, minor_codes],
+        names=index_names,
+        verify_integrity=False,
+    )
+
+
+def _create_mi_with_dt64tz_level():
+    """
+    MultiIndex with a level that is a tzaware DatetimeIndex.
+    """
+    # GH#8367 round trip with pickle
+    return MultiIndex.from_product(
+        [[1, 2], ["a", "b"], date_range("20130101", periods=3, tz="US/Eastern")],
+        names=["one", "two", "three"],
+    )
+
+
+indices_dict = {
+    "object": Index([f"pandas_{i}" for i in range(100)], dtype=object),
+    "string": Index([f"pandas_{i}" for i in range(100)], dtype="str"),
+    "datetime": date_range("2020-01-01", periods=100),
+    "datetime-tz": date_range("2020-01-01", periods=100, tz="US/Pacific"),
+    "period": period_range("2020-01-01", periods=100, freq="D"),
+    "timedelta": timedelta_range(start="1 day", periods=100, freq="D"),
+    "range": RangeIndex(100),
+    "int8": Index(np.arange(100), dtype="int8"),
+    "int16": Index(np.arange(100), dtype="int16"),
+    "int32": Index(np.arange(100), dtype="int32"),
+    "int64": Index(np.arange(100), dtype="int64"),
+    "uint8": Index(np.arange(100), dtype="uint8"),
+    "uint16": Index(np.arange(100), dtype="uint16"),
+    "uint32": Index(np.arange(100), dtype="uint32"),
+    "uint64": Index(np.arange(100), dtype="uint64"),
+    "float32": Index(np.arange(100), dtype="float32"),
+    "float64": Index(np.arange(100), dtype="float64"),
+    "bool-object": Index([True, False] * 5, dtype=object),
+    "bool-dtype": Index([True, False] * 5, dtype=bool),
+    "complex64": Index(
+        np.arange(100, dtype="complex64") + 1.0j * np.arange(100, dtype="complex64")
+    ),
+    "complex128": Index(
+        np.arange(100, dtype="complex128") + 1.0j * np.arange(100, dtype="complex128")
+    ),
+    "categorical": CategoricalIndex(list("abcd") * 25),
+    "interval": IntervalIndex.from_breaks(np.linspace(0, 100, num=101)),
+    "empty": Index([]),
+    "tuples": MultiIndex.from_tuples(zip(["foo", "bar", "baz"], [1, 2, 3])),
+    "mi-with-dt64tz-level": _create_mi_with_dt64tz_level(),
+    "multi": _create_multiindex(),
+    "repeats": Index([0, 0, 1, 1, 2, 2]),
+    "nullable_int": Index(np.arange(100), dtype="Int64"),
+    "nullable_uint": Index(np.arange(100), dtype="UInt16"),
+    "nullable_float": Index(np.arange(100), dtype="Float32"),
+    "nullable_bool": Index(np.arange(100).astype(bool), dtype="boolean"),
+    "string-python": Index(
+        pd.array([f"pandas_{i}" for i in range(100)], dtype="string[python]")
+    ),
+}
+if has_pyarrow:
+    idx = Index(pd.array([f"pandas_{i}" for i in range(100)], dtype="string[pyarrow]"))
+    indices_dict["string-pyarrow"] = idx
+
+
+@pytest.fixture(params=indices_dict.keys())
+def index(request):
+    """
+    Fixture for many "simple" kinds of indices.
+
+    These indices are unlikely to cover corner cases, e.g.
+        - no names
+        - no NaTs/NaNs
+        - no values near implementation bounds
+        - ...
+    """
+    # copy to avoid mutation, e.g. setting .name
+    return indices_dict[request.param].copy()
+
+
+# Needed to generate cartesian product of indices
+index_fixture2 = index
+
+
+@pytest.fixture(
+    params=[
+        key for key, value in indices_dict.items() if not isinstance(value, MultiIndex)
+    ]
+)
+def index_flat(request):
+    """
+    index fixture, but excluding MultiIndex cases.
+    """
+    key = request.param
+    return indices_dict[key].copy()
+
+
+# Alias so we can test with cartesian product of index_flat
+index_flat2 = index_flat
+
+
+@pytest.fixture(
+    params=[
+        key
+        for key, value in indices_dict.items()
+        if not (
+            key.startswith(("int", "uint", "float"))
+            or key in ["range", "empty", "repeats", "bool-dtype"]
+        )
+        and not isinstance(value, MultiIndex)
+    ]
+)
+def index_with_missing(request):
+    """
+    Fixture for indices with missing values.
+
+    Integer-dtype and empty cases are excluded because they cannot hold missing
+    values.
+
+    MultiIndex is excluded because isna() is not defined for MultiIndex.
+    """
+
+    # GH 35538. Use deep copy to avoid illusive bug on np-dev
+    # GHA pipeline that writes into indices_dict despite copy
+    ind = indices_dict[request.param].copy(deep=True)
+    vals = ind.values.copy()
+    if request.param in ["tuples", "mi-with-dt64tz-level", "multi"]:
+        # For setting missing values in the top level of MultiIndex
+        vals = ind.tolist()
+        vals[0] = (None,) + vals[0][1:]
+        vals[-1] = (None,) + vals[-1][1:]
+        return MultiIndex.from_tuples(vals)
+    else:
+        vals[0] = None
+        vals[-1] = None
+        return type(ind)(vals)
+
+
+# ----------------------------------------------------------------
+# Series'
+# ----------------------------------------------------------------
+@pytest.fixture
+def string_series() -> Series:
+    """
+    Fixture for Series of floats with Index of unique strings
+    """
+    return Series(
+        np.arange(30, dtype=np.float64) * 1.1,
+        index=Index([f"i_{i}" for i in range(30)]),
+        name="series",
+    )
+
+
+@pytest.fixture
+def object_series() -> Series:
+    """
+    Fixture for Series of dtype object with Index of unique strings
+    """
+    data = [f"foo_{i}" for i in range(30)]
+    index = Index([f"bar_{i}" for i in range(30)])
+    return Series(data, index=index, name="objects", dtype=object)
+
+
+@pytest.fixture
+def datetime_series() -> Series:
+    """
+    Fixture for Series of floats with DatetimeIndex
+    """
+    return Series(
+        np.random.default_rng(2).standard_normal(30),
+        index=date_range("2000-01-01", periods=30, freq="B"),
+        name="ts",
+    )
+
+
+def _create_series(index):
+    """Helper for the _series dict"""
+    size = len(index)
+    data = np.random.default_rng(2).standard_normal(size)
+    return Series(data, index=index, name="a", copy=False)
+
+
+_series = {
+    f"series-with-{index_id}-index": _create_series(index)
+    for index_id, index in indices_dict.items()
+}
+
+
+@pytest.fixture
+def series_with_simple_index(index) -> Series:
+    """
+    Fixture for tests on series with changing types of indices.
+    """
+    return _create_series(index)
+
+
+_narrow_series = {
+    f"{dtype.__name__}-series": Series(
+        range(30), index=[f"i-{i}" for i in range(30)], name="a", dtype=dtype
+    )
+    for dtype in tm.NARROW_NP_DTYPES
+}
+
+
+_index_or_series_objs = {**indices_dict, **_series, **_narrow_series}
+
+
+@pytest.fixture(params=_index_or_series_objs.keys())
+def index_or_series_obj(request):
+    """
+    Fixture for tests on indexes, series and series with a narrow dtype
+    copy to avoid mutation, e.g. setting .name
+    """
+    return _index_or_series_objs[request.param].copy(deep=True)
+
+
+_typ_objects_series = {
+    f"{dtype.__name__}-series": Series(dtype) for dtype in tm.PYTHON_DATA_TYPES
+}
+
+
+_index_or_series_memory_objs = {
+    **indices_dict,
+    **_series,
+    **_narrow_series,
+    **_typ_objects_series,
+}
+
+
+@pytest.fixture(params=_index_or_series_memory_objs.keys())
+def index_or_series_memory_obj(request):
+    """
+    Fixture for tests on indexes, series, series with a narrow dtype and
+    series with empty objects type
+    copy to avoid mutation, e.g. setting .name
+    """
+    return _index_or_series_memory_objs[request.param].copy(deep=True)
+
+
+# ----------------------------------------------------------------
+# DataFrames
+# ----------------------------------------------------------------
+@pytest.fixture
+def int_frame() -> DataFrame:
+    """
+    Fixture for DataFrame of ints with index of unique strings
+
+    Columns are ['A', 'B', 'C', 'D']
+    """
+    return DataFrame(
+        np.ones((30, 4), dtype=np.int64),
+        index=Index([f"foo_{i}" for i in range(30)]),
+        columns=Index(list("ABCD")),
+    )
+
+
+@pytest.fixture
+def float_frame() -> DataFrame:
+    """
+    Fixture for DataFrame of floats with index of unique strings
+
+    Columns are ['A', 'B', 'C', 'D'].
+    """
+    return DataFrame(
+        np.random.default_rng(2).standard_normal((30, 4)),
+        index=Index([f"foo_{i}" for i in range(30)]),
+        columns=Index(list("ABCD")),
+    )
+
+
+@pytest.fixture
+def rand_series_with_duplicate_datetimeindex() -> Series:
+    """
+    Fixture for Series with a DatetimeIndex that has duplicates.
+    """
+    dates = [
+        datetime(2000, 1, 2),
+        datetime(2000, 1, 2),
+        datetime(2000, 1, 2),
+        datetime(2000, 1, 3),
+        datetime(2000, 1, 3),
+        datetime(2000, 1, 3),
+        datetime(2000, 1, 4),
+        datetime(2000, 1, 4),
+        datetime(2000, 1, 4),
+        datetime(2000, 1, 5),
+    ]
+
+    return Series(np.random.default_rng(2).standard_normal(len(dates)), index=dates)
+
+
+# ----------------------------------------------------------------
+# Scalars
+# ----------------------------------------------------------------
+@pytest.fixture(
+    params=[
+        (Interval(left=0, right=5), IntervalDtype("int64", "right")),
+        (Interval(left=0.1, right=0.5), IntervalDtype("float64", "right")),
+        (Period("2012-01", freq="M"), "period[M]"),
+        (Period("2012-02-01", freq="D"), "period[D]"),
+        (
+            Timestamp("2011-01-01", tz="US/Eastern"),
+            DatetimeTZDtype(unit="s", tz="US/Eastern"),
+        ),
+        (Timedelta(seconds=500), "timedelta64[ns]"),
+    ]
+)
+def ea_scalar_and_dtype(request):
+    return request.param
+
+
+# ----------------------------------------------------------------
+# Operators & Operations
+# ----------------------------------------------------------------
+
+
+@pytest.fixture(params=tm.arithmetic_dunder_methods)
+def all_arithmetic_operators(request):
+    """
+    Fixture for dunder names for common arithmetic operations.
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        operator.add,
+        ops.radd,
+        operator.sub,
+        ops.rsub,
+        operator.mul,
+        ops.rmul,
+        operator.truediv,
+        ops.rtruediv,
+        operator.floordiv,
+        ops.rfloordiv,
+        operator.mod,
+        ops.rmod,
+        operator.pow,
+        ops.rpow,
+        operator.eq,
+        operator.ne,
+        operator.lt,
+        operator.le,
+        operator.gt,
+        operator.ge,
+        operator.and_,
+        ops.rand_,
+        operator.xor,
+        ops.rxor,
+        operator.or_,
+        ops.ror_,
+    ]
+)
+def all_binary_operators(request):
+    """
+    Fixture for operator and roperator arithmetic, comparison, and logical ops.
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        operator.add,
+        ops.radd,
+        operator.sub,
+        ops.rsub,
+        operator.mul,
+        ops.rmul,
+        operator.truediv,
+        ops.rtruediv,
+        operator.floordiv,
+        ops.rfloordiv,
+        operator.mod,
+        ops.rmod,
+        operator.pow,
+        ops.rpow,
+    ]
+)
+def all_arithmetic_functions(request):
+    """
+    Fixture for operator and roperator arithmetic functions.
+
+    Notes
+    -----
+    This includes divmod and rdivmod, whereas all_arithmetic_operators
+    does not.
+    """
+    return request.param
+
+
+_all_numeric_reductions = [
+    "count",
+    "sum",
+    "max",
+    "min",
+    "mean",
+    "prod",
+    "std",
+    "var",
+    "median",
+    "kurt",
+    "skew",
+    "sem",
+]
+
+
+@pytest.fixture(params=_all_numeric_reductions)
+def all_numeric_reductions(request):
+    """
+    Fixture for numeric reduction names.
+    """
+    return request.param
+
+
+_all_boolean_reductions = ["all", "any"]
+
+
+@pytest.fixture(params=_all_boolean_reductions)
+def all_boolean_reductions(request):
+    """
+    Fixture for boolean reduction names.
+    """
+    return request.param
+
+
+_all_reductions = _all_numeric_reductions + _all_boolean_reductions
+
+
+@pytest.fixture(params=_all_reductions)
+def all_reductions(request):
+    """
+    Fixture for all (boolean + numeric) reduction names.
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        operator.eq,
+        operator.ne,
+        operator.gt,
+        operator.ge,
+        operator.lt,
+        operator.le,
+    ]
+)
+def comparison_op(request):
+    """
+    Fixture for operator module comparison functions.
+    """
+    return request.param
+
+
+@pytest.fixture(params=["__le__", "__lt__", "__ge__", "__gt__"])
+def compare_operators_no_eq_ne(request):
+    """
+    Fixture for dunder names for compare operations except == and !=
+
+    * >=
+    * >
+    * <
+    * <=
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=["__and__", "__rand__", "__or__", "__ror__", "__xor__", "__rxor__"]
+)
+def all_logical_operators(request):
+    """
+    Fixture for dunder names for common logical operations
+
+    * |
+    * &
+    * ^
+    """
+    return request.param
+
+
+_all_numeric_accumulations = ["cumsum", "cumprod", "cummin", "cummax"]
+
+
+@pytest.fixture(params=_all_numeric_accumulations)
+def all_numeric_accumulations(request):
+    """
+    Fixture for numeric accumulation names
+    """
+    return request.param
+
+
+# ----------------------------------------------------------------
+# Data sets/files
+# ----------------------------------------------------------------
+@pytest.fixture
+def strict_data_files(pytestconfig):
+    """
+    Returns the configuration for the test setting `--no-strict-data-files`.
+    """
+    return pytestconfig.getoption("--no-strict-data-files")
+
+
+@pytest.fixture
+def datapath(strict_data_files: str) -> Callable[..., str]:
+    """
+    Get the path to a data file.
+
+    Parameters
+    ----------
+    path : str
+        Path to the file, relative to ``pandas/tests/``
+
+    Returns
+    -------
+    path including ``pandas/tests``.
+
+    Raises
+    ------
+    ValueError
+        If the path doesn't exist and the --no-strict-data-files option is not set.
+    """
+    BASE_PATH = os.path.join(os.path.dirname(__file__), "tests")
+
+    def deco(*args):
+        path = os.path.join(BASE_PATH, *args)
+        if not os.path.exists(path):
+            if strict_data_files:
+                raise ValueError(
+                    f"Could not find file {path} and --no-strict-data-files is not set."
+                )
+            pytest.skip(f"Could not find {path}.")
+        return path
+
+    return deco
+
+
+# ----------------------------------------------------------------
+# Time zones
+# ----------------------------------------------------------------
+TIMEZONES = [
+    None,
+    "UTC",
+    "US/Eastern",
+    "Asia/Tokyo",
+    "dateutil/US/Pacific",
+    "dateutil/Asia/Singapore",
+    "+01:15",
+    "-02:15",
+    "UTC+01:15",
+    "UTC-02:15",
+    tzutc(),
+    tzlocal(),
+    FixedOffset(300),
+    FixedOffset(0),
+    FixedOffset(-300),
+    timezone.utc,
+    timezone(timedelta(hours=1)),
+    timezone(timedelta(hours=-1), name="foo"),
+]
+if zoneinfo is not None:
+    TIMEZONES.extend(
+        [
+            zoneinfo.ZoneInfo("US/Pacific"),  # type: ignore[list-item]
+            zoneinfo.ZoneInfo("UTC"),  # type: ignore[list-item]
+        ]
+    )
+TIMEZONE_IDS = [repr(i) for i in TIMEZONES]
+
+
+@td.parametrize_fixture_doc(str(TIMEZONE_IDS))
+@pytest.fixture(params=TIMEZONES, ids=TIMEZONE_IDS)
+def tz_naive_fixture(request):
+    """
+    Fixture for trying timezones including default (None): {0}
+    """
+    return request.param
+
+
+@td.parametrize_fixture_doc(str(TIMEZONE_IDS[1:]))
+@pytest.fixture(params=TIMEZONES[1:], ids=TIMEZONE_IDS[1:])
+def tz_aware_fixture(request):
+    """
+    Fixture for trying explicit timezones: {0}
+    """
+    return request.param
+
+
+# Generate cartesian product of tz_aware_fixture:
+tz_aware_fixture2 = tz_aware_fixture
+
+
+_UTCS = ["utc", "dateutil/UTC", utc, tzutc(), timezone.utc]
+if zoneinfo is not None:
+    _UTCS.append(zoneinfo.ZoneInfo("UTC"))
+
+
+@pytest.fixture(params=_UTCS)
+def utc_fixture(request):
+    """
+    Fixture to provide variants of UTC timezone strings and tzinfo objects.
+    """
+    return request.param
+
+
+utc_fixture2 = utc_fixture
+
+
+@pytest.fixture(params=["s", "ms", "us", "ns"])
+def unit(request):
+    """
+    datetime64 units we support.
+    """
+    return request.param
+
+
+unit2 = unit
+
+
+# ----------------------------------------------------------------
+# Dtypes
+# ----------------------------------------------------------------
+@pytest.fixture(params=tm.STRING_DTYPES)
+def string_dtype(request):
+    """
+    Parametrized fixture for string dtypes.
+
+    * str
+    * 'str'
+    * 'U'
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        ("python", pd.NA),
+        pytest.param(("pyarrow", pd.NA), marks=td.skip_if_no("pyarrow")),
+        pytest.param(("pyarrow", np.nan), marks=td.skip_if_no("pyarrow")),
+        ("python", np.nan),
+    ],
+    ids=[
+        "string=string[python]",
+        "string=string[pyarrow]",
+        "string=str[pyarrow]",
+        "string=str[python]",
+    ],
+)
+def string_dtype_no_object(request):
+    """
+    Parametrized fixture for string dtypes.
+    * 'string[python]' (NA variant)
+    * 'string[pyarrow]' (NA variant)
+    * 'str' (NaN variant, with pyarrow)
+    * 'str' (NaN variant, without pyarrow)
+    """
+    # need to instantiate the StringDtype here instead of in the params
+    # to avoid importing pyarrow during test collection
+    storage, na_value = request.param
+    return pd.StringDtype(storage, na_value)
+
+
+@pytest.fixture(
+    params=[
+        "string[python]",
+        pytest.param("string[pyarrow]", marks=td.skip_if_no("pyarrow")),
+    ]
+)
+def nullable_string_dtype(request):
+    """
+    Parametrized fixture for string dtypes.
+
+    * 'string[python]'
+    * 'string[pyarrow]'
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        pytest.param(("pyarrow", np.nan), marks=td.skip_if_no("pyarrow")),
+        pytest.param(("pyarrow", pd.NA), marks=td.skip_if_no("pyarrow")),
+    ]
+)
+def pyarrow_string_dtype(request):
+    """
+    Parametrized fixture for string dtypes backed by Pyarrow.
+
+    * 'str[pyarrow]'
+    * 'string[pyarrow]'
+    """
+    return pd.StringDtype(*request.param)
+
+
+@pytest.fixture(
+    params=[
+        "python",
+        pytest.param("pyarrow", marks=td.skip_if_no("pyarrow")),
+    ]
+)
+def string_storage(request):
+    """
+    Parametrized fixture for pd.options.mode.string_storage.
+
+    * 'python'
+    * 'pyarrow'
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        ("python", pd.NA),
+        pytest.param(("pyarrow", pd.NA), marks=td.skip_if_no("pyarrow")),
+        pytest.param(("pyarrow", np.nan), marks=td.skip_if_no("pyarrow")),
+        ("python", np.nan),
+    ],
+    ids=[
+        "string=string[python]",
+        "string=string[pyarrow]",
+        "string=str[pyarrow]",
+        "string=str[python]",
+    ],
+)
+def string_dtype_arguments(request):
+    """
+    Parametrized fixture for StringDtype storage and na_value.
+
+    * 'python' + pd.NA
+    * 'pyarrow' + pd.NA
+    * 'pyarrow' + np.nan
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        "numpy_nullable",
+        pytest.param("pyarrow", marks=td.skip_if_no("pyarrow")),
+    ]
+)
+def dtype_backend(request):
+    """
+    Parametrized fixture for pd.options.mode.string_storage.
+
+    * 'python'
+    * 'pyarrow'
+    """
+    return request.param
+
+
+# Alias so we can test with cartesian product of string_storage
+string_storage2 = string_storage
+string_dtype_arguments2 = string_dtype_arguments
+
+
+@pytest.fixture(params=tm.BYTES_DTYPES)
+def bytes_dtype(request):
+    """
+    Parametrized fixture for bytes dtypes.
+
+    * bytes
+    * 'bytes'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.OBJECT_DTYPES)
+def object_dtype(request):
+    """
+    Parametrized fixture for object dtypes.
+
+    * object
+    * 'object'
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        np.dtype("object"),
+        ("python", pd.NA),
+        pytest.param(("pyarrow", pd.NA), marks=td.skip_if_no("pyarrow")),
+        pytest.param(("pyarrow", np.nan), marks=td.skip_if_no("pyarrow")),
+        ("python", np.nan),
+    ],
+    ids=[
+        "string=object",
+        "string=string[python]",
+        "string=string[pyarrow]",
+        "string=str[pyarrow]",
+        "string=str[python]",
+    ],
+)
+def any_string_dtype(request):
+    """
+    Parametrized fixture for string dtypes.
+    * 'object'
+    * 'string[python]' (NA variant)
+    * 'string[pyarrow]' (NA variant)
+    * 'str' (NaN variant, with pyarrow)
+    * 'str' (NaN variant, without pyarrow)
+    """
+    if isinstance(request.param, np.dtype):
+        return request.param
+    else:
+        # need to instantiate the StringDtype here instead of in the params
+        # to avoid importing pyarrow during test collection
+        storage, na_value = request.param
+        return pd.StringDtype(storage, na_value)
+
+
+@pytest.fixture(params=tm.DATETIME64_DTYPES)
+def datetime64_dtype(request):
+    """
+    Parametrized fixture for datetime64 dtypes.
+
+    * 'datetime64[ns]'
+    * 'M8[ns]'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.TIMEDELTA64_DTYPES)
+def timedelta64_dtype(request):
+    """
+    Parametrized fixture for timedelta64 dtypes.
+
+    * 'timedelta64[ns]'
+    * 'm8[ns]'
+    """
+    return request.param
+
+
+@pytest.fixture
+def fixed_now_ts() -> Timestamp:
+    """
+    Fixture emits fixed Timestamp.now()
+    """
+    return Timestamp(  # pyright: ignore[reportGeneralTypeIssues]
+        year=2021, month=1, day=1, hour=12, minute=4, second=13, microsecond=22
+    )
+
+
+@pytest.fixture(params=tm.FLOAT_NUMPY_DTYPES)
+def float_numpy_dtype(request):
+    """
+    Parameterized fixture for float dtypes.
+
+    * float
+    * 'float32'
+    * 'float64'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.FLOAT_EA_DTYPES)
+def float_ea_dtype(request):
+    """
+    Parameterized fixture for float dtypes.
+
+    * 'Float32'
+    * 'Float64'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.ALL_FLOAT_DTYPES)
+def any_float_dtype(request):
+    """
+    Parameterized fixture for float dtypes.
+
+    * float
+    * 'float32'
+    * 'float64'
+    * 'Float32'
+    * 'Float64'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.COMPLEX_DTYPES)
+def complex_dtype(request):
+    """
+    Parameterized fixture for complex dtypes.
+
+    * complex
+    * 'complex64'
+    * 'complex128'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.COMPLEX_FLOAT_DTYPES)
+def complex_or_float_dtype(request):
+    """
+    Parameterized fixture for complex and numpy float dtypes.
+
+    * complex
+    * 'complex64'
+    * 'complex128'
+    * float
+    * 'float32'
+    * 'float64'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.SIGNED_INT_NUMPY_DTYPES)
+def any_signed_int_numpy_dtype(request):
+    """
+    Parameterized fixture for signed integer dtypes.
+
+    * int
+    * 'int8'
+    * 'int16'
+    * 'int32'
+    * 'int64'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.UNSIGNED_INT_NUMPY_DTYPES)
+def any_unsigned_int_numpy_dtype(request):
+    """
+    Parameterized fixture for unsigned integer dtypes.
+
+    * 'uint8'
+    * 'uint16'
+    * 'uint32'
+    * 'uint64'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.ALL_INT_NUMPY_DTYPES)
+def any_int_numpy_dtype(request):
+    """
+    Parameterized fixture for any integer dtype.
+
+    * int
+    * 'int8'
+    * 'uint8'
+    * 'int16'
+    * 'uint16'
+    * 'int32'
+    * 'uint32'
+    * 'int64'
+    * 'uint64'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.ALL_INT_EA_DTYPES)
+def any_int_ea_dtype(request):
+    """
+    Parameterized fixture for any nullable integer dtype.
+
+    * 'UInt8'
+    * 'Int8'
+    * 'UInt16'
+    * 'Int16'
+    * 'UInt32'
+    * 'Int32'
+    * 'UInt64'
+    * 'Int64'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.ALL_INT_DTYPES)
+def any_int_dtype(request):
+    """
+    Parameterized fixture for any nullable integer dtype.
+
+    * int
+    * 'int8'
+    * 'uint8'
+    * 'int16'
+    * 'uint16'
+    * 'int32'
+    * 'uint32'
+    * 'int64'
+    * 'uint64'
+    * 'UInt8'
+    * 'Int8'
+    * 'UInt16'
+    * 'Int16'
+    * 'UInt32'
+    * 'Int32'
+    * 'UInt64'
+    * 'Int64'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.ALL_INT_EA_DTYPES + tm.FLOAT_EA_DTYPES)
+def any_numeric_ea_dtype(request):
+    """
+    Parameterized fixture for any nullable integer dtype and
+    any float ea dtypes.
+
+    * 'UInt8'
+    * 'Int8'
+    * 'UInt16'
+    * 'Int16'
+    * 'UInt32'
+    * 'Int32'
+    * 'UInt64'
+    * 'Int64'
+    * 'Float32'
+    * 'Float64'
+    """
+    return request.param
+
+
+#  Unsupported operand types for + ("List[Union[str, ExtensionDtype, dtype[Any],
+#  Type[object]]]" and "List[str]")
+@pytest.fixture(
+    params=tm.ALL_INT_EA_DTYPES
+    + tm.FLOAT_EA_DTYPES
+    + tm.ALL_INT_PYARROW_DTYPES_STR_REPR
+    + tm.FLOAT_PYARROW_DTYPES_STR_REPR  # type: ignore[operator]
+)
+def any_numeric_ea_and_arrow_dtype(request):
+    """
+    Parameterized fixture for any nullable integer dtype and
+    any float ea dtypes.
+
+    * 'UInt8'
+    * 'Int8'
+    * 'UInt16'
+    * 'Int16'
+    * 'UInt32'
+    * 'Int32'
+    * 'UInt64'
+    * 'Int64'
+    * 'Float32'
+    * 'Float64'
+    * 'uint8[pyarrow]'
+    * 'int8[pyarrow]'
+    * 'uint16[pyarrow]'
+    * 'int16[pyarrow]'
+    * 'uint32[pyarrow]'
+    * 'int32[pyarrow]'
+    * 'uint64[pyarrow]'
+    * 'int64[pyarrow]'
+    * 'float32[pyarrow]'
+    * 'float64[pyarrow]'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.SIGNED_INT_EA_DTYPES)
+def any_signed_int_ea_dtype(request):
+    """
+    Parameterized fixture for any signed nullable integer dtype.
+
+    * 'Int8'
+    * 'Int16'
+    * 'Int32'
+    * 'Int64'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.ALL_REAL_NUMPY_DTYPES)
+def any_real_numpy_dtype(request):
+    """
+    Parameterized fixture for any (purely) real numeric dtype.
+
+    * int
+    * 'int8'
+    * 'uint8'
+    * 'int16'
+    * 'uint16'
+    * 'int32'
+    * 'uint32'
+    * 'int64'
+    * 'uint64'
+    * float
+    * 'float32'
+    * 'float64'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.ALL_REAL_DTYPES)
+def any_real_numeric_dtype(request):
+    """
+    Parameterized fixture for any (purely) real numeric dtype.
+
+    * int
+    * 'int8'
+    * 'uint8'
+    * 'int16'
+    * 'uint16'
+    * 'int32'
+    * 'uint32'
+    * 'int64'
+    * 'uint64'
+    * float
+    * 'float32'
+    * 'float64'
+
+    and associated ea dtypes.
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.ALL_NUMPY_DTYPES)
+def any_numpy_dtype(request):
+    """
+    Parameterized fixture for all numpy dtypes.
+
+    * bool
+    * 'bool'
+    * int
+    * 'int8'
+    * 'uint8'
+    * 'int16'
+    * 'uint16'
+    * 'int32'
+    * 'uint32'
+    * 'int64'
+    * 'uint64'
+    * float
+    * 'float32'
+    * 'float64'
+    * complex
+    * 'complex64'
+    * 'complex128'
+    * str
+    * 'str'
+    * 'U'
+    * bytes
+    * 'bytes'
+    * 'datetime64[ns]'
+    * 'M8[ns]'
+    * 'timedelta64[ns]'
+    * 'm8[ns]'
+    * object
+    * 'object'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.ALL_REAL_NULLABLE_DTYPES)
+def any_real_nullable_dtype(request):
+    """
+    Parameterized fixture for all real dtypes that can hold NA.
+
+    * float
+    * 'float32'
+    * 'float64'
+    * 'Float32'
+    * 'Float64'
+    * 'UInt8'
+    * 'UInt16'
+    * 'UInt32'
+    * 'UInt64'
+    * 'Int8'
+    * 'Int16'
+    * 'Int32'
+    * 'Int64'
+    * 'uint8[pyarrow]'
+    * 'uint16[pyarrow]'
+    * 'uint32[pyarrow]'
+    * 'uint64[pyarrow]'
+    * 'int8[pyarrow]'
+    * 'int16[pyarrow]'
+    * 'int32[pyarrow]'
+    * 'int64[pyarrow]'
+    * 'float[pyarrow]'
+    * 'double[pyarrow]'
+    """
+    return request.param
+
+
+@pytest.fixture(params=tm.ALL_NUMERIC_DTYPES)
+def any_numeric_dtype(request):
+    """
+    Parameterized fixture for all numeric dtypes.
+
+    * int
+    * 'int8'
+    * 'uint8'
+    * 'int16'
+    * 'uint16'
+    * 'int32'
+    * 'uint32'
+    * 'int64'
+    * 'uint64'
+    * float
+    * 'float32'
+    * 'float64'
+    * complex
+    * 'complex64'
+    * 'complex128'
+    * 'UInt8'
+    * 'Int8'
+    * 'UInt16'
+    * 'Int16'
+    * 'UInt32'
+    * 'Int32'
+    * 'UInt64'
+    * 'Int64'
+    * 'Float32'
+    * 'Float64'
+    """
+    return request.param
+
+
+# categoricals are handled separately
+_any_skipna_inferred_dtype = [
+    ("string", ["a", np.nan, "c"]),
+    ("string", ["a", pd.NA, "c"]),
+    ("mixed", ["a", pd.NaT, "c"]),  # pd.NaT not considered valid by is_string_array
+    ("bytes", [b"a", np.nan, b"c"]),
+    ("empty", [np.nan, np.nan, np.nan]),
+    ("empty", []),
+    ("mixed-integer", ["a", np.nan, 2]),
+    ("mixed", ["a", np.nan, 2.0]),
+    ("floating", [1.0, np.nan, 2.0]),
+    ("integer", [1, np.nan, 2]),
+    ("mixed-integer-float", [1, np.nan, 2.0]),
+    ("decimal", [Decimal(1), np.nan, Decimal(2)]),
+    ("boolean", [True, np.nan, False]),
+    ("boolean", [True, pd.NA, False]),
+    ("datetime64", [np.datetime64("2013-01-01"), np.nan, np.datetime64("2018-01-01")]),
+    ("datetime", [Timestamp("20130101"), np.nan, Timestamp("20180101")]),
+    ("date", [date(2013, 1, 1), np.nan, date(2018, 1, 1)]),
+    ("complex", [1 + 1j, np.nan, 2 + 2j]),
+    # The following dtype is commented out due to GH 23554
+    # ('timedelta64', [np.timedelta64(1, 'D'),
+    #                  np.nan, np.timedelta64(2, 'D')]),
+    ("timedelta", [timedelta(1), np.nan, timedelta(2)]),
+    ("time", [time(1), np.nan, time(2)]),
+    ("period", [Period(2013), pd.NaT, Period(2018)]),
+    ("interval", [Interval(0, 1), np.nan, Interval(0, 2)]),
+]
+ids, _ = zip(*_any_skipna_inferred_dtype)  # use inferred type as fixture-id
+
+
+@pytest.fixture(params=_any_skipna_inferred_dtype, ids=ids)
+def any_skipna_inferred_dtype(request):
+    """
+    Fixture for all inferred dtypes from _libs.lib.infer_dtype
+
+    The covered (inferred) types are:
+    * 'string'
+    * 'empty'
+    * 'bytes'
+    * 'mixed'
+    * 'mixed-integer'
+    * 'mixed-integer-float'
+    * 'floating'
+    * 'integer'
+    * 'decimal'
+    * 'boolean'
+    * 'datetime64'
+    * 'datetime'
+    * 'date'
+    * 'timedelta'
+    * 'time'
+    * 'period'
+    * 'interval'
+
+    Returns
+    -------
+    inferred_dtype : str
+        The string for the inferred dtype from _libs.lib.infer_dtype
+    values : np.ndarray
+        An array of object dtype that will be inferred to have
+        `inferred_dtype`
+
+    Examples
+    --------
+    >>> from pandas._libs import lib
+    >>>
+    >>> def test_something(any_skipna_inferred_dtype):
+    ...     inferred_dtype, values = any_skipna_inferred_dtype
+    ...     # will pass
+    ...     assert lib.infer_dtype(values, skipna=True) == inferred_dtype
+    """
+    inferred_dtype, values = request.param
+    values = np.array(values, dtype=object)  # object dtype to avoid casting
+
+    # correctness of inference tested in tests/dtypes/test_inference.py
+    return inferred_dtype, values
+
+
+# ----------------------------------------------------------------
+# Misc
+# ----------------------------------------------------------------
+@pytest.fixture
+def ip():
+    """
+    Get an instance of IPython.InteractiveShell.
+
+    Will raise a skip if IPython is not installed.
+    """
+    pytest.importorskip("IPython", minversion="6.0.0")
+    from IPython.core.interactiveshell import InteractiveShell
+
+    # GH#35711 make sure sqlite history file handle is not leaked
+    from traitlets.config import Config  # isort:skip
+
+    c = Config()
+    c.HistoryManager.hist_file = ":memory:"
+
+    return InteractiveShell(config=c)
+
+
+@pytest.fixture(params=["bsr", "coo", "csc", "csr", "dia", "dok", "lil"])
+def spmatrix(request):
+    """
+    Yields scipy sparse matrix classes.
+    """
+    sparse = pytest.importorskip("scipy.sparse")
+
+    return getattr(sparse, request.param + "_matrix")
+
+
+@pytest.fixture(
+    params=[
+        getattr(pd.offsets, o)
+        for o in pd.offsets.__all__
+        if issubclass(getattr(pd.offsets, o), pd.offsets.Tick) and o != "Tick"
+    ]
+)
+def tick_classes(request):
+    """
+    Fixture for Tick based datetime offsets available for a time series.
+    """
+    return request.param
+
+
+@pytest.fixture(params=[None, lambda x: x])
+def sort_by_key(request):
+    """
+    Simple fixture for testing keys in sorting methods.
+    Tests None (no key) and the identity key.
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        ("foo", None, None),
+        ("Egon", "Venkman", None),
+        ("NCC1701D", "NCC1701D", "NCC1701D"),
+        # possibly-matching NAs
+        (np.nan, np.nan, np.nan),
+        (np.nan, pd.NaT, None),
+        (np.nan, pd.NA, None),
+        (pd.NA, pd.NA, pd.NA),
+    ]
+)
+def names(request) -> tuple[Hashable, Hashable, Hashable]:
+    """
+    A 3-tuple of names, the first two for operands, the last for a result.
+    """
+    return request.param
+
+
+@pytest.fixture(params=[tm.setitem, tm.loc, tm.iloc])
+def indexer_sli(request):
+    """
+    Parametrize over __setitem__, loc.__setitem__, iloc.__setitem__
+    """
+    return request.param
+
+
+@pytest.fixture(params=[tm.loc, tm.iloc])
+def indexer_li(request):
+    """
+    Parametrize over loc.__getitem__, iloc.__getitem__
+    """
+    return request.param
+
+
+@pytest.fixture(params=[tm.setitem, tm.iloc])
+def indexer_si(request):
+    """
+    Parametrize over __setitem__, iloc.__setitem__
+    """
+    return request.param
+
+
+@pytest.fixture(params=[tm.setitem, tm.loc])
+def indexer_sl(request):
+    """
+    Parametrize over __setitem__, loc.__setitem__
+    """
+    return request.param
+
+
+@pytest.fixture(params=[tm.at, tm.loc])
+def indexer_al(request):
+    """
+    Parametrize over at.__setitem__, loc.__setitem__
+    """
+    return request.param
+
+
+@pytest.fixture(params=[tm.iat, tm.iloc])
+def indexer_ial(request):
+    """
+    Parametrize over iat.__setitem__, iloc.__setitem__
+    """
+    return request.param
+
+
+@pytest.fixture
+def using_array_manager() -> bool:
+    """
+    Fixture to check if the array manager is being used.
+    """
+    return _get_option("mode.data_manager", silent=True) == "array"
+
+
+@pytest.fixture
+def using_copy_on_write() -> bool:
+    """
+    Fixture to check if Copy-on-Write is enabled.
+    """
+    return (
+        pd.options.mode.copy_on_write is True
+        and _get_option("mode.data_manager", silent=True) == "block"
+    )
+
+
+@pytest.fixture
+def warn_copy_on_write() -> bool:
+    """
+    Fixture to check if Copy-on-Write is in warning mode.
+    """
+    return (
+        pd.options.mode.copy_on_write == "warn"
+        and _get_option("mode.data_manager", silent=True) == "block"
+    )
+
+
+@pytest.fixture
+def using_infer_string() -> bool:
+    """
+    Fixture to check if infer string option is enabled.
+    """
+    return pd.options.future.infer_string is True
+
+
+warsaws = ["Europe/Warsaw", "dateutil/Europe/Warsaw"]
+if zoneinfo is not None:
+    warsaws.append(zoneinfo.ZoneInfo("Europe/Warsaw"))  # type: ignore[arg-type]
+
+
+@pytest.fixture(params=warsaws)
+def warsaw(request) -> str:
+    """
+    tzinfo for Europe/Warsaw using pytz, dateutil, or zoneinfo.
+    """
+    return request.param
+
+
+@pytest.fixture()
+def arrow_string_storage():
+    return ("pyarrow", "pyarrow_numpy")

shared/package-files/98/98b8dde9c3de47c453617f8b041c745642d5bc05982716fa304dd3e19501b963/_warnings.py

@@ -0,0 +1,114 @@
+# From scikit-image: https://github.com/scikit-image/scikit-image/blob/c2f8c4ab123ebe5f7b827bc495625a32bb225c10/skimage/_shared/_warnings.py
+# Licensed under modified BSD license
+
+__all__ = ["all_warnings", "expected_warnings"]
+
+import inspect
+import os
+import re
+import sys
+import warnings
+from contextlib import contextmanager
+from unittest import mock
+
+
+@contextmanager
+def all_warnings():
+    """
+    Context for use in testing to ensure that all warnings are raised.
+    Examples
+    --------
+    >>> import warnings
+    >>> def foo():
+    ...     warnings.warn(RuntimeWarning("bar"))
+
+    We raise the warning once, while the warning filter is set to "once".
+    Hereafter, the warning is invisible, even with custom filters:
+    >>> with warnings.catch_warnings():
+    ...     warnings.simplefilter('once')
+    ...     foo()
+
+    We can now run ``foo()`` without a warning being raised:
+    >>> from numpy.testing import assert_warns  # doctest: +SKIP
+    >>> foo()  # doctest: +SKIP
+
+    To catch the warning, we call in the help of ``all_warnings``:
+    >>> with all_warnings():  # doctest: +SKIP
+    ...     assert_warns(RuntimeWarning, foo)
+    """
+
+    # Whenever a warning is triggered, Python adds a __warningregistry__
+    # member to the *calling* module.  The exercize here is to find
+    # and eradicate all those breadcrumbs that were left lying around.
+    #
+    # We proceed by first searching all parent calling frames and explicitly
+    # clearing their warning registries (necessary for the doctests above to
+    # pass).  Then, we search for all submodules of skimage and clear theirs
+    # as well (necessary for the skimage test suite to pass).
+
+    frame = inspect.currentframe()
+    if frame:
+        for f in inspect.getouterframes(frame):
+            f[0].f_locals["__warningregistry__"] = {}
+    del frame
+
+    for _, mod in list(sys.modules.items()):
+        try:
+            mod.__warningregistry__.clear()
+        except AttributeError:
+            pass
+
+    with warnings.catch_warnings(record=True) as w, mock.patch.dict(
+        os.environ, {"TRAITLETS_ALL_DEPRECATIONS": "1"}
+    ):
+        warnings.simplefilter("always")
+        yield w
+
+
+@contextmanager
+def expected_warnings(matching):
+    r"""Context for use in testing to catch known warnings matching regexes
+
+    Parameters
+    ----------
+    matching : list of strings or compiled regexes
+        Regexes for the desired warning to catch
+
+    Examples
+    --------
+    >>> from skimage import data, img_as_ubyte, img_as_float  # doctest: +SKIP
+    >>> with expected_warnings(["precision loss"]):           # doctest: +SKIP
+    ...     d = img_as_ubyte(img_as_float(data.coins()))      # doctest: +SKIP
+
+    Notes
+    -----
+    Uses `all_warnings` to ensure all warnings are raised.
+    Upon exiting, it checks the recorded warnings for the desired matching
+    pattern(s).
+    Raises a ValueError if any match was not found or an unexpected
+    warning was raised.
+    Allows for three types of behaviors: "and", "or", and "optional" matches.
+    This is done to accomodate different build enviroments or loop conditions
+    that may produce different warnings.  The behaviors can be combined.
+    If you pass multiple patterns, you get an orderless "and", where all of the
+    warnings must be raised.
+    If you use the "|" operator in a pattern, you can catch one of several warnings.
+    Finally, you can use "|\A\Z" in a pattern to signify it as optional.
+    """
+    with all_warnings() as w:
+        # enter context
+        yield w
+        # exited user context, check the recorded warnings
+        remaining = [m for m in matching if r"\A\Z" not in m.split("|")]
+        for warn in w:
+            found = False
+            for match in matching:
+                if re.search(match, str(warn.message)) is not None:
+                    found = True
+                    if match in remaining:
+                        remaining.remove(match)
+            if not found:
+                raise ValueError("Unexpected warning: %s" % str(warn.message))
+        if len(remaining) > 0:
+            msg = "No warning raised matching:\n%s" % "\n".join(remaining)
+            raise ValueError(msg)

shared/package-files/98/98bf278df7fbace3255edc6690ef155e9a36472c7ee7dbc306a84f8f07bafa61/nll_loss_nd_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor nll_loss_nd_symint(const at::Tensor & self, const at::Tensor & target, const c10::optional<at::Tensor> & weight={}, int64_t reduction=at::Reduction::Mean, c10::SymInt ignore_index=-100);
+} // namespace native
+} // namespace at

shared/package-files/98/98e0487d7357b3bc5df729d23ed1d391a66d9e2665f9ed328dabacc228d4bb83/_cast_Long_ops.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _cast_Long {
+  using schema = at::Tensor (const at::Tensor &, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_cast_Long")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_cast_Long(Tensor self, bool non_blocking=False) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, bool non_blocking);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, bool non_blocking);
+};
+
+}} // namespace at::_ops

shared/package-files/d1/d10ac70fd4d82a5499b8ef1dae75376d4149ad2bbcbf94a772ab6445258b8c63/euler.py

@@ -0,0 +1,108 @@
+"""
+This module implements a method to find
+Euler-Lagrange Equations for given Lagrangian.
+"""
+from itertools import combinations_with_replacement
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.utilities.iterables import iterable
+
+
+def euler_equations(L, funcs=(), vars=()):
+    r"""
+    Find the Euler-Lagrange equations [1]_ for a given Lagrangian.
+
+    Parameters
+    ==========
+
+    L : Expr
+        The Lagrangian that should be a function of the functions listed
+        in the second argument and their derivatives.
+
+        For example, in the case of two functions $f(x,y)$, $g(x,y)$ and
+        two independent variables $x$, $y$ the Lagrangian has the form:
+
+            .. math:: L\left(f(x,y),g(x,y),\frac{\partial f(x,y)}{\partial x},
+                      \frac{\partial f(x,y)}{\partial y},
+                      \frac{\partial g(x,y)}{\partial x},
+                      \frac{\partial g(x,y)}{\partial y},x,y\right)
+
+        In many cases it is not necessary to provide anything, except the
+        Lagrangian, it will be auto-detected (and an error raised if this
+        cannot be done).
+
+    funcs : Function or an iterable of Functions
+        The functions that the Lagrangian depends on. The Euler equations
+        are differential equations for each of these functions.
+
+    vars : Symbol or an iterable of Symbols
+        The Symbols that are the independent variables of the functions.
+
+    Returns
+    =======
+
+    eqns : list of Eq
+        The list of differential equations, one for each function.
+
+    Examples
+    ========
+
+    >>> from sympy import euler_equations, Symbol, Function
+    >>> x = Function('x')
+    >>> t = Symbol('t')
+    >>> L = (x(t).diff(t))**2/2 - x(t)**2/2
+    >>> euler_equations(L, x(t), t)
+    [Eq(-x(t) - Derivative(x(t), (t, 2)), 0)]
+    >>> u = Function('u')
+    >>> x = Symbol('x')
+    >>> L = (u(t, x).diff(t))**2/2 - (u(t, x).diff(x))**2/2
+    >>> euler_equations(L, u(t, x), [t, x])
+    [Eq(-Derivative(u(t, x), (t, 2)) + Derivative(u(t, x), (x, 2)), 0)]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation
+
+    """
+
+    funcs = tuple(funcs) if iterable(funcs) else (funcs,)
+
+    if not funcs:
+        funcs = tuple(L.atoms(Function))
+    else:
+        for f in funcs:
+            if not isinstance(f, Function):
+                raise TypeError('Function expected, got: %s' % f)
+
+    vars = tuple(vars) if iterable(vars) else (vars,)
+
+    if not vars:
+        vars = funcs[0].args
+    else:
+        vars = tuple(sympify(var) for var in vars)
+
+    if not all(isinstance(v, Symbol) for v in vars):
+        raise TypeError('Variables are not symbols, got %s' % vars)
+
+    for f in funcs:
+        if not vars == f.args:
+            raise ValueError("Variables %s do not match args: %s" % (vars, f))
+
+    order = max([len(d.variables) for d in L.atoms(Derivative)
+                        if d.expr in funcs] + [0])
+
+    eqns = []
+    for f in funcs:
+        eq = diff(L, f)
+        for i in range(1, order + 1):
+            for p in combinations_with_replacement(vars, i):
+                eq = eq + S.NegativeOne**i*diff(L, diff(f, *p), *p)
+        new_eq = Eq(eq, 0)
+        if isinstance(new_eq, Eq):
+            eqns.append(new_eq)
+
+    return eqns

shared/package-files/d1/d1119423dda95126d93a1095b189e7832c14d70332dcdd2d0af063f26349bbdf/fbgemm_pack_quantized_matrix_native.h

@@ -0,0 +1,22 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor fbgemm_pack_quantized_matrix(const at::Tensor & input);
+TORCH_API at::Tensor fbgemm_pack_quantized_matrix(const at::Tensor & input, int64_t K, int64_t N);
+} // namespace native
+} // namespace at

shared/package-files/d1/d115718818e3e3367847ce35bb5ff0361d08993d9749d438c918f8eb87ad8814/mt.msg

@@ -0,0 +1,27 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset mt DAYS_OF_WEEK_ABBREV [list \
+        "\u0126ad"\
+        "Tne"\
+        "Tli"\
+        "Erb"\
+        "\u0126am"\
+        "\u0120im"]
+    ::msgcat::mcset mt MONTHS_ABBREV [list \
+        "Jan"\
+        "Fra"\
+        "Mar"\
+        "Apr"\
+        "Mej"\
+        "\u0120un"\
+        "Lul"\
+        "Awi"\
+        "Set"\
+        "Ott"\
+        "Nov"]
+    ::msgcat::mcset mt BCE "QK"
+    ::msgcat::mcset mt CE ""
+    ::msgcat::mcset mt DATE_FORMAT "%A, %e ta %B, %Y"
+    ::msgcat::mcset mt TIME_FORMAT_12 "%l:%M:%S %P"
+    ::msgcat::mcset mt DATE_TIME_FORMAT "%A, %e ta %B, %Y %l:%M:%S %P %z"
+}

shared/package-files/d1/d119859b1979b8decbc7beb0ac5349d90cade35b2e593dc7a9e7f4eb7b22c681/parfor_lowering.py

@@ -0,0 +1,2068 @@
+import copy
+import operator
+
+import types as pytypes
+import operator
+import warnings
+from dataclasses import make_dataclass
+
+import llvmlite.ir
+import numpy as np
+
+import numba
+from numba.parfors import parfor
+from numba.core import types, ir, config, compiler, sigutils, cgutils
+from numba.core.ir_utils import (
+    add_offset_to_labels,
+    replace_var_names,
+    remove_dels,
+    legalize_names,
+    rename_labels,
+    get_name_var_table,
+    visit_vars_inner,
+    get_definition,
+    guard,
+    get_call_table,
+    is_pure,
+    get_np_ufunc_typ,
+    get_unused_var_name,
+    is_const_call,
+    fixup_var_define_in_scope,
+    transfer_scope,
+    find_max_label,
+    get_global_func_typ,
+    find_topo_order,
+)
+from numba.core.typing import signature
+from numba.core import lowering
+from numba.parfors.parfor import ensure_parallel_support
+from numba.core.errors import (
+    NumbaParallelSafetyWarning, NotDefinedError, CompilerError, InternalError,
+)
+from numba.parfors.parfor_lowering_utils import ParforLoweringBuilder
+
+
+class ParforLower(lowering.Lower):
+    """This is a custom lowering class that extends standard lowering so as
+    to accommodate parfor.Parfor nodes."""
+
+    # custom instruction lowering to handle parfor nodes
+    def lower_inst(self, inst):
+        if isinstance(inst, parfor.Parfor):
+            _lower_parfor_parallel(self, inst)
+        else:
+            super().lower_inst(inst)
+
+    @property
+    def _disable_sroa_like_opt(self):
+        """
+        Force disable this because Parfor use-defs is incompatible---it only
+        considers use-defs in blocks that must be executing.
+        See https://github.com/numba/numba/commit/017e2ff9db87fc34149b49dd5367ecbf0bb45268
+        """
+        return True
+
+
+def _lower_parfor_parallel(lowerer, parfor):
+    if parfor.lowerer is None:
+        return _lower_parfor_parallel_std(lowerer, parfor)
+    else:
+        return parfor.lowerer(lowerer, parfor)
+
+
+def _lower_parfor_parallel_std(lowerer, parfor):
+    """Lowerer that handles LLVM code generation for parfor.
+    This function lowers a parfor IR node to LLVM.
+    The general approach is as follows:
+    1) The code from the parfor's init block is lowered normally
+       in the context of the current function.
+    2) The body of the parfor is transformed into a gufunc function.
+    3) Code is inserted into the main function that calls do_scheduling
+       to divide the iteration space for each thread, allocates
+       reduction arrays, calls the gufunc function, and then invokes
+       the reduction function across the reduction arrays to produce
+       the final reduction values.
+    """
+    from numba.np.ufunc.parallel import get_thread_count
+
+    ensure_parallel_support()
+    typingctx = lowerer.context.typing_context
+    targetctx = lowerer.context
+    builder = lowerer.builder
+    # We copy the typemap here because for race condition variable we'll
+    # update their type to array so they can be updated by the gufunc.
+    orig_typemap = lowerer.fndesc.typemap
+    # replace original typemap with copy and restore the original at the end.
+    lowerer.fndesc.typemap = copy.copy(orig_typemap)
+    if config.DEBUG_ARRAY_OPT:
+        print("lowerer.fndesc", lowerer.fndesc, type(lowerer.fndesc))
+    typemap = lowerer.fndesc.typemap
+    varmap = lowerer.varmap
+
+    if config.DEBUG_ARRAY_OPT:
+        print("_lower_parfor_parallel")
+        parfor.dump()
+
+    loc = parfor.init_block.loc
+    scope = parfor.init_block.scope
+
+    # produce instructions for init_block
+    if config.DEBUG_ARRAY_OPT:
+        print("init_block = ", parfor.init_block, " ", type(parfor.init_block))
+    for instr in parfor.init_block.body:
+        if config.DEBUG_ARRAY_OPT:
+            print("lower init_block instr = ", instr)
+        lowerer.lower_inst(instr)
+
+    for racevar in parfor.races:
+        if racevar not in varmap:
+            rvtyp = typemap[racevar]
+            rv = ir.Var(scope, racevar, loc)
+            lowerer._alloca_var(rv.name, rvtyp)
+
+    alias_map = {}
+    arg_aliases = {}
+    numba.parfors.parfor.find_potential_aliases_parfor(parfor, parfor.params, typemap,
+                                        lowerer.func_ir, alias_map, arg_aliases)
+    if config.DEBUG_ARRAY_OPT:
+        print("alias_map", alias_map)
+        print("arg_aliases", arg_aliases)
+
+    # run get_parfor_outputs() and get_parfor_reductions() before gufunc creation
+    # since Jumps are modified so CFG of loop_body dict will become invalid
+    assert parfor.params is not None
+
+    parfor_output_arrays = numba.parfors.parfor.get_parfor_outputs(
+        parfor, parfor.params)
+    parfor_redvars, parfor_reddict = parfor.redvars, parfor.reddict
+    if config.DEBUG_ARRAY_OPT:
+        print("parfor_redvars:", parfor_redvars)
+        print("parfor_reddict:", parfor_reddict)
+
+    # init reduction array allocation here.
+    nredvars = len(parfor_redvars)
+    redarrs = {}
+    to_cleanup = []
+    if nredvars > 0:
+        # reduction arrays outer dimension equal to thread count
+        scope = parfor.init_block.scope
+        loc = parfor.init_block.loc
+        pfbdr = ParforLoweringBuilder(lowerer=lowerer, scope=scope, loc=loc)
+
+        # Get the Numba internal function to call to get the thread count.
+        get_num_threads = pfbdr.bind_global_function(
+            fobj=numba.np.ufunc.parallel._iget_num_threads,
+            ftype=get_global_func_typ(numba.np.ufunc.parallel._iget_num_threads),
+            args=()
+        )
+
+        # Insert the call to assign the thread count to a variable.
+        num_threads_var = pfbdr.assign(
+            rhs=pfbdr.call(get_num_threads, args=[]),
+            typ=types.intp,
+            name="num_threads_var")
+
+        # For each reduction variable...
+        for i in range(nredvars):
+            red_name = parfor_redvars[i]
+            # Get the type of the reduction variable.
+            redvar_typ = lowerer.fndesc.typemap[red_name]
+            # Get the ir.Var for the reduction variable.
+            redvar = ir.Var(scope, red_name, loc)
+            # Get the type of the array that holds the per-thread
+            # reduction variables.
+            redarrvar_typ = redtyp_to_redarraytype(redvar_typ)
+            reddtype = redarrvar_typ.dtype
+            if config.DEBUG_ARRAY_OPT:
+                print(
+                    "reduction_info",
+                    red_name,
+                    redvar_typ,
+                    redarrvar_typ,
+                    reddtype,
+                    types.DType(reddtype),
+                    num_threads_var,
+                    type(num_threads_var)
+                )
+
+            # If this is reduction over an array,
+            # the reduction array has just one added per-worker dimension.
+            if isinstance(redvar_typ, types.npytypes.Array):
+                redarrdim = redvar_typ.ndim + 1
+            else:
+                redarrdim = 1
+
+            # Reduction array is created and initialized to the initial reduction value.
+
+            # First create a var for the numpy empty ufunc.
+            glbl_np_empty = pfbdr.bind_global_function(
+                fobj=np.empty,
+                ftype=get_np_ufunc_typ(np.empty, pfbdr._typingctx),
+                args=(
+                    types.UniTuple(types.intp, redarrdim),
+                ),
+                kws={'dtype': types.DType(reddtype)}
+            )
+
+            size_var_list = [num_threads_var]
+
+            # If this is a reduction over an array...
+            if isinstance(redvar_typ, types.npytypes.Array):
+                # Add code to get the shape of the array being reduced over.
+                redshape_var = pfbdr.assign(
+                    rhs=ir.Expr.getattr(redvar, "shape", loc),
+                    typ=types.UniTuple(types.intp, redvar_typ.ndim),
+                    name="redarr_shape",
+                )
+
+                # Add the dimension sizes of the array being reduced over to the tuple of sizes pass to empty.
+                for j in range(redvar_typ.ndim):
+                    onedimvar = pfbdr.assign(
+                        rhs=ir.Expr.static_getitem(redshape_var, j, None, loc),
+                        typ=types.intp,
+                        name="redshapeonedim",
+                    )
+                    size_var_list.append(onedimvar)
+
+            # Empty call takes tuple of sizes.  Create here and fill in outer dimension (num threads).
+            size_var = pfbdr.make_tuple_variable(
+                size_var_list, name='tuple_size_var',
+            )
+
+            # Resolve dtype
+            cval = pfbdr._typingctx.resolve_value_type(reddtype)
+            dt = pfbdr.make_const_variable(cval=cval, typ=types.DType(reddtype))
+            # Add call to empty passing the size var tuple.
+            empty_call = pfbdr.call(glbl_np_empty, args=[size_var, dt])
+
+            redarr_var = pfbdr.assign(
+                rhs=empty_call, typ=redarrvar_typ, name="redarr",
+            )
+
+            # Remember mapping of original reduction array to the newly created per-worker reduction array.
+            redarrs[redvar.name] = redarr_var
+            to_cleanup.append(redarr_var)
+
+            init_val = parfor_reddict[red_name].init_val
+
+            if init_val is not None:
+                if isinstance(redvar_typ, types.npytypes.Array):
+                    # Create an array of identity values for the reduction.
+                    # First, create a variable for np.full.
+                    full_func_node = pfbdr.bind_global_function(
+                        fobj=np.full,
+                        ftype=get_np_ufunc_typ(np.full, pfbdr._typingctx),
+                        args=(
+                            types.UniTuple(types.intp, redvar_typ.ndim),
+                            reddtype,
+                        ),
+                        kws={'dtype': types.DType(reddtype)},
+                    )
+
+                    # Then create a var with the identify value.
+                    init_val_var = pfbdr.make_const_variable(
+                        cval=init_val,
+                        typ=reddtype,
+                        name="init_val",
+                    )
+
+                    # Then, call np.full with the shape of the reduction array and the identity value.
+                    full_call = pfbdr.call(
+                        full_func_node, args=[redshape_var, init_val_var, dt],
+                    )
+
+                    redtoset = pfbdr.assign(
+                        rhs=full_call,
+                        typ=redvar_typ,
+                        name="redtoset",
+                    )
+                    # rettoset is an array from np.full() and must be released
+                    to_cleanup.append(redtoset)
+                else:
+                    redtoset = pfbdr.make_const_variable(
+                        cval=init_val,
+                        typ=reddtype,
+                        name="redtoset",
+                    )
+            else:
+                redtoset = redvar
+
+                if config.DEBUG_ARRAY_OPT_RUNTIME:
+                    res_print_str = "res_print1 for redvar " + str(redvar) + ":"
+                    strconsttyp = types.StringLiteral(res_print_str)
+
+                    lhs = pfbdr.make_const_variable(
+                        cval=res_print_str,
+                        typ=strconsttyp,
+                        name="str_const",
+                    )
+
+                    res_print = ir.Print(args=[lhs, redvar],
+                                         vararg=None, loc=loc)
+                    lowerer.fndesc.calltypes[res_print] = signature(types.none,
+                                                             typemap[lhs.name],
+                                                             typemap[redvar.name])
+                    print("res_print_redvar", res_print)
+                    lowerer.lower_inst(res_print)
+
+
+            # For each thread, initialize the per-worker reduction array to
+            # the current reduction array value.
+
+            # Get the Numba type of the variable that holds the thread count.
+            num_thread_type = typemap[num_threads_var.name]
+            # Get the LLVM type of the thread count variable.
+            ntllvm_type = targetctx.get_value_type(num_thread_type)
+            # Create a LLVM variable to hold the loop index.
+            alloc_loop_var = cgutils.alloca_once(builder, ntllvm_type)
+            # Associate this LLVM variable to a Numba IR variable so that
+            # we can use setitem IR builder.
+            # Create a Numba IR variable.
+            numba_ir_loop_index_var = scope.redefine("$loop_index", loc)
+            # Give that variable the right type.
+            typemap[numba_ir_loop_index_var.name] = num_thread_type
+            # Associate this Numba variable to the LLVM variable in the
+            # lowerer's varmap.
+            lowerer.varmap[numba_ir_loop_index_var.name] = alloc_loop_var
+            # Insert a loop into the outputed LLVM that goes from 0 to
+            # the current thread count.
+            with cgutils.for_range(builder, lowerer.loadvar(num_threads_var.name), intp=ntllvm_type) as loop:
+                # Store the loop index into the alloca'd LLVM loop index variable.
+                builder.store(loop.index, alloc_loop_var)
+                # Initialize one element of the reduction array using the Numba
+                # IR variable associated with this loop's index.
+                pfbdr.setitem(obj=redarr_var, index=numba_ir_loop_index_var, val=redtoset)
+
+    # compile parfor body as a separate function to be used with GUFuncWrapper
+    flags = parfor.flags.copy()
+    flags.error_model = "numpy"
+    # Can't get here unless  flags.auto_parallel == ParallelOptions(True)
+    index_var_typ = typemap[parfor.loop_nests[0].index_variable.name]
+    # index variables should have the same type, check rest of indices
+    for l in parfor.loop_nests[1:]:
+        assert typemap[l.index_variable.name] == index_var_typ
+    numba.parfors.parfor.sequential_parfor_lowering = True
+    try:
+        (func,
+         func_args,
+         func_sig,
+         func_arg_types,
+         exp_name_to_tuple_var) = _create_gufunc_for_parfor_body(
+            lowerer, parfor, typemap, typingctx, targetctx, flags, {},
+            bool(alias_map), index_var_typ, parfor.races)
+    finally:
+        numba.parfors.parfor.sequential_parfor_lowering = False
+
+    # get the shape signature
+    func_args = ['sched'] + func_args
+    num_reductions = len(parfor_redvars)
+    num_inputs = len(func_args) - len(parfor_output_arrays) - num_reductions
+    if config.DEBUG_ARRAY_OPT:
+        print("func_args = ", func_args)
+        print("num_inputs = ", num_inputs)
+        print("parfor_outputs = ", parfor_output_arrays)
+        print("parfor_redvars = ", parfor_redvars)
+        print("num_reductions = ", num_reductions)
+    gu_signature = _create_shape_signature(
+        parfor.get_shape_classes,
+        num_inputs,
+        num_reductions,
+        func_args,
+        func_sig,
+        parfor.races,
+        typemap)
+    if config.DEBUG_ARRAY_OPT:
+        print("gu_signature = ", gu_signature)
+
+    # call the func in parallel by wrapping it with ParallelGUFuncBuilder
+    loop_ranges = [(l.start, l.stop, l.step) for l in parfor.loop_nests]
+    if config.DEBUG_ARRAY_OPT:
+        print("loop_nests = ", parfor.loop_nests)
+        print("loop_ranges = ", loop_ranges)
+    call_parallel_gufunc(
+        lowerer,
+        func,
+        gu_signature,
+        func_sig,
+        func_args,
+        func_arg_types,
+        loop_ranges,
+        parfor_redvars,
+        parfor_reddict,
+        redarrs,
+        parfor.init_block,
+        index_var_typ,
+        parfor.races,
+        exp_name_to_tuple_var)
+
+    if nredvars > 0:
+        _parfor_lowering_finalize_reduction(
+            parfor, redarrs, lowerer, parfor_reddict, num_threads_var,
+        )
+
+    # Cleanup reduction variable
+    for v in to_cleanup:
+        lowerer.lower_inst(ir.Del(v.name, loc=loc))
+    # Restore the original typemap of the function that was replaced temporarily at the
+    # Beginning of this function.
+    lowerer.fndesc.typemap = orig_typemap
+
+    if config.DEBUG_ARRAY_OPT:
+        print("_lower_parfor_parallel done")
+
+
+_ReductionInfo = make_dataclass(
+    "_ReductionInfo",
+    [
+        "redvar_info",
+        "redvar_name",
+        "redvar_typ",
+        "redarr_var",
+        "redarr_typ",
+        "init_val",
+    ],
+    frozen=True,
+)
+
+
+def _parfor_lowering_finalize_reduction(
+        parfor,
+        redarrs,
+        lowerer,
+        parfor_reddict,
+        thread_count_var,
+    ):
+    """Emit code to finalize the reduction from the intermediate values of
+    each thread.
+    """
+    # For each reduction variable
+    for redvar_name, redarr_var in redarrs.items():
+        # Pseudo-code for this loop body:
+        #     tmp = redarr[0]
+        #     for i in range(1, thread_count):
+        #         tmp = reduce_op(redarr[i], tmp)
+        #     reduction_result = tmp
+        redvar_typ = lowerer.fndesc.typemap[redvar_name]
+        redarr_typ = lowerer.fndesc.typemap[redarr_var.name]
+        init_val = lowerer.loadvar(redvar_name)
+
+        reduce_info = _ReductionInfo(
+            redvar_info = parfor_reddict[redvar_name],
+            redvar_name=redvar_name,
+            redvar_typ=redvar_typ,
+            redarr_var=redarr_var,
+            redarr_typ=redarr_typ,
+            init_val=init_val,
+        )
+        # generate code for combining reduction variable with thread output
+        handler = (_lower_trivial_inplace_binops
+                   if reduce_info.redvar_info.redop is not None
+                   else _lower_non_trivial_reduce)
+        handler(parfor, lowerer, thread_count_var, reduce_info)
+
+
+class ParforsUnexpectedReduceNodeError(InternalError):
+    def __init__(self, inst):
+        super().__init__(f"Unknown reduce instruction node: {inst}")
+
+
+def _lower_trivial_inplace_binops(parfor, lowerer, thread_count_var, reduce_info):
+    """Lower trivial inplace-binop reduction.
+    """
+    for inst in reduce_info.redvar_info.reduce_nodes:
+        # Var assigns to Var?
+        if _lower_var_to_var_assign(lowerer, inst):
+            pass
+        # Is inplace-binop for the reduction?
+        elif _is_right_op_and_rhs_is_init(inst, reduce_info.redvar_name, "inplace_binop"):
+            fn = inst.value.fn
+            redvar_result = _emit_binop_reduce_call(
+                fn, lowerer, thread_count_var, reduce_info,
+            )
+            lowerer.storevar(redvar_result, name=inst.target.name)
+        # Is binop for the reduction?
+        elif _is_right_op_and_rhs_is_init(inst, reduce_info.redvar_name, "binop"):
+            fn = inst.value.fn
+            redvar_result = _emit_binop_reduce_call(
+                fn, lowerer, thread_count_var, reduce_info,
+            )
+            lowerer.storevar(redvar_result, name=inst.target.name)
+        # Otherwise?
+        else:
+            raise ParforsUnexpectedReduceNodeError(inst)
+
+        # XXX: This seems like a hack to stop the loop with this condition.
+        if _fix_redvar_name_ssa_mismatch(parfor, lowerer, inst,
+                                   reduce_info.redvar_name):
+            break
+    if config.DEBUG_ARRAY_OPT_RUNTIME:
+        varname = reduce_info.redvar_name
+        lowerer.print_variable(
+            f"{parfor.loc}: parfor {fn.__name__} reduction {varname} =",
+            varname,
+        )
+
+
+def _lower_non_trivial_reduce(parfor, lowerer, thread_count_var, reduce_info):
+    """Lower non-trivial reduction such as call to `functools.reduce()`.
+    """
+    init_name = f"{reduce_info.redvar_name}#init"
+    # The init_name variable is not defined at this point.
+    lowerer.fndesc.typemap.setdefault(init_name, reduce_info.redvar_typ)
+    # Emit a sequence of the reduction operation for each intermediate result
+    # of each thread.
+    num_thread_llval = lowerer.loadvar(thread_count_var.name)
+    with cgutils.for_range(lowerer.builder, num_thread_llval) as loop:
+        tid = loop.index
+        for inst in reduce_info.redvar_info.reduce_nodes:
+            # Var assigns to Var?
+            if _lower_var_to_var_assign(lowerer, inst):
+                pass
+            # The reduction operation?
+            elif (isinstance(inst, ir.Assign)
+                    and any(var.name == init_name for var in inst.list_vars())):
+                elem = _emit_getitem_call(tid, lowerer, reduce_info)
+                lowerer.storevar(elem, init_name)
+                lowerer.lower_inst(inst)
+
+            # Otherwise?
+            else:
+                raise ParforsUnexpectedReduceNodeError(inst)
+
+            # XXX: This seems like a hack to stop the loop with this condition.
+            if _fix_redvar_name_ssa_mismatch(parfor, lowerer, inst,
+                                       reduce_info.redvar_name):
+                break
+
+    if config.DEBUG_ARRAY_OPT_RUNTIME:
+        varname = reduce_info.redvar_name
+        lowerer.print_variable(
+            f"{parfor.loc}: parfor non-trivial reduction {varname} =",
+            varname,
+        )
+
+def _lower_var_to_var_assign(lowerer, inst):
+    """Lower Var->Var assignment.
+
+    Returns True if-and-only-if `inst` is a Var->Var assignment.
+    """
+    if isinstance(inst, ir.Assign) and isinstance(inst.value, ir.Var):
+        loaded = lowerer.loadvar(inst.value.name)
+        lowerer.storevar(loaded, name=inst.target.name)
+        return True
+    return False
+
+def _emit_getitem_call(idx, lowerer, reduce_info):
+    """Emit call to ``redarr_var[idx]``
+    """
+    def reducer_getitem(redarr, index):
+        return redarr[index]
+
+    builder = lowerer.builder
+    ctx = lowerer.context
+    redarr_typ = reduce_info.redarr_typ
+    arg_arr = lowerer.loadvar(reduce_info.redarr_var.name)
+    args = (arg_arr, idx)
+    sig = signature(reduce_info.redvar_typ, redarr_typ, types.intp)
+    elem = ctx.compile_internal(builder, reducer_getitem, sig, args)
+    return elem
+
+
+def _emit_binop_reduce_call(binop, lowerer, thread_count_var, reduce_info):
+    """Emit call to the ``binop`` for the reduction variable.
+    """
+
+    def reduction_add(thread_count, redarr, init):
+        c = init
+        for i in range(thread_count):
+            c += redarr[i]
+        return c
+
+    def reduction_mul(thread_count, redarr, init):
+        c = init
+        for i in range(thread_count):
+            c *= redarr[i]
+        return c
+
+    kernel = {
+        operator.iadd: reduction_add,
+        operator.isub: reduction_add,
+        operator.add: reduction_add,
+        operator.sub: reduction_add,
+        operator.imul: reduction_mul,
+        operator.ifloordiv: reduction_mul,
+        operator.itruediv: reduction_mul,
+        operator.mul: reduction_mul,
+        operator.floordiv: reduction_mul,
+        operator.truediv: reduction_mul,
+    }[binop]
+
+    ctx = lowerer.context
+    builder = lowerer.builder
+    redarr_typ = reduce_info.redarr_typ
+    arg_arr = lowerer.loadvar(reduce_info.redarr_var.name)
+
+    if config.DEBUG_ARRAY_OPT_RUNTIME:
+        init_var = reduce_info.redarr_var.scope.get(reduce_info.redvar_name)
+        res_print = ir.Print(
+            args=[reduce_info.redarr_var, init_var], vararg=None,
+            loc=lowerer.loc,
+        )
+        typemap = lowerer.fndesc.typemap
+        lowerer.fndesc.calltypes[res_print] = signature(
+            types.none, typemap[reduce_info.redarr_var.name],
+            typemap[init_var.name],
+        )
+        lowerer.lower_inst(res_print)
+
+    arg_thread_count = lowerer.loadvar(thread_count_var.name)
+    args = (arg_thread_count, arg_arr, reduce_info.init_val)
+    sig = signature(
+        reduce_info.redvar_typ, types.uintp, redarr_typ, reduce_info.redvar_typ,
+    )
+
+    redvar_result = ctx.compile_internal(builder, kernel, sig, args)
+    return redvar_result
+
+
+def _is_right_op_and_rhs_is_init(inst, redvar_name, op):
+    """Is ``inst`` an inplace-binop and the RHS is the reduction init?
+    """
+    if not isinstance(inst, ir.Assign):
+        return False
+    rhs = inst.value
+    if not isinstance(rhs, ir.Expr):
+        return False
+    if rhs.op != op:
+        return False
+    if rhs.rhs.name != f"{redvar_name}#init":
+        return False
+    return True
+
+
+def _fix_redvar_name_ssa_mismatch(parfor, lowerer, inst, redvar_name):
+    """Fix reduction variable name mismatch due to SSA.
+    """
+    # Only process reduction statements post-gufunc execution
+    # until we see an assignment with a left-hand side to the
+    # reduction variable's name.  This fixes problems with
+    # cases where there are multiple assignments to the
+    # reduction variable in the parfor.
+    scope = parfor.init_block.scope
+    if isinstance(inst, ir.Assign):
+        try:
+            reduction_var = scope.get_exact(redvar_name)
+        except NotDefinedError:
+            # Ideally, this shouldn't happen. The redvar name
+            # missing from scope indicates an error from
+            # other rewrite passes.
+            is_same_source_var = redvar_name == inst.target.name
+        else:
+            # Because of SSA, the redvar and target var of
+            # the current assignment would be different even
+            # though they refer to the same source-level var.
+            redvar_unver_name = reduction_var.unversioned_name
+            target_unver_name = inst.target.unversioned_name
+            is_same_source_var = redvar_unver_name == target_unver_name
+
+        if is_same_source_var:
+            # If redvar is different from target var, add an
+            # assignment to put target var into redvar.
+            if redvar_name != inst.target.name:
+                val = lowerer.loadvar(inst.target.name)
+                lowerer.storevar(val, name=redvar_name)
+                return True
+
+    return False
+
+def _create_shape_signature(
+        get_shape_classes,
+        num_inputs,
+        num_reductions,
+        args,
+        func_sig,
+        races,
+        typemap):
+    '''Create shape signature for GUFunc
+    '''
+    if config.DEBUG_ARRAY_OPT:
+        print("_create_shape_signature", num_inputs, num_reductions, args, races)
+        for i in args[1:]:
+            print("argument", i, type(i), get_shape_classes(i, typemap=typemap))
+
+    num_inouts = len(args) - num_reductions
+    # maximum class number for array shapes
+    classes = [get_shape_classes(var, typemap=typemap) if var not in races else (-1,) for var in args[1:]]
+    class_set = set()
+    for _class in classes:
+        if _class:
+            for i in _class:
+                class_set.add(i)
+    max_class = max(class_set) + 1 if class_set else 0
+    classes.insert(0, (max_class,)) # force set the class of 'sched' argument
+    class_set.add(max_class)
+    thread_num_class = max_class + 1
+    class_set.add(thread_num_class)
+    class_map = {}
+    # TODO: use prefix + class number instead of single char
+    alphabet = ord('a')
+    for n in class_set:
+       if n >= 0:
+           class_map[n] = chr(alphabet)
+           alphabet += 1
+    threadcount_ordinal = chr(alphabet)
+
+    alpha_dict = {'latest_alpha' : alphabet}
+
+    def bump_alpha(c, class_map):
+        if c >= 0:
+            return class_map[c]
+        else:
+            alpha_dict['latest_alpha'] += 1
+            return chr(alpha_dict['latest_alpha'])
+
+    gu_sin = []
+    gu_sout = []
+    count = 0
+    syms_sin = ()
+    if config.DEBUG_ARRAY_OPT:
+        print("args", args)
+        print("classes", classes)
+        print("threadcount_ordinal", threadcount_ordinal)
+    for cls, arg in zip(classes, args):
+        count = count + 1
+        if cls:
+            dim_syms = tuple(bump_alpha(c, class_map) for c in cls)
+        else:
+            dim_syms = ()
+        if (count > num_inouts):
+            # Add the threadcount_ordinal to represent the thread count
+            # to the start of the reduction array.
+            gu_sin.append(tuple([threadcount_ordinal] + list(dim_syms[1:])))
+        else:
+            gu_sin.append(dim_syms)
+            syms_sin += dim_syms
+    return (gu_sin, gu_sout)
+
+def _print_block(block):
+    for i, inst in enumerate(block.body):
+        print("    ", i, " ", inst)
+
+def _print_body(body_dict):
+    '''Pretty-print a set of IR blocks.
+    '''
+    topo_order = wrap_find_topo(body_dict)
+    for label in topo_order:
+        block = body_dict[label]
+        print("label: ", label)
+        _print_block(block)
+
+
+def wrap_loop_body(loop_body):
+    blocks = loop_body.copy()  # shallow copy is enough
+    first_label = min(blocks.keys())
+    last_label = max(blocks.keys())
+    loc = blocks[last_label].loc
+    blocks[last_label].body.append(ir.Jump(first_label, loc))
+    return blocks
+
+def unwrap_loop_body(loop_body):
+    last_label = max(loop_body.keys())
+    loop_body[last_label].body = loop_body[last_label].body[:-1]
+
+def add_to_def_once_sets(a_def, def_once, def_more):
+    '''If the variable is already defined more than once, do nothing.
+       Else if defined exactly once previously then transition this
+       variable to the defined more than once set (remove it from
+       def_once set and add to def_more set).
+       Else this must be the first time we've seen this variable defined
+       so add to def_once set.
+    '''
+    if a_def in def_more:
+        pass
+    elif a_def in def_once:
+        def_more.add(a_def)
+        def_once.remove(a_def)
+    else:
+        def_once.add(a_def)
+
+def compute_def_once_block(block, def_once, def_more, getattr_taken, typemap, module_assigns):
+    '''Effect changes to the set of variables defined once or more than once
+       for a single block.
+       block - the block to process
+       def_once - set of variable names known to be defined exactly once
+       def_more - set of variable names known to be defined more than once
+       getattr_taken - dict mapping variable name to tuple of object and attribute taken
+       module_assigns - dict mapping variable name to the Global that they came from
+    '''
+    # The only "defs" occur in assignments, so find such instructions.
+    assignments = block.find_insts(ir.Assign)
+    # For each assignment...
+    for one_assign in assignments:
+        # Get the LHS/target of the assignment.
+        a_def = one_assign.target.name
+        # Add variable to def sets.
+        add_to_def_once_sets(a_def, def_once, def_more)
+
+        rhs = one_assign.value
+        if isinstance(rhs, ir.Global):
+            # Remember assignments of the form "a = Global(...)"
+            # Is this a module?
+            if isinstance(rhs.value, pytypes.ModuleType):
+                module_assigns[a_def] = rhs.value.__name__
+        if isinstance(rhs, ir.Expr) and rhs.op == 'getattr' and rhs.value.name in def_once:
+            # Remember assignments of the form "a = b.c"
+            getattr_taken[a_def] = (rhs.value.name, rhs.attr)
+        if isinstance(rhs, ir.Expr) and rhs.op == 'call' and rhs.func.name in getattr_taken:
+            # If "a" is being called then lookup the getattr definition of "a"
+            # as above, getting the module variable "b" (base_obj)
+            # and the attribute "c" (base_attr).
+            base_obj, base_attr = getattr_taken[rhs.func.name]
+            if base_obj in module_assigns:
+                # If we know the definition of the module variable then get the module
+                # name from module_assigns.
+                base_mod_name = module_assigns[base_obj]
+                if not is_const_call(base_mod_name, base_attr):
+                    # Calling a method on an object could modify the object and is thus
+                    # like a def of that object.  We call is_const_call to see if this module/attribute
+                    # combination is known to not modify the module state.  If we don't know that
+                    # the combination is safe then we have to assume there could be a modification to
+                    # the module and thus add the module variable as defined more than once.
+                    add_to_def_once_sets(base_obj, def_once, def_more)
+            else:
+                # Assume the worst and say that base_obj could be modified by the call.
+                add_to_def_once_sets(base_obj, def_once, def_more)
+        if isinstance(rhs, ir.Expr) and rhs.op == 'call':
+            # If a mutable object is passed to a function, then it may be changed and
+            # therefore can't be hoisted.
+            # For each argument to the function...
+            for argvar in rhs.args:
+                # Get the argument's type.
+                if isinstance(argvar, ir.Var):
+                    argvar = argvar.name
+                avtype = typemap[argvar]
+                # If that type doesn't have a mutable attribute or it does and it's set to
+                # not mutable then this usage is safe for hoisting.
+                if getattr(avtype, 'mutable', False):
+                    # Here we have a mutable variable passed to a function so add this variable
+                    # to the def lists.
+                    add_to_def_once_sets(argvar, def_once, def_more)
+
+def wrap_find_topo(loop_body):
+    blocks = wrap_loop_body(loop_body)
+    topo_order = find_topo_order(blocks)
+    unwrap_loop_body(loop_body)
+    return topo_order
+
+def compute_def_once_internal(loop_body, def_once, def_more, getattr_taken, typemap, module_assigns):
+    '''Compute the set of variables defined exactly once in the given set of blocks
+       and use the given sets for storing which variables are defined once, more than
+       once and which have had a getattr call on them.
+    '''
+    # For each block in topological order...
+    topo_order = wrap_find_topo(loop_body)
+    for label in topo_order:
+        block = loop_body[label]
+        # Scan this block and effect changes to def_once, def_more, and getattr_taken
+        # based on the instructions in that block.
+        compute_def_once_block(block, def_once, def_more, getattr_taken, typemap, module_assigns)
+        # Have to recursively process parfors manually here.
+        for inst in block.body:
+            if isinstance(inst, parfor.Parfor):
+                # Recursively compute for the parfor's init block.
+                compute_def_once_block(inst.init_block, def_once, def_more, getattr_taken, typemap, module_assigns)
+                # Recursively compute for the parfor's loop body.
+                compute_def_once_internal(inst.loop_body, def_once, def_more, getattr_taken, typemap, module_assigns)
+
+def compute_def_once(loop_body, typemap):
+    '''Compute the set of variables defined exactly once in the given set of blocks.
+    '''
+    def_once = set()   # set to hold variables defined exactly once
+    def_more = set()   # set to hold variables defined more than once
+    getattr_taken = {}
+    module_assigns = {}
+    compute_def_once_internal(loop_body, def_once, def_more, getattr_taken, typemap, module_assigns)
+    return def_once, def_more
+
+def find_vars(var, varset):
+    assert isinstance(var, ir.Var)
+    varset.add(var.name)
+    return var
+
+def _hoist_internal(inst, dep_on_param, call_table, hoisted, not_hoisted,
+                    typemap, stored_arrays):
+    if inst.target.name in stored_arrays:
+        not_hoisted.append((inst, "stored array"))
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("Instruction", inst, "could not be hoisted because the created array is stored.")
+        return False
+
+    target_type = typemap[inst.target.name]
+
+    uses = set()
+    # Get vars used by this statement.
+    visit_vars_inner(inst.value, find_vars, uses)
+    # Filter out input parameters from the set of variable usages.
+    unhoistable = {assgn.target.name for assgn, _ in not_hoisted}
+    use_unhoist = uses & unhoistable
+    diff = uses.difference(dep_on_param)
+    diff |= use_unhoist
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("_hoist_internal:", inst, "uses:", uses, "diff:", diff)
+    if len(diff) == 0 and is_pure(inst.value, None, call_table):
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("Will hoist instruction", inst, target_type)
+        hoisted.append(inst)
+        if not isinstance(target_type, types.npytypes.Array):
+            dep_on_param += [inst.target.name]
+        return True
+    else:
+        if len(diff) > 0:
+            not_hoisted.append((inst, "dependency"))
+            if config.DEBUG_ARRAY_OPT >= 1:
+                print("Instruction", inst, "could not be hoisted because of a dependency.")
+        else:
+            not_hoisted.append((inst, "not pure"))
+            if config.DEBUG_ARRAY_OPT >= 1:
+                print("Instruction", inst, "could not be hoisted because it isn't pure.")
+    return False
+
+def find_setitems_block(setitems, itemsset, block, typemap):
+    for inst in block.body:
+        if isinstance(inst, (ir.StaticSetItem, ir.SetItem)):
+            setitems.add(inst.target.name)
+            # If we store a non-mutable object into an array then that is safe to hoist.
+            # If the stored object is mutable and you hoist then multiple entries in the
+            # outer array could reference the same object and changing one index would then
+            # change other indices.
+            if getattr(typemap[inst.value.name], "mutable", False):
+                itemsset.add(inst.value.name)
+        elif isinstance(inst, parfor.Parfor):
+            find_setitems_block(setitems, itemsset, inst.init_block, typemap)
+            find_setitems_body(setitems, itemsset, inst.loop_body, typemap)
+        elif isinstance(inst, ir.Assign):
+            # If something of mutable type is given to a build_tuple or
+            # used in a call then consider it unanalyzable and so
+            # unavailable for hoisting.
+            rhs = inst.value
+            def add_to_itemset(item):
+                assert isinstance(item, ir.Var), rhs
+                if getattr(typemap[item.name], "mutable", False):
+                    itemsset.add(item.name)
+
+            if isinstance(rhs, ir.Expr):
+                if rhs.op in ["build_tuple", "build_list", "build_set"]:
+                    for item in rhs.items:
+                        add_to_itemset(item)
+                elif rhs.op == "build_map":
+                    for pair in rhs.items:
+                        for item in pair:
+                            add_to_itemset(item)
+                elif rhs.op == "call":
+                    for item in list(rhs.args) + [x[1] for x in rhs.kws]:
+                        add_to_itemset(item)
+
+def find_setitems_body(setitems, itemsset, loop_body, typemap):
+    """
+      Find the arrays that are written into (goes into setitems) and the
+      mutable objects (mostly arrays) that are written into other arrays
+      (goes into itemsset).
+    """
+    for label, block in loop_body.items():
+        find_setitems_block(setitems, itemsset, block, typemap)
+
+def empty_container_allocator_hoist(inst, dep_on_param, call_table, hoisted,
+                                    not_hoisted, typemap, stored_arrays):
+    if (isinstance(inst, ir.Assign) and
+        isinstance(inst.value, ir.Expr) and
+        inst.value.op == 'call' and
+        inst.value.func.name in call_table):
+        call_list = call_table[inst.value.func.name]
+        if call_list == ['empty', np]:
+            return _hoist_internal(inst, dep_on_param, call_table, hoisted,
+                                   not_hoisted, typemap, stored_arrays)
+    return False
+
+def hoist(parfor_params, loop_body, typemap, wrapped_blocks):
+    dep_on_param = copy.copy(parfor_params)
+    hoisted = []
+    not_hoisted = []
+
+    # Compute the set of variable defined exactly once in the loop body.
+    def_once, def_more = compute_def_once(loop_body, typemap)
+    (call_table, reverse_call_table) = get_call_table(wrapped_blocks)
+
+    setitems = set()
+    itemsset = set()
+    find_setitems_body(setitems, itemsset, loop_body, typemap)
+    dep_on_param = list(set(dep_on_param).difference(setitems))
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("hoist - def_once:", def_once, "setitems:", setitems, "itemsset:", itemsset, "dep_on_param:", dep_on_param, "parfor_params:", parfor_params)
+    for si in setitems:
+        add_to_def_once_sets(si, def_once, def_more)
+
+    for label, block in loop_body.items():
+        new_block = []
+        for inst in block.body:
+            if empty_container_allocator_hoist(inst, dep_on_param, call_table,
+                                   hoisted, not_hoisted, typemap, itemsset):
+                continue
+            elif isinstance(inst, ir.Assign) and inst.target.name in def_once:
+                if _hoist_internal(inst, dep_on_param, call_table,
+                                   hoisted, not_hoisted, typemap, itemsset):
+                    # don't add this instruction to the block since it is
+                    # hoisted
+                    continue
+            elif isinstance(inst, parfor.Parfor):
+                new_init_block = []
+                if config.DEBUG_ARRAY_OPT >= 1:
+                    print("parfor")
+                    inst.dump()
+                for ib_inst in inst.init_block.body:
+                    if empty_container_allocator_hoist(ib_inst, dep_on_param,
+                        call_table, hoisted, not_hoisted, typemap, itemsset):
+                        continue
+                    elif (isinstance(ib_inst, ir.Assign) and
+                        ib_inst.target.name in def_once):
+                        if _hoist_internal(ib_inst, dep_on_param, call_table,
+                                           hoisted, not_hoisted, typemap,
+                                           itemsset):
+                            # don't add this instruction to the block since it is hoisted
+                            continue
+                    new_init_block.append(ib_inst)
+                inst.init_block.body = new_init_block
+
+            new_block.append(inst)
+        block.body = new_block
+    return hoisted, not_hoisted
+
+def redtyp_is_scalar(redtype):
+    return not isinstance(redtype, types.npytypes.Array)
+
+def redtyp_to_redarraytype(redtyp):
+    """Go from a reducation variable type to a reduction array type used to hold
+       per-worker results.
+    """
+    redarrdim = 1
+    # If the reduction type is an array then allocate reduction array with ndim+1 dimensions.
+    if isinstance(redtyp, types.npytypes.Array):
+        redarrdim += redtyp.ndim
+        # We don't create array of array but multi-dimensional reduction array with same dtype.
+        redtyp = redtyp.dtype
+    return types.npytypes.Array(redtyp, redarrdim, "C")
+
+def redarraytype_to_sig(redarraytyp):
+    """Given a reduction array type, find the type of the reduction argument to the gufunc.
+    """
+    assert isinstance(redarraytyp, types.npytypes.Array)
+    return types.npytypes.Array(redarraytyp.dtype, redarraytyp.ndim, redarraytyp.layout)
+
+def legalize_names_with_typemap(names, typemap):
+    """ We use ir_utils.legalize_names to replace internal IR variable names
+        containing illegal characters (e.g. period) with a legal character
+        (underscore) so as to create legal variable names.
+        The original variable names are in the typemap so we also
+        need to add the legalized name to the typemap as well.
+    """
+    outdict = legalize_names(names)
+    # For each pair in the dict of legalized names...
+    for x, y in outdict.items():
+        # If the name had some legalization change to it...
+        if x != y:
+            # Set the type of the new name the same as the type of the old name.
+            typemap[y] = typemap[x]
+    return outdict
+
+def to_scalar_from_0d(x):
+    if isinstance(x, types.ArrayCompatible):
+        if x.ndim == 0:
+            return x.dtype
+    return x
+
+def _create_gufunc_for_parfor_body(
+        lowerer,
+        parfor,
+        typemap,
+        typingctx,
+        targetctx,
+        flags,
+        locals,
+        has_aliases,
+        index_var_typ,
+        races):
+    '''
+    Takes a parfor and creates a gufunc function for its body.
+    There are two parts to this function.
+    1) Code to iterate across the iteration space as defined by the schedule.
+    2) The parfor body that does the work for a single point in the iteration space.
+    Part 1 is created as Python text for simplicity with a sentinel assignment to mark the point
+    in the IR where the parfor body should be added.
+    This Python text is 'exec'ed into existence and its IR retrieved with run_frontend.
+    The IR is scanned for the sentinel assignment where that basic block is split and the IR
+    for the parfor body inserted.
+    '''
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("starting _create_gufunc_for_parfor_body")
+
+    loc = parfor.init_block.loc
+
+    # The parfor body and the main function body share ir.Var nodes.
+    # We have to do some replacements of Var names in the parfor body to make them
+    # legal parameter names.  If we don't copy then the Vars in the main function also
+    # would incorrectly change their name.
+    loop_body = copy.copy(parfor.loop_body)
+    remove_dels(loop_body)
+
+    parfor_dim = len(parfor.loop_nests)
+    loop_indices = [l.index_variable.name for l in parfor.loop_nests]
+
+    # Get all the parfor params.
+    parfor_params = parfor.params
+    # Get just the outputs of the parfor.
+    parfor_outputs = numba.parfors.parfor.get_parfor_outputs(parfor, parfor_params)
+    # Get all parfor reduction vars, and operators.
+    typemap = lowerer.fndesc.typemap
+    parfor_redvars, parfor_reddict = numba.parfors.parfor.get_parfor_reductions(
+        lowerer.func_ir, parfor, parfor_params, lowerer.fndesc.calltypes)
+    # Compute just the parfor inputs as a set difference.
+    parfor_inputs = sorted(
+        list(
+            set(parfor_params) -
+            set(parfor_outputs) -
+            set(parfor_redvars)))
+
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("parfor_params = ", parfor_params, " ", type(parfor_params))
+        print("parfor_outputs = ", parfor_outputs, " ", type(parfor_outputs))
+        print("parfor_inputs = ", parfor_inputs, " ", type(parfor_inputs))
+        print("parfor_redvars = ", parfor_redvars, " ", type(parfor_redvars))
+
+    # -------------------------------------------------------------------------
+    # Convert tuples to individual parameters.
+    tuple_expanded_parfor_inputs = []
+    tuple_var_to_expanded_names = {}
+    expanded_name_to_tuple_var = {}
+    next_expanded_tuple_var = 0
+    parfor_tuple_params = []
+    # For each input to the parfor.
+    for pi in parfor_inputs:
+        # Get the type of the input.
+        pi_type = typemap[pi]
+        # If it is a UniTuple or Tuple we will do the conversion.
+        if isinstance(pi_type, types.UniTuple) or isinstance(pi_type, types.NamedUniTuple):
+            # Get the size and dtype of the tuple.
+            tuple_count = pi_type.count
+            tuple_dtype = pi_type.dtype
+            # Only do tuples up to config.PARFOR_MAX_TUPLE_SIZE length.
+            assert(tuple_count <= config.PARFOR_MAX_TUPLE_SIZE)
+            this_var_expansion = []
+            for i in range(tuple_count):
+                # Generate a new name for the individual part of the tuple var.
+                expanded_name = "expanded_tuple_var_" + str(next_expanded_tuple_var)
+                # Add that name to the new list of inputs to the gufunc.
+                tuple_expanded_parfor_inputs.append(expanded_name)
+                this_var_expansion.append(expanded_name)
+                # Remember a mapping from new param name to original tuple
+                # var and the index within the tuple.
+                expanded_name_to_tuple_var[expanded_name] = (pi, i)
+                next_expanded_tuple_var += 1
+                # Set the type of the new parameter.
+                typemap[expanded_name] = tuple_dtype
+            # Remember a mapping from the original tuple var to the
+            # individual parts.
+            tuple_var_to_expanded_names[pi] = this_var_expansion
+            parfor_tuple_params.append(pi)
+        elif isinstance(pi_type, types.Tuple) or isinstance(pi_type, types.NamedTuple):
+            # This is the same as above for UniTuple except that each part of
+            # the tuple can have a different type and we fetch that type with
+            # pi_type.types[offset].
+            tuple_count = pi_type.count
+            tuple_types = pi_type.types
+            # Only do tuples up to config.PARFOR_MAX_TUPLE_SIZE length.
+            assert(tuple_count <= config.PARFOR_MAX_TUPLE_SIZE)
+            this_var_expansion = []
+            for i in range(tuple_count):
+                expanded_name = "expanded_tuple_var_" + str(next_expanded_tuple_var)
+                tuple_expanded_parfor_inputs.append(expanded_name)
+                this_var_expansion.append(expanded_name)
+                expanded_name_to_tuple_var[expanded_name] = (pi, i)
+                next_expanded_tuple_var += 1
+                typemap[expanded_name] = tuple_types[i]
+            tuple_var_to_expanded_names[pi] = this_var_expansion
+            parfor_tuple_params.append(pi)
+        else:
+            tuple_expanded_parfor_inputs.append(pi)
+    parfor_inputs = tuple_expanded_parfor_inputs
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("parfor_inputs post tuple handling = ", parfor_inputs, " ", type(parfor_inputs))
+    # -------------------------------------------------------------------------
+
+    races = races.difference(set(parfor_redvars))
+    for race in races:
+        msg = ("Variable %s used in parallel loop may be written "
+               "to simultaneously by multiple workers and may result "
+               "in non-deterministic or unintended results." % race)
+        warnings.warn(NumbaParallelSafetyWarning(msg, loc))
+    replace_var_with_array(races, loop_body, typemap, lowerer.fndesc.calltypes)
+
+    # Reduction variables are represented as arrays, so they go under
+    # different names.
+    parfor_redarrs = []
+    parfor_red_arg_types = []
+    for var in parfor_redvars:
+        arr = var + "_arr"
+        parfor_redarrs.append(arr)
+        redarraytype = redtyp_to_redarraytype(typemap[var])
+        parfor_red_arg_types.append(redarraytype)
+        redarrsig = redarraytype_to_sig(redarraytype)
+        if arr in typemap:
+            assert(typemap[arr] == redarrsig)
+        else:
+            typemap[arr] = redarrsig
+
+    # Reorder all the params so that inputs go first then outputs.
+    parfor_params = parfor_inputs + parfor_outputs + parfor_redarrs
+
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("parfor_params = ", parfor_params, " ", type(parfor_params))
+        print("loop_indices = ", loop_indices, " ", type(loop_indices))
+        print("loop_body = ", loop_body, " ", type(loop_body))
+        _print_body(loop_body)
+
+    # Some Var are not legal parameter names so create a dict of potentially illegal
+    # param name to guaranteed legal name.
+    param_dict = legalize_names_with_typemap(parfor_params + parfor_redvars + parfor_tuple_params, typemap)
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print(
+            "param_dict = ",
+            sorted(
+                param_dict.items()),
+            " ",
+            type(param_dict))
+
+    # Some loop_indices are not legal parameter names so create a dict of potentially illegal
+    # loop index to guaranteed legal name.
+    ind_dict = legalize_names_with_typemap(loop_indices, typemap)
+    # Compute a new list of legal loop index names.
+    legal_loop_indices = [ind_dict[v] for v in loop_indices]
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("ind_dict = ", sorted(ind_dict.items()), " ", type(ind_dict))
+        print(
+            "legal_loop_indices = ",
+            legal_loop_indices,
+            " ",
+            type(legal_loop_indices))
+        for pd in parfor_params:
+            print("pd = ", pd)
+            print("pd type = ", typemap[pd], " ", type(typemap[pd]))
+
+    # Get the types of each parameter.
+    param_types = [to_scalar_from_0d(typemap[v]) for v in parfor_params]
+    # Calculate types of args passed to gufunc.
+    func_arg_types = [typemap[v] for v in (parfor_inputs + parfor_outputs)] + parfor_red_arg_types
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("new param_types:", param_types)
+        print("new func_arg_types:", func_arg_types)
+
+    # Replace illegal parameter names in the loop body with legal ones.
+    replace_var_names(loop_body, param_dict)
+    # remember the name before legalizing as the actual arguments
+    parfor_args = parfor_params
+    # Change parfor_params to be legal names.
+    parfor_params = [param_dict[v] for v in parfor_params]
+    parfor_params_orig = parfor_params
+
+    parfor_params = []
+    ascontig = False
+    for pindex in range(len(parfor_params_orig)):
+        if (ascontig and
+            pindex < len(parfor_inputs) and
+            isinstance(param_types[pindex], types.npytypes.Array)):
+            parfor_params.append(parfor_params_orig[pindex]+"param")
+        else:
+            parfor_params.append(parfor_params_orig[pindex])
+
+    # Change parfor body to replace illegal loop index vars with legal ones.
+    replace_var_names(loop_body, ind_dict)
+    loop_body_var_table = get_name_var_table(loop_body)
+    sentinel_name = get_unused_var_name("__sentinel__", loop_body_var_table)
+
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print(
+            "legal parfor_params = ",
+            parfor_params,
+            " ",
+            type(parfor_params))
+
+    # Determine the unique names of the scheduling and gufunc functions.
+    # sched_func_name = "__numba_parfor_sched_%s" % (hex(hash(parfor)).replace("-", "_"))
+    gufunc_name = "__numba_parfor_gufunc_%s" % (
+        hex(hash(parfor)).replace("-", "_"))
+    if config.DEBUG_ARRAY_OPT:
+        # print("sched_func_name ", type(sched_func_name), " ", sched_func_name)
+        print("gufunc_name ", type(gufunc_name), " ", gufunc_name)
+
+    gufunc_txt = ""
+
+    # Create the gufunc function.
+    gufunc_txt += "def " + gufunc_name + \
+        "(sched, " + (", ".join(parfor_params)) + "):\n"
+
+    globls = {"np": np, "numba": numba}
+
+    # First thing in the gufunc, we reconstruct tuples from their
+    # individual parts, e.g., orig_tup_name = (part1, part2,).
+    # The rest of the code of the function will use the original tuple name.
+    for tup_var, exp_names in tuple_var_to_expanded_names.items():
+        tup_type = typemap[tup_var]
+        gufunc_txt += "    " + param_dict[tup_var]
+        # Determine if the tuple is a named tuple.
+        if (isinstance(tup_type, types.NamedTuple) or
+            isinstance(tup_type, types.NamedUniTuple)):
+            named_tup = True
+        else:
+            named_tup = False
+
+        if named_tup:
+            # It is a named tuple so try to find the global that defines the
+            # named tuple.
+            func_def = guard(get_definition, lowerer.func_ir, tup_var)
+            named_tuple_def = None
+            if config.DEBUG_ARRAY_OPT:
+                print("func_def:", func_def, type(func_def))
+            if func_def is not None:
+                if (isinstance(func_def, ir.Expr) and
+                    func_def.op == 'call'):
+                    named_tuple_def = guard(get_definition, lowerer.func_ir, func_def.func)
+                    if config.DEBUG_ARRAY_OPT:
+                        print("named_tuple_def:", named_tuple_def, type(named_tuple_def))
+                elif isinstance(func_def, ir.Arg):
+                    named_tuple_def = typemap[func_def.name]
+                    if config.DEBUG_ARRAY_OPT:
+                        print("named_tuple_def:", named_tuple_def,
+                              type(named_tuple_def), named_tuple_def.name)
+            if named_tuple_def is not None:
+                if (isinstance(named_tuple_def, ir.Global) or
+                    isinstance(named_tuple_def, ir.FreeVar)):
+                    gval = named_tuple_def.value
+                    if config.DEBUG_ARRAY_OPT:
+                        print("gval:", gval, type(gval))
+                    globls[named_tuple_def.name] = gval
+                elif isinstance(named_tuple_def, types.containers.BaseNamedTuple):
+                    named_tuple_name = named_tuple_def.name.split('(')[0]
+                    if config.DEBUG_ARRAY_OPT:
+                        print("name:", named_tuple_name,
+                              named_tuple_def.instance_class,
+                              type(named_tuple_def.instance_class))
+                    globls[named_tuple_name] = named_tuple_def.instance_class
+            else:
+                if config.DEBUG_ARRAY_OPT:
+                    print("Didn't find definition of namedtuple for globls.")
+                raise CompilerError("Could not find definition of " + str(tup_var),
+                                     tup_var.loc)
+            gufunc_txt += " = " + tup_type.instance_class.__name__ + "("
+            for name, field_name in zip(exp_names, tup_type.fields):
+                gufunc_txt += field_name + "=" + param_dict[name] + ","
+        else:
+            # Just a regular tuple so use (part0, part1, ...)
+            gufunc_txt += " = (" + ", ".join([param_dict[x] for x in exp_names])
+            if len(exp_names) == 1:
+                # Add comma for tuples with singular values.  We can't unilaterally
+                # add a comma always because (,) isn't valid.
+                gufunc_txt += ","
+
+        gufunc_txt += ")\n"
+
+    for pindex in range(len(parfor_inputs)):
+        if ascontig and isinstance(param_types[pindex], types.npytypes.Array):
+            gufunc_txt += ("    " + parfor_params_orig[pindex]
+                + " = np.ascontiguousarray(" + parfor_params[pindex] + ")\n")
+
+    gufunc_thread_id_var = "ParallelAcceleratorGufuncThreadId"
+
+    if len(parfor_redarrs) > 0:
+        gufunc_txt += "    " + gufunc_thread_id_var + " = "
+        gufunc_txt += "numba.np.ufunc.parallel._iget_thread_id()\n"
+
+    # Add initialization of reduction variables
+    for arr, var in zip(parfor_redarrs, parfor_redvars):
+        gufunc_txt += "    " + param_dict[var] + \
+             "=" + param_dict[arr] + "[" + gufunc_thread_id_var + "]\n"
+        if config.DEBUG_ARRAY_OPT_RUNTIME:
+            gufunc_txt += "    print(\"thread id =\", ParallelAcceleratorGufuncThreadId)\n"
+            gufunc_txt += "    print(\"initial reduction value\",ParallelAcceleratorGufuncThreadId," + param_dict[var] + "," + param_dict[var] + ".shape)\n"
+            gufunc_txt += "    print(\"reduction array\",ParallelAcceleratorGufuncThreadId," + param_dict[arr] + "," + param_dict[arr] + ".shape)\n"
+
+    # For each dimension of the parfor, create a for loop in the generated gufunc function.
+    # Iterate across the proper values extracted from the schedule.
+    # The form of the schedule is start_dim0, start_dim1, ..., start_dimN, end_dim0,
+    # end_dim1, ..., end_dimN
+    for eachdim in range(parfor_dim):
+        for indent in range(eachdim + 1):
+            gufunc_txt += "    "
+        sched_dim = eachdim
+        gufunc_txt += ("for " +
+                       legal_loop_indices[eachdim] +
+                       " in range(sched[" +
+                       str(sched_dim) +
+                       "], sched[" +
+                       str(sched_dim +
+                           parfor_dim) +
+                       "] + np.uint8(1)):\n")
+
+    if config.DEBUG_ARRAY_OPT_RUNTIME:
+        for indent in range(parfor_dim + 1):
+            gufunc_txt += "    "
+        gufunc_txt += "print("
+        for eachdim in range(parfor_dim):
+            gufunc_txt += "\"" + legal_loop_indices[eachdim] + "\"," + legal_loop_indices[eachdim] + ","
+        gufunc_txt += ")\n"
+
+    # Add the sentinel assignment so that we can find the loop body position
+    # in the IR.
+    for indent in range(parfor_dim + 1):
+        gufunc_txt += "    "
+    gufunc_txt += sentinel_name + " = 0\n"
+    # Add assignments of reduction variables (for returning the value)
+    for arr, var in zip(parfor_redarrs, parfor_redvars):
+        if config.DEBUG_ARRAY_OPT_RUNTIME:
+            gufunc_txt += "    print(\"final reduction value\",ParallelAcceleratorGufuncThreadId," + param_dict[var] + ")\n"
+            gufunc_txt += "    print(\"final reduction array\",ParallelAcceleratorGufuncThreadId," + param_dict[arr] + ")\n"
+        # After the gufunc loops, copy the accumulated temp value back to reduction array.
+        gufunc_txt += "    " + param_dict[arr] + \
+            "[" + gufunc_thread_id_var + "] = " + param_dict[var] + "\n"
+    gufunc_txt += "    return None\n"
+
+    if config.DEBUG_ARRAY_OPT:
+        print("gufunc_txt = ", type(gufunc_txt), "\n", gufunc_txt)
+        print("globls:", globls, type(globls))
+    # Force gufunc outline into existence.
+    locls = {}
+    exec(gufunc_txt, globls, locls)
+    gufunc_func = locls[gufunc_name]
+
+    if config.DEBUG_ARRAY_OPT:
+        print("gufunc_func = ", type(gufunc_func), "\n", gufunc_func)
+    # Get the IR for the gufunc outline.
+    gufunc_ir = compiler.run_frontend(gufunc_func)
+    if config.DEBUG_ARRAY_OPT:
+        print("gufunc_ir dump ", type(gufunc_ir))
+        gufunc_ir.dump()
+        print("loop_body dump ", type(loop_body))
+        _print_body(loop_body)
+
+    # rename all variables in gufunc_ir afresh
+    var_table = get_name_var_table(gufunc_ir.blocks)
+    new_var_dict = {}
+    reserved_names = [sentinel_name] + \
+        list(param_dict.values()) + legal_loop_indices
+    for name, var in var_table.items():
+        if not (name in reserved_names):
+            new_var_dict[name] = parfor.init_block.scope.redefine(name, loc).name
+    replace_var_names(gufunc_ir.blocks, new_var_dict)
+    if config.DEBUG_ARRAY_OPT:
+        print("gufunc_ir dump after renaming ")
+        gufunc_ir.dump()
+    gufunc_param_types = [types.npytypes.Array(
+            index_var_typ, 1, "C")] + param_types
+    if config.DEBUG_ARRAY_OPT:
+        print(
+            "gufunc_param_types = ",
+            type(gufunc_param_types),
+            "\n",
+            gufunc_param_types)
+
+    gufunc_stub_last_label = find_max_label(gufunc_ir.blocks) + 1
+
+    # Add gufunc stub last label to each parfor.loop_body label to prevent
+    # label conflicts.
+    loop_body = add_offset_to_labels(loop_body, gufunc_stub_last_label)
+    # new label for splitting sentinel block
+    new_label = find_max_label(loop_body) + 1
+
+    # If enabled, add a print statement after every assignment.
+    if config.DEBUG_ARRAY_OPT_RUNTIME:
+        for label, block in loop_body.items():
+            new_block = block.copy()
+            new_block.clear()
+            loc = block.loc
+            scope = block.scope
+            for inst in block.body:
+                new_block.append(inst)
+                # Append print after assignment
+                if isinstance(inst, ir.Assign):
+                    # Only apply to numbers
+                    if typemap[inst.target.name] not in types.number_domain:
+                        continue
+
+                    # Make constant string
+                    strval = "{} =".format(inst.target.name)
+                    strconsttyp = types.StringLiteral(strval)
+
+                    lhs = scope.redefine("str_const", loc)
+                    # lhs = ir.Var(scope, mk_unique_var("str_const"), loc)
+                    assign_lhs = ir.Assign(value=ir.Const(value=strval, loc=loc),
+                                           target=lhs, loc=loc)
+                    typemap[lhs.name] = strconsttyp
+                    new_block.append(assign_lhs)
+
+                    # Make print node
+                    print_node = ir.Print(args=[lhs, inst.target], vararg=None, loc=loc)
+                    new_block.append(print_node)
+                    sig = numba.core.typing.signature(types.none,
+                                           typemap[lhs.name],
+                                           typemap[inst.target.name])
+                    lowerer.fndesc.calltypes[print_node] = sig
+            loop_body[label] = new_block
+
+    if config.DEBUG_ARRAY_OPT:
+        print("parfor loop body")
+        _print_body(loop_body)
+
+    wrapped_blocks = wrap_loop_body(loop_body)
+    hoisted, not_hoisted = hoist(parfor_params, loop_body, typemap, wrapped_blocks)
+    start_block = gufunc_ir.blocks[min(gufunc_ir.blocks.keys())]
+    start_block.body = start_block.body[:-1] + hoisted + [start_block.body[-1]]
+    unwrap_loop_body(loop_body)
+
+    # store hoisted into diagnostics
+    diagnostics = lowerer.metadata['parfor_diagnostics']
+    diagnostics.hoist_info[parfor.id] = {'hoisted': hoisted,
+                                         'not_hoisted': not_hoisted}
+
+    if config.DEBUG_ARRAY_OPT:
+        print("After hoisting")
+        _print_body(loop_body)
+
+    # Search all the block in the gufunc outline for the sentinel assignment.
+    for label, block in gufunc_ir.blocks.items():
+        for i, inst in enumerate(block.body):
+            if isinstance(
+                    inst,
+                    ir.Assign) and inst.target.name == sentinel_name:
+                # We found the sentinel assignment.
+                loc = inst.loc
+                scope = block.scope
+                # split block across __sentinel__
+                # A new block is allocated for the statements prior to the sentinel
+                # but the new block maintains the current block label.
+                prev_block = ir.Block(scope, loc)
+                prev_block.body = block.body[:i]
+                # The current block is used for statements after the sentinel.
+                block.body = block.body[i + 1:]
+                # But the current block gets a new label.
+                body_first_label = min(loop_body.keys())
+
+                # The previous block jumps to the minimum labelled block of the
+                # parfor body.
+                prev_block.append(ir.Jump(body_first_label, loc))
+                # Add all the parfor loop body blocks to the gufunc function's
+                # IR.
+                for (l, b) in loop_body.items():
+                    gufunc_ir.blocks[l] = transfer_scope(b, scope)
+                body_last_label = max(loop_body.keys())
+                gufunc_ir.blocks[new_label] = block
+                gufunc_ir.blocks[label] = prev_block
+                # Add a jump from the last parfor body block to the block containing
+                # statements after the sentinel.
+                gufunc_ir.blocks[body_last_label].append(
+                    ir.Jump(new_label, loc))
+                break
+        else:
+            continue
+        break
+
+    if config.DEBUG_ARRAY_OPT:
+        print("gufunc_ir last dump before renaming")
+        gufunc_ir.dump()
+
+    gufunc_ir.blocks = rename_labels(gufunc_ir.blocks)
+    remove_dels(gufunc_ir.blocks)
+
+    if config.DEBUG_ARRAY_OPT:
+        print("gufunc_ir last dump")
+        gufunc_ir.dump()
+        print("flags", flags)
+        print("typemap", typemap)
+
+    old_alias = flags.noalias
+    if not has_aliases:
+        if config.DEBUG_ARRAY_OPT:
+            print("No aliases found so adding noalias flag.")
+        flags.noalias = True
+
+    fixup_var_define_in_scope(gufunc_ir.blocks)
+
+    class ParforGufuncCompiler(compiler.CompilerBase):
+        def define_pipelines(self):
+            from numba.core.compiler_machinery import PassManager
+            dpb = compiler.DefaultPassBuilder
+            pm = PassManager("full_parfor_gufunc")
+            parfor_gufunc_passes = dpb.define_parfor_gufunc_pipeline(self.state)
+            pm.passes.extend(parfor_gufunc_passes.passes)
+            lowering_passes = dpb.define_parfor_gufunc_nopython_lowering_pipeline(self.state)
+            pm.passes.extend(lowering_passes.passes)
+
+            pm.finalize()
+            return [pm]
+
+    kernel_func = compiler.compile_ir(
+        typingctx,
+        targetctx,
+        gufunc_ir,
+        gufunc_param_types,
+        types.none,
+        flags,
+        locals,
+        pipeline_class=ParforGufuncCompiler)
+
+    flags.noalias = old_alias
+
+    kernel_sig = signature(types.none, *gufunc_param_types)
+    if config.DEBUG_ARRAY_OPT:
+        print("finished create_gufunc_for_parfor_body. kernel_sig = ", kernel_sig)
+
+    return kernel_func, parfor_args, kernel_sig, func_arg_types, expanded_name_to_tuple_var
+
+def replace_var_with_array_in_block(vars, block, typemap, calltypes):
+    new_block = []
+    for inst in block.body:
+        if isinstance(inst, ir.Assign) and inst.target.name in vars:
+            loc = inst.loc
+            scope = inst.target.scope
+
+            const_node = ir.Const(0, loc)
+            const_var = scope.redefine("$const_ind_0", loc)
+            typemap[const_var.name] = types.uintp
+            const_assign = ir.Assign(const_node, const_var, loc)
+            new_block.append(const_assign)
+
+            val_var = scope.redefine("$val", loc)
+            typemap[val_var.name] = typemap[inst.target.name]
+            new_block.append(ir.Assign(inst.value, val_var, loc))
+            setitem_node = ir.SetItem(inst.target, const_var, val_var, loc)
+            calltypes[setitem_node] = signature(
+                types.none, types.npytypes.Array(typemap[inst.target.name], 1, "C"), types.intp, typemap[inst.target.name])
+            new_block.append(setitem_node)
+            continue
+        elif isinstance(inst, parfor.Parfor):
+            replace_var_with_array_internal(vars, {0: inst.init_block}, typemap, calltypes)
+            replace_var_with_array_internal(vars, inst.loop_body, typemap, calltypes)
+
+        new_block.append(inst)
+    return new_block
+
+def replace_var_with_array_internal(vars, loop_body, typemap, calltypes):
+    for label, block in loop_body.items():
+        block.body = replace_var_with_array_in_block(vars, block, typemap, calltypes)
+
+def replace_var_with_array(vars, loop_body, typemap, calltypes):
+    replace_var_with_array_internal(vars, loop_body, typemap, calltypes)
+    for v in vars:
+        el_typ = typemap[v]
+        typemap.pop(v, None)
+        typemap[v] = types.npytypes.Array(el_typ, 1, "C")
+
+def call_parallel_gufunc(lowerer, cres, gu_signature, outer_sig, expr_args, expr_arg_types,
+                         loop_ranges, redvars, reddict, redarrdict, init_block, index_var_typ, races,
+                         exp_name_to_tuple_var):
+    '''
+    Adds the call to the gufunc function from the main function.
+    '''
+    context = lowerer.context
+    builder = lowerer.builder
+
+    from numba.np.ufunc.parallel import (build_gufunc_wrapper,
+                           _launch_threads)
+
+    if config.DEBUG_ARRAY_OPT:
+        print("make_parallel_loop")
+        print("outer_sig = ", outer_sig.args, outer_sig.return_type,
+              outer_sig.recvr, outer_sig.pysig)
+        print("loop_ranges = ", loop_ranges)
+        print("expr_args", expr_args)
+        print("expr_arg_types", expr_arg_types)
+        print("gu_signature", gu_signature)
+
+    # Build the wrapper for GUFunc
+    args, return_type = sigutils.normalize_signature(outer_sig)
+    llvm_func = cres.library.get_function(cres.fndesc.llvm_func_name)
+    sin, sout = gu_signature
+
+    # These are necessary for build_gufunc_wrapper to find external symbols
+    _launch_threads()
+
+    info = build_gufunc_wrapper(llvm_func, cres, sin, sout,
+                                cache=False, is_parfors=True)
+    wrapper_name = info.name
+    cres.library._ensure_finalized()
+
+    if config.DEBUG_ARRAY_OPT:
+        print("parallel function = ", wrapper_name, cres)
+
+    # loadvars for loop_ranges
+    def load_range(v):
+        if isinstance(v, ir.Var):
+            return lowerer.loadvar(v.name)
+        else:
+            return context.get_constant(types.uintp, v)
+
+    num_dim = len(loop_ranges)
+    for i in range(num_dim):
+        start, stop, step = loop_ranges[i]
+        start = load_range(start)
+        stop = load_range(stop)
+        assert(step == 1)  # We do not support loop steps other than 1
+        step = load_range(step)
+        loop_ranges[i] = (start, stop, step)
+
+        if config.DEBUG_ARRAY_OPT:
+            print("call_parallel_gufunc loop_ranges[{}] = ".format(i), start,
+                  stop, step)
+            cgutils.printf(builder, "loop range[{}]: %d %d (%d)\n".format(i),
+                           start, stop, step)
+
+    # Commonly used LLVM types and constants
+    byte_t = llvmlite.ir.IntType(8)
+    byte_ptr_t = llvmlite.ir.PointerType(byte_t)
+    byte_ptr_ptr_t = llvmlite.ir.PointerType(byte_ptr_t)
+    intp_t = context.get_value_type(types.intp)
+    uintp_t = context.get_value_type(types.uintp)
+    intp_ptr_t = llvmlite.ir.PointerType(intp_t)
+    intp_ptr_ptr_t = llvmlite.ir.PointerType(intp_ptr_t)
+    uintp_ptr_t = llvmlite.ir.PointerType(uintp_t)
+    uintp_ptr_ptr_t = llvmlite.ir.PointerType(uintp_ptr_t)
+    zero = context.get_constant(types.uintp, 0)
+    one = context.get_constant(types.uintp, 1)
+    one_type = one.type
+    sizeof_intp = context.get_abi_sizeof(intp_t)
+
+    # Prepare sched, first pop it out of expr_args, outer_sig, and gu_signature
+    expr_args.pop(0)
+    sched_sig = sin.pop(0)
+
+    if config.DEBUG_ARRAY_OPT:
+        print("Parfor has potentially negative start", index_var_typ.signed)
+
+    if index_var_typ.signed:
+        sched_type = intp_t
+        sched_ptr_type = intp_ptr_t
+        sched_ptr_ptr_type = intp_ptr_ptr_t
+    else:
+        sched_type = uintp_t
+        sched_ptr_type = uintp_ptr_t
+        sched_ptr_ptr_type = uintp_ptr_ptr_t
+
+    # Call do_scheduling with appropriate arguments
+    dim_starts = cgutils.alloca_once(
+        builder, sched_type, size=context.get_constant(
+            types.uintp, num_dim), name="dim_starts")
+    dim_stops = cgutils.alloca_once(
+        builder, sched_type, size=context.get_constant(
+            types.uintp, num_dim), name="dim_stops")
+    for i in range(num_dim):
+        start, stop, step = loop_ranges[i]
+        if start.type != one_type:
+            start = builder.sext(start, one_type)
+        if stop.type != one_type:
+            stop = builder.sext(stop, one_type)
+        if step.type != one_type:
+            step = builder.sext(step, one_type)
+        # substract 1 because do-scheduling takes inclusive ranges
+        stop = builder.sub(stop, one)
+        builder.store(
+            start, builder.gep(
+                dim_starts, [
+                    context.get_constant(
+                        types.uintp, i)]))
+        builder.store(stop, builder.gep(dim_stops,
+                                        [context.get_constant(types.uintp, i)]))
+
+    # Prepare to call get/set parallel_chunksize and get the number of threads.
+    get_chunksize = cgutils.get_or_insert_function(
+        builder.module,
+        llvmlite.ir.FunctionType(uintp_t, []),
+        name="get_parallel_chunksize")
+
+    set_chunksize = cgutils.get_or_insert_function(
+        builder.module,
+        llvmlite.ir.FunctionType(llvmlite.ir.VoidType(), [uintp_t]),
+        name="set_parallel_chunksize")
+
+    get_num_threads = cgutils.get_or_insert_function(
+        builder.module,
+        llvmlite.ir.FunctionType(llvmlite.ir.IntType(types.intp.bitwidth), []),
+        "get_num_threads")
+
+    # Get the current number of threads.
+    num_threads = builder.call(get_num_threads, [])
+    # Get the current chunksize so we can use it and restore the value later.
+    current_chunksize = builder.call(get_chunksize, [])
+
+    with cgutils.if_unlikely(builder, builder.icmp_signed('<=', num_threads,
+                                                  num_threads.type(0))):
+        cgutils.printf(builder, "num_threads: %d\n", num_threads)
+        context.call_conv.return_user_exc(builder, RuntimeError,
+                                                  ("Invalid number of threads. "
+                                                   "This likely indicates a bug in Numba.",))
+
+    # Call get_sched_size from gufunc_scheduler.cpp that incorporates the size of the work,
+    # the number of threads and the selected chunk size.  This will tell us how many entries
+    # in the schedule we will need.
+    get_sched_size_fnty = llvmlite.ir.FunctionType(uintp_t, [uintp_t, uintp_t, intp_ptr_t, intp_ptr_t])
+    get_sched_size = cgutils.get_or_insert_function(
+        builder.module,
+        get_sched_size_fnty,
+        name="get_sched_size")
+    num_divisions = builder.call(get_sched_size, [num_threads,
+                                                  context.get_constant(types.uintp, num_dim),
+                                                  dim_starts,
+                                                  dim_stops])
+    # Set the chunksize to zero so that any nested calls get the default chunk size behavior.
+    builder.call(set_chunksize, [zero])
+
+    # Each entry in the schedule is 2 times the number of dimensions long.
+    multiplier = context.get_constant(types.uintp, num_dim * 2)
+    # Compute the total number of entries in the schedule.
+    sched_size = builder.mul(num_divisions, multiplier)
+
+    # Prepare to dynamically allocate memory to hold the schedule.
+    alloc_sched_fnty = llvmlite.ir.FunctionType(sched_ptr_type, [uintp_t])
+    alloc_sched_func = cgutils.get_or_insert_function(
+        builder.module,
+        alloc_sched_fnty,
+        name="allocate_sched")
+    # Call gufunc_scheduler.cpp to allocate the schedule.
+    # This may or may not do pooling.
+    alloc_space = builder.call(alloc_sched_func, [sched_size])
+    # Allocate a slot in the entry block to store the schedule pointer.
+    sched = cgutils.alloca_once(builder, sched_ptr_type)
+    # Store the schedule pointer into that slot.
+    builder.store(alloc_space, sched)
+
+    debug_flag = 1 if config.DEBUG_ARRAY_OPT else 0
+    scheduling_fnty = llvmlite.ir.FunctionType(
+        intp_ptr_t, [uintp_t, intp_ptr_t, intp_ptr_t, uintp_t, sched_ptr_type, intp_t])
+    if index_var_typ.signed:
+        do_scheduling = cgutils.get_or_insert_function(builder.module,
+                                                       scheduling_fnty,
+                                                       name="do_scheduling_signed")
+    else:
+        do_scheduling = cgutils.get_or_insert_function(builder.module,
+                                                       scheduling_fnty,
+                                                       name="do_scheduling_unsigned")
+
+    # Call the scheduling routine that decides how to break up the work.
+    builder.call(
+        do_scheduling, [
+            context.get_constant(
+                types.uintp, num_dim), dim_starts, dim_stops, num_divisions,
+            builder.load(sched), context.get_constant(
+                    types.intp, debug_flag)])
+
+    # Get the LLVM vars for the Numba IR reduction array vars.
+    redarrs = [lowerer.loadvar(redarrdict[x].name) for x in redvars]
+
+    nredvars = len(redvars)
+    ninouts = len(expr_args) - nredvars
+
+    def load_potential_tuple_var(x):
+        """Given a variable name, if that variable is not a new name
+           introduced as the extracted part of a tuple then just return
+           the variable loaded from its name.  However, if the variable
+           does represent part of a tuple, as recognized by the name of
+           the variable being present in the exp_name_to_tuple_var dict,
+           then we load the original tuple var instead that we get from
+           the dict and then extract the corresponding element of the
+           tuple, also stored and returned to use in the dict (i.e., offset).
+        """
+        if x in exp_name_to_tuple_var:
+            orig_tup, offset = exp_name_to_tuple_var[x]
+            tup_var = lowerer.loadvar(orig_tup)
+            res = builder.extract_value(tup_var, offset)
+            return res
+        else:
+            return lowerer.loadvar(x)
+
+    # ----------------------------------------------------------------------------
+    # Prepare arguments: args, shapes, steps, data
+    all_args = [load_potential_tuple_var(x) for x in expr_args[:ninouts]] + redarrs
+    num_args = len(all_args)
+    num_inps = len(sin) + 1
+    args = cgutils.alloca_once(
+        builder,
+        byte_ptr_t,
+        size=context.get_constant(
+            types.intp,
+            1 + num_args),
+        name="pargs")
+    array_strides = []
+    # sched goes first
+    builder.store(builder.bitcast(builder.load(sched), byte_ptr_t), args)
+    array_strides.append(context.get_constant(types.intp, sizeof_intp))
+    rv_to_arg_dict = {}
+    # followed by other arguments
+    for i in range(num_args):
+        arg = all_args[i]
+        var = expr_args[i]
+        aty = expr_arg_types[i]
+        dst = builder.gep(args, [context.get_constant(types.intp, i + 1)])
+        if i >= ninouts:  # reduction variables
+            ary = context.make_array(aty)(context, builder, arg)
+            strides = cgutils.unpack_tuple(builder, ary.strides, aty.ndim)
+            # Start from 1 because we skip the first dimension of length num_threads just like sched.
+            for j in range(len(strides)):
+                array_strides.append(strides[j])
+            builder.store(builder.bitcast(ary.data, byte_ptr_t), dst)
+        elif isinstance(aty, types.ArrayCompatible):
+            if var in races:
+                typ = (context.get_data_type(aty.dtype)
+                       if aty.dtype != types.boolean
+                       else llvmlite.ir.IntType(1))
+
+                rv_arg = cgutils.alloca_once(builder, typ)
+                builder.store(arg, rv_arg)
+                builder.store(builder.bitcast(rv_arg, byte_ptr_t), dst)
+                rv_to_arg_dict[var] = (arg, rv_arg)
+
+                array_strides.append(context.get_constant(types.intp, context.get_abi_sizeof(typ)))
+            else:
+                ary = context.make_array(aty)(context, builder, arg)
+                strides = cgutils.unpack_tuple(builder, ary.strides, aty.ndim)
+                for j in range(len(strides)):
+                    array_strides.append(strides[j])
+                builder.store(builder.bitcast(ary.data, byte_ptr_t), dst)
+        else:
+            if i < num_inps:
+                # Scalar input, need to store the value in an array of size 1
+                if isinstance(aty, types.Optional):
+                    # Unpack optional type
+                    unpacked_aty = aty.type
+                    arg = context.cast(builder, arg, aty, unpacked_aty)
+                else:
+                    unpacked_aty = aty
+                typ = (context.get_data_type(unpacked_aty)
+                       if not isinstance(unpacked_aty, types.Boolean)
+                       else llvmlite.ir.IntType(1))
+                ptr = cgutils.alloca_once(builder, typ)
+                builder.store(arg, ptr)
+            else:
+                # Scalar output, must allocate
+                typ = (context.get_data_type(aty)
+                       if not isinstance(aty, types.Boolean)
+                       else llvmlite.ir.IntType(1))
+                ptr = cgutils.alloca_once(builder, typ)
+            builder.store(builder.bitcast(ptr, byte_ptr_t), dst)
+
+    # ----------------------------------------------------------------------------
+    # Next, we prepare the individual dimension info recorded in gu_signature
+    sig_dim_dict = {}
+    occurrences = []
+    occurrences = [sched_sig[0]]
+    sig_dim_dict[sched_sig[0]] = context.get_constant(types.intp, 2 * num_dim)
+    assert len(expr_args) == len(all_args)
+    assert len(expr_args) == len(expr_arg_types)
+    assert len(expr_args) == len(sin + sout)
+    assert len(expr_args) == len(outer_sig.args[1:])
+    for var, arg, aty, gu_sig in zip(expr_args, all_args,
+                                     expr_arg_types, sin + sout):
+        if isinstance(aty, types.npytypes.Array):
+            i = aty.ndim - len(gu_sig)
+        else:
+            i = 0
+        if config.DEBUG_ARRAY_OPT:
+            print("var =", var, "gu_sig =", gu_sig, "type =", aty, "i =", i)
+
+        for dim_sym in gu_sig:
+            if config.DEBUG_ARRAY_OPT:
+                print("var = ", var, " type = ", aty)
+            if var in races:
+                sig_dim_dict[dim_sym] = context.get_constant(types.intp, 1)
+            else:
+                ary = context.make_array(aty)(context, builder, arg)
+                shapes = cgutils.unpack_tuple(builder, ary.shape, aty.ndim)
+                sig_dim_dict[dim_sym] = shapes[i]
+
+            if not (dim_sym in occurrences):
+                if config.DEBUG_ARRAY_OPT:
+                    print("dim_sym = ", dim_sym, ", i = ", i)
+                    cgutils.printf(builder, dim_sym + " = %d\n", sig_dim_dict[dim_sym])
+                occurrences.append(dim_sym)
+            i = i + 1
+
+    # ----------------------------------------------------------------------------
+    # Prepare shapes, which is a single number (outer loop size), followed by
+    # the size of individual shape variables.
+    nshapes = len(sig_dim_dict) + 1
+    shapes = cgutils.alloca_once(builder, intp_t, size=nshapes, name="pshape")
+    # For now, outer loop size is the same as number of threads
+    builder.store(num_divisions, shapes)
+    # Individual shape variables go next
+    i = 1
+    for dim_sym in occurrences:
+        if config.DEBUG_ARRAY_OPT:
+            cgutils.printf(builder, dim_sym + " = %d\n", sig_dim_dict[dim_sym])
+        builder.store(
+            sig_dim_dict[dim_sym], builder.gep(
+                shapes, [
+                    context.get_constant(
+                        types.intp, i)]))
+        i = i + 1
+
+    # ----------------------------------------------------------------------------
+    # Prepare steps for each argument. Note that all steps are counted in
+    # bytes.
+    num_steps = num_args + 1 + len(array_strides)
+    steps = cgutils.alloca_once(
+        builder, intp_t, size=context.get_constant(
+            types.intp, num_steps), name="psteps")
+    # First goes the step size for sched, which is 2 * num_dim
+    builder.store(context.get_constant(types.intp, 2 * num_dim * sizeof_intp),
+                  steps)
+    # The steps for all others are 0, except for reduction results.
+    for i in range(num_args):
+        # steps are strides from one thread to the next
+        stepsize = zero
+
+        dst = builder.gep(steps, [context.get_constant(types.intp, 1 + i)])
+        builder.store(stepsize, dst)
+    for j in range(len(array_strides)):
+        dst = builder.gep(
+            steps, [
+                context.get_constant(
+                    types.intp, 1 + num_args + j)])
+        builder.store(array_strides[j], dst)
+
+    # ----------------------------------------------------------------------------
+    # prepare data
+    data = cgutils.get_null_value(byte_ptr_t)
+
+    fnty = llvmlite.ir.FunctionType(llvmlite.ir.VoidType(),
+                                    [byte_ptr_ptr_t, intp_ptr_t,
+                                     intp_ptr_t, byte_ptr_t])
+
+    fn = cgutils.get_or_insert_function(builder.module, fnty, wrapper_name)
+    context.active_code_library.add_linking_library(info.library)
+
+    if config.DEBUG_ARRAY_OPT:
+        cgutils.printf(builder, "before calling kernel %p\n", fn)
+    builder.call(fn, [args, shapes, steps, data])
+    if config.DEBUG_ARRAY_OPT:
+        cgutils.printf(builder, "after calling kernel %p\n", fn)
+
+    builder.call(set_chunksize, [current_chunksize])
+
+    # Deallocate the schedule's memory.
+    dealloc_sched_fnty = llvmlite.ir.FunctionType(llvmlite.ir.VoidType(), [sched_ptr_type])
+    dealloc_sched_func = cgutils.get_or_insert_function(
+        builder.module,
+        dealloc_sched_fnty,
+        name="deallocate_sched")
+    builder.call(dealloc_sched_func, [builder.load(sched)])
+
+    for k, v in rv_to_arg_dict.items():
+        arg, rv_arg = v
+        only_elem_ptr = builder.gep(rv_arg, [context.get_constant(types.intp, 0)])
+        builder.store(builder.load(only_elem_ptr), lowerer.getvar(k))
+
+    context.active_code_library.add_linking_library(cres.library)

shared/package-files/d1/d123e0b4c2614f680808b58cca0c140ba187494b2c8bcf8c604c7eb739c70882/zh_hk.msg

@@ -0,0 +1,28 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset zh_HK DAYS_OF_WEEK_ABBREV [list \
+        "\u65e5"\
+        "\u4e00"\
+        "\u4e8c"\
+        "\u4e09"\
+        "\u56db"\
+        "\u4e94"\
+        "\u516d"]
+    ::msgcat::mcset zh_HK MONTHS_ABBREV [list \
+        "1\u6708"\
+        "2\u6708"\
+        "3\u6708"\
+        "4\u6708"\
+        "5\u6708"\
+        "6\u6708"\
+        "7\u6708"\
+        "8\u6708"\
+        "9\u6708"\
+        "10\u6708"\
+        "11\u6708"\
+        "12\u6708"\
+        ""]
+    ::msgcat::mcset zh_HK DATE_FORMAT "%Y\u5e74%m\u6708%e\u65e5"
+    ::msgcat::mcset zh_HK TIME_FORMAT_12 "%P%I:%M:%S"
+    ::msgcat::mcset zh_HK DATE_TIME_FORMAT "%Y\u5e74%m\u6708%e\u65e5 %P%I:%M:%S %z"
+}

shared/package-files/d1/d12457044da126028937f45fe199f4d282970bf4e46b779f3d6338ef383a0686/diagnose.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+import os
+import sys
+import tempfile
+
+
+def run_command(cmd):
+    print('Running %r:' % (cmd))
+    os.system(cmd)
+    print('------')
+
+
+def run():
+    _path = os.getcwd()
+    os.chdir(tempfile.gettempdir())
+    print('------')
+    print('os.name=%r' % (os.name))
+    print('------')
+    print('sys.platform=%r' % (sys.platform))
+    print('------')
+    print('sys.version:')
+    print(sys.version)
+    print('------')
+    print('sys.prefix:')
+    print(sys.prefix)
+    print('------')
+    print('sys.path=%r' % (':'.join(sys.path)))
+    print('------')
+
+    try:
+        import numpy
+        has_newnumpy = 1
+    except ImportError as e:
+        print('Failed to import new numpy:', e)
+        has_newnumpy = 0
+
+    try:
+        from numpy.f2py import f2py2e
+        has_f2py2e = 1
+    except ImportError as e:
+        print('Failed to import f2py2e:', e)
+        has_f2py2e = 0
+
+    try:
+        import numpy.distutils
+        has_numpy_distutils = 2
+    except ImportError:
+        try:
+            import numpy_distutils
+            has_numpy_distutils = 1
+        except ImportError as e:
+            print('Failed to import numpy_distutils:', e)
+            has_numpy_distutils = 0
+
+    if has_newnumpy:
+        try:
+            print('Found new numpy version %r in %s' %
+                  (numpy.__version__, numpy.__file__))
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+
+    if has_f2py2e:
+        try:
+            print('Found f2py2e version %r in %s' %
+                  (f2py2e.__version__.version, f2py2e.__file__))
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+
+    if has_numpy_distutils:
+        try:
+            if has_numpy_distutils == 2:
+                print('Found numpy.distutils version %r in %r' % (
+                    numpy.distutils.__version__,
+                    numpy.distutils.__file__))
+            else:
+                print('Found numpy_distutils version %r in %r' % (
+                    numpy_distutils.numpy_distutils_version.numpy_distutils_version,
+                    numpy_distutils.__file__))
+            print('------')
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+        try:
+            if has_numpy_distutils == 1:
+                print(
+                    'Importing numpy_distutils.command.build_flib ...', end=' ')
+                import numpy_distutils.command.build_flib as build_flib
+                print('ok')
+                print('------')
+                try:
+                    print(
+                        'Checking availability of supported Fortran compilers:')
+                    for compiler_class in build_flib.all_compilers:
+                        compiler_class(verbose=1).is_available()
+                        print('------')
+                except Exception as msg:
+                    print('error:', msg)
+                    print('------')
+        except Exception as msg:
+            print(
+                'error:', msg, '(ignore it, build_flib is obsolute for numpy.distutils 0.2.2 and up)')
+            print('------')
+        try:
+            if has_numpy_distutils == 2:
+                print('Importing numpy.distutils.fcompiler ...', end=' ')
+                import numpy.distutils.fcompiler as fcompiler
+            else:
+                print('Importing numpy_distutils.fcompiler ...', end=' ')
+                import numpy_distutils.fcompiler as fcompiler
+            print('ok')
+            print('------')
+            try:
+                print('Checking availability of supported Fortran compilers:')
+                fcompiler.show_fcompilers()
+                print('------')
+            except Exception as msg:
+                print('error:', msg)
+                print('------')
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+        try:
+            if has_numpy_distutils == 2:
+                print('Importing numpy.distutils.cpuinfo ...', end=' ')
+                from numpy.distutils.cpuinfo import cpuinfo
+                print('ok')
+                print('------')
+            else:
+                try:
+                    print(
+                        'Importing numpy_distutils.command.cpuinfo ...', end=' ')
+                    from numpy_distutils.command.cpuinfo import cpuinfo
+                    print('ok')
+                    print('------')
+                except Exception as msg:
+                    print('error:', msg, '(ignore it)')
+                    print('Importing numpy_distutils.cpuinfo ...', end=' ')
+                    from numpy_distutils.cpuinfo import cpuinfo
+                    print('ok')
+                    print('------')
+            cpu = cpuinfo()
+            print('CPU information:', end=' ')
+            for name in dir(cpuinfo):
+                if name[0] == '_' and name[1] != '_' and getattr(cpu, name[1:])():
+                    print(name[1:], end=' ')
+            print('------')
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+    os.chdir(_path)
+if __name__ == "__main__":
+    run()

shared/package-files/d1/d1284cb753ddb8fdcafa7db41e3c6159140c39128ffeae2bb08458796ce80d1d/options.h

@@ -0,0 +1,226 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "arrow/csv/invalid_row.h"
+#include "arrow/csv/type_fwd.h"
+#include "arrow/io/interfaces.h"
+#include "arrow/status.h"
+#include "arrow/util/visibility.h"
+
+namespace arrow {
+
+class DataType;
+class TimestampParser;
+
+namespace csv {
+
+// Silly workaround for https://github.com/michaeljones/breathe/issues/453
+constexpr char kDefaultEscapeChar = '\\';
+
+struct ARROW_EXPORT ParseOptions {
+  // Parsing options
+
+  /// Field delimiter
+  char delimiter = ',';
+  /// Whether quoting is used
+  bool quoting = true;
+  /// Quoting character (if `quoting` is true)
+  char quote_char = '"';
+  /// Whether a quote inside a value is double-quoted
+  bool double_quote = true;
+  /// Whether escaping is used
+  bool escaping = false;
+  /// Escaping character (if `escaping` is true)
+  char escape_char = kDefaultEscapeChar;
+  /// Whether values are allowed to contain CR (0x0d) and LF (0x0a) characters
+  bool newlines_in_values = false;
+  /// Whether empty lines are ignored.  If false, an empty line represents
+  /// a single empty value (assuming a one-column CSV file).
+  bool ignore_empty_lines = true;
+  /// A handler function for rows which do not have the correct number of columns
+  InvalidRowHandler invalid_row_handler;
+
+  /// Create parsing options with default values
+  static ParseOptions Defaults();
+
+  /// \brief Test that all set options are valid
+  Status Validate() const;
+};
+
+struct ARROW_EXPORT ConvertOptions {
+  // Conversion options
+
+  /// Whether to check UTF8 validity of string columns
+  bool check_utf8 = true;
+  /// Optional per-column types (disabling type inference on those columns)
+  std::unordered_map<std::string, std::shared_ptr<DataType>> column_types;
+  /// Recognized spellings for null values
+  std::vector<std::string> null_values;
+  /// Recognized spellings for boolean true values
+  std::vector<std::string> true_values;
+  /// Recognized spellings for boolean false values
+  std::vector<std::string> false_values;
+
+  /// Whether string / binary columns can have null values.
+  ///
+  /// If true, then strings in "null_values" are considered null for string columns.
+  /// If false, then all strings are valid string values.
+  bool strings_can_be_null = false;
+
+  /// Whether quoted values can be null.
+  ///
+  /// If true, then strings in "null_values" are also considered null when they
+  /// appear quoted in the CSV file. Otherwise, quoted values are never considered null.
+  bool quoted_strings_can_be_null = true;
+
+  /// Whether to try to automatically dict-encode string / binary data.
+  /// If true, then when type inference detects a string or binary column,
+  /// it is dict-encoded up to `auto_dict_max_cardinality` distinct values
+  /// (per chunk), after which it switches to regular encoding.
+  ///
+  /// This setting is ignored for non-inferred columns (those in `column_types`).
+  bool auto_dict_encode = false;
+  int32_t auto_dict_max_cardinality = 50;
+
+  /// Decimal point character for floating-point and decimal data
+  char decimal_point = '.';
+
+  // XXX Should we have a separate FilterOptions?
+
+  /// If non-empty, indicates the names of columns from the CSV file that should
+  /// be actually read and converted (in the vector's order).
+  /// Columns not in this vector will be ignored.
+  std::vector<std::string> include_columns;
+  /// If false, columns in `include_columns` but not in the CSV file will error out.
+  /// If true, columns in `include_columns` but not in the CSV file will produce
+  /// a column of nulls (whose type is selected using `column_types`,
+  /// or null by default)
+  /// This option is ignored if `include_columns` is empty.
+  bool include_missing_columns = false;
+
+  /// User-defined timestamp parsers, using the virtual parser interface in
+  /// arrow/util/value_parsing.h. More than one parser can be specified, and
+  /// the CSV conversion logic will try parsing values starting from the
+  /// beginning of this vector. If no parsers are specified, we use the default
+  /// built-in ISO-8601 parser.
+  std::vector<std::shared_ptr<TimestampParser>> timestamp_parsers;
+
+  /// Create conversion options with default values, including conventional
+  /// values for `null_values`, `true_values` and `false_values`
+  static ConvertOptions Defaults();
+
+  /// \brief Test that all set options are valid
+  Status Validate() const;
+};
+
+struct ARROW_EXPORT ReadOptions {
+  // Reader options
+
+  /// Whether to use the global CPU thread pool
+  bool use_threads = true;
+
+  /// \brief Block size we request from the IO layer.
+  ///
+  /// This will determine multi-threading granularity as well as
+  /// the size of individual record batches.
+  /// Minimum valid value for block size is 1
+  int32_t block_size = 1 << 20;  // 1 MB
+
+  /// Number of header rows to skip (not including the row of column names, if any)
+  int32_t skip_rows = 0;
+
+  /// Number of rows to skip after the column names are read, if any
+  int32_t skip_rows_after_names = 0;
+
+  /// Column names for the target table.
+  /// If empty, fall back on autogenerate_column_names.
+  std::vector<std::string> column_names;
+
+  /// Whether to autogenerate column names if `column_names` is empty.
+  /// If true, column names will be of the form "f0", "f1"...
+  /// If false, column names will be read from the first CSV row after `skip_rows`.
+  bool autogenerate_column_names = false;
+
+  /// Create read options with default values
+  static ReadOptions Defaults();
+
+  /// \brief Test that all set options are valid
+  Status Validate() const;
+};
+
+/// \brief Quoting style for CSV writing
+enum class ARROW_EXPORT QuotingStyle {
+  /// Only enclose values in quotes which need them, because their CSV rendering can
+  /// contain quotes itself (e.g. strings or binary values)
+  Needed,
+  /// Enclose all valid values in quotes. Nulls are not quoted. May cause readers to
+  /// interpret all values as strings if schema is inferred.
+  AllValid,
+  /// Do not enclose any values in quotes. Prevents values from containing quotes ("),
+  /// cell delimiters (,) or line endings (\\r, \\n), (following RFC4180). If values
+  /// contain these characters, an error is caused when attempting to write.
+  None
+};
+
+struct ARROW_EXPORT WriteOptions {
+  /// Whether to write an initial header line with column names
+  bool include_header = true;
+
+  /// \brief Maximum number of rows processed at a time
+  ///
+  /// The CSV writer converts and writes data in batches of N rows.
+  /// This number can impact performance.
+  int32_t batch_size = 1024;
+
+  /// Field delimiter
+  char delimiter = ',';
+
+  /// \brief The string to write for null values. Quotes are not allowed in this string.
+  std::string null_string;
+
+  /// \brief IO context for writing.
+  io::IOContext io_context;
+
+  /// \brief The end of line character to use for ending rows
+  std::string eol = "\n";
+
+  /// \brief Quoting style
+  QuotingStyle quoting_style = QuotingStyle::Needed;
+
+  /// \brief Quoting style of header
+  ///
+  /// Note that `QuotingStyle::Needed` and `QuotingStyle::AllValid` have the same
+  /// effect of quoting all column names.
+  QuotingStyle quoting_header = QuotingStyle::Needed;
+
+  /// Create write options with default values
+  static WriteOptions Defaults();
+
+  /// \brief Test that all set options are valid
+  Status Validate() const;
+};
+
+}  // namespace csv
+}  // namespace arrow

shared/package-files/d1/d12ee45a23c42919a2d224bc250dcae530a1cd2a59361026d668f25d081a513f/_grid_sampler_2d_cpu_fallback_backward_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API ::std::tuple<at::Tensor,at::Tensor> _grid_sampler_2d_cpu_fallback_backward(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners);
+
+} // namespace compositeimplicitautograd
+} // namespace at

shared/package-files/d1/d132f83197095d4a28f6a03bbaed2f2efede1eb5d17ab566c9f8bb3b5e3d213c/__init__.py

@@ -0,0 +1,9 @@
+"""CUDA Driver
+
+- Driver API binding
+- NVVM API binding
+- Device array implementation
+
+"""
+from numba.core import config
+assert not config.ENABLE_CUDASIM, 'Cannot use real driver API with simulator'

shared/package-files/d1/d13744c2cd7cd7bf54732637d88ce57fc6b8cd561beadeb62c4190df13ff3dd9/graph_executor.h

@@ -0,0 +1,148 @@
+#pragma once
+
+#include <atomic>
+#include <memory>
+
+#include <torch/csrc/jit/ir/ir.h>
+#include <torch/csrc/jit/python/update_graph_executor_opt.h>
+#include <torch/csrc/jit/runtime/argument_spec.h>
+#include <torch/csrc/jit/runtime/interpreter.h>
+#include <torch/csrc/jit/runtime/variable_tensor_list.h>
+
+C10_DECLARE_bool(torch_jit_enable_new_executor);
+
+C10_DECLARE_bool(torch_jit_execution_plan_reuse_code_graph);
+
+namespace torch::jit {
+struct GraphExecutorState;
+struct Code;
+
+enum ExecutorExecutionMode {
+  SIMPLE,
+  PROFILING,
+};
+
+struct ExecutionPlan {
+  ExecutionPlan() = default;
+  ExecutionPlan(std::shared_ptr<Graph> graph, std::string function_name)
+      : code(graph, std::move(function_name)),
+        graph(
+            FLAGS_torch_jit_execution_plan_reuse_code_graph
+                ? code.graph()
+                : std::move(graph)) {}
+
+  operator bool() const {
+    return static_cast<bool>(graph);
+  }
+
+  Code code;
+  std::shared_ptr<Graph> graph;
+};
+
+// Notice that those structs don't manage lifetime of their members.
+// They are only valid only right after you call getDebugState() and should
+// never be used again once another GraphExecutor function is called.
+
+// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+struct GraphExecutorState {
+  const Graph* graph = nullptr;
+  ExecutionPlan fallback; // XXX: members of this field are optional
+  std::unordered_map<ArgumentSpec, ExecutionPlan> execution_plans;
+};
+
+struct TORCH_API EnableProfilingGuard {
+  EnableProfilingGuard();
+  ~EnableProfilingGuard();
+
+ private:
+  bool old_executor_mode = false;
+  bool old_get_optimize = false;
+};
+
+struct GraphExecutorImplBase;
+struct TORCH_API GraphExecutor {
+  GraphExecutor() = default;
+  GraphExecutor(const std::shared_ptr<Graph>& graph, std::string function_name);
+
+  GraphExecutor(
+      const std::shared_ptr<Graph>& graph,
+      std::string function_name,
+      ExecutorExecutionMode executor_mode);
+
+  void run(Stack& inputs);
+  c10::intrusive_ptr<Future> runAsync(
+      Stack& stack,
+      TaskLauncher taskLauncher = at::launch);
+
+  // `remaining_bailout_depth` stands for the maximum number of profiled and
+  // specialized recompilations allowed for the current `GraphExecutor`. if
+  // remaining_bailout_depth is equal to 0, `GraphExecutor` won't perform any
+  // profiling and specialization. This is also equivalent to the
+  // SIMPLE_EXECUTOR mode. if remaining_bailout_depth is greater than 0,
+  // `GraphExecutor` will profile and specialize its input graph based on the
+  // profiled information whenever a bailout check is failed/triggered, a new
+  // `GraphExecutor` will be created. This new `GraphExecutor`'s
+  // remaining_bailout_depth will be reduced by 1.
+  // If no bailout depth is passed, the depth will be initialized from the
+  // current global fusion strategy settings.
+  const ExecutionPlan& getPlanFor(
+      Stack& inputs,
+      c10::optional<size_t> remaining_bailout_depth = c10::nullopt);
+  GraphExecutorState getDebugState();
+
+  void debugFlushCompilationCache();
+
+  bool isOptimized() const;
+
+ private:
+  std::shared_ptr<GraphExecutorImplBase> pImpl;
+};
+
+TORCH_API Node* replaceBlockWithFallbackGraph(
+    Block* b,
+    ArrayRef<Value*> inputs);
+
+// These passes need to run before it is valid to pass to the interpreter
+// regardless of whether sizes have been specialized or not.
+TORCH_API void runRequiredPasses(const std::shared_ptr<Graph>& g);
+
+TORCH_API void debugSetFusionGroupInlining(bool state);
+TORCH_API bool getFusionGroupInlining();
+
+TORCH_API void debugSetAutodiffSubgraphInlining(bool state);
+TORCH_API std::shared_ptr<Graph> lastExecutedOptimizedGraph();
+
+TORCH_API std::atomic<bool>& getProfilingMode();
+TORCH_API std::atomic<bool>& getExecutorMode();
+TORCH_API std::atomic<size_t>& getNumProfiledRuns();
+TORCH_API size_t getBailoutDepth();
+TORCH_API bool IsNewExecutorEnabled();
+
+struct TORCH_API GraphOptimizerEnabledGuard {
+  GraphOptimizerEnabledGuard(bool state)
+      : old_state_(getGraphExecutorOptimize()) {
+    setGraphExecutorOptimize(state);
+  }
+
+  ~GraphOptimizerEnabledGuard() {
+    setGraphExecutorOptimize(old_state_);
+  }
+
+  bool old_state_;
+};
+
+namespace detail {
+
+GraphExecutor* getGradExecutor(Operation& op);
+
+GraphExecutor* getDifferentiableGraphOpExecutor(Operation& op);
+
+// for debugging information we expose a way to get the last actually
+// run graph. Previous approaches allowed querying the GraphExecutor
+// for what graph it would run in certain circumstances (graphFor), but
+// this is fragile because we sometimes change how these decisions are made.
+// This interface still allows our tests to look at optimized graphs, but
+// with less plumbing.
+} // namespace detail
+
+} // namespace torch::jit

shared/package-files/d1/d13da4530fb2a70d9d66ee96508e6aa0de35f1c0e60a32e52b71b847cec9d292/quantize_pt2e.py

@@ -0,0 +1,250 @@
+import torch
+from torch.fx import GraphModule
+from torch.fx import Node
+
+from .pt2e.prepare import prepare
+from .pt2e.qat_utils import (
+    _fuse_conv_bn_qat,
+    _fold_conv_bn_qat,
+)
+from .pt2e.utils import (
+    _get_node_name_to_scope,
+    _fuse_conv_bn_,
+    _disallow_eval_train,
+)
+from .pt2e.representation import reference_representation_rewrite
+from .quantize_fx import _convert_to_reference_decomposed_fx
+from torch.ao.quantization.quantizer import (  # noqa: F401
+    Quantizer,
+    QuantizationSpecBase,
+    QuantizationSpec,
+    FixedQParamsQuantizationSpec,
+    SharedQuantizationSpec,
+    DerivedQuantizationSpec,
+    QuantizationAnnotation,
+)
+from torch.fx.passes.infra.pass_manager import PassManager
+from torch.ao.quantization.pt2e.duplicate_dq_pass import DuplicateDQPass
+from torch.ao.quantization.pt2e.port_metadata_pass import PortNodeMetaForQDQ
+from torch._inductor.constant_folding import constant_fold
+
+__all__ = [
+    "prepare_pt2e",
+    "prepare_qat_pt2e",
+    "convert_pt2e",
+]
+
+
+def prepare_pt2e(
+    model: GraphModule,
+    quantizer: Quantizer,
+) -> GraphModule:
+    """Prepare a model for post training quantization
+
+    Args:
+      * `model` (torch.fx.GraphModule): a model captured by `torch.export` API
+        in the short term we are using `torch._export.capture_pre_autograd_graph`,
+        in the long term we'll migrate to some `torch.export` API
+      * `quantizer`: A backend specific quantizer that conveys how user want the
+        model to be quantized. Tutorial for how to write a quantizer can be found here:
+        https://pytorch.org/tutorials/prototype/pt2e_quantizer.html
+
+    Return:
+      A GraphModule with observer (based on quantizer annotation), ready for calibration
+
+    Example::
+
+        import torch
+        from torch.ao.quantization.quantize_pt2e import prepare_pt2e
+        from torch._export import capture_pre_autograd_graph
+        from torch.ao.quantization.quantizer import (
+            XNNPACKQuantizer,
+            get_symmetric_quantization_config,
+        )
+
+        class M(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.linear = torch.nn.Linear(5, 10)
+
+           def forward(self, x):
+               return self.linear(x)
+
+        # initialize a floating point model
+        float_model = M().eval()
+
+        # define calibration function
+        def calibrate(model, data_loader):
+            model.eval()
+            with torch.no_grad():
+                for image, target in data_loader:
+                    model(image)
+
+        # Step 1. program capture
+        # NOTE: this API will be updated to torch.export API in the future, but the captured
+        # result shoud mostly stay the same
+        m = capture_pre_autograd_graph(m, *example_inputs)
+        # we get a model with aten ops
+
+        # Step 2. quantization
+        # backend developer will write their own Quantizer and expose methods to allow
+        # users to express how they
+        # want the model to be quantized
+        quantizer = XNNPACKQuantizer().set_global(get_symmetric_quantization_config())
+        m = prepare_pt2e(m, quantizer)
+
+        # run calibration
+        # calibrate(m, sample_inference_data)
+    """
+    torch._C._log_api_usage_once("quantization_api.quantize_pt2e.prepare_pt2e")
+    original_graph_meta = model.meta
+    node_name_to_scope = _get_node_name_to_scope(model)
+    # TODO: check qconfig_mapping to make sure conv and bn are both configured
+    # to be quantized before fusion
+    # TODO: (maybe) rewrite this with subgraph_rewriter
+    _fuse_conv_bn_(model)
+    quantizer.transform_for_annotation(model)
+    quantizer.annotate(model)
+    quantizer.validate(model)
+    model = prepare(model, node_name_to_scope, is_qat=False)
+    model.meta.update(original_graph_meta)
+    model = _disallow_eval_train(model)
+    return model
+
+def prepare_qat_pt2e(
+    model: GraphModule,
+    quantizer: Quantizer,
+) -> GraphModule:
+    """Prepare a model for quantization aware training
+
+    Args:
+      * `model` (torch.fx.GraphModule): see :func:`~torch.ao.quantization.quantize_pt2e.prepare_pt2e`
+      * `quantizer`: see :func:`~torch.ao.quantization.quantize_pt2e.prepare_pt2e`
+
+    Return:
+      A GraphModule with fake quant modules (based on quantizer annotation), ready for
+      quantization aware training
+
+    Example::
+        import torch
+        from torch.ao.quantization.quantize_pt2e import prepare_qat_pt2e
+        from torch._export import capture_pre_autograd_graph
+        from torch.ao.quantization.quantizer import (
+            XNNPACKQuantizer,
+            get_symmetric_quantization_config,
+        )
+
+        class M(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.linear = torch.nn.Linear(5, 10)
+
+           def forward(self, x):
+               return self.linear(x)
+
+        # initialize a floating point model
+        float_model = M().eval()
+
+        # define the training loop for quantization aware training
+        def train_loop(model, train_data):
+            model.train()
+            for image, target in data_loader:
+                ...
+
+        # Step 1. program capture
+        # NOTE: this API will be updated to torch.export API in the future, but the captured
+        # result shoud mostly stay the same
+        m = capture_pre_autograd_graph(m, *example_inputs)
+        # we get a model with aten ops
+
+        # Step 2. quantization
+        # backend developer will write their own Quantizer and expose methods to allow
+        # users to express how they
+        # want the model to be quantized
+        quantizer = XNNPACKQuantizer().set_global(get_symmetric_quantization_config())
+        m = prepare_qat_pt2e(m, quantizer)
+
+        # run quantization aware training
+        train_loop(prepared_model, train_loop)
+
+    """
+    torch._C._log_api_usage_once("quantization_api.quantize_pt2e.prepare_qat_pt2e")
+    original_graph_meta = model.meta
+    node_name_to_scope = _get_node_name_to_scope(model)
+    quantizer.transform_for_annotation(model)
+    quantizer.annotate(model)
+    quantizer.validate(model)
+    # Perform fusion after annotate to avoid quantizing ops in the new
+    # subgraph that don't need to be quantized
+    # TODO: only fuse if conv and bn are both configured to be quantized
+    _fuse_conv_bn_qat(model)
+    model = prepare(model, node_name_to_scope, is_qat=True)
+    model.meta.update(original_graph_meta)
+    model = _disallow_eval_train(model)
+    return model
+
+_QUANT_OPS = [
+    torch.ops.quantized_decomposed.quantize_per_tensor.default,
+    torch.ops.quantized_decomposed.quantize_per_tensor.tensor,
+    torch.ops.quantized_decomposed.quantize_per_channel.default,
+]
+def _quant_node_constraint(n: Node) -> bool:
+    """If there is any pure ops between get_attr and quantize op they will be const propagated
+    e.g. get_attr(weight) -> transpose -> quantize -> dequantize*
+    (Note: dequantize op is not going to be constant propagated)
+
+    This filter is added because we don't want to constant fold the things that are not
+    related to quantization
+    """
+    return n.op == "call_function" and n.target in _QUANT_OPS
+
+def convert_pt2e(
+    model: GraphModule,
+    use_reference_representation: bool = False,
+    fold_quantize: bool = True,
+) -> GraphModule:
+    """Convert a calibrated/trained model to a quantized model
+
+    Args:
+      * `model` (torch.fx.GraphModule): calibrated/trained model
+      * `use_reference_representation` (bool): boolean flag to indicate whether to produce referece representation or not
+      * `fold_quantize` (bool): boolean flag for whether fold the quantize op or not
+
+    Returns:
+        quantized model, either in q/dq representation or reference representation
+
+    Example::
+
+        # prepared_model: the model produced by `prepare_pt2e`/`prepare_qat_pt2e` and calibration/training
+        # `convert_pt2e` produces a quantized model that represents quantized computation with
+        # quantize dequantize ops and fp32 ops by default.
+        # Please refer to
+        # https://pytorch.org/tutorials/prototype/pt2e_quant_ptq_static.html#convert-the-calibrated-model-to-a-quantized-model
+        # for detailed explanation of output quantized model
+        quantized_model = convert_pt2e(prepared_model)
+
+    """  # flake8: noqa
+    torch._C._log_api_usage_once("quantization_api.quantize_pt2e.convert_pt2e")
+    if not isinstance(use_reference_representation, bool):
+        raise ValueError(
+            "Unexpected argument type for `use_reference_representation`, "
+            f"please make sure you intend to pass argument {use_reference_representation} to convert_pt2e")
+    original_graph_meta = model.meta
+    model = _convert_to_reference_decomposed_fx(model)
+    model = _fold_conv_bn_qat(model)
+
+    pm = PassManager([DuplicateDQPass()])
+    model = pm(model).graph_module
+
+    pm = PassManager([PortNodeMetaForQDQ()])
+    model = pm(model).graph_module
+
+    if fold_quantize:
+        constant_fold(model, _quant_node_constraint)
+
+    if use_reference_representation:
+        model = reference_representation_rewrite(model)
+
+    model.meta.update(original_graph_meta)
+    model = _disallow_eval_train(model)
+    return model

shared/package-files/d1/d148cd156ed2cad8f5b77d500fdf5e6dfafe6a5ecd982a5684a50ecaaf55ccaf/_cm_multivar.py

@@ -0,0 +1,166 @@
+# auto-generated by https://github.com/trygvrad/multivariate_colormaps
+# date: 2024-05-28
+
+from .colors import LinearSegmentedColormap, MultivarColormap
+import matplotlib as mpl
+_LUTSIZE = mpl.rcParams['image.lut']
+
+_2VarAddA0_data = [[0.000, 0.000, 0.000],
+                   [0.020, 0.026, 0.031],
+                   [0.049, 0.068, 0.085],
+                   [0.075, 0.107, 0.135],
+                   [0.097, 0.144, 0.183],
+                   [0.116, 0.178, 0.231],
+                   [0.133, 0.212, 0.279],
+                   [0.148, 0.244, 0.326],
+                   [0.161, 0.276, 0.374],
+                   [0.173, 0.308, 0.422],
+                   [0.182, 0.339, 0.471],
+                   [0.190, 0.370, 0.521],
+                   [0.197, 0.400, 0.572],
+                   [0.201, 0.431, 0.623],
+                   [0.204, 0.461, 0.675],
+                   [0.204, 0.491, 0.728],
+                   [0.202, 0.520, 0.783],
+                   [0.197, 0.549, 0.838],
+                   [0.187, 0.577, 0.895]]
+
+_2VarAddA1_data = [[0.000, 0.000, 0.000],
+                   [0.030, 0.023, 0.018],
+                   [0.079, 0.060, 0.043],
+                   [0.125, 0.093, 0.065],
+                   [0.170, 0.123, 0.083],
+                   [0.213, 0.151, 0.098],
+                   [0.255, 0.177, 0.110],
+                   [0.298, 0.202, 0.120],
+                   [0.341, 0.226, 0.128],
+                   [0.384, 0.249, 0.134],
+                   [0.427, 0.271, 0.138],
+                   [0.472, 0.292, 0.141],
+                   [0.517, 0.313, 0.142],
+                   [0.563, 0.333, 0.141],
+                   [0.610, 0.353, 0.139],
+                   [0.658, 0.372, 0.134],
+                   [0.708, 0.390, 0.127],
+                   [0.759, 0.407, 0.118],
+                   [0.813, 0.423, 0.105]]
+
+_2VarSubA0_data = [[1.000, 1.000, 1.000],
+                   [0.959, 0.973, 0.986],
+                   [0.916, 0.948, 0.974],
+                   [0.874, 0.923, 0.965],
+                   [0.832, 0.899, 0.956],
+                   [0.790, 0.875, 0.948],
+                   [0.748, 0.852, 0.940],
+                   [0.707, 0.829, 0.934],
+                   [0.665, 0.806, 0.927],
+                   [0.624, 0.784, 0.921],
+                   [0.583, 0.762, 0.916],
+                   [0.541, 0.740, 0.910],
+                   [0.500, 0.718, 0.905],
+                   [0.457, 0.697, 0.901],
+                   [0.414, 0.675, 0.896],
+                   [0.369, 0.652, 0.892],
+                   [0.320, 0.629, 0.888],
+                   [0.266, 0.604, 0.884],
+                   [0.199, 0.574, 0.881]]
+
+_2VarSubA1_data = [[1.000, 1.000, 1.000],
+                   [0.982, 0.967, 0.955],
+                   [0.966, 0.935, 0.908],
+                   [0.951, 0.902, 0.860],
+                   [0.937, 0.870, 0.813],
+                   [0.923, 0.838, 0.765],
+                   [0.910, 0.807, 0.718],
+                   [0.898, 0.776, 0.671],
+                   [0.886, 0.745, 0.624],
+                   [0.874, 0.714, 0.577],
+                   [0.862, 0.683, 0.530],
+                   [0.851, 0.653, 0.483],
+                   [0.841, 0.622, 0.435],
+                   [0.831, 0.592, 0.388],
+                   [0.822, 0.561, 0.340],
+                   [0.813, 0.530, 0.290],
+                   [0.806, 0.498, 0.239],
+                   [0.802, 0.464, 0.184],
+                   [0.801, 0.426, 0.119]]
+
+_3VarAddA0_data = [[0.000, 0.000, 0.000],
+                   [0.018, 0.023, 0.028],
+                   [0.040, 0.056, 0.071],
+                   [0.059, 0.087, 0.110],
+                   [0.074, 0.114, 0.147],
+                   [0.086, 0.139, 0.183],
+                   [0.095, 0.163, 0.219],
+                   [0.101, 0.187, 0.255],
+                   [0.105, 0.209, 0.290],
+                   [0.107, 0.230, 0.326],
+                   [0.105, 0.251, 0.362],
+                   [0.101, 0.271, 0.398],
+                   [0.091, 0.291, 0.434],
+                   [0.075, 0.309, 0.471],
+                   [0.046, 0.325, 0.507],
+                   [0.021, 0.341, 0.546],
+                   [0.021, 0.363, 0.584],
+                   [0.022, 0.385, 0.622],
+                   [0.023, 0.408, 0.661]]
+
+_3VarAddA1_data = [[0.000, 0.000, 0.000],
+                   [0.020, 0.024, 0.016],
+                   [0.047, 0.058, 0.034],
+                   [0.072, 0.088, 0.048],
+                   [0.093, 0.116, 0.059],
+                   [0.113, 0.142, 0.067],
+                   [0.131, 0.167, 0.071],
+                   [0.149, 0.190, 0.074],
+                   [0.166, 0.213, 0.074],
+                   [0.182, 0.235, 0.072],
+                   [0.198, 0.256, 0.068],
+                   [0.215, 0.276, 0.061],
+                   [0.232, 0.296, 0.051],
+                   [0.249, 0.314, 0.037],
+                   [0.270, 0.330, 0.018],
+                   [0.288, 0.347, 0.000],
+                   [0.302, 0.369, 0.000],
+                   [0.315, 0.391, 0.000],
+                   [0.328, 0.414, 0.000]]
+
+_3VarAddA2_data = [[0.000, 0.000, 0.000],
+                   [0.029, 0.020, 0.023],
+                   [0.072, 0.045, 0.055],
+                   [0.111, 0.067, 0.084],
+                   [0.148, 0.085, 0.109],
+                   [0.184, 0.101, 0.133],
+                   [0.219, 0.115, 0.155],
+                   [0.254, 0.127, 0.176],
+                   [0.289, 0.138, 0.195],
+                   [0.323, 0.147, 0.214],
+                   [0.358, 0.155, 0.232],
+                   [0.393, 0.161, 0.250],
+                   [0.429, 0.166, 0.267],
+                   [0.467, 0.169, 0.283],
+                   [0.507, 0.168, 0.298],
+                   [0.546, 0.168, 0.313],
+                   [0.580, 0.172, 0.328],
+                   [0.615, 0.175, 0.341],
+                   [0.649, 0.178, 0.355]]
+
+cmaps = {
+    name: LinearSegmentedColormap.from_list(name, data, _LUTSIZE) for name, data in [
+        ('2VarAddA0', _2VarAddA0_data),
+        ('2VarAddA1', _2VarAddA1_data),
+        ('2VarSubA0', _2VarSubA0_data),
+        ('2VarSubA1', _2VarSubA1_data),
+        ('3VarAddA0', _3VarAddA0_data),
+        ('3VarAddA1', _3VarAddA1_data),
+        ('3VarAddA2', _3VarAddA2_data),
+    ]}
+
+cmap_families = {
+    '2VarAddA': MultivarColormap([cmaps[f'2VarAddA{i}'] for i in range(2)],
+                                 'sRGB_add', name='2VarAddA'),
+    '2VarSubA': MultivarColormap([cmaps[f'2VarSubA{i}'] for i in range(2)],
+                                 'sRGB_sub', name='2VarSubA'),
+    '3VarAddA': MultivarColormap([cmaps[f'3VarAddA{i}'] for i in range(3)],
+                                 'sRGB_add', name='3VarAddA'),
+}

shared/package-files/d1/d1492a222e1e8710f76a8037cfbcbcfb77693acea8df4fc6a7cad9bc55f55bd4/test_deprecate_nonkeyword_arguments.py

@@ -0,0 +1,141 @@
+"""
+Tests for the `deprecate_nonkeyword_arguments` decorator
+"""
+
+import inspect
+
+from pandas.util._decorators import deprecate_nonkeyword_arguments
+
+import pandas._testing as tm
+
+
+@deprecate_nonkeyword_arguments(
+    version="1.1", allowed_args=["a", "b"], name="f_add_inputs"
+)
+def f(a, b=0, c=0, d=0):
+    return a + b + c + d
+
+
+def test_f_signature():
+    assert str(inspect.signature(f)) == "(a, b=0, *, c=0, d=0)"
+
+
+def test_one_argument():
+    with tm.assert_produces_warning(None):
+        assert f(19) == 19
+
+
+def test_one_and_one_arguments():
+    with tm.assert_produces_warning(None):
+        assert f(19, d=6) == 25
+
+
+def test_two_arguments():
+    with tm.assert_produces_warning(None):
+        assert f(1, 5) == 6
+
+
+def test_two_and_two_arguments():
+    with tm.assert_produces_warning(None):
+        assert f(1, 3, c=3, d=5) == 12
+
+
+def test_three_arguments():
+    with tm.assert_produces_warning(FutureWarning):
+        assert f(6, 3, 3) == 12
+
+
+def test_four_arguments():
+    with tm.assert_produces_warning(FutureWarning):
+        assert f(1, 2, 3, 4) == 10
+
+
+def test_three_arguments_with_name_in_warning():
+    msg = (
+        "Starting with pandas version 1.1 all arguments of f_add_inputs "
+        "except for the arguments 'a' and 'b' will be keyword-only."
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        assert f(6, 3, 3) == 12
+
+
+@deprecate_nonkeyword_arguments(version="1.1")
+def g(a, b=0, c=0, d=0):
+    with tm.assert_produces_warning(None):
+        return a + b + c + d
+
+
+def test_g_signature():
+    assert str(inspect.signature(g)) == "(a, *, b=0, c=0, d=0)"
+
+
+def test_one_and_three_arguments_default_allowed_args():
+    with tm.assert_produces_warning(None):
+        assert g(1, b=3, c=3, d=5) == 12
+
+
+def test_three_arguments_default_allowed_args():
+    with tm.assert_produces_warning(FutureWarning):
+        assert g(6, 3, 3) == 12
+
+
+def test_three_positional_argument_with_warning_message_analysis():
+    msg = (
+        "Starting with pandas version 1.1 all arguments of g "
+        "except for the argument 'a' will be keyword-only."
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        assert g(6, 3, 3) == 12
+
+
+@deprecate_nonkeyword_arguments(version="1.1")
+def h(a=0, b=0, c=0, d=0):
+    return a + b + c + d
+
+
+def test_h_signature():
+    assert str(inspect.signature(h)) == "(*, a=0, b=0, c=0, d=0)"
+
+
+def test_all_keyword_arguments():
+    with tm.assert_produces_warning(None):
+        assert h(a=1, b=2) == 3
+
+
+def test_one_positional_argument():
+    with tm.assert_produces_warning(FutureWarning):
+        assert h(23) == 23
+
+
+def test_one_positional_argument_with_warning_message_analysis():
+    msg = "Starting with pandas version 1.1 all arguments of h will be keyword-only."
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        assert h(19) == 19
+
+
+@deprecate_nonkeyword_arguments(version="1.1")
+def i(a=0, /, b=0, *, c=0, d=0):
+    return a + b + c + d
+
+
+def test_i_signature():
+    assert str(inspect.signature(i)) == "(*, a=0, b=0, c=0, d=0)"
+
+
+class Foo:
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "bar"])
+    def baz(self, bar=None, foobar=None):  # pylint: disable=disallowed-name
+        ...
+
+
+def test_foo_signature():
+    assert str(inspect.signature(Foo.baz)) == "(self, bar=None, *, foobar=None)"
+
+
+def test_class():
+    msg = (
+        r"In a future version of pandas all arguments of Foo\.baz "
+        r"except for the argument \'bar\' will be keyword-only"
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        Foo().baz("qux", "quox")

shared/package-files/d1/d14b4ebc1555a119f8520c4472cacb7d26258da29873ff2265f23fc5e38207a8/lstm_mps_backward_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API void lstm_mps_backward_out(at::Tensor & out0, at::TensorList out1, at::TensorList out2, const c10::optional<at::Tensor> & grad_y, const c10::optional<at::Tensor> & grad_hy, const c10::optional<at::Tensor> & grad_cy, const at::Tensor & z_state, const at::Tensor & cell_state_fwd, const at::Tensor & input, const at::Tensor & layersOutputs, at::TensorList hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first);
+TORCH_API void lstm_mps_backward_outf(const c10::optional<at::Tensor> & grad_y, const c10::optional<at::Tensor> & grad_hy, const c10::optional<at::Tensor> & grad_cy, const at::Tensor & z_state, const at::Tensor & cell_state_fwd, const at::Tensor & input, const at::Tensor & layersOutputs, at::TensorList hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first, at::Tensor & out0, at::TensorList out1, at::TensorList out2);
+
+} // namespace compositeexplicitautograd
+} // namespace at

shared/package-files/d1/d14d03282c4a4f7523cf03d2722d0dd0d0384ec57515a9c3794822758a48797f/median_cuda_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor median(const at::Tensor & self);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> median_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, int64_t dim, bool keepdim=false);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> median_outf(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & values, at::Tensor & indices);
+
+} // namespace cuda
+} // namespace at

shared/package-files/d1/d150b1972b1ee2e21c960ba945516ead85678037d1eef7c8e3749645425ab13b/cran.py

@@ -0,0 +1,1799 @@
+# Copyright (C) 2014 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+"""
+Tools for converting Cran packages to conda recipes.
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+import hashlib
+import re
+import subprocess
+import sys
+import tarfile
+import unicodedata
+import zipfile
+from itertools import chain
+from os import environ, listdir, makedirs, sep
+from os.path import (
+    basename,
+    commonprefix,
+    exists,
+    isabs,
+    isdir,
+    isfile,
+    join,
+    normpath,
+    realpath,
+    relpath,
+)
+
+import requests
+import yaml
+
+# try to import C dumper
+try:
+    from yaml import CSafeDumper as SafeDumper
+except ImportError:
+    from yaml import SafeDumper
+
+from typing import TYPE_CHECKING
+
+from conda.common.io import dashlist
+
+from .. import source
+from ..conda_interface import TemporaryDirectory, cc_conda_build
+from ..config import get_or_merge_config
+from ..license_family import allowed_license_families, guess_license_family
+from ..metadata import MetaData
+from ..utils import ensure_list, rm_rf
+from ..variants import DEFAULT_VARIANTS, get_package_variants
+
+if TYPE_CHECKING:
+    from typing import Literal
+
+SOURCE_META = """\
+  {archive_keys}
+  {git_url_key} {git_url}
+  {git_tag_key} {git_tag}
+  {patches}
+"""
+
+BINARY_META = """\
+  url: {cranurl}{sel}
+  {hash_entry}{sel}
+"""
+
+VERSION_META = """\
+{{% set version = '{cran_version}' %}}{sel}"""
+
+CRAN_META = """\
+{version_source}
+{version_binary1}
+{version_binary2}
+
+{{% set posix = 'm2-' if win else '' %}}
+{{% set native = 'm2w64-' if win else '' %}}
+
+package:
+  name: {packagename}
+  version: {{{{ version|replace("-", "_") }}}}
+
+source:
+{source}
+{binary1}
+{binary2}
+
+build:
+  merge_build_host: True{sel_src_and_win}
+  # If this is a new build for the same version, increment the build number.
+  number: {build_number}
+  {skip_os}
+  {noarch_generic}
+
+  # This is required to make R link correctly on Linux.
+  rpaths:
+    - lib/R/lib/
+    - lib/
+  {script_env}
+{suggests}
+requirements:
+  build:{build_depends}
+
+  host:{host_depends}
+
+  run:{run_depends}
+
+test:
+  commands:
+    # You can put additional test commands to be run here.
+    - $R -e "library('{cran_packagename}')"           # [not win]
+    - "\\"%R%\\" -e \\"library('{cran_packagename}')\\""  # [win]
+
+  # You can also put a file called run_test.py, run_test.sh, or run_test.bat
+  # in the recipe that will be run at test time.
+
+  # requires:
+    # Put any additional test requirements here.
+
+about:
+  {home_comment}home:{homeurl}
+  license: {license}
+  {summary_comment}summary:{summary}
+  license_family: {license_family}
+  {license_file}
+
+{extra_recipe_maintainers}
+
+# The original CRAN metadata for this package was:
+
+{cran_metadata}
+
+# See
+# https://docs.conda.io/projects/conda-build for
+# more information about meta.yaml
+
+"""
+
+CRAN_BUILD_SH_SOURCE = """\
+#!/bin/bash
+
+# 'Autobrew' is being used by more and more packages these days
+# to grab static libraries from Homebrew bottles. These bottles
+# are fetched via Homebrew's --force-bottle option which grabs
+# a bottle for the build machine which may not be macOS 10.9.
+# Also, we want to use conda packages (and shared libraries) for
+# these 'system' dependencies. See:
+# https://github.com/jeroen/autobrew/issues/3
+export DISABLE_AUTOBREW=1
+
+# R refuses to build packages that mark themselves as Priority: Recommended
+mv DESCRIPTION DESCRIPTION.old
+grep -va '^Priority: ' DESCRIPTION.old > DESCRIPTION
+# shellcheck disable=SC2086
+${{R}} CMD INSTALL --build . ${{R_ARGS}}
+
+# Add more build steps here, if they are necessary.
+
+# See
+# https://docs.conda.io/projects/conda-build
+# for a list of environment variables that are set during the build process.
+"""
+
+CRAN_BUILD_SH_MIXED = """\
+#!/bin/bash
+
+set -o errexit -o pipefail
+
+if {source_pf_bash}; then
+  export DISABLE_AUTOBREW=1
+  mv DESCRIPTION DESCRIPTION.old
+  grep -va '^Priority: ' DESCRIPTION.old > DESCRIPTION
+  # shellcheck disable=SC2086
+  ${{R}} CMD INSTALL --build . ${{R_ARGS}}
+else
+  mkdir -p "${{PREFIX}}"/lib/R/library/{cran_packagename}
+  mv ./* "${{PREFIX}}"/lib/R/library/{cran_packagename}
+
+  if [[ ${{target_platform}} == osx-64 ]]; then
+    pushd "${{PREFIX}}"
+      for libdir in lib/R/lib lib/R/modules lib/R/library lib/R/bin/exec sysroot/usr/lib; do
+        pushd "${{libdir}}" || exit 1
+          while IFS= read -r -d '' SHARED_LIB
+          do
+            echo "fixing SHARED_LIB ${{SHARED_LIB}}"
+            install_name_tool -change /Library/Frameworks/R.framework/Versions/3.5.0-MRO/Resources/lib/libR.dylib "${{PREFIX}}"/lib/R/lib/libR.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /Library/Frameworks/R.framework/Versions/3.5/Resources/lib/libR.dylib "${{PREFIX}}"/lib/R/lib/libR.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /usr/local/clang4/lib/libomp.dylib "${{PREFIX}}"/lib/libomp.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /usr/local/gfortran/lib/libgfortran.3.dylib "${{PREFIX}}"/lib/libgfortran.3.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /Library/Frameworks/R.framework/Versions/3.5/Resources/lib/libquadmath.0.dylib "${{PREFIX}}"/lib/libquadmath.0.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /usr/local/gfortran/lib/libquadmath.0.dylib "${{PREFIX}}"/lib/libquadmath.0.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /Library/Frameworks/R.framework/Versions/3.5/Resources/lib/libgfortran.3.dylib "${{PREFIX}}"/lib/libgfortran.3.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /usr/lib/libgcc_s.1.dylib "${{PREFIX}}"/lib/libgcc_s.1.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /usr/lib/libiconv.2.dylib "${{PREFIX}}"/sysroot/usr/lib/libiconv.2.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /usr/lib/libncurses.5.4.dylib "${{PREFIX}}"/sysroot/usr/lib/libncurses.5.4.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /usr/lib/libicucore.A.dylib "${{PREFIX}}"/sysroot/usr/lib/libicucore.A.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /usr/lib/libexpat.1.dylib "${{PREFIX}}"/lib/libexpat.1.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /usr/lib/libcurl.4.dylib "${{PREFIX}}"/lib/libcurl.4.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /usr/lib/libc++.1.dylib "${{PREFIX}}"/lib/libc++.1.dylib "${{SHARED_LIB}}" || true
+            install_name_tool -change /Library/Frameworks/R.framework/Versions/3.5/Resources/lib/libc++.1.dylib "${{PREFIX}}"/lib/libc++.1.dylib "${{SHARED_LIB}}" || true
+          done <   <(find . \\( -type f -iname "*.dylib" -or -iname "*.so" -or -iname "R" \\) -print0)
+        popd
+      done
+    popd
+  fi
+fi
+"""  # noqa: E501
+
+CRAN_BUILD_SH_BINARY = """\
+#!/bin/bash
+
+set -o errexit -o pipefail
+
+mkdir -p "${{PREFIX}}"/lib/R/library/{cran_packagename}
+mv ./* "${{PREFIX}}"/lib/R/library/{cran_packagename}
+"""
+
+CRAN_BLD_BAT_SOURCE = """\
+"%R%" CMD INSTALL --build . %R_ARGS%
+IF %ERRORLEVEL% NEQ 0 exit /B 1
+"""
+
+# We hardcode the fact that CRAN does not provide win32 binaries here.
+CRAN_BLD_BAT_MIXED = """\
+if "%target_platform%" == "win-64" goto skip_source_build
+"%R%" CMD INSTALL --build . %R_ARGS%
+IF %ERRORLEVEL% NEQ 0 exit /B 1
+exit 0
+:skip_source_build
+mkdir %PREFIX%\\lib\\R\\library
+robocopy /E . "%PREFIX%\\lib\\R\\library\\{cran_packagename}"
+if %ERRORLEVEL% NEQ 1 exit /B 1
+exit 0
+"""
+
+INDENT = "\n    - "
+
+CRAN_KEYS = [
+    "Site",
+    "Archs",
+    "Depends",
+    "Enhances",
+    "Imports",
+    "License",
+    "License_is_FOSS",
+    "License_restricts_use",
+    "LinkingTo",
+    "MD5sum",
+    "NeedsCompilation",
+    "OS_type",
+    "Package",
+    "Path",
+    "Priority",
+    "Suggests",
+    "Version",
+    "Title",
+    "Author",
+    "Maintainer",
+]
+
+# The following base/recommended package names are derived from R's source
+# tree (R-3.0.2/share/make/vars.mk).  Hopefully they don't change too much
+# between versions.
+R_BASE_PACKAGE_NAMES = (
+    "base",
+    "compiler",
+    "datasets",
+    "graphics",
+    "grDevices",
+    "grid",
+    "methods",
+    "parallel",
+    "splines",
+    "stats",
+    "stats4",
+    "tcltk",
+    "tools",
+    "utils",
+)
+
+R_RECOMMENDED_PACKAGE_NAMES = (
+    "MASS",
+    "lattice",
+    "Matrix",
+    "nlme",
+    "survival",
+    "boot",
+    "cluster",
+    "codetools",
+    "foreign",
+    "KernSmooth",
+    "rpart",
+    "class",
+    "nnet",
+    "spatial",
+    "mgcv",
+)
+
+# Stolen then tweaked from debian.deb822.PkgRelation.__dep_RE.
+VERSION_DEPENDENCY_REGEX = re.compile(
+    r"^\s*(?P<name>[a-zA-Z0-9.+\-]{1,})"
+    r"(\s*\(\s*(?P<relop>[>=<]+)\s*"
+    r"(?P<version>[0-9a-zA-Z:\-+~.]+)\s*\))"
+    r"?(\s*\[(?P<archs>[\s!\w\-]+)\])?\s*$"
+)
+
+target_platform_bash_test_by_sel = {
+    "linux": "=~ linux.*",
+    "linux32": "== linux-32",
+    "linux64": "== linux-64",
+    "win32": "== win-32",
+    "win64": "== win-64",
+    "osx": "== osx-64",
+}
+
+
+def package_exists(package_name):
+    # TODO: how can we get cran to spit out package presence?
+    # available.packages() is probably a start, but no channels are working on mac right now?
+    return True
+    # install_output = subprocess.check_output([join(sys.prefix, "r"), "-e",
+    #                     # ind=2 arbitrarily chooses some CRAN mirror to try.
+    #                     "chooseCRANmirror(ind=2);install.packages('{}')".format(package_name)])
+
+
+def add_parser(repos):
+    # for loading default variant info
+    cran = repos.add_parser(
+        "cran",
+        help="""
+    Create recipe skeleton for packages hosted on the Comprehensive R Archive
+    Network (CRAN) (cran.r-project.org).
+        """,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    cran.add_argument(
+        "packages",
+        nargs="+",
+        help="""CRAN packages to create recipe skeletons for.""",
+    )
+    cran.add_argument(
+        "--output-dir",
+        help="Directory to write recipes to (default: %(default)s).",
+        default=".",
+    )
+    cran.add_argument(
+        "--output-suffix",
+        help="Suffix to add to recipe dir, can contain other dirs (eg: -feedstock/recipe).",
+        default="",
+    )
+    cran.add_argument(
+        "--add-maintainer",
+        help="Add this github username as a maintainer if not already present.",
+    )
+    cran.add_argument(
+        "--version",
+        help="Version to use. Applies to all packages.",
+    )
+    cran.add_argument(
+        "--git-tag",
+        help="Git tag to use for GitHub recipes.",
+    )
+    cran.add_argument(
+        "--all-urls",
+        action="store_true",
+        help="""Look at all URLs, not just source URLs. Use this if it can't
+                find the right URL.""",
+    )
+    cran.add_argument(
+        "--cran-url",
+        help="URL to use for as source package repository",
+    )
+    cran.add_argument(
+        "--r-interp",
+        default="r-base",
+        help="Declare R interpreter package",
+    )
+    cran.add_argument(
+        "--use-binaries-ver",
+        help=(
+            "Repackage binaries from version provided by argument instead of building "
+            "from source."
+        ),
+    )
+    cran.add_argument(
+        "--use-when-no-binary",
+        choices=("src", "old", "src-old", "old-src", "error"),
+        default="src",
+        help="""Sometimes binaries are not available at the correct version for
+                a given platform (macOS). You can use this flag to specify what
+                fallback to take, either compiling from source or using an older
+                binary or trying one then the other.""",
+    )
+    cran.add_argument(
+        "--use-noarch-generic",
+        action="store_true",
+        dest="use_noarch_generic",
+        help="Mark packages that do not need compilation as `noarch: generic`",
+    )
+    cran.add_argument(
+        "--use-rtools-win",
+        action="store_true",
+        help="Use Rtools when building from source on Windows",
+    )
+    cran.add_argument(
+        "--recursive",
+        action="store_true",
+        help="Create recipes for dependencies if they do not already exist.",
+    )
+    cran.add_argument(
+        "--no-recursive",
+        action="store_false",
+        dest="recursive",
+        help="Don't create recipes for dependencies if they do not already exist.",
+    )
+    cran.add_argument(
+        "--no-archive",
+        action="store_false",
+        dest="archive",
+        help="Don't include an Archive download url.",
+    )
+    cran.add_argument(
+        "--allow-archived",
+        action="store_true",
+        dest="allow_archived",
+        help="If the package has been archived, download the latest version.",
+    )
+    cran.add_argument(
+        "--version-compare",
+        action="store_true",
+        help="""Compare the package version of the recipe with the one available
+        on CRAN. Exits 1 if a newer version is available and 0 otherwise.""",
+    )
+    cran.add_argument(
+        "--update-policy",
+        action="store",
+        choices=(
+            "error",
+            "skip-up-to-date",
+            "skip-existing",
+            "overwrite",
+            "merge-keep-build-num",
+            "merge-incr-build-num",
+        ),
+        default="error",
+        help="""Dictates what to do when existing packages are encountered in the
+        output directory (set by --output-dir). In the present implementation, the
+        merge options avoid overwriting bld.bat and build.sh and only manage copying
+        across patches, and the `build/{number,script_env}` fields. When the version
+        changes, both merge options reset `build/number` to 0. When the version does
+        not change they either keep the old `build/number` or else increase it by one.""",
+    )
+    cran.add_argument(
+        "-m",
+        "--variant-config-files",
+        default=cc_conda_build.get("skeleton_config_yaml", None),
+        help="""Variant config file to add.  These yaml files can contain
+        keys such as `cran_mirror`.  Only one can be provided here.""",
+    )
+    cran.add_argument(
+        "--add-cross-r-base",
+        action="store_true",
+        default=False,
+        help="""Add cross-r-base to build requirements for cross compiling""",
+    )
+    cran.add_argument(
+        "--no-comments",
+        action="store_true",
+        default=False,
+        help="""Do not include instructional comments in recipe files""",
+    )
+
+
+def dict_from_cran_lines(lines):
+    d = {}
+    for line in lines:
+        if not line:
+            continue
+        try:
+            if ": " in line:
+                (k, v) = line.split(": ", 1)
+            else:
+                # Sometimes fields are included but left blank, e.g.:
+                #   - Enhances in data.tree
+                #   - Suggests in corpcor
+                (k, v) = line.split(":", 1)
+        except ValueError:
+            sys.exit("Error: Could not parse metadata (%s)" % line)
+        d[k] = v
+        # if k not in CRAN_KEYS:
+        #     print("Warning: Unknown key %s" % k)
+    d["orig_lines"] = lines
+    return d
+
+
+def remove_package_line_continuations(chunk):
+    """
+    >>> chunk = [
+        'Package: A3',
+        'Version: 0.9.2',
+        'Depends: R (>= 2.15.0), xtable, pbapply',
+        'Suggests: randomForest, e1071',
+        'Imports: MASS, R.methodsS3 (>= 1.5.2), R.oo (>= 1.15.8), R.utils (>=',
+        '        1.27.1), matrixStats (>= 0.8.12), R.filesets (>= 2.3.0), ',
+        '        sampleSelection, scatterplot3d, strucchange, systemfit',
+        'License: GPL (>= 2)',
+        'NeedsCompilation: no']
+    >>> remove_package_line_continuations(chunk)
+    ['Package: A3',
+     'Version: 0.9.2',
+     'Depends: R (>= 2.15.0), xtable, pbapply',
+     'Suggests: randomForest, e1071',
+     'Imports: MASS, R.methodsS3 (>= 1.5.2), R.oo (>= 1.15.8), R.utils (>= 1.27.1), matrixStats (>= 0.8.12), R.filesets (>= 2.3.0), sampleSelection, scatterplot3d, strucchange, systemfit, rgl,'
+     'License: GPL (>= 2)',
+     'NeedsCompilation: no']
+    """  # NOQA
+    continuation = (" ", "\t")
+    continued_ix = None
+    continued_line = None
+    had_continuation = False
+    accumulating_continuations = False
+
+    chunk.append("")
+
+    for i, line in enumerate(chunk):
+        if line.startswith(continuation):
+            line = " " + line.lstrip()
+            if accumulating_continuations:
+                assert had_continuation
+                continued_line += line
+                chunk[i] = None
+            else:
+                accumulating_continuations = True
+                continued_ix = i - 1
+                continued_line = chunk[continued_ix] + line
+                had_continuation = True
+                chunk[i] = None
+        else:
+            if accumulating_continuations:
+                assert had_continuation
+                chunk[continued_ix] = continued_line
+                accumulating_continuations = False
+                continued_line = None
+                continued_ix = None
+
+    if had_continuation:
+        # Remove the None(s).
+        chunk = [c for c in chunk if c]
+
+    chunk.append("")
+
+    return chunk
+
+
+def yaml_quote_string(string):
+    """
+    Quote a string for use in YAML.
+
+    We can't just use yaml.dump because it adds ellipses to the end of the
+    string, and it in general doesn't handle being placed inside an existing
+    document very well.
+
+    Note that this function is NOT general.
+    """
+    return (
+        yaml.dump(string, indent=True, Dumper=SafeDumper)
+        .replace("\n...\n", "")
+        .replace("\n", "\n  ")
+        .rstrip("\n ")
+    )
+
+
+# Due to how we render the metadata there can be significant areas of repeated newlines.
+# This collapses them and also strips any trailing spaces.
+def clear_whitespace(string):
+    lines = []
+    last_line = ""
+    for line in string.splitlines():
+        line = line.rstrip()
+        if not (line == "" and last_line == ""):
+            lines.append(line)
+        last_line = line
+    return "\n".join(lines)
+
+
+def read_description_contents(fp):
+    bytes = fp.read()
+    text = bytes.decode("utf-8", errors="replace")
+    text = clear_whitespace(text)
+    lines = remove_package_line_continuations(text.splitlines())
+    return dict_from_cran_lines(lines)
+
+
+def get_archive_metadata(path, verbose=True):
+    if verbose:
+        print("Reading package metadata from %s" % path)
+    if basename(path) == "DESCRIPTION":
+        with open(path, "rb") as fp:
+            return read_description_contents(fp)
+    elif tarfile.is_tarfile(path):
+        with tarfile.open(path, "r") as tf:
+            for member in tf:
+                if re.match(r"^[^/]+/DESCRIPTION$", member.name):
+                    fp = tf.extractfile(member)
+                    return read_description_contents(fp)
+    elif path.endswith(".zip"):
+        with zipfile.ZipFile(path, "r") as zf:
+            for member in zf.infolist():
+                if re.match(r"^[^/]+/DESCRIPTION$", member.filename):
+                    fp = zf.open(member, "r")
+                    return read_description_contents(fp)
+    else:
+        sys.exit("Cannot extract a DESCRIPTION from file %s" % path)
+    sys.exit("%s does not seem to be a CRAN package (no DESCRIPTION) file" % path)
+
+
+def get_latest_git_tag(config):
+    # SO says to use taggerdate instead of committerdate, but that is invalid for lightweight tags.
+    p = subprocess.Popen(
+        [
+            "git",
+            "for-each-ref",
+            "refs/tags",
+            "--sort=-committerdate",
+            "--format=%(refname:short)",
+            "--count=1",
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        cwd=config.work_dir,
+    )
+
+    stdout, stderr = p.communicate()
+    stdout = stdout.decode("utf-8")
+    stderr = stderr.decode("utf-8")
+    if stderr or p.returncode:
+        sys.exit("Error: git tag failed (%s)" % stderr)
+    tags = stdout.strip().splitlines()
+    if not tags:
+        sys.exit("Error: no tags found")
+
+    print("Using tag %s" % tags[-1])
+    return tags[-1]
+
+
+def _ssl_no_verify():
+    """Gets whether the SSL_NO_VERIFY environment variable is set to 1 or True.
+
+    This provides a workaround for users in some corporate environments where
+    MITM style proxies make it difficult to fetch data over HTTPS.
+    """
+    return environ.get("SSL_NO_VERIFY", "").strip().lower() in ("1", "true")
+
+
+def get_session(output_dir, verbose=True):
+    session = requests.Session()
+    session.verify = _ssl_no_verify()
+    try:
+        import cachecontrol
+        import cachecontrol.caches
+    except ImportError:
+        if verbose:
+            print(
+                "Tip: install CacheControl and lockfile (conda packages) to cache the "
+                "CRAN metadata"
+            )
+    else:
+        session = cachecontrol.CacheControl(
+            session, cache=cachecontrol.caches.FileCache(join(output_dir, ".web_cache"))
+        )
+    return session
+
+
+def get_cran_archive_versions(cran_url, session, package, verbose=True):
+    if verbose:
+        print(f"Fetching archived versions for package {package} from {cran_url}")
+    r = session.get(cran_url + "/src/contrib/Archive/" + package + "/")
+    try:
+        r.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 404:
+            print("No archive directory for package %s" % package)
+            return []
+        raise
+    versions = []
+    for p, dt in re.findall(
+        r'<td><a href="([^"]+)">\1</a></td>\s*<td[^>]*>([^<]*)</td>', r.text
+    ):
+        if p.endswith(".tar.gz") and "_" in p:
+            name, version = p.rsplit(".", 2)[0].split("_", 1)
+            versions.append((dt.strip(), version))
+    return [v for dt, v in sorted(versions, reverse=True)]
+
+
+def get_cran_index(cran_url, session, verbose=True):
+    if verbose:
+        print("Fetching main index from %s" % cran_url)
+    r = session.get(cran_url + "/src/contrib/")
+    r.raise_for_status()
+    records = {}
+    for p in re.findall(r'<td><a href="([^"]+)">\1</a></td>', r.text):
+        if p.endswith(".tar.gz") and "_" in p:
+            name, version = p.rsplit(".", 2)[0].split("_", 1)
+            records[name.lower()] = (name, version)
+    r = session.get(cran_url + "/src/contrib/Archive/")
+    r.raise_for_status()
+    for p in re.findall(r'<td><a href="([^"]+)/">\1/</a></td>', r.text):
+        if re.match(r"^[A-Za-z]", p):
+            records.setdefault(p.lower(), (p, None))
+    return records
+
+
+def make_array(m, key, allow_empty=False):
+    result = []
+    try:
+        old_vals = m.get_value(key, [])
+    except:
+        old_vals = []
+    if old_vals or allow_empty:
+        result.append(key.split("/")[-1] + ":")
+    for old_val in old_vals:
+        result.append(f"{INDENT}{old_val}")
+    return result
+
+
+def existing_recipe_dir(output_dir, output_suffix, package, version):
+    result = None
+    if version:
+        package = package + "-" + version.replace("-", "_")
+    if exists(join(output_dir, package)):
+        result = normpath(join(output_dir, package))
+    elif exists(join(output_dir, package + output_suffix)):
+        result = normpath(join(output_dir, package + output_suffix))
+    elif exists(join(output_dir, "r-" + package + output_suffix)):
+        result = normpath(join(output_dir, "r-" + package + output_suffix))
+    return result
+
+
+def strip_end(string, end):
+    if string.endswith(end):
+        return string[: -len(end)]
+    return string
+
+
+def package_to_inputs_dict(
+    output_dir, output_suffix, git_tag, package: str, version=None
+):
+    """
+    Converts `package` (*) into a tuple of:
+
+    pkg_name (without leading 'r-')
+    location (in a subdir of output_dir - may not exist - or at GitHub)
+    old_git_rev (from existing metadata, so corresponds to the *old* version)
+    metadata or None (if a recipe does *not* already exist)
+
+    (*) `package` could be:
+    1. A package name beginning (or not) with 'r-'
+    2. A GitHub URL
+    3. A file:// URL to a tarball
+    4. A relative path to a recipe from output_dir
+    5. An absolute path to a recipe (fatal unless in the output_dir hierarchy)
+    6. Any of the above ending (or not) in sep or '/'
+
+    So this function cleans all that up:
+
+    Some packages may be from GitHub but we'd like the user not to have to worry
+    about that on the command-line (for pre-existing recipes). Also, we may want
+    to get version information from them (or existing metadata to merge) so lets
+    load *all* existing recipes (later we will add or replace this metadata with
+    any that we create).
+    """
+    if isfile(package):
+        return None
+    print("Parsing input package %s:" % package)
+    package = strip_end(package, "/")
+    package = strip_end(package, sep)
+    if "github.com" in package:
+        package = strip_end(package, ".git")
+    pkg_name = basename(package).lower()
+    pkg_name = strip_end(pkg_name, "-feedstock")
+    if output_suffix:
+        pkg_name = strip_end(pkg_name, output_suffix)
+    if pkg_name.startswith("r-"):
+        pkg_name = pkg_name[2:]
+    if package.startswith("file://"):
+        location = package.replace("file://", "")
+        pkg_filename = basename(location)
+        pkg_name = re.match(r"(.*)_(.*)", pkg_filename).group(1).lower()
+        existing_location = existing_recipe_dir(
+            output_dir, output_suffix, "r-" + pkg_name, version
+        )
+    elif isabs(package):
+        commp = commonprefix((package, output_dir))
+        if commp != output_dir:
+            raise RuntimeError(
+                f"package {package} specified with abs path outside of output-dir {output_dir}"
+            )
+        location = package
+        existing_location = existing_recipe_dir(
+            output_dir, output_suffix, "r-" + pkg_name, version
+        )
+    elif "github.com" in package:
+        location = package
+        existing_location = existing_recipe_dir(
+            output_dir, output_suffix, "r-" + pkg_name, version
+        )
+    else:
+        location = existing_location = existing_recipe_dir(
+            output_dir, output_suffix, package, version
+        )
+    m: MetaData | None
+    if existing_location:
+        try:
+            m = MetaData(existing_location)
+        except:
+            # Happens when the folder exists but contains no recipe.
+            m = None
+    else:
+        m = None
+
+    # It can still be the case that a package without 'github.com' in the location does really
+    # come from there, for that we need to inspect the existing metadata's source/git_url.
+    old_git_rev = git_tag
+    if location and m and "github.com" not in location:
+        git_url = m.get_value("source/git_url", "")
+        if "github.com" in git_url:
+            location = git_url
+            old_git_rev = m.get_value("source/git_rev", None)
+
+    vstr = "-" + version.replace("-", "_") if version else ""
+    new_location = join(output_dir, "r-" + pkg_name + vstr + output_suffix)
+    print(f".. name: {pkg_name} location: {location} new_location: {new_location}")
+
+    return {
+        "pkg-name": pkg_name,
+        "location": location,
+        "old-git-rev": old_git_rev,
+        "old-metadata": m,
+        "new-location": new_location,
+        "version": version,
+    }
+
+
+def get_available_binaries(cran_url, details):
+    url = cran_url + "/" + details["dir"]
+    response = requests.get(url)
+    response.raise_for_status()
+    ext = details["ext"]
+    for filename in re.findall(r'<a href="([^"]*)">\1</a>', response.text):
+        if filename.endswith(ext):
+            pkg, _, ver = filename.rpartition("_")
+            ver, _, _ = ver.rpartition(ext)
+            details["binaries"].setdefault(pkg, []).append((ver, url + filename))
+
+
+def remove_comments(template):
+    re_comment = re.compile(r"^\s*#\s")
+    lines = template.split("\n")
+    lines_no_comments = [line for line in lines if not re_comment.match(line)]
+    return "\n".join(lines_no_comments)
+
+
+def skeletonize(
+    in_packages,
+    output_dir=".",
+    output_suffix="",
+    add_maintainer=None,
+    version=None,
+    git_tag=None,
+    cran_url=None,
+    recursive=False,
+    archive=True,
+    version_compare=False,
+    update_policy="",
+    r_interp="r-base",
+    use_binaries_ver=None,
+    use_noarch_generic=False,
+    use_when_no_binary: Literal["error" | "src" | "old" | "old-src"] = "src",
+    use_rtools_win=False,
+    config=None,
+    variant_config_files=None,
+    allow_archived=False,
+    add_cross_r_base=False,
+    no_comments=False,
+):
+    if (
+        use_when_no_binary != "error"
+        and use_when_no_binary != "src"
+        and use_when_no_binary != "old"
+        and use_when_no_binary != "old-src"
+    ):
+        print(f"ERROR: --use_when_no_binary={use_when_no_binary} not yet implemented")
+        sys.exit(1)
+
+    m: MetaData
+
+    output_dir = realpath(output_dir)
+    config = get_or_merge_config(config, variant_config_files=variant_config_files)
+
+    if allow_archived and not archive:
+        print("ERROR: --no-archive and --allow-archived conflict")
+        sys.exit(1)
+
+    if not cran_url:
+        with TemporaryDirectory() as t:
+            _variant = get_package_variants(t, config)[0]
+        cran_url = ensure_list(
+            _variant.get("cran_mirror", DEFAULT_VARIANTS["cran_mirror"])
+        )[0]
+
+    if len(in_packages) > 1 and version_compare:
+        raise ValueError("--version-compare only works with one package at a time")
+    if update_policy == "error" and not in_packages:
+        raise ValueError("At least one package must be supplied")
+
+    package_dicts = {}
+    package_list = []
+
+    cran_url = cran_url.rstrip("/")
+
+    # Get cran index lazily so we don't have to go to CRAN
+    # for a github repo or a local tarball
+    cran_index = None
+
+    cran_layout_template = {
+        "source": {
+            "selector": "{others}",
+            "dir": "src/contrib/",
+            "ext": ".tar.gz",
+            # If we had platform filters we would change this to:
+            # build_for_linux or is_github_url or is_tarfile
+            "use_this": True,
+        },
+        "win-64": {
+            "selector": "win64",
+            "dir": f"bin/windows/contrib/{use_binaries_ver}/",
+            "ext": ".zip",
+            "use_this": True if use_binaries_ver else False,
+        },
+        "osx-64": {
+            "selector": "osx",
+            "dir": f"bin/macosx/el-capitan/contrib/{use_binaries_ver}/",
+            "ext": ".tgz",
+            "use_this": True if use_binaries_ver else False,
+        },
+    }
+
+    # Figure out what binaries are available once:
+    for archive_type, archive_details in cran_layout_template.items():
+        archive_details["binaries"] = dict()
+        if archive_type != "source" and archive_details["use_this"]:
+            get_available_binaries(cran_url, archive_details)
+
+    for package in in_packages:
+        inputs_dict = package_to_inputs_dict(
+            output_dir, output_suffix, git_tag, package, version
+        )
+        if inputs_dict:
+            package_dicts.update({inputs_dict["pkg-name"]: {"inputs": inputs_dict}})
+
+    for package_name, package_dict in package_dicts.items():
+        package_list.append(package_name)
+
+    while package_list:
+        inputs = package_dicts[package_list.pop()]["inputs"]
+        location = inputs["location"]
+        pkg_name = inputs["pkg-name"]
+        version = inputs["version"]
+        is_github_url = location and "github.com" in location
+        is_tarfile = location and isfile(location) and tarfile.is_tarfile(location)
+        is_archive = False
+        url = inputs["location"]
+
+        dir_path = inputs["new-location"]
+        print(f"Making/refreshing recipe for {pkg_name}")
+
+        # Bodges GitHub packages into cran_metadata
+        if is_tarfile:
+            cran_package = get_archive_metadata(location)
+
+        elif is_github_url or is_tarfile:
+            rm_rf(config.work_dir)
+            m = MetaData.fromdict({"source": {"git_url": location}}, config=config)
+            source.git_source(
+                m.get_section("source"), m.config.git_cache, m.config.work_dir
+            )
+            new_git_tag = git_tag if git_tag else get_latest_git_tag(config)
+            p = subprocess.Popen(
+                ["git", "checkout", new_git_tag],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                cwd=config.work_dir,
+            )
+            stdout, stderr = p.communicate()
+            stdout = stdout.decode("utf-8")
+            stderr = stderr.decode("utf-8")
+            if p.returncode:
+                sys.exit(
+                    f"Error: 'git checkout {new_git_tag}' failed ({stderr.strip()}).\n"
+                    "Invalid tag?"
+                )
+            if stdout:
+                print(stdout, file=sys.stdout)
+            if stderr:
+                print(stderr, file=sys.stderr)
+            DESCRIPTION = join(config.work_dir, "DESCRIPTION")
+            if not isfile(DESCRIPTION):
+                sub_description_pkg = join(config.work_dir, "pkg", "DESCRIPTION")
+                sub_description_name = join(
+                    config.work_dir, location.split("/")[-1], "DESCRIPTION"
+                )
+                if isfile(sub_description_pkg):
+                    DESCRIPTION = sub_description_pkg
+                elif isfile(sub_description_name):
+                    DESCRIPTION = sub_description_name
+                else:
+                    sys.exit(
+                        f"{location} does not appear to be a valid R package "
+                        f"(no DESCRIPTION file in {sub_description_pkg}, {sub_description_name})"
+                    )
+            cran_package = get_archive_metadata(DESCRIPTION)
+
+        else:
+            if cran_index is None:
+                session = get_session(output_dir)
+                cran_index = get_cran_index(cran_url, session)
+            if pkg_name.lower() not in cran_index:
+                sys.exit("Package %s not found" % pkg_name)
+            package, cran_version = cran_index[pkg_name.lower()]
+            if cran_version and (not version or version == cran_version):
+                version = cran_version
+            elif version and not archive:
+                print(
+                    f"ERROR: Version {version} of package {package} is archived, but --no-archive was selected"
+                )
+                sys.exit(1)
+            elif not version and not cran_version and not allow_archived:
+                print(
+                    "ERROR: Package %s is archived; to build, use --allow-archived or a --version value"
+                    % pkg_name
+                )
+                sys.exit(1)
+            else:
+                is_archive = True
+                all_versions = get_cran_archive_versions(cran_url, session, package)
+                if cran_version:
+                    all_versions = [cran_version] + all_versions
+                if not version:
+                    version = all_versions[0]
+                elif version not in all_versions:
+                    msg = f"ERROR: Version {version} of package {package} not found.\n  Available versions: "
+                    print(msg + ", ".join(all_versions))
+                    sys.exit(1)
+            cran_package = None
+
+        if cran_package is not None:
+            package = cran_package["Package"]
+            version = cran_package["Version"]
+        plower = package.lower()
+        d = package_dicts[pkg_name]
+        d.update(
+            {
+                "cran_packagename": package,
+                "cran_version": version,
+                "packagename": "r-" + plower,
+                # Conda versions cannot have -. Conda (verlib) will treat _ as a .
+                "conda_version": version.replace("-", "_"),
+                "patches": "",
+                "build_number": 0,
+                "build_depends": "",
+                "host_depends": "",
+                "run_depends": "",
+                # CRAN doesn't seem to have this metadata :(
+                "home_comment": "#",
+                "homeurl": "",
+                "summary_comment": "#",
+                "summary": "",
+                "binary1": "",
+                "binary2": "",
+            }
+        )
+
+        if version_compare:
+            sys.exit(not version_compare(dir_path, d["conda_version"]))
+
+        patches = []
+        script_env = []
+        extra_recipe_maintainers = []
+        build_number = 0
+        if update_policy.startswith("merge") and inputs["old-metadata"]:
+            m = inputs["old-metadata"]
+            patches = make_array(m, "source/patches")
+            script_env = make_array(m, "build/script_env")
+            extra_recipe_maintainers = make_array(
+                m, "extra/recipe-maintainers", add_maintainer
+            )
+            if m.version() == d["conda_version"]:
+                build_number = m.build_number()
+                build_number += 1 if update_policy == "merge-incr-build-num" else 0
+        if add_maintainer:
+            new_maintainer = f"{INDENT}{add_maintainer}"
+            if new_maintainer not in extra_recipe_maintainers:
+                if not len(extra_recipe_maintainers):
+                    # We hit this case when there is no existing recipe.
+                    extra_recipe_maintainers = make_array(
+                        {}, "extra/recipe-maintainers", True
+                    )
+                extra_recipe_maintainers.append(new_maintainer)
+        if len(extra_recipe_maintainers):
+            extra_recipe_maintainers[1:].sort()
+            extra_recipe_maintainers.insert(0, "extra:\n  ")
+        d["extra_recipe_maintainers"] = "".join(extra_recipe_maintainers)
+        d["patches"] = "".join(patches)
+        d["script_env"] = "".join(script_env)
+        d["build_number"] = build_number
+
+        cached_path = None
+        cran_layout = copy.deepcopy(cran_layout_template)
+        available = {}
+
+        description_path = None
+        for archive_type, archive_details in cran_layout.items():
+            contrib_url = ""
+            archive_details["cran_version"] = d["cran_version"]
+            archive_details["conda_version"] = d["conda_version"]
+            if is_archive and archive_type == "source":
+                archive_details["dir"] += "Archive/" + package + "/"
+            available_artefact = (
+                True
+                if archive_type == "source"
+                else package in archive_details["binaries"]
+                and any(
+                    d["cran_version"] == v
+                    for v, _ in archive_details["binaries"][package]
+                )
+            )
+            if not available_artefact:
+                if use_when_no_binary == "error":
+                    print(
+                        "ERROR: --use-when-no-binary is error (and there is no binary)"
+                    )
+                    sys.exit(1)
+                elif use_when_no_binary.startswith("old"):
+                    if package not in archive_details["binaries"]:
+                        if use_when_no_binary.endswith("src"):
+                            available_artefact = False
+                            archive_details["use_this"] = False
+                            continue
+                        else:
+                            print(
+                                "ERROR: No binary nor old binary found "
+                                "(maybe pass --use-when-no-binary=old-src to fallback to source?)"
+                            )
+                            sys.exit(1)
+                    # Version needs to be stored in archive_details.
+                    archive_details["cranurl"] = archive_details["binaries"][package][
+                        -1
+                    ][1]
+                    archive_details["conda_version"] = archive_details["binaries"][
+                        package
+                    ][-1][0]
+                    archive_details["cran_version"] = archive_details[
+                        "conda_version"
+                    ].replace("_", "-")
+                    available_artefact = True
+            # We may need to inspect the file later to determine which compilers are needed.
+            cached_path = None
+            sha256 = hashlib.sha256()
+            if archive_details["use_this"] and available_artefact:
+                if is_tarfile:
+                    filename = basename(location)
+                    contrib_url = relpath(location, dir_path)
+                    contrib_url_rendered = package_url = contrib_url
+                    cached_path = location
+                elif not is_github_url or archive_type != "source":
+                    filename_rendered = "{}_{}{}".format(
+                        package, archive_details["cran_version"], archive_details["ext"]
+                    )
+                    filename = f"{package}_{{{{ version }}}}" + archive_details["ext"]
+                    contrib_url = "{{{{ cran_mirror }}}}/{}".format(
+                        archive_details["dir"]
+                    )
+                    contrib_url_rendered = cran_url + "/{}".format(
+                        archive_details["dir"]
+                    )
+                    package_url = contrib_url_rendered + filename_rendered
+                    print(f"Downloading {archive_type} from {package_url}")
+                    try:
+                        cached_path, _ = source.download_to_cache(
+                            config.src_cache,
+                            "",
+                            {
+                                "url": package_url,
+                                "fn": archive_type + "-" + filename_rendered,
+                            },
+                        )
+                    except:
+                        print(
+                            f"logic error, file {package_url} should exist, we found it in a dir listing earlier."
+                        )
+                        sys.exit(1)
+                    if description_path is None or archive_type == "source":
+                        description_path = cached_path
+                available_details = {}
+                available_details["selector"] = archive_details["selector"]
+                available_details["cran_version"] = archive_details["cran_version"]
+                available_details["conda_version"] = archive_details["conda_version"]
+                if cached_path:
+                    sha256.update(open(cached_path, "rb").read())
+                    archive_details["cranurl"] = package_url
+                    available_details["filename"] = filename
+                    available_details["contrib_url"] = contrib_url
+                    available_details["contrib_url_rendered"] = contrib_url_rendered
+                    available_details["hash_entry"] = f"sha256: {sha256.hexdigest()}"
+                    available_details["cached_path"] = cached_path
+                # This is rubbish; d[] should be renamed global[] and should be
+                #      merged into source and binaryN.
+                if archive_type == "source":
+                    if is_github_url:
+                        available_details["url_key"] = ""
+                        available_details["git_url_key"] = "git_url:"
+                        available_details["git_tag_key"] = "git_tag:"
+                        hash_msg = "# You can add a hash for the file here, (md5, sha1 or sha256)"
+                        available_details["hash_entry"] = hash_msg
+                        available_details["filename"] = ""
+                        available_details["cranurl"] = ""
+                        available_details["git_url"] = url
+                        available_details["git_tag"] = new_git_tag
+                        available_details["archive_keys"] = ""
+                    else:
+                        available_details["url_key"] = "url:"
+                        available_details["git_url_key"] = ""
+                        available_details["git_tag_key"] = ""
+                        available_details["cranurl"] = " " + contrib_url + filename
+                        available_details["git_url"] = ""
+                        available_details["git_tag"] = ""
+                else:
+                    available_details["cranurl"] = archive_details["cranurl"]
+
+                available_details["patches"] = d["patches"]
+                available[archive_type] = available_details
+
+        # Figure out the selectors according to what is available.
+        _all = ["linux", "win32", "win64", "osx"]
+        from_source = _all[:]
+        binary_id = 1
+        for archive_type, archive_details in available.items():
+            if archive_type == "source":
+                for k, v in archive_details.items():
+                    d[k] = v
+            else:
+                sel = archive_details["selector"]
+                # Does the file exist? If not we need to build from source.
+                from_source.remove(sel)
+                binary_id += 1
+        if from_source == _all:
+            sel_src = ""
+            sel_src_and_win = "  # [win]"
+            sel_src_not_win = "  # [not win]"
+        else:
+            sel_src = "  # [" + " or ".join(from_source) + "]"
+            sel_src_and_win = (
+                "  # ["
+                + " or ".join(fs for fs in from_source if fs.startswith("win"))
+                + "]"
+            )
+            sel_src_not_win = (
+                "  # ["
+                + " or ".join(fs for fs in from_source if not fs.startswith("win"))
+                + "]"
+            )
+        sel_cross = "  # [build_platform != target_platform]"
+        d["sel_src"] = sel_src
+        d["sel_src_and_win"] = sel_src_and_win
+        d["sel_src_not_win"] = sel_src_not_win
+        d["from_source"] = from_source
+
+        if "source" in available:
+            available_details = available["source"]
+            available_details["sel"] = sel_src
+            filename = available_details["filename"]
+            if "contrib_url" in available_details:
+                contrib_url = available_details["contrib_url"]
+                if archive:
+                    if is_tarfile:
+                        available_details["cranurl"] = INDENT + contrib_url
+                    elif not is_archive:
+                        available_details["cranurl"] = (
+                            INDENT
+                            + contrib_url
+                            + filename
+                            + sel_src
+                            + INDENT
+                            + contrib_url
+                            + f"Archive/{package}/"
+                            + filename
+                            + sel_src
+                        )
+                else:
+                    available_details["cranurl"] = (
+                        " " + contrib_url + filename + sel_src
+                    )
+            if not is_github_url:
+                available_details["archive_keys"] = (
+                    "{url_key}{sel}    {cranurl}\n  {hash_entry}{sel}"
+                ).format(**available_details)
+
+        # Extract the DESCRIPTION data from the source
+        if cran_package is None:
+            cran_package = get_archive_metadata(description_path)
+        d["cran_metadata"] = "\n".join(
+            ["# %s" % line for line in cran_package["orig_lines"] if line]
+        )
+
+        # Render the source and binaryN keys
+        binary_id = 1
+        d["version_binary1"] = d["version_binary2"] = ""
+        for archive_type, archive_details in available.items():
+            if archive_type == "source":
+                d["source"] = SOURCE_META.format(**archive_details)
+                d["version_source"] = VERSION_META.format(**archive_details)
+            else:
+                archive_details["sel"] = "  # [" + archive_details["selector"] + "]"
+                d["binary" + str(binary_id)] = BINARY_META.format(**archive_details)
+                d["version_binary" + str(binary_id)] = VERSION_META.format(
+                    **archive_details
+                )
+                binary_id += 1
+
+        license_info = get_license_info(
+            cran_package.get("License", "None"), allowed_license_families
+        )
+        d["license"], d["license_file"], d["license_family"] = license_info
+
+        if "License_is_FOSS" in cran_package:
+            d["license"] += " (FOSS)"
+        if cran_package.get("License_restricts_use") == "yes":
+            d["license"] += " (Restricts use)"
+
+        if "URL" in cran_package:
+            d["home_comment"] = ""
+            d["homeurl"] = " " + yaml_quote_string(cran_package["URL"])
+        else:
+            # use CRAN page as homepage if nothing has been specified
+            d["home_comment"] = ""
+            if is_github_url:
+                d["homeurl"] = f" {location}"
+            else:
+                d["homeurl"] = f" https://CRAN.R-project.org/package={package}"
+
+        if (
+            not use_noarch_generic
+            or cran_package.get("NeedsCompilation", "no") == "yes"
+        ):
+            d["noarch_generic"] = ""
+        else:
+            d["noarch_generic"] = "noarch: generic"
+
+        if "Description" in cran_package:
+            d["summary_comment"] = ""
+            d["summary"] = " " + yaml_quote_string(cran_package["Description"])
+
+        if "Suggests" in cran_package and not no_comments:
+            d["suggests"] = "# Suggests: %s" % cran_package["Suggests"]
+        else:
+            d["suggests"] = ""
+
+        # Every package depends on at least R.
+        # I'm not sure what the difference between depends and imports is.
+        depends = [
+            s.strip() for s in cran_package.get("Depends", "").split(",") if s.strip()
+        ]
+        imports = [
+            s.strip() for s in cran_package.get("Imports", "").split(",") if s.strip()
+        ]
+        links = [
+            s.strip() for s in cran_package.get("LinkingTo", "").split(",") if s.strip()
+        ]
+
+        dep_dict = {}
+
+        seen = set()
+        for s in list(chain(imports, depends, links)):
+            match = VERSION_DEPENDENCY_REGEX.match(s)
+            if not match:
+                sys.exit(f"Could not parse version from dependency of {package}: {s}")
+            name = match.group("name")
+            if name in seen:
+                continue
+            seen.add(name)
+            archs = match.group("archs")
+            relop = match.group("relop") or ""
+            ver = match.group("version") or ""
+            ver = ver.replace("-", "_")
+            # If there is a relop there should be a version
+            assert not relop or ver
+
+            if archs:
+                sys.exit(
+                    "Don't know how to handle archs from dependency of "
+                    f"package {package}: {s}"
+                )
+
+            dep_dict[name] = f"{relop}{ver}"
+
+        if "R" not in dep_dict:
+            dep_dict["R"] = ""
+
+        os_type = cran_package.get("OS_type", "")
+        if os_type != "unix" and os_type != "windows" and os_type != "":
+            print(f"Unknown OS_type: {os_type} in CRAN package")
+            os_type = ""
+        if os_type == "unix":
+            d["skip_os"] = "skip: True  # [not unix]"
+            d["noarch_generic"] = ""
+        if os_type == "windows":
+            d["skip_os"] = "skip: True  # [not win]"
+            d["noarch_generic"] = ""
+        if os_type == "" and no_comments:
+            d["skip_os"] = ""
+        elif os_type == "":
+            d["skip_os"] = "# no skip"
+
+        need_git = is_github_url
+        if cran_package.get("NeedsCompilation", "no") == "yes":
+            with tarfile.open(available["source"]["cached_path"]) as tf:
+                need_f = any(
+                    [
+                        f.name.lower().endswith((".f", ".f90", ".f77", ".f95", ".f03"))
+                        for f in tf
+                    ]
+                )
+                # Fortran builds use CC to perform the link (they do not call the linker directly).
+                need_c = (
+                    True if need_f else any([f.name.lower().endswith(".c") for f in tf])
+                )
+                need_cxx = any(
+                    [
+                        f.name.lower().endswith((".cxx", ".cpp", ".cc", ".c++"))
+                        for f in tf
+                    ]
+                )
+                need_autotools = any(
+                    [f.name.lower().endswith("/configure") for f in tf]
+                )
+                need_make = (
+                    True
+                    if any((need_autotools, need_f, need_cxx, need_c))
+                    else any(
+                        [
+                            f.name.lower().endswith(("/makefile", "/makevars"))
+                            for f in tf
+                        ]
+                    )
+                )
+        else:
+            need_c = need_cxx = need_f = need_autotools = need_make = False
+
+        if "Rcpp" in dep_dict or "RcppArmadillo" in dep_dict:
+            need_cxx = True
+
+        if need_cxx:
+            need_c = True
+
+        for dep_type in ["build", "host", "run"]:
+            deps = []
+            # Put non-R dependencies first.
+            if dep_type == "build":
+                if need_c:
+                    deps.append(
+                        f"{INDENT}{{{{ compiler('c') }}}}            {sel_src_not_win}"
+                    )
+                    deps.append(
+                        f"{INDENT}{{{{ compiler('m2w64_c') }}}}      {sel_src_and_win}"
+                    )
+                if need_cxx:
+                    deps.append(
+                        f"{INDENT}{{{{ compiler('cxx') }}}}          {sel_src_not_win}"
+                    )
+                    deps.append(
+                        f"{INDENT}{{{{ compiler('m2w64_cxx') }}}}    {sel_src_and_win}"
+                    )
+                if need_f:
+                    deps.append(
+                        f"{INDENT}{{{{ compiler('fortran') }}}}      {sel_src_not_win}"
+                    )
+                    deps.append(
+                        f"{INDENT}{{{{ compiler('m2w64_fortran') }}}}{sel_src_and_win}"
+                    )
+                if use_rtools_win:
+                    need_c = need_cxx = need_f = need_autotools = need_make = False
+                    deps.append(f"{INDENT}rtools                   {sel_src_and_win}")
+                    # extsoft is legacy. R packages will download rwinlib subprojects
+                    # as necessary according to Jeroen Ooms. (may need to disable that
+                    # for non-MRO builds or maybe switch to Jeroen's toolchain?)
+                    # deps.append("{indent}{{{{native}}}}extsoft     {sel}".format(
+                    #     indent=INDENT, sel=sel_src_and_win))
+                if need_autotools or need_make or need_git:
+                    deps.append(
+                        f"{INDENT}{{{{ posix }}}}filesystem      {sel_src_and_win}"
+                    )
+                if need_git:
+                    deps.append(f"{INDENT}{{{{ posix }}}}git")
+                if need_autotools:
+                    deps.append(
+                        f"{INDENT}{{{{ posix }}}}sed             {sel_src_and_win}"
+                    )
+                    deps.append(
+                        f"{INDENT}{{{{ posix }}}}grep            {sel_src_and_win}"
+                    )
+                    deps.append(f"{INDENT}{{{{ posix }}}}autoconf        {sel_src}")
+                    deps.append(
+                        f"{INDENT}{{{{ posix }}}}automake        {sel_src_not_win}"
+                    )
+                    deps.append(
+                        f"{INDENT}{{{{ posix }}}}automake-wrapper{sel_src_and_win}"
+                    )
+                    deps.append(f"{INDENT}{{{{ posix }}}}pkg-config")
+                if need_make:
+                    deps.append(f"{INDENT}{{{{ posix }}}}make            {sel_src}")
+                    if not need_autotools:
+                        deps.append(
+                            f"{INDENT}{{{{ posix }}}}sed             {sel_src_and_win}"
+                        )
+                    deps.append(
+                        f"{INDENT}{{{{ posix }}}}coreutils       {sel_src_and_win}"
+                    )
+                deps.append(f"{INDENT}{{{{ posix }}}}zip             {sel_src_and_win}")
+                if add_cross_r_base:
+                    deps.append(f"{INDENT}cross-r-base {{{{ r_base }}}}  {sel_cross}")
+            elif dep_type == "run":
+                if need_c or need_cxx or need_f:
+                    deps.append(
+                        f"{INDENT}{{{{native}}}}gcc-libs       {sel_src_and_win}"
+                    )
+
+            if dep_type == "host" or dep_type == "run":
+                for name in sorted(dep_dict):
+                    if name in R_BASE_PACKAGE_NAMES:
+                        continue
+                    if name == "R":
+                        # Put R first
+                        # Regarless of build or run, and whether this is a
+                        # recommended package or not, it can only depend on
+                        # r_interp since anything else can and will cause
+                        # cycles in the dependency graph. The cran metadata
+                        # lists all dependencies anyway, even those packages
+                        # that are in the recommended group.
+                        # We don't include any R version restrictions because
+                        # conda-build always pins r-base and mro-base version.
+                        deps.insert(0, f"{INDENT}{r_interp}")
+                    else:
+                        conda_name = "r-" + name.lower()
+
+                        if dep_dict[name]:
+                            deps.append(f"{INDENT}{conda_name} {dep_dict[name]}")
+                        else:
+                            deps.append(f"{INDENT}{conda_name}")
+                        if recursive:
+                            lower_name = name.lower()
+                            if lower_name not in package_dicts:
+                                inputs_dict = package_to_inputs_dict(
+                                    output_dir, output_suffix, git_tag, lower_name, None
+                                )
+                                assert (
+                                    lower_name == inputs_dict["pkg-name"]
+                                ), "name {} != inputs_dict['pkg-name'] {}".format(
+                                    name, inputs_dict["pkg-name"]
+                                )
+                                assert lower_name not in package_list
+                                package_dicts.update(
+                                    {lower_name: {"inputs": inputs_dict}}
+                                )
+                                package_list.append(lower_name)
+
+            d["%s_depends" % dep_type] = "".join(deps)
+
+    if no_comments:
+        global CRAN_BUILD_SH_SOURCE, CRAN_META
+        CRAN_BUILD_SH_SOURCE = remove_comments(CRAN_BUILD_SH_SOURCE)
+        CRAN_META = remove_comments(CRAN_META)
+
+    for package in package_dicts:
+        d = package_dicts[package]
+        dir_path = d["inputs"]["new-location"]
+        if exists(dir_path) and not version_compare:
+            if update_policy == "error":
+                raise RuntimeError(
+                    "directory already exists "
+                    "(and --update-policy is 'error'): %s" % dir_path
+                )
+            elif update_policy == "overwrite":
+                rm_rf(dir_path)
+        elif update_policy == "skip-up-to-date":
+            if cran_index is None:
+                session = get_session(output_dir)
+                cran_index = get_cran_index(cran_url, session)
+            if up_to_date(cran_index, d["inputs"]["old-metadata"]):
+                continue
+        elif update_policy == "skip-existing" and d["inputs"]["old-metadata"]:
+            continue
+
+        from_sources = d["from_source"]
+        # Normalize the metadata values
+        d = {
+            k: unicodedata.normalize("NFKD", str(v)).encode("ascii", "ignore").decode()
+            for k, v in d.items()
+        }
+        try:
+            makedirs(join(dir_path))
+        except:
+            pass
+        print("Writing recipe for %s" % package.lower())
+        with open(join(dir_path, "meta.yaml"), "w") as f:
+            f.write(clear_whitespace(CRAN_META.format(**d)))
+        if not exists(join(dir_path, "build.sh")) or update_policy == "overwrite":
+            with open(join(dir_path, "build.sh"), "wb") as f:
+                if from_sources == _all:
+                    f.write(CRAN_BUILD_SH_SOURCE.format(**d).encode("utf-8"))
+                elif from_sources == []:
+                    f.write(CRAN_BUILD_SH_BINARY.format(**d).encode("utf-8"))
+                else:
+                    tpbt = [target_platform_bash_test_by_sel[t] for t in from_sources]
+                    d["source_pf_bash"] = " || ".join(
+                        ["[[ ${target_platform} " + s + " ]]" for s in tpbt]
+                    )
+                    f.write(CRAN_BUILD_SH_MIXED.format(**d).encode("utf-8"))
+
+        if not exists(join(dir_path, "bld.bat")) or update_policy == "overwrite":
+            with open(join(dir_path, "bld.bat"), "wb") as f:
+                if len([fs for fs in from_sources if fs.startswith("win")]) == 2:
+                    f.write(
+                        CRAN_BLD_BAT_SOURCE.format(**d)
+                        .replace("\n", "\r\n")
+                        .encode("utf-8")
+                    )
+                else:
+                    f.write(
+                        CRAN_BLD_BAT_MIXED.format(**d)
+                        .replace("\n", "\r\n")
+                        .encode("utf-8")
+                    )
+
+
+def version_compare(recipe_dir: str, newest_conda_version):
+    m = MetaData(recipe_dir)
+    local_version = m.version()
+    package = basename(recipe_dir)
+
+    print(f"Local recipe for {package} has version {local_version}.")
+
+    print(f"The version on CRAN for {package} is {newest_conda_version}.")
+
+    return local_version == newest_conda_version
+
+
+def get_outdated(output_dir, cran_index, packages=()):
+    to_update = []
+    recipes = listdir(output_dir)
+    for recipe in recipes:
+        if not recipe.startswith("r-") or not isdir(recipe):
+            continue
+
+        recipe_name = recipe[2:]
+
+        if packages and not (recipe_name in packages or recipe in packages):
+            continue
+
+        if recipe_name not in cran_index:
+            print("Skipping %s, not found on CRAN" % recipe)
+            continue
+
+        version_compare(
+            join(output_dir, recipe), cran_index[recipe_name][1].replace("-", "_")
+        )
+
+        print("Updating %s" % recipe)
+        to_update.append(recipe_name)
+
+    return to_update
+
+
+def get_existing(output_dir, cran_index, packages=()):
+    existing = []
+    recipes = listdir(output_dir)
+    for recipe in recipes:
+        if not recipe.startswith("r-") or not isdir(recipe):
+            continue
+
+        recipe_name = recipe[2:]
+
+        if packages and not (recipe_name in packages or recipe in packages):
+            continue
+
+        existing.append(recipe_name)
+
+    return existing
+
+
+def up_to_date(cran_index, package):
+    r_pkg_name, location, old_git_rev, m = package
+    cran_pkg_name = r_pkg_name[2:]
+
+    # Does not exist, so is not up to date.
+    if not m:
+        return False
+
+    # For now. We can do better; need to collect *all* information upfront.
+    if "github.com" in location:
+        return False
+    else:
+        if cran_pkg_name not in cran_index:
+            return False
+
+    name, version = cran_index[cran_pkg_name]
+    if version and m.version() != version:
+        return False
+
+    return True
+
+
+def get_license_info(license_text, allowed_license_families):
+    """
+    Most R packages on CRAN do not include a license file. Instead, to avoid
+    duplication, R base ships with common software licenses:
+
+    complete: AGPL-3, Artistic-2.0, GPL-2, GPL-3, LGPL-2, LGPL-2.1, LGPL-3
+    template: BSD_2_clause BSD_3_clause, MIT
+
+    The complete licenses can be included in conda binaries by pointing to the
+    license file shipped with R base. The template files are more complicated
+    because they would need to be combined with the license information provided
+    by the package authors. In this case, the template file and the license
+    information file are both packaged. All optional ('|' seperated) licenses
+    are included, if they are matching.
+
+    This function returns the path to the license file for the unambiguous
+    cases.
+    """
+
+    # The list order matters. The first element should be the name of the
+    # license file shipped with r-base.
+    d_license = {
+        "agpl3": ["AGPL-3", "AGPL (>= 3)", "AGPL", "GNU Affero General Public License"],
+        "artistic2": ["Artistic-2.0", "Artistic License 2.0"],
+        "gpl2": ["GPL-2", "GPL (>= 2)", "GNU General Public License (>= 2)"],
+        "gpl3": [
+            "GPL-3",
+            "GPL (>= 3)",
+            "GNU General Public License (>= 3)",
+            "GPL",
+            "GNU General Public License",
+        ],
+        "lgpl2": ["LGPL-2", "LGPL (>= 2)"],
+        "lgpl21": ["LGPL-2.1", "LGPL (>= 2.1)"],
+        "lgpl3": ["LGPL-3", "LGPL (>= 3)", "LGPL", "GNU Lesser General Public License"],
+        "bsd2": ["BSD_2_clause", "BSD_2_Clause", "BSD 2-clause License"],
+        "bsd3": ["BSD_3_clause", "BSD_3_Clause", "BSD 3-clause License"],
+        "mit": ["MIT"],
+    }
+
+    license_file_template = (
+        "'{{{{ environ[\"PREFIX\"] }}}}/lib/R/share/licenses/{license_id}'"
+    )
+
+    license_texts = []
+    license_files = []
+
+    # split license_text by "|" and "+" into parts for further matching
+    license_text_parts = [l_opt.strip() for l_opt in re.split(r"\||\+", license_text)]
+    for l_opt in license_text_parts:
+        # the file case
+        if l_opt.startswith("file "):
+            license_files.append(l_opt[5:])
+            continue
+
+        # license id string to match
+        for license_id in d_license.keys():
+            if l_opt in d_license[license_id]:
+                l_opt_text = d_license[license_id][0]
+
+                license_texts.append(l_opt_text)
+                license_files.append(
+                    license_file_template.format(license_id=l_opt_text)
+                )
+                break
+
+    # Join or fallback to original license_text if matched license_texts is empty
+    license_text = " | ".join(license_texts) or license_text
+
+    # Build the license_file entry and ensure it is empty if no license file
+    license_file = ""
+    if license_files:
+        license_file = f"license_file:{dashlist(license_files, indent=4)}\n"
+
+    # Only one family is allowed, so guessing it once
+    license_family = guess_license_family(license_text, allowed_license_families)
+
+    return license_text, license_file, license_family

shared/package-files/d1/d15889a91b4964b212ec87e31eb520608e9122f598d1c7e4d4e8c0969e3466cc/top_level.txt

@@ -0,0 +1 @@
+matplotlib_inline

shared/package-files/d1/d1648a9846ff3b8a687e05635aa0c20c867054f93762f02e49ba6514afe29139/max_native.h

@@ -0,0 +1,32 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+#include <ATen/ops/max_meta.h>
+
+namespace at {
+namespace native {
+struct TORCH_API structured_max_out : public at::meta::structured_max_dim {
+void impl(const at::Tensor & self, int64_t dim, bool keepdim, const at::Tensor & max, const at::Tensor & max_values);
+};
+TORCH_API ::std::tuple<at::Tensor,at::Tensor> qmax(const at::Tensor & self, int64_t dim, bool keepdim=false);
+TORCH_API ::std::tuple<at::Tensor,at::Tensor> max(const at::Tensor & self, at::Dimname dim, bool keepdim=false);
+TORCH_API ::std::tuple<at::Tensor &,at::Tensor &> max_out(const at::Tensor & self, at::Dimname dim, bool keepdim, at::Tensor & max, at::Tensor & max_values);
+TORCH_API at::Tensor max(const at::Tensor & self);
+TORCH_API at::Tensor & max_unary_out(const at::Tensor & self, at::Tensor & out);
+TORCH_API at::Tensor max_quantized_cpu(const at::Tensor & self);
+TORCH_API at::Tensor & max_quantized_unary_out(const at::Tensor & self, at::Tensor & out);
+TORCH_API at::Tensor max(const at::Tensor & self, const at::Tensor & other);
+TORCH_API at::Tensor & max_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+} // namespace native
+} // namespace at

shared/package-files/d1/d173be07d5e60068962e11055bcc2e8c5a3e551d6beb64993fb313f83073d551/test_qcut.py

@@ -0,0 +1,305 @@
+import os
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DatetimeIndex,
+    Interval,
+    IntervalIndex,
+    NaT,
+    Series,
+    Timedelta,
+    TimedeltaIndex,
+    Timestamp,
+    cut,
+    date_range,
+    isna,
+    qcut,
+    timedelta_range,
+)
+import pandas._testing as tm
+from pandas.api.types import CategoricalDtype
+
+from pandas.tseries.offsets import Day
+
+
+def test_qcut():
+    arr = np.random.default_rng(2).standard_normal(1000)
+
+    # We store the bins as Index that have been
+    # rounded to comparisons are a bit tricky.
+    labels, _ = qcut(arr, 4, retbins=True)
+    ex_bins = np.quantile(arr, [0, 0.25, 0.5, 0.75, 1.0])
+
+    result = labels.categories.left.values
+    assert np.allclose(result, ex_bins[:-1], atol=1e-2)
+
+    result = labels.categories.right.values
+    assert np.allclose(result, ex_bins[1:], atol=1e-2)
+
+    ex_levels = cut(arr, ex_bins, include_lowest=True)
+    tm.assert_categorical_equal(labels, ex_levels)
+
+
+def test_qcut_bounds():
+    arr = np.random.default_rng(2).standard_normal(1000)
+
+    factor = qcut(arr, 10, labels=False)
+    assert len(np.unique(factor)) == 10
+
+
+def test_qcut_specify_quantiles():
+    arr = np.random.default_rng(2).standard_normal(100)
+    factor = qcut(arr, [0, 0.25, 0.5, 0.75, 1.0])
+
+    expected = qcut(arr, 4)
+    tm.assert_categorical_equal(factor, expected)
+
+
+def test_qcut_all_bins_same():
+    with pytest.raises(ValueError, match="edges.*unique"):
+        qcut([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 3)
+
+
+def test_qcut_include_lowest():
+    values = np.arange(10)
+    ii = qcut(values, 4)
+
+    ex_levels = IntervalIndex(
+        [
+            Interval(-0.001, 2.25),
+            Interval(2.25, 4.5),
+            Interval(4.5, 6.75),
+            Interval(6.75, 9),
+        ]
+    )
+    tm.assert_index_equal(ii.categories, ex_levels)
+
+
+def test_qcut_nas():
+    arr = np.random.default_rng(2).standard_normal(100)
+    arr[:20] = np.nan
+
+    result = qcut(arr, 4)
+    assert isna(result[:20]).all()
+
+
+def test_qcut_index():
+    result = qcut([0, 2], 2)
+    intervals = [Interval(-0.001, 1), Interval(1, 2)]
+
+    expected = Categorical(intervals, ordered=True)
+    tm.assert_categorical_equal(result, expected)
+
+
+def test_qcut_binning_issues(datapath):
+    # see gh-1978, gh-1979
+    cut_file = datapath(os.path.join("reshape", "data", "cut_data.csv"))
+    arr = np.loadtxt(cut_file)
+    result = qcut(arr, 20)
+
+    starts = []
+    ends = []
+
+    for lev in np.unique(result):
+        s = lev.left
+        e = lev.right
+        assert s != e
+
+        starts.append(float(s))
+        ends.append(float(e))
+
+    for (sp, sn), (ep, en) in zip(
+        zip(starts[:-1], starts[1:]), zip(ends[:-1], ends[1:])
+    ):
+        assert sp < sn
+        assert ep < en
+        assert ep <= sn
+
+
+def test_qcut_return_intervals():
+    ser = Series([0, 1, 2, 3, 4, 5, 6, 7, 8])
+    res = qcut(ser, [0, 0.333, 0.666, 1])
+
+    exp_levels = np.array(
+        [Interval(-0.001, 2.664), Interval(2.664, 5.328), Interval(5.328, 8)]
+    )
+    exp = Series(exp_levels.take([0, 0, 0, 1, 1, 1, 2, 2, 2])).astype(
+        CategoricalDtype(ordered=True)
+    )
+    tm.assert_series_equal(res, exp)
+
+
+@pytest.mark.parametrize("labels", ["foo", 1, True])
+def test_qcut_incorrect_labels(labels):
+    # GH 13318
+    values = range(5)
+    msg = "Bin labels must either be False, None or passed in as a list-like argument"
+    with pytest.raises(ValueError, match=msg):
+        qcut(values, 4, labels=labels)
+
+
+@pytest.mark.parametrize("labels", [["a", "b", "c"], list(range(3))])
+def test_qcut_wrong_length_labels(labels):
+    # GH 13318
+    values = range(10)
+    msg = "Bin labels must be one fewer than the number of bin edges"
+    with pytest.raises(ValueError, match=msg):
+        qcut(values, 4, labels=labels)
+
+
+@pytest.mark.parametrize(
+    "labels, expected",
+    [
+        (["a", "b", "c"], Categorical(["a", "b", "c"], ordered=True)),
+        (list(range(3)), Categorical([0, 1, 2], ordered=True)),
+    ],
+)
+def test_qcut_list_like_labels(labels, expected):
+    # GH 13318
+    values = range(3)
+    result = qcut(values, 3, labels=labels)
+    tm.assert_categorical_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "kwargs,msg",
+    [
+        ({"duplicates": "drop"}, None),
+        ({}, "Bin edges must be unique"),
+        ({"duplicates": "raise"}, "Bin edges must be unique"),
+        ({"duplicates": "foo"}, "invalid value for 'duplicates' parameter"),
+    ],
+)
+def test_qcut_duplicates_bin(kwargs, msg):
+    # see gh-7751
+    values = [0, 0, 0, 0, 1, 2, 3]
+
+    if msg is not None:
+        with pytest.raises(ValueError, match=msg):
+            qcut(values, 3, **kwargs)
+    else:
+        result = qcut(values, 3, **kwargs)
+        expected = IntervalIndex([Interval(-0.001, 1), Interval(1, 3)])
+        tm.assert_index_equal(result.categories, expected)
+
+
+@pytest.mark.parametrize(
+    "data,start,end", [(9.0, 8.999, 9.0), (0.0, -0.001, 0.0), (-9.0, -9.001, -9.0)]
+)
+@pytest.mark.parametrize("length", [1, 2])
+@pytest.mark.parametrize("labels", [None, False])
+def test_single_quantile(data, start, end, length, labels):
+    # see gh-15431
+    ser = Series([data] * length)
+    result = qcut(ser, 1, labels=labels)
+
+    if labels is None:
+        intervals = IntervalIndex([Interval(start, end)] * length, closed="right")
+        expected = Series(intervals).astype(CategoricalDtype(ordered=True))
+    else:
+        expected = Series([0] * length, dtype=np.intp)
+
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "ser",
+    [
+        Series(DatetimeIndex(["20180101", NaT, "20180103"])),
+        Series(TimedeltaIndex(["0 days", NaT, "2 days"])),
+    ],
+    ids=lambda x: str(x.dtype),
+)
+def test_qcut_nat(ser, unit):
+    # see gh-19768
+    ser = ser.dt.as_unit(unit)
+    td = Timedelta(1, unit=unit).as_unit(unit)
+
+    left = Series([ser[0] - td, np.nan, ser[2] - Day()], dtype=ser.dtype)
+    right = Series([ser[2] - Day(), np.nan, ser[2]], dtype=ser.dtype)
+    intervals = IntervalIndex.from_arrays(left, right)
+    expected = Series(Categorical(intervals, ordered=True))
+
+    result = qcut(ser, 2)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("bins", [3, np.linspace(0, 1, 4)])
+def test_datetime_tz_qcut(bins):
+    # see gh-19872
+    tz = "US/Eastern"
+    ser = Series(date_range("20130101", periods=3, tz=tz))
+
+    result = qcut(ser, bins)
+    expected = Series(
+        IntervalIndex(
+            [
+                Interval(
+                    Timestamp("2012-12-31 23:59:59.999999999", tz=tz),
+                    Timestamp("2013-01-01 16:00:00", tz=tz),
+                ),
+                Interval(
+                    Timestamp("2013-01-01 16:00:00", tz=tz),
+                    Timestamp("2013-01-02 08:00:00", tz=tz),
+                ),
+                Interval(
+                    Timestamp("2013-01-02 08:00:00", tz=tz),
+                    Timestamp("2013-01-03 00:00:00", tz=tz),
+                ),
+            ]
+        )
+    ).astype(CategoricalDtype(ordered=True))
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "arg,expected_bins",
+    [
+        [
+            timedelta_range("1day", periods=3),
+            TimedeltaIndex(["1 days", "2 days", "3 days"]),
+        ],
+        [
+            date_range("20180101", periods=3),
+            DatetimeIndex(["2018-01-01", "2018-01-02", "2018-01-03"]),
+        ],
+    ],
+)
+def test_date_like_qcut_bins(arg, expected_bins):
+    # see gh-19891
+    ser = Series(arg)
+    result, result_bins = qcut(ser, 2, retbins=True)
+    tm.assert_index_equal(result_bins, expected_bins)
+
+
+@pytest.mark.parametrize("bins", [6, 7])
+@pytest.mark.parametrize(
+    "box, compare",
+    [
+        (Series, tm.assert_series_equal),
+        (np.array, tm.assert_categorical_equal),
+        (list, tm.assert_equal),
+    ],
+)
+def test_qcut_bool_coercion_to_int(bins, box, compare):
+    # issue 20303
+    data_expected = box([0, 1, 1, 0, 1] * 10)
+    data_result = box([False, True, True, False, True] * 10)
+    expected = qcut(data_expected, bins, duplicates="drop")
+    result = qcut(data_result, bins, duplicates="drop")
+    compare(result, expected)
+
+
+@pytest.mark.parametrize("q", [2, 5, 10])
+def test_qcut_nullable_integer(q, any_numeric_ea_dtype):
+    arr = pd.array(np.arange(100), dtype=any_numeric_ea_dtype)
+    arr[::2] = pd.NA
+
+    result = qcut(arr, q)
+    expected = qcut(arr.astype(float), q)
+
+    tm.assert_categorical_equal(result, expected)

shared/package-files/d1/d17715b895804e35e43e4a58f764b71cfa6776456950d711dd3ec7a0899f0172/_nested_get_offsets.h

@@ -0,0 +1,30 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/_nested_get_offsets_ops.h>
+
+namespace at {
+
+
+// aten::_nested_get_offsets(Tensor self) -> Tensor
+inline at::Tensor _nested_get_offsets(const at::Tensor & self) {
+    return at::_ops::_nested_get_offsets::call(self);
+}
+
+}

shared/package-files/d1/d18db3d2b95eba710fe685b9dd20c03708d8acca258ed48b297261c633dfedf6/dtypes.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from narwhals.stable.v1._dtypes import (
+    Array,
+    Binary,
+    Boolean,
+    Categorical,
+    Date,
+    Datetime,
+    Decimal,
+    DType,
+    Duration,
+    Enum,
+    Field,
+    Float16,
+    Float32,
+    Float64,
+    FloatType,
+    Int8,
+    Int16,
+    Int32,
+    Int64,
+    Int128,
+    IntegerType,
+    List,
+    NestedType,
+    NumericType,
+    Object,
+    SignedIntegerType,
+    String,
+    Struct,
+    Time,
+    UInt8,
+    UInt16,
+    UInt32,
+    UInt64,
+    UInt128,
+    Unknown,
+    UnsignedIntegerType,
+)
+
+__all__ = [
+    "Array",
+    "Binary",
+    "Boolean",
+    "Categorical",
+    "DType",
+    "Date",
+    "Datetime",
+    "Decimal",
+    "Duration",
+    "Enum",
+    "Field",
+    "Float16",
+    "Float32",
+    "Float64",
+    "FloatType",
+    "Int8",
+    "Int16",
+    "Int32",
+    "Int64",
+    "Int128",
+    "IntegerType",
+    "List",
+    "NestedType",
+    "NumericType",
+    "Object",
+    "SignedIntegerType",
+    "String",
+    "Struct",
+    "Time",
+    "UInt8",
+    "UInt16",
+    "UInt32",
+    "UInt64",
+    "UInt128",
+    "Unknown",
+    "UnsignedIntegerType",
+]

shared/package-files/d1/d19128733490ab9f7338677f79693ab1f002b7adaf7509ad87789aeeea961533/_matrix_io.py

@@ -0,0 +1,167 @@
+import numpy as np
+import scipy as sp
+
+__all__ = ['save_npz', 'load_npz']
+
+
+# Make loading safe vs. malicious input
+PICKLE_KWARGS = dict(allow_pickle=False)
+
+
+def save_npz(file, matrix, compressed=True):
+    """ Save a sparse matrix or array to a file using ``.npz`` format.
+
+    Parameters
+    ----------
+    file : str or file-like object
+        Either the file name (string) or an open file (file-like object)
+        where the data will be saved. If file is a string, the ``.npz``
+        extension will be appended to the file name if it is not already
+        there.
+    matrix: spmatrix or sparray
+        The sparse matrix or array to save.
+        Supported formats: ``csc``, ``csr``, ``bsr``, ``dia`` or ``coo``.
+    compressed : bool, optional
+        Allow compressing the file. Default: True
+
+    See Also
+    --------
+    scipy.sparse.load_npz: Load a sparse matrix from a file using ``.npz`` format.
+    numpy.savez: Save several arrays into a ``.npz`` archive.
+    numpy.savez_compressed : Save several arrays into a compressed ``.npz`` archive.
+
+    Examples
+    --------
+    Store sparse matrix to disk, and load it again:
+
+    >>> import numpy as np
+    >>> import scipy as sp
+    >>> sparse_matrix = sp.sparse.csc_matrix([[0, 0, 3], [4, 0, 0]])
+    >>> sparse_matrix
+    <Compressed Sparse Column sparse matrix of dtype 'int64'
+        with 2 stored elements and shape (2, 3)>
+    >>> sparse_matrix.toarray()
+    array([[0, 0, 3],
+           [4, 0, 0]], dtype=int64)
+
+    >>> sp.sparse.save_npz('/tmp/sparse_matrix.npz', sparse_matrix)
+    >>> sparse_matrix = sp.sparse.load_npz('/tmp/sparse_matrix.npz')
+
+    >>> sparse_matrix
+    <Compressed Sparse Column sparse matrix of dtype 'int64'
+        with 2 stored elements and shape (2, 3)>
+    >>> sparse_matrix.toarray()
+    array([[0, 0, 3],
+           [4, 0, 0]], dtype=int64)
+    """
+    arrays_dict = {}
+    if matrix.format in ('csc', 'csr', 'bsr'):
+        arrays_dict.update(indices=matrix.indices, indptr=matrix.indptr)
+    elif matrix.format == 'dia':
+        arrays_dict.update(offsets=matrix.offsets)
+    elif matrix.format == 'coo':
+        arrays_dict.update(row=matrix.row, col=matrix.col)
+    else:
+        msg = f'Save is not implemented for sparse matrix of format {matrix.format}.'
+        raise NotImplementedError(msg)
+    arrays_dict.update(
+        format=matrix.format.encode('ascii'),
+        shape=matrix.shape,
+        data=matrix.data
+    )
+    if isinstance(matrix, sp.sparse.sparray):
+        arrays_dict.update(_is_array=True)
+    if compressed:
+        np.savez_compressed(file, **arrays_dict)
+    else:
+        np.savez(file, **arrays_dict)
+
+
+def load_npz(file):
+    """ Load a sparse array/matrix from a file using ``.npz`` format.
+
+    Parameters
+    ----------
+    file : str or file-like object
+        Either the file name (string) or an open file (file-like object)
+        where the data will be loaded.
+
+    Returns
+    -------
+    result : csc_array, csr_array, bsr_array, dia_array or coo_array
+        A sparse array/matrix containing the loaded data.
+
+    Raises
+    ------
+    OSError
+        If the input file does not exist or cannot be read.
+
+    See Also
+    --------
+    scipy.sparse.save_npz: Save a sparse array/matrix to a file using ``.npz`` format.
+    numpy.load: Load several arrays from a ``.npz`` archive.
+
+    Examples
+    --------
+    Store sparse array/matrix to disk, and load it again:
+
+    >>> import numpy as np
+    >>> import scipy as sp
+    >>> sparse_array = sp.sparse.csc_array([[0, 0, 3], [4, 0, 0]])
+    >>> sparse_array
+    <Compressed Sparse Column sparse array of dtype 'int64'
+        with 2 stored elements and shape (2, 3)>
+    >>> sparse_array.toarray()
+    array([[0, 0, 3],
+           [4, 0, 0]], dtype=int64)
+
+    >>> sp.sparse.save_npz('/tmp/sparse_array.npz', sparse_array)
+    >>> sparse_array = sp.sparse.load_npz('/tmp/sparse_array.npz')
+
+    >>> sparse_array
+    <Compressed Sparse Column sparse array of dtype 'int64'
+        with 2 stored elements and shape (2, 3)>
+    >>> sparse_array.toarray()
+    array([[0, 0, 3],
+           [4, 0, 0]], dtype=int64)
+
+    In this example we force the result to be csr_array from csr_matrix
+    >>> sparse_matrix = sp.sparse.csc_matrix([[0, 0, 3], [4, 0, 0]])
+    >>> sp.sparse.save_npz('/tmp/sparse_matrix.npz', sparse_matrix)
+    >>> tmp = sp.sparse.load_npz('/tmp/sparse_matrix.npz')
+    >>> sparse_array = sp.sparse.csr_array(tmp)
+    """
+    with np.load(file, **PICKLE_KWARGS) as loaded:
+        sparse_format = loaded.get('format')
+        if sparse_format is None:
+            raise ValueError(f'The file {file} does not contain '
+                             f'a sparse array or matrix.')
+        sparse_format = sparse_format.item()
+
+        if not isinstance(sparse_format, str):
+            # Play safe with Python 2 vs 3 backward compatibility;
+            # files saved with SciPy < 1.0.0 may contain unicode or bytes.
+            sparse_format = sparse_format.decode('ascii')
+
+        if loaded.get('_is_array'):
+            sparse_type = sparse_format + '_array'
+        else:
+            sparse_type = sparse_format + '_matrix'
+
+        try:
+            cls = getattr(sp.sparse, f'{sparse_type}')
+        except AttributeError as e:
+            raise ValueError(f'Unknown format "{sparse_type}"') from e
+
+        if sparse_format in ('csc', 'csr', 'bsr'):
+            return cls((loaded['data'], loaded['indices'], loaded['indptr']),
+                       shape=loaded['shape'])
+        elif sparse_format == 'dia':
+            return cls((loaded['data'], loaded['offsets']),
+                       shape=loaded['shape'])
+        elif sparse_format == 'coo':
+            return cls((loaded['data'], (loaded['row'], loaded['col'])),
+                       shape=loaded['shape'])
+        else:
+            raise NotImplementedError(f'Load is not implemented for '
+                                      f'sparse matrix of format {sparse_format}.')

shared/package-files/d1/d19a7033230c463a7a56d9db153d219ae5719f31ed260f694f10c961133c9fa6/selecting.py

@@ -0,0 +1,96 @@
+from typing import Callable, Iterator, Tuple, TypeVar
+
+from torch.utils.data.datapipes._decorator import functional_datapipe
+from torch.utils.data.datapipes.datapipe import IterDataPipe
+from torch.utils.data.datapipes.dataframe import dataframe_wrapper as df_wrapper
+from torch.utils.data.datapipes.utils.common import (
+    _check_unpickable_fn,
+    StreamWrapper,
+    validate_input_col
+)
+
+
+__all__ = ["FilterIterDataPipe", ]
+
+T = TypeVar('T')
+T_co = TypeVar('T_co', covariant=True)
+
+
+@functional_datapipe('filter')
+class FilterIterDataPipe(IterDataPipe[T_co]):
+    r"""
+    Filters out elements from the source datapipe according to input ``filter_fn`` (functional name: ``filter``).
+
+    Args:
+        datapipe: Iterable DataPipe being filtered
+        filter_fn: Customized function mapping an element to a boolean.
+        input_col: Index or indices of data which ``filter_fn`` is applied, such as:
+
+            - ``None`` as default to apply ``filter_fn`` to the data directly.
+            - Integer(s) is used for list/tuple.
+            - Key(s) is used for dict.
+
+    Example:
+        >>> # xdoctest: +SKIP
+        >>> from torchdata.datapipes.iter import IterableWrapper
+        >>> def is_even(n):
+        ...     return n % 2 == 0
+        >>> dp = IterableWrapper(range(5))
+        >>> filter_dp = dp.filter(filter_fn=is_even)
+        >>> list(filter_dp)
+        [0, 2, 4]
+    """
+
+    datapipe: IterDataPipe[T_co]
+    filter_fn: Callable
+
+    def __init__(
+        self,
+        datapipe: IterDataPipe[T_co],
+        filter_fn: Callable,
+        input_col=None,
+    ) -> None:
+        super().__init__()
+        self.datapipe = datapipe
+
+        _check_unpickable_fn(filter_fn)
+        self.filter_fn = filter_fn  # type: ignore[assignment]
+
+        self.input_col = input_col
+        validate_input_col(filter_fn, input_col)
+
+    def _apply_filter_fn(self, data) -> bool:
+        if self.input_col is None:
+            return self.filter_fn(data)
+        elif isinstance(self.input_col, (list, tuple)):
+            args = tuple(data[col] for col in self.input_col)
+            return self.filter_fn(*args)
+        else:
+            return self.filter_fn(data[self.input_col])
+
+    def __iter__(self) -> Iterator[T_co]:
+        for data in self.datapipe:
+            condition, filtered = self._returnIfTrue(data)
+            if condition:
+                yield filtered
+            else:
+                StreamWrapper.close_streams(data)
+
+    def _returnIfTrue(self, data: T) -> Tuple[bool, T]:
+        condition = self._apply_filter_fn(data)
+
+        if df_wrapper.is_column(condition):
+            # We are operating on DataFrames filter here
+            result = []
+            for idx, mask in enumerate(df_wrapper.iterate(condition)):
+                if mask:
+                    result.append(df_wrapper.get_item(data, idx))
+            if len(result):
+                return True, df_wrapper.concat(result)
+            else:
+                return False, None  # type: ignore[return-value]
+
+        if not isinstance(condition, bool):
+            raise ValueError("Boolean output is required for `filter_fn` of FilterIterDataPipe, got", type(condition))
+
+        return condition, data