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

.gitattributes

@@ -661,3 +661,33 @@ shared/package-files/8a/8ac25926942fd2d950af21f4d44c867f080a1930719c78ad39b385e4
 shared/package-files/8a/8ad986ba46fc5e109cc6577e9fa6f3cc010ba312d7f4ce57c41ceaef8b7713a8/blob filter=lfs diff=lfs merge=lfs -text
 shared/package-files/8b/8b062c94aa3d3603fb6cfe6f79a17c9541f4d6cb03b79fe13c1b2514811b3441/blob filter=lfs diff=lfs merge=lfs -text
 shared/package-files/8b/8b511ea60575653c9ae0f6ed7c8e0c3fff8f837b6ec1d36414e0ce52529c54e4/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8b/8b77e6c948fb88a4c36fc94c5fac6b974e5d8cb0167dfba63cd0558b7e8fb4a2/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8b/8bac1070af4cf22f337ff5aaa8184c8f638229a9af3fb4fff630b919418fd47e/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8b/8badfd129686a5d20216b1aba16450f6f471722c8b6ddfc61278dd572283abc0/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8c/8c0b31952c785db21c12ee89a6919f196f37c6988d2a6e67dbc5f4a76b374c80/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8c/8c1e0aa212e2594fad2a3e7a964f58be3f0bebcff5d58c21e383252f4246cb29/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8c/8cbe5d21569103e83cc659ea0fbcb604479711feffc7cbc8f42d18d16fdec3e9/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8c/8cf47083fdd8d31bfa4d690671609e9dbe6e8be0d1e6fad6bcd19aabfd1c1393/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8d/8d52a949e0ca302330a392daad94829b54d353da60486150cbe059e0c64f7809/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8d/8d5ae8b518fb9ebeeecb8ae9b4938c39999724ee32105945c9b97f9ad43741a3/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8d/8db6e820fa88b1cec786e285d6becaf5d68c15f9266d7112cc3dae41f4beaf72/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8d/8dd79f3894a6b02fd3504c822889b5e754568ef02cba18b3649fa92719462997/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8e/8e4407820b776a4b85072983eebf370d315e382afa282065dfe7a06ad7cd1cae/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8e/8e5fb3e5090f1b8b279994f9cb5a5eee4a5b24fa449c9b742065f494bde6f2fc/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8e/8e73d0673b78407c09bf6ee46287f822c51dfe3927c3d8b44a0e020592cdd07f/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8e/8e839f2c461a3ac515aeab1c91336ae012878b6b0323e88f83e8fdf52966a897/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8e/8eda7d391f086bf1cc946e2321b7c1b9fb16e71ddaba1b9303ee496d2052b4d3/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8e/8edff6532664a50b5d7e29936d60c358506f94a5498606a953a6c601243e9299/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8e/8ef75af97e9a7f419439343a56de7cab5bd9467cdce745674e85099d82ac8ea4/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8f/8f08ba828f67e01006b79f343d1134b33657a7001d0ce5e1b964dd275b500e7f/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8f/8f78092b6539927132aebd28deb0e0d1b72f43596b79e074e3206f4a784dd000/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/8f/8f83378aaa0fd5fecd454eb3fc3e5f7ecb379990a5e40a37838d57fa3953598b/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/90/90708fbbce4c895ba7c413e5e91107a7b14c7d9a789cffd0be93657d91832678/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/90/90c6cb7fd3be8d363318f45257de6670ba19d9336d096dc3efb309bac88b2bf9/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/90/90daa30314af66948ae80c21871dda21a1a83bdafc675580390044c524c75325/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/91/917b32cedb7d14c961076c6206d91737b04ce14cf8058de12c95fdcb684632c2/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/91/91ad59d218af59b4cec410b351ef00c8752d29e9ffda8b15a501c0c7e08b9ed0/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/92/92bc9451b4920ac3713e4607abdc40daf4bb4d407e7d0b23ed952eae1e91b348/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/93/931d5ee943e952abef8c5b1ee511d27ceedca8179e2ed95c0d238ec65e4a7e82/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/93/934c22ded0e7d169c4d4678876c96051adf3d94545da962f60b41659b075da3b/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/93/93536616961eb1fab232f4a4dc87e37d7814f6763ac2c25e270ca13c55bfaeae/blob filter=lfs diff=lfs merge=lfs -text

shared/package-files/8b/8b71472317bf3adabf819e665c725d03e3064baa45f6ffbfd78cca83eaa46e8d/blob

@@ -0,0 +1,70 @@
+"""Fix incompatible renames
+
+Fixes:
+  * sys.maxint -> sys.maxsize
+"""
+# Author: Christian Heimes
+# based on Collin Winter's fix_import
+
+# Local imports
+from .. import fixer_base
+from ..fixer_util import Name, attr_chain
+
+MAPPING = {"sys":  {"maxint" : "maxsize"},
+          }
+LOOKUP = {}
+
+def alternates(members):
+    return "(" + "|".join(map(repr, members)) + ")"
+
+
+def build_pattern():
+    #bare = set()
+    for module, replace in list(MAPPING.items()):
+        for old_attr, new_attr in list(replace.items()):
+            LOOKUP[(module, old_attr)] = new_attr
+            #bare.add(module)
+            #bare.add(old_attr)
+            #yield """
+            #      import_name< 'import' (module=%r
+            #          | dotted_as_names< any* module=%r any* >) >
+            #      """ % (module, module)
+            yield """
+                  import_from< 'from' module_name=%r 'import'
+                      ( attr_name=%r | import_as_name< attr_name=%r 'as' any >) >
+                  """ % (module, old_attr, old_attr)
+            yield """
+                  power< module_name=%r trailer< '.' attr_name=%r > any* >
+                  """ % (module, old_attr)
+    #yield """bare_name=%s""" % alternates(bare)
+
+
+class FixRenames(fixer_base.BaseFix):
+    BM_compatible = True
+    PATTERN = "|".join(build_pattern())
+
+    order = "pre" # Pre-order tree traversal
+
+    # Don't match the node if it's within another match
+    def match(self, node):
+        match = super(FixRenames, self).match
+        results = match(node)
+        if results:
+            if any(match(obj) for obj in attr_chain(node, "parent")):
+                return False
+            return results
+        return False
+
+    #def start_tree(self, tree, filename):
+    #    super(FixRenames, self).start_tree(tree, filename)
+    #    self.replace = {}
+
+    def transform(self, node, results):
+        mod_name = results.get("module_name")
+        attr_name = results.get("attr_name")
+        #bare_name = results.get("bare_name")
+        #import_mod = results.get("module")
+
+        if mod_name and attr_name:
+            new_attr = LOOKUP[(mod_name.value, attr_name.value)]
+            attr_name.replace(Name(new_attr, prefix=attr_name.prefix))

shared/package-files/8b/8b720740d5d007214c0af8e3c9dfe1c302520a2523d33d6b4704bd5852b60057/blob

@@ -0,0 +1,196 @@
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.polys import QQ, ZZ
+from sympy.polys.polytools import Poly
+from sympy.polys.polyerrors import NotInvertible
+from sympy.polys.agca.extensions import FiniteExtension
+from sympy.polys.domainmatrix import DomainMatrix
+
+from sympy.testing.pytest import raises
+
+from sympy.abc import x, y, t
+
+
+def test_FiniteExtension():
+    # Gaussian integers
+    A = FiniteExtension(Poly(x**2 + 1, x))
+    assert A.rank == 2
+    assert str(A) == 'ZZ[x]/(x**2 + 1)'
+    i = A.generator
+    assert i.parent() is A
+
+    assert i*i == A(-1)
+    raises(TypeError, lambda: i*())
+
+    assert A.basis == (A.one, i)
+    assert A(1) == A.one
+    assert i**2 == A(-1)
+    assert i**2 != -1  # no coercion
+    assert (2 + i)*(1 - i) == 3 - i
+    assert (1 + i)**8 == A(16)
+    assert A(1).inverse() == A(1)
+    raises(NotImplementedError, lambda: A(2).inverse())
+
+    # Finite field of order 27
+    F = FiniteExtension(Poly(x**3 - x + 1, x, modulus=3))
+    assert F.rank == 3
+    a = F.generator  # also generates the cyclic group F - {0}
+    assert F.basis == (F(1), a, a**2)
+    assert a**27 == a
+    assert a**26 == F(1)
+    assert a**13 == F(-1)
+    assert a**9 == a + 1
+    assert a**3 == a - 1
+    assert a**6 == a**2 + a + 1
+    assert F(x**2 + x).inverse() == 1 - a
+    assert F(x + 2)**(-1) == F(x + 2).inverse()
+    assert a**19 * a**(-19) == F(1)
+    assert (a - 1) / (2*a**2 - 1) == a**2 + 1
+    assert (a - 1) // (2*a**2 - 1) == a**2 + 1
+    assert 2/(a**2 + 1) == a**2 - a + 1
+    assert (a**2 + 1)/2 == -a**2 - 1
+    raises(NotInvertible, lambda: F(0).inverse())
+
+    # Function field of an elliptic curve
+    K = FiniteExtension(Poly(t**2 - x**3 - x + 1, t, field=True))
+    assert K.rank == 2
+    assert str(K) == 'ZZ(x)[t]/(t**2 - x**3 - x + 1)'
+    y = K.generator
+    c = 1/(x**3 - x**2 + x - 1)
+    assert ((y + x)*(y - x)).inverse() == K(c)
+    assert (y + x)*(y - x)*c == K(1)  # explicit inverse of y + x
+
+
+def test_FiniteExtension_eq_hash():
+    # Test eq and hash
+    p1 = Poly(x**2 - 2, x, domain=ZZ)
+    p2 = Poly(x**2 - 2, x, domain=QQ)
+    K1 = FiniteExtension(p1)
+    K2 = FiniteExtension(p2)
+    assert K1 == FiniteExtension(Poly(x**2 - 2))
+    assert K2 != FiniteExtension(Poly(x**2 - 2))
+    assert len({K1, K2, FiniteExtension(p1)}) == 2
+
+
+def test_FiniteExtension_mod():
+    # Test mod
+    K = FiniteExtension(Poly(x**3 + 1, x, domain=QQ))
+    xf = K(x)
+    assert (xf**2 - 1) % 1 == K.zero
+    assert 1 % (xf**2 - 1) == K.zero
+    assert (xf**2 - 1) / (xf - 1) == xf + 1
+    assert (xf**2 - 1) // (xf - 1) == xf + 1
+    assert (xf**2 - 1) % (xf - 1) == K.zero
+    raises(ZeroDivisionError, lambda: (xf**2 - 1) % 0)
+    raises(TypeError, lambda: xf % [])
+    raises(TypeError, lambda: [] % xf)
+
+    # Test mod over ring
+    K = FiniteExtension(Poly(x**3 + 1, x, domain=ZZ))
+    xf = K(x)
+    assert (xf**2 - 1) % 1 == K.zero
+    raises(NotImplementedError, lambda: (xf**2 - 1) % (xf - 1))
+
+
+def test_FiniteExtension_from_sympy():
+    # Test to_sympy/from_sympy
+    K = FiniteExtension(Poly(x**3 + 1, x, domain=ZZ))
+    xf = K(x)
+    assert K.from_sympy(x) == xf
+    assert K.to_sympy(xf) == x
+
+
+def test_FiniteExtension_set_domain():
+    KZ = FiniteExtension(Poly(x**2 + 1, x, domain='ZZ'))
+    KQ = FiniteExtension(Poly(x**2 + 1, x, domain='QQ'))
+    assert KZ.set_domain(QQ) == KQ
+
+
+def test_FiniteExtension_exquo():
+    # Test exquo
+    K = FiniteExtension(Poly(x**4 + 1))
+    xf = K(x)
+    assert K.exquo(xf**2 - 1, xf - 1) == xf + 1
+
+
+def test_FiniteExtension_convert():
+    # Test from_MonogenicFiniteExtension
+    K1 = FiniteExtension(Poly(x**2 + 1))
+    K2 = QQ[x]
+    x1, x2 = K1(x), K2(x)
+    assert K1.convert(x2) == x1
+    assert K2.convert(x1) == x2
+
+    K = FiniteExtension(Poly(x**2 - 1, domain=QQ))
+    assert K.convert_from(QQ(1, 2), QQ) == K.one/2
+
+
+def test_FiniteExtension_division_ring():
+    # Test division in FiniteExtension over a ring
+    KQ = FiniteExtension(Poly(x**2 - 1, x, domain=QQ))
+    KZ = FiniteExtension(Poly(x**2 - 1, x, domain=ZZ))
+    KQt = FiniteExtension(Poly(x**2 - 1, x, domain=QQ[t]))
+    KQtf = FiniteExtension(Poly(x**2 - 1, x, domain=QQ.frac_field(t)))
+    assert KQ.is_Field is True
+    assert KZ.is_Field is False
+    assert KQt.is_Field is False
+    assert KQtf.is_Field is True
+    for K in KQ, KZ, KQt, KQtf:
+        xK = K.convert(x)
+        assert xK / K.one == xK
+        assert xK // K.one == xK
+        assert xK % K.one == K.zero
+        raises(ZeroDivisionError, lambda: xK / K.zero)
+        raises(ZeroDivisionError, lambda: xK // K.zero)
+        raises(ZeroDivisionError, lambda: xK % K.zero)
+        if K.is_Field:
+            assert xK / xK == K.one
+            assert xK // xK == K.one
+            assert xK % xK == K.zero
+        else:
+            raises(NotImplementedError, lambda: xK / xK)
+            raises(NotImplementedError, lambda: xK // xK)
+            raises(NotImplementedError, lambda: xK % xK)
+
+
+def test_FiniteExtension_Poly():
+    K = FiniteExtension(Poly(x**2 - 2))
+    p = Poly(x, y, domain=K)
+    assert p.domain == K
+    assert p.as_expr() == x
+    assert (p**2).as_expr() == 2
+
+    K = FiniteExtension(Poly(x**2 - 2, x, domain=QQ))
+    K2 = FiniteExtension(Poly(t**2 - 2, t, domain=K))
+    assert str(K2) == 'QQ[x]/(x**2 - 2)[t]/(t**2 - 2)'
+
+    eK = K2.convert(x + t)
+    assert K2.to_sympy(eK) == x + t
+    assert K2.to_sympy(eK ** 2) == 4 + 2*x*t
+    p = Poly(x + t, y, domain=K2)
+    assert p**2 == Poly(4 + 2*x*t, y, domain=K2)
+
+
+def test_FiniteExtension_sincos_jacobian():
+    # Use FiniteExtensino to compute the Jacobian of a matrix involving sin
+    # and cos of different symbols.
+    r, p, t = symbols('rho, phi, theta')
+    elements = [
+        [sin(p)*cos(t), r*cos(p)*cos(t), -r*sin(p)*sin(t)],
+        [sin(p)*sin(t), r*cos(p)*sin(t),  r*sin(p)*cos(t)],
+        [       cos(p),       -r*sin(p),                0],
+    ]
+
+    def make_extension(K):
+        K = FiniteExtension(Poly(sin(p)**2+cos(p)**2-1, sin(p), domain=K[cos(p)]))
+        K = FiniteExtension(Poly(sin(t)**2+cos(t)**2-1, sin(t), domain=K[cos(t)]))
+        return K
+
+    Ksc1 = make_extension(ZZ[r])
+    Ksc2 = make_extension(ZZ)[r]
+
+    for K in [Ksc1, Ksc2]:
+        elements_K = [[K.convert(e) for e in row] for row in elements]
+        J = DomainMatrix(elements_K, (3, 3), K)
+        det = J.charpoly()[-1] * (-K.one)**3
+        assert det == K.convert(r**2*sin(p))

shared/package-files/8b/8b733ea1edb0f9d08a0245ea92a765985b083b214a570d5fb50799bacd9c3be6/blob

@@ -0,0 +1,89 @@
+# Copyright (c) 2008-2011 by Enthought, Inc.
+# Copyright (c) 2013-2015 Continuum Analytics, Inc.
+# All rights reserved.
+
+from __future__ import absolute_import
+
+import json
+import logging
+import sys
+from os.path import abspath, basename, exists, join
+
+try:
+    from .._version import __version__
+except ImportError:
+    __version__ = "dev"
+
+from ..utils import DEFAULT_BASE_PREFIX, DEFAULT_PREFIX
+
+if sys.platform == 'win32':
+    from ..platforms.win_utils.win_elevate import isUserAdmin, runAsAdmin
+    from .win32 import Menu, ShortCut
+
+
+def _install(path, remove=False, prefix=None, mode=None, root_prefix=None):
+    prefix = prefix or DEFAULT_PREFIX
+    root_prefix = root_prefix or DEFAULT_BASE_PREFIX
+    if abspath(prefix) == abspath(root_prefix):
+        env_name = None
+    else:
+        env_name = basename(prefix)
+
+    data = json.load(open(path))
+    try:
+        menu_name = data['menu_name']
+    except KeyError:
+        menu_name = 'Python-%d.%d' % sys.version_info[:2]
+
+    shortcuts = data['menu_items']
+    m = Menu(menu_name, prefix=prefix, env_name=env_name, mode=mode, root_prefix=root_prefix)
+    if remove:
+        for sc in shortcuts:
+            ShortCut(m, sc).remove()
+        m.remove()
+    else:
+        m.create()
+        for sc in shortcuts:
+            ShortCut(m, sc).create()
+
+
+def install(path, remove=False, prefix=None, recursing=False, root_prefix=None):
+    """
+    Install Menu and shortcuts
+
+    # Specifying `root_prefix` is used with conda-standalone, because we can't use
+    # `sys.prefix`, therefore we need to specify it
+    """
+    prefix = prefix or DEFAULT_PREFIX
+    root_prefix = root_prefix or DEFAULT_BASE_PREFIX
+    if not sys.platform == 'win32':
+        raise RuntimeError("menuinst._legacy is only supported on Windows.")
+
+    # this root_prefix is intentional.  We want to reflect the state of the root installation.
+
+    if not exists(join(root_prefix, '.nonadmin')):
+        if isUserAdmin():
+            _install(path, remove, prefix, mode='system', root_prefix=root_prefix)
+        else:
+            retcode = 1
+            try:
+                if not recursing:
+                    retcode = runAsAdmin(
+                        [
+                            join(root_prefix, 'python'),
+                            '-c',
+                            "import menuinst; menuinst.install(%r, %r, %r, %r, %r)"
+                            % (path, bool(remove), prefix, True, root_prefix),
+                        ]
+                    )
+            except OSError:
+                pass
+
+            if retcode != 0:
+                logging.warn(
+                    "Insufficient permissions to write menu folder.  "
+                    "Falling back to user location"
+                )
+                _install(path, remove, prefix, mode='user', root_prefix=root_prefix)
+    else:
+        _install(path, remove, prefix, mode='user', root_prefix=root_prefix)

shared/package-files/8b/8b77e6c948fb88a4c36fc94c5fac6b974e5d8cb0167dfba63cd0558b7e8fb4a2/blob

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b77e6c948fb88a4c36fc94c5fac6b974e5d8cb0167dfba63cd0558b7e8fb4a2
+size 84693320

shared/package-files/8b/8b784d08319ab7ff0320c1c5a36d9db3dc77e12ca55f6abd56ef9610b022fed5/blob

@@ -0,0 +1,81 @@
+#pragma once
+#include <c10/util/ApproximateClock.h>
+#include <torch/csrc/autograd/profiler.h>
+
+namespace c10d {
+constexpr int kUnsetTime = -1;
+
+inline int64_t current_time_in_nanos() {
+  return c10::getTime();
+}
+
+class TORCH_API Timer {
+ private:
+  // The timestamp of forward call start time in each iteration.
+  int64_t forward_start_time = kUnsetTime;
+  // The timestamp of backward computation start and end time in each
+  // iteration.
+  int64_t backward_compute_start_time = kUnsetTime;
+  int64_t backward_compute_end_time = kUnsetTime;
+  // The timestamp of first communication call start time in each iteration.
+  int64_t backward_comm_start_time = kUnsetTime;
+  // The timestamp of last communication call end time in each iteration.
+  int64_t backward_comm_end_time = kUnsetTime;
+
+ public:
+  enum class Event {
+    kForwardStart,
+    kBackwardComputeStart,
+    kBackwardComputeEnd,
+    kBackwardCommStart,
+    kBackwardCommEnd,
+  };
+
+  // Record the current event, i.e., mark it as having occurred now. Default
+  // CPU implementation.
+  virtual void record(Event event) {
+    getTimeRef(event) = current_time_in_nanos();
+  }
+
+  // Return the difference between when two events occurred, in nanoseconds.
+  // Or nullopt if one of them hasn't been recorded.
+  virtual c10::optional<int64_t> measureDifference(Event start, Event end) = 0;
+
+  virtual ~Timer() = default;
+
+  // Return host-side timestamp, or nullopt if it has not yet been recorded.
+  c10::optional<int64_t> getTimestamp(Event event) {
+    auto time = getTimeRef(event);
+    if (time == kUnsetTime) {
+      return c10::nullopt;
+    } else {
+      return time;
+    }
+  }
+
+  // Return host-side time member variable corresponding to the given event.
+  int64_t& getTimeRef(Event event) {
+    switch (event) {
+      case Event::kForwardStart:
+        return forward_start_time;
+      case Event::kBackwardComputeStart:
+        return backward_compute_start_time;
+      case Event::kBackwardComputeEnd:
+        return backward_compute_end_time;
+      case Event::kBackwardCommStart:
+        return backward_comm_start_time;
+      case Event::kBackwardCommEnd:
+        return backward_comm_end_time;
+      default:
+        TORCH_INTERNAL_ASSERT(false);
+    }
+  }
+};
+
+TORCH_DECLARE_TYPED_REGISTRY(
+    TimerRegistry,
+    c10::DeviceType,
+    Timer,
+    std::unique_ptr,
+    c10::Device);
+} // namespace c10d

shared/package-files/8b/8b78797c860c531e3ffcca1cecca52d532df2bc4aedfe8857dab8e5d70146f86/blob

@@ -0,0 +1,550 @@
+"""
+Distance dependence measure and the dCov test
+
+Implementation of Székely et al. (2007) calculation of distance
+dependence statistics, including the Distance covariance (dCov) test
+for independence of random vectors of arbitrary length.
+
+Author: Ron Itzikovitch
+
+References
+----------
+.. Szekely, G.J., Rizzo, M.L., and Bakirov, N.K. (2007)
+   "Measuring and testing dependence by correlation of distances".
+   Annals of Statistics, Vol. 35 No. 6, pp. 2769-2794.
+
+"""
+
+from typing import NamedTuple
+import warnings
+
+import numpy as np
+from scipy.spatial.distance import pdist, squareform
+from scipy.stats import norm
+
+from statsmodels.tools.rng_qrng import check_random_state
+from statsmodels.tools.sm_exceptions import HypothesisTestWarning
+from statsmodels.tools.validation import string_like
+
+
+class DistDependStat(NamedTuple):
+    """
+    Result of :func:`distance_statistics`.
+
+    Parameters
+    ----------
+    test_statistic : float
+        The "basic" test statistic (i.e., the one used when the `emp`
+        method is chosen when calling ``distance_covariance_test()``).
+    distance_correlation : float
+        The distance correlation between `x` and `y`.
+    distance_covariance : float
+        The distance covariance of `x` and `y`.
+    dvar_x : float
+        The distance variance of `x`.
+    dvar_y : float
+        The distance variance of `y`.
+    S : float
+        The mean of the euclidean distances in `x` multiplied by those
+        of `y`. Mostly used internally.
+    """
+
+    test_statistic: float
+    distance_correlation: float
+    distance_covariance: float
+    dvar_x: float
+    dvar_y: float
+    S: float
+
+
+def distance_covariance_test(x, y, B=None, method="auto", rng=None):
+    r"""
+    The Distance Covariance (dCov) test
+
+    Apply the Distance Covariance (dCov) test of independence to `x` and `y`.
+    This test was introduced in [1]_, and is based on the distance covariance
+    statistic. The test is applicable to random vectors of arbitrary length
+    (see the notes section for more details).
+
+    Parameters
+    ----------
+    x : array_like, 1-D or 2-D
+        If `x` is 1-D than it is assumed to be a vector of observations of a
+        single random variable. If `x` is 2-D than the rows should be
+        observations and the columns are treated as the components of a
+        random vector, i.e., each column represents a different component of
+        the random vector `x`.
+    y : array_like, 1-D or 2-D
+        Same as `x`, but only the number of observation has to match that of
+        `x`. If `y` is 2-D note that the number of columns of `y` (i.e., the
+        number of components in the random vector) does not need to match
+        the number of columns in `x`.
+    B : int, optional
+        The number of iterations to perform when evaluating the null
+        distribution of the test statistic when the `emp` method is
+        applied (see below). if `B` is `None` than as in [1]_ we set
+        `B` to be ``B = 200 + 5000/n``, where `n` is the number of
+        observations.
+    method : {'auto', 'emp', 'asym'}, optional
+        The method by which to obtain the p-value for the test.
+
+        - `auto` : Default method. The number of observations will be used to
+          determine the method.
+        - `emp` : Empirical evaluation of the p-value using permutations of
+          the rows of `y` to obtain the null distribution.
+        - `asym` : An asymptotic approximation of the distribution of the test
+          statistic is used to find the p-value.
+
+    rng : int, array_like of int, numpy.random.Generator, numpy.random.RandomState, optional
+        If `rng` is None, a new ``Generator`` is created using fresh
+        entropy from the operating system. If `rng` is an int or array
+        of ints, a new ``Generator`` is created, seeded with `rng`. If
+        `rng` is already a ``Generator`` or ``RandomState`` instance,
+        that instance is used.
+
+    Returns
+    -------
+    test_statistic : float
+        The value of the test statistic used in the test.
+    pval : float
+        The p-value.
+    chosen_method : str
+        The method that was used to obtain the p-value. Mostly relevant when
+        the function is called with `method='auto'`.
+
+    Notes
+    -----
+    The test applies to random vectors of arbitrary dimensions, i.e., `x`
+    can be a 1-D vector of observations for a single random variable while
+    `y` can be a `k` by `n` 2-D array (where `k > 1`). In other words, it
+    is also possible for `x` and `y` to both be 2-D arrays and have the
+    same number of rows (observations) while differing in the number of
+    columns.
+
+    As noted in [1]_ the statistics are sensitive to all types of departures
+    from independence, including nonlinear or nonmonotone dependence
+    structure.
+
+    References
+    ----------
+    .. [1] Szekely, G.J., Rizzo, M.L., and Bakirov, N.K. (2007)
+       "Measuring and testing dependence by correlation of distances".
+       Annals of Statistics, Vol. 35 No. 6, pp. 2769-2794.
+
+    Examples
+    --------
+    >>> from statsmodels.stats.dist_dependence_measures import
+    ... distance_covariance_test
+    >>> data = np.random.rand(1000, 10)
+    >>> x, y = data[:, :3], data[:, 3:]
+    >>> x.shape
+    (1000, 3)
+    >>> y.shape
+    (1000, 7)
+    >>> distance_covariance_test(x, y)
+    (1.0426404792714983, 0.2971148340813543, 'asym')
+    # (test_statistic, pval, chosen_method)
+
+    """
+    x, y = _validate_and_tranform_x_and_y(x, y)
+
+    method = string_like(
+        method, "method", options=("auto", "emp", "asym"), lower=False
+    )
+
+    n = x.shape[0]
+    stats = distance_statistics(x, y)
+
+    if (method == "auto" and n <= 500) or method == "emp":
+        chosen_method = "emp"
+        rng = check_random_state(rng)
+        test_statistic, pval = _empirical_pvalue(x, y, B, n, stats, rng)
+
+    else:  # method == "asym", or method == "auto" and n > 500
+        chosen_method = "asym"
+        test_statistic, pval = _asymptotic_pvalue(stats)
+
+    # In case we got an extreme p-value (0 or 1) when using the empirical
+    # distribution of the test statistic under the null, we fall back
+    # to the asymptotic approximation.
+    if chosen_method == "emp" and pval in [0, 1]:
+        msg = (
+            f"p-value was {pval} when using the empirical method. "
+            "The asymptotic approximation will be used instead"
+        )
+        warnings.warn(msg, HypothesisTestWarning, stacklevel=2)
+        _, pval = _asymptotic_pvalue(stats)
+
+    return test_statistic, pval, chosen_method
+
+
+def _validate_and_tranform_x_and_y(x, y):
+    r"""
+    Ensure `x` and `y` have proper shape and transform/reshape them if required
+
+    Parameters
+    ----------
+    x : array_like, 1-D or 2-D
+        If `x` is 1-D than it is assumed to be a vector of observations of a
+        single random variable. If `x` is 2-D than the rows should be
+        observations and the columns are treated as the components of a
+        random vector, i.e., each column represents a different component of
+        the random vector `x`.
+    y : array_like, 1-D or 2-D
+        Same as `x`, but only the number of observation has to match that of
+        `x`. If `y` is 2-D note that the number of columns of `y` (i.e., the
+        number of components in the random vector) does not need to match
+        the number of columns in `x`.
+
+    Returns
+    -------
+    x : ndarray, 2-D
+    y : ndarray, 2-D
+
+    Raises
+    ------
+    ValueError
+        If `x` and `y` have a different number of observations.
+
+    """
+    x = np.asanyarray(x)
+    y = np.asanyarray(y)
+
+    if x.shape[0] != y.shape[0]:
+        raise ValueError("x and y must have the same number of observations (rows).")
+
+    if len(x.shape) == 1:
+        x = x.reshape((x.shape[0], 1))
+
+    if len(y.shape) == 1:
+        y = y.reshape((y.shape[0], 1))
+
+    return x, y
+
+
+def _empirical_pvalue(x, y, B, n, stats, rng):
+    r"""
+    Calculate the empirical p-value based on permutations of `y`'s rows
+
+    Parameters
+    ----------
+    x : array_like, 1-D or 2-D
+        If `x` is 1-D than it is assumed to be a vector of observations of a
+        single random variable. If `x` is 2-D than the rows should be
+        observations and the columns are treated as the components of a
+        random vector, i.e., each column represents a different component of
+        the random vector `x`.
+    y : array_like, 1-D or 2-D
+        Same as `x`, but only the number of observation has to match that of
+        `x`. If `y` is 2-D note that the number of columns of `y` (i.e., the
+        number of components in the random vector) does not need to match
+        the number of columns in `x`.
+    B : int
+        The number of iterations when evaluating the null distribution.
+    n : int
+        Number of observations found in each of `x` and `y`.
+    stats : DistDependStat
+        The result obtained from calling ``distance_statistics(x, y)``.
+    rng : int, array_like of int, numpy.random.Generator, numpy.random.RandomState, optional
+        If `rng` is None, a new ``Generator`` is created using fresh
+        entropy from the operating system. If `rng` is an int or array
+        of ints, a new ``Generator`` is created, seeded with `rng`. If
+        `rng` is already a ``Generator`` or ``RandomState`` instance,
+        that instance is used.
+
+    Returns
+    -------
+    test_statistic : float
+        The empirical test statistic.
+    pval : float
+        The empirical p-value.
+
+    """
+    B = int(B) if B else int(np.floor(200 + 5000 / n))
+    empirical_dist = _get_test_statistic_distribution(x, y, B, rng)
+    pval = 1 - np.searchsorted(sorted(empirical_dist), stats.test_statistic) / len(
+        empirical_dist
+    )
+    test_statistic = stats.test_statistic
+
+    return test_statistic, pval
+
+
+def _asymptotic_pvalue(stats):
+    r"""
+    Calculate the p-value using an asymptotic approximation of the null distribution
+
+    Parameters
+    ----------
+    stats : DistDependStat
+        The result obtained from calling ``distance_statistics(x, y)``.
+
+    Returns
+    -------
+    test_statistic : float
+        The test statistic.
+    pval : float
+        The asymptotic p-value.
+
+    """
+    test_statistic = np.sqrt(stats.test_statistic / stats.S)
+    pval = (1 - norm.cdf(test_statistic)) * 2
+
+    return test_statistic, pval
+
+
+def _get_test_statistic_distribution(x, y, B, rng):
+    r"""
+    Compute the empirical distribution of the test statistic under permutation
+
+    Parameters
+    ----------
+    x : array_like, 1-D or 2-D
+        If `x` is 1-D than it is assumed to be a vector of observations of a
+        single random variable. If `x` is 2-D than the rows should be
+        observations and the columns are treated as the components of a
+        random vector, i.e., each column represents a different component of
+        the random vector `x`.
+    y : array_like, 1-D or 2-D
+        Same as `x`, but only the number of observation has to match that of
+        `x`. If `y` is 2-D note that the number of columns of `y` (i.e., the
+        number of components in the random vector) does not need to match
+        the number of columns in `x`.
+    B : int
+        The number of iterations to perform when evaluating the null
+        distribution.
+    rng : int, array_like of int, numpy.random.Generator, numpy.random.RandomState, optional
+        If `rng` is None, a new ``Generator`` is created using fresh
+        entropy from the operating system. If `rng` is an int or array
+        of ints, a new ``Generator`` is created, seeded with `rng`. If
+        `rng` is already a ``Generator`` or ``RandomState`` instance,
+        that instance is used.
+
+    Returns
+    -------
+    emp_dist : ndarray
+        The empirical distribution of the test statistic.
+
+    """
+    y = y.copy()
+    emp_dist = np.zeros(B)
+    x_dist = squareform(pdist(x, "euclidean"))
+    for i in range(B):
+        rng.shuffle(y)
+        emp_dist[i] = distance_statistics(x, y, x_dist=x_dist).test_statistic
+
+    return emp_dist
+
+
+def distance_statistics(x, y, x_dist=None, y_dist=None):
+    r"""
+    Calculate various distance dependence statistics
+
+    Calculate several distance dependence statistics as described in [1]_.
+
+    Parameters
+    ----------
+    x : array_like, 1-D or 2-D
+        If `x` is 1-D than it is assumed to be a vector of observations of a
+        single random variable. If `x` is 2-D than the rows should be
+        observations and the columns are treated as the components of a
+        random vector, i.e., each column represents a different component of
+        the random vector `x`.
+    y : array_like, 1-D or 2-D
+        Same as `x`, but only the number of observation has to match that of
+        `x`. If `y` is 2-D note that the number of columns of `y` (i.e., the
+        number of components in the random vector) does not need to match
+        the number of columns in `x`.
+    x_dist : array_like, 2-D, optional
+        A square 2-D array_like object whose values are the euclidean
+        distances between `x`'s rows.
+    y_dist : array_like, 2-D, optional
+        A square 2-D array_like object whose values are the euclidean
+        distances between `y`'s rows.
+
+    Returns
+    -------
+    DistDependStat
+        A named tuple of distance dependence statistics. See
+        :class:`DistDependStat` for the full list of fields.
+
+    References
+    ----------
+    .. [1] Szekely, G.J., Rizzo, M.L., and Bakirov, N.K. (2007)
+       "Measuring and testing dependence by correlation of distances".
+       Annals of Statistics, Vol. 35 No. 6, pp. 2769-2794.
+
+    Examples
+    --------
+
+    >>> from statsmodels.stats.dist_dependence_measures import
+    ... distance_statistics
+    >>> distance_statistics(np.random.random(1000), np.random.random(1000))
+    DistDependStat(test_statistic=0.07948284320205831,
+    distance_correlation=0.04269511890990793,
+    distance_covariance=0.008915315092696293,
+    dvar_x=0.20719027438266704, dvar_y=0.21044934264957588,
+    S=0.10892061635588891)
+
+    """
+    x, y = _validate_and_tranform_x_and_y(x, y)
+
+    n = x.shape[0]
+
+    a = x_dist if x_dist is not None else squareform(pdist(x, "euclidean"))
+    b = y_dist if y_dist is not None else squareform(pdist(y, "euclidean"))
+
+    a_row_means = a.mean(axis=0, keepdims=True)
+    b_row_means = b.mean(axis=0, keepdims=True)
+    a_col_means = a.mean(axis=1, keepdims=True)
+    b_col_means = b.mean(axis=1, keepdims=True)
+    a_mean = a.mean()
+    b_mean = b.mean()
+
+    A = a - a_row_means - a_col_means + a_mean
+    B = b - b_row_means - b_col_means + b_mean
+
+    S = a_mean * b_mean
+    dcov = np.sqrt(np.multiply(A, B).mean())
+    dvar_x = np.sqrt(np.multiply(A, A).mean())
+    dvar_y = np.sqrt(np.multiply(B, B).mean())
+    dcor = dcov / np.sqrt(dvar_x * dvar_y)
+
+    test_statistic = n * dcov**2
+
+    return DistDependStat(
+        test_statistic=test_statistic,
+        distance_correlation=dcor,
+        distance_covariance=dcov,
+        dvar_x=dvar_x,
+        dvar_y=dvar_y,
+        S=S,
+    )
+
+
+def distance_covariance(x, y):
+    r"""
+    Distance covariance
+
+    Calculate the empirical distance covariance as described in [1]_.
+
+    Parameters
+    ----------
+    x : array_like, 1-D or 2-D
+        If `x` is 1-D than it is assumed to be a vector of observations of a
+        single random variable. If `x` is 2-D than the rows should be
+        observations and the columns are treated as the components of a
+        random vector, i.e., each column represents a different component of
+        the random vector `x`.
+    y : array_like, 1-D or 2-D
+        Same as `x`, but only the number of observation has to match that of
+        `x`. If `y` is 2-D note that the number of columns of `y` (i.e., the
+        number of components in the random vector) does not need to match
+        the number of columns in `x`.
+
+    Returns
+    -------
+    float
+        The empirical distance covariance between `x` and `y`.
+
+    References
+    ----------
+    .. [1] Szekely, G.J., Rizzo, M.L., and Bakirov, N.K. (2007)
+       "Measuring and testing dependence by correlation of distances".
+       Annals of Statistics, Vol. 35 No. 6, pp. 2769-2794.
+
+    Examples
+    --------
+
+    >>> from statsmodels.stats.dist_dependence_measures import
+    ... distance_covariance
+    >>> distance_covariance(np.random.random(1000), np.random.random(1000))
+    0.007575063951951362
+
+    """
+    return distance_statistics(x, y).distance_covariance
+
+
+def distance_variance(x):
+    r"""
+    Distance variance
+
+    Calculate the empirical distance variance as described in [1]_.
+
+    Parameters
+    ----------
+    x : array_like, 1-D or 2-D
+        If `x` is 1-D than it is assumed to be a vector of observations of a
+        single random variable. If `x` is 2-D than the rows should be
+        observations and the columns are treated as the components of a
+        random vector, i.e., each column represents a different component of
+        the random vector `x`.
+
+    Returns
+    -------
+    float
+        The empirical distance variance of `x`.
+
+    References
+    ----------
+    .. [1] Szekely, G.J., Rizzo, M.L., and Bakirov, N.K. (2007)
+       "Measuring and testing dependence by correlation of distances".
+       Annals of Statistics, Vol. 35 No. 6, pp. 2769-2794.
+
+    Examples
+    --------
+
+    >>> from statsmodels.stats.dist_dependence_measures import
+    ... distance_variance
+    >>> distance_variance(np.random.random(1000))
+    0.21732609190659702
+
+    """
+    return distance_covariance(x, x)
+
+
+def distance_correlation(x, y):
+    r"""
+    Distance correlation
+
+    Calculate the empirical distance correlation as described in [1]_.
+    This statistic is analogous to product-moment correlation and describes
+    the dependence between `x` and `y`, which are random vectors of
+    arbitrary length. The statistics' values range between 0 (implies
+    independence) and 1 (implies complete dependence).
+
+    Parameters
+    ----------
+    x : array_like, 1-D or 2-D
+        If `x` is 1-D than it is assumed to be a vector of observations of a
+        single random variable. If `x` is 2-D than the rows should be
+        observations and the columns are treated as the components of a
+        random vector, i.e., each column represents a different component of
+        the random vector `x`.
+    y : array_like, 1-D or 2-D
+        Same as `x`, but only the number of observation has to match that of
+        `x`. If `y` is 2-D note that the number of columns of `y` (i.e., the
+        number of components in the random vector) does not need to match
+        the number of columns in `x`.
+
+    Returns
+    -------
+    float
+        The empirical distance correlation between `x` and `y`.
+
+    References
+    ----------
+    .. [1] Szekely, G.J., Rizzo, M.L., and Bakirov, N.K. (2007)
+       "Measuring and testing dependence by correlation of distances".
+       Annals of Statistics, Vol. 35 No. 6, pp. 2769-2794.
+
+    Examples
+    --------
+
+    >>> from statsmodels.stats.dist_dependence_measures import
+    ... distance_correlation
+    >>> distance_correlation(np.random.random(1000), np.random.random(1000))
+    0.04060497840149489
+
+    """
+    return distance_statistics(x, y).distance_correlation

shared/package-files/8b/8b790ac38c4ee3ff7d7c93753bba315c694f53ea8c24a0cf8ab6d6693c3be93a/blob

@@ -0,0 +1,365 @@
+import math
+from typing import List, Optional, Tuple
+
+import PIL.Image
+import torch
+from torch.nn.functional import conv2d, pad as torch_pad
+
+from torchvision import tv_tensors
+from torchvision.transforms._functional_tensor import _max_value
+from torchvision.transforms.functional import pil_to_tensor, to_pil_image
+
+from torchvision.utils import _log_api_usage_once
+
+from ._meta import _convert_bounding_box_format
+
+from ._utils import _get_kernel, _register_kernel_internal, is_pure_tensor
+
+
+def normalize(
+    inpt: torch.Tensor,
+    mean: List[float],
+    std: List[float],
+    inplace: bool = False,
+) -> torch.Tensor:
+    """See :class:`~torchvision.transforms.v2.Normalize` for details."""
+    if torch.jit.is_scripting():
+        return normalize_image(inpt, mean=mean, std=std, inplace=inplace)
+
+    _log_api_usage_once(normalize)
+
+    kernel = _get_kernel(normalize, type(inpt))
+    return kernel(inpt, mean=mean, std=std, inplace=inplace)
+
+
+@_register_kernel_internal(normalize, torch.Tensor)
+@_register_kernel_internal(normalize, tv_tensors.Image)
+def normalize_image(image: torch.Tensor, mean: List[float], std: List[float], inplace: bool = False) -> torch.Tensor:
+    if not image.is_floating_point():
+        raise TypeError(f"Input tensor should be a float tensor. Got {image.dtype}.")
+
+    if image.ndim < 3:
+        raise ValueError(f"Expected tensor to be a tensor image of size (..., C, H, W). Got {image.shape}.")
+
+    if isinstance(std, (tuple, list)):
+        divzero = not all(std)
+    elif isinstance(std, (int, float)):
+        divzero = std == 0
+    else:
+        divzero = False
+    if divzero:
+        raise ValueError("std evaluated to zero, leading to division by zero.")
+
+    dtype = image.dtype
+    device = image.device
+    mean = torch.as_tensor(mean, dtype=dtype, device=device)
+    std = torch.as_tensor(std, dtype=dtype, device=device)
+    if mean.ndim == 1:
+        mean = mean.view(-1, 1, 1)
+    if std.ndim == 1:
+        std = std.view(-1, 1, 1)
+
+    if inplace:
+        image = image.sub_(mean)
+    else:
+        image = image.sub(mean)
+
+    return image.div_(std)
+
+
+@_register_kernel_internal(normalize, tv_tensors.Video)
+def normalize_video(video: torch.Tensor, mean: List[float], std: List[float], inplace: bool = False) -> torch.Tensor:
+    return normalize_image(video, mean, std, inplace=inplace)
+
+
+def gaussian_blur(inpt: torch.Tensor, kernel_size: List[int], sigma: Optional[List[float]] = None) -> torch.Tensor:
+    """See :class:`~torchvision.transforms.v2.GaussianBlur` for details."""
+    if torch.jit.is_scripting():
+        return gaussian_blur_image(inpt, kernel_size=kernel_size, sigma=sigma)
+
+    _log_api_usage_once(gaussian_blur)
+
+    kernel = _get_kernel(gaussian_blur, type(inpt))
+    return kernel(inpt, kernel_size=kernel_size, sigma=sigma)
+
+
+def _get_gaussian_kernel1d(kernel_size: int, sigma: float, dtype: torch.dtype, device: torch.device) -> torch.Tensor:
+    lim = (kernel_size - 1) / (2.0 * math.sqrt(2.0) * sigma)
+    x = torch.linspace(-lim, lim, steps=kernel_size, dtype=dtype, device=device)
+    kernel1d = torch.softmax(x.pow_(2).neg_(), dim=0)
+    return kernel1d
+
+
+def _get_gaussian_kernel2d(
+    kernel_size: List[int], sigma: List[float], dtype: torch.dtype, device: torch.device
+) -> torch.Tensor:
+    kernel1d_x = _get_gaussian_kernel1d(kernel_size[0], sigma[0], dtype, device)
+    kernel1d_y = _get_gaussian_kernel1d(kernel_size[1], sigma[1], dtype, device)
+    kernel2d = kernel1d_y.unsqueeze(-1) * kernel1d_x
+    return kernel2d
+
+
+@_register_kernel_internal(gaussian_blur, torch.Tensor)
+@_register_kernel_internal(gaussian_blur, tv_tensors.Image)
+def gaussian_blur_image(
+    image: torch.Tensor, kernel_size: List[int], sigma: Optional[List[float]] = None
+) -> torch.Tensor:
+    # TODO: consider deprecating integers from sigma on the future
+    if isinstance(kernel_size, int):
+        kernel_size = [kernel_size, kernel_size]
+    elif len(kernel_size) != 2:
+        raise ValueError(f"If kernel_size is a sequence its length should be 2. Got {len(kernel_size)}")
+    for ksize in kernel_size:
+        if ksize % 2 == 0 or ksize < 0:
+            raise ValueError(f"kernel_size should have odd and positive integers. Got {kernel_size}")
+
+    if sigma is None:
+        sigma = [ksize * 0.15 + 0.35 for ksize in kernel_size]
+    else:
+        if isinstance(sigma, (list, tuple)):
+            length = len(sigma)
+            if length == 1:
+                s = float(sigma[0])
+                sigma = [s, s]
+            elif length != 2:
+                raise ValueError(f"If sigma is a sequence, its length should be 2. Got {length}")
+        elif isinstance(sigma, (int, float)):
+            s = float(sigma)
+            sigma = [s, s]
+        else:
+            raise TypeError(f"sigma should be either float or sequence of floats. Got {type(sigma)}")
+    for s in sigma:
+        if s <= 0.0:
+            raise ValueError(f"sigma should have positive values. Got {sigma}")
+
+    if image.numel() == 0:
+        return image
+
+    dtype = image.dtype
+    shape = image.shape
+    ndim = image.ndim
+    if ndim == 3:
+        image = image.unsqueeze(dim=0)
+    elif ndim > 4:
+        image = image.reshape((-1,) + shape[-3:])
+
+    fp = torch.is_floating_point(image)
+    kernel = _get_gaussian_kernel2d(kernel_size, sigma, dtype=dtype if fp else torch.float32, device=image.device)
+    kernel = kernel.expand(shape[-3], 1, kernel.shape[0], kernel.shape[1])
+
+    output = image if fp else image.to(dtype=torch.float32)
+
+    # padding = (left, right, top, bottom)
+    padding = [kernel_size[0] // 2, kernel_size[0] // 2, kernel_size[1] // 2, kernel_size[1] // 2]
+    output = torch_pad(output, padding, mode="reflect")
+    output = conv2d(output, kernel, groups=shape[-3])
+
+    if ndim == 3:
+        output = output.squeeze(dim=0)
+    elif ndim > 4:
+        output = output.reshape(shape)
+
+    if not fp:
+        output = output.round_().to(dtype=dtype)
+
+    return output
+
+
+@_register_kernel_internal(gaussian_blur, PIL.Image.Image)
+def _gaussian_blur_image_pil(
+    image: PIL.Image.Image, kernel_size: List[int], sigma: Optional[List[float]] = None
+) -> PIL.Image.Image:
+    t_img = pil_to_tensor(image)
+    output = gaussian_blur_image(t_img, kernel_size=kernel_size, sigma=sigma)
+    return to_pil_image(output, mode=image.mode)
+
+
+@_register_kernel_internal(gaussian_blur, tv_tensors.Video)
+def gaussian_blur_video(
+    video: torch.Tensor, kernel_size: List[int], sigma: Optional[List[float]] = None
+) -> torch.Tensor:
+    return gaussian_blur_image(video, kernel_size, sigma)
+
+
+def to_dtype(inpt: torch.Tensor, dtype: torch.dtype = torch.float, scale: bool = False) -> torch.Tensor:
+    """See :func:`~torchvision.transforms.v2.ToDtype` for details."""
+    if torch.jit.is_scripting():
+        return to_dtype_image(inpt, dtype=dtype, scale=scale)
+
+    _log_api_usage_once(to_dtype)
+
+    kernel = _get_kernel(to_dtype, type(inpt))
+    return kernel(inpt, dtype=dtype, scale=scale)
+
+
+def _num_value_bits(dtype: torch.dtype) -> int:
+    if dtype == torch.uint8:
+        return 8
+    elif dtype == torch.int8:
+        return 7
+    elif dtype == torch.int16:
+        return 15
+    elif dtype == torch.int32:
+        return 31
+    elif dtype == torch.int64:
+        return 63
+    else:
+        raise TypeError(f"Number of value bits is only defined for integer dtypes, but got {dtype}.")
+
+
+@_register_kernel_internal(to_dtype, torch.Tensor)
+@_register_kernel_internal(to_dtype, tv_tensors.Image)
+def to_dtype_image(image: torch.Tensor, dtype: torch.dtype = torch.float, scale: bool = False) -> torch.Tensor:
+
+    if image.dtype == dtype:
+        return image
+    elif not scale:
+        return image.to(dtype)
+
+    float_input = image.is_floating_point()
+    if torch.jit.is_scripting():
+        # TODO: remove this branch as soon as `dtype.is_floating_point` is supported by JIT
+        float_output = torch.tensor(0, dtype=dtype).is_floating_point()
+    else:
+        float_output = dtype.is_floating_point
+
+    if float_input:
+        # float to float
+        if float_output:
+            return image.to(dtype)
+
+        # float to int
+        if (image.dtype == torch.float32 and dtype in (torch.int32, torch.int64)) or (
+            image.dtype == torch.float64 and dtype == torch.int64
+        ):
+            raise RuntimeError(f"The conversion from {image.dtype} to {dtype} cannot be performed safely.")
+
+        # For data in the range `[0.0, 1.0]`, just multiplying by the maximum value of the integer range and converting
+        # to the integer dtype  is not sufficient. For example, `torch.rand(...).mul(255).to(torch.uint8)` will only
+        # be `255` if the input is exactly `1.0`. See https://github.com/pytorch/vision/pull/2078#issuecomment-612045321
+        # for a detailed analysis.
+        # To mitigate this, we could round before we convert to the integer dtype, but this is an extra operation.
+        # Instead, we can also multiply by the maximum value plus something close to `1`. See
+        # https://github.com/pytorch/vision/pull/2078#issuecomment-613524965 for details.
+        eps = 1e-3
+        max_value = float(_max_value(dtype))
+        # We need to scale first since the conversion would otherwise turn the input range `[0.0, 1.0]` into the
+        # discrete set `{0, 1}`.
+        return image.mul(max_value + 1.0 - eps).to(dtype)
+    else:
+        # int to float
+        if float_output:
+            return image.to(dtype).mul_(1.0 / _max_value(image.dtype))
+
+        # int to int
+        num_value_bits_input = _num_value_bits(image.dtype)
+        num_value_bits_output = _num_value_bits(dtype)
+
+        if num_value_bits_input > num_value_bits_output:
+            return image.bitwise_right_shift(num_value_bits_input - num_value_bits_output).to(dtype)
+        else:
+            return image.to(dtype).bitwise_left_shift_(num_value_bits_output - num_value_bits_input)
+
+
+# We encourage users to use to_dtype() instead but we keep this for BC
+def convert_image_dtype(image: torch.Tensor, dtype: torch.dtype = torch.float32) -> torch.Tensor:
+    """[DEPRECATED] Use to_dtype() instead."""
+    return to_dtype_image(image, dtype=dtype, scale=True)
+
+
+@_register_kernel_internal(to_dtype, tv_tensors.Video)
+def to_dtype_video(video: torch.Tensor, dtype: torch.dtype = torch.float, scale: bool = False) -> torch.Tensor:
+    return to_dtype_image(video, dtype, scale=scale)
+
+
+@_register_kernel_internal(to_dtype, tv_tensors.BoundingBoxes, tv_tensor_wrapper=False)
+@_register_kernel_internal(to_dtype, tv_tensors.Mask, tv_tensor_wrapper=False)
+def _to_dtype_tensor_dispatch(inpt: torch.Tensor, dtype: torch.dtype, scale: bool = False) -> torch.Tensor:
+    # We don't need to unwrap and rewrap here, since TVTensor.to() preserves the type
+    return inpt.to(dtype)
+
+
+def sanitize_bounding_boxes(
+    bounding_boxes: torch.Tensor,
+    format: Optional[tv_tensors.BoundingBoxFormat] = None,
+    canvas_size: Optional[Tuple[int, int]] = None,
+    min_size: float = 1.0,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Remove degenerate/invalid bounding boxes and return the corresponding indexing mask.
+
+    This removes bounding boxes that:
+
+    - are below a given ``min_size``: by default this also removes degenerate boxes that have e.g. X2 <= X1.
+    - have any coordinate outside of their corresponding image. You may want to
+      call :func:`~torchvision.transforms.v2.functional.clamp_bounding_boxes` first to avoid undesired removals.
+
+    It is recommended to call it at the end of a pipeline, before passing the
+    input to the models. It is critical to call this transform if
+    :class:`~torchvision.transforms.v2.RandomIoUCrop` was called.
+    If you want to be extra careful, you may call it after all transforms that
+    may modify bounding boxes but once at the end should be enough in most
+    cases.
+
+    Args:
+        bounding_boxes (Tensor or :class:`~torchvision.tv_tensors.BoundingBoxes`): The bounding boxes to be sanitized.
+        format (str or :class:`~torchvision.tv_tensors.BoundingBoxFormat`, optional): The format of the bounding boxes.
+            Must be left to none if ``bounding_boxes`` is a :class:`~torchvision.tv_tensors.BoundingBoxes` object.
+        canvas_size (tuple of int, optional): The canvas_size of the bounding boxes
+            (size of the corresponding image/video).
+            Must be left to none if ``bounding_boxes`` is a :class:`~torchvision.tv_tensors.BoundingBoxes` object.
+        min_size (float, optional) The size below which bounding boxes are removed. Default is 1.
+
+    Returns:
+        out (tuple of Tensors): The subset of valid bounding boxes, and the corresponding indexing mask.
+        The mask can then be used to subset other tensors (e.g. labels) that are associated with the bounding boxes.
+    """
+    if torch.jit.is_scripting() or is_pure_tensor(bounding_boxes):
+        if format is None or canvas_size is None:
+            raise ValueError(
+                "format and canvas_size cannot be None if bounding_boxes is a pure tensor. "
+                f"Got format={format} and canvas_size={canvas_size}."
+                "Set those to appropriate values or pass bounding_boxes as a tv_tensors.BoundingBoxes object."
+            )
+        if isinstance(format, str):
+            format = tv_tensors.BoundingBoxFormat[format.upper()]
+        valid = _get_sanitize_bounding_boxes_mask(
+            bounding_boxes, format=format, canvas_size=canvas_size, min_size=min_size
+        )
+        bounding_boxes = bounding_boxes[valid]
+    else:
+        if not isinstance(bounding_boxes, tv_tensors.BoundingBoxes):
+            raise ValueError("bouding_boxes must be a tv_tensors.BoundingBoxes instance or a pure tensor.")
+        if format is not None or canvas_size is not None:
+            raise ValueError(
+                "format and canvas_size must be None when bounding_boxes is a tv_tensors.BoundingBoxes instance. "
+                f"Got format={format} and canvas_size={canvas_size}. "
+                "Leave those to None or pass bouding_boxes as a pure tensor."
+            )
+        valid = _get_sanitize_bounding_boxes_mask(
+            bounding_boxes, format=bounding_boxes.format, canvas_size=bounding_boxes.canvas_size, min_size=min_size
+        )
+        bounding_boxes = tv_tensors.wrap(bounding_boxes[valid], like=bounding_boxes)
+
+    return bounding_boxes, valid
+
+
+def _get_sanitize_bounding_boxes_mask(
+    bounding_boxes: torch.Tensor,
+    format: tv_tensors.BoundingBoxFormat,
+    canvas_size: Tuple[int, int],
+    min_size: float = 1.0,
+) -> torch.Tensor:
+
+    bounding_boxes = _convert_bounding_box_format(
+        bounding_boxes, new_format=tv_tensors.BoundingBoxFormat.XYXY, old_format=format
+    )
+
+    image_h, image_w = canvas_size
+    ws, hs = bounding_boxes[:, 2] - bounding_boxes[:, 0], bounding_boxes[:, 3] - bounding_boxes[:, 1]
+    valid = (ws >= min_size) & (hs >= min_size) & (bounding_boxes >= 0).all(dim=-1)
+    # TODO: Do we really need to check for out of bounds here? All
+    # transforms should be clamping anyway, so this should never happen?
+    image_h, image_w = canvas_size
+    valid &= (bounding_boxes[:, 0] <= image_w) & (bounding_boxes[:, 2] <= image_w)
+    valid &= (bounding_boxes[:, 1] <= image_h) & (bounding_boxes[:, 3] <= image_h)
+    return valid

shared/package-files/8b/8b7ae587d5e6626d839e50e6bdbaaf7778f29bab25a57b9866ccec713ec6ce15/blob

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <ATen/NumericUtils.h>
+#include <ATen/native/Resize.h>
+#include <c10/util/irange.h>
+
+#ifndef AT_PER_OPERATOR_HEADERS
+#include <ATen/Functions.h>
+#else
+#include <ATen/ops/empty.h>
+#endif
+
+namespace at::native {
+
+// ensure we get good values and indices for kthvalue, mode
+// this will always be with the reducing dim as 1-d
+inline void _reduction_with_indices_allocate_or_resize_output(
+    Tensor& values,
+    Tensor& indices,
+    const Tensor& self,
+    int64_t dim_,
+    bool keepdim) {
+  int64_t dim = maybe_wrap_dim(dim_, self.dim(), /*wrap_scalar=*/true);
+  auto result_sizes = self.sizes().vec();
+  if (!result_sizes.empty()) {
+    result_sizes[dim] = 1;
+  }
+  if (values.defined()) {
+    TORCH_CHECK(
+        self.options().type_equal(values.options()),
+        "output values must be of same type as input");
+    if (!keepdim && values.dim() == self.dim() - 1) {
+      // unsqueeze to preserve passed in noncontiguous tensor in resize
+      values.unsqueeze_(dim);
+    }
+    resize_output(values, result_sizes);
+  } else {
+    values = at::empty(result_sizes, self.options());
+  }
+  if (indices.defined()) {
+    TORCH_CHECK(
+        indices.dtype() == kLong, "output indices must be of scalar type Long");
+    TORCH_CHECK(
+        indices.device() == self.device(),
+        "output indices must be on same device as input");
+    if (!keepdim && indices.dim() == self.dim() - 1) {
+      // unsqueeze to preserve passed in noncontiguous tensor in resize
+      indices.unsqueeze_(dim);
+    }
+    resize_output(indices, result_sizes);
+  } else {
+    indices = at::empty(result_sizes, self.options().dtype(kLong));
+  }
+}
+
+// ensure we get good values and indices for topk
+inline void _allocate_or_resize_output_with_indices(
+    Tensor& values,
+    Tensor& indices,
+    const Tensor& self,
+    int64_t dim_,
+    int64_t k) {
+  int64_t dim = maybe_wrap_dim(dim_, self.dim(), /*wrap_scalar=*/true);
+  auto result_sizes = self.sizes().vec();
+  if (!result_sizes.empty()) {
+    result_sizes[dim] = k;
+  }
+  if (values.defined()) {
+    TORCH_CHECK(
+        self.options().type_equal(values.options()),
+        "output values must be of same type as input");
+    values.resize_(result_sizes);
+  } else {
+    values = at::empty(result_sizes, self.options());
+  }
+  if (indices.defined()) {
+    TORCH_CHECK(
+        indices.dtype() == kLong, "output indices must be of scalar type Long");
+    TORCH_CHECK(
+        indices.device() == self.device(),
+        "output indices must be on same device as input");
+    indices.resize_(result_sizes);
+  } else {
+    indices = at::empty(result_sizes, self.options().dtype(kLong));
+  }
+}
+
+} // namespace at::native

shared/package-files/8b/8b7b8f573b4784884ded9423b548f06d1deabe36673008b8a8a784d31e49539b/blob

@@ -0,0 +1,50 @@
+from multiprocessing import pool
+from multiprocessing.process import Process as Process, active_children as active_children, current_process as current_process
+from multiprocessing.util import SUBDEBUG as SUBDEBUG, SUBWARNING as SUBWARNING
+from Queue import Queue as _BaseQueue
+from typing import Any, Callable, Iterable, Optional, TypeVar
+
+class ProcessError(Exception): ...
+class BufferTooShort(ProcessError): ...
+class TimeoutError(ProcessError): ...
+class AuthenticationError(ProcessError): ...
+
+_T = TypeVar("_T")
+
+class Queue(_BaseQueue[_T]):
+    def __init__(self, maxsize: int = ...) -> None: ...
+    def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ...
+    def put(self, item: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ...
+    def qsize(self) -> int: ...
+    def empty(self) -> bool: ...
+    def full(self) -> bool: ...
+    def put_nowait(self, item: _T) -> None: ...
+    def get_nowait(self) -> _T: ...
+    def close(self) -> None: ...
+    def join_thread(self) -> None: ...
+    def cancel_join_thread(self) -> None: ...
+
+def Manager(): ...
+def Pipe(duplex: bool = ...): ...
+def cpu_count() -> int: ...
+def freeze_support(): ...
+def get_logger(): ...
+def log_to_stderr(level: Optional[Any] = ...): ...
+def allow_connection_pickling(): ...
+def Lock(): ...
+def RLock(): ...
+def Condition(lock: Optional[Any] = ...): ...
+def Semaphore(value: int = ...): ...
+def BoundedSemaphore(value: int = ...): ...
+def Event(): ...
+def JoinableQueue(maxsize: int = ...): ...
+def RawValue(typecode_or_type, *args): ...
+def RawArray(typecode_or_type, size_or_initializer): ...
+def Value(typecode_or_type, *args, **kwds): ...
+def Array(typecode_or_type, size_or_initializer, **kwds): ...
+def Pool(
+    processes: Optional[int] = ...,
+    initializer: Optional[Callable[..., Any]] = ...,
+    initargs: Iterable[Any] = ...,
+    maxtasksperchild: Optional[int] = ...,
+) -> pool.Pool: ...

shared/package-files/8b/8b7c37207ece2c8fce70644de6738aadc1c4262f356485f699f83b4cffe3a880/blob

@@ -0,0 +1,442 @@
+#pragma once
+
+// DO NOT DEFINE STATIC DATA IN THIS HEADER!
+// See Note [Do not compile initializers with AVX]
+
+#include <ATen/cpu/vec/intrinsics.h>
+#include <ATen/cpu/vec/vec_base.h>
+#include <c10/util/irange.h>
+#if defined(CPU_CAPABILITY_AVX2) && !defined(_MSC_VER)
+#include <sleef.h>
+#endif
+
+namespace at::vec {
+// See Note [CPU_CAPABILITY namespace]
+inline namespace CPU_CAPABILITY {
+
+
+#if defined(CPU_CAPABILITY_AVX2) && !defined(_MSC_VER)
+
+template <> class Vectorized<double> {
+private:
+  __m256d values;
+public:
+  using value_type = double;
+  using size_type = int;
+  static constexpr size_type size() {
+    return 4;
+  }
+  Vectorized() {}
+  Vectorized(__m256d v) : values(v) {}
+  Vectorized(double val) {
+    values = _mm256_set1_pd(val);
+  }
+  Vectorized(double val1, double val2, double val3, double val4) {
+    values = _mm256_setr_pd(val1, val2, val3, val4);
+  }
+  operator __m256d() const {
+    return values;
+  }
+  template <int64_t mask>
+  static Vectorized<double> blend(const Vectorized<double>& a, const Vectorized<double>& b) {
+    return _mm256_blend_pd(a.values, b.values, mask);
+  }
+  static Vectorized<double> blendv(const Vectorized<double>& a, const Vectorized<double>& b,
+                               const Vectorized<double>& mask) {
+    return _mm256_blendv_pd(a.values, b.values, mask.values);
+  }
+  template<typename step_t>
+  static Vectorized<double> arange(double base = 0., step_t step = static_cast<step_t>(1)) {
+    return Vectorized<double>(base, base + step, base + 2 * step, base + 3 * step);
+  }
+  static Vectorized<double> set(const Vectorized<double>& a, const Vectorized<double>& b,
+                            int64_t count = size()) {
+    switch (count) {
+      case 0:
+        return a;
+      case 1:
+        return blend<1>(a, b);
+      case 2:
+        return blend<3>(a, b);
+      case 3:
+        return blend<7>(a, b);
+    }
+    return b;
+  }
+  static Vectorized<double> loadu(const void* ptr, int64_t count = size()) {
+    if (count == size())
+      return _mm256_loadu_pd(reinterpret_cast<const double*>(ptr));
+
+
+    __at_align__ double tmp_values[size()];
+    // Ensure uninitialized memory does not change the output value See https://github.com/pytorch/pytorch/issues/32502
+    // for more details. We do not initialize arrays to zero using "={0}" because gcc would compile it to two
+    // instructions while a loop would be compiled to one instruction.
+    for (const auto i : c10::irange(size())) {
+      tmp_values[i] = 0.0;
+    }
+    std::memcpy(
+        tmp_values,
+        reinterpret_cast<const double*>(ptr),
+        count * sizeof(double));
+    return _mm256_load_pd(tmp_values);
+  }
+  void store(void* ptr, int count = size()) const {
+    if (count == size()) {
+      _mm256_storeu_pd(reinterpret_cast<double*>(ptr), values);
+    } else if (count > 0) {
+      double tmp_values[size()];
+      _mm256_storeu_pd(reinterpret_cast<double*>(tmp_values), values);
+      std::memcpy(ptr, tmp_values, count * sizeof(double));
+    }
+  }
+  const double& operator[](int idx) const  = delete;
+  double& operator[](int idx) = delete;
+  int zero_mask() const {
+    // returns an integer mask where all zero elements are translated to 1-bit and others are translated to 0-bit
+    __m256d cmp = _mm256_cmp_pd(values, _mm256_set1_pd(0.0), _CMP_EQ_OQ);
+    return _mm256_movemask_pd(cmp);
+  }
+  Vectorized<double> isnan() const {
+    return _mm256_cmp_pd(values, _mm256_set1_pd(0.0), _CMP_UNORD_Q);
+  }
+  bool has_inf_nan() const {
+    __m256d self_sub  = _mm256_sub_pd(values, values);
+    return (_mm256_movemask_epi8(_mm256_castpd_si256(self_sub)) & 0x77777777) != 0;
+  }
+  Vectorized<double> map(double (*const f)(double)) const {
+    __at_align__ double tmp[size()];
+    store(tmp);
+    for (const auto i : c10::irange(size())) {
+      tmp[i] = f(tmp[i]);
+    }
+    return loadu(tmp);
+  }
+  Vectorized<double> abs() const {
+    auto mask = _mm256_set1_pd(-0.f);
+    return _mm256_andnot_pd(mask, values);
+  }
+  Vectorized<double> angle() const {
+    const auto zero_vec = _mm256_set1_pd(0.f);
+    const auto nan_vec = _mm256_set1_pd(NAN);
+    const auto not_nan_mask = _mm256_cmp_pd(values, values, _CMP_EQ_OQ);
+    const auto nan_mask = _mm256_cmp_pd(not_nan_mask, zero_vec, _CMP_EQ_OQ);
+    const auto pi = _mm256_set1_pd(c10::pi<double>);
+
+    const auto neg_mask = _mm256_cmp_pd(values, zero_vec, _CMP_LT_OQ);
+    auto angle = _mm256_blendv_pd(zero_vec, pi, neg_mask);
+    angle = _mm256_blendv_pd(angle, nan_vec, nan_mask);
+    return angle;
+  }
+  Vectorized<double> real() const {
+    return *this;
+  }
+  Vectorized<double> imag() const {
+    return _mm256_set1_pd(0);
+  }
+  Vectorized<double> conj() const {
+    return *this;
+  }
+  Vectorized<double> acos() const {
+    return Vectorized<double>(Sleef_acosd4_u10(values));
+  }
+  Vectorized<double> acosh() const {
+    return Vectorized<double>(Sleef_acoshd4_u10(values));
+  }
+  Vectorized<double> asin() const {
+    return Vectorized<double>(Sleef_asind4_u10(values));
+  }
+  Vectorized<double> atan() const {
+    return Vectorized<double>(Sleef_atand4_u10(values));
+  }
+  Vectorized<double> atanh() const {
+    return Vectorized<double>(Sleef_atanhd4_u10(values));
+  }
+  Vectorized<double> atan2(const Vectorized<double> &b) const {
+    return Vectorized<double>(Sleef_atan2d4_u10(values, b));
+  }
+  Vectorized<double> copysign(const Vectorized<double> &sign) const {
+    return Vectorized<double>(Sleef_copysignd4(values, sign));
+  }
+  Vectorized<double> erf() const {
+    return Vectorized<double>(Sleef_erfd4_u10(values));
+  }
+  Vectorized<double> erfc() const {
+    return Vectorized<double>(Sleef_erfcd4_u15(values));
+  }
+  Vectorized<double> erfinv() const {
+    return map(calc_erfinv);
+  }
+  Vectorized<double> exp() const {
+    return Vectorized<double>(Sleef_expd4_u10(values));
+  }
+  Vectorized<double> exp2() const {
+    return Vectorized<double>(Sleef_exp2d4_u10(values));
+  }
+  Vectorized<double> expm1() const {
+    return Vectorized<double>(Sleef_expm1d4_u10(values));
+  }
+  Vectorized<double> exp_u20() const {
+    return exp();
+  }
+  Vectorized<double> fmod(const Vectorized<double>& q) const {
+    return Vectorized<double>(Sleef_fmodd4(values, q));
+  }
+  Vectorized<double> hypot(const Vectorized<double> &b) const {
+    return Vectorized<double>(Sleef_hypotd4_u05(values, b));
+  }
+  Vectorized<double> i0() const {
+    return map(calc_i0);
+  }
+  Vectorized<double> i0e() const {
+    return map(calc_i0e);
+  }
+  Vectorized<double> digamma() const {
+    return map(calc_digamma);
+  }
+  Vectorized<double> igamma(const Vectorized<double> &x) const {
+    __at_align__ double tmp[size()];
+    __at_align__ double tmp_x[size()];
+    store(tmp);
+    x.store(tmp_x);
+    for (const auto i : c10::irange(size())) {
+      tmp[i] = calc_igamma(tmp[i], tmp_x[i]);
+    }
+    return loadu(tmp);
+  }
+  Vectorized<double> igammac(const Vectorized<double> &x) const {
+    __at_align__ double tmp[size()];
+    __at_align__ double tmp_x[size()];
+    store(tmp);
+    x.store(tmp_x);
+    for (const auto i : c10::irange(size())) {
+      tmp[i] = calc_igammac(tmp[i], tmp_x[i]);
+    }
+    return loadu(tmp);
+  }
+  Vectorized<double> log() const {
+    return Vectorized<double>(Sleef_logd4_u10(values));
+  }
+  Vectorized<double> log2() const {
+    return Vectorized<double>(Sleef_log2d4_u10(values));
+  }
+  Vectorized<double> log10() const {
+    return Vectorized<double>(Sleef_log10d4_u10(values));
+  }
+  Vectorized<double> log1p() const {
+    return Vectorized<double>(Sleef_log1pd4_u10(values));
+  }
+  Vectorized<double> sin() const {
+    return Vectorized<double>(Sleef_sind4_u10(values));
+  }
+  Vectorized<double> sinh() const {
+    return Vectorized<double>(Sleef_sinhd4_u10(values));
+  }
+  Vectorized<double> cos() const {
+    return Vectorized<double>(Sleef_cosd4_u10(values));
+  }
+  Vectorized<double> cosh() const {
+    return Vectorized<double>(Sleef_coshd4_u10(values));
+  }
+  Vectorized<double> ceil() const {
+    return _mm256_ceil_pd(values);
+  }
+  Vectorized<double> floor() const {
+    return _mm256_floor_pd(values);
+  }
+  Vectorized<double> frac() const;
+  Vectorized<double> neg() const {
+    return _mm256_xor_pd(_mm256_set1_pd(-0.), values);
+  }
+  Vectorized<double> nextafter(const Vectorized<double> &b) const {
+    return Vectorized<double>(Sleef_nextafterd4(values, b));
+  }
+  Vectorized<double> round() const {
+    return _mm256_round_pd(values, (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC));
+  }
+  Vectorized<double> tan() const {
+    return Vectorized<double>(Sleef_tand4_u10(values));
+  }
+  Vectorized<double> tanh() const {
+    return Vectorized<double>(Sleef_tanhd4_u10(values));
+  }
+  Vectorized<double> trunc() const {
+    return _mm256_round_pd(values, (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC));
+  }
+  Vectorized<double> lgamma() const {
+    return Vectorized<double>(Sleef_lgammad4_u10(values));
+  }
+  Vectorized<double> sqrt() const {
+    return _mm256_sqrt_pd(values);
+  }
+  Vectorized<double> reciprocal() const {
+    return _mm256_div_pd(_mm256_set1_pd(1), values);
+  }
+  Vectorized<double> rsqrt() const {
+    return _mm256_div_pd(_mm256_set1_pd(1), _mm256_sqrt_pd(values));
+  }
+  Vectorized<double> pow(const Vectorized<double> &b) const {
+    return Vectorized<double>(Sleef_powd4_u10(values, b));
+  }
+  // Comparison using the _CMP_**_OQ predicate.
+  //   `O`: get false if an operand is NaN
+  //   `Q`: do not raise if an operand is NaN
+  Vectorized<double> operator==(const Vectorized<double>& other) const {
+    return _mm256_cmp_pd(values, other.values, _CMP_EQ_OQ);
+  }
+
+  Vectorized<double> operator!=(const Vectorized<double>& other) const {
+    return _mm256_cmp_pd(values, other.values, _CMP_NEQ_UQ);
+  }
+
+  Vectorized<double> operator<(const Vectorized<double>& other) const {
+    return _mm256_cmp_pd(values, other.values, _CMP_LT_OQ);
+  }
+
+  Vectorized<double> operator<=(const Vectorized<double>& other) const {
+    return _mm256_cmp_pd(values, other.values, _CMP_LE_OQ);
+  }
+
+  Vectorized<double> operator>(const Vectorized<double>& other) const {
+    return _mm256_cmp_pd(values, other.values, _CMP_GT_OQ);
+  }
+
+  Vectorized<double> operator>=(const Vectorized<double>& other) const {
+    return _mm256_cmp_pd(values, other.values, _CMP_GE_OQ);
+  }
+
+  Vectorized<double> eq(const Vectorized<double>& other) const;
+  Vectorized<double> ne(const Vectorized<double>& other) const;
+  Vectorized<double> lt(const Vectorized<double>& other) const;
+  Vectorized<double> le(const Vectorized<double>& other) const;
+  Vectorized<double> gt(const Vectorized<double>& other) const;
+  Vectorized<double> ge(const Vectorized<double>& other) const;
+};
+
+template <>
+Vectorized<double> inline operator+(const Vectorized<double>& a, const Vectorized<double>& b) {
+  return _mm256_add_pd(a, b);
+}
+
+template <>
+Vectorized<double> inline operator-(const Vectorized<double>& a, const Vectorized<double>& b) {
+  return _mm256_sub_pd(a, b);
+}
+
+template <>
+Vectorized<double> inline operator*(const Vectorized<double>& a, const Vectorized<double>& b) {
+  return _mm256_mul_pd(a, b);
+}
+
+template <>
+Vectorized<double> inline operator/(const Vectorized<double>& a, const Vectorized<double>& b) {
+  return _mm256_div_pd(a, b);
+}
+
+// frac. Implement this here so we can use subtraction.
+inline Vectorized<double> Vectorized<double>::frac() const {
+  return *this - this->trunc();
+}
+
+// Implements the IEEE 754 201X `maximum` operation, which propagates NaN if
+// either input is a NaN.
+template <>
+Vectorized<double> inline maximum(const Vectorized<double>& a, const Vectorized<double>& b) {
+  Vectorized<double> max = _mm256_max_pd(a, b);
+  Vectorized<double> isnan = _mm256_cmp_pd(a, b, _CMP_UNORD_Q);
+  // Exploit the fact that all-ones is a NaN.
+  return _mm256_or_pd(max, isnan);
+}
+
+// Implements the IEEE 754 201X `minimum` operation, which propagates NaN if
+// either input is a NaN.
+template <>
+Vectorized<double> inline minimum(const Vectorized<double>& a, const Vectorized<double>& b) {
+  Vectorized<double> min = _mm256_min_pd(a, b);
+  Vectorized<double> isnan = _mm256_cmp_pd(a, b, _CMP_UNORD_Q);
+  // Exploit the fact that all-ones is a NaN.
+  return _mm256_or_pd(min, isnan);
+}
+
+template <>
+Vectorized<double> inline clamp(const Vectorized<double>& a, const Vectorized<double>& min, const Vectorized<double>& max) {
+  return _mm256_min_pd(max, _mm256_max_pd(min, a));
+}
+
+template <>
+Vectorized<double> inline clamp_min(const Vectorized<double>& a, const Vectorized<double>& min) {
+  return _mm256_max_pd(min, a);
+}
+
+template <>
+Vectorized<double> inline clamp_max(const Vectorized<double>& a, const Vectorized<double>& max) {
+  return _mm256_min_pd(max, a);
+}
+
+template <>
+Vectorized<double> inline operator&(const Vectorized<double>& a, const Vectorized<double>& b) {
+  return _mm256_and_pd(a, b);
+}
+
+template <>
+Vectorized<double> inline operator|(const Vectorized<double>& a, const Vectorized<double>& b) {
+  return _mm256_or_pd(a, b);
+}
+
+template <>
+Vectorized<double> inline operator^(const Vectorized<double>& a, const Vectorized<double>& b) {
+  return _mm256_xor_pd(a, b);
+}
+
+inline Vectorized<double> Vectorized<double>::eq(const Vectorized<double>& other) const {
+  return (*this == other) & Vectorized<double>(1.0);
+}
+
+inline Vectorized<double> Vectorized<double>::ne(const Vectorized<double>& other) const {
+  return (*this != other) & Vectorized<double>(1.0);
+}
+
+inline Vectorized<double> Vectorized<double>::gt(const Vectorized<double>& other) const {
+  return (*this > other) & Vectorized<double>(1.0);
+}
+
+inline Vectorized<double> Vectorized<double>::ge(const Vectorized<double>& other) const {
+  return (*this >= other) & Vectorized<double>(1.0);
+}
+
+inline Vectorized<double> Vectorized<double>::lt(const Vectorized<double>& other) const {
+  return (*this < other) & Vectorized<double>(1.0);
+}
+
+inline Vectorized<double> Vectorized<double>::le(const Vectorized<double>& other) const {
+  return (*this <= other) & Vectorized<double>(1.0);
+}
+
+template <>
+inline void convert(const double* src, double* dst, int64_t n) {
+  int64_t i;
+#pragma unroll
+  for (i = 0; i <= (n - Vectorized<double>::size()); i += Vectorized<double>::size()) {
+    _mm256_storeu_pd(dst + i, _mm256_loadu_pd(src + i));
+  }
+#pragma unroll
+  for (; i < n; i++) {
+    dst[i] = src[i];
+  }
+}
+
+#ifdef CPU_CAPABILITY_AVX2
+template <>
+Vectorized<double> inline fmadd(const Vectorized<double>& a, const Vectorized<double>& b, const Vectorized<double>& c) {
+  return _mm256_fmadd_pd(a, b, c);
+}
+
+template <>
+Vectorized<double> inline fmsub(const Vectorized<double>& a, const Vectorized<double>& b, const Vectorized<double>& c) {
+  return _mm256_fmsub_pd(a, b, c);
+}
+#endif
+
+#endif
+
+}} // namespace at::vec::CPU_CAPABILITY

shared/package-files/8b/8b7d767810c385f42c26a20463b1cb3b89a6ebe177830d31a6d6019fe8dc1986/blob

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <torch/csrc/autograd/variable.h>
+#include <torch/csrc/python_headers.h>
+#include <cstdint>
+
+extern PyTypeObject THPSizeType;
+
+#define THPSize_Check(obj) (Py_TYPE(obj) == &THPSizeType)
+
+PyObject* THPSize_New(const torch::autograd::Variable& t);
+PyObject* THPSize_NewFromSizes(int64_t dim, const int64_t* sizes);
+PyObject* THPSize_NewFromSymSizes(const at::Tensor& t);
+
+void THPSize_init(PyObject* module);

shared/package-files/8b/8b7e063d10197b15cc4fa6f0b9fe52132bdd992f9b442cbd28c8f03793baa639/blob

@@ -0,0 +1,1204 @@
+"""AST nodes generated by the parser for the compiler. Also provides
+some node tree helper functions used by the parser and compiler in order
+to normalize nodes.
+"""
+import inspect
+import operator
+import typing as t
+from collections import deque
+
+from markupsafe import Markup
+
+from .utils import _PassArg
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .environment import Environment
+
+_NodeBound = t.TypeVar("_NodeBound", bound="Node")
+
+_binop_to_func: t.Dict[str, t.Callable[[t.Any, t.Any], t.Any]] = {
+    "*": operator.mul,
+    "/": operator.truediv,
+    "//": operator.floordiv,
+    "**": operator.pow,
+    "%": operator.mod,
+    "+": operator.add,
+    "-": operator.sub,
+}
+
+_uaop_to_func: t.Dict[str, t.Callable[[t.Any], t.Any]] = {
+    "not": operator.not_,
+    "+": operator.pos,
+    "-": operator.neg,
+}
+
+_cmpop_to_func: t.Dict[str, t.Callable[[t.Any, t.Any], t.Any]] = {
+    "eq": operator.eq,
+    "ne": operator.ne,
+    "gt": operator.gt,
+    "gteq": operator.ge,
+    "lt": operator.lt,
+    "lteq": operator.le,
+    "in": lambda a, b: a in b,
+    "notin": lambda a, b: a not in b,
+}
+
+
+class Impossible(Exception):
+    """Raised if the node could not perform a requested action."""
+
+
+class NodeType(type):
+    """A metaclass for nodes that handles the field and attribute
+    inheritance.  fields and attributes from the parent class are
+    automatically forwarded to the child."""
+
+    def __new__(mcs, name, bases, d):  # type: ignore
+        for attr in "fields", "attributes":
+            storage = []
+            storage.extend(getattr(bases[0] if bases else object, attr, ()))
+            storage.extend(d.get(attr, ()))
+            assert len(bases) <= 1, "multiple inheritance not allowed"
+            assert len(storage) == len(set(storage)), "layout conflict"
+            d[attr] = tuple(storage)
+        d.setdefault("abstract", False)
+        return type.__new__(mcs, name, bases, d)
+
+
+class EvalContext:
+    """Holds evaluation time information.  Custom attributes can be attached
+    to it in extensions.
+    """
+
+    def __init__(
+        self, environment: "Environment", template_name: t.Optional[str] = None
+    ) -> None:
+        self.environment = environment
+        if callable(environment.autoescape):
+            self.autoescape = environment.autoescape(template_name)
+        else:
+            self.autoescape = environment.autoescape
+        self.volatile = False
+
+    def save(self) -> t.Mapping[str, t.Any]:
+        return self.__dict__.copy()
+
+    def revert(self, old: t.Mapping[str, t.Any]) -> None:
+        self.__dict__.clear()
+        self.__dict__.update(old)
+
+
+def get_eval_context(node: "Node", ctx: t.Optional[EvalContext]) -> EvalContext:
+    if ctx is None:
+        if node.environment is None:
+            raise RuntimeError(
+                "if no eval context is passed, the node must have an"
+                " attached environment."
+            )
+        return EvalContext(node.environment)
+    return ctx
+
+
+class Node(metaclass=NodeType):
+    """Baseclass for all Jinja nodes.  There are a number of nodes available
+    of different types.  There are four major types:
+
+    -   :class:`Stmt`: statements
+    -   :class:`Expr`: expressions
+    -   :class:`Helper`: helper nodes
+    -   :class:`Template`: the outermost wrapper node
+
+    All nodes have fields and attributes.  Fields may be other nodes, lists,
+    or arbitrary values.  Fields are passed to the constructor as regular
+    positional arguments, attributes as keyword arguments.  Each node has
+    two attributes: `lineno` (the line number of the node) and `environment`.
+    The `environment` attribute is set at the end of the parsing process for
+    all nodes automatically.
+    """
+
+    fields: t.Tuple[str, ...] = ()
+    attributes: t.Tuple[str, ...] = ("lineno", "environment")
+    abstract = True
+
+    lineno: int
+    environment: t.Optional["Environment"]
+
+    def __init__(self, *fields: t.Any, **attributes: t.Any) -> None:
+        if self.abstract:
+            raise TypeError("abstract nodes are not instantiable")
+        if fields:
+            if len(fields) != len(self.fields):
+                if not self.fields:
+                    raise TypeError(f"{type(self).__name__!r} takes 0 arguments")
+                raise TypeError(
+                    f"{type(self).__name__!r} takes 0 or {len(self.fields)}"
+                    f" argument{'s' if len(self.fields) != 1 else ''}"
+                )
+            for name, arg in zip(self.fields, fields):
+                setattr(self, name, arg)
+        for attr in self.attributes:
+            setattr(self, attr, attributes.pop(attr, None))
+        if attributes:
+            raise TypeError(f"unknown attribute {next(iter(attributes))!r}")
+
+    def iter_fields(
+        self,
+        exclude: t.Optional[t.Container[str]] = None,
+        only: t.Optional[t.Container[str]] = None,
+    ) -> t.Iterator[t.Tuple[str, t.Any]]:
+        """This method iterates over all fields that are defined and yields
+        ``(key, value)`` tuples.  Per default all fields are returned, but
+        it's possible to limit that to some fields by providing the `only`
+        parameter or to exclude some using the `exclude` parameter.  Both
+        should be sets or tuples of field names.
+        """
+        for name in self.fields:
+            if (
+                (exclude is None and only is None)
+                or (exclude is not None and name not in exclude)
+                or (only is not None and name in only)
+            ):
+                try:
+                    yield name, getattr(self, name)
+                except AttributeError:
+                    pass
+
+    def iter_child_nodes(
+        self,
+        exclude: t.Optional[t.Container[str]] = None,
+        only: t.Optional[t.Container[str]] = None,
+    ) -> t.Iterator["Node"]:
+        """Iterates over all direct child nodes of the node.  This iterates
+        over all fields and yields the values of they are nodes.  If the value
+        of a field is a list all the nodes in that list are returned.
+        """
+        for _, item in self.iter_fields(exclude, only):
+            if isinstance(item, list):
+                for n in item:
+                    if isinstance(n, Node):
+                        yield n
+            elif isinstance(item, Node):
+                yield item
+
+    def find(self, node_type: t.Type[_NodeBound]) -> t.Optional[_NodeBound]:
+        """Find the first node of a given type.  If no such node exists the
+        return value is `None`.
+        """
+        for result in self.find_all(node_type):
+            return result
+
+        return None
+
+    def find_all(
+        self, node_type: t.Union[t.Type[_NodeBound], t.Tuple[t.Type[_NodeBound], ...]]
+    ) -> t.Iterator[_NodeBound]:
+        """Find all the nodes of a given type.  If the type is a tuple,
+        the check is performed for any of the tuple items.
+        """
+        for child in self.iter_child_nodes():
+            if isinstance(child, node_type):
+                yield child  # type: ignore
+            yield from child.find_all(node_type)
+
+    def set_ctx(self, ctx: str) -> "Node":
+        """Reset the context of a node and all child nodes.  Per default the
+        parser will all generate nodes that have a 'load' context as it's the
+        most common one.  This method is used in the parser to set assignment
+        targets and other nodes to a store context.
+        """
+        todo = deque([self])
+        while todo:
+            node = todo.popleft()
+            if "ctx" in node.fields:
+                node.ctx = ctx  # type: ignore
+            todo.extend(node.iter_child_nodes())
+        return self
+
+    def set_lineno(self, lineno: int, override: bool = False) -> "Node":
+        """Set the line numbers of the node and children."""
+        todo = deque([self])
+        while todo:
+            node = todo.popleft()
+            if "lineno" in node.attributes:
+                if node.lineno is None or override:
+                    node.lineno = lineno
+            todo.extend(node.iter_child_nodes())
+        return self
+
+    def set_environment(self, environment: "Environment") -> "Node":
+        """Set the environment for all nodes."""
+        todo = deque([self])
+        while todo:
+            node = todo.popleft()
+            node.environment = environment
+            todo.extend(node.iter_child_nodes())
+        return self
+
+    def __eq__(self, other: t.Any) -> bool:
+        if type(self) is not type(other):
+            return NotImplemented
+
+        return tuple(self.iter_fields()) == tuple(other.iter_fields())
+
+    __hash__ = object.__hash__
+
+    def __repr__(self) -> str:
+        args_str = ", ".join(f"{a}={getattr(self, a, None)!r}" for a in self.fields)
+        return f"{type(self).__name__}({args_str})"
+
+    def dump(self) -> str:
+        def _dump(node: t.Union[Node, t.Any]) -> None:
+            if not isinstance(node, Node):
+                buf.append(repr(node))
+                return
+
+            buf.append(f"nodes.{type(node).__name__}(")
+            if not node.fields:
+                buf.append(")")
+                return
+            for idx, field in enumerate(node.fields):
+                if idx:
+                    buf.append(", ")
+                value = getattr(node, field)
+                if isinstance(value, list):
+                    buf.append("[")
+                    for idx, item in enumerate(value):
+                        if idx:
+                            buf.append(", ")
+                        _dump(item)
+                    buf.append("]")
+                else:
+                    _dump(value)
+            buf.append(")")
+
+        buf: t.List[str] = []
+        _dump(self)
+        return "".join(buf)
+
+
+class Stmt(Node):
+    """Base node for all statements."""
+
+    abstract = True
+
+
+class Helper(Node):
+    """Nodes that exist in a specific context only."""
+
+    abstract = True
+
+
+class Template(Node):
+    """Node that represents a template.  This must be the outermost node that
+    is passed to the compiler.
+    """
+
+    fields = ("body",)
+    body: t.List[Node]
+
+
+class Output(Stmt):
+    """A node that holds multiple expressions which are then printed out.
+    This is used both for the `print` statement and the regular template data.
+    """
+
+    fields = ("nodes",)
+    nodes: t.List["Expr"]
+
+
+class Extends(Stmt):
+    """Represents an extends statement."""
+
+    fields = ("template",)
+    template: "Expr"
+
+
+class For(Stmt):
+    """The for loop.  `target` is the target for the iteration (usually a
+    :class:`Name` or :class:`Tuple`), `iter` the iterable.  `body` is a list
+    of nodes that are used as loop-body, and `else_` a list of nodes for the
+    `else` block.  If no else node exists it has to be an empty list.
+
+    For filtered nodes an expression can be stored as `test`, otherwise `None`.
+    """
+
+    fields = ("target", "iter", "body", "else_", "test", "recursive")
+    target: Node
+    iter: Node
+    body: t.List[Node]
+    else_: t.List[Node]
+    test: t.Optional[Node]
+    recursive: bool
+
+
+class If(Stmt):
+    """If `test` is true, `body` is rendered, else `else_`."""
+
+    fields = ("test", "body", "elif_", "else_")
+    test: Node
+    body: t.List[Node]
+    elif_: t.List["If"]
+    else_: t.List[Node]
+
+
+class Macro(Stmt):
+    """A macro definition.  `name` is the name of the macro, `args` a list of
+    arguments and `defaults` a list of defaults if there are any.  `body` is
+    a list of nodes for the macro body.
+    """
+
+    fields = ("name", "args", "defaults", "body")
+    name: str
+    args: t.List["Name"]
+    defaults: t.List["Expr"]
+    body: t.List[Node]
+
+
+class CallBlock(Stmt):
+    """Like a macro without a name but a call instead.  `call` is called with
+    the unnamed macro as `caller` argument this node holds.
+    """
+
+    fields = ("call", "args", "defaults", "body")
+    call: "Call"
+    args: t.List["Name"]
+    defaults: t.List["Expr"]
+    body: t.List[Node]
+
+
+class FilterBlock(Stmt):
+    """Node for filter sections."""
+
+    fields = ("body", "filter")
+    body: t.List[Node]
+    filter: "Filter"
+
+
+class With(Stmt):
+    """Specific node for with statements.  In older versions of Jinja the
+    with statement was implemented on the base of the `Scope` node instead.
+
+    .. versionadded:: 2.9.3
+    """
+
+    fields = ("targets", "values", "body")
+    targets: t.List["Expr"]
+    values: t.List["Expr"]
+    body: t.List[Node]
+
+
+class Block(Stmt):
+    """A node that represents a block.
+
+    .. versionchanged:: 3.0.0
+        the `required` field was added.
+    """
+
+    fields = ("name", "body", "scoped", "required")
+    name: str
+    body: t.List[Node]
+    scoped: bool
+    required: bool
+
+
+class Include(Stmt):
+    """A node that represents the include tag."""
+
+    fields = ("template", "with_context", "ignore_missing")
+    template: "Expr"
+    with_context: bool
+    ignore_missing: bool
+
+
+class Import(Stmt):
+    """A node that represents the import tag."""
+
+    fields = ("template", "target", "with_context")
+    template: "Expr"
+    target: str
+    with_context: bool
+
+
+class FromImport(Stmt):
+    """A node that represents the from import tag.  It's important to not
+    pass unsafe names to the name attribute.  The compiler translates the
+    attribute lookups directly into getattr calls and does *not* use the
+    subscript callback of the interface.  As exported variables may not
+    start with double underscores (which the parser asserts) this is not a
+    problem for regular Jinja code, but if this node is used in an extension
+    extra care must be taken.
+
+    The list of names may contain tuples if aliases are wanted.
+    """
+
+    fields = ("template", "names", "with_context")
+    template: "Expr"
+    names: t.List[t.Union[str, t.Tuple[str, str]]]
+    with_context: bool
+
+
+class ExprStmt(Stmt):
+    """A statement that evaluates an expression and discards the result."""
+
+    fields = ("node",)
+    node: Node
+
+
+class Assign(Stmt):
+    """Assigns an expression to a target."""
+
+    fields = ("target", "node")
+    target: "Expr"
+    node: Node
+
+
+class AssignBlock(Stmt):
+    """Assigns a block to a target."""
+
+    fields = ("target", "filter", "body")
+    target: "Expr"
+    filter: t.Optional["Filter"]
+    body: t.List[Node]
+
+
+class Expr(Node):
+    """Baseclass for all expressions."""
+
+    abstract = True
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        """Return the value of the expression as constant or raise
+        :exc:`Impossible` if this was not possible.
+
+        An :class:`EvalContext` can be provided, if none is given
+        a default context is created which requires the nodes to have
+        an attached environment.
+
+        .. versionchanged:: 2.4
+           the `eval_ctx` parameter was added.
+        """
+        raise Impossible()
+
+    def can_assign(self) -> bool:
+        """Check if it's possible to assign something to this node."""
+        return False
+
+
+class BinExpr(Expr):
+    """Baseclass for all binary expressions."""
+
+    fields = ("left", "right")
+    left: Expr
+    right: Expr
+    operator: str
+    abstract = True
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+
+        # intercepted operators cannot be folded at compile time
+        if (
+            eval_ctx.environment.sandboxed
+            and self.operator in eval_ctx.environment.intercepted_binops  # type: ignore
+        ):
+            raise Impossible()
+        f = _binop_to_func[self.operator]
+        try:
+            return f(self.left.as_const(eval_ctx), self.right.as_const(eval_ctx))
+        except Exception as e:
+            raise Impossible() from e
+
+
+class UnaryExpr(Expr):
+    """Baseclass for all unary expressions."""
+
+    fields = ("node",)
+    node: Expr
+    operator: str
+    abstract = True
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+
+        # intercepted operators cannot be folded at compile time
+        if (
+            eval_ctx.environment.sandboxed
+            and self.operator in eval_ctx.environment.intercepted_unops  # type: ignore
+        ):
+            raise Impossible()
+        f = _uaop_to_func[self.operator]
+        try:
+            return f(self.node.as_const(eval_ctx))
+        except Exception as e:
+            raise Impossible() from e
+
+
+class Name(Expr):
+    """Looks up a name or stores a value in a name.
+    The `ctx` of the node can be one of the following values:
+
+    -   `store`: store a value in the name
+    -   `load`: load that name
+    -   `param`: like `store` but if the name was defined as function parameter.
+    """
+
+    fields = ("name", "ctx")
+    name: str
+    ctx: str
+
+    def can_assign(self) -> bool:
+        return self.name not in {"true", "false", "none", "True", "False", "None"}
+
+
+class NSRef(Expr):
+    """Reference to a namespace value assignment"""
+
+    fields = ("name", "attr")
+    name: str
+    attr: str
+
+    def can_assign(self) -> bool:
+        # We don't need any special checks here; NSRef assignments have a
+        # runtime check to ensure the target is a namespace object which will
+        # have been checked already as it is created using a normal assignment
+        # which goes through a `Name` node.
+        return True
+
+
+class Literal(Expr):
+    """Baseclass for literals."""
+
+    abstract = True
+
+
+class Const(Literal):
+    """All constant values.  The parser will return this node for simple
+    constants such as ``42`` or ``"foo"`` but it can be used to store more
+    complex values such as lists too.  Only constants with a safe
+    representation (objects where ``eval(repr(x)) == x`` is true).
+    """
+
+    fields = ("value",)
+    value: t.Any
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        return self.value
+
+    @classmethod
+    def from_untrusted(
+        cls,
+        value: t.Any,
+        lineno: t.Optional[int] = None,
+        environment: "t.Optional[Environment]" = None,
+    ) -> "Const":
+        """Return a const object if the value is representable as
+        constant value in the generated code, otherwise it will raise
+        an `Impossible` exception.
+        """
+        from .compiler import has_safe_repr
+
+        if not has_safe_repr(value):
+            raise Impossible()
+        return cls(value, lineno=lineno, environment=environment)
+
+
+class TemplateData(Literal):
+    """A constant template string."""
+
+    fields = ("data",)
+    data: str
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> str:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        if eval_ctx.volatile:
+            raise Impossible()
+        if eval_ctx.autoescape:
+            return Markup(self.data)
+        return self.data
+
+
+class Tuple(Literal):
+    """For loop unpacking and some other things like multiple arguments
+    for subscripts.  Like for :class:`Name` `ctx` specifies if the tuple
+    is used for loading the names or storing.
+    """
+
+    fields = ("items", "ctx")
+    items: t.List[Expr]
+    ctx: str
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Tuple[t.Any, ...]:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return tuple(x.as_const(eval_ctx) for x in self.items)
+
+    def can_assign(self) -> bool:
+        for item in self.items:
+            if not item.can_assign():
+                return False
+        return True
+
+
+class List(Literal):
+    """Any list literal such as ``[1, 2, 3]``"""
+
+    fields = ("items",)
+    items: t.List[Expr]
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.List[t.Any]:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return [x.as_const(eval_ctx) for x in self.items]
+
+
+class Dict(Literal):
+    """Any dict literal such as ``{1: 2, 3: 4}``.  The items must be a list of
+    :class:`Pair` nodes.
+    """
+
+    fields = ("items",)
+    items: t.List["Pair"]
+
+    def as_const(
+        self, eval_ctx: t.Optional[EvalContext] = None
+    ) -> t.Dict[t.Any, t.Any]:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return dict(x.as_const(eval_ctx) for x in self.items)
+
+
+class Pair(Helper):
+    """A key, value pair for dicts."""
+
+    fields = ("key", "value")
+    key: Expr
+    value: Expr
+
+    def as_const(
+        self, eval_ctx: t.Optional[EvalContext] = None
+    ) -> t.Tuple[t.Any, t.Any]:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return self.key.as_const(eval_ctx), self.value.as_const(eval_ctx)
+
+
+class Keyword(Helper):
+    """A key, value pair for keyword arguments where key is a string."""
+
+    fields = ("key", "value")
+    key: str
+    value: Expr
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Tuple[str, t.Any]:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return self.key, self.value.as_const(eval_ctx)
+
+
+class CondExpr(Expr):
+    """A conditional expression (inline if expression).  (``{{
+    foo if bar else baz }}``)
+    """
+
+    fields = ("test", "expr1", "expr2")
+    test: Expr
+    expr1: Expr
+    expr2: t.Optional[Expr]
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        if self.test.as_const(eval_ctx):
+            return self.expr1.as_const(eval_ctx)
+
+        # if we evaluate to an undefined object, we better do that at runtime
+        if self.expr2 is None:
+            raise Impossible()
+
+        return self.expr2.as_const(eval_ctx)
+
+
+def args_as_const(
+    node: t.Union["_FilterTestCommon", "Call"], eval_ctx: t.Optional[EvalContext]
+) -> t.Tuple[t.List[t.Any], t.Dict[t.Any, t.Any]]:
+    args = [x.as_const(eval_ctx) for x in node.args]
+    kwargs = dict(x.as_const(eval_ctx) for x in node.kwargs)
+
+    if node.dyn_args is not None:
+        try:
+            args.extend(node.dyn_args.as_const(eval_ctx))
+        except Exception as e:
+            raise Impossible() from e
+
+    if node.dyn_kwargs is not None:
+        try:
+            kwargs.update(node.dyn_kwargs.as_const(eval_ctx))
+        except Exception as e:
+            raise Impossible() from e
+
+    return args, kwargs
+
+
+class _FilterTestCommon(Expr):
+    fields = ("node", "name", "args", "kwargs", "dyn_args", "dyn_kwargs")
+    node: Expr
+    name: str
+    args: t.List[Expr]
+    kwargs: t.List[Pair]
+    dyn_args: t.Optional[Expr]
+    dyn_kwargs: t.Optional[Expr]
+    abstract = True
+    _is_filter = True
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+
+        if eval_ctx.volatile:
+            raise Impossible()
+
+        if self._is_filter:
+            env_map = eval_ctx.environment.filters
+        else:
+            env_map = eval_ctx.environment.tests
+
+        func = env_map.get(self.name)
+        pass_arg = _PassArg.from_obj(func)  # type: ignore
+
+        if func is None or pass_arg is _PassArg.context:
+            raise Impossible()
+
+        if eval_ctx.environment.is_async and (
+            getattr(func, "jinja_async_variant", False) is True
+            or inspect.iscoroutinefunction(func)
+        ):
+            raise Impossible()
+
+        args, kwargs = args_as_const(self, eval_ctx)
+        args.insert(0, self.node.as_const(eval_ctx))
+
+        if pass_arg is _PassArg.eval_context:
+            args.insert(0, eval_ctx)
+        elif pass_arg is _PassArg.environment:
+            args.insert(0, eval_ctx.environment)
+
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            raise Impossible() from e
+
+
+class Filter(_FilterTestCommon):
+    """Apply a filter to an expression. ``name`` is the name of the
+    filter, the other fields are the same as :class:`Call`.
+
+    If ``node`` is ``None``, the filter is being used in a filter block
+    and is applied to the content of the block.
+    """
+
+    node: t.Optional[Expr]  # type: ignore
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        if self.node is None:
+            raise Impossible()
+
+        return super().as_const(eval_ctx=eval_ctx)
+
+
+class Test(_FilterTestCommon):
+    """Apply a test to an expression. ``name`` is the name of the test,
+    the other field are the same as :class:`Call`.
+
+    .. versionchanged:: 3.0
+        ``as_const`` shares the same logic for filters and tests. Tests
+        check for volatile, async, and ``@pass_context`` etc.
+        decorators.
+    """
+
+    _is_filter = False
+
+
+class Call(Expr):
+    """Calls an expression.  `args` is a list of arguments, `kwargs` a list
+    of keyword arguments (list of :class:`Keyword` nodes), and `dyn_args`
+    and `dyn_kwargs` has to be either `None` or a node that is used as
+    node for dynamic positional (``*args``) or keyword (``**kwargs``)
+    arguments.
+    """
+
+    fields = ("node", "args", "kwargs", "dyn_args", "dyn_kwargs")
+    node: Expr
+    args: t.List[Expr]
+    kwargs: t.List[Keyword]
+    dyn_args: t.Optional[Expr]
+    dyn_kwargs: t.Optional[Expr]
+
+
+class Getitem(Expr):
+    """Get an attribute or item from an expression and prefer the item."""
+
+    fields = ("node", "arg", "ctx")
+    node: Expr
+    arg: Expr
+    ctx: str
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        if self.ctx != "load":
+            raise Impossible()
+
+        eval_ctx = get_eval_context(self, eval_ctx)
+
+        try:
+            return eval_ctx.environment.getitem(
+                self.node.as_const(eval_ctx), self.arg.as_const(eval_ctx)
+            )
+        except Exception as e:
+            raise Impossible() from e
+
+
+class Getattr(Expr):
+    """Get an attribute or item from an expression that is a ascii-only
+    bytestring and prefer the attribute.
+    """
+
+    fields = ("node", "attr", "ctx")
+    node: Expr
+    attr: str
+    ctx: str
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        if self.ctx != "load":
+            raise Impossible()
+
+        eval_ctx = get_eval_context(self, eval_ctx)
+
+        try:
+            return eval_ctx.environment.getattr(self.node.as_const(eval_ctx), self.attr)
+        except Exception as e:
+            raise Impossible() from e
+
+
+class Slice(Expr):
+    """Represents a slice object.  This must only be used as argument for
+    :class:`Subscript`.
+    """
+
+    fields = ("start", "stop", "step")
+    start: t.Optional[Expr]
+    stop: t.Optional[Expr]
+    step: t.Optional[Expr]
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> slice:
+        eval_ctx = get_eval_context(self, eval_ctx)
+
+        def const(obj: t.Optional[Expr]) -> t.Optional[t.Any]:
+            if obj is None:
+                return None
+            return obj.as_const(eval_ctx)
+
+        return slice(const(self.start), const(self.stop), const(self.step))
+
+
+class Concat(Expr):
+    """Concatenates the list of expressions provided after converting
+    them to strings.
+    """
+
+    fields = ("nodes",)
+    nodes: t.List[Expr]
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> str:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return "".join(str(x.as_const(eval_ctx)) for x in self.nodes)
+
+
+class Compare(Expr):
+    """Compares an expression with some other expressions.  `ops` must be a
+    list of :class:`Operand`\\s.
+    """
+
+    fields = ("expr", "ops")
+    expr: Expr
+    ops: t.List["Operand"]
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        result = value = self.expr.as_const(eval_ctx)
+
+        try:
+            for op in self.ops:
+                new_value = op.expr.as_const(eval_ctx)
+                result = _cmpop_to_func[op.op](value, new_value)
+
+                if not result:
+                    return False
+
+                value = new_value
+        except Exception as e:
+            raise Impossible() from e
+
+        return result
+
+
+class Operand(Helper):
+    """Holds an operator and an expression."""
+
+    fields = ("op", "expr")
+    op: str
+    expr: Expr
+
+
+class Mul(BinExpr):
+    """Multiplies the left with the right node."""
+
+    operator = "*"
+
+
+class Div(BinExpr):
+    """Divides the left by the right node."""
+
+    operator = "/"
+
+
+class FloorDiv(BinExpr):
+    """Divides the left by the right node and converts the
+    result into an integer by truncating.
+    """
+
+    operator = "//"
+
+
+class Add(BinExpr):
+    """Add the left to the right node."""
+
+    operator = "+"
+
+
+class Sub(BinExpr):
+    """Subtract the right from the left node."""
+
+    operator = "-"
+
+
+class Mod(BinExpr):
+    """Left modulo right."""
+
+    operator = "%"
+
+
+class Pow(BinExpr):
+    """Left to the power of right."""
+
+    operator = "**"
+
+
+class And(BinExpr):
+    """Short circuited AND."""
+
+    operator = "and"
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return self.left.as_const(eval_ctx) and self.right.as_const(eval_ctx)
+
+
+class Or(BinExpr):
+    """Short circuited OR."""
+
+    operator = "or"
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return self.left.as_const(eval_ctx) or self.right.as_const(eval_ctx)
+
+
+class Not(UnaryExpr):
+    """Negate the expression."""
+
+    operator = "not"
+
+
+class Neg(UnaryExpr):
+    """Make the expression negative."""
+
+    operator = "-"
+
+
+class Pos(UnaryExpr):
+    """Make the expression positive (noop for most expressions)"""
+
+    operator = "+"
+
+
+# Helpers for extensions
+
+
+class EnvironmentAttribute(Expr):
+    """Loads an attribute from the environment object.  This is useful for
+    extensions that want to call a callback stored on the environment.
+    """
+
+    fields = ("name",)
+    name: str
+
+
+class ExtensionAttribute(Expr):
+    """Returns the attribute of an extension bound to the environment.
+    The identifier is the identifier of the :class:`Extension`.
+
+    This node is usually constructed by calling the
+    :meth:`~jinja2.ext.Extension.attr` method on an extension.
+    """
+
+    fields = ("identifier", "name")
+    identifier: str
+    name: str
+
+
+class ImportedName(Expr):
+    """If created with an import name the import name is returned on node
+    access.  For example ``ImportedName('cgi.escape')`` returns the `escape`
+    function from the cgi module on evaluation.  Imports are optimized by the
+    compiler so there is no need to assign them to local variables.
+    """
+
+    fields = ("importname",)
+    importname: str
+
+
+class InternalName(Expr):
+    """An internal name in the compiler.  You cannot create these nodes
+    yourself but the parser provides a
+    :meth:`~jinja2.parser.Parser.free_identifier` method that creates
+    a new identifier for you.  This identifier is not available from the
+    template and is not treated specially by the compiler.
+    """
+
+    fields = ("name",)
+    name: str
+
+    def __init__(self) -> None:
+        raise TypeError(
+            "Can't create internal names.  Use the "
+            "`free_identifier` method on a parser."
+        )
+
+
+class MarkSafe(Expr):
+    """Mark the wrapped expression as safe (wrap it as `Markup`)."""
+
+    fields = ("expr",)
+    expr: Expr
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> Markup:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return Markup(self.expr.as_const(eval_ctx))
+
+
+class MarkSafeIfAutoescape(Expr):
+    """Mark the wrapped expression as safe (wrap it as `Markup`) but
+    only if autoescaping is active.
+
+    .. versionadded:: 2.5
+    """
+
+    fields = ("expr",)
+    expr: Expr
+
+    def as_const(
+        self, eval_ctx: t.Optional[EvalContext] = None
+    ) -> t.Union[Markup, t.Any]:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        if eval_ctx.volatile:
+            raise Impossible()
+        expr = self.expr.as_const(eval_ctx)
+        if eval_ctx.autoescape:
+            return Markup(expr)
+        return expr
+
+
+class ContextReference(Expr):
+    """Returns the current template context.  It can be used like a
+    :class:`Name` node, with a ``'load'`` ctx and will return the
+    current :class:`~jinja2.runtime.Context` object.
+
+    Here an example that assigns the current template name to a
+    variable named `foo`::
+
+        Assign(Name('foo', ctx='store'),
+               Getattr(ContextReference(), 'name'))
+
+    This is basically equivalent to using the
+    :func:`~jinja2.pass_context` decorator when using the high-level
+    API, which causes a reference to the context to be passed as the
+    first argument to a function.
+    """
+
+
+class DerivedContextReference(Expr):
+    """Return the current template context including locals. Behaves
+    exactly like :class:`ContextReference`, but includes local
+    variables, such as from a ``for`` loop.
+
+    .. versionadded:: 2.11
+    """
+
+
+class Continue(Stmt):
+    """Continue a loop."""
+
+
+class Break(Stmt):
+    """Break a loop."""
+
+
+class Scope(Stmt):
+    """An artificial scope."""
+
+    fields = ("body",)
+    body: t.List[Node]
+
+
+class OverlayScope(Stmt):
+    """An overlay scope for extensions.  This is a largely unoptimized scope
+    that however can be used to introduce completely arbitrary variables into
+    a sub scope from a dictionary or dictionary like object.  The `context`
+    field has to evaluate to a dictionary object.
+
+    Example usage::
+
+        OverlayScope(context=self.call_method('get_context'),
+                     body=[...])
+
+    .. versionadded:: 2.10
+    """
+
+    fields = ("context", "body")
+    context: Expr
+    body: t.List[Node]
+
+
+class EvalContextModifier(Stmt):
+    """Modifies the eval context.  For each option that should be modified,
+    a :class:`Keyword` has to be added to the :attr:`options` list.
+
+    Example to change the `autoescape` setting::
+
+        EvalContextModifier(options=[Keyword('autoescape', Const(True))])
+    """
+
+    fields = ("options",)
+    options: t.List[Keyword]
+
+
+class ScopedEvalContextModifier(EvalContextModifier):
+    """Modifies the eval context and reverts it later.  Works exactly like
+    :class:`EvalContextModifier` but will only modify the
+    :class:`~jinja2.nodes.EvalContext` for nodes in the :attr:`body`.
+    """
+
+    fields = ("body",)
+    body: t.List[Node]
+
+
+# make sure nobody creates custom nodes
+def _failing_new(*args: t.Any, **kwargs: t.Any) -> "te.NoReturn":
+    raise TypeError("can't create custom node types")
+
+
+NodeType.__new__ = staticmethod(_failing_new)  # type: ignore
+del _failing_new

shared/package-files/8b/8b813bd8c270347eb5ec038972ee3150da92249c11df6840e915e92c1926855b/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 cpu {
+
+TORCH_API at::Tensor special_i1(const at::Tensor & self);
+TORCH_API at::Tensor & special_i1_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & special_i1_outf(const at::Tensor & self, at::Tensor & out);
+
+} // namespace cpu
+} // namespace at

shared/package-files/8b/8b8318b8974f0efa80f9a0f97da51096db1cbca83be1effcb840b479e6cafcf0/blob

@@ -0,0 +1,61 @@
+from torch.utils.data.datapipes.utils.common import _check_unpickable_fn
+from typing import Callable, TypeVar
+from torch.utils.data.datapipes._decorator import functional_datapipe
+from torch.utils.data.datapipes.datapipe import MapDataPipe
+
+__all__ = ["MapperMapDataPipe", "default_fn"]
+
+T_co = TypeVar('T_co', covariant=True)
+
+
+# Default function to return each item directly
+# In order to keep datapipe picklable, eliminates the usage
+# of python lambda function
+def default_fn(data):
+    return data
+
+
+@functional_datapipe('map')
+class MapperMapDataPipe(MapDataPipe[T_co]):
+    r"""
+    Apply the input function over each item from the source DataPipe (functional name: ``map``).
+
+    The function can be any regular Python function or partial object. Lambda
+    function is not recommended as it is not supported by pickle.
+
+    Args:
+        datapipe: Source MapDataPipe
+        fn: Function being applied to each item
+
+    Example:
+        >>> # xdoctest: +SKIP
+        >>> from torchdata.datapipes.map import SequenceWrapper, Mapper
+        >>> def add_one(x):
+        ...     return x + 1
+        >>> dp = SequenceWrapper(range(10))
+        >>> map_dp_1 = dp.map(add_one)
+        >>> list(map_dp_1)
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        >>> map_dp_2 = Mapper(dp, lambda x: x + 1)
+        >>> list(map_dp_2)
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    """
+
+    datapipe: MapDataPipe
+    fn: Callable
+
+    def __init__(
+        self,
+        datapipe: MapDataPipe,
+        fn: Callable = default_fn,
+    ) -> None:
+        super().__init__()
+        self.datapipe = datapipe
+        _check_unpickable_fn(fn)
+        self.fn = fn  # type: ignore[assignment]
+
+    def __len__(self) -> int:
+        return len(self.datapipe)
+
+    def __getitem__(self, index) -> T_co:
+        return self.fn(self.datapipe[index])

shared/package-files/8b/8b90c2623ff71532b5856bc5736ec3488566bdcf66628a9bad443b4783bc23ed/blob

@@ -0,0 +1,113 @@
+/*quarterly, seasonally adjusted, U.S.
+fixed investment (y1), change in business inventories (y2),
+1947Q1-1972Q4;
+source: U.S. Department of Commerce, Bureau of Economic Analysis,
+The National Income and Product Accounts of the United States, 1929-1974
+*/
+
+<1947 Q1>
+   y1         y2
+ 69.6        0.1
+ 67.6       -0.9
+ 69.5       -2.9
+ 74.7        2.7
+ 77.1        4.1
+ 77.4        5.6
+ 76.6        6.9
+ 76.1        5.3
+ 71.8       -0.3
+ 68.9       -7.1
+ 68.5       -2.5
+ 70.6       -7.7
+ 75.4        4.4
+ 82.3        7.7
+ 88.2        8.0
+ 86.9       22.1
+ 83.4       13.4
+ 80.3       19.9
+ 79.4       14.6
+ 78.6        7.0
+ 79.3        7.3
+ 80.3       -2.7
+ 75.3        5.4
+ 80.6        7.2
+ 83.9        3.9
+ 84.2        5.1
+ 84.4        1.9
+ 83.8       -5.0
+ 82.8       -3.4
+ 84.1       -4.1
+ 87.0       -2.7
+ 88.5        1.5
+ 92.1        5.9
+ 96.1        8.0
+ 98.3        7.8
+ 98.8        9.2
+ 96.6        7.5
+ 97.4        5.5
+ 97.6        4.9
+ 96.6        5.4
+ 96.2        2.5
+ 95.3        2.9
+ 96.4        3.7
+ 94.9       -3.0
+ 90.0       -6.8
+ 87.2       -6.2
+ 88.0        0.3
+ 93.0        5.3
+ 98.3        5.0
+101.6       13.0
+102.6       -0.4
+101.4        8.2
+104.9       13.5
+101.8        4.9
+ 98.8        3.0
+ 98.6       -3.9
+ 97.7       -3.8
+ 99.2        1.9
+101.3        6.6
+104.6        6.7
+106.1       10.6
+109.9        9.2
+111.1        8.0
+110.1        4.7
+110.7        7.6
+116.0        7.0
+118.5        9.3
+122.0        7.1
+124.0        6.1
+124.0        8.0
+124.9        7.3
+126.4        7.9
+133.4       13.4
+137.9       10.6
+140.1       12.4
+143.8        8.8
+147.5       13.5
+146.2       17.8
+145.0       15.1
+139.7       20.5
+136.4       14.6
+139.6        7.5
+141.1       12.2
+145.5       13.8
+148.9        6.3
+148.9       11.8
+150.7        9.2
+155.0        7.6
+159.1        9.8
+158.4       12.2
+158.1       13.4
+154.3        6.8
+151.8        2.9
+150.0        4.8
+150.4        6.3
+149.5        3.3
+154.3        7.9
+158.4       10.0
+162.1        5.0
+166.0        3.7
+174.3        4.8
+176.1       10.1
+178.2       12.1
+186.7       10.8

shared/package-files/8b/8b9121a163d486ee2495add7bb866f5c5d6554b3e223a660e21ea8f236a26a6a/blob

@@ -0,0 +1,6 @@
+from numpy.core import _dtype_ctypes
+
+_globals = globals()
+
+for item in _dtype_ctypes.__dir__():
+    _globals[item] = getattr(_dtype_ctypes, item)

shared/package-files/8b/8b9262fc79b943a382d24a96dab8a16757398cd7d7ea33766fd7e5ed6382a645/blob

@@ -0,0 +1,547 @@
+[build-system]
+build-backend = 'mesonpy'
+requires = [
+    'meson-python',
+    "cython>=3.0.13,<4",  # Sync with CYTHON_MIN_VER in setup
+    "numpy>=2.0.0,<3",
+    "scipy>=1.13,<2",
+    "setuptools_scm>=9.2.0,<10",
+]
+
+[project]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Programming Language :: Cython",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: OS Independent",
+    "Intended Audience :: End Users/Desktop",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Natural Language :: English",
+    "Topic :: Office/Business :: Financial",
+    "Topic :: Scientific/Engineering",
+]
+description = "Statistical computations and models for Python"
+dynamic = ["version"]
+keywords = [
+    "statistics",
+    "econometrics",
+    "time series",
+    "regression",
+    "anova",
+    "statistical tests",
+    "linear models",
+    "generalized linear models",
+    "discrete choice models",
+    "robust linear models",
+    "mixed linear models",
+    "time series analysis",
+    "state space models",
+    "vector autoregression",
+    "volatility modeling",
+    "unit root tests",
+    "cointegration tests",
+    "nonparametric methods",
+    "multivariate statistics"
+]
+license = "BSD-3-Clause"
+license-files = [ "LICENSE.txt" ]
+maintainers = [
+    { name = "statsmodels Developers", email = "pystatsmodels@googlegroups.com" },
+]
+name = "statsmodels"
+dependencies = [
+    "numpy>=1.23.5,<3",  # released March 2022
+    "scipy>=1.8,!=1.9.2",  # released Feb 2022, 1.9.2 blocked due to bug
+    "pandas>=1.4,!=2.1.0",  # released Feb 2022, 2.1.0 blocked due to bug
+    "patsy>=0.5.6",  # released December 2023
+    "packaging>=21.3",  # released Nov 2021
+    "formulaic>=1.1.0",  # released December 2024
+]
+readme = "README.md"
+requires-python = ">=3.10"
+
+[project.optional-dependencies]
+test = [
+    # test
+    "pytest>=8.4.1,<10",
+    "pytest-randomly",
+    "pytest-run-parallel",
+    "pytest-xdist",
+    "pytest-cov",
+    "coverage[toml]",
+    "meson",
+    'ninja; sys_platform != "emscripten"',
+]
+doc = [
+    # Requirements for doc build, in addition to requirements.txt
+    "sphinx",
+    # Avoid warnings which break Sphinx by pinning pandas
+    "pandas>=2.2.2,!=2.1.0",
+    "pydata-sphinx-theme",
+    "jupyter",
+    "notebook",
+    "nbsphinx",
+    "nbconvert",
+    "pyyaml",
+    "pandas-datareader",
+    "simplegeneric",
+    "seaborn",
+    "numpydoc",
+    # "theano-pymc; os_name != 'nt'", # disabled because it is not compatible with move recent Python version
+    "pymc; os_name != 'nt'",
+    "arviz; os_name != 'nt'",
+    "jinja2",
+    "pickleshare",
+    "pytest>=8.4.1,<10",
+]
+dev = [
+    # build
+    "cython>=3.0.10,<4",
+    "setuptools_scm~=9.0",
+    "meson-python>=0.18.0",
+    "meson",
+    "ninja",
+    # run
+    "matplotlib>=3",
+    "colorama",
+    "joblib",
+    # Remove due to failures on azure CI
+    # cvxopt; os_name != "win32"
+    # Pin on Win32
+    "pywinpty; os_name == 'nt'",
+    # code quality
+    "ruff",
+]
+polars = [
+    # Polars support
+    "polars>=1.0.0",
+]
+
+[project.urls]
+homepage = "https://www.statsmodels.org"
+documentation = "https://www.statsmodels.org/stable/index.html"
+repository = "https://github.com/statsmodels/statsmodels"
+changelog = "https://bashtage.github.io/arch/changes.html"
+bugtracker = "https://github.com/statsmodels/statsmodels/issues"
+
+[tool.meson-python.args]
+setup = ['--vsenv']
+
+[tool.ruff]
+line-length = 88
+fix = false
+# Matches requires-python (>=3.10) and [tool.black]'s target-version below;
+# also affects which pyupgrade (UP) rules apply.
+target-version = "py310"
+# archive/ is explicitly documented (archive/README) as deprecated, no
+# longer maintained legacy code; excluded so it's not linted as if it
+# were part of the active codebase.
+extend-exclude = ["archive", "examples/python"]
+
+[tool.ruff.lint]
+typing-modules = ["statsmodels.compat.python", "compat.python"]
+
+select = [
+  # pyflakes
+  "F",
+  # pycodestyle
+  "E", "W",
+  # flake8-2020
+  "YTT",
+  # flake8-bugbear
+  "B",
+  # flake8-quotes
+  "Q",
+  # flake8-debugger
+  "T10",
+  # flake8-gettext
+  "INT",
+  # pylint
+  "PL",
+  # flake8-pytest-style
+  "PT",
+  # misc lints
+  "PIE",
+  # flake8-pyi
+  "PYI",
+  # tidy imports
+  "TID",
+  # implicit string concatenation
+  "ISC",
+  # flake8-type-checking
+  "TC",
+  # comprehensions
+  "C4",
+  # pygrep-hooks
+  "PGH",
+  # Ruff-specific rules
+  "RUF",
+  # Perflint
+  "PERF",
+  # flynt
+  "FLY",
+  # flake8-future-annotations
+  "FA",
+  # flake8-import-conventions
+  "ICN",
+  # flake8-slots
+  "SLOT",
+  # flake8-raise
+  "RSE",
+  # flake8-async
+  "ASYNC",
+  # flake8-executable
+  "EXE",
+  # flake8-logging-format
+  "G",
+  # flake8-logging
+  "LOG",
+  # refurb
+  "FURB",
+  # flake8-bandit
+  "S",
+  # isort
+  "I",
+  # pyupgrade
+  "UP",
+  # flake8-builtins
+  "A",
+  # flake8-airflow (this project has no Airflow usage, so this and the
+  # frameworks below are all currently clean; enabled for completeness)
+  "AIR",
+  # flake8-commas: only COM812/COM819 fail (already in the never-enable
+  # list above), COM818 is otherwise clean
+  "COM",
+  # flake8-django (no Django usage, currently clean)
+  "DJ",
+  # flake8-datetimez
+  "DTZ",
+  # flake8-fastapi (no FastAPI usage, currently clean)
+  "FAST",
+  # pandas-vet
+  "PD",
+  # flake8-use-pathlib: os.path is used throughout, but fewer than half
+  # the rule's codes actually fire here, so the category is selected with
+  # the failing codes carved out below (see ignore list) rather than
+  # listing the larger set of passing codes individually. A full
+  # os.path -> pathlib migration is a bigger undertaking than a config
+  # change.
+  "PTH",
+  # pep8-naming: most of "N" fails on scientific/statistical variable
+  # naming conventions (e.g. X, Y, N806 alone is 2000+ hits), so only the
+  # individually-clean rules are selected rather than the whole category.
+  "N804", "N811", "N813", "N817",
+  # flake8-simplify: most of "SIM" still has real hits, so only the
+  # individually-clean rules are selected rather than the whole category.
+  "SIM107", "SIM109", "SIM110", "SIM112", "SIM116", "SIM202", "SIM208",
+  "SIM220", "SIM221", "SIM222", "SIM223", "SIM911",
+  # tryceratops: TRY003 alone (no vanilla-args messages in raise) is
+  # 1300+ hits, so only the individually-clean rules are selected rather
+  # than the whole category.
+  "TRY400", "TRY401",
+  # flake8-use-pathlib
+  "PTH",
+    "RET501",
+    "RET502",
+    "RET507",
+    "RET508",
+]
+
+# pydocstyle ("D") is intentionally NOT selected above. This project already
+# validates numpydoc docstring structure via tools/validate_docstrings.py
+# (built on the numpydoc package), which understands our numpydoc convention
+# far more precisely than ruff's generic pydocstyle checks do - even with
+# `[tool.ruff.lint.pydocstyle] convention = "numpy"` set, D still produces
+# tens of thousands of violations and disagrees with the dedicated
+# validator in places. Do not add "D" to select.
+
+ignore = [
+  # Required to allow black formatting
+  # Whitespace before ':' (Needed for black)
+  "E203",
+  # Line too long (### > 88 characters) (Needed for black)
+  "E501",
+  # Multiple statements on one line (colon) (E701)
+  "E701",
+
+  ### Never enable: these conflict with the black/ruff-format formatter.
+  # ISC001 is deliberately NOT in this list: we keep ISC001 enabled and fix
+  # the occasional real violation by hand instead of suppressing it.
+  "COM812", # missing-trailing-comma: black decides this, not us
+  "COM819", # prohibited-trailing-comma: black decides this, not us
+  "Q003", # avoidable-escaped-quote
+
+  ### Intentionally disabled
+  # Counts below are from `ruff check . --select ALL`
+  # (this project's conformance scope), refreshed 2026-07-27.
+  # Too many arguments to function call
+  "PLR0913", # 645
+  # Too many returns
+  "PLR0911", # 12
+  # Too many branches
+  "PLR0912", # 221
+  # Too many statements
+  "PLR0915", # 221
+  # Too many positional arguments
+  "PLR0917", # 617
+  # Redefined loop name
+  "PLW2901", # 49
+  # incorrect-dict-iterator, flags valid Series.items usage
+  "PERF102", # 5
+  # try-except-in-loop, becomes useless in Python 3.11
+  "PERF203", # 9
+  # pytest-parametrize-names-wrong-type
+  "PT006", # 36
+  # pytest-raises-with-multiple-statements
+  "PT012", # 15
+  # Docstring contains ambiguous letter
+  "RUF002", # Do Not Enable
+  # Magic number
+  "PLR2004", # 717
+  # import-outside-toplevel
+  "PLC0415", # 853
+
+  ### TODO: Enable gradually
+  # Too many uses of dict(...) instread of {...}
+  # Would be good enforce eventually
+  "C408", # 324
+  # Too many places without match= in pytest raises
+  # Would be goot enforce eventually
+  "PT011", # 519
+  "RUF059", # 342
+  "PERF401", # 30
+  # collection-literal-concatenation
+  "RUF005", # 138
+  # mutable-class-default
+  "RUF012", # 177
+  # repeated-equality-comparison
+  "PLR1714", # 27
+
+  ### New 2026-07-27 when enabling ASYNC, EXE, G, LOG, FURB, S, full ICN
+  # assert is used pervasively outside of tests in this codebase (input
+  # validation, invariant checks); not adopting flake8-bandit's blanket
+  # objection to it
+  "S101", # 1669
+  # try/except/pass: mostly deliberate best-effort cleanup code
+  "S110", # 5
+  # pickle usage: needed for model persistence, a documented feature
+  "S301", # 11
+  # eval usage in a handful of expression-parsing helpers
+  "S307", # 3
+  # urlopen used only for fetching public, hardcoded dataset URLs
+  "S310", # 2
+  # subprocess with shell=True / without shell=True check: used in a couple
+  # of dev/CI helper scripts, not on untrusted input
+  "S602", # 2
+  "S603", # 2
+
+  ### New 2026-07-27 when enabling A, DTZ, PD, PTH
+  # Variable/argument/import shadows a builtin name (e.g. `id`, `type`,
+  # `filter`); common in this codebase's mathematical notation and not
+  # worth a rename sweep
+  "A001", # 35
+  "A002", # 10
+  "A004", # 2
+  # datetime()/datetime.now() without tzinfo; this project works with
+  # naive timestamps throughout (dataset dates, log timestamps) and does
+  # not need timezone-aware datetimes
+  "DTZ001", # 82
+  "DTZ005", # 4
+  # inplace=True is used deliberately in a number of places
+  "PD002", # 10
+  # .pivot()/.unstack() and .stack() instead of .pivot_table()/.melt():
+  # deliberate choices, not accidental API misuse
+  "PD010", # 25
+  "PD013", # 13
+  # .values instead of .to_numpy(): a pervasive, long-standing idiom
+  # throughout this codebase, not worth a mechanical rewrite
+  "PD011", # 308
+  # os.path used throughout instead of pathlib; a real modernization
+  # opportunity, but a bigger migration than a quick fix
+  "PTH100", # 107
+  "PTH103", # 4
+  "PTH106", # 1
+  "PTH107", # 6
+  "PTH110", # 13
+  "PTH111", # 1
+  "PTH112", # 1
+  "PTH113", # 1
+  "PTH118", # 237
+  "PTH119", # 1
+  "PTH120", # 123
+  "PTH122", # 4
+  "PTH123", # 89
+  "PTH204", # 4
+  "PTH207", # 6
+  "PTH208", # 3
+]
+
+[tool.ruff.lint.flake8-quotes]
+multiline-quotes = "double"
+
+[tool.ruff.lint.isort]
+# Mirrors original [tool.isort] below as closely as ruff's isort implementation
+# allows. 
+combine-as-imports = true
+force-sort-within-sections = true
+known-first-party = ["statsmodels"]
+known-third-party = ["Cython", "cython", "numpy", "matplotlib", "pandas", "patsy", "pytest", "cvxopt"]
+section-order = ["future", "compat", "standard-library", "third-party", "first-party", "local-folder"]
+split-on-trailing-comma = true
+
+[tool.ruff.lint.isort.sections]
+# Mirrors known_compat from [tool.isort].
+compat = ["statsmodels.compat", "setuptools"]
+
+[tool.ruff.lint.per-file-ignores]
+# relative imports allowed for asv_bench
+"statsmodels/__init__.py" = ["PT028"]
+"statsmodels/tsa/vector_ar/var_model.py" = ["PT028"]
+"statsmodels/stats/rates.py" = ["PT028"]
+"statsmodels/stats/proportion.py" = ["PT028"]
+"statsmodels/stats/oneway.py" = ["PT028"]
+"statsmodels/stats/multivariate.py" = ["PT028"]
+"statsmodels/stats/diagnostic_gen.py" = ["PT028"]
+"statsmodels/discrete/_diagnostics_count.py" = ["PT028"]
+"statsmodels/examples/tests/test_notebooks.py" = ["F401"]
+# Example scripts/notebooks are left as-is (not converted to pathlib).
+"**/examples/**" = ["PTH"]
+[tool.pytest.ini_options]
+minversion = "8.4.1"
+addopts = "--strict --durations=30 --junitxml=test-data.xml --randomly-dont-reset-seed"
+testpaths = "statsmodels"
+xfail_strict = true
+empty_parameter_set_mark = "fail_at_collect"
+filterwarnings = [
+    "ignore:`formatargspec`:DeprecationWarning:statsmodels",
+    "ignore:Using or importing:DeprecationWarning",
+    "ignore:Session._key_changed is deprecated:DeprecationWarning",
+    "error:Support for multi-dimensional:DeprecationWarning",
+    "error:Mutating unit root tests is deprecated:FutureWarning",
+    "error:Lag selection has changed:DeprecationWarning",
+    "error:More than 20 figures have been opened:RuntimeWarning:",
+    "error:Inequality constraints incompatible::",
+    "error:Parameters are not consistent with a::",
+    "ignore:The --strict option is deprecated:pytest.PytestDeprecationWarning",
+    "error:The default for reindex:FutureWarning:",
+    "error:Values in x were outside bounds:RuntimeWarning:",
+    "error:The random_state property is deprecated:FutureWarning",
+    "error:random_state is deprecated:FutureWarning",
+    "error:seed is deprecated:FutureWarning",
+    "error:get_state is deprecated:FutureWarning",
+    "error:Conversion of an array with ndim:DeprecationWarning:",
+    "error:the matrix subclass is not the recommended::",
+    "error:The Dataframe Interchange Protocol::",
+    "error:Setting the shape:DeprecationWarning:",
+    "error:After 0.17 or January 2028:FutureWarning:",
+    "error:A future version of pandas:",
+    "error:The inplace keyword in::",
+    "error:Keyword arguments have been passed:FutureWarning:",
+    "error:After statsmodels 0.15 is released:FutureWarning:",
+    "error:Passing `None` as the seed currently:FutureWarning:",
+    "error:the 'random_state' keyword is deprecated:FutureWarning:",
+    "error:the 'seed' keyword is deprecated:FutureWarning:",
+    "error:the 'center' keyword is deprecated:FutureWarning:",
+    "error:Unpacking:FutureWarning:",
+    "error:The test statistic is outside:statsmodels.tools.sm_exceptions.InterpolationWarning:",
+    "error:The design matrix is:statsmodels.tools.sm_exceptions.SingularMatrixWarning:",
+    "error:Fast medcouple algorithm:UserWarning:",
+    "error:medcouple is undefined:UserWarning:",
+    "error:Provided `endog` series:UserWarning:",
+    # Strict checks disabled
+    # "error:overflow encountered in square:RuntimeWarning",
+    # "error:invalid value encountered in cos:RuntimeWarning",
+    # "error:divide by zero encountered in double_scalars:RuntimeWarning",
+    # "error:invalid value encountered in log:RuntimeWarning",
+    # "error:invalid value encountered in sqrt:RuntimeWarning:",
+    # "error:overflow encountered in double_scalars:RuntimeWarning:",
+    # "error:overflow encountered in multiply:RuntimeWarning:",
+]
+junit_family = "xunit2"
+markers = [
+    "example: mark a test that runs example code",
+    "matplotlib: mark a test that requires matplotlib",
+    "slow: mark a test as slow",
+    "smoke: mark a test as a smoke test",
+    "high_memory: mark a test as a high memory utilization test",
+    "low_precision: mark a test as low precision",
+    "todo: mark a test as incomplete",
+    "polars: mark a test that requires polars",
+    "singleton_randomstate: mark a test as changing the singleton RandomState",
+    "joblib: mark a test as using joblib for parallel computation",
+]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.coverage.run]
+source = ["statsmodels"]
+branch = true
+plugins = ["Cython.Coverage"]
+omit = [
+    # print_version is untestable
+    "*/print_version.py",
+    # skip compatibility code
+    "*/compat/*",
+    # Unused file
+    "*/results/gee_generate_tests.py",
+    # Results for tests
+    "*/tests/results/*",
+    # Simulation checks
+    "*/tests/*_simulation_check.py",
+    # Misc non-test files in test directories
+    "*/tests/_*",
+    "*/tests/e*",
+    "*/tests/c*",
+    "*/tests/d*",
+    "*/tests/g*",
+    "*/tests/m*",
+    "*/tests/p*",
+    "*/tests/r*",
+    "*/tests/s*",
+    "*/_version.py",
+    "*/_pss_critical_values/*",
+]
+
+[tool.coverage.report]
+show_missing = true
+ignore_errors = false
+# Regexes for lines to exclude from consideration
+exclude_also = [
+    # Have to re-enable the standard pragma
+    "pragma: no cover",
+
+    # Do not complain about missing debug-only code:
+    "def __repr__",
+    "if self\\.debug",
+    "if pdf_output:",
+
+    # Do not complain if tests do not hit defensive assertion code:
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "except NotImplementedError",
+    "except ImportError",
+    "except (HTTPError, URLError, SSLError, timeout)",
+    "except IGNORED_EXCEPTIONS",
+
+    # Ignore pass
+    "pass",
+
+    # Do not complain if non-runnable code is not run:
+    "if 0:",
+    "if __name__ == .__main__.:",
+]
+
+[tool.coverage.html]
+directory = "coverage_html_report"
+
+
+[tool.black]
+line-length = 88
+target-version = ["py310"]

shared/package-files/8b/8b98ae07154d4192178886dad7c2939d83412ccd802457b11bfa7dba4356364e/blob

@@ -0,0 +1,461 @@
+#pragma once
+
+#include <cstdint>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+#include <c10/core/OptionalRef.h>
+#include <c10/core/ScalarType.h>
+#include <c10/core/SymBool.h>
+#include <c10/core/SymFloat.h>
+#include <c10/core/SymInt.h>
+#include <c10/core/SymNodeImpl.h>
+#include <c10/macros/Export.h>
+#include <c10/macros/Macros.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Exception.h>
+#include <c10/util/Half.h>
+#include <c10/util/TypeCast.h>
+#include <c10/util/complex.h>
+#include <c10/util/intrusive_ptr.h>
+
+namespace c10 {
+
+/**
+ * Scalar represents a 0-dimensional tensor which contains a single element.
+ * Unlike a tensor, numeric literals (in C++) are implicitly convertible to
+ * Scalar (which is why, for example, we provide both add(Tensor) and
+ * add(Scalar) overloads for many operations). It may also be used in
+ * circumstances where you statically know a tensor is 0-dim and single size,
+ * but don't know its type.
+ */
+class C10_API Scalar {
+ public:
+  Scalar() : Scalar(int64_t(0)) {}
+
+  void destroy() {
+    if (Tag::HAS_si == tag || Tag::HAS_sd == tag || Tag::HAS_sb == tag) {
+      raw::intrusive_ptr::decref(v.p);
+      v.p = nullptr;
+    }
+  }
+
+  ~Scalar() {
+    destroy();
+  }
+
+#define DEFINE_IMPLICIT_CTOR(type, name) \
+  Scalar(type vv) : Scalar(vv, true) {}
+
+  AT_FORALL_SCALAR_TYPES_AND7(
+      Half,
+      BFloat16,
+      Float8_e5m2,
+      Float8_e4m3fn,
+      Float8_e5m2fnuz,
+      Float8_e4m3fnuz,
+      ComplexHalf,
+      DEFINE_IMPLICIT_CTOR)
+  AT_FORALL_COMPLEX_TYPES(DEFINE_IMPLICIT_CTOR)
+
+  // Helper constructors to allow Scalar creation from long and long long types
+  // As std::is_same_v<long, long long> is false(except Android), one needs to
+  // provide a constructor from either long or long long in addition to one from
+  // int64_t
+#if defined(__APPLE__) || defined(__MACOSX)
+  static_assert(
+      std::is_same_v<long long, int64_t>,
+      "int64_t is the same as long long on MacOS");
+  Scalar(long vv) : Scalar(vv, true) {}
+#endif
+#if defined(__linux__) && !defined(__ANDROID__)
+  static_assert(
+      std::is_same_v<long, int64_t>,
+      "int64_t is the same as long on Linux");
+  Scalar(long long vv) : Scalar(vv, true) {}
+#endif
+
+  Scalar(uint16_t vv) : Scalar(vv, true) {}
+  Scalar(uint32_t vv) : Scalar(vv, true) {}
+  Scalar(uint64_t vv) {
+    if (vv > static_cast<uint64_t>(INT64_MAX)) {
+      tag = Tag::HAS_u;
+      v.u = vv;
+    } else {
+      tag = Tag::HAS_i;
+      // NB: no need to use convert, we've already tested convertibility
+      v.i = static_cast<int64_t>(vv);
+    }
+  }
+
+#undef DEFINE_IMPLICIT_CTOR
+
+  // Value* is both implicitly convertible to SymbolicVariable and bool which
+  // causes ambiguity error. Specialized constructor for bool resolves this
+  // problem.
+  template <
+      typename T,
+      typename std::enable_if_t<std::is_same_v<T, bool>, bool>* = nullptr>
+  Scalar(T vv) : tag(Tag::HAS_b) {
+    v.i = convert<int64_t, bool>(vv);
+  }
+
+  template <
+      typename T,
+      typename std::enable_if_t<std::is_same_v<T, c10::SymBool>, bool>* =
+          nullptr>
+  Scalar(T vv) : tag(Tag::HAS_sb) {
+    v.i = convert<int64_t, c10::SymBool>(vv);
+  }
+
+#define DEFINE_ACCESSOR(type, name)                                   \
+  type to##name() const {                                             \
+    if (Tag::HAS_d == tag) {                                          \
+      return checked_convert<type, double>(v.d, #type);               \
+    } else if (Tag::HAS_z == tag) {                                   \
+      return checked_convert<type, c10::complex<double>>(v.z, #type); \
+    }                                                                 \
+    if (Tag::HAS_b == tag) {                                          \
+      return checked_convert<type, bool>(v.i, #type);                 \
+    } else if (Tag::HAS_i == tag) {                                   \
+      return checked_convert<type, int64_t>(v.i, #type);              \
+    } else if (Tag::HAS_u == tag) {                                   \
+      return checked_convert<type, uint64_t>(v.u, #type);             \
+    } else if (Tag::HAS_si == tag) {                                  \
+      return checked_convert<type, int64_t>(                          \
+          toSymInt().guard_int(__FILE__, __LINE__), #type);           \
+    } else if (Tag::HAS_sd == tag) {                                  \
+      return checked_convert<type, int64_t>(                          \
+          toSymFloat().guard_float(__FILE__, __LINE__), #type);       \
+    } else if (Tag::HAS_sb == tag) {                                  \
+      return checked_convert<type, int64_t>(                          \
+          toSymBool().guard_bool(__FILE__, __LINE__), #type);         \
+    }                                                                 \
+    TORCH_CHECK(false)                                                \
+  }
+
+  // TODO: Support ComplexHalf accessor
+  AT_FORALL_SCALAR_TYPES_WITH_COMPLEX(DEFINE_ACCESSOR)
+  DEFINE_ACCESSOR(uint16_t, UInt16)
+  DEFINE_ACCESSOR(uint32_t, UInt32)
+  DEFINE_ACCESSOR(uint64_t, UInt64)
+
+#undef DEFINE_ACCESSOR
+
+  SymInt toSymInt() const {
+    if (Tag::HAS_si == tag) {
+      return c10::SymInt(intrusive_ptr<SymNodeImpl>::reclaim_copy(
+          static_cast<SymNodeImpl*>(v.p)));
+    } else {
+      return toLong();
+    }
+  }
+
+  SymFloat toSymFloat() const {
+    if (Tag::HAS_sd == tag) {
+      return c10::SymFloat(intrusive_ptr<SymNodeImpl>::reclaim_copy(
+          static_cast<SymNodeImpl*>(v.p)));
+    } else {
+      return toDouble();
+    }
+  }
+
+  SymBool toSymBool() const {
+    if (Tag::HAS_sb == tag) {
+      return c10::SymBool(intrusive_ptr<SymNodeImpl>::reclaim_copy(
+          static_cast<SymNodeImpl*>(v.p)));
+    } else {
+      return toBool();
+    }
+  }
+
+  // also support scalar.to<int64_t>();
+  // Deleted for unsupported types, but specialized below for supported types
+  template <typename T>
+  T to() const = delete;
+
+  // audit uses of data_ptr
+  const void* data_ptr() const {
+    TORCH_INTERNAL_ASSERT(!isSymbolic());
+    return static_cast<const void*>(&v);
+  }
+
+  bool isFloatingPoint() const {
+    return Tag::HAS_d == tag || Tag::HAS_sd == tag;
+  }
+
+  C10_DEPRECATED_MESSAGE(
+      "isIntegral is deprecated. Please use the overload with 'includeBool' parameter instead.")
+  bool isIntegral() const {
+    return Tag::HAS_i == tag || Tag::HAS_si == tag || Tag::HAS_u == tag;
+  }
+  bool isIntegral(bool includeBool) const {
+    return Tag::HAS_i == tag || Tag::HAS_si == tag || Tag::HAS_u == tag ||
+        (includeBool && isBoolean());
+  }
+
+  bool isComplex() const {
+    return Tag::HAS_z == tag;
+  }
+  bool isBoolean() const {
+    return Tag::HAS_b == tag || Tag::HAS_sb == tag;
+  }
+
+  // you probably don't actually want these; they're mostly for testing
+  bool isSymInt() const {
+    return Tag::HAS_si == tag;
+  }
+  bool isSymFloat() const {
+    return Tag::HAS_sd == tag;
+  }
+  bool isSymBool() const {
+    return Tag::HAS_sb == tag;
+  }
+
+  bool isSymbolic() const {
+    return Tag::HAS_si == tag || Tag::HAS_sd == tag || Tag::HAS_sb == tag;
+  }
+
+  C10_ALWAYS_INLINE Scalar& operator=(Scalar&& other) noexcept {
+    if (&other == this) {
+      return *this;
+    }
+
+    destroy();
+    moveFrom(std::move(other));
+    return *this;
+  }
+
+  C10_ALWAYS_INLINE Scalar& operator=(const Scalar& other) {
+    if (&other == this) {
+      return *this;
+    }
+
+    *this = Scalar(other);
+    return *this;
+  }
+
+  Scalar operator-() const;
+  Scalar conj() const;
+  Scalar log() const;
+
+  template <
+      typename T,
+      typename std::enable_if_t<!c10::is_complex<T>::value, int> = 0>
+  bool equal(T num) const {
+    if (isComplex()) {
+      TORCH_INTERNAL_ASSERT(!isSymbolic());
+      auto val = v.z;
+      return (val.real() == num) && (val.imag() == T());
+    } else if (isFloatingPoint()) {
+      TORCH_CHECK(!isSymbolic(), "NYI SymFloat equality");
+      return v.d == num;
+    } else if (tag == Tag::HAS_i) {
+      if (overflows<T>(v.i, /* strict_unsigned */ true)) {
+        return false;
+      } else {
+        return static_cast<T>(v.i) == num;
+      }
+    } else if (tag == Tag::HAS_u) {
+      if (overflows<T>(v.u, /* strict_unsigned */ true)) {
+        return false;
+      } else {
+        return static_cast<T>(v.u) == num;
+      }
+    } else if (tag == Tag::HAS_si) {
+      TORCH_INTERNAL_ASSERT(false, "NYI SymInt equality");
+    } else if (isBoolean()) {
+      // boolean scalar does not equal to a non boolean value
+      TORCH_INTERNAL_ASSERT(!isSymbolic());
+      return false;
+    } else {
+      TORCH_INTERNAL_ASSERT(false);
+    }
+  }
+
+  template <
+      typename T,
+      typename std::enable_if_t<c10::is_complex<T>::value, int> = 0>
+  bool equal(T num) const {
+    if (isComplex()) {
+      TORCH_INTERNAL_ASSERT(!isSymbolic());
+      return v.z == num;
+    } else if (isFloatingPoint()) {
+      TORCH_CHECK(!isSymbolic(), "NYI SymFloat equality");
+      return (v.d == num.real()) && (num.imag() == T());
+    } else if (tag == Tag::HAS_i) {
+      if (overflows<T>(v.i, /* strict_unsigned */ true)) {
+        return false;
+      } else {
+        return static_cast<T>(v.i) == num.real() && num.imag() == T();
+      }
+    } else if (tag == Tag::HAS_u) {
+      if (overflows<T>(v.u, /* strict_unsigned */ true)) {
+        return false;
+      } else {
+        return static_cast<T>(v.u) == num.real() && num.imag() == T();
+      }
+    } else if (tag == Tag::HAS_si) {
+      TORCH_INTERNAL_ASSERT(false, "NYI SymInt equality");
+    } else if (isBoolean()) {
+      // boolean scalar does not equal to a non boolean value
+      TORCH_INTERNAL_ASSERT(!isSymbolic());
+      return false;
+    } else {
+      TORCH_INTERNAL_ASSERT(false);
+    }
+  }
+
+  bool equal(bool num) const {
+    if (isBoolean()) {
+      TORCH_INTERNAL_ASSERT(!isSymbolic());
+      return static_cast<bool>(v.i) == num;
+    } else {
+      return false;
+    }
+  }
+
+  ScalarType type() const {
+    if (isComplex()) {
+      return ScalarType::ComplexDouble;
+    } else if (isFloatingPoint()) {
+      return ScalarType::Double;
+    } else if (isIntegral(/*includeBool=*/false)) {
+      // Represent all integers as long, UNLESS it is unsigned and therefore
+      // unrepresentable as long
+      if (Tag::HAS_u == tag) {
+        return ScalarType::UInt64;
+      }
+      return ScalarType::Long;
+    } else if (isBoolean()) {
+      return ScalarType::Bool;
+    } else {
+      throw std::runtime_error("Unknown scalar type.");
+    }
+  }
+
+  Scalar(Scalar&& rhs) noexcept : tag(rhs.tag) {
+    moveFrom(std::move(rhs));
+  }
+
+  Scalar(const Scalar& rhs) : tag(rhs.tag), v(rhs.v) {
+    if (isSymbolic()) {
+      c10::raw::intrusive_ptr::incref(v.p);
+    }
+  }
+
+  Scalar(c10::SymInt si) {
+    if (auto m = si.maybe_as_int()) {
+      tag = Tag::HAS_i;
+      v.i = *m;
+    } else {
+      tag = Tag::HAS_si;
+      v.p = std::move(si).release();
+    }
+  }
+
+  Scalar(c10::SymFloat sd) {
+    if (sd.is_symbolic()) {
+      tag = Tag::HAS_sd;
+      v.p = std::move(sd).release();
+    } else {
+      tag = Tag::HAS_d;
+      v.d = sd.as_float_unchecked();
+    }
+  }
+
+  Scalar(c10::SymBool sb) {
+    if (auto m = sb.maybe_as_bool()) {
+      tag = Tag::HAS_b;
+      v.i = *m;
+    } else {
+      tag = Tag::HAS_sb;
+      v.p = std::move(sb).release();
+    }
+  }
+
+  // We can't set v in the initializer list using the
+  // syntax v{ .member = ... } because it doesn't work on MSVC
+ private:
+  enum class Tag { HAS_d, HAS_i, HAS_u, HAS_z, HAS_b, HAS_sd, HAS_si, HAS_sb };
+
+  // Note [Meaning of HAS_u]
+  // ~~~~~~~~~~~~~~~~~~~~~~~
+  // HAS_u is a bit special.  On its face, it just means that we
+  // are holding an unsigned integer.  However, we generally don't
+  // distinguish between different bit sizes in Scalar (e.g., we represent
+  // float as double), instead, it represents a mathematical notion
+  // of some quantity (integral versus floating point).  So actually,
+  // HAS_u is used solely to represent unsigned integers that could
+  // not be represented as a signed integer.  That means only uint64_t
+  // potentially can get this tag; smaller types like uint8_t fits into a
+  // regular int and so for BC reasons we keep as an int.
+
+  // NB: assumes that self has already been cleared
+  // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
+  C10_ALWAYS_INLINE void moveFrom(Scalar&& rhs) noexcept {
+    v = rhs.v;
+    tag = rhs.tag;
+    if (rhs.tag == Tag::HAS_si || rhs.tag == Tag::HAS_sd ||
+        rhs.tag == Tag::HAS_sb) {
+      // Move out of scalar
+      rhs.tag = Tag::HAS_i;
+      rhs.v.i = 0;
+    }
+  }
+
+  Tag tag;
+
+  union v_t {
+    double d{};
+    int64_t i;
+    // See Note [Meaning of HAS_u]
+    uint64_t u;
+    c10::complex<double> z;
+    c10::intrusive_ptr_target* p;
+    // NOLINTNEXTLINE(modernize-use-equals-default)
+    v_t() {} // default constructor
+  } v;
+
+  template <
+      typename T,
+      typename std::enable_if_t<
+          std::is_integral_v<T> && !std::is_same_v<T, bool>,
+          bool>* = nullptr>
+  Scalar(T vv, bool) : tag(Tag::HAS_i) {
+    v.i = convert<decltype(v.i), T>(vv);
+  }
+
+  template <
+      typename T,
+      typename std::enable_if_t<
+          !std::is_integral_v<T> && !c10::is_complex<T>::value,
+          bool>* = nullptr>
+  Scalar(T vv, bool) : tag(Tag::HAS_d) {
+    v.d = convert<decltype(v.d), T>(vv);
+  }
+
+  template <
+      typename T,
+      typename std::enable_if_t<c10::is_complex<T>::value, bool>* = nullptr>
+  Scalar(T vv, bool) : tag(Tag::HAS_z) {
+    v.z = convert<decltype(v.z), T>(vv);
+  }
+};
+
+using OptionalScalarRef = c10::OptionalRef<Scalar>;
+
+// define the scalar.to<int64_t>() specializations
+#define DEFINE_TO(T, name)         \
+  template <>                      \
+  inline T Scalar::to<T>() const { \
+    return to##name();             \
+  }
+AT_FORALL_SCALAR_TYPES_WITH_COMPLEX(DEFINE_TO)
+DEFINE_TO(uint16_t, UInt16)
+DEFINE_TO(uint32_t, UInt32)
+DEFINE_TO(uint64_t, UInt64)
+#undef DEFINE_TO
+
+} // namespace c10

shared/package-files/8b/8b99e880d840da023013d691988e76f16c3dc20737eb2fb046659b390e819fc0/blob

@@ -0,0 +1,32 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor random(const at::Tensor & self, int64_t from, c10::optional<int64_t> to, c10::optional<at::Generator> generator=c10::nullopt);
+TORCH_API at::Tensor & random_from_out(const at::Tensor & self, int64_t from, c10::optional<int64_t> to, c10::optional<at::Generator> generator, at::Tensor & out);
+TORCH_API at::Tensor & random_(at::Tensor & self, int64_t from, c10::optional<int64_t> to, c10::optional<at::Generator> generator=c10::nullopt);
+TORCH_API at::Tensor & random_meta_(at::Tensor & self, int64_t from, c10::optional<int64_t> to, c10::optional<at::Generator> generator=c10::nullopt);
+TORCH_API at::Tensor random(const at::Tensor & self, int64_t to, c10::optional<at::Generator> generator=c10::nullopt);
+TORCH_API at::Tensor & random_to_out(const at::Tensor & self, int64_t to, c10::optional<at::Generator> generator, at::Tensor & out);
+TORCH_API at::Tensor & random_(at::Tensor & self, int64_t to, c10::optional<at::Generator> generator=c10::nullopt);
+TORCH_API at::Tensor & random_meta_(at::Tensor & self, int64_t to, c10::optional<at::Generator> generator=c10::nullopt);
+TORCH_API at::Tensor random(const at::Tensor & self, c10::optional<at::Generator> generator=c10::nullopt);
+TORCH_API at::Tensor & random_out(const at::Tensor & self, c10::optional<at::Generator> generator, at::Tensor & out);
+TORCH_API at::Tensor & random_(at::Tensor & self, c10::optional<at::Generator> generator=c10::nullopt);
+TORCH_API at::Tensor & random_meta_(at::Tensor & self, c10::optional<at::Generator> generator=c10::nullopt);
+} // namespace native
+} // namespace at

shared/package-files/8b/8b9f5dff2e2f70ac88457066a9b8e3d18518df408da36edd42f904642f50d944/blob

@@ -0,0 +1,921 @@
+"""Abstract linear algebra library.
+
+This module defines a class hierarchy that implements a kind of "lazy"
+matrix representation, called the ``LinearOperator``. It can be used to do
+linear algebra with extremely large sparse or structured matrices, without
+representing those explicitly in memory. Such matrices can be added,
+multiplied, transposed, etc.
+
+As a motivating example, suppose you want have a matrix where almost all of
+the elements have the value one. The standard sparse matrix representation
+skips the storage of zeros, but not ones. By contrast, a LinearOperator is
+able to represent such matrices efficiently. First, we need a compact way to
+represent an all-ones matrix::
+
+    >>> import numpy as np
+    >>> from scipy.sparse.linalg._interface import LinearOperator
+    >>> class Ones(LinearOperator):
+    ...     def __init__(self, shape):
+    ...         super().__init__(dtype=None, shape=shape)
+    ...     def _matvec(self, x):
+    ...         return np.repeat(x.sum(), self.shape[0])
+
+Instances of this class emulate ``np.ones(shape)``, but using a constant
+amount of storage, independent of ``shape``. The ``_matvec`` method specifies
+how this linear operator multiplies with (operates on) a vector. We can now
+add this operator to a sparse matrix that stores only offsets from one::
+
+    >>> from scipy.sparse.linalg._interface import aslinearoperator
+    >>> from scipy.sparse import csr_array
+    >>> offsets = csr_array([[1, 0, 2], [0, -1, 0], [0, 0, 3]])
+    >>> A = aslinearoperator(offsets) + Ones(offsets.shape)
+    >>> A.dot([1, 2, 3])
+    array([13,  4, 15])
+
+The result is the same as that given by its dense, explicitly-stored
+counterpart::
+
+    >>> (np.ones(A.shape, A.dtype) + offsets.toarray()).dot([1, 2, 3])
+    array([13,  4, 15])
+
+Several algorithms in the ``scipy.sparse`` library are able to operate on
+``LinearOperator`` instances.
+"""
+
+import warnings
+
+import numpy as np
+
+from scipy.sparse import issparse
+from scipy.sparse._sputils import isshape, isintlike, asmatrix, is_pydata_spmatrix
+
+__all__ = ['LinearOperator', 'aslinearoperator']
+
+
+class LinearOperator:
+    """Common interface for performing matrix vector products
+
+    Many iterative methods (e.g. cg, gmres) do not need to know the
+    individual entries of a matrix to solve a linear system A@x=b.
+    Such solvers only require the computation of matrix vector
+    products, A@v where v is a dense vector.  This class serves as
+    an abstract interface between iterative solvers and matrix-like
+    objects.
+
+    To construct a concrete LinearOperator, either pass appropriate
+    callables to the constructor of this class, or subclass it.
+
+    A subclass must implement either one of the methods ``_matvec``
+    and ``_matmat``, and the attributes/properties ``shape`` (pair of
+    integers) and ``dtype`` (may be None). It may call the ``__init__``
+    on this class to have these attributes validated. Implementing
+    ``_matvec`` automatically implements ``_matmat`` (using a naive
+    algorithm) and vice-versa.
+
+    Optionally, a subclass may implement ``_rmatvec`` or ``_adjoint``
+    to implement the Hermitian adjoint (conjugate transpose). As with
+    ``_matvec`` and ``_matmat``, implementing either ``_rmatvec`` or
+    ``_adjoint`` implements the other automatically. Implementing
+    ``_adjoint`` is preferable; ``_rmatvec`` is mostly there for
+    backwards compatibility.
+
+    Parameters
+    ----------
+    shape : tuple
+        Matrix dimensions (M, N).
+    matvec : callable f(v)
+        Returns returns A @ v.
+    rmatvec : callable f(v)
+        Returns A^H @ v, where A^H is the conjugate transpose of A.
+    matmat : callable f(V)
+        Returns A @ V, where V is a dense matrix with dimensions (N, K).
+    dtype : dtype
+        Data type of the matrix.
+    rmatmat : callable f(V)
+        Returns A^H @ V, where V is a dense matrix with dimensions (M, K).
+
+    Attributes
+    ----------
+    args : tuple
+        For linear operators describing products etc. of other linear
+        operators, the operands of the binary operation.
+    ndim : int
+        Number of dimensions (this is always 2)
+
+    See Also
+    --------
+    aslinearoperator : Construct LinearOperators
+
+    Notes
+    -----
+    The user-defined matvec() function must properly handle the case
+    where v has shape (N,) as well as the (N,1) case.  The shape of
+    the return type is handled internally by LinearOperator.
+
+    It is highly recommended to explicitly specify the `dtype`, otherwise
+    it is determined automatically at the cost of a single matvec application
+    on `int8` zero vector using the promoted `dtype` of the output.
+    Python `int` could be difficult to automatically cast to numpy integers
+    in the definition of the `matvec` so the determination may be inaccurate.
+    It is assumed that `matmat`, `rmatvec`, and `rmatmat` would result in
+    the same dtype of the output given an `int8` input as `matvec`.
+
+    LinearOperator instances can also be multiplied, added with each
+    other and exponentiated, all lazily: the result of these operations
+    is always a new, composite LinearOperator, that defers linear
+    operations to the original operators and combines the results.
+
+    More details regarding how to subclass a LinearOperator and several
+    examples of concrete LinearOperator instances can be found in the
+    external project `PyLops <https://pylops.readthedocs.io>`_.
+
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.sparse.linalg import LinearOperator
+    >>> def mv(v):
+    ...     return np.array([2*v[0], 3*v[1]])
+    ...
+    >>> A = LinearOperator((2,2), matvec=mv)
+    >>> A
+    <2x2 _CustomLinearOperator with dtype=int8>
+    >>> A.matvec(np.ones(2))
+    array([ 2.,  3.])
+    >>> A @ np.ones(2)
+    array([ 2.,  3.])
+
+    """
+
+    ndim = 2
+    # Necessary for right matmul with numpy arrays.
+    __array_ufunc__ = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls is LinearOperator:
+            # Operate as _CustomLinearOperator factory.
+            return super().__new__(_CustomLinearOperator)
+        else:
+            obj = super().__new__(cls)
+
+            if (type(obj)._matvec == LinearOperator._matvec
+                    and type(obj)._matmat == LinearOperator._matmat):
+                warnings.warn("LinearOperator subclass should implement"
+                              " at least one of _matvec and _matmat.",
+                              category=RuntimeWarning, stacklevel=2)
+
+            return obj
+
+    def __init__(self, dtype, shape):
+        """Initialize this LinearOperator.
+
+        To be called by subclasses. ``dtype`` may be None; ``shape`` should
+        be convertible to a length-2 tuple.
+        """
+        if dtype is not None:
+            dtype = np.dtype(dtype)
+
+        shape = tuple(shape)
+        if not isshape(shape):
+            raise ValueError(f"invalid shape {shape!r} (must be 2-d)")
+
+        self.dtype = dtype
+        self.shape = shape
+
+    def _init_dtype(self):
+        """Determine the dtype by executing `matvec` on an `int8` test vector.
+
+        In `np.promote_types` hierarchy, the type `int8` is the smallest,
+        so we call `matvec` on `int8` and use the promoted dtype of the output
+        to set the default `dtype` of the `LinearOperator`.
+        We assume that `matmat`, `rmatvec`, and `rmatmat` would result in
+        the same dtype of the output given an `int8` input as `matvec`.
+
+        Called from subclasses at the end of the __init__ routine.
+        """
+        if self.dtype is None:
+            v = np.zeros(self.shape[-1], dtype=np.int8)
+            try:
+                matvec_v = np.asarray(self.matvec(v))
+            except OverflowError:
+                # Python large `int` promoted to `np.int64`or `np.int32`
+                self.dtype = np.dtype(int)
+            else:
+                self.dtype = matvec_v.dtype
+
+    def _matmat(self, X):
+        """Default matrix-matrix multiplication handler.
+
+        Falls back on the user-defined _matvec method, so defining that will
+        define matrix multiplication (though in a very suboptimal way).
+        """
+
+        return np.hstack([self.matvec(col.reshape(-1,1)) for col in X.T])
+
+    def _matvec(self, x):
+        """Default matrix-vector multiplication handler.
+
+        If self is a linear operator of shape (M, N), then this method will
+        be called on a shape (N,) or (N, 1) ndarray, and should return a
+        shape (M,) or (M, 1) ndarray.
+
+        This default implementation falls back on _matmat, so defining that
+        will define matrix-vector multiplication as well.
+        """
+        return self.matmat(x.reshape(-1, 1))
+
+    def matvec(self, x):
+        """Matrix-vector multiplication.
+
+        Performs the operation y=A@x where A is an MxN linear
+        operator and x is a column vector or 1-d array.
+
+        Parameters
+        ----------
+        x : {matrix, ndarray}
+            An array with shape (N,) or (N,1).
+
+        Returns
+        -------
+        y : {matrix, ndarray}
+            A matrix or ndarray with shape (M,) or (M,1) depending
+            on the type and shape of the x argument.
+
+        Notes
+        -----
+        This matvec wraps the user-specified matvec routine or overridden
+        _matvec method to ensure that y has the correct shape and type.
+
+        """
+
+        x = np.asanyarray(x)
+
+        M,N = self.shape
+
+        if x.shape != (N,) and x.shape != (N,1):
+            raise ValueError('dimension mismatch')
+
+        y = self._matvec(x)
+
+        if isinstance(x, np.matrix):
+            y = asmatrix(y)
+        else:
+            y = np.asarray(y)
+
+        if x.ndim == 1:
+            y = y.reshape(M)
+        elif x.ndim == 2:
+            y = y.reshape(M,1)
+        else:
+            raise ValueError('invalid shape returned by user-defined matvec()')
+
+        return y
+
+    def rmatvec(self, x):
+        """Adjoint matrix-vector multiplication.
+
+        Performs the operation y = A^H @ x where A is an MxN linear
+        operator and x is a column vector or 1-d array.
+
+        Parameters
+        ----------
+        x : {matrix, ndarray}
+            An array with shape (M,) or (M,1).
+
+        Returns
+        -------
+        y : {matrix, ndarray}
+            A matrix or ndarray with shape (N,) or (N,1) depending
+            on the type and shape of the x argument.
+
+        Notes
+        -----
+        This rmatvec wraps the user-specified rmatvec routine or overridden
+        _rmatvec method to ensure that y has the correct shape and type.
+
+        """
+
+        x = np.asanyarray(x)
+
+        M,N = self.shape
+
+        if x.shape != (M,) and x.shape != (M,1):
+            raise ValueError('dimension mismatch')
+
+        y = self._rmatvec(x)
+
+        if isinstance(x, np.matrix):
+            y = asmatrix(y)
+        else:
+            y = np.asarray(y)
+
+        if x.ndim == 1:
+            y = y.reshape(N)
+        elif x.ndim == 2:
+            y = y.reshape(N,1)
+        else:
+            raise ValueError('invalid shape returned by user-defined rmatvec()')
+
+        return y
+
+    def _rmatvec(self, x):
+        """Default implementation of _rmatvec; defers to adjoint."""
+        if type(self)._adjoint == LinearOperator._adjoint:
+            # _adjoint not overridden, prevent infinite recursion
+            if (hasattr(self, "_rmatmat")
+                    and type(self)._rmatmat != LinearOperator._rmatmat):
+                # Try to use _rmatmat as a fallback
+                return self._rmatmat(x.reshape(-1, 1)).reshape(-1)
+            raise NotImplementedError
+        else:
+            return self.H.matvec(x)
+
+    def matmat(self, X):
+        """Matrix-matrix multiplication.
+
+        Performs the operation y=A@X where A is an MxN linear
+        operator and X dense N*K matrix or ndarray.
+
+        Parameters
+        ----------
+        X : {matrix, ndarray}
+            An array with shape (N,K).
+
+        Returns
+        -------
+        Y : {matrix, ndarray}
+            A matrix or ndarray with shape (M,K) depending on
+            the type of the X argument.
+
+        Notes
+        -----
+        This matmat wraps any user-specified matmat routine or overridden
+        _matmat method to ensure that y has the correct type.
+
+        """
+        if not (issparse(X) or is_pydata_spmatrix(X)):
+            X = np.asanyarray(X)
+
+        if X.ndim != 2:
+            raise ValueError(f'expected 2-d ndarray or matrix, not {X.ndim}-d')
+
+        if X.shape[0] != self.shape[1]:
+            raise ValueError(f'dimension mismatch: {self.shape}, {X.shape}')
+
+        try:
+            Y = self._matmat(X)
+        except Exception as e:
+            if issparse(X) or is_pydata_spmatrix(X):
+                raise TypeError(
+                    "Unable to multiply a LinearOperator with a sparse matrix."
+                    " Wrap the matrix in aslinearoperator first."
+                ) from e
+            raise
+
+        if isinstance(Y, np.matrix):
+            Y = asmatrix(Y)
+
+        return Y
+
+    def rmatmat(self, X):
+        """Adjoint matrix-matrix multiplication.
+
+        Performs the operation y = A^H @ x where A is an MxN linear
+        operator and x is a column vector or 1-d array, or 2-d array.
+        The default implementation defers to the adjoint.
+
+        Parameters
+        ----------
+        X : {matrix, ndarray}
+            A matrix or 2D array.
+
+        Returns
+        -------
+        Y : {matrix, ndarray}
+            A matrix or 2D array depending on the type of the input.
+
+        Notes
+        -----
+        This rmatmat wraps the user-specified rmatmat routine.
+
+        """
+        if not (issparse(X) or is_pydata_spmatrix(X)):
+            X = np.asanyarray(X)
+
+        if X.ndim != 2:
+            raise ValueError('expected 2-d ndarray or matrix, not %d-d'
+                             % X.ndim)
+
+        if X.shape[0] != self.shape[0]:
+            raise ValueError(f'dimension mismatch: {self.shape}, {X.shape}')
+
+        try:
+            Y = self._rmatmat(X)
+        except Exception as e:
+            if issparse(X) or is_pydata_spmatrix(X):
+                raise TypeError(
+                    "Unable to multiply a LinearOperator with a sparse matrix."
+                    " Wrap the matrix in aslinearoperator() first."
+                ) from e
+            raise
+
+        if isinstance(Y, np.matrix):
+            Y = asmatrix(Y)
+        return Y
+
+    def _rmatmat(self, X):
+        """Default implementation of _rmatmat defers to rmatvec or adjoint."""
+        if type(self)._adjoint == LinearOperator._adjoint:
+            return np.hstack([self.rmatvec(col.reshape(-1, 1)) for col in X.T])
+        else:
+            return self.H.matmat(X)
+
+    def __call__(self, x):
+        return self@x
+
+    def __mul__(self, x):
+        return self.dot(x)
+
+    def __truediv__(self, other):
+        if not np.isscalar(other):
+            raise ValueError("Can only divide a linear operator by a scalar.")
+
+        return _ScaledLinearOperator(self, 1.0/other)
+
+    def dot(self, x):
+        """Matrix-matrix or matrix-vector multiplication.
+
+        Parameters
+        ----------
+        x : array_like
+            1-d or 2-d array, representing a vector or matrix.
+
+        Returns
+        -------
+        Ax : array
+            1-d or 2-d array (depending on the shape of x) that represents
+            the result of applying this linear operator on x.
+
+        """
+        if isinstance(x, LinearOperator):
+            return _ProductLinearOperator(self, x)
+        elif np.isscalar(x):
+            return _ScaledLinearOperator(self, x)
+        else:
+            if not issparse(x) and not is_pydata_spmatrix(x):
+                # Sparse matrices shouldn't be converted to numpy arrays.
+                x = np.asarray(x)
+
+            if x.ndim == 1 or x.ndim == 2 and x.shape[1] == 1:
+                return self.matvec(x)
+            elif x.ndim == 2:
+                return self.matmat(x)
+            else:
+                raise ValueError(f'expected 1-d or 2-d array or matrix, got {x!r}')
+
+    def __matmul__(self, other):
+        if np.isscalar(other):
+            raise ValueError("Scalar operands are not allowed, "
+                             "use '*' instead")
+        return self.__mul__(other)
+
+    def __rmatmul__(self, other):
+        if np.isscalar(other):
+            raise ValueError("Scalar operands are not allowed, "
+                             "use '*' instead")
+        return self.__rmul__(other)
+
+    def __rmul__(self, x):
+        if np.isscalar(x):
+            return _ScaledLinearOperator(self, x)
+        else:
+            return self._rdot(x)
+
+    def _rdot(self, x):
+        """Matrix-matrix or matrix-vector multiplication from the right.
+
+        Parameters
+        ----------
+        x : array_like
+            1-d or 2-d array, representing a vector or matrix.
+
+        Returns
+        -------
+        xA : array
+            1-d or 2-d array (depending on the shape of x) that represents
+            the result of applying this linear operator on x from the right.
+
+        Notes
+        -----
+        This is copied from dot to implement right multiplication.
+        """
+        if isinstance(x, LinearOperator):
+            return _ProductLinearOperator(x, self)
+        elif np.isscalar(x):
+            return _ScaledLinearOperator(self, x)
+        else:
+            if not issparse(x) and not is_pydata_spmatrix(x):
+                # Sparse matrices shouldn't be converted to numpy arrays.
+                x = np.asarray(x)
+
+            # We use transpose instead of rmatvec/rmatmat to avoid
+            # unnecessary complex conjugation if possible.
+            if x.ndim == 1 or x.ndim == 2 and x.shape[0] == 1:
+                return self.T.matvec(x.T).T
+            elif x.ndim == 2:
+                return self.T.matmat(x.T).T
+            else:
+                raise ValueError(f'expected 1-d or 2-d array or matrix, got {x!r}')
+
+    def __pow__(self, p):
+        if np.isscalar(p):
+            return _PowerLinearOperator(self, p)
+        else:
+            return NotImplemented
+
+    def __add__(self, x):
+        if isinstance(x, LinearOperator):
+            return _SumLinearOperator(self, x)
+        else:
+            return NotImplemented
+
+    def __neg__(self):
+        return _ScaledLinearOperator(self, -1)
+
+    def __sub__(self, x):
+        return self.__add__(-x)
+
+    def __repr__(self):
+        M,N = self.shape
+        if self.dtype is None:
+            dt = 'unspecified dtype'
+        else:
+            dt = 'dtype=' + str(self.dtype)
+
+        return '<%dx%d %s with %s>' % (M, N, self.__class__.__name__, dt)
+
+    def adjoint(self):
+        """Hermitian adjoint.
+
+        Returns the Hermitian adjoint of self, aka the Hermitian
+        conjugate or Hermitian transpose. For a complex matrix, the
+        Hermitian adjoint is equal to the conjugate transpose.
+
+        Can be abbreviated self.H instead of self.adjoint().
+
+        Returns
+        -------
+        A_H : LinearOperator
+            Hermitian adjoint of self.
+        """
+        return self._adjoint()
+
+    H = property(adjoint)
+
+    def transpose(self):
+        """Transpose this linear operator.
+
+        Returns a LinearOperator that represents the transpose of this one.
+        Can be abbreviated self.T instead of self.transpose().
+        """
+        return self._transpose()
+
+    T = property(transpose)
+
+    def _adjoint(self):
+        """Default implementation of _adjoint; defers to rmatvec."""
+        return _AdjointLinearOperator(self)
+
+    def _transpose(self):
+        """ Default implementation of _transpose; defers to rmatvec + conj"""
+        return _TransposedLinearOperator(self)
+
+
+class _CustomLinearOperator(LinearOperator):
+    """Linear operator defined in terms of user-specified operations."""
+
+    def __init__(self, shape, matvec, rmatvec=None, matmat=None,
+                 dtype=None, rmatmat=None):
+        super().__init__(dtype, shape)
+
+        self.args = ()
+
+        self.__matvec_impl = matvec
+        self.__rmatvec_impl = rmatvec
+        self.__rmatmat_impl = rmatmat
+        self.__matmat_impl = matmat
+
+        self._init_dtype()
+
+    def _matmat(self, X):
+        if self.__matmat_impl is not None:
+            return self.__matmat_impl(X)
+        else:
+            return super()._matmat(X)
+
+    def _matvec(self, x):
+        return self.__matvec_impl(x)
+
+    def _rmatvec(self, x):
+        func = self.__rmatvec_impl
+        if func is None:
+            raise NotImplementedError("rmatvec is not defined")
+        return self.__rmatvec_impl(x)
+
+    def _rmatmat(self, X):
+        if self.__rmatmat_impl is not None:
+            return self.__rmatmat_impl(X)
+        else:
+            return super()._rmatmat(X)
+
+    def _adjoint(self):
+        return _CustomLinearOperator(shape=(self.shape[1], self.shape[0]),
+                                     matvec=self.__rmatvec_impl,
+                                     rmatvec=self.__matvec_impl,
+                                     matmat=self.__rmatmat_impl,
+                                     rmatmat=self.__matmat_impl,
+                                     dtype=self.dtype)
+
+
+class _AdjointLinearOperator(LinearOperator):
+    """Adjoint of arbitrary Linear Operator"""
+
+    def __init__(self, A):
+        shape = (A.shape[1], A.shape[0])
+        super().__init__(dtype=A.dtype, shape=shape)
+        self.A = A
+        self.args = (A,)
+
+    def _matvec(self, x):
+        return self.A._rmatvec(x)
+
+    def _rmatvec(self, x):
+        return self.A._matvec(x)
+
+    def _matmat(self, x):
+        return self.A._rmatmat(x)
+
+    def _rmatmat(self, x):
+        return self.A._matmat(x)
+
+class _TransposedLinearOperator(LinearOperator):
+    """Transposition of arbitrary Linear Operator"""
+
+    def __init__(self, A):
+        shape = (A.shape[1], A.shape[0])
+        super().__init__(dtype=A.dtype, shape=shape)
+        self.A = A
+        self.args = (A,)
+
+    def _matvec(self, x):
+        # NB. np.conj works also on sparse matrices
+        return np.conj(self.A._rmatvec(np.conj(x)))
+
+    def _rmatvec(self, x):
+        return np.conj(self.A._matvec(np.conj(x)))
+
+    def _matmat(self, x):
+        # NB. np.conj works also on sparse matrices
+        return np.conj(self.A._rmatmat(np.conj(x)))
+
+    def _rmatmat(self, x):
+        return np.conj(self.A._matmat(np.conj(x)))
+
+def _get_dtype(operators, dtypes=None):
+    if dtypes is None:
+        dtypes = []
+    for obj in operators:
+        if obj is not None and hasattr(obj, 'dtype'):
+            dtypes.append(obj.dtype)
+    return np.result_type(*dtypes)
+
+
+class _SumLinearOperator(LinearOperator):
+    def __init__(self, A, B):
+        if not isinstance(A, LinearOperator) or \
+                not isinstance(B, LinearOperator):
+            raise ValueError('both operands have to be a LinearOperator')
+        if A.shape != B.shape:
+            raise ValueError(f'cannot add {A} and {B}: shape mismatch')
+        self.args = (A, B)
+        super().__init__(_get_dtype([A, B]), A.shape)
+
+    def _matvec(self, x):
+        return self.args[0].matvec(x) + self.args[1].matvec(x)
+
+    def _rmatvec(self, x):
+        return self.args[0].rmatvec(x) + self.args[1].rmatvec(x)
+
+    def _rmatmat(self, x):
+        return self.args[0].rmatmat(x) + self.args[1].rmatmat(x)
+
+    def _matmat(self, x):
+        return self.args[0].matmat(x) + self.args[1].matmat(x)
+
+    def _adjoint(self):
+        A, B = self.args
+        return A.H + B.H
+
+
+class _ProductLinearOperator(LinearOperator):
+    def __init__(self, A, B):
+        if not isinstance(A, LinearOperator) or \
+                not isinstance(B, LinearOperator):
+            raise ValueError('both operands have to be a LinearOperator')
+        if A.shape[1] != B.shape[0]:
+            raise ValueError(f'cannot multiply {A} and {B}: shape mismatch')
+        super().__init__(_get_dtype([A, B]),
+                                                     (A.shape[0], B.shape[1]))
+        self.args = (A, B)
+
+    def _matvec(self, x):
+        return self.args[0].matvec(self.args[1].matvec(x))
+
+    def _rmatvec(self, x):
+        return self.args[1].rmatvec(self.args[0].rmatvec(x))
+
+    def _rmatmat(self, x):
+        return self.args[1].rmatmat(self.args[0].rmatmat(x))
+
+    def _matmat(self, x):
+        return self.args[0].matmat(self.args[1].matmat(x))
+
+    def _adjoint(self):
+        A, B = self.args
+        return B.H @ A.H
+
+
+class _ScaledLinearOperator(LinearOperator):
+    def __init__(self, A, alpha):
+        if not isinstance(A, LinearOperator):
+            raise ValueError('LinearOperator expected as A')
+        if not np.isscalar(alpha):
+            raise ValueError('scalar expected as alpha')
+        if isinstance(A, _ScaledLinearOperator):
+            A, alpha_original = A.args
+            # Avoid in-place multiplication so that we don't accidentally mutate
+            # the original prefactor.
+            alpha = alpha * alpha_original
+
+        dtype = _get_dtype([A], [type(alpha)])
+        super().__init__(dtype, A.shape)
+        self.args = (A, alpha)
+        # Note: args[1] is alpha (a scalar), so use `*` below, not `@`
+
+    def _matvec(self, x):
+        return self.args[1] * self.args[0].matvec(x)
+
+    def _rmatvec(self, x):
+        return np.conj(self.args[1]) * self.args[0].rmatvec(x)
+
+    def _rmatmat(self, x):
+        return np.conj(self.args[1]) * self.args[0].rmatmat(x)
+
+    def _matmat(self, x):
+        return self.args[1] * self.args[0].matmat(x)
+
+    def _adjoint(self):
+        A, alpha = self.args
+        return A.H * np.conj(alpha)
+
+
+class _PowerLinearOperator(LinearOperator):
+    def __init__(self, A, p):
+        if not isinstance(A, LinearOperator):
+            raise ValueError('LinearOperator expected as A')
+        if A.shape[0] != A.shape[1]:
+            raise ValueError(f'square LinearOperator expected, got {A!r}')
+        if not isintlike(p) or p < 0:
+            raise ValueError('non-negative integer expected as p')
+
+        super().__init__(_get_dtype([A]), A.shape)
+        self.args = (A, p)
+
+    def _power(self, fun, x):
+        res = np.array(x, copy=True)
+        for i in range(self.args[1]):
+            res = fun(res)
+        return res
+
+    def _matvec(self, x):
+        return self._power(self.args[0].matvec, x)
+
+    def _rmatvec(self, x):
+        return self._power(self.args[0].rmatvec, x)
+
+    def _rmatmat(self, x):
+        return self._power(self.args[0].rmatmat, x)
+
+    def _matmat(self, x):
+        return self._power(self.args[0].matmat, x)
+
+    def _adjoint(self):
+        A, p = self.args
+        return A.H ** p
+
+
+class MatrixLinearOperator(LinearOperator):
+    def __init__(self, A):
+        super().__init__(A.dtype, A.shape)
+        self.A = A
+        self.__adj = None
+        self.args = (A,)
+
+    def _matmat(self, X):
+        return self.A.dot(X)
+
+    def _adjoint(self):
+        if self.__adj is None:
+            self.__adj = _AdjointMatrixOperator(self.A)
+        return self.__adj
+
+
+class _AdjointMatrixOperator(MatrixLinearOperator):
+    def __init__(self, adjoint_array):
+        self.A = adjoint_array.T.conj()
+        self.args = (adjoint_array,)
+        self.shape = adjoint_array.shape[1], adjoint_array.shape[0]
+
+    @property
+    def dtype(self):
+        return self.args[0].dtype
+
+    def _adjoint(self):
+        return MatrixLinearOperator(self.args[0])
+
+
+class IdentityOperator(LinearOperator):
+    def __init__(self, shape, dtype=None):
+        super().__init__(dtype, shape)
+
+    def _matvec(self, x):
+        return x
+
+    def _rmatvec(self, x):
+        return x
+
+    def _rmatmat(self, x):
+        return x
+
+    def _matmat(self, x):
+        return x
+
+    def _adjoint(self):
+        return self
+
+
+def aslinearoperator(A):
+    """Return A as a LinearOperator.
+
+    'A' may be any of the following types:
+     - ndarray
+     - matrix
+     - sparse array (e.g. csr_array, lil_array, etc.)
+     - LinearOperator
+     - An object with .shape and .matvec attributes
+
+    See the LinearOperator documentation for additional information.
+
+    Notes
+    -----
+    If 'A' has no .dtype attribute, the data type is determined by calling
+    :func:`LinearOperator.matvec()` - set the .dtype attribute to prevent this
+    call upon the linear operator creation.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.sparse.linalg import aslinearoperator
+    >>> M = np.array([[1,2,3],[4,5,6]], dtype=np.int32)
+    >>> aslinearoperator(M)
+    <2x3 MatrixLinearOperator with dtype=int32>
+    """
+    if isinstance(A, LinearOperator):
+        return A
+
+    elif isinstance(A, np.ndarray) or isinstance(A, np.matrix):
+        if A.ndim > 2:
+            raise ValueError('array must have ndim <= 2')
+        A = np.atleast_2d(np.asarray(A))
+        return MatrixLinearOperator(A)
+
+    elif issparse(A) or is_pydata_spmatrix(A):
+        return MatrixLinearOperator(A)
+
+    else:
+        if hasattr(A, 'shape') and hasattr(A, 'matvec'):
+            rmatvec = None
+            rmatmat = None
+            dtype = None
+
+            if hasattr(A, 'rmatvec'):
+                rmatvec = A.rmatvec
+            if hasattr(A, 'rmatmat'):
+                rmatmat = A.rmatmat
+            if hasattr(A, 'dtype'):
+                dtype = A.dtype
+            return LinearOperator(A.shape, A.matvec, rmatvec=rmatvec,
+                                  rmatmat=rmatmat, dtype=dtype)
+
+        else:
+            raise TypeError('type not understood')

shared/package-files/8b/8b9f6fe4750edf6e8b848fb49cfa169d2cafe88b2e0ddff1469e0d744bbc1946/blob

@@ -0,0 +1,341 @@
+import itertools
+import math
+import sys
+
+from numba import jit, types
+from numba.tests.support import TestCase, skip_unless_py314_or_later
+from .complex_usecases import *
+import unittest
+
+enable_pyobj_flags = {'forceobj': True}
+no_pyobj_flags = {'nopython': True}
+
+
+class BaseComplexTest(object):
+
+    def basic_values(self):
+        reals = [-0.0, +0.0, 1, -1, +1.5, -3.5,
+                 float('-inf'), float('+inf')]
+        if sys.platform != 'win32':
+            reals += [float('nan')]
+        return [complex(x, y) for x, y in itertools.product(reals, reals)]
+
+    def more_values(self):
+        reals = [-0.0, +0.0, 1, -1, -math.pi, +math.pi,
+                 float('-inf'), float('+inf')]
+        if sys.platform != 'win32':
+            reals += [float('nan')]
+        return [complex(x, y) for x, y in itertools.product(reals, reals)]
+
+    def non_nan_values(self):
+        reals = [-0.0, +0.0, 1, -1, -math.pi, +math.pi,
+                 float('inf'), float('-inf')]
+        return [complex(x, y) for x, y in itertools.product(reals, reals)]
+
+    def run_unary(self, pyfunc, x_types, x_values, ulps=1, abs_tol=None,
+                  flags=enable_pyobj_flags):
+        for tx in x_types:
+            cfunc = jit((tx,), **flags)(pyfunc)
+            prec = 'single' if tx in (types.float32, types.complex64) else 'double'
+            for vx in x_values:
+                try:
+                    expected = pyfunc(vx)
+                except ValueError as e:
+                    self.assertIn("math domain error", str(e))
+                    continue
+                got = cfunc(vx)
+                msg = 'for input %r with prec %r' % (vx, prec)
+                self.assertPreciseEqual(got, expected, prec=prec,
+                                        ulps=ulps, abs_tol=abs_tol, msg=msg)
+
+    def run_binary(self, pyfunc, value_types, values, ulps=1,
+                   flags=enable_pyobj_flags):
+        for tx, ty in value_types:
+            cfunc = jit((tx, ty), **flags)(pyfunc)
+            prec = ('single'
+                    if set([tx, ty]) & set([types.float32, types.complex64])
+                    else 'double')
+            for vx, vy in values:
+                try:
+                    expected = pyfunc(vx, vy)
+                except ValueError as e:
+                    self.assertIn("math domain error", str(e))
+                    continue
+                except ZeroDivisionError:
+                    continue
+                got = cfunc(vx, vy)
+                msg = 'for input %r with prec %r' % ((vx, vy), prec)
+                self.assertPreciseEqual(got, expected, prec=prec,
+                                        ulps=ulps, msg=msg)
+
+
+class TestComplex(BaseComplexTest, TestCase):
+
+    def test_real(self, flags=enable_pyobj_flags):
+        self.run_unary(real_usecase, [types.complex64, types.complex128],
+                       self.basic_values(), flags=flags)
+        self.run_unary(real_usecase, [types.int8, types.int64],
+                       [1, 0, -3], flags=flags)
+        self.run_unary(real_usecase, [types.float32, types.float64],
+                       [1.5, -0.5], flags=flags)
+
+    def test_real_npm(self):
+        self.test_real(flags=no_pyobj_flags)
+
+    def test_imag(self, flags=enable_pyobj_flags):
+        self.run_unary(imag_usecase, [types.complex64, types.complex128],
+                       self.basic_values(), flags=flags)
+        self.run_unary(imag_usecase, [types.int8, types.int64],
+                       [1, 0, -3], flags=flags)
+        self.run_unary(imag_usecase, [types.float32, types.float64],
+                       [1.5, -0.5], flags=flags)
+
+    def test_imag_npm(self):
+        self.test_imag(flags=no_pyobj_flags)
+
+    def test_conjugate(self, flags=enable_pyobj_flags):
+        self.run_unary(conjugate_usecase, [types.complex64, types.complex128],
+                       self.basic_values(), flags=flags)
+        self.run_unary(conjugate_usecase, [types.int8, types.int64],
+                       [1, 0, -3], flags=flags)
+        self.run_unary(conjugate_usecase, [types.float32, types.float64],
+                       [1.5, -0.5], flags=flags)
+
+    def test_conjugate_npm(self):
+        self.test_conjugate(flags=no_pyobj_flags)
+
+    def test_div(self, flags=enable_pyobj_flags):
+        """
+        Test complex.__div__ implementation with non-trivial values.
+        """
+        # XXX Fold into test_operator?
+        values = list(itertools.product(self.more_values(), self.more_values()))
+        value_types = [(types.complex128, types.complex128),
+                       (types.complex64, types.complex64)]
+        self.run_binary(div_usecase, value_types, values, flags=flags)
+
+    def test_div_npm(self):
+        self.test_div(flags=no_pyobj_flags)
+
+
+@skip_unless_py314_or_later
+class TestComplexNaNRecovery(BaseComplexTest, TestCase):
+    """
+    Verify CPython NaN-recovery for complex mul / div.
+    """
+
+    def special_values(self):
+        # 1e200 (large finite) is here so mul can overflow before recovering
+        reals = [-0.0, +0.0, 1, -1, 1e200,
+                 float('-inf'), float('+inf'), float('nan')]
+        return [complex(x, y) for x, y in itertools.product(reals, reals)]
+
+    def test_mul(self, flags=no_pyobj_flags):
+        values = list(itertools.product(self.special_values(),
+                                        self.special_values()))
+        value_types = [(types.complex128, types.complex128)]
+        self.run_binary(mul_usecase, value_types, values, flags=flags)
+
+    def test_div(self, flags=no_pyobj_flags):
+        values = list(itertools.product(self.special_values(),
+                                        self.special_values()))
+        value_types = [(types.complex128, types.complex128)]
+        self.run_binary(div_usecase, value_types, values, flags=flags)
+
+    def test_div_zero(self, flags=no_pyobj_flags):
+        cfunc = jit((types.complex128, types.complex128), **flags)(div_usecase)
+        for denom in [0j, complex(0.0, 0.0), complex(-0.0, -0.0),
+                      complex(0.0, -0.0), complex(-0.0, 0.0)]:
+            with self.assertRaises(ZeroDivisionError):
+                cfunc(1+1j, denom)
+
+
+class TestCMath(BaseComplexTest, TestCase):
+    """
+    Tests for cmath module support.
+    """
+
+    def check_predicate_func(self, pyfunc, flags):
+        self.run_unary(pyfunc, [types.complex128, types.complex64],
+                       self.basic_values(), flags=flags)
+
+    def check_unary_func(self, pyfunc, flags, ulps=1, abs_tol=None,
+                         values=None):
+        self.run_unary(pyfunc, [types.complex128],
+                       values or self.more_values(), flags=flags, ulps=ulps,
+                       abs_tol=abs_tol)
+        # Avoid discontinuities around pi when in single precision.
+        self.run_unary(pyfunc, [types.complex64],
+                       values or self.basic_values(), flags=flags, ulps=ulps,
+                       abs_tol=abs_tol)
+
+    # Conversions
+
+    def test_phase(self):
+        self.check_unary_func(phase_usecase, enable_pyobj_flags)
+
+    def test_phase_npm(self):
+        self.check_unary_func(phase_usecase, no_pyobj_flags)
+
+    def test_polar(self):
+        self.check_unary_func(polar_usecase, enable_pyobj_flags)
+
+    def test_polar_npm(self):
+        self.check_unary_func(polar_usecase, no_pyobj_flags)
+
+    def test_rect(self, flags=enable_pyobj_flags):
+        def do_test(tp, seed_values):
+            values = [(z.real, z.imag) for z in seed_values
+                      if not math.isinf(z.imag) or z.real == 0]
+            self.run_binary(rect_usecase, [(tp, tp)], values, flags=flags)
+        do_test(types.float64, self.more_values())
+        # Avoid discontinuities around pi when in single precision.
+        do_test(types.float32, self.basic_values())
+
+    def test_rect_npm(self):
+        self.test_rect(flags=no_pyobj_flags)
+
+    # Classification
+
+    def test_isnan(self, flags=enable_pyobj_flags):
+        self.check_predicate_func(isnan_usecase, enable_pyobj_flags)
+
+    def test_isnan_npm(self):
+        self.check_predicate_func(isnan_usecase, no_pyobj_flags)
+
+    def test_isinf(self, flags=enable_pyobj_flags):
+        self.check_predicate_func(isinf_usecase, enable_pyobj_flags)
+
+    def test_isinf_npm(self):
+        self.check_predicate_func(isinf_usecase, no_pyobj_flags)
+
+    def test_isfinite(self, flags=enable_pyobj_flags):
+        self.check_predicate_func(isfinite_usecase, enable_pyobj_flags)
+
+    def test_isfinite_npm(self):
+        self.check_predicate_func(isfinite_usecase, no_pyobj_flags)
+
+    # Power and logarithms
+
+    def test_exp(self):
+        self.check_unary_func(exp_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_exp_npm(self):
+        # Aggressive optimization fixes the following subnormal float problem.
+        ## The two tests are failing due to subnormal float problems.
+        ## We are seeing (6.9532198665326e-310+2.1221202807e-314j) != 0j
+        self.check_unary_func(exp_usecase, no_pyobj_flags, ulps=2)
+
+    def test_log(self):
+        self.check_unary_func(log_usecase, enable_pyobj_flags)
+
+    def test_log_npm(self):
+        self.check_unary_func(log_usecase, no_pyobj_flags)
+
+    def test_log_base(self, flags=enable_pyobj_flags):
+        values = list(itertools.product(self.more_values(), self.more_values()))
+        value_types = [(types.complex128, types.complex128),
+                       (types.complex64, types.complex64)]
+        self.run_binary(log_base_usecase, value_types, values, flags=flags,
+                        ulps=3)
+
+    def test_log_base_npm(self):
+        self.test_log_base(flags=no_pyobj_flags)
+
+    def test_log10(self):
+        self.check_unary_func(log10_usecase, enable_pyobj_flags)
+
+    def test_log10_npm(self):
+        self.check_unary_func(log10_usecase, no_pyobj_flags)
+
+    def test_sqrt(self):
+        self.check_unary_func(sqrt_usecase, enable_pyobj_flags)
+
+    def test_sqrt_npm(self):
+        self.check_unary_func(sqrt_usecase, no_pyobj_flags)
+        # issue #3499, check large complex128 values, values cross the float32
+        # representation limit threshold
+        values = [-10 ** i for i in range(36, 41)]
+        self.run_unary(sqrt_usecase, [types.complex128],
+                       values, flags=no_pyobj_flags)
+
+    # Trigonometric functions
+
+    def test_acos(self):
+        self.check_unary_func(acos_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_acos_npm(self):
+        self.check_unary_func(acos_usecase, no_pyobj_flags, ulps=2)
+
+    def test_asin(self):
+        self.check_unary_func(asin_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_asin_npm(self):
+        self.check_unary_func(asin_usecase, no_pyobj_flags, ulps=2)
+
+    def test_atan(self):
+        self.check_unary_func(atan_usecase, enable_pyobj_flags, ulps=2,)
+
+    def test_atan_npm(self):
+        self.check_unary_func(atan_usecase, no_pyobj_flags, ulps=2,)
+
+    def test_cos(self):
+        self.check_unary_func(cos_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_cos_npm(self):
+        self.check_unary_func(cos_usecase, no_pyobj_flags, ulps=2)
+
+    def test_sin(self):
+        # See test_sinh.
+        self.check_unary_func(sin_usecase, enable_pyobj_flags, abs_tol='eps')
+
+    def test_sin_npm(self):
+        self.check_unary_func(sin_usecase, no_pyobj_flags, abs_tol='eps')
+
+    def test_tan(self):
+        self.check_unary_func(tan_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_tan_npm(self):
+        self.check_unary_func(tan_usecase, enable_pyobj_flags, ulps=2)
+
+    # Hyperbolic functions
+
+    def test_acosh(self):
+        self.check_unary_func(acosh_usecase, enable_pyobj_flags)
+
+    def test_acosh_npm(self):
+        self.check_unary_func(acosh_usecase, no_pyobj_flags)
+
+    def test_asinh(self):
+        self.check_unary_func(asinh_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_asinh_npm(self):
+        self.check_unary_func(asinh_usecase, no_pyobj_flags, ulps=2)
+
+    def test_atanh(self):
+        self.check_unary_func(atanh_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_atanh_npm(self):
+        self.check_unary_func(atanh_usecase, no_pyobj_flags, ulps=2)
+
+    def test_cosh(self):
+        self.check_unary_func(cosh_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_cosh_npm(self):
+        self.check_unary_func(cosh_usecase, no_pyobj_flags, ulps=2)
+
+    def test_sinh(self):
+        self.check_unary_func(sinh_usecase, enable_pyobj_flags, abs_tol='eps')
+
+    def test_sinh_npm(self):
+        self.check_unary_func(sinh_usecase, no_pyobj_flags, abs_tol='eps')
+
+    def test_tanh(self):
+        self.check_unary_func(tanh_usecase, enable_pyobj_flags, ulps=2)
+
+    def test_tanh_npm(self):
+        self.check_unary_func(tanh_usecase, enable_pyobj_flags, ulps=2)
+
+
+if __name__ == '__main__':
+    unittest.main()

shared/package-files/8b/8b9fc65039f9df190eb3bfc0d68cdc0eed6070fa2b21afe4c48288f1988068d0/blob

@@ -0,0 +1,44 @@
+import torch
+import torch.nn.functional as F
+from .expanded_weights_impl import implements_per_sample_grads
+from .expanded_weights_utils import \
+    forward_helper, set_grad_sample_if_exists, unpack_expanded_weight_or_tensor, is_batch_first
+from typing import List, Optional
+
+@implements_per_sample_grads(F.linear)
+class LinearPerSampleGrad(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, _, __, *expanded_args_and_kwargs):
+        if len(expanded_args_and_kwargs[0].shape) <= 1:
+            raise RuntimeError("Input does not have a batch dimension. Expanded Weights expected input "
+                               f"of at least rank 2, got of rank {len(expanded_args_and_kwargs[0].shape)}")
+        expanded_kwargs = {'bias': expanded_args_and_kwargs[2] if len(expanded_args_and_kwargs) == 3 else None}
+        expanded_args = expanded_args_and_kwargs[:2]
+        ctx.batch_first = is_batch_first(expanded_args_and_kwargs)
+        output = forward_helper(F.linear, expanded_args, expanded_kwargs)
+        ctx.args = expanded_args
+        ctx.kwargs = expanded_kwargs
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        input, weight = ctx.args
+        bias = ctx.kwargs['bias']
+        results: List[Optional[torch.Tensor]] = []
+        results.append(None)  # for kwarg_names
+        results.append(None)  # for op reference
+
+        if input.requires_grad:
+            results.append(grad_output.matmul(unpack_expanded_weight_or_tensor(weight)))
+        else:
+            results.append(None)
+        results.extend([None] * 2)  # weight and bias don't compute batched gradients
+
+        if not ctx.batch_first:
+            grad_output = grad_output.transpose(0, 1)
+            input = input.transpose(0, 1)
+
+        # weight and bias get their grad_sample fields set directly if they exist
+        set_grad_sample_if_exists(weight, lambda _: torch.einsum("n...i,n...j->nij", grad_output, input))
+        set_grad_sample_if_exists(bias, lambda _: torch.einsum("n...k->nk", grad_output))
+        return tuple(results)

shared/package-files/8b/8b9fd73515667141ecfc6067f2b27f4a4afb3340139b737521f811d33c8a523b/blob

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import functools
+from typing import Any
+
+import narwhals.stable.v1 as narwhals
+import numpy
+import pandas
+
+
+@functools.singledispatch
+def lag(data: Any, k: int = 1) -> Any:
+    """
+    Shift the data indices forward or backward by the specified number of
+    intervals.
+
+    Args:
+        data: The array-like dataset to be lagged along its first axis.
+        k: The number of intervals to shift back the observations by. For "lead"
+            shifts, use negative integers.
+
+    Notes:
+      * For this transform to make sense, `data` must represent a time-series
+        collected at regularly spaced intervals.
+      * `k` is chosen as the offset parameter for compatibility with R.
+    """
+    raise NotImplementedError(
+        f"No implementation of `lag` for data of type {type(data)}."
+    )
+
+
+@lag.register
+def _(data: pandas.Series, offset: int = 1) -> pandas.Series:
+    return data.shift(offset)
+
+
+@lag.register
+def _(data: numpy.ndarray, offset: int = 1) -> numpy.ndarray:
+    if data.shape == () or offset == 0:
+        return data
+
+    data = numpy.copy(data).astype(float)
+
+    if offset > 0:
+        data[offset:] = data[:-offset]
+        data[:offset] = numpy.nan
+    else:
+        data[:offset] = data[-offset:]
+        data[offset:] = numpy.nan
+
+    return data
+
+
+@lag.register
+def _(data: narwhals.Series, offset: int = 1) -> narwhals.Series:
+    return data.shift(offset)

shared/package-files/8b/8ba054d3b7ea9a8fd954531d3abe5cbaf18bfa0e635d39c7082e31ab2a021ba0/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 bool _use_cudnn_rnn_flatten_weight();
+
+} // namespace compositeimplicitautograd
+} // namespace at

shared/package-files/8b/8ba3d5ba862412d7d509da7ad8828cfba503ea44e5e04c88b39e86fa3ddd455e/blob

@@ -0,0 +1,566 @@
+import argparse
+import copy
+import functools
+import logging
+import os
+import shutil
+import sys
+import textwrap
+from importlib import import_module
+from typing import Union
+
+import torch
+import torch.fx as fx
+
+from torch._dynamo.debug_utils import (
+    AccuracyError,
+    backend_accuracy_fails,
+    BUCK_CMD_PREFIX,
+    BuckTargetWriter,
+    extra_imports,
+    generate_config_string,
+    helper_for_dump_minify,
+    InputReader,
+    InputWriter,
+    minifier_dir,
+    NNModuleToString,
+    NopInputReader,
+    run_fwd_maybe_bwd,
+    same_two_models,
+)
+from torch.fx.experimental.symbolic_shapes import fx_placeholder_targets
+from torch.hub import tqdm
+
+from .. import config
+from ..backends.registry import lookup_backend, register_debug_backend
+from ..debug_utils import clone_inputs_retaining_gradness
+
+log = logging.getLogger(__name__)
+
+
+inductor_config = import_module("torch._inductor.config")
+use_buck = inductor_config.is_fbcode()
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+#                           MAIN ENTRY POINT
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+
+
+def wrap_backend_debug(unconfigured_compiler_fn, compiler_name: str):
+    """
+    A minifier decorator that wraps the TorchDynamo produced Fx graph modules.
+    As opposed to wrap_compiler_debug, this wrapper intercepts at the
+    TorchDynamo produced Fx Graph Module. This makes it backend-agnostic to some
+    level, e.g., it is useful for minifying issues related to Aot Autograd
+    tracing.  If an error is found, we minify and save the minified repro in
+    repro.tar.gz.
+    """
+
+    @functools.wraps(unconfigured_compiler_fn)
+    def debug_wrapper(gm, example_inputs, **kwargs):
+        compiler_fn = functools.partial(unconfigured_compiler_fn, **kwargs)
+        assert config.repro_after in ("dynamo", "aot", None)
+
+        if config.repro_after == "dynamo":
+
+            def add_paths(exc):
+                exc.minifier_path = os.path.join(minifier_dir(), "minifier_launcher.py")
+                if use_buck:
+                    exc.buck_command = " ".join(
+                        BUCK_CMD_PREFIX
+                        + [BuckTargetWriter(exc.minifier_path).cmd_line_path]
+                    )
+
+            if config.repro_level == 3:
+                dump_to_minify_after_dynamo(gm, example_inputs, compiler_name)
+
+            # Check for either accuracy (level 4) or other type of failures.
+            if config.repro_level == 4:
+                # Check Accuracy
+                compiled_gm = compiler_fn(copy.deepcopy(gm), example_inputs)
+                if backend_accuracy_fails(gm, example_inputs, compiler_fn):
+                    log.warning(
+                        "Accuracy failed for the TorchDynamo produced graph. Creating script to minify the error."
+                    )
+                    dump_to_minify_after_dynamo(
+                        fx.GraphModule(gm, copy.deepcopy(gm.graph)),
+                        example_inputs,
+                        compiler_name,
+                    )
+                    exc = AccuracyError("Bad accuracy detected.")
+                    add_paths(exc)
+                    raise exc
+            else:
+                try:
+                    compiled_gm = compiler_fn(copy.deepcopy(gm), example_inputs)
+                    run_fwd_maybe_bwd(compiled_gm, example_inputs)
+                except Exception as exc:
+                    log.warning(
+                        "Compiled Fx GraphModule failed. Creating script to minify the error."
+                    )
+                    if config.repro_level == 1:
+                        dump_state_fn = functools.partial(
+                            dump_backend_state, compiler_name=compiler_name
+                        )
+                        dump_state_fn(
+                            fx.GraphModule(gm, copy.deepcopy(gm.graph)), example_inputs
+                        )
+                    elif config.repro_level == 2:
+                        dump_to_minify_after_dynamo(
+                            fx.GraphModule(gm, copy.deepcopy(gm.graph)),
+                            example_inputs,
+                            compiler_name,
+                        )
+                    add_paths(exc)
+                    raise
+        else:
+            compiled_gm = compiler_fn(gm, example_inputs)
+
+        return compiled_gm
+
+    debug_wrapper._torchdynamo_orig_callable = unconfigured_compiler_fn  # type: ignore[attr-defined]
+    if hasattr(unconfigured_compiler_fn, "compiler_name"):
+        debug_wrapper.__name__ = unconfigured_compiler_fn.compiler_name
+    if hasattr(unconfigured_compiler_fn, "get_compiler_config"):
+        debug_wrapper.get_compiler_config = unconfigured_compiler_fn.get_compiler_config  # type: ignore[attr-defined]
+    return debug_wrapper
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+#                           REPRO DUMPERS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+
+
+def generate_dynamo_fx_repro_string(
+    gm,
+    args,
+    compiler_name,
+    check_accuracy=False,
+    *,
+    stable_output=False,
+    save_dir=None,
+    command="run",
+):
+    """
+    Generate a repro string for backend-agnostic minified version.
+    """
+
+    model_str = NNModuleToString.convert(gm)
+
+    # TODO: Figure out why torch.compile'd hash isn't work on this codepath
+    writer = InputWriter(save_dir, stable_hash=True)
+    for placeholder, arg in zip(fx_placeholder_targets(gm), args):
+        if isinstance(arg, (int, torch.SymInt)):
+            writer.symint(placeholder, arg)
+        elif isinstance(arg, torch.Tensor):
+            # TODO: improve these names with FQN
+            writer.tensor(placeholder, arg)
+        else:
+            raise TypeError(f"arg is neither SymInt/int nor torch.Tensor, {arg}")
+    load_args = "\n".join(writer.lines())
+
+    return textwrap.dedent(
+        f"""
+from math import inf
+import torch
+from torch import tensor, device
+import torch.fx as fx
+import torch._dynamo
+from torch._dynamo.testing import rand_strided
+from torch._dynamo.debug_utils import run_fwd_maybe_bwd
+
+{generate_config_string(stable_output=stable_output)}
+
+{extra_imports}
+
+{model_str}
+mod = Repro()
+
+{load_args}
+
+if __name__ == '__main__':
+    from torch._dynamo.repro.after_dynamo import run_repro
+    run_repro(mod, load_args, accuracy={check_accuracy!r}, command={command!r},
+        save_dir={save_dir!r}, autocast={torch.is_autocast_enabled()!r}, backend={compiler_name!r})
+"""
+    )
+
+
+def dump_backend_repro_as_file(gm, args, compiler_name, check_accuracy=False):
+    """
+    Saves the repro to a repro.py file
+    """
+    curdir = os.getcwd()
+    subdir = os.path.join(os.getcwd(), "checkpoints")
+    if not os.path.exists(subdir):
+        os.makedirs(subdir, exist_ok=True)
+    file_name = os.path.join(subdir, f"minified_{len(gm.graph.nodes)}_nodes.py")
+    log.warning(
+        "Writing checkpoint with %s nodes to %s", len(gm.graph.nodes), file_name
+    )
+
+    with open(file_name, "w") as fd:
+        fd.write(
+            generate_dynamo_fx_repro_string(
+                gm, args, compiler_name, check_accuracy, save_dir=subdir
+            )
+        )
+    latest_repro = os.path.join(curdir, "repro.py")
+    log.warning("Copying %s to %s for convenience", file_name, latest_repro)
+
+    if use_buck:
+        BuckTargetWriter(latest_repro).write()
+
+    shutil.copyfile(file_name, latest_repro)
+
+
+def dump_backend_state(gm, args, compiler_name, check_accuracy=False):
+    """
+    Dumps the dynamo graph to repro the issue.
+    1) It tries to convert Fx GraphModule to a string. If we can, it writes to a
+    repro.py file.
+    2) If we can't convert Fx GraphModule to a string, we use to_folder to save
+    the module and save a tar file.
+    """
+    assert NNModuleToString.can_convert_to_string(gm)
+    return dump_backend_repro_as_file(gm, args, compiler_name, check_accuracy)
+    # return dump_backend_repro_as_tarfile(gm, args, compiler_name)
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+#                       MINIFIER DUMPER
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+
+
+def dump_to_minify_after_dynamo(gm, args, compiler_name):
+    # TODO: factor this out
+    subdir = os.path.join(minifier_dir(), "checkpoints")
+    if not os.path.exists(subdir):
+        os.makedirs(subdir, exist_ok=True)
+    helper_for_dump_minify(
+        generate_dynamo_fx_repro_string(
+            gm,
+            args,
+            compiler_name,
+            check_accuracy=config.repro_level == 4,
+            save_dir=subdir,
+            command="minify",
+        )
+    )
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+#                       MINIFIER BACKENDS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+
+
+@register_debug_backend
+def dynamo_minifier_backend(gm, example_inputs, compiler_name):
+    from functorch.compile import minifier
+
+    compiler_fn = lookup_backend(compiler_name)
+
+    # TODO: It's inconsistent to pass SymInt inputs but REAL tensors.
+    # We should pass ints and look at the GraphModule placeholders
+    # to resolve them to SymInt (if necessary)
+    example_inputs = [
+        i.node.hint if isinstance(i, torch.SymInt) else i for i in example_inputs
+    ]
+
+    try:
+        compiled_gm = compiler_fn(gm, example_inputs)
+        run_fwd_maybe_bwd(compiled_gm, example_inputs)
+        raise ValueError("No issue was detected")
+    except Exception as exc:
+        orig_failure = str(exc)
+        log.warning(
+            "Compiled Fx GraphModule failed. Creating script to minify the error."
+        )
+        dump_state_fn = functools.partial(
+            dump_backend_state, compiler_name=compiler_name
+        )
+        dump_state_fn(fx.GraphModule(gm, copy.deepcopy(gm.graph)), example_inputs)
+        fails_fn = functools.partial(
+            backend_fails,
+            compiler_fn=compiler_fn,
+            orig_failure=orig_failure,
+        )
+        minifier(
+            gm,
+            example_inputs,
+            module_fails=fails_fn,
+            dump_state=dump_state_fn,
+        )
+    return gm
+
+
+@register_debug_backend
+def dynamo_accuracy_minifier_backend(gm, example_inputs, compiler_name):
+    from functorch.compile import minifier
+
+    compiler_fn = lookup_backend(compiler_name)
+
+    # Set the eval mode to remove randomness.
+    gm.eval()
+
+    # Check Accuracy
+    if backend_accuracy_fails(
+        gm, example_inputs, compiler_fn, only_fwd=config.repro_forward_only
+    ):
+        log.warning("Accuracy failed for the TorchDynamo produced graph")
+        dump_state_fn = functools.partial(
+            dump_backend_state, compiler_name=compiler_name, check_accuracy=True
+        )
+        fails_fn = functools.partial(
+            backend_accuracy_fails,
+            compiler_fn=compiler_fn,
+            only_fwd=config.repro_forward_only,
+        )
+        dump_state_fn(fx.GraphModule(gm, copy.deepcopy(gm.graph)), example_inputs)
+        minifier(
+            gm,
+            example_inputs,
+            module_fails=fails_fn,
+            dump_state=dump_state_fn,
+        )
+    else:
+        log.error("Input graph does not fail accuracy testing")
+    return gm
+
+
+def backend_fails(gm, example_inputs, compiler_fn, orig_failure):
+    """
+    Minifier uses this function to identify if the minified graph module fails
+    with the same error.
+
+    One caveat is that minifier can potentially go into a wrong direction when
+    the resulting graph module fails for a different reason. To avoid this, we
+    save the string for the original exception and check similarity between new
+    and old exception. They can be somewhat different in some cases, when the
+    exception string depends on the failing node information. So, we have a
+    loose similarity metric to guide the minifier path.
+    """
+    from difflib import SequenceMatcher
+
+    try:
+        # Run the original gm to check eager validity
+        run_fwd_maybe_bwd(gm, clone_inputs_retaining_gradness(example_inputs))
+        compiled_gm = compiler_fn(gm, example_inputs)
+        run_fwd_maybe_bwd(compiled_gm, clone_inputs_retaining_gradness(example_inputs))
+        return False
+    except Exception as e:
+        new_failure = str(e)
+        if SequenceMatcher(None, orig_failure, new_failure).ratio() > 0.5:
+            return True
+        return False
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+#                           REPRO MAIN
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+
+
+def run_load_args(options, mod, load_args):
+    if not hasattr(load_args, "_version"):
+        log.warning(
+            "load_args does not have a _version attribute, please file a bug to PyTorch "
+            "and describe how you generate this repro script"
+        )
+    else:
+        if load_args._version > 0:
+            log.warning(
+                "load_args is version %s, but this version of PyTorch only supports "
+                "version 0.  We will try to run it anyway but there may be an incompatibility; "
+                "if so, try upgrading your version of PyTorch.",
+                load_args._version,
+            )
+
+    nop_reader = NopInputReader()
+    load_args(nop_reader)
+
+    with tqdm(desc="Loading inputs", total=nop_reader.total) as pbar:
+        input_reader = InputReader(save_dir=options.save_dir, pbar=pbar)
+        load_args(input_reader)
+        args = input_reader.args
+
+    return args
+
+
+def repro_minify(options, mod, load_args):
+    args = run_load_args(options, mod, load_args)
+
+    # Setup debug minifier compiler
+    if not options.accuracy:
+        compiler_fn = lookup_backend("dynamo_minifier_backend")
+    else:
+        compiler_fn = lookup_backend("dynamo_accuracy_minifier_backend")
+
+    if options.backend is None:
+        raise RuntimeError(
+            "Compiler name is None - this likely means that a custom compiler "
+            "was called by torchdynamo. Please remove this error, import your "
+            "custom compiler function, and replace the backend=None "
+            "line in run_repro to backend=<my_imported_custom_function>"
+        )
+
+    dynamo_minifier_backend = functools.partial(
+        compiler_fn,
+        compiler_name=options.backend,
+    )
+    opt_mod = torch._dynamo.optimize(dynamo_minifier_backend)(mod)
+
+    with torch.cuda.amp.autocast(enabled=options.autocast):
+        opt_mod(*args)
+
+
+def repro_run(options, mod, load_args):
+    opt_mod = torch._dynamo.optimize(options.backend)(mod)
+
+    if options.accuracy != "":
+        mod.eval()
+        opt_mod.eval()
+
+        with torch.cuda.amp.autocast(enabled=options.autocast):
+            # TODO: disable clone
+            args = run_load_args(options, mod, load_args)
+            assert same_two_models(mod, mod, args), "Eager itself failed"
+            if not same_two_models(mod, opt_mod, args):
+                raise AccuracyError("Dynamo failed")
+    else:
+        with torch.cuda.amp.autocast(enabled=options.autocast):
+            args = run_load_args(options, mod, load_args)
+            ref = run_fwd_maybe_bwd(
+                mod, args, only_fwd=options.only_fwd, disable_clone=True
+            )
+            del args
+
+            args = run_load_args(options, mod, load_args)
+            res = run_fwd_maybe_bwd(
+                opt_mod, args, only_fwd=options.only_fwd, disable_clone=True
+            )
+
+
+def run_repro(
+    mod,
+    load_args,
+    *,
+    command="run",
+    accuracy: Union[bool, str] = "",
+    save_dir=None,
+    autocast=False,
+    backend="inductor",
+    **kwargs,
+):
+    for k in kwargs:
+        log.warning(
+            "Unrecognized kwarg %s; perhaps this repro was made on a newer version of PyTorch",
+            k,
+        )
+
+    if accuracy is True:
+        accuracy = "accuracy"
+    elif accuracy is False:
+        accuracy = ""
+
+    parser = argparse.ArgumentParser(
+        description=f"""\
+An after_dynamo repro script, typically triggering a bug in Dynamo or
+AOTAutograd.  When run with no arguments, this script defaults to running
+'{command}'.  Extra flags may be available; to find out more, try '{command}
+--help'.  There are also alternate subcommands available, see below.
+
+default settings on this script:
+  {accuracy=}
+  {save_dir=}
+""",
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+
+    def common_flags(parser):
+        accuracy_group = parser.add_mutually_exclusive_group()
+        accuracy_group.add_argument(
+            "--no-accuracy",
+            dest="accuracy",
+            action="store_const",
+            const="",
+            default=accuracy,
+            help="do not test accuracy, just run the module and see if it errors",
+        )
+        accuracy_group.add_argument(
+            "--accuracy",
+            action="store_const",
+            const="accuracy",
+            default=accuracy,
+            help="test accuracy",
+        )
+        parser.add_argument(
+            "--save-dir",
+            type=str,
+            default=save_dir,
+            metavar="DIR",
+            help="directory where saved inputs live",
+        )
+        parser.add_argument(
+            "--no-save-dir",
+            dest="save_dir",
+            action="store_const",
+            const=None,
+            help="don't use any directory for saved inputs",
+        )
+        parser.add_argument(
+            "--no-isolate",
+            dest="isolate",
+            action="store_false",
+            default=False,
+            help="no isolate (doesn't do anything for after_dynamo)",
+        )
+        parser.add_argument(
+            "--autocast",
+            default=autocast,
+            action="store_true",
+            help="use torch.cuda.amp.autocast",
+        )
+        parser.add_argument(
+            "--no-autocast",
+            dest="autocast",
+            action="store_false",
+            help="don't use torch.cuda.amp.autocast",
+        )
+        parser.add_argument(
+            "--backend",
+            type=str,
+            default=backend,
+            metavar="BACKEND",
+            help="torch.compile backend to use",
+        )
+
+    subparsers = parser.add_subparsers(
+        dest="command", metavar="{run,minify}", required=True
+    )
+
+    parser_run = subparsers.add_parser(
+        "run",
+        help="just run the repro",
+    )
+    common_flags(parser_run)
+    parser_run.add_argument(
+        "--only-fwd",
+        action="store_true",
+        help="don't run backwards compilation for testing",
+    )
+
+    parser_minify = subparsers.add_parser(
+        "minify", help="run the minifier on the repro"
+    )
+    common_flags(parser_minify)
+
+    args = None
+    if len(sys.argv) <= 1:
+        args = [command, *sys.argv[1:]]
+
+    options = parser.parse_args(args)
+    COMMAND_FNS = {
+        "minify": repro_minify,
+        "run": repro_run,
+    }
+    COMMAND_FNS[options.command](options, mod, load_args)

shared/package-files/8b/8babb286a74d5fb93bad98906f3c4b70386c0e3dfb4f31edf184a012887bec5c/blob

@@ -0,0 +1,606 @@
+from typing import Any, Dict, Set, Tuple, Callable
+from collections import OrderedDict
+import torch
+from torch.ao.quantization.fx._model_report.detector import (
+    DetectorBase,
+    DETECTOR_OBS_ARGS_KEY,
+    DETECTOR_OBS_TO_INSERT_KEY,
+    DETECTOR_IS_POST_OBS_KEY,
+    DETECTOR_TARGET_NODE_KEY,
+    DetectorQConfigInfo
+)
+from torch.ao.quantization.fx._model_report.model_report_visualizer import ModelReportVisualizer
+from torch.ao.quantization.fx.graph_module import GraphModule
+from torch.ao.quantization.observer import ObserverBase
+from torch.ao.quantization.qconfig_mapping import QConfigMapping, QConfig
+from torch.ao.quantization.fx._equalize import EqualizationQConfig
+
+class ModelReport:
+    r"""
+    The ModelReport class aims to provide users an easy way to diagnose issues that they run into
+    with their models. The class works with all traceable GraphModules to help diagnose issues,
+    though the requirements on the type of model more-so depends on the specific report the user
+    is trying to generate. With respect to the reports, the ModelReport class is initialized with
+    a set of Detector classes, each of which generate reports on quantization configuration
+    issues a use might have.
+
+    Currently supports generating reports on:
+    - Suggestions for per-channel vs. per-tensor quantization (nn.Module)
+    - Suggestions for dynamic vs static quantization for linear layers (Graph Modules)
+    - Suggestions for input-weight equalization for linear and conv layers (Graph Modules)
+    - Suggestions for outlier detection for all layers (Graph Modules)
+
+    The ModelReport class has the primary functionality of inserting observers (primarily the ModelReportObserver)
+    where needed for each detector to gather the information it needs, and then after callibration, the ModelReport
+    class compiles the report generated by each Detector class into a single report to return to the user. It also
+    has the capability to remove all the observers it inserted as well.
+
+    * :attr:`_model` The model we wish to generate the report for. Must be a traceable GraphModule
+
+    * :attr:`_desired_report_detectors` The set of Detectors representing desired reports from the ModelReport class
+        Make sure that these are all unique types of detectors [do not have more than 1 of the same class]
+
+    * :attr:`_desired_detector_names` The set of detector names of the _desired_report_detectors.
+        This set is generated by calling the get_detector_name() of each detector
+
+    * :attr:`_detector_name_to_observer_fqns` The mapping from each detector to fqns of observers of interest
+        The purpose of this is to keep track of what observers were inserted for each detector, so that they
+        can be removed at the end if desired
+
+    * :attr:`_prepared_flag` A boolean flag that keeps track of whether we have prepared the model or not
+        This is to ensure we only insert observers once with the ModelReport instance
+
+    * :attr:`_removed_observers` A boolean to track if we have removed observers already
+        The purpose is to ensure we don't attempt to remove observers twice with the same ModelReport
+        instance. This also allows the functionality where we can generate the report multiple times
+        as long as we haven't removed the observers yet.
+
+    Note:
+        This class was initially designed to work with the Fx Graph Mode workflow in mind. However,
+        full functionality is available as long as there is a traceable GraphModule that is being used.
+        One method to get a traceable GraphModule without going through the Fx workflow is to use
+        the QuantizationTracer class.
+
+    General Flow for Fx workflow:
+    1.) Initialize ModelReport object with reports of interest by passing in initialized detector objects and model
+    2.) Prepare your model with prepare_fx
+    3.) Call model_report.prepare_detailed_calibration to add relevant observers
+    4.) Callibrate your model with data
+    5.) Call model_report.generate_report on your model to generate report and optionally remove added observers
+    Optional
+        6.) Call model_report.generate_visualizer to get a ModelReportVisualizer instance
+        7.) To help in parsing report information and debugging, view report info as a:
+            - Table
+            - Histogram
+            - Line plot
+    8.) Call model_report.generate_qconfigs to generate the qconfigs based on the report suggestions
+
+    Example (with QuantizationTracer):
+        >>> # xdoctest: +SKIP
+        >>> # get the necessary qconfig
+        >>> config = PrepareCustomConfig()
+        >>> skipped_module_names, skipped_module_classes = get_skipped_module_name_and_classes(config, False)
+
+        >>> # initialize our model and get GraphModule
+        >>> model = SomeModel()
+        >>> tracer = QuantizationTracer(skipped_module_names, skipped_module_classes)
+        >>> graph_module = GraphModule(model, tracer.trace(model))
+
+        >>> # get our set of detectors and ModelReport instance
+        >>> detector_set = set([DynamicStaticDetector(tolerance=0.5), InputWeightEqualizationDetector(ratio_threshold=0.7)])
+        >>> tracer_reporter = ModelReport(graph_module, tracer_detector_set)
+
+        >>> # now we insert the observers and callibrate the model
+        >>> tracer_model_with_observers = tracer_reporter.prepare_detailed_calibration()
+        >>> for i in range(num_callibration_batches):
+        >>>     example_input = get_callibration_input()
+        >>>     tracer_model_with_observers(example_input)
+
+        >>> # finally we generate the reports and optionally remove the observers we inserted
+        >>> reports = tracer_reporter.generate_model_report(remove_inserted_observers=True)
+
+        >>> # Optional: we can generate the qconfig mapping based on the suggestions
+        >>> qconfigs = model_report.generate_qconfig_mapping()
+
+        >>> # Optional: we can generate the equalization mapping based on the suggestions
+        >>> qconfigs = model_report.generate_equalization_mapping()
+
+        >>> # Optional: we get a ModelReportVisualizer instance to do any visualizations desired
+        >>> model_report_visualizer = tracer_reporter.generate_visualizer()
+
+    """
+
+    def __init__(self, model: GraphModule, desired_report_detectors: Set[DetectorBase]):
+
+        if len(desired_report_detectors) == 0:
+            raise ValueError("Should include at least 1 desired report")
+
+        # keep track of the model we wish to generate report for
+        self._model: GraphModule = model
+
+        # keep the reports private so they can't be modified
+        self._desired_report_detectors = desired_report_detectors
+        self._desired_detector_names = {detector.get_detector_name() for detector in desired_report_detectors}
+
+        # keep a mapping of desired reports to observers of interest
+        # this is to get the readings, and to remove them, can create a large set
+        # this set can then be used to traverse the graph and remove added observers
+        self._detector_name_to_observer_fqns: Dict[str, Set[str]] = {}
+
+        # initialize each report to have empty set of observers of interest
+        for desired_report in self._desired_detector_names:
+            self._detector_name_to_observer_fqns[desired_report] = set()
+
+        # flags to ensure that we can only prepare and remove observers once
+        self._prepared_flag = False
+        self._removed_observers = False
+
+        # store the reports that we generated for visualization purposes
+        # initially empty since no reports generated
+        self._generated_reports: Dict[str, Dict] = {}
+
+    def get_desired_reports_names(self) -> Set[str]:
+        """ Returns a copy of the desired reports for viewing """
+        return self._desired_detector_names.copy()
+
+    def get_observers_of_interest(self) -> Dict[str, Set[str]]:
+        """ Returns a copy of the observers of interest for viewing """
+        return self._detector_name_to_observer_fqns.copy()
+
+    def prepare_detailed_calibration(self) -> GraphModule:
+        r"""
+        Takes in a graph model and inserts the following observers:
+        - ModelReportObserver
+
+        Each observer is inserted based on the desired_reports into the relevant locations
+
+        Right now, each report in self._desired_detector_names has independent insertions
+            However, if a module already has a Observer of the same type, the insertion will not occur
+            This is because all of the same type of Observer collect same information, so redundant
+
+        Returns the same GraphModule with the observers inserted
+        """
+
+        # if already prepared once, cannot prepare again
+        if self._prepared_flag:
+            raise ValueError("Already ran preparing detailed callibration. Run the report generation next after callibration.")
+
+        # loop through each detector, find where placements should be, and keep track
+        insert_observers_fqns: Dict[str, Any] = {}
+
+        for detector in self._desired_report_detectors:
+            # determine observer points for each detector
+            obs_fqn_to_info = detector.determine_observer_insert_points(self._model)
+            # map each insert point to the observer to use
+            insert_observers_fqns.update(obs_fqn_to_info)
+            # update the set of observers this report cares about
+            self._detector_name_to_observer_fqns[detector.get_detector_name()] = set(obs_fqn_to_info.keys())
+
+        # now insert all the observers at their desired locations
+        for observer_fqn in insert_observers_fqns:
+            target_node = insert_observers_fqns[observer_fqn][DETECTOR_TARGET_NODE_KEY]
+            insert_obs = insert_observers_fqns[observer_fqn][DETECTOR_OBS_TO_INSERT_KEY]
+            insert_post = insert_observers_fqns[observer_fqn][DETECTOR_IS_POST_OBS_KEY]
+            observer_args = insert_observers_fqns[observer_fqn][DETECTOR_OBS_ARGS_KEY]
+            self._insert_observer_around_module(
+                observer_fqn, target_node, insert_obs, observer_args, insert_post
+            )
+
+        self._prepared_flag = True
+
+        return self._model
+
+    def _insert_observer_around_module(
+        self,
+        obs_fqn: str,
+        target_node: torch.fx.node.Node,
+        obs_to_insert: ObserverBase,
+        observer_args: Tuple,
+        insert_post: bool
+    ):
+        r"""
+        Helper function that inserts the observer into both the graph structure and the module of the model
+
+        Args
+            node_fqn (str): The fully qualified name of the observer we want to insert
+            target_node (torch.fx.node.Node): The node in model we are inserting observers around
+            obs_to_insert (ObserverBase): The observer we are inserting around target_node
+            observer_args (Tuple): The arguments we want to pass into the observer
+            insert_post (bool): whether this is meant to be a post observer for this node
+        """
+        # if we are inserting post, then our target node is the next node
+        if insert_post:
+            target_node = target_node.next
+
+        with self._model.graph.inserting_before(target_node):
+            self._model.add_submodule(obs_fqn, obs_to_insert)
+            self._model.graph.create_node(op="call_module", target=obs_fqn, args=observer_args)
+
+        # recompile model after inserts are made
+        self._model.recompile()
+
+    def _get_node_from_fqn(self, node_fqn: str) -> torch.fx.node.Node:
+        r"""
+        Takes in a node fqn and returns the node based on the fqn
+
+        Args
+            node_fqn (str): The fully qualified name of the node we want to find in model
+
+        Returns the Node object of the given node_fqn otherwise returns None
+        """
+        node_to_return = None
+        for node in self._model.graph.nodes:
+            # if the target matches the fqn, it's the node we are looking for
+            if node.target == node_fqn:
+                node_to_return = node
+                break
+
+        if node_to_return is None:
+            raise ValueError("The node_fqn is was not found within the module.")
+
+        # assert for MyPy
+        assert isinstance(node_to_return, torch.fx.node.Node)
+
+        return node_to_return
+
+    def generate_model_report(
+        self, remove_inserted_observers: bool
+    ) -> Dict[str, Tuple[str, Dict]]:
+        r"""
+        Generates all the requested reports.
+
+        Note:
+            You should have callibrated the model with relevant data before calling this
+
+        The reports generated are specified by the desired_reports specified in desired_reports
+
+        Can optionally remove all the observers inserted by the ModelReport instance
+
+        Args:
+            remove_inserted_observers (bool): True to remove the observers inserted by this ModelReport instance
+
+        Returns a mapping of each desired report name to a tuple with:
+            The textual summary of that report information
+            A dictionary containing relevant statistics or information for that report
+
+        Note:
+            Throws exception if we try to generate report on model we already removed observers from
+            Throws exception if we try to generate report without preparing for callibration
+        """
+        # if we haven't prepped model for callibration, then we shouldn't generate report yet
+        if not self._prepared_flag:
+            raise Exception("Cannot generate report without preparing model for callibration")
+
+        # if we already removed the observers, we cannot generate report
+        if self._removed_observers:
+            raise Exception("Cannot generate report on model you already removed observers from")
+
+        # keep track of all the reports of interest and their outputs
+        reports_of_interest = {}
+
+        for detector in self._desired_report_detectors:
+            # generate the individual report for the detector
+            report_output = detector.generate_detector_report(self._model)
+            reports_of_interest[detector.get_detector_name()] = report_output
+
+        # if user wishes to remove inserted observers, go ahead and remove
+        if remove_inserted_observers:
+            self._removed_observers = True
+            # get the set of all Observers inserted by this instance of ModelReport
+            all_observers_of_interest: Set[str] = set()
+            for desired_report in self._detector_name_to_observer_fqns:
+                observers_of_interest = self._detector_name_to_observer_fqns[desired_report]
+                all_observers_of_interest.update(observers_of_interest)
+
+            # go through all_observers_of_interest and remove them from the graph and model
+            for observer_fqn in all_observers_of_interest:
+                # remove the observer from the model
+                self._model.delete_submodule(observer_fqn)
+
+                # remove the observer from the graph structure
+                node_obj = self._get_node_from_fqn(observer_fqn)
+
+                if node_obj:
+                    self._model.graph.erase_node(node_obj)
+                else:
+                    raise ValueError("Node no longer exists in GraphModule structure")
+
+            # remember to recompile the model
+            self._model.recompile()
+
+        # save the generated reports for visualization purposes
+        saved_reports: Dict[str, Dict] = {
+            report_name : report_tuple[1] for report_name, report_tuple in reports_of_interest.items()
+        }
+
+        self._generated_reports = saved_reports
+
+        # return the reports of interest
+        return reports_of_interest
+
+    def _is_same_info_for_same_key(self, info_dict_a: Dict, info_dict_b: Dict) -> bool:
+        r"""
+        Takes in two dictionaries and ensures that any common keys between the two have the same
+        values.
+
+        Args:
+            info_dict_a (Dict): First dictionary we wish to compare
+            info_dict_b (Dict): Second dictionary we wish to compare
+
+        Returns True if all shared keys have same values, false otherwise
+        """
+        # get the set of keys for both
+        dict_a_keys: Set = set(info_dict_a.keys())
+        dict_b_keys: Set = set(info_dict_b.keys())
+
+        # get the insersection keys and check if same value for both dicts
+        intersecting_keys: Set = dict_a_keys.intersection(dict_b_keys)
+
+        for key in intersecting_keys:
+            dict_a_val = info_dict_a[key]
+            dict_b_val = info_dict_b[key]
+
+            # if it's a tensor we have to handle separately
+            if type(dict_a_val) == torch.Tensor:
+                # if dict_b_val not tensor, automatically false
+                if type(dict_b_val) != torch.Tensor or sum(dict_a_val != dict_b_val) != 0:
+                    return False
+            else:
+                # for non-tensor vals
+                if dict_a_val != dict_b_val:
+                    return False
+
+        # if no non matching shared keys found, return true
+        return True
+
+    def _reformat_reports_for_visualizer(self) -> OrderedDict:
+        r"""
+        Takes the generated reports and reformats them into the format that is desired by the
+        ModelReportVisualizer
+
+        Returns an OrderedDict mapping module_fqns to their features
+        """
+        # we want to reorder and reformat the information so it is ordered in terms of order
+        # found in the model
+
+        # first create new dict with all modules as keys and features under respective module
+        module_fqns_to_features: Dict[str, Dict] = {}
+
+        for report_name in self._generated_reports:
+            # get mod -> feature dict and go through
+            module_info = self._generated_reports[report_name]
+
+            for module_fqn in module_info:
+                # check if already in our accumulation dict
+                if module_fqn in module_fqns_to_features:
+                    # we merge all the features together
+                    new_info: Dict = module_info[module_fqn]
+                    present_info: Dict = module_fqns_to_features[module_fqn]
+
+                    # merge them together into the new unioned dict
+                    # same features keys -> same info, so okay if override
+
+                    # do safety check to make sure shared keys have same info
+                    if self._is_same_info_for_same_key(new_info, present_info):
+                        module_fqns_to_features[module_fqn] = {**new_info, **present_info}
+                    else:
+                        error_str = "You have the same key with different values across detectors. "
+                        error_str += "Someone incorrectly implemented a detector with conflicting keys to existing detectors."
+                        raise ValueError(error_str)
+                else:
+                    # we just set it
+                    module_fqns_to_features[module_fqn] = module_info[module_fqn]
+
+        # our ordered dict so that modules can be ordered in order of how they appear in model
+        features_by_module: OrderedDict[str, Dict] = OrderedDict()
+
+        # we loop through modules in graph in order
+        for fqn, module in self._model.named_modules():
+            # find that fqn in fqns_to_features
+            if fqn in module_fqns_to_features:
+                # add it to our ordered dict
+                features_by_module[fqn] = module_fqns_to_features[fqn]
+
+        # return the ordered dict of info we created
+        return features_by_module
+
+    def generate_visualizer(self) -> ModelReportVisualizer:
+        r"""
+        Generates a ModelReportVisualizer instance using the reports generated
+        by the generate_model_report() method.
+
+        Returns the generated ModelReportVisualizer instance initialized
+
+        Note:
+            Throws exception if attempt to get visualizers without generating report
+        """
+        # check if user has generated reports at least once
+        if len(self._generated_reports) == 0:
+            raise Exception("Unable to generate visualizers without first generating reports")
+
+        # get the ordered dict mapping modules to their full set of collected features / stats
+        module_fqns_to_features: OrderedDict = self._reformat_reports_for_visualizer()
+
+        # create and return ModelReportVisualizer instance
+        visualizer: ModelReportVisualizer = ModelReportVisualizer(module_fqns_to_features)
+
+        return visualizer
+
+    def _generate_qconfig_mapping_helper(
+        self,
+        detector_qconfig_info_combined: Dict[str, DetectorQConfigInfo],
+        generation_function: Callable
+    ) -> QConfigMapping:
+        r"""
+        This helper takes in the compiled detector qconfig info that
+        has been compiled together and merges it into a QConfigMapping
+        """
+        # keep track of the qconfigmapping
+        qconfig_mapping = QConfigMapping()
+
+        # loop through each module / fqn and attempt to create QConfigMapping
+        for fqn, module in self._model.named_modules():
+            # if we have a qconfig info for this module
+            if fqn in detector_qconfig_info_combined:
+                qconfig_info_compiled = detector_qconfig_info_combined[fqn]
+
+                # now generate the qconfig and add it to the mapping
+                generated_qconfig = generation_function(qconfig_info_compiled, module)
+
+                # add to our config
+                qconfig_mapping.set_module_name(fqn, generated_qconfig)
+
+        # return compiled mapping
+        return qconfig_mapping
+
+    def _update_detector_quantizaiton_qconfig_info(self, combined_info: DetectorQConfigInfo, new_info: DetectorQConfigInfo):
+        r"""
+        Takes in the old and new information and updates the combined information.
+
+        Args:
+            combined_info (DetectorQConfigInfo): The DetectorQConfigInfo we are compiling all of the information in
+            new_info (DetectorQConfigInfo): The DetectorQConfigInfo with the information we are trying to merge the new info
+                into it
+        """
+        combined_info.is_activation_dynamic = combined_info.is_activation_dynamic or new_info.is_activation_dynamic
+        combined_info.is_weight_per_channel = combined_info.is_weight_per_channel or new_info.is_weight_per_channel
+
+    def _update_detector_equalization_qconfig_info(self, combined_info: DetectorQConfigInfo, new_info: DetectorQConfigInfo):
+        r"""
+        Takes in the old and new information and updates the combined information.
+
+        Args:
+            combined_info (DetectorQConfigInfo): The DetectorQConfigInfo we are compiling all of the information in
+            new_info (DetectorQConfigInfo): The DetectorQConfigInfo with the information we are trying to merge the new info
+                into it
+        """
+        is_equalization_recommended = combined_info.is_equalization_recommended or new_info.is_equalization_recommended
+        combined_info.is_equalization_recommended = is_equalization_recommended
+
+    def _generate_module_fqn_to_detector_info_mapping(
+        self,
+        update_qconfig_info_function: Callable
+    ) -> Dict[str, DetectorQConfigInfo]:
+        r"""
+        Generates a QConfigMapping based on the suggestions of the
+        ModelReport API. The generated mapping encompasses all the
+        different types of feedback from the different detectors
+        all into one place.
+
+        These configs are based on the suggestions provided by the ModelReport API
+        and can only be generated once the reports have been generated.
+
+        Args:
+            update_qconfig_info_function (Callable) takes in a function that takes in two DetectorQConfigInfo
+            and updates the one that is being compiled
+
+        Returns a Dict mapping module_fqns to DetectorQConfigInfo objects
+
+        Note:
+            Throws exception if we try to generate mapping on model we already removed observers from
+            Throws exception if we try to generate mapping without preparing for callibration
+        """
+        # if we haven't prepped model for callibration, then we shouldn't generate mapping yet
+        if not self._prepared_flag:
+            raise Exception("Cannot generate report without preparing model for callibration")
+
+        # if we already removed the observers, we cannot mapping
+        if self._removed_observers:
+            raise Exception("Cannot generate report on model you already removed observers from")
+
+        # keep track of qconfig info for each module across detectors
+        detector_qconfig_info_combined: Dict[str, DetectorQConfigInfo] = {}
+
+        for detector in self._desired_report_detectors:
+            # get the info from the detector
+            detector_info: Dict[str, DetectorQConfigInfo] = detector.get_qconfig_info(self._model)
+
+            # we go through the modules
+            for module_fqn in detector_info:
+                # see if we already have info on it
+                if module_fqn in detector_qconfig_info_combined:
+                    # we combine the current options with what is there
+                    current_options = detector_qconfig_info_combined[module_fqn]
+                    detector_options = detector_info[module_fqn]
+
+                    update_qconfig_info_function(current_options, detector_options)
+                else:
+                    # we just use this for now
+                    detector_qconfig_info_combined[module_fqn] = detector_info[module_fqn]
+
+        return detector_qconfig_info_combined
+
+    def generate_qconfig_mapping(self) -> QConfigMapping:
+        r"""
+        Generates a QConfigMapping based on the suggestions of the
+        ModelReport API. The generated mapping encompasses all the
+        different types of feedback from the different detectors
+        all into one place.
+
+        These configs are based on the suggestions provided by the ModelReport API
+        and can only be generated once the reports have been generated.
+
+        Returns a QConfigMapping for the quantization configuration
+
+        Note:
+            Throws exception if we try to generate mapping on model we already removed observers from
+            Throws exception if we try to generate mapping without preparing for callibration
+        """
+        # get the mapping info
+        detector_qconfig_info_combined = self._generate_module_fqn_to_detector_info_mapping(
+            self._update_detector_quantizaiton_qconfig_info
+        )
+
+        # we will do a bit of processing and remove fqns that don't have input weight recommended
+
+        # now we generate the QConfig for each of the options
+        mapping: QConfigMapping = self._generate_qconfig_mapping_helper(
+            detector_qconfig_info_combined,
+            self._quantization_config_generator
+        )
+
+        # return the generated mapping
+        return mapping
+
+    def _quantization_config_generator(self, detector_qconfig_info: DetectorQConfigInfo, module: torch.nn.Module) -> QConfig:
+        r"""
+        Returns the quantization configuration generated by the DetectorQConfigInfo object
+        """
+        return detector_qconfig_info.generate_quantization_qconfig(module)
+
+    def _equalization_config_generator(
+        self,
+        detector_qconfig_info: DetectorQConfigInfo,
+        module: torch.nn.Module
+    ) -> EqualizationQConfig:
+        r"""
+        We ignore the module argument here, and only focus on thedetector_qconfig_info
+
+        Returns the equalization configuration generated by the DetectorQConfigInfo object
+        """
+        return detector_qconfig_info.generate_equalization_qconfig()
+
+    def generate_equalization_mapping(self) -> QConfigMapping:
+        r"""
+        Generates a QConfigMapping based on the suggestions of the
+        ModelReport API for equalization. The generated mapping encompasses all the
+        different types of feedback from the input-weight equalization detector.
+
+        These configs are based on the suggestions provided by the ModelReport API
+        and can only be generated once the reports have been generated.
+
+        Returns a QConfigMapping for the equalization configuration
+        """
+        # get the mapping info
+        detector_qconfig_info_combined = self._generate_module_fqn_to_detector_info_mapping(
+            self._update_detector_equalization_qconfig_info
+        )
+
+        # now we generate the QConfig for each of the options
+        mapping: QConfigMapping = self._generate_qconfig_mapping_helper(
+            detector_qconfig_info_combined,
+            self._equalization_config_generator
+        )
+
+        # return the generated mapping
+        return mapping

shared/package-files/8b/8bac1070af4cf22f337ff5aaa8184c8f638229a9af3fb4fff630b919418fd47e/blob

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8bac1070af4cf22f337ff5aaa8184c8f638229a9af3fb4fff630b919418fd47e
+size 208346

shared/package-files/8b/8badfd129686a5d20216b1aba16450f6f471722c8b6ddfc61278dd572283abc0/blob

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8badfd129686a5d20216b1aba16450f6f471722c8b6ddfc61278dd572283abc0
+size 555268959

shared/package-files/8b/8bb075675e65561a64af676d362b7a55867696d0f0f5a15973451b8c155294c6/blob

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

shared/package-files/8b/8bb0c4a825ec10fb775f144093ab733132671db740246a713f00825d3b889e34/blob

@@ -0,0 +1,31 @@
+"""
+Test that all docstrings are the same:
+
+>>> len({f.__doc__ for f in (a, b, c, d)})
+1
+"""
+from numba import guvectorize, int64, njit, vectorize
+
+
+def a():
+    """>>> x = 1"""
+    return 1
+
+
+@njit
+def b():
+    """>>> x = 1"""
+    return 1
+
+
+@guvectorize([(int64[:], int64, int64[:])], "(n),()->(n)")
+def c(x, y, res):
+    """>>> x = 1"""
+    for i in range(x.shape[0]):
+        res[i] = x[i] + y
+
+
+@vectorize([int64(int64, int64)])
+def d(x, y):
+    """>>> x = 1"""
+    return x + y

shared/package-files/8b/8bb7d57be88bc8bb50c427c06b82317711feb9f70798c93b85b0861b94f1018e/blob

@@ -0,0 +1,1008 @@
+StartFontMetrics 2.0
+Comment Copyright (c) 1989, 1991 Adobe Systems Incorporated.  All Rights Reserved.
+Comment Creation Date: Fri Jan 17 13:15:45 1992
+Comment UniqueID 37666
+Comment VMusage 34143 41035
+FontName Utopia-Italic
+FullName Utopia Italic
+FamilyName Utopia
+Weight Regular
+ItalicAngle -13
+IsFixedPitch false
+FontBBox -201 -250 1170 890 
+UnderlinePosition -100
+UnderlineThickness 50
+Version 001.002
+Notice Copyright (c) 1989, 1991 Adobe Systems Incorporated.  All Rights Reserved.Utopia is a registered trademark of Adobe Systems Incorporated.
+EncodingScheme AdobeStandardEncoding
+CapHeight 692
+XHeight 502
+Ascender 742
+Descender -242
+StartCharMetrics 228
+C 32 ; WX 225 ; N space ; B 0 0 0 0 ;
+C 33 ; WX 240 ; N exclam ; B 34 -12 290 707 ;
+C 34 ; WX 402 ; N quotedbl ; B 171 469 454 742 ;
+C 35 ; WX 530 ; N numbersign ; B 54 0 585 668 ;
+C 36 ; WX 530 ; N dollar ; B 31 -109 551 743 ;
+C 37 ; WX 826 ; N percent ; B 98 -25 795 702 ;
+C 38 ; WX 725 ; N ampersand ; B 60 -12 703 680 ;
+C 39 ; WX 216 ; N quoteright ; B 112 482 265 742 ;
+C 40 ; WX 350 ; N parenleft ; B 106 -128 458 692 ;
+C 41 ; WX 350 ; N parenright ; B -46 -128 306 692 ;
+C 42 ; WX 412 ; N asterisk ; B 106 356 458 707 ;
+C 43 ; WX 570 ; N plus ; B 58 0 542 490 ;
+C 44 ; WX 265 ; N comma ; B 11 -134 173 142 ;
+C 45 ; WX 392 ; N hyphen ; B 82 216 341 286 ;
+C 46 ; WX 265 ; N period ; B 47 -12 169 113 ;
+C 47 ; WX 270 ; N slash ; B 0 -15 341 707 ;
+C 48 ; WX 530 ; N zero ; B 60 -12 541 680 ;
+C 49 ; WX 530 ; N one ; B 74 0 429 680 ;
+C 50 ; WX 530 ; N two ; B -2 0 538 680 ;
+C 51 ; WX 530 ; N three ; B 19 -12 524 680 ;
+C 52 ; WX 530 ; N four ; B 32 0 509 668 ;
+C 53 ; WX 530 ; N five ; B 24 -12 550 668 ;
+C 54 ; WX 530 ; N six ; B 56 -12 551 680 ;
+C 55 ; WX 530 ; N seven ; B 130 -12 600 668 ;
+C 56 ; WX 530 ; N eight ; B 46 -12 535 680 ;
+C 57 ; WX 530 ; N nine ; B 51 -12 536 680 ;
+C 58 ; WX 265 ; N colon ; B 47 -12 248 490 ;
+C 59 ; WX 265 ; N semicolon ; B 11 -134 248 490 ;
+C 60 ; WX 570 ; N less ; B 51 1 529 497 ;
+C 61 ; WX 570 ; N equal ; B 58 111 542 389 ;
+C 62 ; WX 570 ; N greater ; B 51 1 529 497 ;
+C 63 ; WX 425 ; N question ; B 115 -12 456 707 ;
+C 64 ; WX 794 ; N at ; B 88 -15 797 707 ;
+C 65 ; WX 624 ; N A ; B -58 0 623 692 ;
+C 66 ; WX 632 ; N B ; B 3 0 636 692 ;
+C 67 ; WX 661 ; N C ; B 79 -15 723 707 ;
+C 68 ; WX 763 ; N D ; B 5 0 767 692 ;
+C 69 ; WX 596 ; N E ; B 3 0 657 692 ;
+C 70 ; WX 571 ; N F ; B 3 0 660 692 ;
+C 71 ; WX 709 ; N G ; B 79 -15 737 707 ;
+C 72 ; WX 775 ; N H ; B 5 0 857 692 ;
+C 73 ; WX 345 ; N I ; B 5 0 428 692 ;
+C 74 ; WX 352 ; N J ; B -78 -119 436 692 ;
+C 75 ; WX 650 ; N K ; B 5 -5 786 692 ;
+C 76 ; WX 565 ; N L ; B 5 0 568 692 ;
+C 77 ; WX 920 ; N M ; B -4 0 1002 692 ;
+C 78 ; WX 763 ; N N ; B -4 0 855 692 ;
+C 79 ; WX 753 ; N O ; B 79 -15 754 707 ;
+C 80 ; WX 614 ; N P ; B 5 0 646 692 ;
+C 81 ; WX 753 ; N Q ; B 79 -203 754 707 ;
+C 82 ; WX 640 ; N R ; B 5 0 642 692 ;
+C 83 ; WX 533 ; N S ; B 34 -15 542 707 ;
+C 84 ; WX 606 ; N T ; B 102 0 708 692 ;
+C 85 ; WX 794 ; N U ; B 131 -15 880 692 ;
+C 86 ; WX 637 ; N V ; B 96 0 786 692 ;
+C 87 ; WX 946 ; N W ; B 86 0 1075 692 ;
+C 88 ; WX 632 ; N X ; B -36 0 735 692 ;
+C 89 ; WX 591 ; N Y ; B 96 0 744 692 ;
+C 90 ; WX 622 ; N Z ; B -20 0 703 692 ;
+C 91 ; WX 330 ; N bracketleft ; B 69 -128 414 692 ;
+C 92 ; WX 390 ; N backslash ; B 89 -15 371 707 ;
+C 93 ; WX 330 ; N bracketright ; B -21 -128 324 692 ;
+C 94 ; WX 570 ; N asciicircum ; B 83 228 547 668 ;
+C 95 ; WX 500 ; N underscore ; B 0 -125 500 -75 ;
+C 96 ; WX 216 ; N quoteleft ; B 130 488 283 748 ;
+C 97 ; WX 561 ; N a ; B 31 -12 563 502 ;
+C 98 ; WX 559 ; N b ; B 47 -12 557 742 ;
+C 99 ; WX 441 ; N c ; B 46 -12 465 502 ;
+C 100 ; WX 587 ; N d ; B 37 -12 612 742 ;
+C 101 ; WX 453 ; N e ; B 45 -12 471 502 ;
+C 102 ; WX 315 ; N f ; B -107 -242 504 742 ; L i fi ; L l fl ;
+C 103 ; WX 499 ; N g ; B -5 -242 573 512 ;
+C 104 ; WX 607 ; N h ; B 57 -12 588 742 ;
+C 105 ; WX 317 ; N i ; B 79 -12 328 715 ;
+C 106 ; WX 309 ; N j ; B -95 -242 330 715 ;
+C 107 ; WX 545 ; N k ; B 57 -12 567 742 ;
+C 108 ; WX 306 ; N l ; B 76 -12 331 742 ;
+C 109 ; WX 912 ; N m ; B 63 -12 894 502 ;
+C 110 ; WX 618 ; N n ; B 63 -12 600 502 ;
+C 111 ; WX 537 ; N o ; B 49 -12 522 502 ;
+C 112 ; WX 590 ; N p ; B 22 -242 586 502 ;
+C 113 ; WX 559 ; N q ; B 38 -242 567 525 ;
+C 114 ; WX 402 ; N r ; B 69 -12 448 502 ;
+C 115 ; WX 389 ; N s ; B 19 -12 397 502 ;
+C 116 ; WX 341 ; N t ; B 84 -12 404 616 ;
+C 117 ; WX 618 ; N u ; B 89 -12 609 502 ;
+C 118 ; WX 510 ; N v ; B 84 -12 528 502 ;
+C 119 ; WX 785 ; N w ; B 87 -12 808 502 ;
+C 120 ; WX 516 ; N x ; B -4 -12 531 502 ;
+C 121 ; WX 468 ; N y ; B -40 -242 505 502 ;
+C 122 ; WX 468 ; N z ; B 4 -12 483 490 ;
+C 123 ; WX 340 ; N braceleft ; B 100 -128 423 692 ;
+C 124 ; WX 270 ; N bar ; B 130 -250 198 750 ;
+C 125 ; WX 340 ; N braceright ; B -20 -128 302 692 ;
+C 126 ; WX 570 ; N asciitilde ; B 98 176 522 318 ;
+C 161 ; WX 240 ; N exclamdown ; B -18 -217 238 502 ;
+C 162 ; WX 530 ; N cent ; B 94 -21 563 669 ;
+C 163 ; WX 530 ; N sterling ; B 9 0 549 680 ;
+C 164 ; WX 100 ; N fraction ; B -201 -24 369 698 ;
+C 165 ; WX 530 ; N yen ; B 72 0 645 668 ;
+C 166 ; WX 530 ; N florin ; B 4 -135 588 691 ;
+C 167 ; WX 530 ; N section ; B 55 -115 533 707 ;
+C 168 ; WX 530 ; N currency ; B 56 90 536 578 ;
+C 169 ; WX 216 ; N quotesingle ; B 161 469 274 742 ;
+C 170 ; WX 402 ; N quotedblleft ; B 134 488 473 748 ;
+C 171 ; WX 462 ; N guillemotleft ; B 79 41 470 435 ;
+C 172 ; WX 277 ; N guilsinglleft ; B 71 41 267 435 ;
+C 173 ; WX 277 ; N guilsinglright ; B 44 41 240 435 ;
+C 174 ; WX 607 ; N fi ; B -107 -242 589 742 ;
+C 175 ; WX 603 ; N fl ; B -107 -242 628 742 ;
+C 177 ; WX 500 ; N endash ; B 12 221 524 279 ;
+C 178 ; WX 500 ; N dagger ; B 101 -125 519 717 ;
+C 179 ; WX 490 ; N daggerdbl ; B 39 -119 509 717 ;
+C 180 ; WX 265 ; N periodcentered ; B 89 187 211 312 ;
+C 182 ; WX 560 ; N paragraph ; B 109 -101 637 692 ;
+C 183 ; WX 500 ; N bullet ; B 110 192 429 512 ;
+C 184 ; WX 216 ; N quotesinglbase ; B -7 -109 146 151 ;
+C 185 ; WX 402 ; N quotedblbase ; B -7 -109 332 151 ;
+C 186 ; WX 402 ; N quotedblright ; B 107 484 446 744 ;
+C 187 ; WX 462 ; N guillemotright ; B 29 41 420 435 ;
+C 188 ; WX 1000 ; N ellipsis ; B 85 -12 873 113 ;
+C 189 ; WX 1200 ; N perthousand ; B 98 -25 1170 702 ;
+C 191 ; WX 425 ; N questiondown ; B 3 -217 344 502 ;
+C 193 ; WX 400 ; N grave ; B 146 542 368 723 ;
+C 194 ; WX 400 ; N acute ; B 214 542 436 723 ;
+C 195 ; WX 400 ; N circumflex ; B 187 546 484 720 ;
+C 196 ; WX 400 ; N tilde ; B 137 563 492 682 ;
+C 197 ; WX 400 ; N macron ; B 193 597 489 656 ;
+C 198 ; WX 400 ; N breve ; B 227 568 501 698 ;
+C 199 ; WX 402 ; N dotaccent ; B 252 570 359 680 ;
+C 200 ; WX 400 ; N dieresis ; B 172 572 487 682 ;
+C 202 ; WX 400 ; N ring ; B 186 550 402 752 ;
+C 203 ; WX 400 ; N cedilla ; B 62 -230 241 0 ;
+C 205 ; WX 400 ; N hungarumlaut ; B 176 546 455 750 ;
+C 206 ; WX 350 ; N ogonek ; B 68 -219 248 0 ;
+C 207 ; WX 400 ; N caron ; B 213 557 510 731 ;
+C 208 ; WX 1000 ; N emdash ; B 12 221 1024 279 ;
+C 225 ; WX 880 ; N AE ; B -88 0 941 692 ;
+C 227 ; WX 425 ; N ordfeminine ; B 77 265 460 590 ;
+C 232 ; WX 571 ; N Lslash ; B 11 0 574 692 ;
+C 233 ; WX 753 ; N Oslash ; B 79 -45 754 736 ;
+C 234 ; WX 1020 ; N OE ; B 79 0 1081 692 ;
+C 235 ; WX 389 ; N ordmasculine ; B 86 265 420 590 ;
+C 241 ; WX 779 ; N ae ; B 34 -12 797 514 ;
+C 245 ; WX 317 ; N dotlessi ; B 79 -12 299 502 ;
+C 248 ; WX 318 ; N lslash ; B 45 -12 376 742 ;
+C 249 ; WX 537 ; N oslash ; B 49 -39 522 529 ;
+C 250 ; WX 806 ; N oe ; B 49 -12 824 502 ;
+C 251 ; WX 577 ; N germandbls ; B -107 -242 630 742 ;
+C -1 ; WX 370 ; N onesuperior ; B 90 272 326 680 ;
+C -1 ; WX 570 ; N minus ; B 58 221 542 279 ;
+C -1 ; WX 400 ; N degree ; B 152 404 428 680 ;
+C -1 ; WX 537 ; N oacute ; B 49 -12 530 723 ;
+C -1 ; WX 753 ; N Odieresis ; B 79 -15 754 848 ;
+C -1 ; WX 537 ; N odieresis ; B 49 -12 532 682 ;
+C -1 ; WX 596 ; N Eacute ; B 3 0 657 890 ;
+C -1 ; WX 618 ; N ucircumflex ; B 89 -12 609 720 ;
+C -1 ; WX 890 ; N onequarter ; B 97 -24 805 698 ;
+C -1 ; WX 570 ; N logicalnot ; B 58 102 542 389 ;
+C -1 ; WX 596 ; N Ecircumflex ; B 3 0 657 876 ;
+C -1 ; WX 890 ; N onehalf ; B 71 -24 812 698 ;
+C -1 ; WX 753 ; N Otilde ; B 79 -15 754 842 ;
+C -1 ; WX 618 ; N uacute ; B 89 -12 609 723 ;
+C -1 ; WX 453 ; N eacute ; B 45 -12 508 723 ;
+C -1 ; WX 317 ; N iacute ; B 79 -12 398 723 ;
+C -1 ; WX 596 ; N Egrave ; B 3 0 657 890 ;
+C -1 ; WX 317 ; N icircumflex ; B 79 -12 383 720 ;
+C -1 ; WX 618 ; N mu ; B 11 -232 609 502 ;
+C -1 ; WX 270 ; N brokenbar ; B 130 -175 198 675 ;
+C -1 ; WX 584 ; N thorn ; B 16 -242 580 700 ;
+C -1 ; WX 624 ; N Aring ; B -58 0 623 861 ;
+C -1 ; WX 468 ; N yacute ; B -40 -242 505 723 ;
+C -1 ; WX 591 ; N Ydieresis ; B 96 0 744 848 ;
+C -1 ; WX 1100 ; N trademark ; B 91 277 1094 692 ;
+C -1 ; WX 836 ; N registered ; B 91 -15 819 707 ;
+C -1 ; WX 537 ; N ocircumflex ; B 49 -12 522 720 ;
+C -1 ; WX 624 ; N Agrave ; B -58 0 623 890 ;
+C -1 ; WX 533 ; N Scaron ; B 34 -15 561 888 ;
+C -1 ; WX 794 ; N Ugrave ; B 131 -15 880 890 ;
+C -1 ; WX 596 ; N Edieresis ; B 3 0 657 848 ;
+C -1 ; WX 794 ; N Uacute ; B 131 -15 880 890 ;
+C -1 ; WX 537 ; N otilde ; B 49 -12 525 682 ;
+C -1 ; WX 618 ; N ntilde ; B 63 -12 600 682 ;
+C -1 ; WX 468 ; N ydieresis ; B -40 -242 513 682 ;
+C -1 ; WX 624 ; N Aacute ; B -58 0 642 890 ;
+C -1 ; WX 537 ; N eth ; B 47 -12 521 742 ;
+C -1 ; WX 561 ; N acircumflex ; B 31 -12 563 720 ;
+C -1 ; WX 561 ; N aring ; B 31 -12 563 752 ;
+C -1 ; WX 753 ; N Ograve ; B 79 -15 754 890 ;
+C -1 ; WX 441 ; N ccedilla ; B 46 -230 465 502 ;
+C -1 ; WX 570 ; N multiply ; B 88 22 532 478 ;
+C -1 ; WX 570 ; N divide ; B 58 25 542 475 ;
+C -1 ; WX 370 ; N twosuperior ; B 35 272 399 680 ;
+C -1 ; WX 763 ; N Ntilde ; B -4 0 855 842 ;
+C -1 ; WX 618 ; N ugrave ; B 89 -12 609 723 ;
+C -1 ; WX 794 ; N Ucircumflex ; B 131 -15 880 876 ;
+C -1 ; WX 624 ; N Atilde ; B -58 0 623 842 ;
+C -1 ; WX 468 ; N zcaron ; B 4 -12 484 731 ;
+C -1 ; WX 317 ; N idieresis ; B 79 -12 398 682 ;
+C -1 ; WX 624 ; N Acircumflex ; B -58 0 623 876 ;
+C -1 ; WX 345 ; N Icircumflex ; B 5 0 453 876 ;
+C -1 ; WX 591 ; N Yacute ; B 96 0 744 890 ;
+C -1 ; WX 753 ; N Oacute ; B 79 -15 754 890 ;
+C -1 ; WX 624 ; N Adieresis ; B -58 0 623 848 ;
+C -1 ; WX 622 ; N Zcaron ; B -20 0 703 888 ;
+C -1 ; WX 561 ; N agrave ; B 31 -12 563 723 ;
+C -1 ; WX 370 ; N threesuperior ; B 59 265 389 680 ;
+C -1 ; WX 537 ; N ograve ; B 49 -12 522 723 ;
+C -1 ; WX 890 ; N threequarters ; B 105 -24 816 698 ;
+C -1 ; WX 770 ; N Eth ; B 12 0 774 692 ;
+C -1 ; WX 570 ; N plusminus ; B 58 0 542 556 ;
+C -1 ; WX 618 ; N udieresis ; B 89 -12 609 682 ;
+C -1 ; WX 453 ; N edieresis ; B 45 -12 490 682 ;
+C -1 ; WX 561 ; N aacute ; B 31 -12 571 723 ;
+C -1 ; WX 317 ; N igrave ; B 55 -12 299 723 ;
+C -1 ; WX 345 ; N Idieresis ; B 5 0 461 848 ;
+C -1 ; WX 561 ; N adieresis ; B 31 -12 563 682 ;
+C -1 ; WX 345 ; N Iacute ; B 5 0 506 890 ;
+C -1 ; WX 836 ; N copyright ; B 91 -15 819 707 ;
+C -1 ; WX 345 ; N Igrave ; B 5 0 428 890 ;
+C -1 ; WX 661 ; N Ccedilla ; B 79 -230 723 707 ;
+C -1 ; WX 389 ; N scaron ; B 19 -12 457 731 ;
+C -1 ; WX 453 ; N egrave ; B 45 -12 471 723 ;
+C -1 ; WX 753 ; N Ocircumflex ; B 79 -15 754 876 ;
+C -1 ; WX 604 ; N Thorn ; B 5 0 616 692 ;
+C -1 ; WX 561 ; N atilde ; B 31 -12 563 682 ;
+C -1 ; WX 794 ; N Udieresis ; B 131 -15 880 848 ;
+C -1 ; WX 453 ; N ecircumflex ; B 45 -12 475 720 ;
+EndCharMetrics
+StartKernData
+StartKernPairs 690
+
+KPX A y -20
+KPX A x 10
+KPX A w -30
+KPX A v -30
+KPX A u -10
+KPX A t -6
+KPX A s 15
+KPX A r -12
+KPX A quoteright -110
+KPX A quotedblright -110
+KPX A q 10
+KPX A p -12
+KPX A o -10
+KPX A n -18
+KPX A m -18
+KPX A l -18
+KPX A j 6
+KPX A h -6
+KPX A d 10
+KPX A c -6
+KPX A b -6
+KPX A a 12
+KPX A Y -76
+KPX A X -8
+KPX A W -80
+KPX A V -90
+KPX A U -60
+KPX A T -72
+KPX A Q -30
+KPX A O -30
+KPX A G -30
+KPX A C -30
+
+KPX B y -6
+KPX B u -20
+KPX B r -15
+KPX B quoteright -40
+KPX B quotedblright -30
+KPX B o 6
+KPX B l -20
+KPX B k -15
+KPX B i -12
+KPX B h -15
+KPX B e 6
+KPX B a 12
+KPX B W -20
+KPX B V -50
+KPX B U -50
+KPX B T -20
+
+KPX C z -6
+KPX C y -18
+KPX C u -18
+KPX C quotedblright 20
+KPX C i -5
+KPX C e -6
+KPX C a -6
+
+KPX D y 18
+KPX D u -10
+KPX D quoteright -40
+KPX D quotedblright -50
+KPX D period -30
+KPX D o 6
+KPX D i 6
+KPX D h -25
+KPX D e 6
+KPX D comma -20
+KPX D a 6
+KPX D Y -70
+KPX D W -50
+KPX D V -60
+
+KPX E z -6
+KPX E y -18
+KPX E x 5
+KPX E w -20
+KPX E v -18
+KPX E u -24
+KPX E t -18
+KPX E s 5
+KPX E r -6
+KPX E quoteright 10
+KPX E quotedblright 10
+KPX E q 10
+KPX E period 10
+KPX E p -12
+KPX E o -6
+KPX E n -12
+KPX E m -12
+KPX E l -12
+KPX E k -10
+KPX E j -6
+KPX E i -12
+KPX E g -12
+KPX E e 5
+KPX E d 10
+KPX E comma 10
+KPX E b -6
+
+KPX F y -12
+KPX F u -30
+KPX F r -18
+KPX F quoteright 15
+KPX F quotedblright 35
+KPX F period -180
+KPX F o -30
+KPX F l -6
+KPX F i -12
+KPX F e -30
+KPX F comma -170
+KPX F a -30
+KPX F A -45
+
+KPX G y -16
+KPX G u -22
+KPX G r -22
+KPX G quoteright -20
+KPX G quotedblright -20
+KPX G o 10
+KPX G n -22
+KPX G l -24
+KPX G i -12
+KPX G h -18
+KPX G e 10
+KPX G a 5
+
+KPX H y -18
+KPX H u -30
+KPX H quoteright 10
+KPX H quotedblright 10
+KPX H o -12
+KPX H i -12
+KPX H e -12
+KPX H a -12
+
+KPX I z -20
+KPX I y -6
+KPX I x -6
+KPX I w -30
+KPX I v -30
+KPX I u -30
+KPX I t -18
+KPX I s -18
+KPX I r -12
+KPX I quoteright 10
+KPX I quotedblright 10
+KPX I p -18
+KPX I o -12
+KPX I n -18
+KPX I m -18
+KPX I l -6
+KPX I k -6
+KPX I g -12
+KPX I f -6
+KPX I d -6
+KPX I c -12
+KPX I b -6
+KPX I a -6
+
+KPX J y -12
+KPX J u -36
+KPX J quoteright 6
+KPX J quotedblright 15
+KPX J o -36
+KPX J i -30
+KPX J e -36
+KPX J braceright 10
+KPX J a -36
+
+KPX K y -40
+KPX K w -30
+KPX K v -20
+KPX K u -24
+KPX K r -12
+KPX K quoteright 25
+KPX K quotedblright 40
+KPX K o -24
+KPX K n -18
+KPX K i -6
+KPX K h 6
+KPX K e -12
+KPX K a -6
+KPX K Q -24
+KPX K O -24
+KPX K G -24
+KPX K C -24
+
+KPX L y -55
+KPX L w -30
+KPX L u -18
+KPX L quoteright -110
+KPX L quotedblright -110
+KPX L l -16
+KPX L j -18
+KPX L i -18
+KPX L a 10
+KPX L Y -80
+KPX L W -90
+KPX L V -110
+KPX L U -42
+KPX L T -80
+KPX L Q -48
+KPX L O -48
+KPX L G -48
+KPX L C -48
+KPX L A 30
+
+KPX M y -18
+KPX M u -24
+KPX M quoteright 6
+KPX M quotedblright 15
+KPX M o -25
+KPX M n -12
+KPX M j -18
+KPX M i -12
+KPX M e -20
+KPX M d -10
+KPX M c -20
+KPX M a -6
+
+KPX N y -18
+KPX N u -24
+KPX N quoteright 10
+KPX N quotedblright 10
+KPX N o -25
+KPX N i -12
+KPX N e -20
+KPX N a -22
+
+KPX O z -6
+KPX O y 12
+KPX O w -10
+KPX O v -10
+KPX O u -6
+KPX O t -6
+KPX O s -6
+KPX O r -6
+KPX O quoteright -40
+KPX O quotedblright -40
+KPX O q 5
+KPX O period -20
+KPX O p -6
+KPX O n -6
+KPX O m -6
+KPX O l -20
+KPX O k -10
+KPX O j -6
+KPX O h -10
+KPX O g -6
+KPX O e 5
+KPX O d 6
+KPX O comma -10
+KPX O c 5
+KPX O b -6
+KPX O a 5
+KPX O Y -75
+KPX O X -30
+KPX O W -40
+KPX O V -60
+KPX O T -48
+KPX O A -18
+
+KPX P y 6
+KPX P u -18
+KPX P t -6
+KPX P s -24
+KPX P r -6
+KPX P period -220
+KPX P o -24
+KPX P n -12
+KPX P l -25
+KPX P h -15
+KPX P e -24
+KPX P comma -220
+KPX P a -24
+KPX P I -30
+KPX P H -30
+KPX P E -30
+KPX P A -75
+
+KPX Q u -6
+KPX Q quoteright -40
+KPX Q quotedblright -50
+KPX Q a -6
+KPX Q Y -70
+KPX Q X -12
+KPX Q W -35
+KPX Q V -60
+KPX Q U -35
+KPX Q T -36
+KPX Q A -18
+
+KPX R y -14
+KPX R u -12
+KPX R quoteright -30
+KPX R quotedblright -20
+KPX R o -12
+KPX R hyphen -20
+KPX R e -12
+KPX R Y -50
+KPX R W -30
+KPX R V -40
+KPX R U -40
+KPX R T -30
+KPX R Q -10
+KPX R O -10
+KPX R G -10
+KPX R C -10
+KPX R A -6
+
+KPX S y -30
+KPX S w -30
+KPX S v -30
+KPX S u -18
+KPX S t -30
+KPX S r -20
+KPX S quoteright -38
+KPX S quotedblright -30
+KPX S p -18
+KPX S n -24
+KPX S m -24
+KPX S l -30
+KPX S k -24
+KPX S j -25
+KPX S i -30
+KPX S h -30
+KPX S e -6
+
+KPX T z -70
+KPX T y -60
+KPX T w -64
+KPX T u -74
+KPX T semicolon -36
+KPX T s -72
+KPX T r -64
+KPX T quoteright 45
+KPX T quotedblright 50
+KPX T period -100
+KPX T parenright 54
+KPX T o -90
+KPX T m -64
+KPX T i -34
+KPX T hyphen -100
+KPX T endash -60
+KPX T emdash -60
+KPX T e -90
+KPX T comma -110
+KPX T colon -10
+KPX T bracketright 45
+KPX T braceright 54
+KPX T a -90
+KPX T Y 12
+KPX T X 18
+KPX T W 6
+KPX T T 18
+KPX T Q -12
+KPX T O -12
+KPX T G -12
+KPX T C -12
+KPX T A -56
+
+KPX U z -30
+KPX U x -40
+KPX U t -24
+KPX U s -30
+KPX U r -30
+KPX U quoteright 10
+KPX U quotedblright 10
+KPX U p -40
+KPX U n -45
+KPX U m -45
+KPX U l -12
+KPX U k -12
+KPX U i -24
+KPX U h -6
+KPX U g -30
+KPX U d -40
+KPX U c -35
+KPX U b -6
+KPX U a -40
+KPX U A -45
+
+KPX V y -46
+KPX V u -42
+KPX V semicolon -35
+KPX V r -50
+KPX V quoteright 75
+KPX V quotedblright 70
+KPX V period -130
+KPX V parenright 64
+KPX V o -62
+KPX V i -10
+KPX V hyphen -60
+KPX V endash -20
+KPX V emdash -20
+KPX V e -52
+KPX V comma -120
+KPX V colon -18
+KPX V bracketright 64
+KPX V braceright 64
+KPX V a -60
+KPX V T 6
+KPX V A -70
+
+KPX W y -42
+KPX W u -56
+KPX W t -20
+KPX W semicolon -28
+KPX W r -40
+KPX W quoteright 55
+KPX W quotedblright 60
+KPX W period -108
+KPX W parenright 64
+KPX W o -60
+KPX W m -35
+KPX W i -10
+KPX W hyphen -40
+KPX W endash -2
+KPX W emdash -10
+KPX W e -54
+KPX W d -50
+KPX W comma -108
+KPX W colon -28
+KPX W bracketright 55
+KPX W braceright 64
+KPX W a -60
+KPX W T 12
+KPX W Q -10
+KPX W O -10
+KPX W G -10
+KPX W C -10
+KPX W A -58
+
+KPX X y -35
+KPX X u -30
+KPX X r -6
+KPX X quoteright 35
+KPX X quotedblright 15
+KPX X i -6
+KPX X e -10
+KPX X a 5
+KPX X Y -6
+KPX X W -6
+KPX X Q -30
+KPX X O -30
+KPX X G -30
+KPX X C -30
+KPX X A -18
+
+KPX Y v -50
+KPX Y u -58
+KPX Y t -32
+KPX Y semicolon -36
+KPX Y quoteright 65
+KPX Y quotedblright 70
+KPX Y q -100
+KPX Y period -90
+KPX Y parenright 60
+KPX Y o -72
+KPX Y l 10
+KPX Y hyphen -95
+KPX Y endash -20
+KPX Y emdash -20
+KPX Y e -72
+KPX Y d -80
+KPX Y comma -80
+KPX Y colon -36
+KPX Y bracketright 64
+KPX Y braceright 75
+KPX Y a -82
+KPX Y Y 12
+KPX Y X 12
+KPX Y W 12
+KPX Y V 6
+KPX Y T 25
+KPX Y Q -5
+KPX Y O -5
+KPX Y G -5
+KPX Y C -5
+KPX Y A -36
+
+KPX Z y -36
+KPX Z w -36
+KPX Z u -12
+KPX Z quoteright 10
+KPX Z quotedblright 10
+KPX Z o -6
+KPX Z i -12
+KPX Z e -6
+KPX Z a -6
+KPX Z Q -30
+KPX Z O -30
+KPX Z G -30
+KPX Z C -30
+KPX Z A 12
+
+KPX a quoteright -40
+KPX a quotedblright -40
+
+KPX b y -6
+KPX b w -15
+KPX b v -15
+KPX b quoteright -50
+KPX b quotedblright -50
+KPX b period -40
+KPX b comma -30
+
+KPX braceleft Y 64
+KPX braceleft W 64
+KPX braceleft V 64
+KPX braceleft T 54
+KPX braceleft J 80
+
+KPX bracketleft Y 64
+KPX bracketleft W 64
+KPX bracketleft V 64
+KPX bracketleft T 54
+KPX bracketleft J 80
+
+KPX c quoteright -20
+KPX c quotedblright -20
+
+KPX colon space -30
+
+KPX comma space -40
+KPX comma quoteright -80
+KPX comma quotedblright -80
+
+KPX d quoteright -12
+KPX d quotedblright -12
+
+KPX e x -10
+KPX e w -10
+KPX e quoteright -30
+KPX e quotedblright -30
+
+KPX f quoteright 110
+KPX f quotedblright 110
+KPX f period -20
+KPX f parenright 100
+KPX f comma -20
+KPX f bracketright 90
+KPX f braceright 90
+
+KPX g y 30
+KPX g p 12
+KPX g f 42
+
+KPX h quoteright -80
+KPX h quotedblright -80
+
+KPX j quoteright -20
+KPX j quotedblright -20
+KPX j period -35
+KPX j comma -20
+
+KPX k quoteright -30
+KPX k quotedblright -50
+
+KPX m quoteright -80
+KPX m quotedblright -80
+
+KPX n quoteright -80
+KPX n quotedblright -80
+
+KPX o z -10
+KPX o y -20
+KPX o x -20
+KPX o w -30
+KPX o v -35
+KPX o quoteright -60
+KPX o quotedblright -50
+KPX o period -30
+KPX o comma -20
+
+KPX p z -10
+KPX p w -15
+KPX p quoteright -50
+KPX p quotedblright -70
+KPX p period -30
+KPX p comma -20
+
+KPX parenleft Y 75
+KPX parenleft W 75
+KPX parenleft V 75
+KPX parenleft T 64
+KPX parenleft J 80
+
+KPX period space -40
+KPX period quoteright -80
+KPX period quotedblright -80
+
+KPX q quoteright -20
+KPX q quotedblright -30
+KPX q period -20
+KPX q comma -10
+
+KPX quotedblleft z -30
+KPX quotedblleft x -40
+KPX quotedblleft w -12
+KPX quotedblleft v -12
+KPX quotedblleft u -12
+KPX quotedblleft t -12
+KPX quotedblleft s -30
+KPX quotedblleft r -12
+KPX quotedblleft q -40
+KPX quotedblleft p -12
+KPX quotedblleft o -30
+KPX quotedblleft n -12
+KPX quotedblleft m -12
+KPX quotedblleft l 10
+KPX quotedblleft k 10
+KPX quotedblleft h 10
+KPX quotedblleft g -30
+KPX quotedblleft e -40
+KPX quotedblleft d -40
+KPX quotedblleft c -40
+KPX quotedblleft b 24
+KPX quotedblleft a -60
+KPX quotedblleft Y 12
+KPX quotedblleft X 28
+KPX quotedblleft W 28
+KPX quotedblleft V 28
+KPX quotedblleft T 36
+KPX quotedblleft A -90
+
+KPX quotedblright space -40
+KPX quotedblright period -100
+KPX quotedblright comma -100
+
+KPX quoteleft z -30
+KPX quoteleft y -10
+KPX quoteleft x -40
+KPX quoteleft w -12
+KPX quoteleft v -12
+KPX quoteleft u -12
+KPX quoteleft t -12
+KPX quoteleft s -30
+KPX quoteleft r -12
+KPX quoteleft quoteleft -18
+KPX quoteleft q -30
+KPX quoteleft p -12
+KPX quoteleft o -30
+KPX quoteleft n -12
+KPX quoteleft m -12
+KPX quoteleft l 10
+KPX quoteleft k 10
+KPX quoteleft h 10
+KPX quoteleft g -30
+KPX quoteleft e -30
+KPX quoteleft d -30
+KPX quoteleft c -30
+KPX quoteleft b 24
+KPX quoteleft a -45
+KPX quoteleft Y 12
+KPX quoteleft X 28
+KPX quoteleft W 28
+KPX quoteleft V 28
+KPX quoteleft T 36
+KPX quoteleft A -90
+
+KPX quoteright v -35
+KPX quoteright t -35
+KPX quoteright space -40
+KPX quoteright s -55
+KPX quoteright r -25
+KPX quoteright quoteright -18
+KPX quoteright period -100
+KPX quoteright m -25
+KPX quoteright l -12
+KPX quoteright d -70
+KPX quoteright comma -100
+
+KPX r y 18
+KPX r w 6
+KPX r v 6
+KPX r t 8
+KPX r quotedblright -15
+KPX r q -24
+KPX r period -120
+KPX r o -6
+KPX r l -20
+KPX r k -20
+KPX r hyphen -30
+KPX r h -20
+KPX r f 8
+KPX r emdash -20
+KPX r e -26
+KPX r d -26
+KPX r comma -110
+KPX r c -12
+KPX r a -20
+
+KPX s quoteright -40
+KPX s quotedblright -45
+
+KPX semicolon space -30
+
+KPX space quotesinglbase -30
+KPX space quoteleft -40
+KPX space quotedblleft -40
+KPX space quotedblbase -30
+KPX space Y -70
+KPX space W -70
+KPX space V -70
+
+KPX t quoteright 10
+KPX t quotedblright -10
+
+KPX u quoteright -55
+KPX u quotedblright -50
+
+KPX v quoteright -20
+KPX v quotedblright -30
+KPX v q -6
+KPX v period -70
+KPX v o -6
+KPX v e -6
+KPX v d -6
+KPX v comma -70
+KPX v c -6
+KPX v a -6
+
+KPX w quoteright -20
+KPX w quotedblright -30
+KPX w period -62
+KPX w comma -62
+
+KPX x y 12
+KPX x w -6
+KPX x quoteright -40
+KPX x quotedblright -50
+KPX x q -6
+KPX x o -6
+KPX x e -6
+KPX x d -6
+KPX x c -6
+
+KPX y quoteright -10
+KPX y quotedblright -20
+KPX y period -70
+KPX y emdash 40
+KPX y comma -60
+
+KPX z quoteright -40
+KPX z quotedblright -50
+KPX z o -6
+KPX z e -6
+KPX z d -6
+KPX z c -6
+EndKernPairs
+EndKernData
+EndFontMetrics

shared/package-files/8b/8bb850c565aa389fdc16f3a46965ad23d82adff60f2393fc2762b63185e8e6c9/blob

@@ -0,0 +1,18 @@
+Copyright (c) 2010-2020 Benjamin Peterson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

shared/package-files/8b/8bba1a38cadd44be6132d04665742d0768d1fe020372a96d73424c64f7931cc6/blob

@@ -0,0 +1,27 @@
+import sys
+from typing import Optional, Union, overload
+from typing_extensions import Literal
+
+if sys.platform == "win32":
+    SND_FILENAME: int
+    SND_ALIAS: int
+    SND_LOOP: int
+    SND_MEMORY: int
+    SND_PURGE: int
+    SND_ASYNC: int
+    SND_NODEFAULT: int
+    SND_NOSTOP: int
+    SND_NOWAIT: int
+
+    MB_ICONASTERISK: int
+    MB_ICONEXCLAMATION: int
+    MB_ICONHAND: int
+    MB_ICONQUESTION: int
+    MB_OK: int
+    def Beep(frequency: int, duration: int) -> None: ...
+    # Can actually accept anything ORed with 4, and if not it's definitely str, but that's inexpressible
+    @overload
+    def PlaySound(sound: Optional[bytes], flags: Literal[4]) -> None: ...
+    @overload
+    def PlaySound(sound: Optional[Union[str, bytes]], flags: int) -> None: ...
+    def MessageBeep(type: int = ...) -> None: ...

shared/package-files/8b/8bbbffb486494564490858800c2c1538ea7fb7d568fda669fdc10bd2570e049f/blob

@@ -0,0 +1,6 @@
+from .cache import Cache as Cache
+from .decorators import cached as cached, cachedmethod as cachedmethod
+from .lfu import LFUCache as LFUCache
+from .lru import LRUCache as LRUCache
+from .rr import RRCache as RRCache
+from .ttl import TTLCache as TTLCache

shared/package-files/8b/8bbc55b991109d8aee328e317ef188d22ce8cc8d6a26f70f3bc0ebeca454d158/blob

@@ -0,0 +1,213 @@
+"""
+    pygments.lexers.fortran
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Fortran languages.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, bygroups, include, words, using, default
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Generic
+
+__all__ = ['FortranLexer', 'FortranFixedLexer']
+
+
+class FortranLexer(RegexLexer):
+    """
+    Lexer for FORTRAN 90 code.
+
+    .. versionadded:: 0.10
+    """
+    name = 'Fortran'
+    url = 'https://fortran-lang.org/'
+    aliases = ['fortran', 'f90']
+    filenames = ['*.f03', '*.f90', '*.F03', '*.F90']
+    mimetypes = ['text/x-fortran']
+    flags = re.IGNORECASE | re.MULTILINE
+
+    # Data Types: INTEGER, REAL, COMPLEX, LOGICAL, CHARACTER and DOUBLE PRECISION
+    # Operators: **, *, +, -, /, <, >, <=, >=, ==, /=
+    # Logical (?): NOT, AND, OR, EQV, NEQV
+
+    # Builtins:
+    # http://gcc.gnu.org/onlinedocs/gcc-3.4.6/g77/Table-of-Intrinsic-Functions.html
+
+    tokens = {
+        'root': [
+            (r'^#.*\n', Comment.Preproc),
+            (r'!.*\n', Comment),
+            include('strings'),
+            include('core'),
+            (r'[a-z][\w$]*', Name),
+            include('nums'),
+            (r'[\s]+', Text.Whitespace),
+        ],
+        'core': [
+            # Statements
+
+            (r'\b(DO)(\s+)(CONCURRENT)\b', bygroups(Keyword, Text.Whitespace, Keyword)),
+            (r'\b(GO)(\s*)(TO)\b', bygroups(Keyword, Text.Whitespace, Keyword)),
+
+            (words((
+                'ABSTRACT', 'ACCEPT', 'ALL', 'ALLSTOP', 'ALLOCATABLE', 'ALLOCATE',
+                'ARRAY', 'ASSIGN', 'ASSOCIATE', 'ASYNCHRONOUS', 'BACKSPACE', 'BIND',
+                'BLOCK', 'BLOCKDATA', 'BYTE', 'CALL', 'CASE', 'CLASS', 'CLOSE',
+                'CODIMENSION', 'COMMON', 'CONTIGUOUS', 'CONTAINS',
+                'CONTINUE', 'CRITICAL', 'CYCLE', 'DATA', 'DEALLOCATE', 'DECODE',
+                'DEFERRED', 'DIMENSION', 'DO', 'ELEMENTAL', 'ELSE', 'ENCODE', 'END',
+                'ENDASSOCIATE', 'ENDBLOCK', 'ENDDO', 'ENDENUM', 'ENDFORALL',
+                'ENDFUNCTION',  'ENDIF', 'ENDINTERFACE', 'ENDMODULE', 'ENDPROGRAM',
+                'ENDSELECT', 'ENDSUBMODULE', 'ENDSUBROUTINE', 'ENDTYPE', 'ENDWHERE',
+                'ENTRY', 'ENUM', 'ENUMERATOR', 'EQUIVALENCE', 'ERROR STOP', 'EXIT',
+                'EXTENDS', 'EXTERNAL', 'EXTRINSIC', 'FILE', 'FINAL', 'FORALL', 'FORMAT',
+                'FUNCTION', 'GENERIC', 'IF', 'IMAGES', 'IMPLICIT',
+                'IMPORT', 'IMPURE', 'INCLUDE', 'INQUIRE', 'INTENT', 'INTERFACE',
+                'INTRINSIC', 'IS', 'LOCK', 'MEMORY', 'MODULE', 'NAMELIST', 'NULLIFY',
+                'NONE', 'NON_INTRINSIC', 'NON_OVERRIDABLE', 'NOPASS', 'ONLY', 'OPEN',
+                'OPTIONAL', 'OPTIONS', 'PARAMETER', 'PASS', 'PAUSE', 'POINTER', 'PRINT',
+                'PRIVATE', 'PROGRAM', 'PROCEDURE', 'PROTECTED', 'PUBLIC', 'PURE', 'READ',
+                'RECURSIVE', 'RESULT', 'RETURN', 'REWIND', 'SAVE', 'SELECT', 'SEQUENCE',
+                'STOP', 'SUBMODULE', 'SUBROUTINE', 'SYNC', 'SYNCALL', 'SYNCIMAGES',
+                'SYNCMEMORY', 'TARGET', 'THEN', 'TYPE', 'UNLOCK', 'USE', 'VALUE',
+                'VOLATILE', 'WHERE', 'WRITE', 'WHILE'), prefix=r'\b', suffix=r'\s*\b'),
+             Keyword),
+
+            # Data Types
+            (words((
+                'CHARACTER', 'COMPLEX', 'DOUBLE PRECISION', 'DOUBLE COMPLEX', 'INTEGER',
+                'LOGICAL', 'REAL', 'C_INT', 'C_SHORT', 'C_LONG', 'C_LONG_LONG',
+                'C_SIGNED_CHAR', 'C_SIZE_T', 'C_INT8_T', 'C_INT16_T', 'C_INT32_T',
+                'C_INT64_T', 'C_INT_LEAST8_T', 'C_INT_LEAST16_T', 'C_INT_LEAST32_T',
+                'C_INT_LEAST64_T', 'C_INT_FAST8_T', 'C_INT_FAST16_T', 'C_INT_FAST32_T',
+                'C_INT_FAST64_T', 'C_INTMAX_T', 'C_INTPTR_T', 'C_FLOAT', 'C_DOUBLE',
+                'C_LONG_DOUBLE', 'C_FLOAT_COMPLEX', 'C_DOUBLE_COMPLEX',
+                'C_LONG_DOUBLE_COMPLEX', 'C_BOOL', 'C_CHAR', 'C_PTR', 'C_FUNPTR'),
+                   prefix=r'\b', suffix=r'\s*\b'),
+             Keyword.Type),
+
+            # Operators
+            (r'(\*\*|\*|\+|-|\/|<|>|<=|>=|==|\/=|=)', Operator),
+
+            (r'(::)', Keyword.Declaration),
+
+            (r'[()\[\],:&%;.]', Punctuation),
+            # Intrinsics
+            (words((
+                'Abort', 'Abs', 'Access', 'AChar', 'ACos', 'ACosH', 'AdjustL',
+                'AdjustR', 'AImag', 'AInt', 'Alarm', 'All', 'Allocated', 'ALog',
+                'AMax', 'AMin', 'AMod', 'And', 'ANInt', 'Any', 'ASin', 'ASinH',
+                'Associated', 'ATan', 'ATanH', 'Atomic_Define', 'Atomic_Ref',
+                'BesJ', 'BesJN', 'Bessel_J0', 'Bessel_J1', 'Bessel_JN', 'Bessel_Y0',
+                'Bessel_Y1', 'Bessel_YN', 'BesY', 'BesYN', 'BGE', 'BGT', 'BLE',
+                'BLT', 'Bit_Size', 'BTest', 'CAbs', 'CCos', 'Ceiling', 'CExp',
+                'Char', 'ChDir', 'ChMod', 'CLog', 'Cmplx', 'Command_Argument_Count',
+                'Complex', 'Conjg', 'Cos', 'CosH', 'Count', 'CPU_Time', 'CShift',
+                'CSin', 'CSqRt', 'CTime', 'C_Loc', 'C_Associated',
+                'C_Null_Ptr', 'C_Null_Funptr', 'C_F_Pointer', 'C_F_ProcPointer',
+                'C_Null_Char', 'C_Alert', 'C_Backspace', 'C_Form_Feed', 'C_FunLoc',
+                'C_Sizeof', 'C_New_Line', 'C_Carriage_Return',
+                'C_Horizontal_Tab', 'C_Vertical_Tab', 'DAbs', 'DACos', 'DASin',
+                'DATan', 'Date_and_Time', 'DbesJ', 'DbesJN', 'DbesY',
+                'DbesYN', 'Dble', 'DCos', 'DCosH', 'DDiM', 'DErF',
+                'DErFC', 'DExp', 'Digits', 'DiM', 'DInt', 'DLog', 'DMax',
+                'DMin', 'DMod', 'DNInt', 'Dot_Product', 'DProd', 'DSign', 'DSinH',
+                'DShiftL', 'DShiftR', 'DSin', 'DSqRt', 'DTanH', 'DTan', 'DTime',
+                'EOShift', 'Epsilon', 'ErF', 'ErFC', 'ErFC_Scaled', 'ETime',
+                'Execute_Command_Line', 'Exit', 'Exp', 'Exponent', 'Extends_Type_Of',
+                'FDate', 'FGet', 'FGetC', 'FindLoc', 'Float', 'Floor', 'Flush',
+                'FNum', 'FPutC', 'FPut', 'Fraction', 'FSeek', 'FStat', 'FTell',
+                'Gamma', 'GError', 'GetArg', 'Get_Command', 'Get_Command_Argument',
+                'Get_Environment_Variable', 'GetCWD', 'GetEnv', 'GetGId', 'GetLog',
+                'GetPId', 'GetUId', 'GMTime', 'HostNm', 'Huge', 'Hypot', 'IAbs',
+                'IAChar', 'IAll', 'IAnd', 'IAny', 'IArgC', 'IBClr', 'IBits',
+                'IBSet', 'IChar', 'IDate', 'IDiM', 'IDInt', 'IDNInt', 'IEOr',
+                'IErrNo', 'IFix', 'Imag', 'ImagPart', 'Image_Index', 'Index',
+                'Int', 'IOr', 'IParity', 'IRand', 'IsaTty', 'IShft', 'IShftC',
+                'ISign', 'Iso_C_Binding', 'Is_Contiguous', 'Is_Iostat_End',
+                'Is_Iostat_Eor', 'ITime', 'Kill', 'Kind', 'LBound', 'LCoBound',
+                'Len', 'Len_Trim', 'LGe', 'LGt', 'Link', 'LLe', 'LLt', 'LnBlnk',
+                'Loc', 'Log', 'Log_Gamma', 'Logical', 'Long', 'LShift', 'LStat',
+                'LTime', 'MaskL', 'MaskR', 'MatMul', 'Max', 'MaxExponent',
+                'MaxLoc', 'MaxVal', 'MClock', 'Merge', 'Merge_Bits', 'Move_Alloc',
+                'Min', 'MinExponent', 'MinLoc', 'MinVal', 'Mod', 'Modulo', 'MvBits',
+                'Nearest', 'New_Line', 'NInt', 'Norm2', 'Not', 'Null', 'Num_Images',
+                'Or', 'Pack', 'Parity', 'PError', 'Precision', 'Present', 'Product',
+                'Radix', 'Rand', 'Random_Number', 'Random_Seed', 'Range', 'Real',
+                'RealPart', 'Rename', 'Repeat', 'Reshape', 'RRSpacing', 'RShift',
+                'Same_Type_As', 'Scale', 'Scan', 'Second', 'Selected_Char_Kind',
+                'Selected_Int_Kind', 'Selected_Real_Kind', 'Set_Exponent', 'Shape',
+                'ShiftA', 'ShiftL', 'ShiftR', 'Short', 'Sign', 'Signal', 'SinH',
+                'Sin', 'Sleep', 'Sngl', 'Spacing', 'Spread', 'SqRt', 'SRand',
+                'Stat', 'Storage_Size', 'Sum', 'SymLnk', 'System', 'System_Clock',
+                'Tan', 'TanH', 'Time', 'This_Image', 'Tiny', 'TrailZ', 'Transfer',
+                'Transpose', 'Trim', 'TtyNam', 'UBound', 'UCoBound', 'UMask',
+                'Unlink', 'Unpack', 'Verify', 'XOr', 'ZAbs', 'ZCos', 'ZExp',
+                'ZLog', 'ZSin', 'ZSqRt'), prefix=r'\b', suffix=r'\s*\b'),
+             Name.Builtin),
+
+            # Booleans
+            (r'\.(true|false)\.', Name.Builtin),
+            # Comparing Operators
+            (r'\.(eq|ne|lt|le|gt|ge|not|and|or|eqv|neqv)\.', Operator.Word),
+        ],
+
+        'strings': [
+            (r'"(\\[0-7]+|\\[^0-7]|[^"\\])*"', String.Double),
+            (r"'(\\[0-7]+|\\[^0-7]|[^'\\])*'", String.Single),
+        ],
+
+        'nums': [
+            (r'\d+(?![.e])(_([1-9]|[a-z]\w*))?', Number.Integer),
+            (r'[+-]?\d*\.\d+([ed][-+]?\d+)?(_([1-9]|[a-z]\w*))?', Number.Float),
+            (r'[+-]?\d+\.\d*([ed][-+]?\d+)?(_([1-9]|[a-z]\w*))?', Number.Float),
+            (r'[+-]?\d+(\.\d*)?[ed][-+]?\d+(_([1-9]|[a-z]\w*))?', Number.Float),
+        ],
+    }
+
+
+class FortranFixedLexer(RegexLexer):
+    """
+    Lexer for fixed format Fortran.
+
+    .. versionadded:: 2.1
+    """
+    name = 'FortranFixed'
+    aliases = ['fortranfixed']
+    filenames = ['*.f', '*.F']
+
+    flags = re.IGNORECASE
+
+    def _lex_fortran(self, match, ctx=None):
+        """Lex a line just as free form fortran without line break."""
+        lexer = FortranLexer()
+        text = match.group(0) + "\n"
+        for index, token, value in lexer.get_tokens_unprocessed(text):
+            value = value.replace('\n', '')
+            if value != '':
+                yield index, token, value
+
+    tokens = {
+        'root': [
+            (r'[C*].*\n', Comment),
+            (r'#.*\n', Comment.Preproc),
+            (r' {0,4}!.*\n', Comment),
+            (r'(.{5})', Name.Label, 'cont-char'),
+            (r'.*\n', using(FortranLexer)),
+        ],
+        'cont-char': [
+            (' ', Text, 'code'),
+            ('0', Comment, 'code'),
+            ('.', Generic.Strong, 'code'),
+        ],
+        'code': [
+            (r'(.{66})(.*)(\n)',
+             bygroups(_lex_fortran, Comment, Text.Whitespace), 'root'),
+            (r'(.*)(\n)', bygroups(_lex_fortran, Text.Whitespace), 'root'),
+            default('root'),
+        ]
+    }

shared/package-files/8b/8bc0648758f4ee980fea922fcc5c45219eee0254757d03826c81e1eefd38c70f/blob

@@ -0,0 +1,9 @@
+from ._typedefs cimport intp_t
+
+from cython cimport floating
+
+cdef int simultaneous_sort(
+    floating *dist,
+    intp_t *idx,
+    intp_t size,
+) noexcept nogil

shared/package-files/8b/8bc0e900307c66122e70a73c96df497d86d000d46f47aeeee7da107f9c229ef8/blob

@@ -0,0 +1,26 @@
+#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.
+     */
+    #if !defined(__AVX512FP16__)
+        #error "HOST/ARCH doesn't support Sapphire Rapids AVX512FP16 features"
+    #endif
+#endif
+
+#include <immintrin.h>
+
+int main(int argc, char **argv)
+{
+/* clang has a bug regarding our spr coode, see gh-23730. */
+#if __clang__
+#error
+#endif
+    __m512h a = _mm512_loadu_ph((void*)argv[argc-1]);
+    __m512h temp = _mm512_fmadd_ph(a, a, a);
+    _mm512_storeu_ph((void*)(argv[argc-1]), temp);
+    return 0;
+}

shared/package-files/8b/8bc152afd712148ae1d7a3bc87b7289bc2cab5df67b0b63cc221214a9935fda6/blob

@@ -0,0 +1,31 @@
+"""
+Charset-Normalizer
+~~~~~~~~~~~~~~
+The Real First Universal Charset Detector.
+A library that helps you read text from an unknown charset encoding.
+Motivated by chardet, This package is trying to resolve the issue by taking a new approach.
+All IANA character set names for which the Python core library provides codecs are supported.
+
+Basic usage:
+   >>> from charset_normalizer import from_bytes
+   >>> results = from_bytes('Bсеки човек има право на образование. Oбразованието трябва да бъде безплатно, поне що се отнася до началното и основното образование.'.encode('utf_8'))
+   >>> "utf_8" in results
+   True
+   >>> best_result = results.best()
+   >>> str(best_result)
+   'Bсеки човек има право на образование. Oбразованието трябва да бъде безплатно, поне що се отнася до началното и основното образование.'
+
+Others methods and usages are available - see the full documentation
+at <https://github.com/Ousret/charset_normalizer>.
+:copyright: (c) 2021 by Ahmed TAHRI
+:license: MIT, see LICENSE for more details.
+"""
+from charset_normalizer.api import from_fp, from_path, from_bytes, normalize
+from charset_normalizer.legacy import detect
+from charset_normalizer.version import __version__, VERSION
+from charset_normalizer.models import CharsetMatch, CharsetMatches
+
+# Backward-compatible v1 imports
+from charset_normalizer.models import CharsetNormalizerMatch
+import charset_normalizer.api as CharsetDetector
+CharsetNormalizerMatches = CharsetDetector

shared/package-files/8b/8bc19c6d27178483db3047bbbae3205ea87f714da6666d9fea1b29220996e6e3/blob

@@ -0,0 +1,35 @@
+from sympy.crypto.crypto import (cycle_list,
+        encipher_shift, encipher_affine, encipher_substitution,
+        check_and_join, encipher_vigenere, decipher_vigenere, bifid5_square,
+        bifid6_square, encipher_hill, decipher_hill,
+        encipher_bifid5, encipher_bifid6, decipher_bifid5,
+        decipher_bifid6, encipher_kid_rsa, decipher_kid_rsa,
+        kid_rsa_private_key, kid_rsa_public_key, decipher_rsa, rsa_private_key,
+        rsa_public_key, encipher_rsa, lfsr_connection_polynomial,
+        lfsr_autocorrelation, lfsr_sequence, encode_morse, decode_morse,
+        elgamal_private_key, elgamal_public_key, decipher_elgamal,
+        encipher_elgamal, dh_private_key, dh_public_key, dh_shared_key,
+        padded_key, encipher_bifid, decipher_bifid, bifid_square, bifid5,
+        bifid6, bifid10, decipher_gm, encipher_gm, gm_public_key,
+        gm_private_key, bg_private_key, bg_public_key, encipher_bg, decipher_bg,
+        encipher_rot13, decipher_rot13, encipher_atbash, decipher_atbash,
+        encipher_railfence, decipher_railfence)
+
+__all__ = [
+    'cycle_list', 'encipher_shift', 'encipher_affine',
+    'encipher_substitution', 'check_and_join', 'encipher_vigenere',
+    'decipher_vigenere', 'bifid5_square', 'bifid6_square', 'encipher_hill',
+    'decipher_hill', 'encipher_bifid5', 'encipher_bifid6', 'decipher_bifid5',
+    'decipher_bifid6', 'encipher_kid_rsa', 'decipher_kid_rsa',
+    'kid_rsa_private_key', 'kid_rsa_public_key', 'decipher_rsa',
+    'rsa_private_key', 'rsa_public_key', 'encipher_rsa',
+    'lfsr_connection_polynomial', 'lfsr_autocorrelation', 'lfsr_sequence',
+    'encode_morse', 'decode_morse', 'elgamal_private_key',
+    'elgamal_public_key', 'decipher_elgamal', 'encipher_elgamal',
+    'dh_private_key', 'dh_public_key', 'dh_shared_key', 'padded_key',
+    'encipher_bifid', 'decipher_bifid', 'bifid_square', 'bifid5', 'bifid6',
+    'bifid10', 'decipher_gm', 'encipher_gm', 'gm_public_key',
+    'gm_private_key', 'bg_private_key', 'bg_public_key', 'encipher_bg',
+    'decipher_bg', 'encipher_rot13', 'decipher_rot13', 'encipher_atbash',
+    'decipher_atbash', 'encipher_railfence', 'decipher_railfence',
+]

shared/package-files/8b/8bc4ba21bd4e4237082c0fa5e2093392d3197b5f1369e50d238f4f2d1a7a3815/blob

@@ -0,0 +1,90 @@
+import functools
+import warnings
+import re
+import textwrap
+import email.message
+
+from ._text import FoldedCase
+from ._compat import pypy_partial
+
+
+# Do not remove prior to 2024-01-01 or Python 3.14
+_warn = functools.partial(
+    warnings.warn,
+    "Implicit None on return values is deprecated and will raise KeyErrors.",
+    DeprecationWarning,
+    stacklevel=pypy_partial(2),
+)
+
+
+class Message(email.message.Message):
+    multiple_use_keys = set(
+        map(
+            FoldedCase,
+            [
+                'Classifier',
+                'Obsoletes-Dist',
+                'Platform',
+                'Project-URL',
+                'Provides-Dist',
+                'Provides-Extra',
+                'Requires-Dist',
+                'Requires-External',
+                'Supported-Platform',
+                'Dynamic',
+            ],
+        )
+    )
+    """
+    Keys that may be indicated multiple times per PEP 566.
+    """
+
+    def __new__(cls, orig: email.message.Message):
+        res = super().__new__(cls)
+        vars(res).update(vars(orig))
+        return res
+
+    def __init__(self, *args, **kwargs):
+        self._headers = self._repair_headers()
+
+    # suppress spurious error from mypy
+    def __iter__(self):
+        return super().__iter__()
+
+    def __getitem__(self, item):
+        """
+        Warn users that a ``KeyError`` can be expected when a
+        mising key is supplied. Ref python/importlib_metadata#371.
+        """
+        res = super().__getitem__(item)
+        if res is None:
+            _warn()
+        return res
+
+    def _repair_headers(self):
+        def redent(value):
+            "Correct for RFC822 indentation"
+            if not value or '\n' not in value:
+                return value
+            return textwrap.dedent(' ' * 8 + value)
+
+        headers = [(key, redent(value)) for key, value in vars(self)['_headers']]
+        if self._payload:
+            headers.append(('Description', self.get_payload()))
+        return headers
+
+    @property
+    def json(self):
+        """
+        Convert PackageMetadata to a JSON-compatible format
+        per PEP 0566.
+        """
+
+        def transform(key):
+            value = self.get_all(key) if key in self.multiple_use_keys else self[key]
+            if key == 'Keywords':
+                value = re.split(r'\s+', value)
+            tk = key.lower().replace('-', '_')
+            return tk, value
+
+        return dict(map(transform, map(FoldedCase, self)))