Publish 11 evaluated Astra histories with reproducible checkpoint artifacts (part 16)

.gitattributes

@@ -252,3 +252,22 @@ shared/package-files/2d/2d1384f65f1897f0ebd3685461cdedefd4c38e9148004d66478721a5
 shared/package-files/2d/2dafd96242e798bd6badf82ca2e58a75f7ae39b59e85a15a04ab6724ba6a67f1/blob filter=lfs diff=lfs merge=lfs -text
 shared/package-files/2d/2df214270d7c2fc2dba566a047d23e2a1ae88d8de5b64a95325511838a6e3129/blob filter=lfs diff=lfs merge=lfs -text
 shared/package-files/2e/2e744a910df689584b5e7f45e62723e8fcfb1951f82bbc5e5f0b385caa27a15a/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2e/2e94bf106f33025763f512d208285c441f2344c344d4c3f3a67ba778d0589f51/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2e/2ea4a717a746c15cfa898719b58815519482e2875a2119c5457e6f0885af589d/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2e/2eb0e1b96a4fa1f4fcc3edbaefaf5094c583a852ee0bcf8715b1cce911477b3b/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2f/2f1a92c18f01c13c9a89908fb86a7309ae5b89a882db9914114957bc4b6fed92/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2f/2f1d086b642fd7ca8cde9c3c1bfbdda86f9178e42ffb035d2e285e27180f71ff/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2f/2f2ed822742486b148167fa34eb9725a66c2686afbc4f12f2c94466d38dcb522/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2f/2f31a0f1567cea4ce99391a914d6f783de2d33543ae3a690ca11ba51fc284327/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2f/2f49d9e22c0ac3805fd499e23815b6310a447dad1a85541b6aadd6c7968c1ef7/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2f/2f626635294596acca06c371a1312462b11e6cd919678eb3e244d61d4e0a2db5/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2f/2f78bbcbca0c663f15bb1744612a35e97581a1063b99c05b6d560bc417976aa2/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2f/2f78f2961eda0d1fbe672fd4e14692d4c36f2a6a6a570e634cb347bec89c7e35/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2f/2f84ea0d0e55dfc231a9e4a351e6034c21fd9e9efd3f84958c10ea43fb7b1a99/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2f/2fb9b38eba1d1b12b464d7828efc94a3c8306599909bbc7db311fab71d96d061/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/2f/2fbf3905d18dcba8e6899424c9ba60c25bce67893e84a22fbb8ea6a4a8a29b2e/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/30/30aa6a82e55c9b6882c41c9aaf9e9137c4c8c4545b627542d6b23ef5743b0acc/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/30/30e2c5853b7762551f32be245e79fd9d06e52a7cfdfd9c31bfece83405563292/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/31/3196378de7c8f842481203abc471a1e1b5f231b4c1da26fd6812cc90df38e012/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/31/31977145330b3a430a9088dcab494e4598947e5084b79e19958f694840c249e6/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/31/31b8c3d177e2f59d9cff0198d08c057aafd81f9098b9ad34eae9d7a4a7b10120/blob filter=lfs diff=lfs merge=lfs -text

shared/package-files/2e/2e88d0c1ed7f4e4b8068130b6210fd68f61897d9fafa2f14015acb2879a18d3a/blob

@@ -0,0 +1,39 @@
+#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 mkldnn_max_pool3d {
+  using schema = at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::mkldnn_max_pool3d")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "mkldnn_max_pool3d(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode);
+};
+
+struct TORCH_API mkldnn_max_pool3d_out {
+  using schema = at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::mkldnn_max_pool3d")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "mkldnn_max_pool3d.out(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out);
+};
+
+}} // namespace at::_ops

shared/package-files/2e/2e8cb9fbcd3ba9fee49adc064123d8a063d6473936ef84719fc5c5343c1352f8/blob

@@ -0,0 +1,61 @@
+#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/blackman_window_ops.h>
+
+namespace at {
+
+
+// aten::blackman_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
+inline at::Tensor blackman_window(int64_t window_length, at::TensorOptions options={}) {
+    return at::_ops::blackman_window::call(window_length, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
+}
+// aten::blackman_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
+inline at::Tensor blackman_window(int64_t window_length, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory) {
+    return at::_ops::blackman_window::call(window_length, dtype, layout, device, pin_memory);
+}
+
+// aten::blackman_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
+inline at::Tensor blackman_window(int64_t window_length, bool periodic, at::TensorOptions options={}) {
+    return at::_ops::blackman_window_periodic::call(window_length, periodic, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
+}
+// aten::blackman_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
+inline at::Tensor blackman_window(int64_t window_length, bool periodic, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory) {
+    return at::_ops::blackman_window_periodic::call(window_length, periodic, dtype, layout, device, pin_memory);
+}
+
+// aten::blackman_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & blackman_window_out(at::Tensor & out, int64_t window_length) {
+    return at::_ops::blackman_window_out::call(window_length, out);
+}
+// aten::blackman_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & blackman_window_outf(int64_t window_length, at::Tensor & out) {
+    return at::_ops::blackman_window_out::call(window_length, out);
+}
+
+// aten::blackman_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & blackman_window_out(at::Tensor & out, int64_t window_length, bool periodic) {
+    return at::_ops::blackman_window_periodic_out::call(window_length, periodic, out);
+}
+// aten::blackman_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & blackman_window_outf(int64_t window_length, bool periodic, at::Tensor & out) {
+    return at::_ops::blackman_window_periodic_out::call(window_length, periodic, out);
+}
+
+}

shared/package-files/2e/2e8ddec2c108827f8b40160d9e2efdc3be2ee4b4afbee5581747ba822100ad08/blob

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from collections import deque
+from functools import wraps
+from typing import Any, Callable, Dict, Generic, Hashable, Tuple, TypeVar, cast
+
+__all__ = [
+    "SimpleCache",
+    "FastDictCache",
+    "memoized",
+]
+
+_T = TypeVar("_T", bound=Hashable)
+_U = TypeVar("_U")
+
+
+class SimpleCache(Generic[_T, _U]):
+    """
+    Very simple cache that discards the oldest item when the cache size is
+    exceeded.
+
+    :param maxsize: Maximum size of the cache. (Don't make it too big.)
+    """
+
+    def __init__(self, maxsize: int = 8) -> None:
+        assert maxsize > 0
+
+        self._data: dict[_T, _U] = {}
+        self._keys: deque[_T] = deque()
+        self.maxsize: int = maxsize
+
+    def get(self, key: _T, getter_func: Callable[[], _U]) -> _U:
+        """
+        Get object from the cache.
+        If not found, call `getter_func` to resolve it, and put that on the top
+        of the cache instead.
+        """
+        # Look in cache first.
+        try:
+            return self._data[key]
+        except KeyError:
+            # Not found? Get it.
+            value = getter_func()
+            self._data[key] = value
+            self._keys.append(key)
+
+            # Remove the oldest key when the size is exceeded.
+            if len(self._data) > self.maxsize:
+                key_to_remove = self._keys.popleft()
+                if key_to_remove in self._data:
+                    del self._data[key_to_remove]
+
+            return value
+
+    def clear(self) -> None:
+        "Clear cache."
+        self._data = {}
+        self._keys = deque()
+
+
+_K = TypeVar("_K", bound=Tuple[Hashable, ...])
+_V = TypeVar("_V")
+
+
+class FastDictCache(Dict[_K, _V]):
+    """
+    Fast, lightweight cache which keeps at most `size` items.
+    It will discard the oldest items in the cache first.
+
+    The cache is a dictionary, which doesn't keep track of access counts.
+    It is perfect to cache little immutable objects which are not expensive to
+    create, but where a dictionary lookup is still much faster than an object
+    instantiation.
+
+    :param get_value: Callable that's called in case of a missing key.
+    """
+
+    # NOTE: This cache is used to cache `prompt_toolkit.layout.screen.Char` and
+    #       `prompt_toolkit.Document`. Make sure to keep this really lightweight.
+    #       Accessing the cache should stay faster than instantiating new
+    #       objects.
+    #       (Dictionary lookups are really fast.)
+    #       SimpleCache is still required for cases where the cache key is not
+    #       the same as the arguments given to the function that creates the
+    #       value.)
+    def __init__(self, get_value: Callable[..., _V], size: int = 1000000) -> None:
+        assert size > 0
+
+        self._keys: deque[_K] = deque()
+        self.get_value = get_value
+        self.size = size
+
+    def __missing__(self, key: _K) -> _V:
+        # Remove the oldest key when the size is exceeded.
+        if len(self) > self.size:
+            key_to_remove = self._keys.popleft()
+            if key_to_remove in self:
+                del self[key_to_remove]
+
+        result = self.get_value(*key)
+        self[key] = result
+        self._keys.append(key)
+        return result
+
+
+_F = TypeVar("_F", bound=Callable[..., object])
+
+
+def memoized(maxsize: int = 1024) -> Callable[[_F], _F]:
+    """
+    Memoization decorator for immutable classes and pure functions.
+    """
+
+    def decorator(obj: _F) -> _F:
+        cache: SimpleCache[Hashable, Any] = SimpleCache(maxsize=maxsize)
+
+        @wraps(obj)
+        def new_callable(*a: Any, **kw: Any) -> Any:
+            def create_new() -> Any:
+                return obj(*a, **kw)
+
+            key = (a, tuple(sorted(kw.items())))
+            return cache.get(key, create_new)
+
+        return cast(_F, new_callable)
+
+    return decorator

shared/package-files/2e/2e8f346967d8aefa3f5bf5314c8b264258a54402618c9e0cb5852018dad8bc68/blob

@@ -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 cuda {
+
+TORCH_API at::Tensor _nested_tensor_from_mask(const at::Tensor & t, const at::Tensor & mask, bool mask_check=true);
+
+} // namespace cuda
+} // namespace at

shared/package-files/2e/2e93737d50bd68e6fba65dcc677e569a85d58f5a9d26ddb307756f823f6f3ad3/blob

@@ -0,0 +1,25 @@
+#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/hardsigmoid_meta.h>
+
+namespace at {
+namespace native {
+struct TORCH_API structured_hardsigmoid_out : public at::meta::structured_hardsigmoid {
+void impl(const at::Tensor & self, const at::Tensor & out);
+};
+TORCH_API at::Tensor hardsigmoid_quantized_cpu(const at::Tensor & self);
+TORCH_API at::Tensor & hardsigmoid_out_quantized_cpu(const at::Tensor & self, at::Tensor & out);
+} // namespace native
+} // namespace at

shared/package-files/2e/2e94bf106f33025763f512d208285c441f2344c344d4c3f3a67ba778d0589f51/blob

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e94bf106f33025763f512d208285c441f2344c344d4c3f3a67ba778d0589f51
+size 695056

shared/package-files/2e/2e9b428e5ad448f442fdcea301508c046ad8062b56a8b2b560837481ecec51ce/blob

@@ -0,0 +1,11 @@
+from packaging.version import Version, parse
+
+try:
+    import matplotlib as mpl
+
+    version = parse(mpl.__version__)
+    MPL_LT_310 = version < Version("3.9.99")
+except ImportError:
+    MPL_LT_310 = False
+
+__all__ = ["MPL_LT_310"]

shared/package-files/2e/2e9b54587398ac57cd835fbc70d10cc43a10cc2743b60ba286056819bd100bd3/blob

@@ -0,0 +1,652 @@
+from sympy.core import (
+    Basic, Rational, Symbol, S, Float, Integer, Mul, Number, Pow,
+    Expr, I, nan, pi, symbols, oo, zoo, N)
+from sympy.core.parameters import global_parameters
+from sympy.core.tests.test_evalf import NS
+from sympy.core.function import expand_multinomial
+from sympy.functions.elementary.miscellaneous import sqrt, cbrt
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.special.error_functions import erf
+from sympy.functions.elementary.trigonometric import (
+    sin, cos, tan, sec, csc, atan)
+from sympy.functions.elementary.hyperbolic import cosh, sinh, tanh
+from sympy.polys import Poly
+from sympy.series.order import O
+from sympy.sets import FiniteSet
+from sympy.core.power import power, integer_nthroot
+from sympy.testing.pytest import warns, _both_exp_pow
+from sympy.utilities.exceptions import SymPyDeprecationWarning
+from sympy.abc import a, b, c, x, y
+
+def test_rational():
+    a = Rational(1, 5)
+
+    r = sqrt(5)/5
+    assert sqrt(a) == r
+    assert 2*sqrt(a) == 2*r
+
+    r = a*a**S.Half
+    assert a**Rational(3, 2) == r
+    assert 2*a**Rational(3, 2) == 2*r
+
+    r = a**5*a**Rational(2, 3)
+    assert a**Rational(17, 3) == r
+    assert 2 * a**Rational(17, 3) == 2*r
+
+
+def test_large_rational():
+    e = (Rational(123712**12 - 1, 7) + Rational(1, 7))**Rational(1, 3)
+    assert e == 234232585392159195136 * (Rational(1, 7)**Rational(1, 3))
+
+
+def test_negative_real():
+    def feq(a, b):
+        return abs(a - b) < 1E-10
+
+    assert feq(S.One / Float(-0.5), -Integer(2))
+
+
+def test_expand():
+    assert (2**(-1 - x)).expand() == S.Half*2**(-x)
+
+
+def test_issue_3449():
+    #test if powers are simplified correctly
+    #see also issue 3995
+    assert ((x**Rational(1, 3))**Rational(2)) == x**Rational(2, 3)
+    assert (
+        (x**Rational(3))**Rational(2, 5)) == (x**Rational(3))**Rational(2, 5)
+
+    a = Symbol('a', real=True)
+    b = Symbol('b', real=True)
+    assert (a**2)**b == (abs(a)**b)**2
+    assert sqrt(1/a) != 1/sqrt(a)  # e.g. for a = -1
+    assert (a**3)**Rational(1, 3) != a
+    assert (x**a)**b != x**(a*b)  # e.g. x = -1, a=2, b=1/2
+    assert (x**.5)**b == x**(.5*b)
+    assert (x**.5)**.5 == x**.25
+    assert (x**2.5)**.5 != x**1.25  # e.g. for x = 5*I
+
+    k = Symbol('k', integer=True)
+    m = Symbol('m', integer=True)
+    assert (x**k)**m == x**(k*m)
+    assert Number(5)**Rational(2, 3) == Number(25)**Rational(1, 3)
+
+    assert (x**.5)**2 == x**1.0
+    assert (x**2)**k == (x**k)**2 == x**(2*k)
+
+    a = Symbol('a', positive=True)
+    assert (a**3)**Rational(2, 5) == a**Rational(6, 5)
+    assert (a**2)**b == (a**b)**2
+    assert (a**Rational(2, 3))**x == a**(x*Rational(2, 3)) != (a**x)**Rational(2, 3)
+
+
+def test_issue_3866():
+    assert --sqrt(sqrt(5) - 1) == sqrt(sqrt(5) - 1)
+
+
+def test_negative_one():
+    x = Symbol('x', complex=True)
+    y = Symbol('y', complex=True)
+    assert 1/x**y == x**(-y)
+
+
+def test_issue_4362():
+    neg = Symbol('neg', negative=True)
+    nonneg = Symbol('nonneg', nonnegative=True)
+    any = Symbol('any')
+    num, den = sqrt(1/neg).as_numer_denom()
+    assert num == sqrt(-1)
+    assert den == sqrt(-neg)
+    num, den = sqrt(1/nonneg).as_numer_denom()
+    assert num == 1
+    assert den == sqrt(nonneg)
+    num, den = sqrt(1/any).as_numer_denom()
+    assert num == sqrt(1/any)
+    assert den == 1
+
+    def eqn(num, den, pow):
+        return (num/den)**pow
+    npos = 1
+    nneg = -1
+    dpos = 2 - sqrt(3)
+    dneg = 1 - sqrt(3)
+    assert dpos > 0 and dneg < 0 and npos > 0 and nneg < 0
+    # pos or neg integer
+    eq = eqn(npos, dpos, 2)
+    assert eq.is_Pow and eq.as_numer_denom() == (1, dpos**2)
+    eq = eqn(npos, dneg, 2)
+    assert eq.is_Pow and eq.as_numer_denom() == (1, dneg**2)
+    eq = eqn(nneg, dpos, 2)
+    assert eq.is_Pow and eq.as_numer_denom() == (1, dpos**2)
+    eq = eqn(nneg, dneg, 2)
+    assert eq.is_Pow and eq.as_numer_denom() == (1, dneg**2)
+    eq = eqn(npos, dpos, -2)
+    assert eq.is_Pow and eq.as_numer_denom() == (dpos**2, 1)
+    eq = eqn(npos, dneg, -2)
+    assert eq.is_Pow and eq.as_numer_denom() == (dneg**2, 1)
+    eq = eqn(nneg, dpos, -2)
+    assert eq.is_Pow and eq.as_numer_denom() == (dpos**2, 1)
+    eq = eqn(nneg, dneg, -2)
+    assert eq.is_Pow and eq.as_numer_denom() == (dneg**2, 1)
+    # pos or neg rational
+    pow = S.Half
+    eq = eqn(npos, dpos, pow)
+    assert eq.is_Pow and eq.as_numer_denom() == (npos**pow, dpos**pow)
+    eq = eqn(npos, dneg, pow)
+    assert eq.is_Pow is False and eq.as_numer_denom() == ((-npos)**pow, (-dneg)**pow)
+    eq = eqn(nneg, dpos, pow)
+    assert not eq.is_Pow or eq.as_numer_denom() == (nneg**pow, dpos**pow)
+    eq = eqn(nneg, dneg, pow)
+    assert eq.is_Pow and eq.as_numer_denom() == ((-nneg)**pow, (-dneg)**pow)
+    eq = eqn(npos, dpos, -pow)
+    assert eq.is_Pow and eq.as_numer_denom() == (dpos**pow, npos**pow)
+    eq = eqn(npos, dneg, -pow)
+    assert eq.is_Pow is False and eq.as_numer_denom() == (-(-npos)**pow*(-dneg)**pow, npos)
+    eq = eqn(nneg, dpos, -pow)
+    assert not eq.is_Pow or eq.as_numer_denom() == (dpos**pow, nneg**pow)
+    eq = eqn(nneg, dneg, -pow)
+    assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-nneg)**pow)
+    # unknown exponent
+    pow = 2*any
+    eq = eqn(npos, dpos, pow)
+    assert eq.is_Pow and eq.as_numer_denom() == (npos**pow, dpos**pow)
+    eq = eqn(npos, dneg, pow)
+    assert eq.is_Pow and eq.as_numer_denom() == ((-npos)**pow, (-dneg)**pow)
+    eq = eqn(nneg, dpos, pow)
+    assert eq.is_Pow and eq.as_numer_denom() == (nneg**pow, dpos**pow)
+    eq = eqn(nneg, dneg, pow)
+    assert eq.is_Pow and eq.as_numer_denom() == ((-nneg)**pow, (-dneg)**pow)
+    eq = eqn(npos, dpos, -pow)
+    assert eq.as_numer_denom() == (dpos**pow, npos**pow)
+    eq = eqn(npos, dneg, -pow)
+    assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-npos)**pow)
+    eq = eqn(nneg, dpos, -pow)
+    assert eq.is_Pow and eq.as_numer_denom() == (dpos**pow, nneg**pow)
+    eq = eqn(nneg, dneg, -pow)
+    assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-nneg)**pow)
+
+    assert ((1/(1 + x/3))**(-S.One)).as_numer_denom() == (3 + x, 3)
+    notp = Symbol('notp', positive=False)  # not positive does not imply real
+    b = ((1 + x/notp)**-2)
+    assert (b**(-y)).as_numer_denom() == (1, b**y)
+    assert (b**(-S.One)).as_numer_denom() == ((notp + x)**2, notp**2)
+    nonp = Symbol('nonp', nonpositive=True)
+    assert (((1 + x/nonp)**-2)**(-S.One)).as_numer_denom() == ((-nonp -
+            x)**2, nonp**2)
+
+    n = Symbol('n', negative=True)
+    assert (x**n).as_numer_denom() == (1, x**-n)
+    assert sqrt(1/n).as_numer_denom() == (S.ImaginaryUnit, sqrt(-n))
+    n = Symbol('0 or neg', nonpositive=True)
+    # if x and n are split up without negating each term and n is negative
+    # then the answer might be wrong; if n is 0 it won't matter since
+    # 1/oo and 1/zoo are both zero as is sqrt(0)/sqrt(-x) unless x is also
+    # zero (in which case the negative sign doesn't matter):
+    # 1/sqrt(1/-1) = -I but sqrt(-1)/sqrt(1) = I
+    assert (1/sqrt(x/n)).as_numer_denom() == (sqrt(-n), sqrt(-x))
+    c = Symbol('c', complex=True)
+    e = sqrt(1/c)
+    assert e.as_numer_denom() == (e, 1)
+    i = Symbol('i', integer=True)
+    assert ((1 + x/y)**i).as_numer_denom() == ((x + y)**i, y**i)
+
+
+def test_Pow_Expr_args():
+    bases = [Basic(), Poly(x, x), FiniteSet(x)]
+    for base in bases:
+        # The cache can mess with the stacklevel test
+        with warns(SymPyDeprecationWarning, test_stacklevel=False):
+            Pow(base, S.One)
+
+
+def test_Pow_signs():
+    """Cf. issues 4595 and 5250"""
+    n = Symbol('n', even=True)
+    assert (3 - y)**2 != (y - 3)**2
+    assert (3 - y)**n != (y - 3)**n
+    assert (-3 + y - x)**2 != (3 - y + x)**2
+    assert (y - 3)**3 != -(3 - y)**3
+
+
+def test_power_with_noncommutative_mul_as_base():
+    x = Symbol('x', commutative=False)
+    y = Symbol('y', commutative=False)
+    assert not (x*y)**3 == x**3*y**3
+    assert (2*x*y)**3 == 8*(x*y)**3
+
+
+@_both_exp_pow
+def test_power_rewrite_exp():
+    assert (I**I).rewrite(exp) == exp(-pi/2)
+
+    expr = (2 + 3*I)**(4 + 5*I)
+    assert expr.rewrite(exp) == exp((4 + 5*I)*(log(sqrt(13)) + I*atan(Rational(3, 2))))
+    assert expr.rewrite(exp).expand() == \
+        169*exp(5*I*log(13)/2)*exp(4*I*atan(Rational(3, 2)))*exp(-5*atan(Rational(3, 2)))
+
+    assert ((6 + 7*I)**5).rewrite(exp) == 7225*sqrt(85)*exp(5*I*atan(Rational(7, 6)))
+
+    expr = 5**(6 + 7*I)
+    assert expr.rewrite(exp) == exp((6 + 7*I)*log(5))
+    assert expr.rewrite(exp).expand() == 15625*exp(7*I*log(5))
+
+    assert Pow(123, 789, evaluate=False).rewrite(exp) == 123**789
+    assert (1**I).rewrite(exp) == 1**I
+    assert (0**I).rewrite(exp) == 0**I
+
+    expr = (-2)**(2 + 5*I)
+    assert expr.rewrite(exp) == exp((2 + 5*I)*(log(2) + I*pi))
+    assert expr.rewrite(exp).expand() == 4*exp(-5*pi)*exp(5*I*log(2))
+
+    assert ((-2)**S(-5)).rewrite(exp) == (-2)**S(-5)
+
+    x, y = symbols('x y')
+    assert (x**y).rewrite(exp) == exp(y*log(x))
+    if global_parameters.exp_is_pow:
+        assert (7**x).rewrite(exp) == Pow(S.Exp1, x*log(7), evaluate=False)
+    else:
+        assert (7**x).rewrite(exp) == exp(x*log(7), evaluate=False)
+    assert ((2 + 3*I)**x).rewrite(exp) == exp(x*(log(sqrt(13)) + I*atan(Rational(3, 2))))
+    assert (y**(5 + 6*I)).rewrite(exp) == exp(log(y)*(5 + 6*I))
+
+    assert all((1/func(x)).rewrite(exp) == 1/(func(x).rewrite(exp)) for func in
+                    (sin, cos, tan, sec, csc, sinh, cosh, tanh))
+
+
+def test_zero():
+    assert 0**x != 0
+    assert 0**(2*x) == 0**x
+    assert 0**(1.0*x) == 0**x
+    assert 0**(2.0*x) == 0**x
+    assert (0**(2 - x)).as_base_exp() == (0, 2 - x)
+    assert 0**(x - 2) != S.Infinity**(2 - x)
+    assert 0**(2*x*y) == 0**(x*y)
+    assert 0**(-2*x*y) == S.ComplexInfinity**(x*y)
+    assert Float(0)**2 is not S.Zero
+    assert Float(0)**2 == 0.0
+    assert Float(0)**-2 is zoo
+    assert Float(0)**oo is S.Zero
+
+    #Test issue 19572
+    assert 0 ** -oo is zoo
+    assert power(0, -oo) is zoo
+    assert Float(0)**-oo is zoo
+
+def test_pow_as_base_exp():
+    assert (S.Infinity**(2 - x)).as_base_exp() == (S.Infinity, 2 - x)
+    assert (S.Infinity**(x - 2)).as_base_exp() == (S.Infinity, x - 2)
+    p = S.Half**x
+    assert p.base, p.exp == p.as_base_exp() == (S(2), -x)
+    p = (S(3)/2)**x
+    assert p.base, p.exp == p.as_base_exp() == (3*S.Half, x)
+    p = (S(2)/3)**x
+    assert p.as_base_exp() == (S(3)/2, -x)
+    assert p.base, p.exp == (S(2)/3, x)
+    # issue 8344:
+    assert Pow(1, 2, evaluate=False).as_base_exp() == (S.One, S(2))
+
+
+def test_nseries():
+    assert sqrt(I*x - 1)._eval_nseries(x, 4, None, 1) == I + x/2 + I*x**2/8 - x**3/16 + O(x**4)
+    assert sqrt(I*x - 1)._eval_nseries(x, 4, None, -1) == -I - x/2 - I*x**2/8 + x**3/16 + O(x**4)
+    assert cbrt(I*x - 1)._eval_nseries(x, 4, None, 1) == (-1)**(S(1)/3) - (-1)**(S(5)/6)*x/3 + \
+    (-1)**(S(1)/3)*x**2/9 + 5*(-1)**(S(5)/6)*x**3/81 + O(x**4)
+    assert cbrt(I*x - 1)._eval_nseries(x, 4, None, -1) == -(-1)**(S(2)/3) - (-1)**(S(1)/6)*x/3 - \
+    (-1)**(S(2)/3)*x**2/9 + 5*(-1)**(S(1)/6)*x**3/81 + O(x**4)
+    assert (1 / (exp(-1/x) + 1/x))._eval_nseries(x, 2, None) == x + O(x**2)
+    # test issue 23752
+    assert sqrt(-I*x**2 + x - 3)._eval_nseries(x, 4, None, 1) == -sqrt(3)*I + sqrt(3)*I*x/6 - \
+    sqrt(3)*I*x**2*(-S(1)/72 + I/6) - sqrt(3)*I*x**3*(-S(1)/432 + I/36) + O(x**4)
+    assert sqrt(-I*x**2 + x - 3)._eval_nseries(x, 4, None, -1) == -sqrt(3)*I + sqrt(3)*I*x/6 - \
+    sqrt(3)*I*x**2*(-S(1)/72 + I/6) - sqrt(3)*I*x**3*(-S(1)/432 + I/36) + O(x**4)
+    assert cbrt(-I*x**2 + x - 3)._eval_nseries(x, 4, None, 1) == -(-1)**(S(2)/3)*3**(S(1)/3) + \
+    (-1)**(S(2)/3)*3**(S(1)/3)*x/9 - (-1)**(S(2)/3)*3**(S(1)/3)*x**2*(-S(1)/81 + I/9) - \
+    (-1)**(S(2)/3)*3**(S(1)/3)*x**3*(-S(5)/2187 + 2*I/81) + O(x**4)
+    assert cbrt(-I*x**2 + x - 3)._eval_nseries(x, 4, None, -1) == -(-1)**(S(2)/3)*3**(S(1)/3) + \
+    (-1)**(S(2)/3)*3**(S(1)/3)*x/9 - (-1)**(S(2)/3)*3**(S(1)/3)*x**2*(-S(1)/81 + I/9) - \
+    (-1)**(S(2)/3)*3**(S(1)/3)*x**3*(-S(5)/2187 + 2*I/81) + O(x**4)
+
+
+def test_issue_6100_12942_4473():
+    assert x**1.0 != x
+    assert x != x**1.0
+    assert True != x**1.0
+    assert x**1.0 is not True
+    assert x is not True
+    assert x*y != (x*y)**1.0
+    # Pow != Symbol
+    assert (x**1.0)**1.0 != x
+    assert (x**1.0)**2.0 != x**2
+    b = Expr()
+    assert Pow(b, 1.0, evaluate=False) != b
+    # if the following gets distributed as a Mul (x**1.0*y**1.0 then
+    # __eq__ methods could be added to Symbol and Pow to detect the
+    # power-of-1.0 case.
+    assert ((x*y)**1.0).func is Pow
+
+
+def test_issue_6208():
+    from sympy.functions.elementary.miscellaneous import root
+    assert sqrt(33**(I*9/10)) == -33**(I*9/20)
+    assert root((6*I)**(2*I), 3).as_base_exp()[1] == Rational(1, 3)  # != 2*I/3
+    assert root((6*I)**(I/3), 3).as_base_exp()[1] == I/9
+    assert sqrt(exp(3*I)) == exp(3*I/2)
+    assert sqrt(-sqrt(3)*(1 + 2*I)) == sqrt(sqrt(3))*sqrt(-1 - 2*I)
+    assert sqrt(exp(5*I)) == -exp(5*I/2)
+    assert root(exp(5*I), 3).exp == Rational(1, 3)
+
+
+def test_issue_6990():
+    assert (sqrt(a + b*x + x**2)).series(x, 0, 3).removeO() == \
+        sqrt(a)*x**2*(1/(2*a) - b**2/(8*a**2)) + sqrt(a) + b*x/(2*sqrt(a))
+
+
+def test_issue_6068():
+    assert sqrt(sin(x)).series(x, 0, 7) == \
+        sqrt(x) - x**Rational(5, 2)/12 + x**Rational(9, 2)/1440 - \
+        x**Rational(13, 2)/24192 + O(x**7)
+    assert sqrt(sin(x)).series(x, 0, 9) == \
+        sqrt(x) - x**Rational(5, 2)/12 + x**Rational(9, 2)/1440 - \
+        x**Rational(13, 2)/24192 - 67*x**Rational(17, 2)/29030400 + O(x**9)
+    assert sqrt(sin(x**3)).series(x, 0, 19) == \
+        x**Rational(3, 2) - x**Rational(15, 2)/12 + x**Rational(27, 2)/1440 + O(x**19)
+    assert sqrt(sin(x**3)).series(x, 0, 20) == \
+        x**Rational(3, 2) - x**Rational(15, 2)/12 + x**Rational(27, 2)/1440 - \
+        x**Rational(39, 2)/24192 + O(x**20)
+
+
+def test_issue_6782():
+    assert sqrt(sin(x**3)).series(x, 0, 7) == x**Rational(3, 2) + O(x**7)
+    assert sqrt(sin(x**4)).series(x, 0, 3) == x**2 + O(x**3)
+
+
+def test_issue_6653():
+    assert (1 / sqrt(1 + sin(x**2))).series(x, 0, 3) == 1 - x**2/2 + O(x**3)
+
+
+def test_issue_6429():
+    f = (c**2 + x)**(0.5)
+    assert f.series(x, x0=0, n=1) == (c**2)**0.5 + O(x)
+    assert f.taylor_term(0, x) == (c**2)**0.5
+    assert f.taylor_term(1, x) == 0.5*x*(c**2)**(-0.5)
+    assert f.taylor_term(2, x) == -0.125*x**2*(c**2)**(-1.5)
+
+
+def test_issue_7638():
+    f = pi/log(sqrt(2))
+    assert ((1 + I)**(I*f/2))**0.3 == (1 + I)**(0.15*I*f)
+    # if 1/3 -> 1.0/3 this should fail since it cannot be shown that the
+    # sign will be +/-1; for the previous "small arg" case, it didn't matter
+    # that this could not be proved
+    assert (1 + I)**(4*I*f) == ((1 + I)**(12*I*f))**Rational(1, 3)
+
+    assert (((1 + I)**(I*(1 + 7*f)))**Rational(1, 3)).exp == Rational(1, 3)
+    r = symbols('r', real=True)
+    assert sqrt(r**2) == abs(r)
+    assert cbrt(r**3) != r
+    assert sqrt(Pow(2*I, 5*S.Half)) != (2*I)**Rational(5, 4)
+    p = symbols('p', positive=True)
+    assert cbrt(p**2) == p**Rational(2, 3)
+    assert NS(((0.2 + 0.7*I)**(0.7 + 1.0*I))**(0.5 - 0.1*I), 1) == '0.4 + 0.2*I'
+    assert sqrt(1/(1 + I)) == sqrt(1 - I)/sqrt(2)  # or 1/sqrt(1 + I)
+    e = 1/(1 - sqrt(2))
+    assert sqrt(e) == I/sqrt(-1 + sqrt(2))
+    assert e**Rational(-1, 2) == -I*sqrt(-1 + sqrt(2))
+    assert sqrt((cos(1)**2 + sin(1)**2 - 1)**(3 + I)).exp in [S.Half,
+                                                              Rational(3, 2) + I/2]
+    assert sqrt(r**Rational(4, 3)) != r**Rational(2, 3)
+    assert sqrt((p + I)**Rational(4, 3)) == (p + I)**Rational(2, 3)
+
+    for q in 1+I, 1-I:
+        assert sqrt(q**2) == q
+    for q in -1+I, -1-I:
+        assert sqrt(q**2) == -q
+
+    assert sqrt((p + r*I)**2) != p + r*I
+    e = (1 + I/5)
+    assert sqrt(e**5) == e**(5*S.Half)
+    assert sqrt(e**6) == e**3
+    assert sqrt((1 + I*r)**6) != (1 + I*r)**3
+
+
+def test_issue_8582():
+    assert 1**oo is nan
+    assert 1**(-oo) is nan
+    assert 1**zoo is nan
+    assert 1**(oo + I) is nan
+    assert 1**(1 + I*oo) is nan
+    assert 1**(oo + I*oo) is nan
+
+
+def test_issue_8650():
+    n = Symbol('n', integer=True, nonnegative=True)
+    assert (n**n).is_positive is True
+    x = 5*n + 5
+    assert (x**(5*(n + 1))).is_positive is True
+
+
+def test_issue_13914():
+    b = Symbol('b')
+    assert (-1)**zoo is nan
+    assert 2**zoo is nan
+    assert (S.Half)**(1 + zoo) is nan
+    assert I**(zoo + I) is nan
+    assert b**(I + zoo) is nan
+
+
+def test_better_sqrt():
+    n = Symbol('n', integer=True, nonnegative=True)
+    assert sqrt(3 + 4*I) == 2 + I
+    assert sqrt(3 - 4*I) == 2 - I
+    assert sqrt(-3 - 4*I) == 1 - 2*I
+    assert sqrt(-3 + 4*I) == 1 + 2*I
+    assert sqrt(32 + 24*I) == 6 + 2*I
+    assert sqrt(32 - 24*I) == 6 - 2*I
+    assert sqrt(-32 - 24*I) == 2 - 6*I
+    assert sqrt(-32 + 24*I) == 2 + 6*I
+
+    # triple (3, 4, 5):
+    # parity of 3 matches parity of 5 and
+    # den, 4, is a square
+    assert sqrt((3 + 4*I)/4) == 1 + I/2
+    # triple (8, 15, 17)
+    # parity of 8 doesn't match parity of 17 but
+    # den/2, 8/2, is a square
+    assert sqrt((8 + 15*I)/8) == (5 + 3*I)/4
+    # handle the denominator
+    assert sqrt((3 - 4*I)/25) == (2 - I)/5
+    assert sqrt((3 - 4*I)/26) == (2 - I)/sqrt(26)
+    # mul
+    #  issue #12739
+    assert sqrt((3 + 4*I)/(3 - 4*I)) == (3 + 4*I)/5
+    assert sqrt(2/(3 + 4*I)) == sqrt(2)/5*(2 - I)
+    assert sqrt(n/(3 + 4*I)).subs(n, 2) == sqrt(2)/5*(2 - I)
+    assert sqrt(-2/(3 + 4*I)) == sqrt(2)/5*(1 + 2*I)
+    assert sqrt(-n/(3 + 4*I)).subs(n, 2) == sqrt(2)/5*(1 + 2*I)
+    # power
+    assert sqrt(1/(3 + I*4)) == (2 - I)/5
+    assert sqrt(1/(3 - I)) == sqrt(10)*sqrt(3 + I)/10
+    # symbolic
+    i = symbols('i', imaginary=True)
+    assert sqrt(3/i) == Mul(sqrt(3), 1/sqrt(i), evaluate=False)
+    # multiples of 1/2; don't make this too automatic
+    assert sqrt(3 + 4*I)**3 == (2 + I)**3
+    assert Pow(3 + 4*I, Rational(3, 2)) == 2 + 11*I
+    assert Pow(6 + 8*I, Rational(3, 2)) == 2*sqrt(2)*(2 + 11*I)
+    n, d = (3 + 4*I), (3 - 4*I)**3
+    a = n/d
+    assert a.args == (1/d, n)
+    eq = sqrt(a)
+    assert eq.args == (a, S.Half)
+    assert expand_multinomial(eq) == sqrt((-117 + 44*I)*(3 + 4*I))/125
+    assert eq.expand() == (7 - 24*I)/125
+
+    # issue 12775
+    # pos im part
+    assert sqrt(2*I) == (1 + I)
+    assert sqrt(2*9*I) == Mul(3, 1 + I, evaluate=False)
+    assert Pow(2*I, 3*S.Half) == (1 + I)**3
+    # neg im part
+    assert sqrt(-I/2) == Mul(S.Half, 1 - I, evaluate=False)
+    # fractional im part
+    assert Pow(Rational(-9, 2)*I, Rational(3, 2)) == 27*(1 - I)**3/8
+
+
+def test_issue_2993():
+    assert str((2.3*x - 4)**0.3) == '1.5157165665104*(0.575*x - 1)**0.3'
+    assert str((2.3*x + 4)**0.3) == '1.5157165665104*(0.575*x + 1)**0.3'
+    assert str((-2.3*x + 4)**0.3) == '1.5157165665104*(1 - 0.575*x)**0.3'
+    assert str((-2.3*x - 4)**0.3) == '1.5157165665104*(-0.575*x - 1)**0.3'
+    assert str((2.3*x - 2)**0.3) == '1.28386201800527*(x - 0.869565217391304)**0.3'
+    assert str((-2.3*x - 2)**0.3) == '1.28386201800527*(-x - 0.869565217391304)**0.3'
+    assert str((-2.3*x + 2)**0.3) == '1.28386201800527*(0.869565217391304 - x)**0.3'
+    assert str((2.3*x + 2)**0.3) == '1.28386201800527*(x + 0.869565217391304)**0.3'
+    assert str((2.3*x - 4)**Rational(1, 3)) == '2**(2/3)*(0.575*x - 1)**(1/3)'
+    eq = (2.3*x + 4)
+    assert eq**2 == 16*(0.575*x + 1)**2
+    assert (1/eq).args == (eq, -1)  # don't change trivial power
+    # issue 17735
+    q=.5*exp(x) - .5*exp(-x) + 0.1
+    assert int((q**2).subs(x, 1)) == 1
+    # issue 17756
+    y = Symbol('y')
+    assert len(sqrt(x/(x + y)**2 + Float('0.008', 30)).subs(y, pi.n(25)).atoms(Float)) == 2
+    # issue 17756
+    a, b, c, d, e, f, g = symbols('a:g')
+    expr = sqrt(1 + a*(c**4 + g*d - 2*g*e - f*(-g + d))**2/
+        (c**3*b**2*(d - 3*e + 2*f)**2))/2
+    r = [
+    (a, N('0.0170992456333788667034850458615', 30)),
+    (b, N('0.0966594956075474769169134801223', 30)),
+    (c, N('0.390911862903463913632151616184', 30)),
+    (d, N('0.152812084558656566271750185933', 30)),
+    (e, N('0.137562344465103337106561623432', 30)),
+    (f, N('0.174259178881496659302933610355', 30)),
+    (g, N('0.220745448491223779615401870086', 30))]
+    tru = expr.n(30, subs=dict(r))
+    seq = expr.subs(r)
+    # although `tru` is the right way to evaluate
+    # expr with numerical values, `seq` will have
+    # significant loss of precision if extraction of
+    # the largest coefficient of a power's base's terms
+    # is done improperly
+    assert seq == tru
+
+def test_issue_17450():
+    assert (erf(cosh(1)**7)**I).is_real is None
+    assert (erf(cosh(1)**7)**I).is_imaginary is False
+    assert (Pow(exp(1+sqrt(2)), ((1-sqrt(2))*I*pi), evaluate=False)).is_real is None
+    assert ((-10)**(10*I*pi/3)).is_real is False
+    assert ((-5)**(4*I*pi)).is_real is False
+
+
+def test_issue_18190():
+    assert sqrt(1 / tan(1 + I)) == 1 / sqrt(tan(1 + I))
+
+
+def test_issue_14815():
+    x = Symbol('x', real=True)
+    assert sqrt(x).is_extended_negative is False
+    x = Symbol('x', real=False)
+    assert sqrt(x).is_extended_negative is None
+    x = Symbol('x', complex=True)
+    assert sqrt(x).is_extended_negative is False
+    x = Symbol('x', extended_real=True)
+    assert sqrt(x).is_extended_negative is False
+    assert sqrt(zoo, evaluate=False).is_extended_negative is None
+    assert sqrt(nan, evaluate=False).is_extended_negative is None
+
+
+def test_issue_18509():
+    x = Symbol('x', prime=True)
+    assert x**oo is oo
+    assert (1/x)**oo is S.Zero
+    assert (-1/x)**oo is S.Zero
+    assert (-x)**oo is zoo
+    assert (-oo)**(-1 + I) is S.Zero
+    assert (-oo)**(1 + I) is zoo
+    assert (oo)**(-1 + I) is S.Zero
+    assert (oo)**(1 + I) is zoo
+
+
+def test_issue_18762():
+    e, p = symbols('e p')
+    g0 = sqrt(1 + e**2 - 2*e*cos(p))
+    assert len(g0.series(e, 1, 3).args) == 4
+
+
+def test_issue_21860():
+    e = 3*2**Rational(66666666667,200000000000)*3**Rational(16666666667,50000000000)*x**Rational(66666666667, 200000000000)
+    ans = Mul(Rational(3, 2),
+              Pow(Integer(2), Rational(33333333333, 100000000000)),
+              Pow(Integer(3), Rational(26666666667, 40000000000)))
+    assert e.xreplace({x: Rational(3,8)}) == ans
+
+
+def test_issue_21647():
+    e = log((Integer(567)/500)**(811*(Integer(567)/500)**x/100))
+    ans = log(Mul(Rational(64701150190720499096094005280169087619821081527,
+                           76293945312500000000000000000000000000000000000),
+                  Pow(Integer(2), Rational(396204892125479941, 781250000000000000)),
+                  Pow(Integer(3), Rational(385045107874520059, 390625000000000000)),
+                  Pow(Integer(5), Rational(407364676376439823, 1562500000000000000)),
+                  Pow(Integer(7), Rational(385045107874520059, 1562500000000000000))))
+    assert e.xreplace({x: 6}) == ans
+
+
+def test_issue_21762():
+    e = (x**2 + 6)**(Integer(33333333333333333)/50000000000000000)
+    ans = Mul(Rational(5, 4),
+              Pow(Integer(2), Rational(16666666666666667, 25000000000000000)),
+              Pow(Integer(5), Rational(8333333333333333, 25000000000000000)))
+    assert e.xreplace({x: S.Half}) == ans
+
+
+def test_issue_14704():
+    a = 144**144
+    x, xexact = integer_nthroot(a,a)
+    assert x == 1 and xexact is False
+
+
+def test_rational_powers_larger_than_one():
+    assert Rational(2, 3)**Rational(3, 2) == 2*sqrt(6)/9
+    assert Rational(1, 6)**Rational(9, 4) == 6**Rational(3, 4)/216
+    assert Rational(3, 7)**Rational(7, 3) == 9*3**Rational(1, 3)*7**Rational(2, 3)/343
+
+
+def test_power_dispatcher():
+
+    class NewBase(Expr):
+        pass
+    class NewPow(NewBase, Pow):
+        pass
+    a, b = Symbol('a'), NewBase()
+
+    @power.register(Expr, NewBase)
+    @power.register(NewBase, Expr)
+    @power.register(NewBase, NewBase)
+    def _(a, b):
+        return NewPow(a, b)
+
+    # Pow called as fallback
+    assert power(2, 3) == 8*S.One
+    assert power(a, 2) == Pow(a, 2)
+    assert power(a, a) == Pow(a, a)
+
+    # NewPow called by dispatch
+    assert power(a, b) == NewPow(a, b)
+    assert power(b, a) == NewPow(b, a)
+    assert power(b, b) == NewPow(b, b)
+
+
+def test_powers_of_I():
+    assert [sqrt(I)**i for i in range(13)] == [
+        1, sqrt(I), I, sqrt(I)**3, -1, -sqrt(I), -I, -sqrt(I)**3,
+        1, sqrt(I), I, sqrt(I)**3, -1]
+    assert sqrt(I)**(S(9)/2) == -I**(S(1)/4)
+
+
+def test_issue_23918():
+    b = S(2)/3
+    assert (b**x).as_base_exp() == (1/b, -x)

shared/package-files/2e/2e9d04897257e83b6fec7fe1c0a06913709a4df371b9c90ebfa3c75c9f749ed2/blob

@@ -0,0 +1,61 @@
+x,weights,x_gau_wd,x_epa_wd,x_epan2_wd,x_bi_wd,x_par_wd,x_tri_wd,x_cos_wd,x_rec_wd
+.50370319,.60467487,.27195577,.27358917,.28859682,.30192719,.31283399,.29793749,.31904846,.25210428
+.41308592,.60446553,.28380106,.28108376,.3181792,.32885763,.34548845,.32667957,.3553171,.3010559
+-1.13905,.84897398,.26095184,.24941442,.32307763,.34872245,.38725314,.34866867,.42649716,.30003257
+.66034203,.89616498,.2498343,.25886883,.24541009,.23760925,.23485521,.24529473,.23002624,.2627293
+.46479403,.58916777,.27716742,.27709199,.30071519,.31461812,.3288969,.31115181,.33274659,.27792568
+-.30933686,.92004553,.314696,.31804133,.34663542,.35808323,.38279667,.36339898,.44094594,.31994675
+-.64959307,.73271562,.29736955,.31088207,.25708713,.24806417,.2539103,.26299651,.28856418,.30887871
+.68375801,.31006212,.24646059,.25568508,.23632094,.22824775,.22264335,.23446073,.21686179,.2512418
+-.64383424,.93079,.2977045,.3114788,.25702669,.2509086,.25709325,.26391628,.29057321,.30887871
+.42128692,.31271088,.28277417,.28032663,.315695,.3267261,.34319264,.32450914,.35120708,.3010559
+1.0328139,.6187646,.19865928,.20562102,.1561914,.14491215,.14684135,.15591422,.16079396,.19385198
+-1.2904935,.95351446,.24177169,.22953008,.32501344,.38069438,.4611249,.36532316,.54515641,.23436556
+.78787175,.32106611,.23156764,.24078401,.20218871,.19425712,.17622449,.19531208,.16070512,.21671793
+1.5157072,.66341627,.13665126,.12703345,.17581124,.20039954,.25847706,.20674992,.35899704,.15119583
+-.27648715,.39563784,.3158193,.31586931,.3481959,.35810566,.38200715,.36407338,.42546061,.31994675
+-.22376217,.52433377,.31726241,.31194313,.35102832,.35601176,.37307496,.35644025,.38768768,.37555419
+1.3974312,.51672953,.15280551,.1444295,.19194916,.21056571,.22903207,.20154176,.23748733,.15119583
+1.5038735,.89413116,.13831766,.12874814,.17849067,.20256748,.25945018,.20968897,.3582845,.15119583
+-.47890497,.97143796,.30692589,.32055942,.30950537,.32610177,.33693342,.31654009,.30584078,.27657124
+-.1359496,.14135297,.31850248,.30708612,.35335067,.356503,.35032857,.34820511,.32358697,.36376222
+-.73032662,.52783029,.29259949,.30296315,.24788827,.21783998,.2070478,.23766242,.22559505,.30464283
+-.03327709,.86167095,.31776682,.30409739,.35990479,.35322891,.33260293,.35696834,.31130253,.35590704
+.28115083,.95467052,.2986962,.29242144,.33561626,.34984221,.36523791,.34821892,.38413714,.30800325
+-1.2989147,.80130654,.24054457,.228406,.3242507,.37937907,.45917069,.36459455,.5425096,.23436556
+-2.8194873,.29377041,.03423861,.03397935,.01992567,.01845811,.02368624,.02238546,.03521327,.02886914
+-.85198542,.07745348,.28499181,.28840952,.24395463,.21358347,.16033312,.21929099,.08660478,.27849863
+-1.1069518,.49668391,.26433879,.25400233,.32229855,.33312293,.35156483,.33496984,.37965384,.30003257
+-.93773148,.19808942,.27902143,.27775656,.27754821,.24108994,.1807995,.24935348,.0900434,.32253643
+-1.5377704,.325444,.19963066,.19249631,.23509243,.22351351,.20130053,.22380662,.15481808,.23739545
+.5557587,.24841208,.2647569,.26995034,.27512558,.28157636,.28811611,.27768035,.30157454,.27132668
+-2.277282,.75179027,.07828852,.07873796,.07875061,.09204377,.11446709,.0922851,.15025998,.05700553
+-.39020054,.13177808,.31133267,.32104843,.33517543,.35027672,.36907311,.34495022,.40165181,.29228903
+1.2071225,.36595759,.17694573,.17676473,.18418833,.17480444,.15023094,.17594001,.12570809,.17381817
+.17869009,.61706068,.30769076,.29939275,.34442456,.347134,.35602386,.34847054,.36011693,.36522916
+-1.0041675,.1042514,.27381383,.26920255,.29856445,.27641696,.23392586,.27843723,.19447102,.29342568
+-1.3776266,.92715643,.22828438,.21635169,.30823856,.35053859,.40838262,.34325694,.47623359,.23204453
+.49928077,.16346328,.2725563,.27403682,.28985754,.30351024,.31480322,.2993623,.32039228,.25210428
+-1.4052563,.96126524,.22366107,.21181391,.29911819,.33392962,.37877909,.32774722,.43913813,.23204453
+.16256489,.38334264,.30887154,.30012656,.34572104,.34707247,.35358542,.34768253,.3560065,.35593763
+-.06778502,.77186504,.31829891,.30559493,.35826195,.3554906,.33637638,.35551408,.305725,.34139722
+-1.2600064,.12778838,.24607265,.2333853,.32622041,.38243622,.46216935,.3612336,.54549954,.23436556
+-1.1328956,.49085611,.26161854,.25023928,.3231961,.34583442,.38073288,.34660716,.41805519,.30003257
+-2.0064812,.48090321,.11322783,.12879922,.0646241,.06034824,.05482294,.06467009,.05764425,.066758
+.30101641,.13432719,.29667228,.29063393,.33480316,.34885982,.36454689,.34424398,.38577022,.29229072
+.05911705,.72259881,.31483242,.30162583,.360174,.34909635,.33698463,.35400964,.32926111,.3572589
+1.1384692,.43570061,.18542783,.18785159,.17569715,.15617806,.14519084,.16879885,.15817458,.20996476
+-2.4006338,.0702726,.0661328,.05973222,.07546614,.08153031,.09764932,.08181684,.12409822,.06580884
+-.28085336,.91503527,.31567929,.31617356,.34821096,.35820009,.38234837,.36478543,.42807283,.31994675
+.02565318,.21581449,.31615397,.3015383,.36059293,.34980376,.33308907,.35373627,.32250968,.37892557
+-1.3860712,.52139452,.22688798,.21494935,.30566124,.34579032,.39987794,.33922414,.46560575,.23204453
+.86393679,.4338506,.22096543,.22892366,.1834737,.1740142,.15644199,.17635877,.12724629,.18408431
+.25246163,.90097287,.30146488,.29459784,.33628211,.35007398,.36442492,.34886654,.38021707,.29838197
+1.5005706,.52615659,.13878075,.12921959,.17919626,.20313531,.25952209,.20982585,.35751304,.15119583
+1.0532023,.23850945,.19607429,.20225294,.1596919,.1452661,.14646528,.15783051,.16537447,.19385198
+-2.3385949,.03208453,.07201598,.06861114,.07788137,.08815269,.11183084,.08955035,.15620679,.06580884
+-.37427851,.80847815,.31205326,.32060023,.33786515,.35297134,.37326996,.3501085,.41938363,.29228903
+-2.3599583,.56724767,.06994132,.06564237,.07736941,.08614625,.10817961,.08872598,.14898803,.06580884
+-1.1578862,.98669892,.25885895,.24676433,.32192541,.35726098,.40592428,.35127741,.45134312,.30003257
+-.55186497,.1049692,.30295427,.31836946,.28119002,.29690047,.30298875,.28439032,.29007716,.24740666
+1.5926728,.78610254,.12554701,.11550205,.15819727,.18163449,.22681772,.17941142,.29077747,.12550619

shared/package-files/2e/2ea490b3d369e66dd002ea0133404c4a452900f17d7bf3bd6fb0661f2058055f/blob

@@ -0,0 +1,318 @@
+6b27a881f2d07a8453c008e7092aac0cfe08fb8d80bc8a4f7e28516b3ece1bb2  FINALIZATION.json
+ccc350f3f818fddd8e66ecaa11850b2d16fd5fd62e3c3a84117f069f7d4eab97  README.md
+09f52a522875fdb94cbc620011af68e38234549b2fcecfc91fbc9bea7bafd7da  STATIC_CHECKS.json
+8b044597670ed62d4f353707cf5dfa7da2a159a8545e0ba3969f5cb59be8a27c  additional-elastic-tensor-diagnostic.json
+d930f63632374b852701f536bfcef561b960ba3e0e952577b38327d641896a09  additional-elasticity-predictions.jsonl
+e666556933fa11976a51462a9953238ceff6086cd8e94517d4b5ef947a232e9d  additional-elasticity-run.json
+2873596540f394f1df1390d8ab3ad5cbd0775342b0916d5ec951c403e5204503  additional-elasticity-score.json
+54e3278959c0c72e3a9a11a1c2cb9349449e9fb4a995d2c7c2b08d205c6cf9e4  additional-kappa-audit/README.md
+9b6442a20759a648111c0d70f976de018596435d334c070add045419a1ef2040  additional-kappa-audit/identity.json
+ed568b6438416cf1b4be8f0e1a2635a4bb945220a6224c5b228f08b71a41c93b  additional-kappa-audit/items/mp-12779.json
+cdba13c9ae13084197ef7982b9a66ffefd1d3219c58737bb5f34b2c3701a3e80  additional-kappa-audit/items/mp-22905.json
+784c5791ca8b8df0f07bb91061a78a2a585ca33319ba658584041fcc53728de0  additional-kappa-audit/items/mp-569346.json
+97cceaf3fe8ff0e0f4d6132284d3952628a770bea5cfd3cbecd39590121b88cb  additional-kappa-audit/items/mp-580941.json
+314b8675f76be9d5417341868c5db7fa89e4f34c08fdcecf13df09acfe7cfbec  additional-kappa-audit/run.json
+66c2524548199ce3040c7f3e076923c76dc4ec47f34d8f85d4f13c50a9a96ec8  additional-kappa-audit/score.json
+3fd700ea23e69b999ffdb5165823f37921c964a5a08e8309bd548bdf0a9d4991  additional-kappa-audit/transport-selection.json
+59194f1656bc310581cb3e1194e066c95c0f3c4bc2a1ab8c95e6019f36297f75  additional-neb-audit/README.md
+6621841b5dfe9e02071611de60df450a59687bc2110ffcb4a7cc47bc3d76cde5  additional-neb-audit/identity.json
+cbed98d6264e5cec710757044fa9c5bb533a77736c0c3234d0a6ca30924a5cbe  additional-neb-audit/items/mp-556902_3_6_1_1_0.json
+27602c68f2fadd3a22e26919f0c5b05dfe34d5840dc8bc7bfcd002c04e40edf8  additional-neb-audit/items/mp-569085_5_9_1_1_0.json
+d9927abb0bd1e501e2d7aa3b776b448ce572661dbfb98cc5a4e00df41b5ffec0  additional-neb-audit/items/mp-778397_1_3_0_0_0.json
+697a58fb95ec8e6bbefe1b000fcb098cbab1b37f662d6290e7f04b36e4096a98  additional-neb-audit/items/mp-778397_2_6_0_0_0.json
+2f5d9382231ba56dfc8afb5f42de9c071218001217e3f85ddb6fc7b7b68e6298  additional-neb-audit/run.json
+139e6850591f3d36be416f8473e431d0e8ad0dffd3abd81111e062e25703eb9b  additional-neb-audit/score.json
+3fd700ea23e69b999ffdb5165823f37921c964a5a08e8309bd548bdf0a9d4991  additional-neb-audit/transport-selection.json
+adeca46ec93eca52e2cb119b0d2b0867528d23e65c571b5c9a453020df18182c  additional-neb57-cuda-diagnostic/README.md
+a4de75de449322fbacc0c701da959624251bf8b9f0898172c0b2d19d5aa1dd45  additional-neb57-cuda-diagnostic/all57/references.json
+b74d217c7f61ee9310be711ef597bac0b0385bbcb6480090a20621e15586baab  additional-neb57-cuda-diagnostic/barriers.pdf
+f70ec31af394751e7a2fdcadceeb7a048836b9caed1402f89e76d43db5f39610  additional-neb57-cuda-diagnostic/barriers.png
+9fd85a3b9d8a7d35d4e1af0a902effc42837d4fd0a09038dce6ec06dfb697159  additional-neb57-cuda-diagnostic/gap1/references.json
+7663623b7a44355d5b5e6969af9c6e89b63dd311c0f4403e8af8070f9fc2977a  additional-neb57-cuda-diagnostic/gap2/references.json
+f7a5641bfa3af2fd4436d00869da01feb13b25e0137df480c99fc78b671c2306  additional-neb57-cuda-diagnostic/gap3/references.json
+5a84371b007dc9a923dbc27c270958eebec6bea17b8e8f86d064d3a513d77e90  additional-neb57-cuda-diagnostic/gap4/references.json
+eadd306e0c03358578123de88a4bdce0be11631c2f9fbc3f5e8e2ce89f716691  additional-neb57-cuda-diagnostic/plan.json
+9ae1ef774cde90d60a22dcc1436a764e1de070f08f0987bdbe4a473a61851d9a  additional-neb57-cuda-diagnostic/report.json
+3076fc3787acc4c4bc35a9405c151d808c6d03753e735a71a01e8524bbe5074a  additional-neb57-cuda-diagnostic/review_cached_neb57_v1.py
+cfa0ec5dd3f9b3efbe044e53ed14f1911a34b391f384e41821d71e3e18cf6c5c  additional-neb57-cuda-diagnostic/source-caches/gap1/items/mp-556902_7_6_0_0_1.json
+e893abf0b04210f2d928be923aa28a3b99bb50405679cd9115b17b04e68e4991  additional-neb57-cuda-diagnostic/source-caches/gap1/items/mp-778397_0_2_0_0_0.json
+586ec9e003fbf0c13fbaca46db872276c062468f94d2dd726df114e99ef42d7f  additional-neb57-cuda-diagnostic/source-caches/gap1/items/mp-778397_0_3_0_0_0.json
+c6473e5dfccd7d3ed139559e82ca4247f8dc0b1c2856074c089a00343555ff65  additional-neb57-cuda-diagnostic/source-caches/gap1/plan.json
+a6ff900f910d2bf59c6e3b7c3cbddb229546ef0ae44738459cc254d4c448e133  additional-neb57-cuda-diagnostic/source-caches/gap1/report.json
+d296835ebc563495b7dfea0e8aa816e5177d48fe7ec007014318fcbf35aed45c  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1020030_0_1_0_0_0.json
+ed96c414931cd2a3227c9a0427135481caae3ce9b84a010bc72de8e79585cc38  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1199122_0_18_0_0_0.json
+dbbc61dd1b220b280ee091e68e189def77ae226132284ced3d055a4b2f57f991  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1199122_0_5_0_0_1.json
+2b8f952d305ff6bc9bd6f449c974a6a3f38d7122edaacf68bba79590af77c307  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222482_0_1_0_0_0.json
+2258584bdf17b6fe17b64cf2bd278791229a99639c2dde9700a9efed54d9bf09  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222482_0_2_0_0_0.json
+7b54c5b4a8a2f5555b3ec54e49e7517ca993291b8c888492ade80379bd7370e5  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222482_0_5_0_0_0.json
+ab21ac708fd26de1c35e23ffa55454a3343a5d75b8e3bf3249baa9d5694c2c3d  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222482_2_3_0_0_0.json
+ff7ec30542800c422524ceba1b6591e90143e76c493334922d2bfef1e0e356ae  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222482_3_4_0_0_0.json
+f3b291dc7802f513e9e4eb1fed3dc13dbe46cd726b80897a195b8c70e1c60180  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222482_3_5_0_0_0.json
+70944aecb8547cd55d11114af0878c1bdfad781d9ce4aa44794d9e9656f3e9e9  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222575_0_2_0_0_0.json
+c1d7bd56f8146120e0216919937ecdaef335914e3e5f9273845c9efa683d8bcb  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222575_1_2_0_0_0.json
+f75736b162b085a80ea84b0f594cc280bce694392299053d130307c632ec6171  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-29040_1_3_0_0_0.json
+8dd56454180f74f0b98054f8a1c9a56faa9c6b180ba7fc644d036652b71ec8e5  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-29040_4_3_0_1_1.json
+7f1f042436e2283cf1cbe7a98516b0dcd6587490f887cb9d7aa1438ef0f5ceb6  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-561294_1_2_0_0_0.json
+a75cc45d8cc057c2f3aab44e237f68f2b0572967dd0ecec0d8bbb8929752870b  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-755352_0_1_0_0_0.json
+24b3aae70f0b9d382a6c25f75a51afae02e3273fa36515837b7fc8dbaca0f7c7  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-756639_0_4_0_0_0.json
+97869cdfe3a348633a41e07d1d97992ca472fd85dc5f7beef0dd70e1c310a4aa  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-756639_1_3_1_0_0.json
+d6a2e7ae857d55aa485ed402b3cae42c22438b7880398dfa3914e9c621115827  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-760791_1_3_1_1_0.json
+3253cdfd8014d4e540cc3c85e5a5f6279d92efe60c590eb391c19094c9986e44  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-760791_1_4_0_0_0.json
+efd003c93738c7d217b12b2d3e5c165c259181bb0ac0dca2bf8d92410014f048  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-760791_1_6_0_1_0.json
+4ef342095c8e89823c3d2c969622ef83f9bca3527ef63d0e71e3f6adeb745988  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-761849_5_7_0_0_1.json
+ad502250b1b332beb24437bcc6385159d24f9b031c23ccb69fe59994e2698e7f  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-761849_6_5_1_0_0.json
+9a6d73f9d03fe5dac069e059dca91e6da8c7f4950828131a6d620c13647fd8d7  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-762240_8_13_0_0_0.json
+f140ec6ad27ef06c59e6ed245127a62e1a8f0d3aba9347f73805fdf9f182249b  additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-772260_4_15_0_1_-1.json
+f5d5688e38960598c457024f8bdfd34321324118e119a9c7e4e2268c43997100  additional-neb57-cuda-diagnostic/source-caches/gap2/plan.json
+74d141f8546500159b5fadfb2acc1b59d15a589ed2833f744924e831d8fc090e  additional-neb57-cuda-diagnostic/source-caches/gap2/report.json
+9ece10cdaa075e2a106763e52e9d283ffd6af6f12ecf9269bcd7171db6ee0be2  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-1176566_0_2_0_0_0.json
+8dbc36df07c319abf6bd68a0c6606b834bfd85228581005f2dc554ebc253051d  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-1222512_0_3_0_0_1.json
+eada026ecb2ad17c832916e88d4f9e51e3bb2eeae6c6aea009eccb2db1f6ba7b  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-23384_0_6_1_0_0.json
+ba0b30d8b36d6a655e0cbd5053f32d4a3a73931bd82d696d48897dc16664923f  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-27417_0_1_0_0_0.json
+3b5e1911558c2102d5d55878e8896c8831c54eda9c81086f8b8a7e853169fead  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-27417_0_2_0_1_0.json
+8393555260eeba07c0f0e0e39ff7de3692c76c1effb2db97219e309d79ebc912  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-27417_0_6_0_1_1.json
+af33e858aba6562b08da5d3501e41f31105b884c82cab2dd4f01f2a9df65e073  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-27417_0_8_0_0_1.json
+c285a32cc70771c63bd023570b105d65d54ba3204d62656fbba15692e03a81c5  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-27417_0_8_0_1_1.json
+fe53db2bf23f3f7cff31bff4de19740c16b2083a2f3d08d1a86057cd3e9a9244  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-28548_0_8_0_0_0.json
+c5d5bb3394eb4e8da3ed3693bd08ecd59ac424fcbc6b20609fbcf1f475afb0e2  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-5418_2_8_1_-1_0.json
+5f4ca375697503a1f05aa8f3b91672a717d295ee25b38c3dab1564cabea64013  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-560189_10_13_0_0_0.json
+1d629b8e7f58c61952f872e29ccd7d4e6178182dc19655ec65a5403e73e1a6c2  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-560189_14_22_0_0_0.json
+c29337b1f5a9cf413752c5148e8b19f10aaa974048457f7e537e7b9e4ce21582  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-560189_9_11_0_0_0.json
+1354537ddff339f74921e5316ea260779c101a2b27ba32a0812256fb4fffd782  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-6326_0_11_1_0_0.json
+a37d8965b1f3010a67e42d45e134186da5a659509b2c6e56c527ef561ed71a44  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-6327_0_0_0_1_0.json
+0d75c9d9747181c7b4bea23b4f15bde04e1b63d93ce8c0c8ba3c589396856ee5  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-753520_2_6_0_0_0.json
+69333ca3487096cd20306e8c1a5602f33ed3f48edbfaf6663fba2f0be20256e1  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-755559_0_0_0_0_1.json
+83d2f8f69964c1bd387ac831e28762a1def0b1235f852f841db2f10f763da7e5  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-757905_0_2_0_1_1.json
+a53311b74e3b09333665342eed5a73333837cc37fd610140814acdde545b89c9  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-760701_0_1_0_0_0.json
+a0542e0adb7ee0f6b9062e2cb1d81d643a20ca1718f323243aeb1f5b32b3f7fb  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-768982_2_6_0_0_0.json
+cb828c1327f6dbb4e9032fa44d52c5350388cd5ff140faabb4e829215fd55726  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-780226_0_6_0_0_0.json
+e464fba7666174863322d66001f892f039e5e501b1273747b216eebf547fbf5a  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-780226_1_2_1_0_0.json
+d5ab368d8f8f227d3ac54d87815a5fdff89e973f62409f4182a529dae3586653  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-780226_4_11_0_1_0.json
+1cfae77d0015b526627d89a71422e3eed9749645f864cdad46a35def923f01cf  additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-780226_5_0_1_1_0.json
+a396e1fa123a6cdeff95fe61ce612387e5075aca4ac30cbd8f619768f2df42f4  additional-neb57-cuda-diagnostic/source-caches/gap3/plan.json
+77298a731088934bfeb4893a361bbd45ccec6f72bf93e0e5f4d429e544c179bf  additional-neb57-cuda-diagnostic/source-caches/gap3/report.json
+054d8a855bcc77e3487d106b791358dbe7091c403e2899b145a1abeade5b7081  additional-neb57-cuda-diagnostic/source-caches/gap4/items/mp-1147685_5_17_0_0_0.json
+9642c47a3c2f71bbb5e2a7db093489043ac66981a6202723deec8ec80e73cf82  additional-neb57-cuda-diagnostic/source-caches/gap4/items/mp-5418_3_9_1_-1_1.json
+0bb24f4a7373448e725f7c42d86847ffd0e57c4aa5dce8b08840804615c9ce04  additional-neb57-cuda-diagnostic/source-caches/gap4/items/mp-5418_7_5_1_0_0.json
+559da223167a74586193fa8c654c89c76be15c850f5e7586c9f9bbb31fbcc255  additional-neb57-cuda-diagnostic/source-caches/gap4/items/mp-755225_0_3_0_0_0.json
+fff1ee5ef54a55e39a6b4670b84d5fe1b818970919350f64c06ce0f010d3f5d2  additional-neb57-cuda-diagnostic/source-caches/gap4/items/mp-772185_0_2_0_0_0.json
+1dd71e20e63f3dd36445f8e62f5b25d5f0eefb0a453049b48e529b894d02027a  additional-neb57-cuda-diagnostic/source-caches/gap4/items/mp-772185_3_2_1_-1_0.json
+3d22ae7d5a0f1abf01dbd6adfe938f04282757fcbf6b19d68c990510f814b089  additional-neb57-cuda-diagnostic/source-caches/gap4/plan.json
+cea3f30ebdb81402ec197d9ba405b073365e626a6bd8c85926e0947a308573dd  additional-neb57-cuda-diagnostic/source-caches/gap4/report.json
+e8981584d852f6608e8dc915a9825b3c7d24569c16458b3d0de90ae65d1f1f02  additional-phonons-predictions.jsonl
+3f02f845eb7778f1cd0d6cfccc59a559d9fd037b7d16ab803a35ab8ebb97790b  additional-phonons-run.json
+828b6345710c407b652a9356a5121a8dba67ffabd9e64ee19b7e39e15081cb2c  additional-phonons-score.json
+f4c2bf293c514e6085e4ee0e7a21d2a2e57cffe6fb4f394520bfb5ee083e71d9  amorphous-energy-decomposition.json
+f7ce67284512c19666bd64a0ab93c5f7f281aff022b7cb3025cdf9f2ba6ae950  audit_continuation.py
+e8020b08c19ac43607476db20f2dde9a83458339184b808c1672d00f4a7d99ae  background-suspension.json
+93a7e0bbdb816bb86bb1b27dc451d42025a637b227b33dd58077af69c1381b5a  broader-OMat-comparison.json
+7b08c354083cb24910b058e8580466488c5f1aebaa39ba39ba6e050e1e4c37c8  broader-elasticity-comparison.json
+6517f1839ba5c2a8aa200330e035869aca8884ee27bae42eff0ce4ac20a80137  broader-labeled-diagnostic-summary.json
+9ff832696f76d3fce9a0b0524b33030404a6417dd165c6aa8eab6881a1c92fe3  broader-labeled-diagnostic.json
+4e86bca6127f03a81984a08c6f86a8d20bac0d07b102d41a305dffa8ad9d36b8  broader-metadata-update.json
+78aae19ada53b2fbcd7d6fccd34e2f568a672daaed2ca3802dea94376f7372b1  broader-phonon-comparison.json
+02aaeeda3d67f6f0b4750125b254f8eb38ac3443af8ace4bf6f60ed74a54681c  calculator.py
+b5c16b0631fc8bd04237d41af809b681a3881d5fe63dee11c5effabbafaca311  check_package.py
+79fb4236ae6620e1e858d5a0d8c4021dbf4ade013e569354b040c58a208abe2c  completed-full-suite-comparison/README.md
+7b4571e223254461bf99f341612c1d9356f25936483102688f14d063c615ecfc  completed-full-suite-comparison/compare_completed100k_suites_v2.py
+c27ea455bc1f1ae8ed4692c21deca2d9897d7b0b9583946e1433b8114763996e  completed-full-suite-comparison/comparison.pdf
+cf29c06f38f49698a3ddb99efb84350a83295fec6af06a0dc8dfffba01771a54  completed-full-suite-comparison/comparison.png
+2e1d293de166306f5e245c7049cf0dd212bdd8eefce9ee25ee3603537bed96ce  completed-full-suite-comparison/report.json
+489e815b900ef7790e67012fc43b5d26c624a90af416bc759146174379fb60cc  completed-six-suite-comparison/README.md
+d160442b44aa9756b12dc575c427b09fa39bf838522e6ee6aa0f8acfc9e04b30  completed-six-suite-comparison/compare_completed100k_suites_v3.py
+127fa452f5b72883f53c9998494d143d7c05366a03b34e1c0fb5309a369de5e9  completed-six-suite-comparison/comparison.pdf
+326f7950937ae1bdd50169bf8a604bde6c2e1a758b32d015a4dc5996eac1e9e2  completed-six-suite-comparison/comparison.png
+b7b64174d1dd8dffc44c4558a6adf77ae2ca10530ea12a361c91a9b4f503d211  completed-six-suite-comparison/report.json
+bf511bcc8a5de55dc406bd75df67e2d35f586f5865b10ae98838641a078a7d78  consistency.json
+c66fc6463d9ab433aee2fbb20f0b87ebe4e458bbd57981f589924827b3682dcd  continuation_stage.py
+3b91b17e20ca5d25a237de5d3412d5a12f2046929dc248f2ce01787c4f7b2cf2  curate_environments.py
+79ef38898294ea1db1a288316f5ae48eb008c9f13d6ef41428c36c02cc761221  curate_hydrogen.py
+ed7036a6069bca1b06a7f9e09a9a80d65727d7132ad465eadff387963552ad17  development-registry.json
+86bf2dfb859aa4621964206cf3662e431c37bdf02f32abd6f0b7c0d5afb1a0c4  discovery-metadata-update.json
+f9f35cfa199dd23096a446ca0d8dd34020f5a788d311141288562b12b92f3a13  effective-config.yaml
+165e29f52cc761278bc9e3b979bdbfb0a0da196282e1f21d54deff5c63ef389a  elastic-tensor-diagnostic.json
+245f0b63d23b93a741ffe2e7a603709b0eb16df3743e177a02498e554d15e885  experiment.json
+16d011ab077d9b8ef75c33c5b5eadac8c664c08897148e838a96d0f14fb344f5  export.json
+64abf01febead6a296358011fa24e13e21e330b86d975975a553ef3df6ce1531  finalization-records/README-before-finalization.md
+9c43ced1908d435650ce5a94b437e74dfd1af35f9b563549143d5a44fab7faaf  finalization-records/auxiliary-energy-floor150k-v1-decision.json
+dbe108ce91809d357ddd84b8c9535b1ad98b5b6bc28ee67c3a3478ecf115c9b7  finalization-records/cell-stress-replay-v1-decision.json
+fbce46942b540402d81aad75cea5d3edc2e36f42e622f4e2451bd16725ee6675  finalization-records/contract.md
+6853ac53076a7768659f43596e1ba2f3a6201d9b32649006581021354da51224  finalization-records/duration150k-floor-v1-decision.json
+b5b98fdd12b17b20fa1ccd5384d05a4e4f27cad28731a936e1250018e740676f  finalization-records/duration150k-segment-v1-decision.json
+27b7ad61c92703dbd8afd9c27e784951a5ba877bb90c9a522d654fdab3991d26  finalization-records/finite-cell-force-floor150k-v1-decision.json
+3c175c11e93402407cfcc0f5e6cb1ea0a7008359bdb24991effc06b57fd388bb  finalization-records/force-increment-floor150k-v1-decision.json
+cb28aae4485dbd81a75310601874948aef32d647433ae5d080b39c38a26bd645  finalization-records/prior-strain-components-v1-decision.json
+417262466780cf3fc465e91f02c578d049d7ff1b5e7b016533f2dcfc66db9834  finalization-records/rattled6000-floor150k-v1-decision.json
+661d9a8633f5c178f3e6c9b449f4ff79192b588302e2c2fcd9cd3ca4dfcf0643  finalization-records/rattled6000-segment150k-v1-decision.json
+90fc0f0a2d45fd5da4240a63494d0d9dff4119d4c6754173e659a13e37b23fb7  finalization-records/source-context-v1-decision.json
+81cd7d01fdfa145aef89d25b1f9c072c0b4e047c4591ca4e99ec48442665e123  finalize_coverage_v2.py
+d81879fd1f40120fe8eca865c2db60e7e1c54b4d6ba8ddf415fdea18628112d0  finalize_curation.py
+9b28a4c7fadd009a90eebf95b5e76427ebf23a9e7085d8a20d6341e3207baabe  full-amorphous-comparison.json
+87ea0c734166173ad64ba09bc29f82da4bb3c1c147e8d08fe06cc436b389f7b4  full-amorphous-diagnostic.json
+080af7e77c4f682523b4e33965301aa41df1c55e2793116807a9a5abeef7398e  full-amorphous-identity.json
+17e71dc7d0b87b19a58e6bf8796b5ac1b75bc26a37ac70d607fa1095d304fb84  full-amorphous-metadata-update.json
+1868b5265dceead98b11653e7f1fe81a40fe8239995b32a2361fdc9f6d7e2539  full-amorphous-predictions.json.gz
+52184d9d257c77b9d3d56724abc1259ddbc4364ea5da43b1dc3d21e8ca3a2ae4  full-amorphous-run.json
+8ed595af11fc06c4c1200744976b736404bf4ba6ade39f18ea02d19d96a6a306  full-amorphous-score.json
+adff399c6628ae18949358f9c2e993df6dbabdcc2f10cf820a0559c8b7005736  full-carbon-duration-comparison.json
+37c06477d596bb3502af98965e14b87748028f23dc1597e37822de3e9514706e  full-carbon-duration-comparison.pdf
+661dc6977b108085c076cd167a13931a7c76c051edabbb974a82a8620f85693b  full-discovery-cpu-published-panel-overlap.json
+657ca37ee7ee41e64fd359eff4501af044831f0c6a7945d606623b0ef1b532d1  full-discovery-duration-comparison.json
+c91473f9d283909f17e339f39f81bdb6d3e74c392afdd1558f6c65d8d4d31066  full-discovery-duration-comparison.pdf
+fa7685839d95ab727e8ff0558ff592899c7960100455be7ce8fbaffa1662b58d  full-discovery-duration-comparison.png
+b05c67a1ceb3ca6f5caec89575ecad39725261fcd722f304fce8cdd2fa278999  full-discovery-predictions.jsonl.gz
+3249018347c2b00ed3c2d72f9775efd3bf25b75bc03d17d7df3ccf2c90511ffc  full-discovery-run.json
+ea2ec565aa31c64311e0a87d0cc7c234a9b6981f93dda948399f422c18dd7e87  full-discovery-score.json
+dc98283ac0fe23c366ea4558a92eac8b808c82fff97491c057a062b51fa870a0  full-discovery-selection.json
+464f1bd0ef29b4fa39e4297dc5ac7ccb718725cbbc5d349442238a9d12c1385b  full-elasticity-metadata-update.json
+aa2d98fc1151125adbb33c615ec4ebc1b5f080876a7e7d75502c831e7b3ac713  full-elasticity-summary-metadata-update.json
+f314b1723dbaeeb9620b3489e86442f4c37140125d6f99683678f33a22da7121  full-elasticity-validation/README.md
+29d44ca50d6d6345fde901deec3bf3749f24b7aa5be950d9130ded832e688c17  full-elasticity-validation/diagnostic.json
+ce0cbed7638706df3d5a9e3d944523b9f8a7aa41746abd4a249fb6b390b989fe  full-elasticity-validation/identity.json
+38e57e50a717a1d907fbfb1f2b2652dc0cf7df089fa534094869703189d89c9c  full-elasticity-validation/predictions.jsonl
+6e9638cb94dd5063fcadcb1b18f00f677399ae0d860081f10554674bce4b58e2  full-elasticity-validation/priority-plan.json
+e800d22eed47fcf5be3287486a33de7f3bc10f162dc0fa18c9fca7487b137112  full-elasticity-validation/run.json
+f04f8a920d242247206fe496c8cfc235b15f7ce725d4298f15f6f01f55ef6146  full-elasticity-validation/score.json
+a22ca38a96d93b219a1f9fecfb0ed08ba214db4203ed391a9c318647d0937ecb  full-elasticity-validation/selection.json
+7eb2e44b5af79420055af8c58b70e8365338c59249964df0d5b0c8b22e7885a3  full-kappa-metadata-update.json
+fe1b03c0221b4622619debf557b697793b27efd548f20b2d6ffb024ebbf8f81f  full-kappa-validation/README.md
+5ffed54198e9d639d852744e0162074cfbbc35fe51ae82c7ee1abb255989d8ce  full-kappa-validation/documentation-plan.json
+9292416602ba7296c164ae6519a1b9dd5337628c5955df25aced7536691a3e5b  full-kappa-validation/identity.json
+b6248623cdc7308a8fdec1a93f678b31d263f75e4eaeb6088435b9711730359d  full-kappa-validation/items/mp-1039.json
+587cd4a0e4855d2788bf94e55c6b3c1c915f5d40f508b35c9e2289b2605d951c  full-kappa-validation/items/mp-1132.json
+654e6ac81515afd67c3fe43232039ec229963bc1f49458af1dd18838f724aa09  full-kappa-validation/items/mp-1253.json
+ed568b6438416cf1b4be8f0e1a2635a4bb945220a6224c5b228f08b71a41c93b  full-kappa-validation/items/mp-12779.json
+d64f0a27f9d38ff533132d30040d1d50a88e3a02e3eb9e17ee9641e34957ef44  full-kappa-validation/items/mp-1342.json
+0e36aa1aae925715fcb08c99c0fcebeeb125fae439f55be423608a4f903e2fe4  full-kappa-validation/items/mp-1415.json
+b9790be2b82f0c9865a030012ab8687bb4dd6445ac451b1cd84764a68f597d9e  full-kappa-validation/items/mp-1479.json
+59feb2678256f631b6049cd5dc66eae6df591f7950fbe6482b545d2c8b7f2649  full-kappa-validation/items/mp-1541.json
+90297f221976c2499906a9d420280f5c0a6e7fe3afb95e67de5e1410b7bf9d89  full-kappa-validation/items/mp-1672.json
+bc9d722e3d4a5e88871e8123cde6e8c7964e8557832a852fccb74f570009790b  full-kappa-validation/items/mp-20012.json
+12060875b2e64cb0f1d6e14acbda917a7abde68e673126048c47d1a660363c85  full-kappa-validation/items/mp-20305.json
+bfe0c4ae5ea8f06483c09eff7fc15d5dbf7b41f9e0bfdcd4ae5657433ca30967  full-kappa-validation/items/mp-20411.json
+0f38ad5e40cbb07a83f699650e6ac0c01837e2b74719bd45e82c28d7499533a6  full-kappa-validation/items/mp-2133.json
+a19545470eee3db16b60645fed8d26b3958d41e683e6e80290078562a70652cc  full-kappa-validation/items/mp-2176.json
+1c96b79dcf321bb94c2266b7f24d96f0136d9cfeb53eea36b22bd2dc16edc8b6  full-kappa-validation/items/mp-2201.json
+6b8d6917ff6102e3549959d183085e7e180a35e91b22cbbfbf99703b3c207dc7  full-kappa-validation/items/mp-22205.json
+f22109858d8098bd740a88437975a1f879c93c02ebef926d532acc1b4b5d1904  full-kappa-validation/items/mp-22903.json
+cdba13c9ae13084197ef7982b9a66ffefd1d3219c58737bb5f34b2c3701a3e80  full-kappa-validation/items/mp-22905.json
+2244c45767fd28551f7e523bda118e0656d8c779c80f20a28c8563c9423a1018  full-kappa-validation/items/mp-22914.json
+6672f9de900601bf34b4d4969bfc883c6dd824e39790341f50e893d42f8ed5a9  full-kappa-validation/items/mp-22916.json
+5cfe8819530e434da26959eace2aaef8cfa5372610a1b39515b9cfd8cc3e37ed  full-kappa-validation/items/mp-23193.json
+64a9e0d8417376a33b5c25e26227fbea0ae11d7d3464db2529b730285ccc9160  full-kappa-validation/items/mp-23251.json
+f3a5408a35c9734e2262b516fb3a7098e43e4f5725dad7b3e61ac8aaad1b66ab  full-kappa-validation/items/mp-23259.json
+0a991e4254df35f40ce3410803a771f37e8750d24080e54c3333bce4aaaa0322  full-kappa-validation/items/mp-23703.json
+56f5b44573c5af68cb93ffb4e9ec228c61dbccfa0a1408daf106915f8d5c6eba  full-kappa-validation/items/mp-24093.json
+1b2541d6fd5f3fd1bcdeeeba0192b11a4c29f66f70848943d8886557aa19836f  full-kappa-validation/items/mp-2490.json
+9cde80d5ed95c86ba5efc90024f107e1a2f3e96e6105c3c2fa929628ed6a1be1  full-kappa-validation/items/mp-2534.json
+845df40827e3df5d8f108bf88bcf8f0ee6f4493b4d990a6f93178edfa308927c  full-kappa-validation/items/mp-2624.json
+3a75a9e46e1ae27403267a96e92b881093c0ab1095c95d2ba79da1a46f5db2f5  full-kappa-validation/items/mp-2653.json
+f03c572107ded4e61112aceb49a7ca635efd53ed67a00f8e531376eb792649b9  full-kappa-validation/items/mp-2691.json
+2f0e038b5e4239676e47f373c0f7b6807e9dfd173edd15308fb9bd01f27cf49a  full-kappa-validation/items/mp-422.json
+1ca0d6e74ce4e8c76cf0c981cae130812bb5048e0a2c61abd3770bc461f991ff  full-kappa-validation/items/mp-463.json
+784c5791ca8b8df0f07bb91061a78a2a585ca33319ba658584041fcc53728de0  full-kappa-validation/items/mp-569346.json
+97cceaf3fe8ff0e0f4d6132284d3952628a770bea5cfd3cbecd39590121b88cb  full-kappa-validation/items/mp-580941.json
+3070df21e12e434caf9dbd1c7b5f3fe1076f9792eb256f7694691ffc85585acc  full-kappa-validation/items/mp-672.json
+652a090b10880132f5fffc2ca61a6e5d8821133695102bdb3195043155244f59  full-kappa-validation/items/mp-830.json
+b5c43c83ddad8d869a12cb025bcebfc4b7ff5145ed8f5d4eec87eb12d82c9a13  full-kappa-validation/items/mp-8880.json
+0c50c93ddc4de3a5acd35a95b6ad9c5d6696c84c97a91a318ec8aa478f58f77b  full-kappa-validation/items/mp-8881.json
+bbcaa0ff45e4a001dc16a2a87f48efe1135c8f373627545a248bd9c531911ba6  full-kappa-validation/items/mp-8882.json
+70483edbf3253e914fb4452649fecb0833d9452fc308b1ec042be667a31690f7  full-kappa-validation/items/no-mp-3.json
+0f2c2f924844805b9e5addbd9807ccf4c585cf1eabdad31ade0c44f9da49cb7f  full-kappa-validation/recovery-1-before.json
+d7565fede082a971d7815d6096215d93c7818887609e2003520c41fe91ce6ba9  full-kappa-validation/recovery-1-plan.json
+b8baac30b4a872b74033d922364d0927e12a503cabf095520761c7b6849d96c3  full-kappa-validation/recovery-1-progress.json
+30a38c479af08dbe98fcc17295597537c7dac481a971b4ff9f791960517d5b12  full-kappa-validation/recovery-1-stage-before.json
+eba16ad8724753a45e9ad949ecc66d0f98d04d7f171afa0b4300f52e40e6561e  full-kappa-validation/recovery-2-before.json
+c0a5191007d013ddd07c9185bbfbfb26a0d02e93e352e38943af29318305c751  full-kappa-validation/recovery-2-plan.json
+4de738b9d1da9856a8c2a148cf4327555bbb2667d4d181b71062bcf0b2e4ea6e  full-kappa-validation/recovery-2-progress.json
+14632891a7d5b5fccbf3a7398671ae88783ac3fb1cdc46940c69eb67f100073c  full-kappa-validation/recovery-2-stage-before.json
+5eaee11bcbdeda01f8006bca1383d31a5e22ba1887c44433c8d82cf0638249c1  full-kappa-validation/recovery-summary.json
+6fdb895646fc84955fc8deb1480ab1411b6babc8957813e6b0d94e11cbd7f92f  full-kappa-validation/run.json
+bae1968d6b64254c9917ae3e69b012d1185c953c93698e4eb49f0579852c9996  full-kappa-validation/score.json
+d33b2ba9637886ff83385c8a1ba9dd2f539b6a5197a95af662add0633d51e5c7  full-kappa-validation/transport-plan.json
+ba04ed6a17745e6c87e2b2a8af30a24ef11de1993a13a75f195b23ce917b2159  full-phonons-metadata-update.json
+b01b79e50321a623e07a7ebcf287b71e4e784775854731026826aa7e2c26dbc2  full-phonons-validation/README.md
+e78164868927192432ba2c060738cbeeeae0abf399a21b1107467649eccec997  full-phonons-validation/diagnostic.json
+ccb55839ad98f578ade8e6af02bc07e44af273c1086bd288543780a1a9126503  full-phonons-validation/identity.json
+7fa53ebe1395bf03e86d0f727fd388c19ff56d270e26499f8c796846169933a6  full-phonons-validation/predictions.jsonl
+6e9638cb94dd5063fcadcb1b18f00f677399ae0d860081f10554674bce4b58e2  full-phonons-validation/priority-plan.json
+32c8ccd94dbdb544c346ded3a16dd9800e40c74745753bedf2aff640a2733265  full-phonons-validation/recovery-1-before.json
+d7565fede082a971d7815d6096215d93c7818887609e2003520c41fe91ce6ba9  full-phonons-validation/recovery-1-plan.json
+5847ea1bf79f0e496ed7f34c7e2b8d18a2a70e90416f0222d7660d965a987487  full-phonons-validation/recovery-1-progress.json
+2d94967ef8222fb2e3d8228806194878815398329615573c787400b2d23a7223  full-phonons-validation/recovery-1-stage-before.json
+d472d01ddc8b87bff79624a0ff533b0ea1d38c236ca6054f046d14502590a8bd  full-phonons-validation/recovery-2-before.json
+7530e549d548ca9827ad3f86ff5347bdcd5381ced80a6d86265cf8910222a52d  full-phonons-validation/recovery-2-completion.json
+c0a5191007d013ddd07c9185bbfbfb26a0d02e93e352e38943af29318305c751  full-phonons-validation/recovery-2-plan.json
+f404e7449f848c9b934a67f92ff57a91ac14598082a7a2f067f37679ae8f3e63  full-phonons-validation/recovery-2-progress.json
+635be0206f79d608becfe048c46939d34d7be405c1b5c3c6e52ec86128e34ad4  full-phonons-validation/recovery-2-stage-before.json
+41632525baa5120c0eeedb5e4bb94cf6a602b97c7da3834100c87486652f5902  full-phonons-validation/recovery-documentation-plan.json
+dd2c4c98d32fd6ce62596b63ae88ef51f2f2ff3d35aab8ca4fd3d20b8bb692a9  full-phonons-validation/recovery-documentation.json
+0a1270110ebdc5aeccbb2ab71ef3830bc9c0d2d8e16a2ad92597ced9098a0ab0  full-phonons-validation/run.json
+cf650c679d1d0f48e10d80d5f6a67aac61146b6ae84d694a8d403ea89f599c22  full-phonons-validation/score.json
+0617df92f372a781d8eabb7e4bafe2ed8c1a55b16e4eaed29b3507248de7ad9c  full-phonons-validation/selection.json
+b510cab6383afcf3fdfd30aa437d9a33d329693493ffd26009c3e2508a178375  full-surface-duration-comparison.json
+cd490e2ceab3ff1c6ed85b17f0cea54aefd797d7e768b1c6940656affdabf90f  full-surface-duration-comparison.pdf
+02327be235c219a32e65e8a13426d8cadf6f82bc19a11c27df8085d3a89da490  full-surfaces-identity.json
+cf6d241b27a1ba3fe3bf38a927549d904a2baa63bc18a9963b0f3c427d664ad2  full-surfaces-predictions.jsonl.gz
+c4840d7bdaf56af150b65106c31c2cdf5ab6644071ca02cfdb7f5d20506a300f  full-surfaces-progress.json
+1de4933f1718fcdf8cb44ceff1b3ed0c7cfc5612c111879732af2879b9e08d80  full-surfaces-score.json
+3e0cef6620a19f5415ec4a947bd2dde42ee75509bf02697336db20e84aed97e7  kappa-audit-metadata-update.json
+b61eb6401edfdefd979d36017e4209bb3a7b907010e1a9985a6af9e507815969  loader-audit.json
+aed46a96a909a2c5ed20f94c26252dc290e94d5551a4a8d9800a971328a32f83  matched-runtime-control-validation.json
+81b3a176ec847c1c1be0bf8ed80058c0b8bcaffdfa3c873f1ad97d6e8b566f79  matched-runtime-publication-review.json
+ff109bae525fad5a87d10ad1bc55a9be3450a427c42dc0b8da82056be8dfd902  matched_controls.py
+de8d12af689868c9baebb2054e64cfb38d583c224078aa8e95b829b57524f848  metadata-update.json
+e9114f3f1647fc56a61162ce30b78ce12d0657143166dc1d51dc8213a3400cec  model.pt
+6378e5c54ab2c826195cbdfeecdd9057b3a2090a38e30cc0ac36319bd9e5bac3  mof-backend-sensitivity/README.md
+520d2bf8a0e8406442eac52bd90030f775509d994869d8a8e87febda49148189  mof-backend-sensitivity/duration100k-runtime12-step100000-case.json
+5d82738956186ea0ae6c30a6cc57f232b2f2b4e592cdb48dc191c64bf52ef1b3  mof-backend-sensitivity/duration100k-step100000-case.json
+bb2c46b082f325e3a12d996e45bccdf65638f21005a91c89559bef5591ce11a9  mof-backend-sensitivity/duration100k-step100000-cpu-case.json
+77d278cad12e9a4c528a555de7f2d7e7ea9ea1138387b5c52f4b21b0380cd4e9  mof-backend-sensitivity/report.json
+aabdd288d22ddbc3b0e9cdb0ba3ac71f24c148daabede11e8af4544a33324f66  mof-backend-sensitivity/review_mof100k_backend_scans.py
+7e2e2733e66a123ecfa0ef9cabf5354487cf4fda6aa44ff9ffea367409250172  mof-backend-sensitivity/scans.pdf
+01e0d376352c8f8de9e5e13cf97756480f3a3a3244ea4d681b96c966af352e17  mof-backend-sensitivity/scans.png
+1240d2eb13064b5c1615b73b5820587faaa9979fa29f7c55bd3b19a0b3582508  mof-scan-diagnostic.json
+07b4355232fe7d67669c674e0bff0162bea2169226c1ac679caf9806d737941c  mof-sensitivity-metadata-update.json
+5fc18c2a57f3d1b7664fa52f566812a0a558c3a0d7a078e0817bb16d319be749  neb-audit-metadata-update.json
+aa808c28a59b033e65dcdfbf0b24acd46053426534620cef5de39632decc0ffc  neb57-diagnostic-metadata-update.json
+be353f6ff845951df65bdf1bb84cc34b21b84891d82cb51686572f3854522f61  neighbor-coverage-metadata-update.json
+8f228561566c04d3ef44d566658c158890bf9280a3b025246ddc328fed2d871c  parent-training-and-validation.md
+3b48a7431c65fb73188e1019a0e8977caf04dbbe9c69cd389d43b1d894724e45  pause_background_workers.py
+dc7eb169056d4cecf365acc075da76cb52b0e523a10048fed8bd2f7747d12439  pipeline-orchestration-update.json
+b870c0492a2f9e1bfbbcd292717928459fcf2b10891678f61e9098831497477e  pool-stress-path-audit.json
+7ee370190036a302d8c27f9e396f9bd1c8669c2689cc57d44f27fc6bf58b9377  predecessor-control-repeatability.json
+534403ed3f7c41a4e8ece63d62619ac156162622982fe3ef301f7af4c4823f5a  preparation.json
+f24557a332118ef8a9063881564c3f05a00e5ca2d62c7df330888022728c20b9  prepare_continuation.py
+28929714f5aed5a870a5e3d1e7062e49965c460089b893b8e9a9237b0203bcb6  prepare_coverage_config.py
+637675084e7d9a09a9a6d035fb2357803df5e4eaed2fc2e4a65d99a0f52d766c  prepare_coverage_h_config.py
+a12b1aa4774852346113bc350cfe6ffe97c0aa93293e5ce2cf1b766d79fb3d59  prepare_omat_dev_diagnostic.py
+a69395bca75158076ef549d82205e3f41083a871e5c1da747d1ed6446df101f7  prepare_training.py
+a69395bca75158076ef549d82205e3f41083a871e5c1da747d1ed6446df101f7  prepare_v1.py
+50473f06807de0241fc959d558c1b61199b41116d7b5e9e259ffcfbe3ba9f277  publication-review.json
+335127beca52f68b64c720624349feec4312e0b78c763b634e50bc02a831753b  relative_energy.py
+683c1a88378806bb1374caa48a8fdfc4b8efbcbc9faf1c78e807cc7acb28cb19  relative_training.py
+a0f7033adebd46911a57c8df2487a13108c1c58774040d5fe9dc8ff83cb96b97  resource-scientific-review.json
+7aa5409c3556eec576e7a0fcdcef25a4fe764f9932f21efa8a3ffaad4f56f6c0  run_mof_logged.py
+e3472bbbf7b64b283d2162bce39c8a964dfef38911454fd6e2963d22b9b1cb99  run_panel.py
+e052d936ae5cee824602d876fb0f989d114c993180d37970550114a42137501e  runtime-experiment-plan.json
+5a7aaf419ad9bb6719f47c4af93e1f41c879491638efabfb362bca8f5069de81  runtime-profile-provenance.json
+f42d4de3a0703aae19562afaf92cdf7ab953c038413d8e5f5ed5f74eb6f37834  runtime-thread-observation.json
+5f992fea43279081319d94509ba9b9484dea3d49620c3a7b02060ffff5b8506e  runtime12_stage.py
+e81e3f0f8da139ef4755193317882c8aa6a958df67123909e8baac1392838ce1  selection-plan.json
+ca2bb6e294cd73be4b60f7f28aa3e04d4b4358a19a54fca84ab54b1baddd81b9  selection.jsonl.gz
+6ceadefcebfb794d378cabc249da571e0b52aa8913e74ef6d5a972cec9fd619a  six-suite-status-metadata-update.json
+f24e92ffc7963d6b022a26ed7c2d8cbeeaabc12395556dbd3db79fe495fe7b5f  smoke.yaml
+ce7e36ec4e9ec838dc0b0988aeba284e2d31ad4de94cfb9f58a577c227b4f03d  source-stress-decomposition.json
+37cb7efbe6e795b21c80c8e5bcd08afe2d0fbf59d097f76b6b565fa85dc8c5c8  split-audit.json
+4fe23321a1e15186bac0fd3d9e84c3f14df65115d72801b711aea3339cf65014  surfaces-metadata-update.json
+d082e67d20666f85927512a44ca7657b2cfd869e9f579cd4976046aa7233fc20  train_single.py
+4edb51c2f8006cd3a32378914f49231bfdc59db44c68a4e519eafeb942680b7e  training-neighbor-coverage/README.md
+9533fd3a50134f522350c75340b8371ae011965a33bc3e04fa667f75de4dcaac  training-neighbor-coverage/confirmed-empty-graph-failure.json
+214158d1dfe5fce49ec24b7047eafaab9259e4c3557ed0e80e3262ae63ea2629  training-neighbor-coverage/isolated-atom-review/README.md
+d5be3401bc5f8f77f87da9f66de6f1d4516392bc1bc27a17a2caa5e4610c9569  training-neighbor-coverage/isolated-atom-review/plan.json
+7c68ebc11e20ad8e5aa918b3a99dd175016e5d47ac350f4490a6d3b619fde6e4  training-neighbor-coverage/isolated-atom-review/report.json
+bb84e1ee0567694c139577c3e3aa55395a350361ab0f0e9ddf1834d49033fef6  training-neighbor-coverage/plan.json
+8463b5b2bab690e8d445398db1b8bb213ead18b52ef2858948ddffbe8170c7e9  training-neighbor-coverage/report.json
+68c99d90fa22cc28dc5208eb13fe341289d5523e4e3871cd82f8efafb53456be  training-summary.json
+5de3a59493b8f6166833006612b06c82f3e7c060515da59b0445b6a6303f1eb1  validation-panel.json
+6297922ca40f5361d89397dd70813bf90aea55ec478770af4a7b2a26bd7582b2  validation.json

shared/package-files/2e/2ea4a717a746c15cfa898719b58815519482e2875a2119c5457e6f0885af589d/blob

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ea4a717a746c15cfa898719b58815519482e2875a2119c5457e6f0885af589d
+size 353320

shared/package-files/2e/2eab602cade8e09484ac61e8c813333e531828c91cfe2e4ffdef8f2908dcb7f7/blob

@@ -0,0 +1,39 @@
+#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 convolution_overrideable {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional<at::Tensor> &, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::SymIntArrayRef, bool, c10::SymIntArrayRef, c10::SymInt);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::convolution_overrideable")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "convolution_overrideable(Tensor input, Tensor weight, Tensor? bias, SymInt[] stride, SymInt[] padding, SymInt[] dilation, bool transposed, SymInt[] output_padding, SymInt groups) -> Tensor")
+  static at::Tensor call(const at::Tensor & input, const at::Tensor & weight, const c10::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & weight, const c10::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups);
+};
+
+struct TORCH_API convolution_overrideable_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional<at::Tensor> &, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::SymIntArrayRef, bool, c10::SymIntArrayRef, c10::SymInt, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::convolution_overrideable")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "convolution_overrideable.out(Tensor input, Tensor weight, Tensor? bias, SymInt[] stride, SymInt[] padding, SymInt[] dilation, bool transposed, SymInt[] output_padding, SymInt groups, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & input, const at::Tensor & weight, const c10::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & weight, const c10::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, at::Tensor & out);
+};
+
+}} // namespace at::_ops

shared/package-files/2e/2eabb41cdb7633a98cb0d49f3d7938f87853397075d0d4c49227a3abde1d063f/blob

@@ -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 avg_pool1d(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride={}, at::IntArrayRef padding=0, bool ceil_mode=false, bool count_include_pad=true);
+} // namespace native
+} // namespace at

shared/package-files/2e/2eabb4ac0bbc238804fe01626bb3b94c9711d1653350382481b886a819cb3640/blob

@@ -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 detach(const at::Tensor & self);
+TORCH_API at::Tensor & detach_(at::Tensor & self);
+} // namespace native
+} // namespace at

shared/package-files/2e/2ead4cdad023d0c362f960157422c50f36596e151be4090d0e1d3ccb83aefe15/blob

@@ -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/mps_convolution_backward_ops.h>
+
+namespace at {
+
+
+// aten::mps_convolution_backward(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
+inline ::std::tuple<at::Tensor,at::Tensor,at::Tensor> mps_convolution_backward(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array<bool,3> output_mask) {
+    return at::_ops::mps_convolution_backward::call(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  ::std::tuple<at::Tensor,at::Tensor,at::Tensor> mps_convolution_backward(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array<bool,3> output_mask) {
+    return at::_ops::mps_convolution_backward::call(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask);
+  }
+}
+
+// aten::mps_convolution_backward(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
+inline ::std::tuple<at::Tensor,at::Tensor,at::Tensor> mps_convolution_backward_symint(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask) {
+    return at::_ops::mps_convolution_backward::call(self, grad_output, weight, padding, stride, dilation, groups, output_mask);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  ::std::tuple<at::Tensor,at::Tensor,at::Tensor> mps_convolution_backward(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask) {
+    return at::_ops::mps_convolution_backward::call(self, grad_output, weight, padding, stride, dilation, groups, output_mask);
+  }
+}
+
+// aten::mps_convolution_backward.out(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
+inline ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mps_convolution_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array<bool,3> output_mask) {
+    return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask, out0, out1, out2);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mps_convolution_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array<bool,3> output_mask) {
+    return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask, out0, out1, out2);
+  }
+}
+
+// aten::mps_convolution_backward.out(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
+inline ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mps_convolution_backward_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
+    return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask, out0, out1, out2);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mps_convolution_backward_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
+    return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask, out0, out1, out2);
+  }
+}
+
+// aten::mps_convolution_backward.out(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
+inline ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mps_convolution_backward_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask) {
+    return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, padding, stride, dilation, groups, output_mask, out0, out1, out2);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mps_convolution_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask) {
+    return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, padding, stride, dilation, groups, output_mask, out0, out1, out2);
+  }
+}
+
+// aten::mps_convolution_backward.out(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
+inline ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mps_convolution_backward_symint_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
+    return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, padding, stride, dilation, groups, output_mask, out0, out1, out2);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mps_convolution_backward_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
+    return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, padding, stride, dilation, groups, output_mask, out0, out1, out2);
+  }
+}
+
+}

shared/package-files/2e/2eb0e1b96a4fa1f4fcc3edbaefaf5094c583a852ee0bcf8715b1cce911477b3b/blob

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2eb0e1b96a4fa1f4fcc3edbaefaf5094c583a852ee0bcf8715b1cce911477b3b
+size 5916984

shared/package-files/2e/2eb40044553fffc467aaf31fad117e24949cfd62b4dfd2a2d94dbad5e0f2151d/blob

@@ -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 at::Tensor view_as(const at::Tensor & self, const at::Tensor & other);
+
+} // namespace compositeimplicitautograd
+} // namespace at

shared/package-files/2e/2eb44462c9e559c11b14a7bc2c1d088a551566f12f76d73d3b9672326a8cd5c8/blob

@@ -0,0 +1,51 @@
+import copy
+import warnings
+from torch.utils.data.datapipes.datapipe import IterDataPipe
+
+__all__ = ["IterableWrapperIterDataPipe", ]
+
+
+class IterableWrapperIterDataPipe(IterDataPipe):
+    r"""
+    Wraps an iterable object to create an IterDataPipe.
+
+    Args:
+        iterable: Iterable object to be wrapped into an IterDataPipe
+        deepcopy: Option to deepcopy input iterable object for each
+            iterator. The copy is made when the first element is read in ``iter()``.
+
+    .. note::
+        If ``deepcopy`` is explicitly set to ``False``, users should ensure
+        that the data pipeline doesn't contain any in-place operations over
+        the iterable instance to prevent data inconsistency across iterations.
+
+    Example:
+        >>> # xdoctest: +SKIP
+        >>> from torchdata.datapipes.iter import IterableWrapper
+        >>> dp = IterableWrapper(range(10))
+        >>> list(dp)
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    """
+
+    def __init__(self, iterable, deepcopy=True):
+        self.iterable = iterable
+        self.deepcopy = deepcopy
+
+    def __iter__(self):
+        source_data = self.iterable
+        if self.deepcopy:
+            try:
+                source_data = copy.deepcopy(self.iterable)
+            # For the case that data cannot be deep-copied,
+            # all in-place operations will affect iterable variable.
+            # When this DataPipe is iterated second time, it will
+            # yield modified items.
+            except TypeError:
+                warnings.warn(
+                    "The input iterable can not be deepcopied, "
+                    "please be aware of in-place modification would affect source data."
+                )
+        yield from source_data
+
+    def __len__(self):
+        return len(self.iterable)

shared/package-files/2e/2eb6246b0764da26e8e0c408cdab10aff3cf03be070dbd5ad8c7dd2e79c470d2/blob

@@ -0,0 +1,555 @@
+#!/usr/bin/env python3
+
+# Copyright (c) Facebook, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import abc
+import logging
+import os
+import re
+import signal
+import subprocess
+import sys
+import time
+from contextlib import nullcontext
+from dataclasses import dataclass, field
+from enum import IntFlag
+from typing import Any, Callable, Dict, Optional, Set, Tuple, Union
+
+import torch.multiprocessing as mp
+from torchelastic.multiprocessing.errors import ProcessFailure, record
+from torchelastic.multiprocessing.redirects import redirect_stderr, redirect_stdout
+from torchelastic.multiprocessing.tail_log import TailLog
+
+log = logging.getLogger(__name__)
+
+
+def _validate_full_rank(d: Dict[int, Any], nprocs: int, what: str):
+    actual_keys = set(d.keys())
+    expected_keys = set(range(nprocs))
+
+    if actual_keys != expected_keys:
+        raise RuntimeError(
+            f"{what}, local rank mapping mismatch,"
+            f" expected: {expected_keys}, actual: {actual_keys}"
+        )
+
+
+_MAPPING_REGEX = r"^(\d:[0123],)*(\d:[0123])$"
+_VALUE_REGEX = r"^[0123]$"
+
+
+class Std(IntFlag):
+    NONE = 0
+    OUT = 1
+    ERR = 2
+    ALL = OUT | ERR
+
+    @classmethod
+    def from_str(cls, vm: str) -> Union["Std", Dict[int, "Std"]]:
+        """
+        Example:
+
+        ::
+
+         from_str("0") -> Std.NONE
+         from_str("1") -> Std.OUT
+         from_str("0:3,1:0,2:1,3:2") -> {0: Std.ALL, 1: Std.NONE, 2: Std.OUT, 3: Std.ERR}
+
+        Any other input raises an exception
+        """
+
+        def to_std(v):
+            v = int(v)
+            for s in Std:
+                if s == v:
+                    return s
+            # return None -> should NEVER reach here since we regex check input
+
+        if re.match(_VALUE_REGEX, vm):  # vm is a number (e.g. 0)
+            return to_std(vm)
+        elif re.match(_MAPPING_REGEX, vm):  # vm is a mapping (e.g. 0:1,1:2)
+            d: Dict[int, Std] = {}
+            for m in vm.split(","):
+                i, v = m.split(":")
+                d[int(i)] = to_std(v)
+            return d
+        else:
+            raise ValueError(
+                f"{vm} does not match: <{_VALUE_REGEX}> or <{_MAPPING_REGEX}>"
+            )
+
+
+def to_map(
+    val_or_map: Union[Std, Dict[int, Std]], local_world_size: int
+) -> Dict[int, Std]:
+    """
+    Certain APIs take redirect settings either as a single value (e.g. apply to all
+    local ranks) or as an explicit user-provided mapping. This method is a convenience
+    method that converts a value or mapping into a mapping.
+
+    Example:
+
+    ::
+
+     to_map(Std.OUT, local_world_size=2) # returns: {0: Std.OUT, 1: Std.OUT}
+     to_map({1: Std.OUT}, local_world_size=2) # returns: {0: Std.NONE, 1: Std.OUT}
+     to_map({0: Std.OUT, 1: Std.OUT}, local_world_size=2) # returns: {0: Std.OUT, 1: Std.OUT}
+    """
+    if isinstance(val_or_map, Std):
+        return {i: val_or_map for i in range(local_world_size)}
+    else:
+        map = {}
+        for i in range(local_world_size):
+            map[i] = val_or_map.get(i, Std.NONE)
+        return map
+
+
+@dataclass
+class RunProcsResult:
+    """
+    Results of a completed run of processes started with ``start_processes()``.
+    Returned by ``PContext``.
+
+    Note the following:
+
+    1. All fields are mapped by local rank
+    2. ``return_values`` - only populated for functions (not the binaries).
+    3. ``stdouts`` - path to stdout.log (empty string if no redirect)
+    4. ``stderrs`` - path to stderr.log (empty string if no redirect)
+
+    """
+
+    return_values: Dict[int, Any] = field(default_factory=dict)
+    failures: Dict[int, ProcessFailure] = field(default_factory=dict)
+    stdouts: Dict[int, str] = field(default_factory=dict)
+    stderrs: Dict[int, str] = field(default_factory=dict)
+
+    def is_failed(self) -> bool:
+        return len(self.failures) > 0
+
+
+class PContext(abc.ABC):
+    """
+    The base class that standardizes operations over a set of processes
+    that are launched via different mechanisms. The name ``PContext``
+    is intentional to disambiguate with ``torch.multiprocessing.ProcessContext``.
+
+    .. warning:: stdouts and stderrs should ALWAYS be a superset of
+                 tee_stdouts and tee_stderrs (respectively) this is b/c
+                 tee is implemented as a redirect + tail -f <stdout/stderr.log>
+    """
+
+    def __init__(
+        self,
+        name: str,
+        entrypoint: Union[Callable, str],
+        args: Dict[int, Tuple],
+        envs: Dict[int, Dict[str, str]],
+        stdouts: Dict[int, str],
+        stderrs: Dict[int, str],
+        tee_stdouts: Dict[int, str],
+        tee_stderrs: Dict[int, str],
+        error_files: Dict[int, str],
+    ):
+        self.name = name
+        # validate that all mappings have the same number of keys and
+        # all local ranks are accounted for
+        nprocs = len(args)
+        _validate_full_rank(stdouts, nprocs, "stdouts")
+        _validate_full_rank(stderrs, nprocs, "stderrs")
+
+        self.entrypoint = entrypoint
+        self.args = args
+        self.envs = envs
+        self.stdouts = stdouts
+        self.stderrs = stderrs
+        self.error_files = error_files
+        self.nprocs = nprocs
+
+        self._stdout_tail = TailLog(name, tee_stdouts, sys.stdout)
+        self._stderr_tail = TailLog(name, tee_stderrs, sys.stderr)
+
+    def start(self) -> None:
+        """
+        Start processes using parameters defined in the constructor.
+        """
+        self._start()
+        self._stdout_tail.start()
+        self._stderr_tail.start()
+
+    @abc.abstractmethod
+    def _start(self) -> None:
+        """
+        Start processes using strategy defined in a particular context.
+        """
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def _poll(self) -> Optional[RunProcsResult]:
+        """
+        Polls the run status of the processes running under this context.
+        This method follows an "all-or-nothing" policy and returns
+        a ``RunProcessResults`` object if either all processes complete
+        successfully or any process fails. Returns ``None`` if
+        all processes are still running.
+        """
+        raise NotImplementedError()
+
+    def wait(self, timeout: float = -1, period: float = 1) -> Optional[RunProcsResult]:
+        """
+        Waits for the specified ``timeout`` seconds, polling every ``period`` seconds
+        for the processes to be done. Returns ``None`` if the processes are still running
+        on timeout expiry. Negative timeout values are interpreted as "wait-forever".
+        A timeout value of zero simply queries the status of the processes (e.g. equivalent
+        to a poll).
+        """
+
+        if timeout == 0:
+            return self._poll()
+
+        if timeout < 0:
+            timeout = sys.maxsize
+
+        expiry = time.time() + timeout
+        while time.time() < expiry:
+            pr = self._poll()
+            if pr:
+                return pr
+            time.sleep(period)
+
+        return None
+
+    @abc.abstractmethod
+    def pids(self) -> Dict[int, int]:
+        """
+        Returns pids of processes mapped by their respective local_ranks
+        """
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def _close(self) -> None:
+        r"""
+        Terminates all processes managed by this context and cleans up any
+        meta resources (e.g. redirect, error_file files).
+        """
+        raise NotImplementedError()
+
+    def close(self) -> None:
+        self._close()
+        if self._stdout_tail:
+            self._stdout_tail.stop()
+        if self._stderr_tail:
+            self._stderr_tail.stop()
+
+
+def _wrap(
+    local_rank: int,
+    fn: Callable,
+    args: Dict[int, Tuple],
+    envs: Dict[int, Dict[str, str]],
+    stdout_redirects: Dict[int, str],  # redirect file for stdout (to console if None)
+    stderr_redirects: Dict[int, str],  # redirect file for stderr (to console if None)
+    ret_vals: Dict[int, mp.SimpleQueue],
+) -> None:
+    # get the per-rank params up front so we fail fast if no mapping is found
+    args_ = args[local_rank]
+    env_ = envs[local_rank]
+    ret_val_ = ret_vals[local_rank]
+
+    stdout_rd = stdout_redirects[local_rank]
+    stderr_rd = stderr_redirects[local_rank]
+
+    stdout_cm = redirect_stdout(stdout_rd) if stdout_rd else nullcontext()
+    stderr_cm = redirect_stderr(stderr_rd) if stderr_rd else nullcontext()
+
+    for k, v in env_.items():
+        os.environ[k] = v
+
+    with stdout_cm, stderr_cm:
+        ret = record(fn)(*args_)
+    ret_val_.put(ret)
+
+
+class MultiprocessContext(PContext):
+    """
+    ``PContext`` holding worker processes invoked as a function.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        entrypoint: Callable,
+        args: Dict[int, Tuple],
+        envs: Dict[int, Dict[str, str]],
+        stdouts: Dict[int, str],
+        stderrs: Dict[int, str],
+        tee_stdouts: Dict[int, str],
+        tee_stderrs: Dict[int, str],
+        error_files: Dict[int, str],
+        start_method: str,
+    ):
+        super().__init__(
+            name,
+            entrypoint,
+            args,
+            envs,
+            stdouts,
+            stderrs,
+            tee_stdouts,
+            tee_stderrs,
+            error_files,
+        )
+
+        self.start_method = start_method
+        # each ret_val queue will always contain a single element.
+        self._ret_vals = {
+            local_rank: mp.get_context(self.start_method).SimpleQueue()
+            for local_rank in range(self.nprocs)
+        }
+
+        # see comments in ``join()`` for what this is
+        self._return_values: Dict[int, Any] = {}
+        # pyre-fixme[8]: The attribute is defined in _start method
+        self._pc: mp.ProcessContext = None
+
+    def _start(self):
+        if self._pc:
+            raise ValueError(
+                "The process context already initialized. Most likely the start method got called twice."
+            )
+        self._pc: mp.ProcessContext = mp.start_processes(
+            fn=_wrap,
+            args=(
+                self.entrypoint,
+                self.args,
+                self.envs,
+                self.stdouts,
+                self.stderrs,
+                self._ret_vals,
+            ),
+            nprocs=self.nprocs,
+            join=False,
+            daemon=False,
+            start_method=self.start_method,
+        )
+
+    def _poll(self) -> Optional[RunProcsResult]:
+        try:
+            # torch.mp.ProcessContext returns True if all the workers have
+            # successfully finished, False if some/all are still running
+            # and throws an Exception if some/all of them failed
+            # timeout < 0 checks worker status and return immediately
+            done = self._pc.join(-1)
+
+            # IMPORTANT: we use multiprocessing.Queue to carry worker return values
+            # back to the parent, the worker process will wait before terminating
+            # until all the buffered items are fed by the feeder thread to the underlying
+            # pipe. Hence to prevent deadlocks on large return values,
+            # we opportunistically try queue.get on each join call
+            # See: https://docs.python.org/2/library/multiprocessing.html#all-platforms
+            for local_rank in range(0, self.nprocs):
+                return_queue = self._ret_vals[local_rank]
+                if not return_queue.empty():
+                    # save the return values temporarily into a member var
+                    self._return_values[local_rank] = return_queue.get()
+
+            if done:
+                # we should ALWAYS have ALL the return values when all the processes are done
+                _validate_full_rank(
+                    self._return_values, self.nprocs, "return_value queue"
+                )
+                self.close()
+                return RunProcsResult(
+                    return_values=self._return_values,
+                    stdouts=self.stdouts,
+                    stderrs=self.stderrs,
+                )
+            else:
+                return None
+        except (mp.ProcessRaisedException, mp.ProcessExitedException) as e:
+            failed_local_rank = e.error_index
+            # pyre-ignore entrypoint fn has a __qualname__.
+            fn_name = self.entrypoint.__qualname__
+            failed_proc = self._pc.processes[failed_local_rank]
+            error_filepath = self.error_files[failed_local_rank]
+
+            log.error(
+                f"failed (exitcode: {failed_proc.exitcode})"
+                f" local_rank: {failed_local_rank} (pid: {e.pid})"
+                f" of fn: {fn_name} (start_method: {self.start_method})",
+                exc_info=True,
+            )
+
+            self.close()
+            return RunProcsResult(
+                failures={
+                    failed_local_rank: ProcessFailure(
+                        local_rank=failed_local_rank,
+                        pid=e.pid,
+                        exitcode=failed_proc.exitcode,
+                        error_file=error_filepath,
+                    )
+                },
+                stdouts=self.stdouts,
+                stderrs=self.stderrs,
+            )
+
+    def pids(self) -> Dict[int, int]:
+        return {local_rank: pid for local_rank, pid in enumerate(self._pc.pids())}
+
+    def _close(self) -> None:
+        if self._pc:
+            for proc in self._pc.processes:
+                proc.terminate()
+                proc.join()
+
+
+class SubprocessHandler:
+    """
+    Convenience wrapper around python's ``subprocess.Popen``. Keeps track of
+    meta-objects associated to the process (e.g. stdout and stderr redirect fds).
+    """
+
+    def __init__(
+        self,
+        entrypoint: str,
+        args: Tuple,
+        env: Dict[str, str],
+        preexec_fn: Callable,
+        stdout: str,
+        stderr: str,
+    ):
+        self._stdout = open(stdout, "w") if stdout else None
+        self._stderr = open(stderr, "w") if stderr else None
+        args_str = [str(e) for e in args]
+
+        # inherit parent environment vars
+        env_vars = os.environ.copy()
+        env_vars.update(env)
+
+        self.proc: subprocess.Popen = subprocess.Popen(
+            args=(entrypoint, *args_str),
+            env=env_vars,
+            preexec_fn=preexec_fn,
+            stdout=self._stdout,
+            stderr=self._stderr,
+        )
+
+    def close(self):
+        self.proc.terminate()
+        self.proc.wait()
+        if self._stdout:
+            self._stdout.close()
+        if self._stderr:
+            self._stderr.close()
+
+
+class SubprocessContext(PContext):
+    """
+    ``PContext`` holding worker processes invoked as a binary.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        entrypoint: str,
+        args: Dict[int, Tuple],
+        envs: Dict[int, Dict[str, str]],
+        stdouts: Dict[int, str],
+        stderrs: Dict[int, str],
+        tee_stdouts: Dict[int, str],
+        tee_stderrs: Dict[int, str],
+        error_files: Dict[int, str],
+    ):
+        super().__init__(
+            name,
+            entrypoint,
+            args,
+            envs,
+            stdouts,
+            stderrs,
+            tee_stdouts,
+            tee_stderrs,
+            error_files,
+        )
+
+        # state vector; _vdone[local_rank] -> is local_rank finished or not
+        self._running_local_ranks: Set[int] = set(range(self.nprocs))
+        self._failures: Dict[int, ProcessFailure] = {}
+        # pyre-fixme[8]: The attribute is defined in _start method
+        self.subprocess_handlers: Dict[int, SubprocessHandler] = None
+
+    def _start(self):
+        if self.subprocess_handlers:
+            raise ValueError(
+                "The subprocess handlers already initialized. Most likely the start method got called twice."
+            )
+        self.subprocess_handlers: Dict[int, SubprocessHandler] = {
+            local_rank: SubprocessHandler(
+                entrypoint=self.entrypoint,
+                args=self.args[local_rank],
+                env=self.envs[local_rank],
+                preexec_fn=mp._prctl_pr_set_pdeathsig(signal.SIGTERM),
+                stdout=self.stdouts[local_rank],
+                stderr=self.stderrs[local_rank],
+            )
+            for local_rank in range(self.nprocs)
+        }
+
+    def _poll(self) -> Optional[RunProcsResult]:
+        done_local_ranks = set()
+        for local_rank in self._running_local_ranks:
+            handler = self.subprocess_handlers[local_rank]
+            exitcode = handler.proc.poll()
+            if exitcode is not None:
+                done_local_ranks.add(local_rank)
+                if exitcode != 0:  # failed or signaled
+                    self._failures[local_rank] = ProcessFailure(
+                        local_rank=local_rank,
+                        pid=handler.proc.pid,
+                        exitcode=exitcode,
+                        error_file=self.error_files[local_rank],
+                    )
+                # else: --> succeeded; nothing to do
+
+        self._running_local_ranks.difference_update(done_local_ranks)
+
+        # if ALL procs are finished or ANY have failed
+        if not self._running_local_ranks or self._failures:
+            self.close()  # terminate all running procs
+            result = RunProcsResult(
+                failures=self._failures,
+                stdouts=self.stdouts,
+                stderrs=self.stderrs,
+            )
+            if result.is_failed():
+                first_failure = min(result.failures.values(), key=lambda f: f.timestamp)
+                log.error(
+                    f"failed (exitcode: {first_failure.exitcode})"
+                    f" local_rank: {first_failure.local_rank} (pid: {first_failure.pid})"
+                    f" of binary: {self.entrypoint}"
+                )
+            else:
+                # Populate return with dummy values. This provides consistency with MultiprocessingHandler
+                result.return_values = {
+                    local_rank: None for local_rank in range(self.nprocs)
+                }
+
+            return result
+        else:  # there are no failures and procs still running
+            return None
+
+    def pids(self) -> Dict[int, int]:
+        return {
+            local_rank: sh.proc.pid
+            for local_rank, sh in self.subprocess_handlers.items()
+        }
+
+    def _close(self) -> None:
+        if self.subprocess_handlers:
+            for handler in self.subprocess_handlers.values():
+                handler.close()

shared/package-files/2e/2eb9c84a7741917b5dba0bce59e464f59198425ced148e72ab2b6869988a3909/blob

@@ -0,0 +1,19 @@
+#define TORCH_ASSERT_NO_OPERATORS
+
+#include <ATen/native/DispatchStub.h>
+#include <ATen/TensorIterator.h>
+#include <ATen/TensorMeta.h>
+
+namespace at {
+
+// NB: this is explicitly copied here (via codegen) rather than
+// included via NativeFunctions.h to avoid recompiling this file when
+// NativeFunctions.h changes
+namespace meta {
+${meta_declaration}
+}
+
+namespace native {
+${native_declaration}
+${native_definitions}
+}} // namespace at::native

shared/package-files/2e/2ebd6a872ab2c28a1b3648fdb007dda2fa05cbdbc17e4cf678775309ceec651b/blob

@@ -0,0 +1,307 @@
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2003-2017 Nominum, Inc.
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose with or without fee is hereby granted,
+# provided that the above copyright notice and this permission notice
+# appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+import itertools
+
+
+class Set:
+    """A simple set class.
+
+    This class was originally used to deal with sets being missing in
+    ancient versions of python, but dnspython will continue to use it
+    as these sets are based on lists and are thus indexable, and this
+    ability is widely used in dnspython applications.
+    """
+
+    __slots__ = ["items"]
+
+    def __init__(self, items=None):
+        """Initialize the set.
+
+        *items*, an iterable or ``None``, the initial set of items.
+        """
+
+        self.items = dict()
+        if items is not None:
+            for item in items:
+                # This is safe for how we use set, but if other code
+                # subclasses it could be a legitimate issue.
+                self.add(item)  # lgtm[py/init-calls-subclass]
+
+    def __repr__(self):
+        return "dns.set.Set(%s)" % repr(list(self.items.keys()))
+
+    def add(self, item):
+        """Add an item to the set."""
+
+        if item not in self.items:
+            self.items[item] = None
+
+    def remove(self, item):
+        """Remove an item from the set."""
+
+        try:
+            del self.items[item]
+        except KeyError:
+            raise ValueError
+
+    def discard(self, item):
+        """Remove an item from the set if present."""
+
+        self.items.pop(item, None)
+
+    def pop(self):
+        """Remove an arbitrary item from the set."""
+        (k, _) = self.items.popitem()
+        return k
+
+    def _clone(self) -> "Set":
+        """Make a (shallow) copy of the set.
+
+        There is a 'clone protocol' that subclasses of this class
+        should use.  To make a copy, first call your super's _clone()
+        method, and use the object returned as the new instance.  Then
+        make shallow copies of the attributes defined in the subclass.
+
+        This protocol allows us to write the set algorithms that
+        return new instances (e.g. union) once, and keep using them in
+        subclasses.
+        """
+
+        if hasattr(self, "_clone_class"):
+            cls = self._clone_class  # type: ignore
+        else:
+            cls = self.__class__
+        obj = cls.__new__(cls)
+        obj.items = dict()
+        obj.items.update(self.items)
+        return obj
+
+    def __copy__(self):
+        """Make a (shallow) copy of the set."""
+
+        return self._clone()
+
+    def copy(self):
+        """Make a (shallow) copy of the set."""
+
+        return self._clone()
+
+    def union_update(self, other):
+        """Update the set, adding any elements from other which are not
+        already in the set.
+        """
+
+        if not isinstance(other, Set):
+            raise ValueError("other must be a Set instance")
+        if self is other:  # lgtm[py/comparison-using-is]
+            return
+        for item in other.items:
+            self.add(item)
+
+    def intersection_update(self, other):
+        """Update the set, removing any elements from other which are not
+        in both sets.
+        """
+
+        if not isinstance(other, Set):
+            raise ValueError("other must be a Set instance")
+        if self is other:  # lgtm[py/comparison-using-is]
+            return
+        # we make a copy of the list so that we can remove items from
+        # the list without breaking the iterator.
+        for item in list(self.items):
+            if item not in other.items:
+                del self.items[item]
+
+    def difference_update(self, other):
+        """Update the set, removing any elements from other which are in
+        the set.
+        """
+
+        if not isinstance(other, Set):
+            raise ValueError("other must be a Set instance")
+        if self is other:  # lgtm[py/comparison-using-is]
+            self.items.clear()
+        else:
+            for item in other.items:
+                self.discard(item)
+
+    def symmetric_difference_update(self, other):
+        """Update the set, retaining only elements unique to both sets."""
+
+        if not isinstance(other, Set):
+            raise ValueError("other must be a Set instance")
+        if self is other:  # lgtm[py/comparison-using-is]
+            self.items.clear()
+        else:
+            overlap = self.intersection(other)
+            self.union_update(other)
+            self.difference_update(overlap)
+
+    def union(self, other):
+        """Return a new set which is the union of ``self`` and ``other``.
+
+        Returns the same Set type as this set.
+        """
+
+        obj = self._clone()
+        obj.union_update(other)
+        return obj
+
+    def intersection(self, other):
+        """Return a new set which is the intersection of ``self`` and
+        ``other``.
+
+        Returns the same Set type as this set.
+        """
+
+        obj = self._clone()
+        obj.intersection_update(other)
+        return obj
+
+    def difference(self, other):
+        """Return a new set which ``self`` - ``other``, i.e. the items
+        in ``self`` which are not also in ``other``.
+
+        Returns the same Set type as this set.
+        """
+
+        obj = self._clone()
+        obj.difference_update(other)
+        return obj
+
+    def symmetric_difference(self, other):
+        """Return a new set which (``self`` - ``other``) | (``other``
+        - ``self), ie: the items in either ``self`` or ``other`` which
+        are not contained in their intersection.
+
+        Returns the same Set type as this set.
+        """
+
+        obj = self._clone()
+        obj.symmetric_difference_update(other)
+        return obj
+
+    def __or__(self, other):
+        return self.union(other)
+
+    def __and__(self, other):
+        return self.intersection(other)
+
+    def __add__(self, other):
+        return self.union(other)
+
+    def __sub__(self, other):
+        return self.difference(other)
+
+    def __xor__(self, other):
+        return self.symmetric_difference(other)
+
+    def __ior__(self, other):
+        self.union_update(other)
+        return self
+
+    def __iand__(self, other):
+        self.intersection_update(other)
+        return self
+
+    def __iadd__(self, other):
+        self.union_update(other)
+        return self
+
+    def __isub__(self, other):
+        self.difference_update(other)
+        return self
+
+    def __ixor__(self, other):
+        self.symmetric_difference_update(other)
+        return self
+
+    def update(self, other):
+        """Update the set, adding any elements from other which are not
+        already in the set.
+
+        *other*, the collection of items with which to update the set, which
+        may be any iterable type.
+        """
+
+        for item in other:
+            self.add(item)
+
+    def clear(self):
+        """Make the set empty."""
+        self.items.clear()
+
+    def __eq__(self, other):
+        return self.items == other.items
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __len__(self):
+        return len(self.items)
+
+    def __iter__(self):
+        return iter(self.items)
+
+    def __getitem__(self, i):
+        if isinstance(i, slice):
+            return list(itertools.islice(self.items, i.start, i.stop, i.step))
+        else:
+            return next(itertools.islice(self.items, i, i + 1))
+
+    def __delitem__(self, i):
+        if isinstance(i, slice):
+            for elt in list(self[i]):
+                del self.items[elt]
+        else:
+            del self.items[self[i]]
+
+    def issubset(self, other):
+        """Is this set a subset of *other*?
+
+        Returns a ``bool``.
+        """
+
+        if not isinstance(other, Set):
+            raise ValueError("other must be a Set instance")
+        for item in self.items:
+            if item not in other.items:
+                return False
+        return True
+
+    def issuperset(self, other):
+        """Is this set a superset of *other*?
+
+        Returns a ``bool``.
+        """
+
+        if not isinstance(other, Set):
+            raise ValueError("other must be a Set instance")
+        for item in other.items:
+            if item not in self.items:
+                return False
+        return True
+
+    def isdisjoint(self, other):
+        if not isinstance(other, Set):
+            raise ValueError("other must be a Set instance")
+        for item in other.items:
+            if item in self.items:
+                return False
+        return True

shared/package-files/2e/2ebdb2ff589719bc9cd931b5d7f2dec8183b217151fbed270d48fbd8a30d69a5/blob

@@ -0,0 +1,540 @@
+# -*- coding: utf-8 -*-
+"""
+Defines a variety of Pygments lexers for highlighting IPython code.
+
+This includes:
+
+    IPythonLexer, IPython3Lexer
+        Lexers for pure IPython (python + magic/shell commands)
+
+    IPythonPartialTracebackLexer, IPythonTracebackLexer
+        Supports 2.x and 3.x via keyword `python3`.  The partial traceback
+        lexer reads everything but the Python code appearing in a traceback.
+        The full lexer combines the partial lexer with an IPython lexer.
+
+    IPythonConsoleLexer
+        A lexer for IPython console sessions, with support for tracebacks.
+
+    IPyLexer
+        A friendly lexer which examines the first line of text and from it,
+        decides whether to use an IPython lexer or an IPython console lexer.
+        This is probably the only lexer that needs to be explicitly added
+        to Pygments.
+
+"""
+#-----------------------------------------------------------------------------
+# Copyright (c) 2013, the IPython Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+# Standard library
+import re
+
+# Third party
+from pygments.lexers import (
+    BashLexer, HtmlLexer, JavascriptLexer, RubyLexer, PerlLexer, PythonLexer,
+    Python3Lexer, TexLexer)
+from pygments.lexer import (
+    Lexer, DelegatingLexer, RegexLexer, do_insertions, bygroups, using,
+)
+from pygments.token import (
+    Generic, Keyword, Literal, Name, Operator, Other, Text, Error,
+)
+from pygments.util import get_bool_opt
+
+# Local
+
+line_re = re.compile('.*?\n')
+
+__all__ = ['build_ipy_lexer', 'IPython3Lexer', 'IPythonLexer',
+           'IPythonPartialTracebackLexer', 'IPythonTracebackLexer',
+           'IPythonConsoleLexer', 'IPyLexer']
+
+
+def build_ipy_lexer(python3):
+    """Builds IPython lexers depending on the value of `python3`.
+
+    The lexer inherits from an appropriate Python lexer and then adds
+    information about IPython specific keywords (i.e. magic commands,
+    shell commands, etc.)
+
+    Parameters
+    ----------
+    python3 : bool
+        If `True`, then build an IPython lexer from a Python 3 lexer.
+
+    """
+    # It would be nice to have a single IPython lexer class which takes
+    # a boolean `python3`.  But since there are two Python lexer classes,
+    # we will also have two IPython lexer classes.
+    if python3:
+        PyLexer = Python3Lexer
+        name = 'IPython3'
+        aliases = ['ipython3']
+        doc = """IPython3 Lexer"""
+    else:
+        PyLexer = PythonLexer
+        name = 'IPython'
+        aliases = ['ipython2', 'ipython']
+        doc = """IPython Lexer"""
+
+    ipython_tokens = [
+       (r'(?s)(\s*)(%%capture)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
+        (r'(?s)(\s*)(%%debug)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
+        (r'(?is)(\s*)(%%html)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(HtmlLexer))),
+        (r'(?s)(\s*)(%%javascript)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(JavascriptLexer))),
+        (r'(?s)(\s*)(%%js)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(JavascriptLexer))),
+        (r'(?s)(\s*)(%%latex)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(TexLexer))),
+        (r'(?s)(\s*)(%%perl)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PerlLexer))),
+        (r'(?s)(\s*)(%%prun)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
+        (r'(?s)(\s*)(%%pypy)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
+        (r'(?s)(\s*)(%%python)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
+        (r'(?s)(\s*)(%%python2)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PythonLexer))),
+        (r'(?s)(\s*)(%%python3)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(Python3Lexer))),
+        (r'(?s)(\s*)(%%ruby)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(RubyLexer))),
+        (r'(?s)(\s*)(%%time)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
+        (r'(?s)(\s*)(%%timeit)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
+        (r'(?s)(\s*)(%%writefile)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
+        (r'(?s)(\s*)(%%file)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
+        (r"(?s)(\s*)(%%)(\w+)(.*)", bygroups(Text, Operator, Keyword, Text)),
+        (r'(?s)(^\s*)(%%!)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(BashLexer))),
+        (r"(%%?)(\w+)(\?\??)$",  bygroups(Operator, Keyword, Operator)),
+        (r"\b(\?\??)(\s*)$",  bygroups(Operator, Text)),
+        (r'(%)(sx|sc|system)(.*)(\n)', bygroups(Operator, Keyword,
+                                                using(BashLexer), Text)),
+        (r'(%)(\w+)(.*\n)', bygroups(Operator, Keyword, Text)),
+        (r'^(!!)(.+)(\n)', bygroups(Operator, using(BashLexer), Text)),
+        (r'(!)(?!=)(.+)(\n)', bygroups(Operator, using(BashLexer), Text)),
+        (r'^(\s*)(\?\??)(\s*%{0,2}[\w\.\*]*)', bygroups(Text, Operator, Text)),
+        (r'(\s*%{0,2}[\w\.\*]*)(\?\??)(\s*)$', bygroups(Text, Operator, Text)),
+    ]
+
+    tokens = PyLexer.tokens.copy()
+    tokens['root'] = ipython_tokens + tokens['root']
+
+    attrs = {'name': name, 'aliases': aliases, 'filenames': [],
+             '__doc__': doc, 'tokens': tokens}
+
+    return type(name, (PyLexer,), attrs)
+
+
+IPython3Lexer = build_ipy_lexer(python3=True)
+IPythonLexer = build_ipy_lexer(python3=False)
+
+
+class IPythonPartialTracebackLexer(RegexLexer):
+    """
+    Partial lexer for IPython tracebacks.
+
+    Handles all the non-python output.
+
+    """
+    name = 'IPython Partial Traceback'
+
+    tokens = {
+        'root': [
+            # Tracebacks for syntax errors have a different style.
+            # For both types of tracebacks, we mark the first line with
+            # Generic.Traceback.  For syntax errors, we mark the filename
+            # as we mark the filenames for non-syntax tracebacks.
+            #
+            # These two regexps define how IPythonConsoleLexer finds a
+            # traceback.
+            #
+            ## Non-syntax traceback
+            (r'^(\^C)?(-+\n)', bygroups(Error, Generic.Traceback)),
+            ## Syntax traceback
+            (r'^(  File)(.*)(, line )(\d+\n)',
+             bygroups(Generic.Traceback, Name.Namespace,
+                      Generic.Traceback, Literal.Number.Integer)),
+
+            # (Exception Identifier)(Whitespace)(Traceback Message)
+            (r'(?u)(^[^\d\W]\w*)(\s*)(Traceback.*?\n)',
+             bygroups(Name.Exception, Generic.Whitespace, Text)),
+            # (Module/Filename)(Text)(Callee)(Function Signature)
+            # Better options for callee and function signature?
+            (r'(.*)( in )(.*)(\(.*\)\n)',
+             bygroups(Name.Namespace, Text, Name.Entity, Name.Tag)),
+            # Regular line: (Whitespace)(Line Number)(Python Code)
+            (r'(\s*?)(\d+)(.*?\n)',
+             bygroups(Generic.Whitespace, Literal.Number.Integer, Other)),
+            # Emphasized line: (Arrow)(Line Number)(Python Code)
+            # Using Exception token so arrow color matches the Exception.
+            (r'(-*>?\s?)(\d+)(.*?\n)',
+             bygroups(Name.Exception, Literal.Number.Integer, Other)),
+            # (Exception Identifier)(Message)
+            (r'(?u)(^[^\d\W]\w*)(:.*?\n)',
+             bygroups(Name.Exception, Text)),
+            # Tag everything else as Other, will be handled later.
+            (r'.*\n', Other),
+        ],
+    }
+
+
+class IPythonTracebackLexer(DelegatingLexer):
+    """
+    IPython traceback lexer.
+
+    For doctests, the tracebacks can be snipped as much as desired with the
+    exception to the lines that designate a traceback. For non-syntax error
+    tracebacks, this is the line of hyphens. For syntax error tracebacks,
+    this is the line which lists the File and line number.
+
+    """
+    # The lexer inherits from DelegatingLexer.  The "root" lexer is an
+    # appropriate IPython lexer, which depends on the value of the boolean
+    # `python3`.  First, we parse with the partial IPython traceback lexer.
+    # Then, any code marked with the "Other" token is delegated to the root
+    # lexer.
+    #
+    name = 'IPython Traceback'
+    aliases = ['ipythontb']
+
+    def __init__(self, **options):
+        """
+        A subclass of `DelegatingLexer` which delegates to the appropriate to either IPyLexer,
+        IPythonPartialTracebackLexer.
+        """
+        # note we need a __init__ doc, as otherwise it inherits the doc from the super class
+        # which will fail the documentation build as it references section of the pygments docs that
+        # do not exists when building IPython's docs.
+        self.python3 = get_bool_opt(options, 'python3', False)
+        if self.python3:
+            self.aliases = ['ipython3tb']
+        else:
+            self.aliases = ['ipython2tb', 'ipythontb']
+
+        if self.python3:
+            IPyLexer = IPython3Lexer
+        else:
+            IPyLexer = IPythonLexer
+
+        DelegatingLexer.__init__(self, IPyLexer,
+                                 IPythonPartialTracebackLexer, **options)
+
+class IPythonConsoleLexer(Lexer):
+    """
+    An IPython console lexer for IPython code-blocks and doctests, such as:
+
+    .. code-block:: rst
+
+        .. code-block:: ipythonconsole
+
+            In [1]: a = 'foo'
+
+            In [2]: a
+            Out[2]: 'foo'
+
+            In [3]: print(a)
+            foo
+
+
+    Support is also provided for IPython exceptions:
+
+    .. code-block:: rst
+
+        .. code-block:: ipythonconsole
+
+            In [1]: raise Exception
+            Traceback (most recent call last):
+            ...
+            Exception
+
+    """
+    name = 'IPython console session'
+    aliases = ['ipythonconsole']
+    mimetypes = ['text/x-ipython-console']
+
+    # The regexps used to determine what is input and what is output.
+    # The default prompts for IPython are:
+    #
+    #    in           = 'In [#]: '
+    #    continuation = '   .D.: '
+    #    template     = 'Out[#]: '
+    #
+    # Where '#' is the 'prompt number' or 'execution count' and 'D' 
+    # D is a number of dots  matching the width of the execution count 
+    #
+    in1_regex = r'In \[[0-9]+\]: '
+    in2_regex = r'   \.\.+\.: '
+    out_regex = r'Out\[[0-9]+\]: '
+
+    #: The regex to determine when a traceback starts.
+    ipytb_start = re.compile(r'^(\^C)?(-+\n)|^(  File)(.*)(, line )(\d+\n)')
+
+    def __init__(self, **options):
+        """Initialize the IPython console lexer.
+
+        Parameters
+        ----------
+        python3 : bool
+            If `True`, then the console inputs are parsed using a Python 3
+            lexer. Otherwise, they are parsed using a Python 2 lexer.
+        in1_regex : RegexObject
+            The compiled regular expression used to detect the start
+            of inputs. Although the IPython configuration setting may have a
+            trailing whitespace, do not include it in the regex. If `None`,
+            then the default input prompt is assumed.
+        in2_regex : RegexObject
+            The compiled regular expression used to detect the continuation
+            of inputs. Although the IPython configuration setting may have a
+            trailing whitespace, do not include it in the regex. If `None`,
+            then the default input prompt is assumed.
+        out_regex : RegexObject
+            The compiled regular expression used to detect outputs. If `None`,
+            then the default output prompt is assumed.
+
+        """
+        self.python3 = get_bool_opt(options, 'python3', False)
+        if self.python3:
+            self.aliases = ['ipython3console']
+        else:
+            self.aliases = ['ipython2console', 'ipythonconsole']
+
+        in1_regex = options.get('in1_regex', self.in1_regex)
+        in2_regex = options.get('in2_regex', self.in2_regex)
+        out_regex = options.get('out_regex', self.out_regex)
+
+        # So that we can work with input and output prompts which have been
+        # rstrip'd (possibly by editors) we also need rstrip'd variants. If
+        # we do not do this, then such prompts will be tagged as 'output'.
+        # The reason can't just use the rstrip'd variants instead is because
+        # we want any whitespace associated with the prompt to be inserted
+        # with the token. This allows formatted code to be modified so as hide
+        # the appearance of prompts, with the whitespace included. One example
+        # use of this is in copybutton.js from the standard lib Python docs.
+        in1_regex_rstrip = in1_regex.rstrip() + '\n'
+        in2_regex_rstrip = in2_regex.rstrip() + '\n'
+        out_regex_rstrip = out_regex.rstrip() + '\n'
+
+        # Compile and save them all.
+        attrs = ['in1_regex', 'in2_regex', 'out_regex',
+                 'in1_regex_rstrip', 'in2_regex_rstrip', 'out_regex_rstrip']
+        for attr in attrs:
+            self.__setattr__(attr, re.compile(locals()[attr]))
+
+        Lexer.__init__(self, **options)
+
+        if self.python3:
+            pylexer = IPython3Lexer
+            tblexer = IPythonTracebackLexer
+        else:
+            pylexer = IPythonLexer
+            tblexer = IPythonTracebackLexer
+
+        self.pylexer = pylexer(**options)
+        self.tblexer = tblexer(**options)
+
+        self.reset()
+
+    def reset(self):
+        self.mode = 'output'
+        self.index = 0
+        self.buffer = u''
+        self.insertions = []
+
+    def buffered_tokens(self):
+        """
+        Generator of unprocessed tokens after doing insertions and before
+        changing to a new state.
+
+        """
+        if self.mode == 'output':
+            tokens = [(0, Generic.Output, self.buffer)]
+        elif self.mode == 'input':
+            tokens = self.pylexer.get_tokens_unprocessed(self.buffer)
+        else: # traceback
+            tokens = self.tblexer.get_tokens_unprocessed(self.buffer)
+
+        for i, t, v in do_insertions(self.insertions, tokens):
+            # All token indexes are relative to the buffer.
+            yield self.index + i, t, v
+
+        # Clear it all
+        self.index += len(self.buffer)
+        self.buffer = u''
+        self.insertions = []
+
+    def get_mci(self, line):
+        """
+        Parses the line and returns a 3-tuple: (mode, code, insertion).
+
+        `mode` is the next mode (or state) of the lexer, and is always equal
+        to 'input', 'output', or 'tb'.
+
+        `code` is a portion of the line that should be added to the buffer
+        corresponding to the next mode and eventually lexed by another lexer.
+        For example, `code` could be Python code if `mode` were 'input'.
+
+        `insertion` is a 3-tuple (index, token, text) representing an
+        unprocessed "token" that will be inserted into the stream of tokens
+        that are created from the buffer once we change modes. This is usually
+        the input or output prompt.
+
+        In general, the next mode depends on current mode and on the contents
+        of `line`.
+
+        """
+        # To reduce the number of regex match checks, we have multiple
+        # 'if' blocks instead of 'if-elif' blocks.
+
+        # Check for possible end of input
+        in2_match = self.in2_regex.match(line)
+        in2_match_rstrip = self.in2_regex_rstrip.match(line)
+        if (in2_match and in2_match.group().rstrip() == line.rstrip()) or \
+           in2_match_rstrip:
+            end_input = True
+        else:
+            end_input = False
+        if end_input and self.mode != 'tb':
+            # Only look for an end of input when not in tb mode.
+            # An ellipsis could appear within the traceback.
+            mode = 'output'
+            code = u''
+            insertion = (0, Generic.Prompt, line)
+            return mode, code, insertion
+
+        # Check for output prompt
+        out_match = self.out_regex.match(line)
+        out_match_rstrip = self.out_regex_rstrip.match(line)
+        if out_match or out_match_rstrip:
+            mode = 'output'
+            if out_match:
+                idx = out_match.end()
+            else:
+                idx = out_match_rstrip.end()
+            code = line[idx:]
+            # Use the 'heading' token for output.  We cannot use Generic.Error
+            # since it would conflict with exceptions.
+            insertion = (0, Generic.Heading, line[:idx])
+            return mode, code, insertion
+
+
+        # Check for input or continuation prompt (non stripped version)
+        in1_match = self.in1_regex.match(line)
+        if in1_match or (in2_match and self.mode != 'tb'):
+            # New input or when not in tb, continued input.
+            # We do not check for continued input when in tb since it is
+            # allowable to replace a long stack with an ellipsis.
+            mode = 'input'
+            if in1_match:
+                idx = in1_match.end()
+            else: # in2_match
+                idx = in2_match.end()
+            code = line[idx:]
+            insertion = (0, Generic.Prompt, line[:idx])
+            return mode, code, insertion
+
+        # Check for input or continuation prompt (stripped version)
+        in1_match_rstrip = self.in1_regex_rstrip.match(line)
+        if in1_match_rstrip or (in2_match_rstrip and self.mode != 'tb'):
+            # New input or when not in tb, continued input.
+            # We do not check for continued input when in tb since it is
+            # allowable to replace a long stack with an ellipsis.
+            mode = 'input'
+            if in1_match_rstrip:
+                idx = in1_match_rstrip.end()
+            else: # in2_match
+                idx = in2_match_rstrip.end()
+            code = line[idx:]
+            insertion = (0, Generic.Prompt, line[:idx])
+            return mode, code, insertion
+
+        # Check for traceback
+        if self.ipytb_start.match(line):
+            mode = 'tb'
+            code = line
+            insertion = None
+            return mode, code, insertion
+
+        # All other stuff...
+        if self.mode in ('input', 'output'):
+            # We assume all other text is output. Multiline input that
+            # does not use the continuation marker cannot be detected.
+            # For example, the 3 in the following is clearly output:
+            #
+            #    In [1]: print 3
+            #    3
+            #
+            # But the following second line is part of the input:
+            #
+            #    In [2]: while True:
+            #        print True
+            #
+            # In both cases, the 2nd line will be 'output'.
+            #
+            mode = 'output'
+        else:
+            mode = 'tb'
+
+        code = line
+        insertion = None
+
+        return mode, code, insertion
+
+    def get_tokens_unprocessed(self, text):
+        self.reset()
+        for match in line_re.finditer(text):
+            line = match.group()
+            mode, code, insertion = self.get_mci(line)
+
+            if mode != self.mode:
+                # Yield buffered tokens before transitioning to new mode.
+                for token in self.buffered_tokens():
+                    yield token
+                self.mode = mode
+
+            if insertion:
+                self.insertions.append((len(self.buffer), [insertion]))
+            self.buffer += code
+
+        for token in self.buffered_tokens():
+            yield token
+
+class IPyLexer(Lexer):
+    r"""
+    Primary lexer for all IPython-like code.
+
+    This is a simple helper lexer.  If the first line of the text begins with
+    "In \[[0-9]+\]:", then the entire text is parsed with an IPython console
+    lexer. If not, then the entire text is parsed with an IPython lexer.
+
+    The goal is to reduce the number of lexers that are registered
+    with Pygments.
+
+    """
+    name = 'IPy session'
+    aliases = ['ipy']
+
+    def __init__(self, **options):
+        """
+        Create a new IPyLexer instance which dispatch to either an
+        IPythonCOnsoleLexer (if In prompts are present) or and IPythonLexer (if
+        In prompts are not present).
+        """
+        # init docstring is necessary for docs not to fail to build do to parent
+        # docs referenceing a section in pygments docs.
+        self.python3 = get_bool_opt(options, 'python3', False)
+        if self.python3:
+            self.aliases = ['ipy3']
+        else:
+            self.aliases = ['ipy2', 'ipy']
+
+        Lexer.__init__(self, **options)
+
+        self.IPythonLexer = IPythonLexer(**options)
+        self.IPythonConsoleLexer = IPythonConsoleLexer(**options)
+
+    def get_tokens_unprocessed(self, text):
+        # Search for the input prompt anywhere...this allows code blocks to
+        # begin with comments as well.
+        if re.match(r'.*(In \[[0-9]+\]:)', text.strip(), re.DOTALL):
+            lex = self.IPythonConsoleLexer
+        else:
+            lex = self.IPythonLexer
+        for token in lex.get_tokens_unprocessed(text):
+            yield token
+

shared/package-files/2e/2ec42712829628685d7aa1a131cebc02ac33e0cad39c4b36d0a0186c58941f3a/blob

@@ -0,0 +1,28 @@
+###############################################################################
+# Modification of concurrent.futures.Future
+#
+# author: Thomas Moreau and Olivier Grisel
+#
+# adapted from concurrent/futures/_base.py (17/02/2017)
+#  * Do not use yield from
+#  * Use old super syntax
+#
+# Copyright 2009 Brian Quinlan. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+from concurrent.futures import Future as _BaseFuture
+from concurrent.futures._base import LOGGER
+
+
+# To make loky._base.Future instances awaitable  by concurrent.futures.wait,
+# derive our custom Future class from _BaseFuture. _invoke_callback is the only
+# modification made to this class in loky.
+# TODO investigate why using `concurrent.futures.Future` directly does not
+# always work in our test suite.
+class Future(_BaseFuture):
+    def _invoke_callbacks(self):
+        for callback in self._done_callbacks:
+            try:
+                callback(self)
+            except BaseException:
+                LOGGER.exception(f"exception calling callback for {self!r}")

shared/package-files/2e/2ec7d9373df55b89d3f35d5c1ebb6f82a85598f4e0f6b062a189c1781010379b/blob

@@ -0,0 +1,264 @@
+"""
+Tests for numba.core.codegen.
+"""
+
+
+import warnings
+import base64
+import ctypes
+import pickle
+import re
+import subprocess
+import sys
+import weakref
+
+import llvmlite.binding as ll
+
+import unittest
+from numba import njit
+from numba.core.codegen import JITCPUCodegen
+from numba.core.compiler_lock import global_compiler_lock
+from numba.tests.support import TestCase
+
+
+asm_sum = r"""
+    define i32 @sum(i32 %.1, i32 %.2) {
+      %.3 = add i32 %.1, %.2
+      ret i32 %.3
+    }
+    """
+
+# Note we're using a rather mangled function name to check that it
+# is compatible with object serialization.
+
+asm_sum_inner = """
+    define i32 @"__main__.ising_element_update$1.array(int8,_2d,_C).int64.int64"(i32 %.1, i32 %.2) {
+      %.3 = add i32 %.1, %.2
+      ret i32 %.3
+    }
+"""    # noqa: E501
+
+asm_sum_outer = """
+    declare i32 @"__main__.ising_element_update$1.array(int8,_2d,_C).int64.int64"(i32 %.1, i32 %.2)
+
+    define i32 @sum(i32 %.1, i32 %.2) {
+      %.3 = call i32 @"__main__.ising_element_update$1.array(int8,_2d,_C).int64.int64"(i32 %.1, i32 %.2)
+      ret i32 %.3
+    }
+"""    # noqa: E501
+
+
+ctypes_sum_ty = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int)
+
+
+class JITCPUCodegenTestCase(TestCase):
+    """
+    Test the JIT code generation.
+    """
+
+    def setUp(self):
+        global_compiler_lock.acquire()
+        self.codegen = JITCPUCodegen('test_codegen')
+
+    def tearDown(self):
+        del self.codegen
+        global_compiler_lock.release()
+
+    def compile_module(self, asm, linking_asm=None):
+        library = self.codegen.create_library('compiled_module')
+        ll_module = ll.parse_assembly(asm)
+        ll_module.verify()
+        library.add_llvm_module(ll_module)
+        if linking_asm:
+            linking_library = self.codegen.create_library('linking_module')
+            ll_module = ll.parse_assembly(linking_asm)
+            ll_module.verify()
+            linking_library.add_llvm_module(ll_module)
+            library.add_linking_library(linking_library)
+        return library
+
+    @classmethod
+    def _check_unserialize_sum(cls, state):
+        codegen = JITCPUCodegen('other_codegen')
+        library = codegen.unserialize_library(state)
+        ptr = library.get_pointer_to_function("sum")
+        assert ptr, ptr
+        cfunc = ctypes_sum_ty(ptr)
+        res = cfunc(2, 3)
+        assert res == 5, res
+
+    def test_get_pointer_to_function(self):
+        library = self.compile_module(asm_sum)
+        ptr = library.get_pointer_to_function("sum")
+        self.assertIsInstance(ptr, int)
+        cfunc = ctypes_sum_ty(ptr)
+        self.assertEqual(cfunc(2, 3), 5)
+        # Note: With llvm3.9.1, deleting `library` will cause memory error in
+        #       the following code during running of optimization passes in
+        #       LLVM. The reason of the error is unclear. The error is known to
+        #       replicate on osx64 and linux64.
+
+        # Same, but with dependency on another library
+        library2 = self.compile_module(asm_sum_outer, asm_sum_inner)
+        ptr = library2.get_pointer_to_function("sum")
+        self.assertIsInstance(ptr, int)
+        cfunc = ctypes_sum_ty(ptr)
+        self.assertEqual(cfunc(2, 3), 5)
+
+    def test_magic_tuple(self):
+        tup = self.codegen.magic_tuple()
+        pickle.dumps(tup)
+        cg2 = JITCPUCodegen('xxx')
+        self.assertEqual(cg2.magic_tuple(), tup)
+
+    # Serialization tests.
+
+    def _check_serialize_unserialize(self, state):
+        self._check_unserialize_sum(state)
+
+    def _check_unserialize_other_process(self, state):
+        arg = base64.b64encode(pickle.dumps(state, -1))
+        code = """if 1:
+            import base64
+            import pickle
+            import sys
+            from numba.tests.test_codegen import %(test_class)s
+
+            state = pickle.loads(base64.b64decode(sys.argv[1]))
+            %(test_class)s._check_unserialize_sum(state)
+            """ % dict(test_class=self.__class__.__name__)
+        subprocess.check_call([sys.executable, '-c', code, arg.decode()])
+
+    def test_serialize_unserialize_bitcode(self):
+        library = self.compile_module(asm_sum_outer, asm_sum_inner)
+        state = library.serialize_using_bitcode()
+        self._check_serialize_unserialize(state)
+
+    def test_unserialize_other_process_bitcode(self):
+        library = self.compile_module(asm_sum_outer, asm_sum_inner)
+        state = library.serialize_using_bitcode()
+        self._check_unserialize_other_process(state)
+
+    def test_serialize_unserialize_object_code(self):
+        library = self.compile_module(asm_sum_outer, asm_sum_inner)
+        library.enable_object_caching()
+        state = library.serialize_using_object_code()
+        self._check_serialize_unserialize(state)
+
+    def test_unserialize_other_process_object_code(self):
+        library = self.compile_module(asm_sum_outer, asm_sum_inner)
+        library.enable_object_caching()
+        state = library.serialize_using_object_code()
+        self._check_unserialize_other_process(state)
+
+    def test_cache_disabled_inspection(self):
+        """
+        """
+        library = self.compile_module(asm_sum_outer, asm_sum_inner)
+        library.enable_object_caching()
+        state = library.serialize_using_object_code()
+
+        # exercise the valid behavior
+        with warnings.catch_warnings(record=True) as w:
+            old_llvm = library.get_llvm_str()
+            old_asm = library.get_asm_str()
+            library.get_function_cfg('sum')
+        self.assertEqual(len(w), 0)
+
+        # unserialize
+        codegen = JITCPUCodegen('other_codegen')
+        library = codegen.unserialize_library(state)
+
+        # the inspection methods would warn and give incorrect result
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            self.assertNotEqual(old_llvm, library.get_llvm_str())
+        self.assertEqual(len(w), 1)
+        self.assertIn("Inspection disabled", str(w[0].message))
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            self.assertNotEqual(library.get_asm_str(), old_asm)
+        self.assertEqual(len(w), 1)
+        self.assertIn("Inspection disabled", str(w[0].message))
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            with self.assertRaises(NameError) as raises:
+                library.get_function_cfg('sum')
+        self.assertEqual(len(w), 1)
+        self.assertIn("Inspection disabled", str(w[0].message))
+        self.assertIn("sum", str(raises.exception))
+
+    # Lifetime tests
+
+    @unittest.expectedFailure  # MCJIT removeModule leaks and it is disabled
+    def test_library_lifetime(self):
+        library = self.compile_module(asm_sum_outer, asm_sum_inner)
+        # Exercise code generation
+        library.enable_object_caching()
+        library.serialize_using_bitcode()
+        library.serialize_using_object_code()
+        u = weakref.ref(library)
+        v = weakref.ref(library._final_module)
+        del library
+        # Both the library and its backing LLVM module are collected
+        self.assertIs(u(), None)
+        self.assertIs(v(), None)
+
+
+class TestWrappers(TestCase):
+
+    def test_noinline_on_main_call(self):
+        # Checks that the cpython and cfunc wrapper produces a call with the
+        # "noinline" attr present for the decorated function.
+
+        # Creating a refcounted object induces a side-effect that prevents IPO
+        # from eliding the call to the function with LLVM 15. See Issue #9658:
+        # https://github.com/numba/numba/issues/9658
+        @njit
+        def foo():
+            return list([1])
+
+        foo()
+        sig = foo.signatures[0]
+
+        ol = foo.overloads[sig]
+        name = ol.fndesc.mangled_name.replace("$", r"\$")
+        p1 = r".*call.*{}".format(name)
+        p2 = r".*(#[0-9]+).*"
+        call_site = re.compile(p1 + p2)
+
+        lines = foo.inspect_llvm(sig).splitlines()
+        meta_data_idx = []
+        for l in lines:
+            matched = call_site.match(l)
+            if matched:
+                meta_data_idx.append(matched.groups()[0])
+
+        # should be 2 calls, one from cpython wrapper one from cfunc wrapper
+        self.assertEqual(len(meta_data_idx), 2)
+        # both calls should refer to the same metadata item
+        self.assertEqual(meta_data_idx[0], meta_data_idx[1])
+
+        p1 = r"^attributes\s+{}".format(meta_data_idx[0])
+        p2 = r"\s+=\s+{(.*)}.*$"
+        attr_site = re.compile(p1 + p2)
+
+        for l in reversed(lines):
+            matched = attr_site.match(l)
+            if matched:
+                meta_data = matched.groups()[0]
+                lmeta = meta_data.strip().split(' ')
+                for x in lmeta:
+                    if 'noinline' in x:
+                        break
+                else:
+                    continue
+                break
+        else:
+            return self.fail("Metadata did not match 'noinline'")
+
+
+if __name__ == '__main__':
+    unittest.main()

shared/package-files/2e/2ecb5434dae88d16cfebb2396f2566564d98a62b0ebc1a9a8ca3a181f26d132c/property_features.py

@@ -0,0 +1,23 @@
+"""Shared fixed public-spectrum and candidate-property definitions."""
+import numpy as np
+from spectrum_features import spectrum_features
+from prior_features import descriptors,transformed,FEATURE_NAMES
+TARGET_NAMES=['MolLogP','TPSA','HDonors','HAcceptors','RotatableBonds','FractionCSP3','AromaticRings','AliphaticRings','Heterocycles']
+TARGET_INDICES=[FEATURE_NAMES.index(n) for n in TARGET_NAMES]
+def broad_public_features(q):
+ x,names=spectrum_features(q);ce=q.get('collision_energy');known=ce is not None
+ # Contract allows finite numeric energies; signed log remains defined for unusual inputs.
+ value=float(ce) if known else 0.
+ return np.concatenate([x,np.asarray([float(known),np.sign(value)*np.log1p(abs(value))],np.float32)]),names+['energy_known','signed_log_energy']
+def candidate_targets(smiles):
+ values,valid=descriptors(smiles);return transformed(values[TARGET_INDICES]),valid
+
+from neutral_loss_features import neutral_losses,NAMES
+def neutral_public_features(q):
+ x,names=broad_public_features(q)
+ return np.concatenate([x,neutral_losses(q)]),names+NAMES
+
+from fragment_pair_features import fragment_pairs,NAMES as PAIR_NAMES
+def public_features(q):
+ x,names=neutral_public_features(q)
+ return np.concatenate([x,fragment_pairs(q)]),names+PAIR_NAMES

shared/package-files/2e/2ecc26b4441f97c8a50f772ad29f9b8e47afdf44fa9a0da2162d1208e56e830d/blob

@@ -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 gather_backward {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, 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::gather_backward")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "gather_backward(Tensor grad, Tensor self, int dim, Tensor index, bool sparse_grad) -> Tensor")
+  static at::Tensor call(const at::Tensor & grad, const at::Tensor & self, int64_t dim, const at::Tensor & index, bool sparse_grad);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad, const at::Tensor & self, int64_t dim, const at::Tensor & index, bool sparse_grad);
+};
+
+}} // namespace at::_ops

shared/package-files/2e/2ecea44b99a5e2e19f8c2f0afc0dfca30e880a4ee73535900ab9e10f4dc32449/blob

@@ -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 compositeexplicitautograd {
+
+TORCH_API at::Tensor sparse_resize_and_clear(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim);
+TORCH_API const at::Tensor & sparse_resize_and_clear_out(const at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim);
+TORCH_API const at::Tensor & sparse_resize_and_clear_outf(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim, const at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

shared/package-files/2e/2ed0833b84de3212d60224c6889113dd83fc44ee93dce42a99da49f091f7f758/blob

@@ -0,0 +1,40 @@
+""" common utilities """
+from __future__ import annotations
+
+from typing import (
+    Any,
+    Literal,
+)
+
+
+def _mklbl(prefix: str, n: int):
+    return [f"{prefix}{i}" for i in range(n)]
+
+
+def check_indexing_smoketest_or_raises(
+    obj,
+    method: Literal["iloc", "loc"],
+    key: Any,
+    axes: Literal[0, 1] | None = None,
+    fails=None,
+) -> None:
+    if axes is None:
+        axes_list = [0, 1]
+    else:
+        assert axes in [0, 1]
+        axes_list = [axes]
+
+    for ax in axes_list:
+        if ax < obj.ndim:
+            # create a tuple accessor
+            new_axes = [slice(None)] * obj.ndim
+            new_axes[ax] = key
+            axified = tuple(new_axes)
+            try:
+                getattr(obj, method).__getitem__(axified)
+            except (IndexError, TypeError, KeyError) as detail:
+                # if we are in fails, the ok, otherwise raise it
+                if fails is not None:
+                    if isinstance(detail, fails):
+                        return
+                raise

shared/package-files/2e/2ed0f84625acfeb439f191192e9fbfd4171ed41d79b78192d56a62c475bcf758/blob

@@ -0,0 +1,61 @@
+from jedi.inference.base_value import ValueSet, NO_VALUES
+from jedi.common import monkeypatch
+
+
+class AbstractLazyValue:
+    def __init__(self, data, min=1, max=1):
+        self.data = data
+        self.min = min
+        self.max = max
+
+    def __repr__(self):
+        return '<%s: %s>' % (self.__class__.__name__, self.data)
+
+    def infer(self):
+        raise NotImplementedError
+
+
+class LazyKnownValue(AbstractLazyValue):
+    """data is a Value."""
+    def infer(self):
+        return ValueSet([self.data])
+
+
+class LazyKnownValues(AbstractLazyValue):
+    """data is a ValueSet."""
+    def infer(self):
+        return self.data
+
+
+class LazyUnknownValue(AbstractLazyValue):
+    def __init__(self, min=1, max=1):
+        super().__init__(None, min, max)
+
+    def infer(self):
+        return NO_VALUES
+
+
+class LazyTreeValue(AbstractLazyValue):
+    def __init__(self, context, node, min=1, max=1):
+        super().__init__(node, min, max)
+        self.context = context
+        # We need to save the predefined names. It's an unfortunate side effect
+        # that needs to be tracked otherwise results will be wrong.
+        self._predefined_names = dict(context.predefined_names)
+
+    def infer(self):
+        with monkeypatch(self.context, 'predefined_names', self._predefined_names):
+            return self.context.infer_node(self.data)
+
+
+def get_merged_lazy_value(lazy_values):
+    if len(lazy_values) > 1:
+        return MergedLazyValues(lazy_values)
+    else:
+        return lazy_values[0]
+
+
+class MergedLazyValues(AbstractLazyValue):
+    """data is a list of lazy values."""
+    def infer(self):
+        return ValueSet.from_sets(l.infer() for l in self.data)

shared/package-files/2e/2ed374ea5c33373f68633f4045e4128b3a72f5bedcd7c4caa52a8039c64c89b0/blob

@@ -0,0 +1,23 @@
+#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/acos_meta.h>
+
+namespace at {
+namespace native {
+struct TORCH_API structured_acos_out : public at::meta::structured_acos {
+void impl(const at::Tensor & self, const at::Tensor & out);
+};
+} // namespace native
+} // namespace at

shared/package-files/2e/2ed5ed8d31bfe29f23cd375465f0d0154512f2355c509d543080b375b028dd55/blob

@@ -0,0 +1,273 @@
+"""
+Tests corresponding to sandbox.distributions.mv_normal
+"""
+from statsmodels.compat.scipy import SP_LT_116
+
+import numpy as np
+from numpy.testing import assert_allclose, assert_array_almost_equal
+import pytest
+from scipy import stats
+
+from statsmodels.sandbox.distributions.mv_normal import (
+    MVT,
+    BivariateNormal,
+    MVNormal,
+    MVNormal0,
+    bivariate_normal,
+    expect_mc,
+)
+
+MEAN3 = np.array([-1, 0.0, 2.0])
+COV3 = np.array([[1.0, 0.5, 0.75], [0.5, 1.5, 0.6], [0.75, 0.6, 2.0]])
+
+
+def test_bivariate_normal_function_matches_scipy():
+    x = np.array([[0.0, 0.0], [1.0, 1.0], [-1.0, 2.0]])
+    mu = [0.0, 0.0]
+    cov = np.array([[1.0, 0.3], [0.3, 1.0]])
+    result = bivariate_normal(x, mu, cov)
+    expected = stats.multivariate_normal.pdf(x, mean=mu, cov=cov)
+    assert_allclose(result, expected, rtol=1e-10)
+
+
+def test_bivariate_normal_class_construction():
+    BivariateNormal([0.0, 0.0], np.eye(2))
+
+
+class TestMVNormal:
+    def setup_method(self):
+        self.mvn = MVNormal(MEAN3, COV3)
+
+    def test_logpdf_matches_scipy(self):
+        pt = np.array([0.0, 1.0, 1.5])
+        result = self.mvn.logpdf(pt)
+        expected = stats.multivariate_normal.logpdf(pt, mean=MEAN3, cov=COV3)
+        assert_allclose(result, expected, rtol=1e-10)
+
+    def test_logpdf_2d_input_matches_scipy_rowwise(self):
+        pts = np.array([[0.0, 1.0, 1.5], [-1.0, 0.0, 2.0], [1.0, 1.0, 1.0]])
+        result = self.mvn.logpdf(pts)
+        expected = stats.multivariate_normal.logpdf(pts, mean=MEAN3, cov=COV3)
+        assert_allclose(result, expected, rtol=1e-10)
+
+    def test_pdf_is_exp_logpdf(self):
+        pt = np.array([0.0, 1.0, 1.5])
+        assert_allclose(self.mvn.pdf(pt), np.exp(self.mvn.logpdf(pt)))
+
+    def test_cov_property_equals_sigma(self):
+        assert_array_almost_equal(self.mvn.cov, COV3)
+
+    def test_std_and_corr_consistent_with_cov(self):
+        std = self.mvn.std
+        corr = self.mvn.corr
+        assert_array_almost_equal(std, np.sqrt(np.diag(COV3)))
+        reconstructed = corr * np.outer(std, std)
+        assert_array_almost_equal(reconstructed, COV3)
+
+    def test_rvs_moments_match_by_monte_carlo(self):
+        rvs = self.mvn.rvs(size=200000)
+        assert_allclose(rvs.mean(0), MEAN3, atol=0.02)
+        assert_allclose(np.cov(rvs, rowvar=False), COV3, atol=0.05)
+
+    @pytest.mark.skipif(
+        not SP_LT_116,
+        reason=(
+            "MVNormal.cdf() delegates to sandbox.distributions.extras."
+            "mvnormcdf -> mvstdnormcdf -> mvndst, a compiled scipy.stats "
+            "Fortran routine that was removed in SciPy >= 1.16.0 (see "
+            "sandbox.distributions.tests.test_multivariate for the same "
+            "issue against mvstdtprob/mvstdnormcdf directly)."
+        ),
+    )
+    def test_cdf_matches_scipy(self):
+        pt = np.array([0.0, 1.0, 1.5])
+        result = self.mvn.cdf(pt)
+        expected = stats.multivariate_normal.cdf(pt, mean=MEAN3, cov=COV3)
+        assert_allclose(result, expected, atol=1e-4)
+
+    def test_whiten_standardize_relationship(self):
+        x = np.array([0.5, 1.0, 2.5])
+        assert_array_almost_equal(
+            self.mvn.standardize(x), self.mvn.whiten(x - MEAN3)
+        )
+
+    def test_normalized_has_correlation_as_sigma_and_zero_mean(self):
+        normalized = self.mvn.normalized()
+        assert_array_almost_equal(normalized.sigma, self.mvn.corr)
+        assert_array_almost_equal(normalized.mean, np.zeros(3))
+
+    def test_normalized_not_demeaned(self):
+        normalized = self.mvn.normalized(demeaned=False)
+        assert_array_almost_equal(normalized.mean, MEAN3 / self.mvn.std_sigma)
+
+    def test_normalized2_sigma_matches_normalized(self):
+        assert_array_almost_equal(
+            self.mvn.normalized().sigma, self.mvn.normalized2().sigma
+        )
+
+    @pytest.mark.xfail(
+        reason=(
+            "BUG: normalized2(demeaned=True) computes shift=-self.mean and "
+            "passes it to affine_transformed(shift, scale), which computes "
+            "mean_new = scale @ mean + shift. That only cancels to zero "
+            "when scale is the identity; here scale=diag(1/std_sigma), so "
+            "the result is mean/std_sigma - mean, not zero. normalized() "
+            "(a separate, non-affine implementation) gets this right by "
+            "directly setting mean_new = zeros. The same shift-vs-scale "
+            "bug affects .standardized(), see "
+            "test_standardized_mean_is_zero below."
+        ),
+        raises=AssertionError,
+        strict=True,
+    )
+    def test_normalized2_mean_matches_normalized(self):
+        assert_array_almost_equal(
+            self.mvn.normalized().mean, self.mvn.normalized2().mean
+        )
+
+    def test_marginal(self):
+        marg = self.mvn.marginal(np.array([0, 2]))
+        assert_array_almost_equal(marg.mean, MEAN3[[0, 2]])
+        assert_array_almost_equal(marg.sigma, COV3[np.ix_([0, 2], [0, 2])])
+
+    def test_conditional_matches_textbook_formula(self):
+        keep = np.array([0])
+        given = np.array([1, 2])
+        values = np.array([1.0, 1.5])
+        cond = self.mvn.conditional(keep, values)
+
+        sigmakk = COV3[np.ix_(keep, keep)]
+        sigmagg = COV3[np.ix_(given, given)]
+        sigmakg = COV3[np.ix_(keep, given)]
+        expected_mean = MEAN3[keep] + sigmakg @ np.linalg.solve(
+            sigmagg, values - MEAN3[given]
+        )
+        expected_sigma = sigmakk - sigmakg @ np.linalg.solve(sigmagg, sigmakg.T)
+        assert_array_almost_equal(cond.mean, expected_mean)
+        assert_array_almost_equal(cond.sigma, expected_sigma)
+
+    def test_affine_transformed(self):
+        shift = np.array([1.0, 1.0, 1.0])
+        scale = np.eye(3) * 2
+        transformed = self.mvn.affine_transformed(shift, scale)
+        assert_array_almost_equal(transformed.mean, shift + scale @ MEAN3)
+        assert_array_almost_equal(transformed.sigma, scale @ COV3 @ scale.T)
+
+    def test_standardized_has_identity_sigma(self):
+        standardized = self.mvn.standardized()
+        assert_array_almost_equal(standardized.sigma, np.eye(3), decimal=8)
+
+    @pytest.mark.xfail(
+        reason=(
+            "BUG: standardized() calls "
+            "affine_transformed(-self.mean, self.cholsigmainv), but "
+            "affine_transformed computes mean_new = B @ mean + shift. "
+            "With B=cholsigmainv and shift=-mean (unscaled), the result is "
+            "cholsigmainv @ mean - mean, not zero. The instance *method* "
+            ".standardize(x) is implemented correctly (it does whiten(x - "
+            "mean), see test_whiten_standardize_relationship and "
+            "test_manual_standardize_of_samples_has_zero_mean); only the "
+            "*factory* .standardized(), which builds a new zero-mean "
+            "MVNormal via the generic affine-transform path, has the bug. "
+            "The correct shift would be -B @ self.mean."
+        ),
+        raises=AssertionError,
+        strict=True,
+    )
+    def test_standardized_mean_is_zero(self):
+        standardized = self.mvn.standardized()
+        assert_array_almost_equal(standardized.mean, np.zeros(3))
+
+    def test_manual_standardize_of_samples_has_zero_mean(self):
+        # the .standardize(x) instance method (as opposed to the buggy
+        # .standardized() factory above) correctly produces zero-mean
+        # output when applied to samples from the distribution
+        rng = np.random.default_rng(0)
+        rvs = rng.multivariate_normal(MEAN3, COV3, size=200000)
+        whitened = self.mvn.standardize(rvs)
+        assert_allclose(whitened.mean(0), np.zeros(3), atol=0.02)
+        assert_allclose(np.cov(whitened, rowvar=False), np.eye(3), atol=0.05)
+
+
+class TestMVNormalConstruction:
+    def test_scalar_sigma_is_iid(self):
+        mvn = MVNormal([0.0, 0.0], 2.0)
+        assert_array_almost_equal(mvn.cov, 2.0 * np.eye(2))
+
+    def test_1d_sigma_is_diagonal(self):
+        mvn = MVNormal([0.0, 0.0, 0.0], np.array([1.0, 2.0, 3.0]))
+        assert_array_almost_equal(mvn.cov, np.diag([1.0, 2.0, 3.0]))
+
+    def test_invalid_sigma_shape_raises(self):
+        with pytest.raises(ValueError, match="sigma has invalid shape"):
+            MVNormal([0.0, 0.0], np.ones((3, 2)))
+
+
+class TestMVT:
+    def setup_method(self):
+        self.df = 5
+        self.mvt = MVT(MEAN3, COV3, self.df)
+
+    def test_logpdf_matches_scipy_multivariate_t(self):
+        pt = np.array([0.0, 1.0, 1.5])
+        result = self.mvt.logpdf(pt)
+        expected = stats.multivariate_t.logpdf(
+            pt, loc=MEAN3, shape=COV3, df=self.df
+        )
+        assert_allclose(result, expected, rtol=1e-10)
+
+    def test_cov_formula_for_df_greater_than_2(self):
+        expected = self.df / (self.df - 2.0) * COV3
+        assert_array_almost_equal(self.mvt.cov, expected)
+
+    def test_cov_is_nan_for_df_leq_2(self):
+        mvt2 = MVT(MEAN3, COV3, df=2)
+        assert np.all(np.isnan(mvt2.cov))
+        mvt1 = MVT(MEAN3, COV3, df=1)
+        assert np.all(np.isnan(mvt1.cov))
+
+    def test_rvs_covariance_matches_by_monte_carlo(self):
+        rvs = self.mvt.rvs(size=200000)
+        assert_allclose(np.cov(rvs, rowvar=False), self.mvt.cov, atol=0.1)
+
+    def test_affine_transformed(self):
+        shift = np.array([1.0, 1.0, 1.0])
+        scale = np.eye(3) * 2
+        transformed = self.mvt.affine_transformed(shift, scale)
+        assert_array_almost_equal(transformed.mean, shift + scale @ MEAN3)
+        assert_array_almost_equal(transformed.sigma, scale @ COV3 @ scale.T)
+        assert transformed.df == self.df
+
+    def test_marginal_preserves_df(self):
+        marg = self.mvt.marginal(np.array([0, 2]))
+        assert marg.df == self.df
+        assert_array_almost_equal(marg.mean, MEAN3[[0, 2]])
+
+
+class TestMVNormal0:
+    # legacy reference implementation kept alongside MVNormal/MVElliptical
+    def test_logpdf_matches_mvnormal(self):
+        legacy = MVNormal0(MEAN3, COV3)
+        current = MVNormal(MEAN3, COV3)
+        pt = np.array([0.0, 1.0, 1.5])
+        assert_allclose(legacy.logpdf(pt), current.logpdf(pt), rtol=1e-10)
+
+    @pytest.mark.singleton_randomstate
+    def test_rvs_shape(self):
+        # MVNormal0.rvs() calls np.random.multivariate_normal directly
+        # (the legacy singleton RandomState API, unlike MVNormal.rvs()
+        # which threads an explicit rng/Generator), so this legitimately
+        # mutates global numpy random state.
+        legacy = MVNormal0(MEAN3, COV3)
+        rvs = legacy.rvs(size=5)
+        assert rvs.shape == (5, 3)
+
+
+def test_expect_mc_estimates_normal_orthant_probability():
+    # expected value of an indicator function via Monte Carlo should be
+    # close to the true probability computed from the cdf
+    mvn = MVNormal([0.0, 0.0], np.eye(2))
+    a = np.array([0.0, 0.0])
+    result = expect_mc(mvn, lambda x: (x < a).all(-1), size=200000)
+    expected = stats.multivariate_normal.cdf(a, mean=[0.0, 0.0], cov=np.eye(2))
+    assert_allclose(result, expected, atol=0.01)

shared/package-files/2e/2edaf7151e34a33e0bace52ba5949e4770a644cb53d4792fb8e4ed6404538ae5/blob

@@ -0,0 +1,39 @@
+#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/special_gammaln_ops.h>
+
+namespace at {
+
+
+// aten::special_gammaln(Tensor self) -> Tensor
+inline at::Tensor special_gammaln(const at::Tensor & self) {
+    return at::_ops::special_gammaln::call(self);
+}
+
+// aten::special_gammaln.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & special_gammaln_out(at::Tensor & out, const at::Tensor & self) {
+    return at::_ops::special_gammaln_out::call(self, out);
+}
+// aten::special_gammaln.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & special_gammaln_outf(const at::Tensor & self, at::Tensor & out) {
+    return at::_ops::special_gammaln_out::call(self, out);
+}
+
+}

shared/package-files/2e/2edb767a89d7bc06e14532908fbe151f6f7d3412bd982c785d809dc945cb4385/blob

@@ -0,0 +1,155 @@
+from . cimport sf_error
+cdef void _set_action(sf_error.sf_error_t, sf_error.sf_action_t) noexcept nogil
+cdef void *_export_beta_pdf_float
+cdef void *_export_beta_pdf_double
+cdef void *_export_beta_ppf_float
+cdef void *_export_beta_ppf_double
+cdef void *_export_binom_cdf_float
+cdef void *_export_binom_cdf_double
+cdef void *_export_binom_isf_float
+cdef void *_export_binom_isf_double
+cdef void *_export_binom_pmf_float
+cdef void *_export_binom_pmf_double
+cdef void *_export_binom_ppf_float
+cdef void *_export_binom_ppf_double
+cdef void *_export_binom_sf_float
+cdef void *_export_binom_sf_double
+cdef void *_export_cauchy_isf_float
+cdef void *_export_cauchy_isf_double
+cdef void *_export_cauchy_ppf_float
+cdef void *_export_cauchy_ppf_double
+cdef void *_export_hypergeom_cdf_float
+cdef void *_export_hypergeom_cdf_double
+cdef void *_export_hypergeom_mean_float
+cdef void *_export_hypergeom_mean_double
+cdef void *_export_hypergeom_pmf_float
+cdef void *_export_hypergeom_pmf_double
+cdef void *_export_hypergeom_sf_float
+cdef void *_export_hypergeom_sf_double
+cdef void *_export_hypergeom_skewness_float
+cdef void *_export_hypergeom_skewness_double
+cdef void *_export_hypergeom_variance_float
+cdef void *_export_hypergeom_variance_double
+cdef void *_export_invgauss_isf_float
+cdef void *_export_invgauss_isf_double
+cdef void *_export_invgauss_ppf_float
+cdef void *_export_invgauss_ppf_double
+cdef void *_export_landau_cdf_float
+cdef void *_export_landau_cdf_double
+cdef void *_export_landau_isf_float
+cdef void *_export_landau_isf_double
+cdef void *_export_landau_pdf_float
+cdef void *_export_landau_pdf_double
+cdef void *_export_landau_ppf_float
+cdef void *_export_landau_ppf_double
+cdef void *_export_landau_sf_float
+cdef void *_export_landau_sf_double
+cdef void *_export_nbinom_cdf_float
+cdef void *_export_nbinom_cdf_double
+cdef void *_export_nbinom_isf_float
+cdef void *_export_nbinom_isf_double
+cdef void *_export_nbinom_kurtosis_excess_float
+cdef void *_export_nbinom_kurtosis_excess_double
+cdef void *_export_nbinom_mean_float
+cdef void *_export_nbinom_mean_double
+cdef void *_export_nbinom_pmf_float
+cdef void *_export_nbinom_pmf_double
+cdef void *_export_nbinom_ppf_float
+cdef void *_export_nbinom_ppf_double
+cdef void *_export_nbinom_sf_float
+cdef void *_export_nbinom_sf_double
+cdef void *_export_nbinom_skewness_float
+cdef void *_export_nbinom_skewness_double
+cdef void *_export_nbinom_variance_float
+cdef void *_export_nbinom_variance_double
+cdef void *_export_ncf_isf_float
+cdef void *_export_ncf_isf_double
+cdef void *_export_ncf_kurtosis_excess_float
+cdef void *_export_ncf_kurtosis_excess_double
+cdef void *_export_ncf_mean_float
+cdef void *_export_ncf_mean_double
+cdef void *_export_ncf_pdf_float
+cdef void *_export_ncf_pdf_double
+cdef void *_export_ncf_sf_float
+cdef void *_export_ncf_sf_double
+cdef void *_export_ncf_skewness_float
+cdef void *_export_ncf_skewness_double
+cdef void *_export_ncf_variance_float
+cdef void *_export_ncf_variance_double
+cdef void *_export_nct_isf_float
+cdef void *_export_nct_isf_double
+cdef void *_export_nct_kurtosis_excess_float
+cdef void *_export_nct_kurtosis_excess_double
+cdef void *_export_nct_mean_float
+cdef void *_export_nct_mean_double
+cdef void *_export_nct_pdf_float
+cdef void *_export_nct_pdf_double
+cdef void *_export_nct_ppf_float
+cdef void *_export_nct_ppf_double
+cdef void *_export_nct_sf_float
+cdef void *_export_nct_sf_double
+cdef void *_export_nct_skewness_float
+cdef void *_export_nct_skewness_double
+cdef void *_export_nct_variance_float
+cdef void *_export_nct_variance_double
+cdef void *_export_ncx2_cdf_float
+cdef void *_export_ncx2_cdf_double
+cdef void *_export_ncx2_isf_float
+cdef void *_export_ncx2_isf_double
+cdef void *_export_ncx2_pdf_float
+cdef void *_export_ncx2_pdf_double
+cdef void *_export_ncx2_ppf_float
+cdef void *_export_ncx2_ppf_double
+cdef void *_export_ncx2_sf_float
+cdef void *_export_ncx2_sf_double
+cdef void *_export_skewnorm_cdf_float
+cdef void *_export_skewnorm_cdf_double
+cdef void *_export_skewnorm_isf_float
+cdef void *_export_skewnorm_isf_double
+cdef void *_export_skewnorm_ppf_float
+cdef void *_export_skewnorm_ppf_double
+cdef void *_export__stirling2_inexact
+cdef void *_export_ibeta_float
+cdef void *_export_ibeta_double
+cdef void *_export_ibetac_float
+cdef void *_export_ibetac_double
+cdef void *_export_ibetac_inv_float
+cdef void *_export_ibetac_inv_double
+cdef void *_export_ibeta_inv_float
+cdef void *_export_ibeta_inv_double
+cdef void *_export_faddeeva_dawsn
+cdef void *_export_faddeeva_dawsn_complex
+cdef void *_export_fellint_RC
+cdef void *_export_cellint_RC
+cdef void *_export_fellint_RD
+cdef void *_export_cellint_RD
+cdef void *_export_fellint_RF
+cdef void *_export_cellint_RF
+cdef void *_export_fellint_RG
+cdef void *_export_cellint_RG
+cdef void *_export_fellint_RJ
+cdef void *_export_cellint_RJ
+cdef void *_export_faddeeva_erf
+cdef void *_export_faddeeva_erfc_complex
+cdef void *_export_faddeeva_erfcx
+cdef void *_export_faddeeva_erfcx_complex
+cdef void *_export_faddeeva_erfi
+cdef void *_export_faddeeva_erfi_complex
+cdef void *_export_erfinv_float
+cdef void *_export_erfinv_double
+cdef void *_export_hyp1f1_double
+cdef void *_export_faddeeva_log_ndtr
+cdef void *_export_faddeeva_log_ndtr_complex
+cdef void *_export_ncf_cdf_float
+cdef void *_export_ncf_cdf_double
+cdef void *_export_ncf_ppf_float
+cdef void *_export_ncf_ppf_double
+cdef void *_export_nct_cdf_float
+cdef void *_export_nct_cdf_double
+cdef void *_export_faddeeva_ndtr
+cdef void *_export_powm1_float
+cdef void *_export_powm1_double
+cdef void *_export_faddeeva_voigt_profile
+cdef void *_export_faddeeva_w
+cdef void *_export_wrightomega
+cdef void *_export_wrightomega_real

shared/package-files/2e/2ee1a46e823643a77ad24420c0c0ee772fb97846e2c5a68218fefc0b01e58ba7/blob

@@ -0,0 +1,724 @@
+from datetime import datetime
+import re
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.dtypes import ArrowDtype
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+    _testing as tm,
+)
+
+
+def test_extract_expand_kwarg_wrong_type_raises(any_string_dtype):
+    # TODO: should this raise TypeError
+    values = Series(["fooBAD__barBAD", np.nan, "foo"], dtype=any_string_dtype)
+    with pytest.raises(ValueError, match="expand must be True or False"):
+        values.str.extract(".*(BAD[_]+).*(BAD)", expand=None)
+
+
+def test_extract_expand_kwarg(any_string_dtype):
+    s = Series(["fooBAD__barBAD", np.nan, "foo"], dtype=any_string_dtype)
+    expected = DataFrame(["BAD__", np.nan, np.nan], dtype=any_string_dtype)
+
+    result = s.str.extract(".*(BAD[_]+).*")
+    tm.assert_frame_equal(result, expected)
+
+    result = s.str.extract(".*(BAD[_]+).*", expand=True)
+    tm.assert_frame_equal(result, expected)
+
+    expected = DataFrame(
+        [["BAD__", "BAD"], [np.nan, np.nan], [np.nan, np.nan]], dtype=any_string_dtype
+    )
+    result = s.str.extract(".*(BAD[_]+).*(BAD)", expand=False)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extract_expand_False_mixed_object():
+    ser = Series(
+        ["aBAD_BAD", np.nan, "BAD_b_BAD", True, datetime.today(), "foo", None, 1, 2.0]
+    )
+
+    # two groups
+    result = ser.str.extract(".*(BAD[_]+).*(BAD)", expand=False)
+    er = [np.nan, np.nan]  # empty row
+    expected = DataFrame(
+        [["BAD_", "BAD"], er, ["BAD_", "BAD"], er, er, er, er, er, er], dtype=object
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # single group
+    result = ser.str.extract(".*(BAD[_]+).*BAD", expand=False)
+    expected = Series(
+        ["BAD_", np.nan, "BAD_", np.nan, np.nan, np.nan, None, np.nan, np.nan],
+        dtype=object,
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_extract_expand_index_raises():
+    # GH9980
+    # Index only works with one regex group since
+    # multi-group would expand to a frame
+    idx = Index(["A1", "A2", "A3", "A4", "B5"])
+    msg = "only one regex group is supported with Index"
+    with pytest.raises(ValueError, match=msg):
+        idx.str.extract("([AB])([123])", expand=False)
+
+
+def test_extract_expand_no_capture_groups_raises(index_or_series, any_string_dtype):
+    s_or_idx = index_or_series(["A1", "B2", "C3"], dtype=any_string_dtype)
+    msg = "pattern contains no capture groups"
+
+    # no groups
+    with pytest.raises(ValueError, match=msg):
+        s_or_idx.str.extract("[ABC][123]", expand=False)
+
+    # only non-capturing groups
+    with pytest.raises(ValueError, match=msg):
+        s_or_idx.str.extract("(?:[AB]).*", expand=False)
+
+
+def test_extract_expand_single_capture_group(index_or_series, any_string_dtype):
+    # single group renames series/index properly
+    s_or_idx = index_or_series(["A1", "A2"], dtype=any_string_dtype)
+    result = s_or_idx.str.extract(r"(?P<uno>A)\d", expand=False)
+
+    expected = index_or_series(["A", "A"], name="uno", dtype=any_string_dtype)
+    if index_or_series == Series:
+        tm.assert_series_equal(result, expected)
+    else:
+        tm.assert_index_equal(result, expected)
+
+
+def test_extract_expand_capture_groups(any_string_dtype):
+    s = Series(["A1", "B2", "C3"], dtype=any_string_dtype)
+    # one group, no matches
+    result = s.str.extract("(_)", expand=False)
+    expected = Series([np.nan, np.nan, np.nan], dtype=any_string_dtype)
+    tm.assert_series_equal(result, expected)
+
+    # two groups, no matches
+    result = s.str.extract("(_)(_)", expand=False)
+    expected = DataFrame(
+        [[np.nan, np.nan], [np.nan, np.nan], [np.nan, np.nan]], dtype=any_string_dtype
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # one group, some matches
+    result = s.str.extract("([AB])[123]", expand=False)
+    expected = Series(["A", "B", np.nan], dtype=any_string_dtype)
+    tm.assert_series_equal(result, expected)
+
+    # two groups, some matches
+    result = s.str.extract("([AB])([123])", expand=False)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], [np.nan, np.nan]], dtype=any_string_dtype
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # one named group
+    result = s.str.extract("(?P<letter>[AB])", expand=False)
+    expected = Series(["A", "B", np.nan], name="letter", dtype=any_string_dtype)
+    tm.assert_series_equal(result, expected)
+
+    # two named groups
+    result = s.str.extract("(?P<letter>[AB])(?P<number>[123])", expand=False)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], [np.nan, np.nan]],
+        columns=["letter", "number"],
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # mix named and unnamed groups
+    result = s.str.extract("([AB])(?P<number>[123])", expand=False)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], [np.nan, np.nan]],
+        columns=[0, "number"],
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # one normal group, one non-capturing group
+    result = s.str.extract("([AB])(?:[123])", expand=False)
+    expected = Series(["A", "B", np.nan], dtype=any_string_dtype)
+    tm.assert_series_equal(result, expected)
+
+    # two normal groups, one non-capturing group
+    s = Series(["A11", "B22", "C33"], dtype=any_string_dtype)
+    result = s.str.extract("([AB])([123])(?:[123])", expand=False)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], [np.nan, np.nan]], dtype=any_string_dtype
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # one optional group followed by one normal group
+    s = Series(["A1", "B2", "3"], dtype=any_string_dtype)
+    result = s.str.extract("(?P<letter>[AB])?(?P<number>[123])", expand=False)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], [np.nan, "3"]],
+        columns=["letter", "number"],
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # one normal group followed by one optional group
+    s = Series(["A1", "B2", "C"], dtype=any_string_dtype)
+    result = s.str.extract("(?P<letter>[ABC])(?P<number>[123])?", expand=False)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], ["C", np.nan]],
+        columns=["letter", "number"],
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extract_expand_capture_groups_index(index, any_string_dtype):
+    # https://github.com/pandas-dev/pandas/issues/6348
+    # not passing index to the extractor
+    data = ["A1", "B2", "C"]
+
+    if len(index) == 0:
+        pytest.skip("Test requires len(index) > 0")
+    while len(index) < len(data):
+        index = index.repeat(2)
+
+    index = index[: len(data)]
+    ser = Series(data, index=index, dtype=any_string_dtype)
+
+    result = ser.str.extract(r"(\d)", expand=False)
+    expected = Series(["1", "2", np.nan], index=index, dtype=any_string_dtype)
+    tm.assert_series_equal(result, expected)
+
+    result = ser.str.extract(r"(?P<letter>\D)(?P<number>\d)?", expand=False)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], ["C", np.nan]],
+        columns=["letter", "number"],
+        index=index,
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extract_single_series_name_is_preserved(any_string_dtype):
+    s = Series(["a3", "b3", "c2"], name="bob", dtype=any_string_dtype)
+    result = s.str.extract(r"(?P<sue>[a-z])", expand=False)
+    expected = Series(["a", "b", "c"], name="sue", dtype=any_string_dtype)
+    tm.assert_series_equal(result, expected)
+
+
+def test_extract_expand_True(any_string_dtype):
+    # Contains tests like those in test_match and some others.
+    s = Series(["fooBAD__barBAD", np.nan, "foo"], dtype=any_string_dtype)
+
+    result = s.str.extract(".*(BAD[_]+).*(BAD)", expand=True)
+    expected = DataFrame(
+        [["BAD__", "BAD"], [np.nan, np.nan], [np.nan, np.nan]], dtype=any_string_dtype
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extract_expand_True_mixed_object():
+    er = [np.nan, np.nan]  # empty row
+    mixed = Series(
+        [
+            "aBAD_BAD",
+            np.nan,
+            "BAD_b_BAD",
+            True,
+            datetime.today(),
+            "foo",
+            None,
+            1,
+            2.0,
+        ]
+    )
+
+    result = mixed.str.extract(".*(BAD[_]+).*(BAD)", expand=True)
+    expected = DataFrame(
+        [["BAD_", "BAD"], er, ["BAD_", "BAD"], er, er, er, er, er, er], dtype=object
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extract_expand_True_single_capture_group_raises(
+    index_or_series, any_string_dtype
+):
+    # these should work for both Series and Index
+    # no groups
+    s_or_idx = index_or_series(["A1", "B2", "C3"], dtype=any_string_dtype)
+    msg = "pattern contains no capture groups"
+    with pytest.raises(ValueError, match=msg):
+        s_or_idx.str.extract("[ABC][123]", expand=True)
+
+    # only non-capturing groups
+    with pytest.raises(ValueError, match=msg):
+        s_or_idx.str.extract("(?:[AB]).*", expand=True)
+
+
+def test_extract_expand_True_single_capture_group(index_or_series, any_string_dtype):
+    # single group renames series/index properly
+    s_or_idx = index_or_series(["A1", "A2"], dtype=any_string_dtype)
+    result = s_or_idx.str.extract(r"(?P<uno>A)\d", expand=True)
+    expected = DataFrame({"uno": ["A", "A"]}, dtype=any_string_dtype)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("name", [None, "series_name"])
+def test_extract_series(name, any_string_dtype):
+    # extract should give the same result whether or not the series has a name.
+    s = Series(["A1", "B2", "C3"], name=name, dtype=any_string_dtype)
+
+    # one group, no matches
+    result = s.str.extract("(_)", expand=True)
+    expected = DataFrame([np.nan, np.nan, np.nan], dtype=any_string_dtype)
+    tm.assert_frame_equal(result, expected)
+
+    # two groups, no matches
+    result = s.str.extract("(_)(_)", expand=True)
+    expected = DataFrame(
+        [[np.nan, np.nan], [np.nan, np.nan], [np.nan, np.nan]], dtype=any_string_dtype
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # one group, some matches
+    result = s.str.extract("([AB])[123]", expand=True)
+    expected = DataFrame(["A", "B", np.nan], dtype=any_string_dtype)
+    tm.assert_frame_equal(result, expected)
+
+    # two groups, some matches
+    result = s.str.extract("([AB])([123])", expand=True)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], [np.nan, np.nan]], dtype=any_string_dtype
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # one named group
+    result = s.str.extract("(?P<letter>[AB])", expand=True)
+    expected = DataFrame({"letter": ["A", "B", np.nan]}, dtype=any_string_dtype)
+    tm.assert_frame_equal(result, expected)
+
+    # two named groups
+    result = s.str.extract("(?P<letter>[AB])(?P<number>[123])", expand=True)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], [np.nan, np.nan]],
+        columns=["letter", "number"],
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # mix named and unnamed groups
+    result = s.str.extract("([AB])(?P<number>[123])", expand=True)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], [np.nan, np.nan]],
+        columns=[0, "number"],
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # one normal group, one non-capturing group
+    result = s.str.extract("([AB])(?:[123])", expand=True)
+    expected = DataFrame(["A", "B", np.nan], dtype=any_string_dtype)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extract_optional_groups(any_string_dtype):
+    # two normal groups, one non-capturing group
+    s = Series(["A11", "B22", "C33"], dtype=any_string_dtype)
+    result = s.str.extract("([AB])([123])(?:[123])", expand=True)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], [np.nan, np.nan]], dtype=any_string_dtype
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # one optional group followed by one normal group
+    s = Series(["A1", "B2", "3"], dtype=any_string_dtype)
+    result = s.str.extract("(?P<letter>[AB])?(?P<number>[123])", expand=True)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], [np.nan, "3"]],
+        columns=["letter", "number"],
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # one normal group followed by one optional group
+    s = Series(["A1", "B2", "C"], dtype=any_string_dtype)
+    result = s.str.extract("(?P<letter>[ABC])(?P<number>[123])?", expand=True)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], ["C", np.nan]],
+        columns=["letter", "number"],
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extract_dataframe_capture_groups_index(index, any_string_dtype):
+    # GH6348
+    # not passing index to the extractor
+
+    data = ["A1", "B2", "C"]
+
+    if len(index) < len(data):
+        pytest.skip(f"Index needs more than {len(data)} values")
+
+    index = index[: len(data)]
+    s = Series(data, index=index, dtype=any_string_dtype)
+
+    result = s.str.extract(r"(\d)", expand=True)
+    expected = DataFrame(["1", "2", np.nan], index=index, dtype=any_string_dtype)
+    tm.assert_frame_equal(result, expected)
+
+    result = s.str.extract(r"(?P<letter>\D)(?P<number>\d)?", expand=True)
+    expected = DataFrame(
+        [["A", "1"], ["B", "2"], ["C", np.nan]],
+        columns=["letter", "number"],
+        index=index,
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extract_single_group_returns_frame(any_string_dtype):
+    # GH11386 extract should always return DataFrame, even when
+    # there is only one group. Prior to v0.18.0, extract returned
+    # Series when there was only one group in the regex.
+    s = Series(["a3", "b3", "c2"], name="series_name", dtype=any_string_dtype)
+    result = s.str.extract(r"(?P<letter>[a-z])", expand=True)
+    expected = DataFrame({"letter": ["a", "b", "c"]}, dtype=any_string_dtype)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extractall(any_string_dtype):
+    data = [
+        "dave@google.com",
+        "tdhock5@gmail.com",
+        "maudelaperriere@gmail.com",
+        "rob@gmail.com some text steve@gmail.com",
+        "a@b.com some text c@d.com and e@f.com",
+        np.nan,
+        "",
+    ]
+    expected_tuples = [
+        ("dave", "google", "com"),
+        ("tdhock5", "gmail", "com"),
+        ("maudelaperriere", "gmail", "com"),
+        ("rob", "gmail", "com"),
+        ("steve", "gmail", "com"),
+        ("a", "b", "com"),
+        ("c", "d", "com"),
+        ("e", "f", "com"),
+    ]
+    pat = r"""
+    (?P<user>[a-z0-9]+)
+    @
+    (?P<domain>[a-z]+)
+    \.
+    (?P<tld>[a-z]{2,4})
+    """
+    expected_columns = ["user", "domain", "tld"]
+    s = Series(data, dtype=any_string_dtype)
+    # extractall should return a DataFrame with one row for each match, indexed by the
+    # subject from which the match came.
+    expected_index = MultiIndex.from_tuples(
+        [(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 0), (4, 1), (4, 2)],
+        names=(None, "match"),
+    )
+    expected = DataFrame(
+        expected_tuples, expected_index, expected_columns, dtype=any_string_dtype
+    )
+    result = s.str.extractall(pat, flags=re.VERBOSE)
+    tm.assert_frame_equal(result, expected)
+
+    # The index of the input Series should be used to construct the index of the output
+    # DataFrame:
+    mi = MultiIndex.from_tuples(
+        [
+            ("single", "Dave"),
+            ("single", "Toby"),
+            ("single", "Maude"),
+            ("multiple", "robAndSteve"),
+            ("multiple", "abcdef"),
+            ("none", "missing"),
+            ("none", "empty"),
+        ]
+    )
+    s = Series(data, index=mi, dtype=any_string_dtype)
+    expected_index = MultiIndex.from_tuples(
+        [
+            ("single", "Dave", 0),
+            ("single", "Toby", 0),
+            ("single", "Maude", 0),
+            ("multiple", "robAndSteve", 0),
+            ("multiple", "robAndSteve", 1),
+            ("multiple", "abcdef", 0),
+            ("multiple", "abcdef", 1),
+            ("multiple", "abcdef", 2),
+        ],
+        names=(None, None, "match"),
+    )
+    expected = DataFrame(
+        expected_tuples, expected_index, expected_columns, dtype=any_string_dtype
+    )
+    result = s.str.extractall(pat, flags=re.VERBOSE)
+    tm.assert_frame_equal(result, expected)
+
+    # MultiIndexed subject with names.
+    s = Series(data, index=mi, dtype=any_string_dtype)
+    s.index.names = ("matches", "description")
+    expected_index.names = ("matches", "description", "match")
+    expected = DataFrame(
+        expected_tuples, expected_index, expected_columns, dtype=any_string_dtype
+    )
+    result = s.str.extractall(pat, flags=re.VERBOSE)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "pat,expected_names",
+    [
+        # optional groups.
+        ("(?P<letter>[AB])?(?P<number>[123])", ["letter", "number"]),
+        # only one of two groups has a name.
+        ("([AB])?(?P<number>[123])", [0, "number"]),
+    ],
+)
+def test_extractall_column_names(pat, expected_names, any_string_dtype):
+    s = Series(["", "A1", "32"], dtype=any_string_dtype)
+
+    result = s.str.extractall(pat)
+    expected = DataFrame(
+        [("A", "1"), (np.nan, "3"), (np.nan, "2")],
+        index=MultiIndex.from_tuples([(1, 0), (2, 0), (2, 1)], names=(None, "match")),
+        columns=expected_names,
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extractall_single_group(any_string_dtype):
+    s = Series(["a3", "b3", "d4c2"], name="series_name", dtype=any_string_dtype)
+    expected_index = MultiIndex.from_tuples(
+        [(0, 0), (1, 0), (2, 0), (2, 1)], names=(None, "match")
+    )
+
+    # extractall(one named group) returns DataFrame with one named column.
+    result = s.str.extractall(r"(?P<letter>[a-z])")
+    expected = DataFrame(
+        {"letter": ["a", "b", "d", "c"]}, index=expected_index, dtype=any_string_dtype
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # extractall(one un-named group) returns DataFrame with one un-named column.
+    result = s.str.extractall(r"([a-z])")
+    expected = DataFrame(
+        ["a", "b", "d", "c"], index=expected_index, dtype=any_string_dtype
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extractall_single_group_with_quantifier(any_string_dtype):
+    # GH#13382
+    # extractall(one un-named group with quantifier) returns DataFrame with one un-named
+    # column.
+    s = Series(["ab3", "abc3", "d4cd2"], name="series_name", dtype=any_string_dtype)
+    result = s.str.extractall(r"([a-z]+)")
+    expected = DataFrame(
+        ["ab", "abc", "d", "cd"],
+        index=MultiIndex.from_tuples(
+            [(0, 0), (1, 0), (2, 0), (2, 1)], names=(None, "match")
+        ),
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data, names",
+    [
+        ([], (None,)),
+        ([], ("i1",)),
+        ([], (None, "i2")),
+        ([], ("i1", "i2")),
+        (["a3", "b3", "d4c2"], (None,)),
+        (["a3", "b3", "d4c2"], ("i1", "i2")),
+        (["a3", "b3", "d4c2"], (None, "i2")),
+        (["a3", "b3", "d4c2"], ("i1", "i2")),
+    ],
+)
+def test_extractall_no_matches(data, names, any_string_dtype):
+    # GH19075 extractall with no matches should return a valid MultiIndex
+    n = len(data)
+    if len(names) == 1:
+        index = Index(range(n), name=names[0])
+    else:
+        tuples = (tuple([i] * (n - 1)) for i in range(n))
+        index = MultiIndex.from_tuples(tuples, names=names)
+    s = Series(data, name="series_name", index=index, dtype=any_string_dtype)
+    expected_index = MultiIndex.from_tuples([], names=(names + ("match",)))
+
+    # one un-named group.
+    result = s.str.extractall("(z)")
+    expected = DataFrame(columns=[0], index=expected_index, dtype=any_string_dtype)
+    tm.assert_frame_equal(result, expected)
+
+    # two un-named groups.
+    result = s.str.extractall("(z)(z)")
+    expected = DataFrame(columns=[0, 1], index=expected_index, dtype=any_string_dtype)
+    tm.assert_frame_equal(result, expected)
+
+    # one named group.
+    result = s.str.extractall("(?P<first>z)")
+    expected = DataFrame(
+        columns=["first"], index=expected_index, dtype=any_string_dtype
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # two named groups.
+    result = s.str.extractall("(?P<first>z)(?P<second>z)")
+    expected = DataFrame(
+        columns=["first", "second"], index=expected_index, dtype=any_string_dtype
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # one named, one un-named.
+    result = s.str.extractall("(z)(?P<second>z)")
+    expected = DataFrame(
+        columns=[0, "second"], index=expected_index, dtype=any_string_dtype
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extractall_stringindex(any_string_dtype):
+    s = Series(["a1a2", "b1", "c1"], name="xxx", dtype=any_string_dtype)
+    result = s.str.extractall(r"[ab](?P<digit>\d)")
+    expected = DataFrame(
+        {"digit": ["1", "2", "1"]},
+        index=MultiIndex.from_tuples([(0, 0), (0, 1), (1, 0)], names=[None, "match"]),
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+    # index should return the same result as the default index without name thus
+    # index.name doesn't affect to the result
+    if any_string_dtype == "object":
+        for idx in [
+            Index(["a1a2", "b1", "c1"], dtype=object),
+            Index(["a1a2", "b1", "c1"], name="xxx", dtype=object),
+        ]:
+            result = idx.str.extractall(r"[ab](?P<digit>\d)")
+            tm.assert_frame_equal(result, expected)
+
+    s = Series(
+        ["a1a2", "b1", "c1"],
+        name="s_name",
+        index=Index(["XX", "yy", "zz"], name="idx_name"),
+        dtype=any_string_dtype,
+    )
+    result = s.str.extractall(r"[ab](?P<digit>\d)")
+    expected = DataFrame(
+        {"digit": ["1", "2", "1"]},
+        index=MultiIndex.from_tuples(
+            [("XX", 0), ("XX", 1), ("yy", 0)], names=["idx_name", "match"]
+        ),
+        dtype=any_string_dtype,
+    )
+    tm.assert_frame_equal(result, expected)
+
+
+def test_extractall_no_capture_groups_raises(any_string_dtype):
+    # Does not make sense to use extractall with a regex that has no capture groups.
+    # (it returns DataFrame with one column for each capture group)
+    s = Series(["a3", "b3", "d4c2"], name="series_name", dtype=any_string_dtype)
+    with pytest.raises(ValueError, match="no capture groups"):
+        s.str.extractall(r"[a-z]")
+
+
+def test_extract_index_one_two_groups():
+    s = Series(["a3", "b3", "d4c2"], index=["A3", "B3", "D4"], name="series_name")
+    r = s.index.str.extract(r"([A-Z])", expand=True)
+    e = DataFrame(["A", "B", "D"])
+    tm.assert_frame_equal(r, e)
+
+    # Prior to v0.18.0, index.str.extract(regex with one group)
+    # returned Index. With more than one group, extract raised an
+    # error (GH9980). Now extract always returns DataFrame.
+    r = s.index.str.extract(r"(?P<letter>[A-Z])(?P<digit>[0-9])", expand=True)
+    e_list = [("A", "3"), ("B", "3"), ("D", "4")]
+    e = DataFrame(e_list, columns=["letter", "digit"])
+    tm.assert_frame_equal(r, e)
+
+
+def test_extractall_same_as_extract(any_string_dtype):
+    s = Series(["a3", "b3", "c2"], name="series_name", dtype=any_string_dtype)
+
+    pattern_two_noname = r"([a-z])([0-9])"
+    extract_two_noname = s.str.extract(pattern_two_noname, expand=True)
+    has_multi_index = s.str.extractall(pattern_two_noname)
+    no_multi_index = has_multi_index.xs(0, level="match")
+    tm.assert_frame_equal(extract_two_noname, no_multi_index)
+
+    pattern_two_named = r"(?P<letter>[a-z])(?P<digit>[0-9])"
+    extract_two_named = s.str.extract(pattern_two_named, expand=True)
+    has_multi_index = s.str.extractall(pattern_two_named)
+    no_multi_index = has_multi_index.xs(0, level="match")
+    tm.assert_frame_equal(extract_two_named, no_multi_index)
+
+    pattern_one_named = r"(?P<group_name>[a-z])"
+    extract_one_named = s.str.extract(pattern_one_named, expand=True)
+    has_multi_index = s.str.extractall(pattern_one_named)
+    no_multi_index = has_multi_index.xs(0, level="match")
+    tm.assert_frame_equal(extract_one_named, no_multi_index)
+
+    pattern_one_noname = r"([a-z])"
+    extract_one_noname = s.str.extract(pattern_one_noname, expand=True)
+    has_multi_index = s.str.extractall(pattern_one_noname)
+    no_multi_index = has_multi_index.xs(0, level="match")
+    tm.assert_frame_equal(extract_one_noname, no_multi_index)
+
+
+def test_extractall_same_as_extract_subject_index(any_string_dtype):
+    # same as above tests, but s has an MultiIndex.
+    mi = MultiIndex.from_tuples(
+        [("A", "first"), ("B", "second"), ("C", "third")],
+        names=("capital", "ordinal"),
+    )
+    s = Series(["a3", "b3", "c2"], index=mi, name="series_name", dtype=any_string_dtype)
+
+    pattern_two_noname = r"([a-z])([0-9])"
+    extract_two_noname = s.str.extract(pattern_two_noname, expand=True)
+    has_match_index = s.str.extractall(pattern_two_noname)
+    no_match_index = has_match_index.xs(0, level="match")
+    tm.assert_frame_equal(extract_two_noname, no_match_index)
+
+    pattern_two_named = r"(?P<letter>[a-z])(?P<digit>[0-9])"
+    extract_two_named = s.str.extract(pattern_two_named, expand=True)
+    has_match_index = s.str.extractall(pattern_two_named)
+    no_match_index = has_match_index.xs(0, level="match")
+    tm.assert_frame_equal(extract_two_named, no_match_index)
+
+    pattern_one_named = r"(?P<group_name>[a-z])"
+    extract_one_named = s.str.extract(pattern_one_named, expand=True)
+    has_match_index = s.str.extractall(pattern_one_named)
+    no_match_index = has_match_index.xs(0, level="match")
+    tm.assert_frame_equal(extract_one_named, no_match_index)
+
+    pattern_one_noname = r"([a-z])"
+    extract_one_noname = s.str.extract(pattern_one_noname, expand=True)
+    has_match_index = s.str.extractall(pattern_one_noname)
+    no_match_index = has_match_index.xs(0, level="match")
+    tm.assert_frame_equal(extract_one_noname, no_match_index)
+
+
+def test_extractall_preserves_dtype():
+    # Ensure that when extractall is called on a series with specific dtypes set, that
+    # the dtype is preserved in the resulting DataFrame's column.
+    pa = pytest.importorskip("pyarrow")
+
+    result = Series(["abc", "ab"], dtype=ArrowDtype(pa.string())).str.extractall("(ab)")
+    assert result.dtypes[0] == "string[pyarrow]"

shared/package-files/2e/2ee356ffa2491a5a60bdf7d7febfac426824904738615a0c1d07aef6bda3b76f/blob

@@ -0,0 +1,6 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset it_CH DATE_FORMAT "%e. %B %Y"
+    ::msgcat::mcset it_CH TIME_FORMAT "%H:%M:%S"
+    ::msgcat::mcset it_CH DATE_TIME_FORMAT "%e. %B %Y %H:%M:%S %z"
+}

shared/package-files/2e/2ee441783df4613b7b64a908cb440f239714a0274391c154a613c5dcfe951e65/blob

@@ -0,0 +1,11 @@
+from typing import Dict, List, Optional, Union
+
+from django.db.backends.base.client import BaseDatabaseClient
+
+class DatabaseClient(BaseDatabaseClient):
+    executable_name: str = ...
+    @classmethod
+    def settings_to_cmd_args(
+        cls, settings_dict: Dict[str, Optional[Union[Dict[str, Dict[str, str]], int, str]]]
+    ) -> List[str]: ...
+    def runshell(self) -> None: ...

shared/package-files/2e/2ee4f4c3ffc032d6b09ec04ca1b844316f60a76ca4d26039651cf0178e5cd142/blob

@@ -0,0 +1,14 @@
+from . import asciiTable
+
+
+class table_T_T_F_A_(asciiTable.asciiTable):
+    """ttfautohint parameters table
+
+    The ``TTFA`` table is used by the free-software `ttfautohint` program
+    to record the parameters that `ttfautohint` was called with when it
+    was used to auto-hint the font.
+
+    See also http://freetype.org/ttfautohint/doc/ttfautohint.html#miscellaneous-1
+    """
+
+    pass

shared/package-files/2e/2ee656f28f77559662edc6043f7d1dbca5939bb330d532e60ade546970f10898/blob

@@ -0,0 +1,20 @@
+#if defined(DETECT_FEATURES) && defined(__INTEL_COMPILER)
+    /*
+     * Unlike GCC and CLANG, Intel Compiler exposes all supported intrinsics,
+     * whether or not the build options for those features are specified.
+     * Therefore, we must test #definitions of CPU features when option native/host
+     * is enabled via `--cpu-baseline` or through env var `CFLAGS` otherwise
+     * the test will be broken and leads to enable all possible features.
+     */
+    #ifndef __AVX__
+        #error "HOST/ARCH doesn't support AVX"
+    #endif
+#endif
+
+#include <immintrin.h>
+
+int main(int argc, char **argv)
+{
+    __m256 a = _mm256_add_ps(_mm256_loadu_ps((const float*)argv[argc-1]), _mm256_loadu_ps((const float*)argv[1]));
+    return (int)_mm_cvtss_f32(_mm256_castps256_ps128(a));
+}

shared/package-files/2e/2ee7953a85601960c1c106fc385c1791529f567df708cd4b9307f5f80f3ab514/blob

@@ -0,0 +1,91 @@
+"""macOS."""
+from __future__ import annotations
+
+import os.path
+
+from .api import PlatformDirsABC
+
+
+class MacOS(PlatformDirsABC):
+    """
+    Platform directories for the macOS operating system. Follows the guidance from `Apple documentation
+    <https://developer.apple.com/library/archive/documentation/FileManagement/Conceptual/FileSystemProgrammingGuide/MacOSXDirectories/MacOSXDirectories.html>`_.
+    Makes use of the `appname <platformdirs.api.PlatformDirsABC.appname>`,
+    `version <platformdirs.api.PlatformDirsABC.version>`,
+    `ensure_exists <platformdirs.api.PlatformDirsABC.ensure_exists>`.
+    """
+
+    @property
+    def user_data_dir(self) -> str:
+        """:return: data directory tied to the user, e.g. ``~/Library/Application Support/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Application Support"))  # noqa: PTH111
+
+    @property
+    def site_data_dir(self) -> str:
+        """:return: data directory shared by users, e.g. ``/Library/Application Support/$appname/$version``"""
+        return self._append_app_name_and_version("/Library/Application Support")
+
+    @property
+    def user_config_dir(self) -> str:
+        """:return: config directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users, same as `site_data_dir`"""
+        return self.site_data_dir
+
+    @property
+    def user_cache_dir(self) -> str:
+        """:return: cache directory tied to the user, e.g. ``~/Library/Caches/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches"))  # noqa: PTH111
+
+    @property
+    def site_cache_dir(self) -> str:
+        """:return: cache directory shared by users, e.g. ``/Library/Caches/$appname/$version``"""
+        return self._append_app_name_and_version("/Library/Caches")
+
+    @property
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_log_dir(self) -> str:
+        """:return: log directory tied to the user, e.g. ``~/Library/Logs/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Logs"))  # noqa: PTH111
+
+    @property
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user, e.g. ``~/Documents``"""
+        return os.path.expanduser("~/Documents")  # noqa: PTH111
+
+    @property
+    def user_downloads_dir(self) -> str:
+        """:return: downloads directory tied to the user, e.g. ``~/Downloads``"""
+        return os.path.expanduser("~/Downloads")  # noqa: PTH111
+
+    @property
+    def user_pictures_dir(self) -> str:
+        """:return: pictures directory tied to the user, e.g. ``~/Pictures``"""
+        return os.path.expanduser("~/Pictures")  # noqa: PTH111
+
+    @property
+    def user_videos_dir(self) -> str:
+        """:return: videos directory tied to the user, e.g. ``~/Movies``"""
+        return os.path.expanduser("~/Movies")  # noqa: PTH111
+
+    @property
+    def user_music_dir(self) -> str:
+        """:return: music directory tied to the user, e.g. ``~/Music``"""
+        return os.path.expanduser("~/Music")  # noqa: PTH111
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """:return: runtime directory tied to the user, e.g. ``~/Library/Caches/TemporaryItems/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches/TemporaryItems"))  # noqa: PTH111
+
+
+__all__ = [
+    "MacOS",
+]

shared/package-files/2e/2ee8cbfb3974ecd0a735b3057ed88de45ab044b3125f2ae4c219f206df1c3ccb/blob

@@ -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 row_indices {
+  using schema = at::Tensor (const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::row_indices")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "row_indices(Tensor(a) self) -> Tensor(a)")
+  static at::Tensor call(const at::Tensor & self);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self);
+};
+
+}} // namespace at::_ops

shared/package-files/2e/2eed6198a6a99a5937fe377515c20f6eb9f3f3d595953342c18e3a0f84c56df1/blob

@@ -0,0 +1,38 @@
+from typing import AnyStr, Generic, Iterable, List, Optional, Tuple, Union
+
+from paramiko.util import ClosingContextManager
+
+class BufferedFile(ClosingContextManager, Generic[AnyStr]):
+    SEEK_SET: int
+    SEEK_CUR: int
+    SEEK_END: int
+
+    FLAG_READ: int
+    FLAG_WRITE: int
+    FLAG_APPEND: int
+    FLAG_BINARY: int
+    FLAG_BUFFERED: int
+    FLAG_LINE_BUFFERED: int
+    FLAG_UNIVERSAL_NEWLINE: int
+
+    newlines: Union[None, AnyStr, Tuple[AnyStr, ...]]
+    def __init__(self) -> None: ...
+    def __del__(self) -> None: ...
+    def __iter__(self) -> BufferedFile: ...
+    def close(self) -> None: ...
+    def flush(self) -> None: ...
+    def __next__(self) -> AnyStr: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def seekable(self) -> bool: ...
+    def readinto(self, buff: bytearray) -> int: ...
+    def read(self, size: Optional[int] = ...) -> AnyStr: ...
+    def readline(self, size: Optional[int] = ...) -> AnyStr: ...
+    def readlines(self, sizehint: Optional[int] = ...) -> List[AnyStr]: ...
+    def seek(self, offset: int, whence: int = ...) -> None: ...
+    def tell(self) -> int: ...
+    def write(self, data: AnyStr) -> None: ...
+    def writelines(self, sequence: Iterable[AnyStr]) -> None: ...
+    def xreadlines(self) -> BufferedFile: ...
+    @property
+    def closed(self) -> bool: ...

shared/package-files/2e/2eed95d9d64b0c4dcd8a7ebf8476d10ba5762f6eefeaf35c3f44abc9f45f8fb6/blob

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <torch/csrc/jit/tensorexpr/kernel.h>
+
+namespace torch {
+namespace jit {
+namespace tensorexpr {
+
+Tensor computeMatmul(
+    const std::vector<ArgValue>& inputs,
+    const std::vector<ExprHandle>& outputShape,
+    const std::vector<ExprHandle>& outputStrides,
+    const c10::optional<ScalarType>& outputType,
+    at::Device device);
+Tensor computeAddMM(
+    const std::vector<ArgValue>& inputs,
+    const std::vector<ExprHandle>& outputShape,
+    const std::vector<ExprHandle>& outputStrides,
+    const c10::optional<ScalarType>& outputType,
+    at::Device device);
+
+} // namespace tensorexpr
+} // namespace jit
+} // namespace torch

shared/package-files/2e/2eee023a23bca6fcc91e7cbd517a975efeaff648fa41ce8fbc2b0976dba35c7a/blob

@@ -0,0 +1,7 @@
+from torch.ao.nn.intrinsic.quantized import BNReLU2d
+from torch.ao.nn.intrinsic.quantized import BNReLU3d
+
+__all__ = [
+    'BNReLU2d',
+    'BNReLU3d',
+]