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

.gitattributes

@@ -445,3 +445,46 @@ shared/package-files/55/5502ad58d22988cf4bf19181ba7bd9639b7b163bebd08a65bad62edd
 shared/package-files/55/55100c41d53c4378900457f83afe3a2a87605598f06b5fe55395011ccabe8376/blob filter=lfs diff=lfs merge=lfs -text
 shared/package-files/55/55aa0e595790ba47863e3b8b60fcac1728af9360017c06ca09049ade495e41e0/blob filter=lfs diff=lfs merge=lfs -text
 shared/package-files/55/55ae261f3d27c23f34f9d4c1328562bf5f4119a0f62d9aad40b37db02800ea92/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/56/56200dff83bb581b078ee68656999e720a8916f51ea86e52ea7123753ac149fd/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/56/563bae0d769e16d7de0c6d77333e35c68f398272b7223c3890bbdfadbc2d0d76/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/56/569318a3168345477b972293d086b9318dbcdb6c79a4df1dbd1f7c57ed7a296e/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/56/56d6740b800583fa54adba6594ef8562832f86d156435527c4a1ca8584653bbe/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/57/573228ba3e53a6349b543fd02f858ce9d8cc2ce2fd7d278f3abe181c245768da/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/57/5756e9ba55f144cc0501b4921eb246c51cded107896b5b8eb62f533ae8783c84/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/57/57890ca757167d3ba732d0e70064b6926101c4e2c67c1bd9c902983d4e7e3f58/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/57/579016d0b705ddc977b1de41f89e134278ae465f9a920372af9a2776cda6ec83/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/57/579e20340ab76800c92d28a1f49c34074abf51a8baf71e38a3faefc89bc666ed/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/58091005c74f9a5e50f535052b35850c04f63a676448efb82c386f3bcf1f849c/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/580af86d75988e8c3fa2caab4352304ca80a276da4145886c6547a7dd929a910/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/58239d2916fb44f8c120a3d2ba7520ac51c7f2851c4e50b428e908661ab9be4c/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/583afcae904440fa8bdcbdc6400bb8a74113970a05b6517bdde3de343600b61e/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/585c091ae1f93828db647470326a379f2bbf69e9f2dc717e0bf5057c0c26f071/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/58839a0f8175fa5bc5b44c2b37effcc9b15679d3ec502d3287ff7d4d29640371/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/5887db851f7f8700e8ccb8252b530ed09632f393ef492c6e0077cc539054fed9/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/58883b24debc2464addc4b82387a5f28c8be816abe44b6b754567a6cca9a2482/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/58ce118d80dfe7d5603a2468ebe311d338125f8e5b766c040f15d723a5f99231/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/58cf984966970134b0e3e965a8ce7ff8eb7aa9a0817d05ef82e53d4ca74422e3/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/58d73aa22d8b83f9c9edacfd13ab8d744fb99e073d480da0e5f6085b6ab1fbb7/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/58e88d0b2dfad21e7382338eb9b556097c726be8c3ebf2d63ceb3decc2c44937/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/58/58e92051889458222282d3a430a2ba3c8a8c816166e5d55601bddb383f15dd93/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/59/591a29ec303b429688277aa34f00fc22c2c7a24a3bdd0b572af323f42c9fe22a/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/59/59255c69bc79fe83b3ef8c3359535d2a4cf723af8848cdf14b4e34afab33828c/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/59/59a674a4ea546a62d9e0fbeb7152b60c2c13c8bdd08935a4c8c6bc8b0df681c7/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/59/59f270823574f9d238d1e55f3f2ea91efbe690b34b4e8a5210ccbfb36d7d0069/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/59/59f839467f2752b7df6fb6d4094396edd32a5929b764f7ffa1e6666431e6cac6/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5a/5a5e8f90a608f84f0592bad0213117ba9b3d056d6dc3feb325965a830f25a3e0/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5a/5a657ad0673dd465f7647e920d9d8d29c519acd034d76f0c00d7617c2012bf1a/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5a/5a788dc1ea57cdca643356628888f191cba7d3b21784bdb8a488132fdc261f78/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5a/5a9bf614151d2ed9c5d0151e52295b0d2266dde627e0e6e58685a622389c8d05/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5b/5b4228e644528d0195d8d2785973637be5c41408166e1e2e9417902b346720f7/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5b/5b451c23149edea31ddcf56270e23494babf7c9137c460d7f50533cd938a83c3/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5b/5b52d319e64c87be4647d770e58fe3509b84f7585dedc99c7411c54d3913d0e4/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5b/5b72231a3ef9e1995615d4b2cf5925df58ba6f8f10d0b8a8eaa692270fb8c8c4/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5b/5bc7d7e94302cd9b94f34d8df5d55a1b35d7eae3ce66372c73726652ff210e89/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5b/5bcae5f2f1671d582e4891073209ec0bfe7e9c9f1f5b81543964080c1e74cd95/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5c/5c2fae37c86e68c3a38605a95f512d7d12d5f3db986310be47f57304aa72a5ee/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5c/5c3c5a4ee1fd1034102b390dc38a2c394d39816de74d7f0430e57263581b30a5/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5c/5ca716cd5632c9b717bb167d187387483b5485fead55f45b25cc44325d5d18ea/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5d/5d213d7fa401bd485e5d1f62c818db510af4d90c544dad78fd421e292c09500a/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5d/5d4e01395b75733e2233105efa95ca8039c3eae40cf10423e89c9487bef60ed0/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/5d/5d7b238a111ba401377e9c0e157730483fa2081ea5badca34b5fd12c67aa1d05/blob filter=lfs diff=lfs merge=lfs -text

shared/package-files/56/561ec7f24a961f85fc6b7557d976765737bdb2bc096af90d1c0671749533fdb9/blob

@@ -0,0 +1,14 @@
+"""
+Render to qt from agg
+"""
+from .. import backends
+
+backends._QT_FORCE_QT5_BINDING = True
+from .backend_qtagg import (    # noqa: F401, E402 # pylint: disable=W0611
+    _BackendQTAgg, FigureCanvasQTAgg, FigureManagerQT, NavigationToolbar2QT,
+    FigureCanvasAgg, FigureCanvasQT)
+
+
+@_BackendQTAgg.export
+class _BackendQT5Agg(_BackendQTAgg):
+    pass

shared/package-files/56/56200dff83bb581b078ee68656999e720a8916f51ea86e52ea7123753ac149fd/blob

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56200dff83bb581b078ee68656999e720a8916f51ea86e52ea7123753ac149fd
+size 342392

shared/package-files/56/562173cf3e5a16d3dc69ef89fd17b99d9aefbd1789fc63443d84f01b855ef8cc/blob

@@ -0,0 +1,47 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/_reshape_copy_ops.h>
+
+namespace at {
+
+
+// aten::_reshape_copy(Tensor self, SymInt[] size) -> Tensor
+inline at::Tensor _reshape_copy(const at::Tensor & self, at::IntArrayRef size) {
+    return at::_ops::_reshape_copy::call(self, c10::fromIntArrayRefSlow(size));
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor _reshape_copy(const at::Tensor & self, at::IntArrayRef size) {
+    return at::_ops::_reshape_copy::call(self, c10::fromIntArrayRefSlow(size));
+  }
+}
+
+// aten::_reshape_copy(Tensor self, SymInt[] size) -> Tensor
+inline at::Tensor _reshape_copy_symint(const at::Tensor & self, c10::SymIntArrayRef size) {
+    return at::_ops::_reshape_copy::call(self, size);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor _reshape_copy(const at::Tensor & self, c10::SymIntArrayRef size) {
+    return at::_ops::_reshape_copy::call(self, size);
+  }
+}
+
+}

shared/package-files/56/5621b7f0f809b08853df1680aee82fc344cf3fa556a0fd95263ec51085b2a648/blob

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import os
+import sys
+from contextlib import suppress
+from errno import ENOSYS
+from typing import cast
+
+from ._api import BaseFileLock
+from ._util import ensure_directory_exists
+
+#: a flag to indicate if the fcntl API is available
+has_fcntl = False
+if sys.platform == "win32":  # pragma: win32 cover
+
+    class UnixFileLock(BaseFileLock):
+        """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
+
+        def _acquire(self) -> None:
+            raise NotImplementedError
+
+        def _release(self) -> None:
+            raise NotImplementedError
+
+else:  # pragma: win32 no cover
+    try:
+        import fcntl
+    except ImportError:
+        pass
+    else:
+        has_fcntl = True
+
+    class UnixFileLock(BaseFileLock):
+        """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
+
+        def _acquire(self) -> None:
+            ensure_directory_exists(self.lock_file)
+            open_flags = os.O_RDWR | os.O_CREAT | os.O_TRUNC
+            fd = os.open(self.lock_file, open_flags, self._context.mode)
+            with suppress(PermissionError):  # This locked is not owned by this UID
+                os.fchmod(fd, self._context.mode)
+            try:
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except OSError as exception:
+                os.close(fd)
+                if exception.errno == ENOSYS:  # NotImplemented error
+                    msg = "FileSystem does not appear to support flock; user SoftFileLock instead"
+                    raise NotImplementedError(msg) from exception
+            else:
+                self._context.lock_file_fd = fd
+
+        def _release(self) -> None:
+            # Do not remove the lockfile:
+            #   https://github.com/tox-dev/py-filelock/issues/31
+            #   https://stackoverflow.com/questions/17708885/flock-removing-locked-file-without-race-condition
+            fd = cast(int, self._context.lock_file_fd)
+            self._context.lock_file_fd = None
+            fcntl.flock(fd, fcntl.LOCK_UN)
+            os.close(fd)
+
+
+__all__ = [
+    "has_fcntl",
+    "UnixFileLock",
+]

shared/package-files/56/56243a12c4fe44781e453d01d2388a4dfbcfe0107b49a7010b64656cd569a966/blob

@@ -0,0 +1,1205 @@
+"""
+Multivariate Conditional and Unconditional Kernel Regression
+with Mixed Data Types
+
+References
+----------
+[1] Racine, J., Li, Q. Nonparametric econometrics: theory and practice.
+    Princeton University Press. (2007)
+[2] Racine, Jeff. "Nonparametric Econometrics: A Primer," Foundation
+    and Trends in Econometrics: Vol 3: No 1, pp1-88. (2008)
+    http://dx.doi.org/10.1561/0800000009
+[3] Racine, J., Li, Q. "Nonparametric Estimation of Distributions
+    with Categorical and Continuous Data." Working Paper. (2000)
+[4] Racine, J. Li, Q. "Kernel Estimation of Multivariate Conditional
+    Distributions Annals of Economics and Finance 5, 211-235 (2004)
+[5] Liu, R., Yang, L. "Kernel estimation of multivariate
+    cumulative distribution function."
+    Journal of Nonparametric Statistics (2008)
+[6] Li, R., Ju, G. "Nonparametric Estimation of Multivariate CDF
+    with Categorical and Continuous Data." Working Paper
+[7] Li, Q., Racine, J. "Cross-validated local linear nonparametric
+    regression" Statistica Sinica 14(2004), pp. 485-512
+[8] Racine, J.: "Consistent Significance Testing for Nonparametric
+        Regression" Journal of Business & Economics Statistics
+[9] Racine, J., Hart, J., Li, Q., "Testing the Significance of
+        Categorical Predictor Variables in Nonparametric Regression
+        Models", 2006, Econometric Reviews 25, 523-544
+
+"""
+
+from statsmodels.compat.pandas import deprecate_kwarg
+
+# TODO: make default behavior efficient=True above a certain n_obs
+import copy
+import warnings
+
+import numpy as np
+from scipy import optimize
+from scipy.stats.mstats import mquantiles
+
+from ._kernel_base import (
+    EstimatorSettings,
+    GenericKDE,
+    LeaveOneOut,
+    _adjust_shape,
+    _compute_min_std_IQR,
+    _get_type_pos,
+    gpke,
+    initialize_generator,
+    kernel_func,
+)
+
+__all__ = ["KernelCensoredReg", "KernelReg"]
+
+
+class KernelReg(GenericKDE):
+    """
+    Nonparametric kernel regression class
+
+    Calculates the conditional mean ``E[y|X]`` where ``y = g(X) + e``.
+    Note that the "local constant" type of regression provided here is also
+    known as Nadaraya-Watson kernel regression; "local linear" is an extension
+    of that which suffers less from bias issues at the edge of the support. Note
+    that specifying a custom kernel works only with "local linear" kernel
+    regression. For example, a custom ``tricube`` kernel yields LOESS regression.
+
+    Parameters
+    ----------
+    endog : array_like
+        This is the dependent variable.
+    exog : array_like
+        The training data for the independent variable(s)
+        Each element in the list is a separate variable
+    var_type : str
+        The type of the variables, one character per variable:
+
+            - c: continuous
+            - u: unordered (discrete)
+            - o: ordered (discrete)
+
+    reg_type : {'lc', 'll'}, optional
+        Type of regression estimator. 'lc' means local constant and
+        'll' local Linear estimator.  Default is 'll'
+    bw : str or array_like, optional
+        Either a user-specified bandwidth or the method for bandwidth
+        selection. If a string, valid values are 'cv_ls' (least-squares
+        cross-validation) and 'aic' (AIC Hurvich bandwidth estimation).
+        Default is 'cv_ls'. User specified bandwidth must have as many
+        entries as the number of variables.
+    ckertype : str, optional
+        The kernel used for the continuous variables.
+    okertype : str, optional
+        The kernel used for the ordered discrete variables.
+    ukertype : str, optional
+        The kernel used for the unordered discrete variables.
+    defaults : EstimatorSettings instance, optional
+        The default values for the efficient bandwidth estimation.
+    rng : int, array_like of int, numpy.random.Generator, or numpy.random.RandomState, optional
+        If `rng` is None, the legacy global (singleton) ``RandomState``
+        provided by ``numpy.random`` is used; this behavior is
+        deprecated and will change to creating a new ``Generator``
+        using fresh entropy from the operating system in a future
+        release. 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.
+
+        .. deprecated:: 0.15.0
+
+            In release 0.17.0 or after January 2028, whichever comes sooner,
+            using None will initialize a new numpy.random.default_rng using
+            system entropy.
+
+    Attributes
+    ----------
+    bw : ndarray
+        The bandwidth parameters.
+    """
+
+    @deprecate_kwarg("seed", "rng")
+    def __init__(
+        self,
+        endog,
+        exog,
+        var_type,
+        reg_type="ll",
+        bw="cv_ls",
+        ckertype="gaussian",
+        okertype="wangryzin",
+        ukertype="aitchisonaitken",
+        defaults=None,
+        *,
+        rng=None,
+    ):
+        self.var_type = var_type
+        self.data_type = var_type
+        self.reg_type = reg_type
+        self.ckertype = ckertype
+        self.okertype = okertype
+        self.ukertype = ukertype
+        if not (
+            self.ckertype in kernel_func
+            and self.ukertype in kernel_func
+            and self.okertype in kernel_func
+        ):
+            raise ValueError(
+                "user specified kernel must be a supported "
+                "kernel from statsmodels.nonparametric.kernels."
+            )
+
+        self.k_vars = len(self.var_type)
+        self.endog = _adjust_shape(endog, 1)
+        self.exog = _adjust_shape(exog, self.k_vars)
+        self.data = np.column_stack((self.endog, self.exog))
+        self.nobs = np.shape(self.exog)[0]
+        self.est = dict(lc=self._est_loc_constant, ll=self._est_loc_linear)
+        defaults = EstimatorSettings() if defaults is None else defaults
+        self._set_defaults(defaults)
+        self.seed = rng
+        self.rng = rng
+        self._generator = initialize_generator(rng)
+        if not isinstance(bw, str):
+            bw = np.asarray(bw)
+            if len(bw) != self.k_vars:
+                raise ValueError(
+                    "bw must have the same dimension as the number of variables."
+                )
+        if not self.efficient:
+            self.bw = self._compute_reg_bw(bw)
+        else:
+            self.bw = self._compute_efficient(bw)
+
+    def _compute_reg_bw(self, bw):
+        if not isinstance(bw, str):
+            self._bw_method = "user-specified"
+            return np.asarray(bw)
+        else:
+            # The user specified a bandwidth selection method e.g., 'cv_ls'
+            self._bw_method = bw
+            # Workaround to avoid instance methods in __dict__
+            if bw == "cv_ls":
+                res = self.cv_loo
+            else:  # bw == 'aic'
+                res = self.aic_hurvich
+            X = np.std(self.exog, axis=0)
+            h0 = 1.06 * X * self.nobs ** (-1.0 / (4 + np.size(self.exog, axis=1)))
+
+            func = self.est[self.reg_type]
+            bw_estimated = optimize.fmin(
+                res, x0=h0, args=(func,), maxiter=1e3, maxfun=1e3, disp=0
+            )
+            return bw_estimated
+
+    def _est_loc_linear(self, bw, endog, exog, data_predict):
+        """
+        Local linear estimator of g(x) in the regression ``y = g(x) + e``
+
+        Parameters
+        ----------
+        bw : array_like
+            Vector of bandwidth value(s).
+        endog : 1D array_like
+            The dependent variable.
+        exog : 1D or 2D array_like
+            The independent variable(s).
+        data_predict : 1D array_like of length K, where K is the number of variables.
+            The point at which the conditional mean is estimated.
+
+        Returns
+        -------
+        mean : ndarray
+            The value of the conditional mean at `data_predict`.
+        mfx : ndarray
+            The marginal effects.
+
+        Notes
+        -----
+        See p. 81 in [1] and p.38 in [2] for the formulas.
+        Unlike other methods, this one requires that `data_predict` be 1D.
+        """
+        nobs, k_vars = exog.shape
+        ker = gpke(
+            bw,
+            data=exog,
+            data_predict=data_predict,
+            var_type=self.var_type,
+            ckertype=self.ckertype,
+            ukertype=self.ukertype,
+            okertype=self.okertype,
+            tosum=False,
+        ) / float(nobs)
+        # Create the matrix on p.492 in [7], after the multiplication w/ K_h,ij
+        # See also p. 38 in [2]
+        # ix_cont = np.arange(self.k_vars)  # Use all vars instead of continuous only
+        # Note: because ix_cont was defined here such that it selected all
+        # columns, I removed the indexing with it from exog/data_predict.
+
+        # Convert ker to a 2-D array to make matrix operations below work
+        ker = ker[:, np.newaxis]
+
+        M12 = exog - data_predict
+        M22 = np.dot(M12.T, M12 * ker)
+        M12 = (M12 * ker).sum(axis=0)
+        M = np.empty((k_vars + 1, k_vars + 1))
+        M[0, 0] = ker.sum()
+        M[0, 1:] = M12
+        M[1:, 0] = M12
+        M[1:, 1:] = M22
+
+        ker_endog = ker * endog
+        V = np.empty((k_vars + 1, 1))
+        V[0, 0] = ker_endog.sum()
+        V[1:, 0] = ((exog - data_predict) * ker_endog).sum(axis=0)
+
+        mean_mfx = np.dot(np.linalg.pinv(M), V)
+        mean = mean_mfx[0]
+        mfx = mean_mfx[1:, :]
+        return mean, mfx
+
+    def _est_loc_constant(self, bw, endog, exog, data_predict):
+        """
+        Local constant estimator of g(x) in the regression
+        y = g(x) + e
+
+        Parameters
+        ----------
+        bw : array_like
+            Array of bandwidth value(s).
+        endog : 1D array_like
+            The dependent variable.
+        exog : 1D or 2D array_like
+            The independent variable(s).
+        data_predict : 1D or 2D array_like
+            The point(s) at which the conditional mean is estimated.
+
+        Returns
+        -------
+        G : ndarray
+            The value of the conditional mean at `data_predict`.
+        B_x : ndarray
+            The marginal effects.
+        """
+        ker_x = gpke(
+            bw,
+            data=exog,
+            data_predict=data_predict,
+            var_type=self.var_type,
+            ckertype=self.ckertype,
+            ukertype=self.ukertype,
+            okertype=self.okertype,
+            tosum=False,
+        )
+        ker_x = np.reshape(ker_x, np.shape(endog))
+        G_numer = (ker_x * endog).sum(axis=0)
+        G_denom = ker_x.sum(axis=0)
+        G = G_numer / G_denom
+        nobs = exog.shape[0]
+        f_x = G_denom / float(nobs)
+        ker_xc = gpke(
+            bw,
+            data=exog,
+            data_predict=data_predict,
+            var_type=self.var_type,
+            ckertype="d_gaussian",
+            # okertype='wangryzin_reg',
+            tosum=False,
+        )
+
+        ker_xc = ker_xc[:, np.newaxis]
+        d_mx = -(endog * ker_xc).sum(axis=0) / float(nobs)  # * np.prod(bw[:, ix_cont]))
+        d_fx = -ker_xc.sum(axis=0) / float(nobs)  # * np.prod(bw[:, ix_cont]))
+        B_x = d_mx / f_x - G * d_fx / f_x
+        B_x = (G_numer * d_fx - G_denom * d_mx) / (G_denom**2)
+        # B_x = (f_x * d_mx - m_x * d_fx) / (f_x ** 2)
+        return G, B_x
+
+    def aic_hurvich(self, bw, func=None):
+        """
+        Computes the AIC Hurvich criteria for the estimation of the bandwidth
+
+        Parameters
+        ----------
+        bw : array_like
+            Vector of bandwidth value(s) at which to evaluate the criterion.
+        func : callable, optional
+            Unused here, needed in signature because it's used in `cv_loo`.
+
+        Returns
+        -------
+        aic : ndarray
+            The value of the AIC Hurvich criterion.
+
+        References
+        ----------
+        See ch.2 in [1] and p.35 in [2].
+        """
+        H = np.empty((self.nobs, self.nobs))
+        for j in range(self.nobs):
+            H[:, j] = gpke(
+                bw,
+                data=self.exog,
+                data_predict=self.exog[j, :],
+                ckertype=self.ckertype,
+                ukertype=self.ukertype,
+                okertype=self.okertype,
+                var_type=self.var_type,
+                tosum=False,
+            )
+
+        denom = H.sum(axis=1)
+        H = H / denom
+        gx = KernelReg(
+            endog=self.endog,
+            exog=self.exog,
+            var_type=self.var_type,
+            reg_type=self.reg_type,
+            bw=bw,
+            defaults=EstimatorSettings(efficient=False),
+        ).fit()[0]
+        gx = np.reshape(gx, (self.nobs, 1))
+        sigma = ((self.endog - gx) ** 2).sum(axis=0) / float(self.nobs)
+
+        frac = (1 + np.trace(H) / float(self.nobs)) / (
+            1 - (np.trace(H) + 2) / float(self.nobs)
+        )
+        # siga = np.dot(self.endog.T, (I - H).T)
+        # sigb = np.dot((I - H), self.endog)
+        # sigma = np.dot(siga, sigb) / float(self.nobs)
+        aic = np.log(sigma) + frac
+        return aic
+
+    def cv_loo(self, bw, func):
+        r"""
+        The cross-validation function with leave-one-out estimator
+
+        Parameters
+        ----------
+        bw : array_like
+            Vector of bandwidth values.
+        func : callable
+            Returns the estimator of g(x).  Can be either ``_est_loc_constant``
+            (local constant) or ``_est_loc_linear`` (local_linear).
+
+        Returns
+        -------
+        L : float
+            The value of the CV function.
+
+        Notes
+        -----
+        Calculates the cross-validation least-squares function. This function
+        is minimized by compute_bw to calculate the optimal value of `bw`.
+
+        For details see p.35 in [2]
+
+        .. math:: CV(h)=n^{-1}\sum_{i=1}^{n}(Y_{i}-g_{-i}(X_{i}))^{2}
+
+        where :math:`g_{-i}(X_{i})` is the leave-one-out estimator of g(X)
+        and :math:`h` is the vector of bandwidths
+        """
+        LOO_X = LeaveOneOut(self.exog)
+        LOO_Y = LeaveOneOut(self.endog).__iter__()
+        L = 0
+        for ii, X_not_i in enumerate(LOO_X):
+            Y = next(LOO_Y)
+            G = func(bw, endog=Y, exog=-X_not_i, data_predict=-self.exog[ii, :])[0]
+            L += (self.endog[ii] - G) ** 2
+
+        # Note: There might be a way to vectorize this. See p.72 in [1]
+        return L / self.nobs
+
+    def r_squared(self):
+        r"""
+        Returns the R-Squared for the nonparametric regression
+
+        Returns
+        -------
+        r2 : float
+            The R-Squared statistic computed from the fitted mean.
+
+        Notes
+        -----
+        For more details see p.45 in [2]
+        The R-Squared is calculated by:
+
+        .. math:: R^{2}=\frac{\left[\sum_{i=1}^{n}
+            (Y_{i}-\bar{y})(\hat{Y_{i}}-\bar{y}\right]^{2}}{\sum_{i=1}^{n}
+            (Y_{i}-\bar{y})^{2}\sum_{i=1}^{n}(\hat{Y_{i}}-\bar{y})^{2}},
+
+        where :math:`\hat{Y_{i}}` is the mean calculated in `fit` at the exog
+        points.
+        """
+        Y = np.squeeze(self.endog)
+        Yhat = self.fit()[0]
+        Y_bar = np.mean(Yhat)
+        R2_numer = (((Y - Y_bar) * (Yhat - Y_bar)).sum()) ** 2
+        R2_denom = ((Y - Y_bar) ** 2).sum(axis=0) * ((Yhat - Y_bar) ** 2).sum(axis=0)
+        return R2_numer / R2_denom
+
+    def fit(self, data_predict=None):
+        """
+        Returns the mean and marginal effects at the `data_predict` points
+
+        Parameters
+        ----------
+        data_predict : array_like, optional
+            Points at which to return the mean and marginal effects.  If not
+            given, ``data_predict == exog``.
+
+        Returns
+        -------
+        mean : ndarray
+            The regression result for the mean (i.e., the actual curve).
+        mfx : ndarray
+            The marginal effects, i.e., the partial derivatives of the mean.
+        """
+        func = self.est[self.reg_type]
+        if data_predict is None:
+            data_predict = self.exog
+        else:
+            data_predict = _adjust_shape(data_predict, self.k_vars)
+
+        N_data_predict = np.shape(data_predict)[0]
+        mean = np.empty((N_data_predict,))
+        mfx = np.empty((N_data_predict, self.k_vars))
+        for i in range(N_data_predict):
+            mean_mfx = func(
+                self.bw, self.endog, self.exog, data_predict=data_predict[i, :]
+            )
+            mean[i] = np.squeeze(mean_mfx[0])
+            mfx_c = np.squeeze(mean_mfx[1])
+            mfx[i, :] = mfx_c
+
+        return mean, mfx
+
+    def sig_test(self, var_pos, nboot=50, nested_res=25, pivot=False):
+        """
+        Significance test for the variables in the regression
+
+        Parameters
+        ----------
+        var_pos : array_like of int
+            The position of the variable in exog to be tested.
+        nboot : int, optional
+            Number of bootstrap samples used to determine the distribution
+            of the test statistic in a finite sample. Default is 50.
+        nested_res : int, optional
+            Number of nested resamples used to calculate lambda when
+            `pivot` is True. Default is 25.
+        pivot : bool, optional
+            Pivot the test statistic by dividing by its standard error.
+            Significantly increases computational time, but pivot
+            statistics have more desirable properties. Default is False.
+
+        Returns
+        -------
+        sig : str
+            The level of significance:
+
+                - `*` : at 90% confidence level
+                - `**` : at 95% confidence level
+                - `***` : at 99% confidence level
+                - "Not Significant" : if not significant
+        """
+        var_pos = np.asarray(var_pos)
+        ix_cont, ix_ord, ix_unord = _get_type_pos(self.var_type)
+        if np.any(ix_cont[var_pos]):
+            if np.any(ix_ord[var_pos]) or np.any(ix_unord[var_pos]):
+                raise ValueError("Discrete variable in hypothesis. Must be continuous")
+
+            Sig = TestRegCoefC(self, var_pos, nboot, nested_res, pivot, rng=self.rng)
+        else:
+            Sig = TestRegCoefD(self, var_pos, nboot, rng=self.rng)
+
+        return Sig.sig
+
+    def __repr__(self):
+        """Provide something sane to print"""
+        rpr = "KernelReg instance\n"
+        rpr += "Number of variables: k_vars = " + str(self.k_vars) + "\n"
+        rpr += "Number of samples:   N = " + str(self.nobs) + "\n"
+        rpr += "Variable types:      " + self.var_type + "\n"
+        rpr += "BW selection method: " + self._bw_method + "\n"
+        rpr += "Estimator type: " + self.reg_type + "\n"
+        return rpr
+
+    def _get_class_vars_type(self):
+        """Helper method to be able to pass needed vars to _compute_subset"""
+        class_type = "KernelReg"
+        class_vars = (self.var_type, self.k_vars, self.reg_type)
+        return class_type, class_vars
+
+    def _compute_dispersion(self, data):
+        """
+        Computes the measure of dispersion
+
+        The minimum of the standard deviation and interquartile range / 1.349
+
+        Parameters
+        ----------
+        data : ndarray
+            The data array, with the dependent variable in the first column
+            and the independent variables in the remaining columns.
+
+        Returns
+        -------
+        ndarray
+            The minimum of the standard deviation and IQR / 1.349 for each
+            independent variable.
+
+        References
+        ----------
+        See the user guide for the np package in R.
+        In the notes on bwscaling option in npreg, npudens, npcdens there is
+        a discussion on the measure of dispersion
+        """
+        data = data[:, 1:]
+        return _compute_min_std_IQR(data)
+
+
+class KernelCensoredReg(KernelReg):
+    """
+    Nonparametric censored regression
+
+    Calculates the conditional mean ``E[y|X]`` where ``y = g(X) + e``,
+    where y is left-censored.  Left censored variable Y is defined as
+    ``Y = min {Y', L}`` where ``L`` is the value at which ``Y`` is censored
+    and ``Y'`` is the true value of the variable.
+
+    Parameters
+    ----------
+    endog : array_like
+        This is the dependent variable.
+    exog : array_like
+        The training data for the independent variable(s)
+        Each element in the list is a separate variable
+    var_type : str
+        The type of the variables, one character per variable:
+
+            - c: Continuous
+            - u: Unordered (Discrete)
+            - o: Ordered (Discrete)
+
+    reg_type : str
+        Type of regression estimator
+
+            - lc: Local Constant Estimator
+            - ll: Local Linear Estimator
+
+    bw : str or array_like, optional
+        Either a user-specified bandwidth or
+        the method for bandwidth selection.
+
+            - cv_ls: cross-validation least squares
+            - aic: AIC Hurvich Estimator
+
+    ckertype : str, optional
+        The kernel used for the continuous variables.
+    okertype : str, optional
+        The kernel used for the ordered discrete variables.
+    ukertype : str, optional
+        The kernel used for the unordered discrete variables.
+    censor_val : float, optional
+        Value at which the dependent variable is censored. Default is 0.
+    defaults : EstimatorSettings instance, optional
+        The default values for the efficient bandwidth estimation
+    rng : int, array_like of int, numpy.random.Generator, or numpy.random.RandomState, optional
+        If `rng` is None, the legacy global (singleton) ``RandomState``
+        provided by ``numpy.random`` is used; this behavior is
+        deprecated and will change to creating a new ``Generator``
+        using fresh entropy from the operating system in a future
+        release. 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.
+
+        .. deprecated:: 0.15.0
+
+            In release 0.17.0 or after January 2028, whichever comes sooner,
+            using None will initialize a new numpy.random.default_rng using
+            system entropy.
+
+    Attributes
+    ----------
+    bw : ndarray
+        The bandwidth parameters
+    """
+
+    @deprecate_kwarg("seed", "rng")
+    def __init__(
+        self,
+        endog,
+        exog,
+        var_type,
+        reg_type,
+        bw="cv_ls",
+        ckertype="gaussian",
+        ukertype="aitchison_aitken_reg",
+        okertype="wangryzin_reg",
+        censor_val=0,
+        defaults=None,
+        *,
+        rng=None,
+    ):
+        self.var_type = var_type
+        self.data_type = var_type
+        self.reg_type = reg_type
+        self.ckertype = ckertype
+        self.okertype = okertype
+        self.ukertype = ukertype
+        if not (
+            self.ckertype in kernel_func
+            and self.ukertype in kernel_func
+            and self.okertype in kernel_func
+        ):
+            raise ValueError(
+                "user specified kernel must be a supported "
+                "kernel from statsmodels.nonparametric.kernels."
+            )
+
+        self.k_vars = len(self.var_type)
+        self.endog = _adjust_shape(endog, 1)
+        self.exog = _adjust_shape(exog, self.k_vars)
+        self.data = np.column_stack((self.endog, self.exog))
+        self.nobs = np.shape(self.exog)[0]
+        self.est = dict(lc=self._est_loc_constant, ll=self._est_loc_linear)
+        self._generator = initialize_generator(rng)
+        defaults = EstimatorSettings() if defaults is None else defaults
+        self._set_defaults(defaults)
+        self.censor_val = censor_val
+        if self.censor_val is not None:
+            self.censored(censor_val)
+        else:
+            self.W_in = np.ones((self.nobs, 1))
+
+        if not self.efficient:
+            self.bw = self._compute_reg_bw(bw)
+        else:
+            self.bw = self._compute_efficient(bw)
+
+    def censored(self, censor_val):
+        # see pp. 341-344 in [1]
+        self.d = (self.endog != censor_val) * 1.0
+        ix = np.argsort(np.squeeze(self.endog))
+        self.sortix = ix
+        self.sortix_rev = np.zeros(ix.shape, int)
+        self.sortix_rev[ix] = np.arange(len(ix))
+        self.endog = np.squeeze(self.endog[ix])
+        self.endog = _adjust_shape(self.endog, 1)
+        self.exog = np.squeeze(self.exog[ix])
+        self.d = np.squeeze(self.d[ix])
+        self.W_in = np.empty((self.nobs, 1))
+        for i in range(1, self.nobs + 1):
+            P = 1
+            for j in range(1, i):
+                P *= ((self.nobs - j) / (float(self.nobs) - j + 1)) ** self.d[j - 1]
+            self.W_in[i - 1, 0] = P * self.d[i - 1] / (float(self.nobs) - i + 1)
+
+    def __repr__(self):
+        """Provide something sane to print"""
+        rpr = "KernelCensoredReg instance\n"
+        rpr += "Number of variables: k_vars = " + str(self.k_vars) + "\n"
+        rpr += "Number of samples:   nobs = " + str(self.nobs) + "\n"
+        rpr += "Variable types:      " + self.var_type + "\n"
+        rpr += "BW selection method: " + self._bw_method + "\n"
+        rpr += "Estimator type: " + self.reg_type + "\n"
+        return rpr
+
+    def _est_loc_linear(self, bw, endog, exog, data_predict, W):
+        """
+        Local linear estimator of g(x) in the regression ``y = g(x) + e``
+
+        Parameters
+        ----------
+        bw : array_like
+            Vector of bandwidth value(s)
+        endog : 1D array_like
+            The dependent variable
+        exog : 1D or 2D array_like
+            The independent variable(s)
+        data_predict : 1D array_like of length K, where K is
+            the number of variables. The point at which
+            the conditional mean is estimated
+        W : array_like
+            The weights used to account for the censoring, as computed by
+            `censored`.
+
+        Returns
+        -------
+        mean : ndarray
+            The value of the conditional mean at data_predict
+        mfx : ndarray
+            The marginal effects.
+
+        Notes
+        -----
+        See p. 81 in [1] and p.38 in [2] for the formulas
+        Unlike other methods, this one requires that data_predict be 1D
+        """
+        nobs, k_vars = exog.shape
+        ker = gpke(
+            bw,
+            data=exog,
+            data_predict=data_predict,
+            var_type=self.var_type,
+            ckertype=self.ckertype,
+            ukertype=self.ukertype,
+            okertype=self.okertype,
+            tosum=False,
+        )
+        # Create the matrix on p.492 in [7], after the multiplication w/ K_h,ij
+        # See also p. 38 in [2]
+
+        # Convert ker to a 2-D array to make matrix operations below work
+        ker = W * ker[:, np.newaxis]
+
+        M12 = exog - data_predict
+        M22 = np.dot(M12.T, M12 * ker)
+        M12 = (M12 * ker).sum(axis=0)
+        M = np.empty((k_vars + 1, k_vars + 1))
+        M[0, 0] = ker.sum()
+        M[0, 1:] = M12
+        M[1:, 0] = M12
+        M[1:, 1:] = M22
+
+        ker_endog = ker * endog
+        V = np.empty((k_vars + 1, 1))
+        V[0, 0] = ker_endog.sum()
+        V[1:, 0] = ((exog - data_predict) * ker_endog).sum(axis=0)
+
+        mean_mfx = np.dot(np.linalg.pinv(M), V)
+        mean = mean_mfx[0]
+        mfx = mean_mfx[1:, :]
+        return mean, mfx
+
+    def cv_loo(self, bw, func):
+        r"""
+        The cross-validation function with leave-one-out
+        estimator
+
+        Parameters
+        ----------
+        bw : array_like
+            Vector of bandwidth values
+        func : callable
+            Returns the estimator of g(x).
+            Can be either ``_est_loc_constant`` (local constant) or
+            ``_est_loc_linear`` (local_linear).
+
+        Returns
+        -------
+        L : float
+            The value of the CV function
+
+        Notes
+        -----
+        Calculates the cross-validation least-squares
+        function. This function is minimized by compute_bw
+        to calculate the optimal value of bw
+
+        For details see p.35 in [2]
+
+        .. math:: CV(h)=n^{-1}\sum_{i=1}^{n}(Y_{i}-g_{-i}(X_{i}))^{2}
+
+        where :math:`g_{-i}(X_{i})` is the leave-one-out estimator of g(X)
+        and :math:`h` is the vector of bandwidths
+        """
+        LOO_X = LeaveOneOut(self.exog)
+        LOO_Y = LeaveOneOut(self.endog).__iter__()
+        LOO_W = LeaveOneOut(self.W_in).__iter__()
+        L = 0
+        for ii, X_not_i in enumerate(LOO_X):
+            Y = next(LOO_Y)
+            w = next(LOO_W)
+            G = func(bw, endog=Y, exog=-X_not_i, data_predict=-self.exog[ii, :], W=w)[0]
+            L += (self.endog[ii] - G) ** 2
+
+        # Note: There might be a way to vectorize this. See p.72 in [1]
+        return L / self.nobs
+
+    def fit(self, data_predict=None):
+        """
+        Returns the mean and marginal effects at the `data_predict` points
+
+        Parameters
+        ----------
+        data_predict : array_like, optional
+            Points at which to return the mean and marginal effects.  If not
+            given, ``data_predict == exog``.
+
+        Returns
+        -------
+        mean : ndarray
+            The regression result for the mean (i.e., the actual curve).
+        mfx : ndarray
+            The marginal effects, i.e., the partial derivatives of the mean.
+        """
+        func = self.est[self.reg_type]
+        if data_predict is None:
+            data_predict = self.exog
+        else:
+            data_predict = _adjust_shape(data_predict, self.k_vars)
+
+        N_data_predict = np.shape(data_predict)[0]
+        mean = np.empty((N_data_predict,))
+        mfx = np.empty((N_data_predict, self.k_vars))
+        for i in range(N_data_predict):
+            mean_mfx = func(
+                self.bw,
+                self.endog,
+                self.exog,
+                data_predict=data_predict[i, :],
+                W=self.W_in,
+            )
+            mean[i] = np.squeeze(mean_mfx[0])
+            mfx_c = np.squeeze(mean_mfx[1])
+            mfx[i, :] = mfx_c
+
+        return mean, mfx
+
+
+class TestRegCoefC:
+    """
+    Significance test for continuous variables in a nonparametric regression
+
+    The null hypothesis is ``dE(Y|X)/dX_not_i = 0``, the alternative hypothesis
+    is ``dE(Y|X)/dX_not_i != 0``.
+
+    Parameters
+    ----------
+    model : KernelReg instance
+        This is the nonparametric regression model whose elements
+        are tested for significance.
+    test_vars : sequence of int
+        index of position of the continuous variables to be tested
+        for significance. e.g., (1,3,5) jointly tests variables at
+        position 1,3 and 5 for significance.
+    nboot : int, optional
+        Number of bootstrap samples used to determine the distribution
+        of the test statistic in a finite sample. Default is 400
+    nested_res : int, optional
+        Number of nested resamples used to calculate lambda. Default is 400.
+        Must enable the pivot option
+    pivot : bool, optional
+        Pivot the test statistic by dividing by its standard error
+        Significantly increases computational time. But pivot statistics
+        have more desirable properties
+        (See references). Default is False.
+    rng : int, array_like of int, numpy.random.Generator, or numpy.random.RandomState, optional
+        If `rng` is None, the legacy global (singleton) ``RandomState``
+        provided by ``numpy.random`` is used; this behavior is
+        deprecated and will change to creating a new ``Generator``
+        using fresh entropy from the operating system in a future
+        release. 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.
+
+        .. deprecated:: 0.15.0
+
+            In release 0.17.0 or after January 2028, whichever comes sooner,
+            using None will initialize a new numpy.random.default_rng using
+            system entropy.
+
+    Attributes
+    ----------
+    sig : str
+        The significance level of the variable(s) tested
+        "Not Significant": Not significant at the 90% confidence level
+                            Fails to reject the null
+        "*": Significant at the 90% confidence level
+        "**": Significant at the 95% confidence level
+        "***": Significant at the 99% confidence level
+
+    Notes
+    -----
+    This class allows testing of joint hypothesis as long as all variables
+    are continuous.
+
+    References
+    ----------
+    Racine, J.: "Consistent Significance Testing for Nonparametric Regression"
+    Journal of Business & Economics Statistics.
+
+    Chapter 12 in [1].
+    """
+
+    # Significance of continuous vars in nonparametric regression
+    # Racine: Consistent Significance Testing for Nonparametric Regression
+    # Journal of Business & Economics Statistics
+    @deprecate_kwarg("seed", "rng")
+    def __init__(
+        self, model, test_vars, nboot=400, nested_res=400, pivot=False, rng=None
+    ):
+        self.nboot = nboot
+        self.nres = nested_res
+        self.test_vars = test_vars
+        self.model = model
+        self.bw = model.bw
+        self.var_type = model.var_type
+        self.k_vars = len(self.var_type)
+        self.endog = model.endog
+        self.exog = model.exog
+        self.gx = model.est[model.reg_type]
+        self.test_vars = test_vars
+        self.pivot = pivot
+        self._generator = initialize_generator(rng)
+        self.run()
+
+    def run(self):
+        self.test_stat = self._compute_test_stat(self.endog, self.exog)
+        self.sig = self._compute_sig()
+
+    def _compute_test_stat(self, Y, X):
+        """
+        Computes the test statistic
+
+        See p.371 in [8].
+        """
+        lam = self._compute_lambda(Y, X)
+        t = lam
+        if self.pivot:
+            se_lam = self._compute_se_lambda(Y, X)
+            t = lam / float(se_lam)
+
+        return t
+
+    def _compute_lambda(self, Y, X):
+        """Computes only lambda -- the main part of the test statistic"""
+        n = np.shape(X)[0]
+        Y = _adjust_shape(Y, 1)
+        X = _adjust_shape(X, self.k_vars)
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                category=FutureWarning,
+            )
+            b = KernelReg(
+                Y,
+                X,
+                self.var_type,
+                self.model.reg_type,
+                self.bw,
+                defaults=EstimatorSettings(efficient=False),
+            ).fit()[1]
+
+        b = b[:, self.test_vars]
+        b = np.reshape(b, (n, len(self.test_vars)))
+        # fct = np.std(b)  # Pivot the statistic by dividing by SE
+        fct = 1.0  # Do not Pivot -- Bootstrapping works better if Pivot
+        lam = ((b / fct) ** 2).sum() / float(n)
+        return lam
+
+    def _compute_se_lambda(self, Y, X):
+        """
+        Calculates the SE of lambda by nested resampling
+        Used to pivot the statistic.
+        Bootstrapping works better with estimating pivotal statistics
+        but slows down computation significantly.
+        """
+        n = np.shape(Y)[0]
+        lam = np.empty(shape=(self.nres,))
+        for i in range(self.nres):
+            ind = self._integers(0, n, size=(n, 1))
+            Y1 = Y[ind, 0]
+            X1 = X[ind, :]
+            lam[i] = self._compute_lambda(Y1, X1)
+
+        se_lambda = np.std(lam)
+        return se_lambda
+
+    def _compute_sig(self):
+        """
+        Computes the significance value for the variable(s) tested
+
+        The empirical distribution of the test statistic is obtained through
+        bootstrapping the sample.  The null hypothesis is rejected if the test
+        statistic is larger than the 90, 95, 99 percentiles.
+        """
+        t_dist = np.empty(shape=(self.nboot,))
+        Y = self.endog
+        X = copy.deepcopy(self.exog)
+        n = np.shape(Y)[0]
+
+        X[:, self.test_vars] = np.mean(X[:, self.test_vars], axis=0)
+        # Calculate the restricted mean. See p. 372 in [8]
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                category=FutureWarning,
+            )
+            M = KernelReg(
+                Y,
+                X,
+                self.var_type,
+                self.model.reg_type,
+                self.bw,
+                defaults=EstimatorSettings(efficient=False),
+            ).fit()[0]
+        M = np.reshape(M, (n, 1))
+        e = Y - M
+        e = e - np.mean(e)  # recenter residuals
+        for i in range(self.nboot):
+            ind = self._integers(0, n, size=(n, 1))
+            e_boot = e[ind, 0]
+            Y_boot = M + e_boot
+            t_dist[i] = self._compute_test_stat(Y_boot, self.exog)
+
+        self.t_dist = t_dist
+        sig = "Not Significant"
+        if self.test_stat > mquantiles(t_dist, 0.9):
+            sig = "*"
+        if self.test_stat > mquantiles(t_dist, 0.95):
+            sig = "**"
+        if self.test_stat > mquantiles(t_dist, 0.99):
+            sig = "***"
+
+        return sig
+
+    def _integers(self, low: int, upper: int, size: tuple[int, int]):
+        if self._generator is None:
+            return np.random.randint(low, upper, size=size)
+        elif isinstance(self._generator, np.random.RandomState):
+            return self._generator.randint(low, upper, size=size)
+        else:
+            return self._generator.integers(low, upper, size=size)
+
+    def _uniform(self, low: float, upper: float, size: tuple[int, int]):
+        if self._generator is None:
+            return np.random.uniform(low, upper, size=size)
+        return self._generator.uniform(low, upper, size=size)
+
+
+class TestRegCoefD(TestRegCoefC):
+    """
+    Significance test for the categorical variables in a nonparametric
+    regression
+
+    Parameters
+    ----------
+    model : Instance of KernelReg class
+        This is the nonparametric regression model whose elements
+        are tested for significance.
+    test_vars : sequence of int
+        index of position of the discrete variable to be tested
+        for significance. e.g., (3) tests variable at
+        position 3 for significance.
+    nboot : int, optional
+        Number of bootstrap samples used to determine the distribution
+        of the test statistic in a finite sample. Default is 400
+    rng : int, array_like of int, numpy.random.Generator, or numpy.random.RandomState, optional
+        If `rng` is None, the legacy global (singleton) ``RandomState``
+        provided by ``numpy.random`` is used; this behavior is
+        deprecated and will change to creating a new ``Generator``
+        using fresh entropy from the operating system in a future
+        release. 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.
+
+        .. deprecated:: 0.15.0
+
+            In release 0.17.0 or after January 2028, whichever comes sooner,
+            using None will initialize a new numpy.random.default_rng using
+            system entropy.
+
+    Attributes
+    ----------
+    sig : str
+        The significance level of the variable(s) tested
+        "Not Significant": Not significant at the 90% confidence level
+                            Fails to reject the null
+        "*": Significant at the 90% confidence level
+        "**": Significant at the 95% confidence level
+        "***": Significant at the 99% confidence level
+
+    Notes
+    -----
+    This class currently does not allow joint hypothesis.
+    Only one variable can be tested at a time
+
+    References
+    ----------
+    See [9] and chapter 12 in [1].
+    """
+
+    def _compute_test_stat(self, Y, X):
+        """Computes the test statistic"""
+
+        dom_x = np.sort(np.unique(self.exog[:, self.test_vars]))
+
+        n = np.shape(X)[0]
+        model = KernelReg(
+            Y,
+            X,
+            self.var_type,
+            self.model.reg_type,
+            self.bw,
+            defaults=EstimatorSettings(efficient=False),
+            rng=self._generator,
+        )
+        X1 = copy.deepcopy(X)
+        X1[:, self.test_vars] = 0
+
+        m0 = model.fit(data_predict=X1)[0]
+        m0 = np.reshape(m0, (n, 1))
+        zvec = np.zeros((n, 1))
+        for i in dom_x[1:]:
+            X1[:, self.test_vars] = i
+            m1 = model.fit(data_predict=X1)[0]
+            m1 = np.reshape(m1, (n, 1))
+            zvec += (m1 - m0) ** 2
+
+        avg = zvec.sum(axis=0) / float(n)
+        return avg
+
+    def _compute_sig(self):
+        """Calculates the significance level of the variable tested"""
+
+        m = self._est_cond_mean()
+        Y = self.endog
+        X = self.exog
+        n = np.shape(X)[0]
+        u = Y - m
+        u = u - np.mean(u)  # center
+        fct1 = (1 - 5**0.5) / 2.0
+        fct2 = (1 + 5**0.5) / 2.0
+        u1 = fct1 * u
+        u2 = fct2 * u
+        r = fct2 / (5**0.5)
+        I_dist = np.empty((self.nboot, 1))
+        for j in range(self.nboot):
+            u_boot = copy.deepcopy(u2)
+
+            prob = self._uniform(0, 1, size=(n, 1))
+            ind = prob < r
+            u_boot[ind] = u1[ind]
+            Y_boot = m + u_boot
+            I_dist[j] = self._compute_test_stat(Y_boot, X)
+
+        sig = "Not Significant"
+        if self.test_stat > mquantiles(I_dist, 0.9):
+            sig = "*"
+        if self.test_stat > mquantiles(I_dist, 0.95):
+            sig = "**"
+        if self.test_stat > mquantiles(I_dist, 0.99):
+            sig = "***"
+
+        return sig
+
+    def _est_cond_mean(self):
+        """
+        Calculates the expected conditional mean
+        m(X, Z=l) for all possible l
+        """
+        self.dom_x = np.sort(np.unique(self.exog[:, self.test_vars]))
+        X = copy.deepcopy(self.exog)
+        m = 0
+        for i in self.dom_x:
+            X[:, self.test_vars] = i
+            m += self.model.fit(data_predict=X)[0]
+
+        m = m / float(len(self.dom_x))
+        m = np.reshape(m, (np.shape(self.exog)[0], 1))
+        return m

shared/package-files/56/5625ccbe57902084adaae1cdd350a94d43d8c6ede3802e7b19a08e92e5d1b285/blob

@@ -0,0 +1,841 @@
+from .accumulationbounds import AccumBounds, AccumulationBounds # noqa: F401
+from .singularities import singularities
+from sympy.core import Pow, S
+from sympy.core.function import diff, expand_mul
+from sympy.core.kind import NumberKind
+from sympy.core.mod import Mod
+from sympy.core.numbers import equal_valued
+from sympy.core.relational import Relational
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.complexes import Abs, im, re
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (
+    TrigonometricFunction, sin, cos, csc, sec)
+from sympy.polys.polytools import degree, lcm_list
+from sympy.sets.sets import (Interval, Intersection, FiniteSet, Union,
+                             Complement)
+from sympy.sets.fancysets import ImageSet
+from sympy.utilities import filldedent
+from sympy.utilities.iterables import iterable
+
+
+def continuous_domain(f, symbol, domain):
+    """
+    Returns the intervals in the given domain for which the function
+    is continuous.
+    This method is limited by the ability to determine the various
+    singularities and discontinuities of the given function.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the intervals are to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the continuity of the symbol has to be checked.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, tan, log, pi, sqrt
+    >>> from sympy.calculus.util import continuous_domain
+    >>> x = Symbol('x')
+    >>> continuous_domain(1/x, x, S.Reals)
+    Union(Interval.open(-oo, 0), Interval.open(0, oo))
+    >>> continuous_domain(tan(x), x, Interval(0, pi))
+    Union(Interval.Ropen(0, pi/2), Interval.Lopen(pi/2, pi))
+    >>> continuous_domain(sqrt(x - 2), x, Interval(-5, 5))
+    Interval(2, 5)
+    >>> continuous_domain(log(2*x - 1), x, S.Reals)
+    Interval.open(1/2, oo)
+
+    Returns
+    =======
+
+    :py:class:`~.Interval`
+        Union of all intervals where the function is continuous.
+
+    Raises
+    ======
+
+    NotImplementedError
+        If the method to determine continuity of such a function
+        has not yet been developed.
+
+    """
+    from sympy.solvers.inequalities import solve_univariate_inequality
+
+    if domain.is_subset(S.Reals):
+        constrained_interval = domain
+        for atom in f.atoms(Pow):
+            den = atom.exp.as_numer_denom()[1]
+            if den.is_even and den.is_nonzero:
+                constraint = solve_univariate_inequality(atom.base >= 0,
+                                                         symbol).as_set()
+                constrained_interval = Intersection(constraint,
+                                                    constrained_interval)
+
+        for atom in f.atoms(log):
+            constraint = solve_univariate_inequality(atom.args[0] > 0,
+                                                     symbol).as_set()
+            constrained_interval = Intersection(constraint,
+                                                constrained_interval)
+
+
+    return constrained_interval - singularities(f, symbol, domain)
+
+
+def function_range(f, symbol, domain):
+    """
+    Finds the range of a function in a given domain.
+    This method is limited by the ability to determine the singularities and
+    determine limits.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the range of function is to be determined.
+    domain : :py:class:`~.Interval`
+        The domain under which the range of the function has to be found.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, exp, log, pi, sqrt, sin, tan
+    >>> from sympy.calculus.util import function_range
+    >>> x = Symbol('x')
+    >>> function_range(sin(x), x, Interval(0, 2*pi))
+    Interval(-1, 1)
+    >>> function_range(tan(x), x, Interval(-pi/2, pi/2))
+    Interval(-oo, oo)
+    >>> function_range(1/x, x, S.Reals)
+    Union(Interval.open(-oo, 0), Interval.open(0, oo))
+    >>> function_range(exp(x), x, S.Reals)
+    Interval.open(0, oo)
+    >>> function_range(log(x), x, S.Reals)
+    Interval(-oo, oo)
+    >>> function_range(sqrt(x), x, Interval(-5, 9))
+    Interval(0, 3)
+
+    Returns
+    =======
+
+    :py:class:`~.Interval`
+        Union of all ranges for all intervals under domain where function is
+        continuous.
+
+    Raises
+    ======
+
+    NotImplementedError
+        If any of the intervals, in the given domain, for which function
+        is continuous are not finite or real,
+        OR if the critical points of the function on the domain cannot be found.
+    """
+
+    if domain is S.EmptySet:
+        return S.EmptySet
+
+    period = periodicity(f, symbol)
+    if period == S.Zero:
+        # the expression is constant wrt symbol
+        return FiniteSet(f.expand())
+
+    from sympy.series.limits import limit
+    from sympy.solvers.solveset import solveset
+
+    if period is not None:
+        if isinstance(domain, Interval):
+            if (domain.inf - domain.sup).is_infinite:
+                domain = Interval(0, period)
+        elif isinstance(domain, Union):
+            for sub_dom in domain.args:
+                if isinstance(sub_dom, Interval) and \
+                ((sub_dom.inf - sub_dom.sup).is_infinite):
+                    domain = Interval(0, period)
+
+    intervals = continuous_domain(f, symbol, domain)
+    range_int = S.EmptySet
+    if isinstance(intervals,(Interval, FiniteSet)):
+        interval_iter = (intervals,)
+
+    elif isinstance(intervals, Union):
+        interval_iter = intervals.args
+
+    else:
+            raise NotImplementedError(filldedent('''
+                Unable to find range for the given domain.
+                '''))
+
+    for interval in interval_iter:
+        if isinstance(interval, FiniteSet):
+            for singleton in interval:
+                if singleton in domain:
+                    range_int += FiniteSet(f.subs(symbol, singleton))
+        elif isinstance(interval, Interval):
+            vals = S.EmptySet
+            critical_points = S.EmptySet
+            critical_values = S.EmptySet
+            bounds = ((interval.left_open, interval.inf, '+'),
+                   (interval.right_open, interval.sup, '-'))
+
+            for is_open, limit_point, direction in bounds:
+                if is_open:
+                    critical_values += FiniteSet(limit(f, symbol, limit_point, direction))
+                    vals += critical_values
+
+                else:
+                    vals += FiniteSet(f.subs(symbol, limit_point))
+
+            solution = solveset(f.diff(symbol), symbol, interval)
+
+            if not iterable(solution):
+                raise NotImplementedError(
+                        'Unable to find critical points for {}'.format(f))
+            if isinstance(solution, ImageSet):
+                raise NotImplementedError(
+                        'Infinite number of critical points for {}'.format(f))
+
+            critical_points += solution
+
+            for critical_point in critical_points:
+                vals += FiniteSet(f.subs(symbol, critical_point))
+
+            left_open, right_open = False, False
+
+            if critical_values is not S.EmptySet:
+                if critical_values.inf == vals.inf:
+                    left_open = True
+
+                if critical_values.sup == vals.sup:
+                    right_open = True
+
+            range_int += Interval(vals.inf, vals.sup, left_open, right_open)
+        else:
+            raise NotImplementedError(filldedent('''
+                Unable to find range for the given domain.
+                '''))
+
+    return range_int
+
+
+def not_empty_in(finset_intersection, *syms):
+    """
+    Finds the domain of the functions in ``finset_intersection`` in which the
+    ``finite_set`` is not-empty.
+
+    Parameters
+    ==========
+
+    finset_intersection : Intersection of FiniteSet
+        The unevaluated intersection of FiniteSet containing
+        real-valued functions with Union of Sets
+    syms : Tuple of symbols
+        Symbol for which domain is to be found
+
+    Raises
+    ======
+
+    NotImplementedError
+        The algorithms to find the non-emptiness of the given FiniteSet are
+        not yet implemented.
+    ValueError
+        The input is not valid.
+    RuntimeError
+        It is a bug, please report it to the github issue tracker
+        (https://github.com/sympy/sympy/issues).
+
+    Examples
+    ========
+
+    >>> from sympy import FiniteSet, Interval, not_empty_in, oo
+    >>> from sympy.abc import x
+    >>> not_empty_in(FiniteSet(x/2).intersect(Interval(0, 1)), x)
+    Interval(0, 2)
+    >>> not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x)
+    Union(Interval(1, 2), Interval(-sqrt(2), -1))
+    >>> not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x)
+    Union(Interval.Lopen(-2, -1), Interval(2, oo))
+    """
+
+    # TODO: handle piecewise defined functions
+    # TODO: handle transcendental functions
+    # TODO: handle multivariate functions
+    if len(syms) == 0:
+        raise ValueError("One or more symbols must be given in syms.")
+
+    if finset_intersection is S.EmptySet:
+        return S.EmptySet
+
+    if isinstance(finset_intersection, Union):
+        elm_in_sets = finset_intersection.args[0]
+        return Union(not_empty_in(finset_intersection.args[1], *syms),
+                     elm_in_sets)
+
+    if isinstance(finset_intersection, FiniteSet):
+        finite_set = finset_intersection
+        _sets = S.Reals
+    else:
+        finite_set = finset_intersection.args[1]
+        _sets = finset_intersection.args[0]
+
+    if not isinstance(finite_set, FiniteSet):
+        raise ValueError('A FiniteSet must be given, not %s: %s' %
+                         (type(finite_set), finite_set))
+
+    if len(syms) == 1:
+        symb = syms[0]
+    else:
+        raise NotImplementedError('more than one variables %s not handled' %
+                                  (syms,))
+
+    def elm_domain(expr, intrvl):
+        """ Finds the domain of an expression in any given interval """
+        from sympy.solvers.solveset import solveset
+
+        _start = intrvl.start
+        _end = intrvl.end
+        _singularities = solveset(expr.as_numer_denom()[1], symb,
+                                  domain=S.Reals)
+
+        if intrvl.right_open:
+            if _end is S.Infinity:
+                _domain1 = S.Reals
+            else:
+                _domain1 = solveset(expr < _end, symb, domain=S.Reals)
+        else:
+            _domain1 = solveset(expr <= _end, symb, domain=S.Reals)
+
+        if intrvl.left_open:
+            if _start is S.NegativeInfinity:
+                _domain2 = S.Reals
+            else:
+                _domain2 = solveset(expr > _start, symb, domain=S.Reals)
+        else:
+            _domain2 = solveset(expr >= _start, symb, domain=S.Reals)
+
+        # domain in the interval
+        expr_with_sing = Intersection(_domain1, _domain2)
+        expr_domain = Complement(expr_with_sing, _singularities)
+        return expr_domain
+
+    if isinstance(_sets, Interval):
+        return Union(*[elm_domain(element, _sets) for element in finite_set])
+
+    if isinstance(_sets, Union):
+        _domain = S.EmptySet
+        for intrvl in _sets.args:
+            _domain_element = Union(*[elm_domain(element, intrvl)
+                                      for element in finite_set])
+            _domain = Union(_domain, _domain_element)
+        return _domain
+
+
+def periodicity(f, symbol, check=False):
+    """
+    Tests the given function for periodicity in the given symbol.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the period is to be determined.
+    check : bool, optional
+        The flag to verify whether the value being returned is a period or not.
+
+    Returns
+    =======
+
+    period
+        The period of the function is returned.
+        ``None`` is returned when the function is aperiodic or has a complex period.
+        The value of $0$ is returned as the period of a constant function.
+
+    Raises
+    ======
+
+    NotImplementedError
+        The value of the period computed cannot be verified.
+
+
+    Notes
+    =====
+
+    Currently, we do not support functions with a complex period.
+    The period of functions having complex periodic values such
+    as ``exp``, ``sinh`` is evaluated to ``None``.
+
+    The value returned might not be the "fundamental" period of the given
+    function i.e. it may not be the smallest periodic value of the function.
+
+    The verification of the period through the ``check`` flag is not reliable
+    due to internal simplification of the given expression. Hence, it is set
+    to ``False`` by default.
+
+    Examples
+    ========
+    >>> from sympy import periodicity, Symbol, sin, cos, tan, exp
+    >>> x = Symbol('x')
+    >>> f = sin(x) + sin(2*x) + sin(3*x)
+    >>> periodicity(f, x)
+    2*pi
+    >>> periodicity(sin(x)*cos(x), x)
+    pi
+    >>> periodicity(exp(tan(2*x) - 1), x)
+    pi/2
+    >>> periodicity(sin(4*x)**cos(2*x), x)
+    pi
+    >>> periodicity(exp(x), x)
+    """
+    if symbol.kind is not NumberKind:
+        raise NotImplementedError("Cannot use symbol of kind %s" % symbol.kind)
+    temp = Dummy('x', real=True)
+    f = f.subs(symbol, temp)
+    symbol = temp
+
+    def _check(orig_f, period):
+        '''Return the checked period or raise an error.'''
+        new_f = orig_f.subs(symbol, symbol + period)
+        if new_f.equals(orig_f):
+            return period
+        else:
+            raise NotImplementedError(filldedent('''
+                The period of the given function cannot be verified.
+                When `%s` was replaced with `%s + %s` in `%s`, the result
+                was `%s` which was not recognized as being the same as
+                the original function.
+                So either the period was wrong or the two forms were
+                not recognized as being equal.
+                Set check=False to obtain the value.''' %
+                (symbol, symbol, period, orig_f, new_f)))
+
+    orig_f = f
+    period = None
+
+    if isinstance(f, Relational):
+        f = f.lhs - f.rhs
+
+    f = f.simplify()
+
+    if symbol not in f.free_symbols:
+        return S.Zero
+
+    if isinstance(f, TrigonometricFunction):
+        try:
+            period = f.period(symbol)
+        except NotImplementedError:
+            pass
+
+    if isinstance(f, Abs):
+        arg = f.args[0]
+        if isinstance(arg, (sec, csc, cos)):
+            # all but tan and cot might have a
+            # a period that is half as large
+            # so recast as sin
+            arg = sin(arg.args[0])
+        period = periodicity(arg, symbol)
+        if period is not None and isinstance(arg, sin):
+            # the argument of Abs was a trigonometric other than
+            # cot or tan; test to see if the half-period
+            # is valid. Abs(arg) has behaviour equivalent to
+            # orig_f, so use that for test:
+            orig_f = Abs(arg)
+            try:
+                return _check(orig_f, period/2)
+            except NotImplementedError as err:
+                if check:
+                    raise NotImplementedError(err)
+            # else let new orig_f and period be
+            # checked below
+
+    if isinstance(f, exp) or (f.is_Pow and f.base == S.Exp1):
+        f = Pow(S.Exp1, expand_mul(f.exp))
+        if im(f) != 0:
+            period_real = periodicity(re(f), symbol)
+            period_imag = periodicity(im(f), symbol)
+            if period_real is not None and period_imag is not None:
+                period = lcim([period_real, period_imag])
+
+    if f.is_Pow and f.base != S.Exp1:
+        base, expo = f.args
+        base_has_sym = base.has(symbol)
+        expo_has_sym = expo.has(symbol)
+
+        if base_has_sym and not expo_has_sym:
+            period = periodicity(base, symbol)
+
+        elif expo_has_sym and not base_has_sym:
+            period = periodicity(expo, symbol)
+
+        else:
+            period = _periodicity(f.args, symbol)
+
+    elif f.is_Mul:
+        coeff, g = f.as_independent(symbol, as_Add=False)
+        if isinstance(g, TrigonometricFunction) or not equal_valued(coeff, 1):
+            period = periodicity(g, symbol)
+        else:
+            period = _periodicity(g.args, symbol)
+
+    elif f.is_Add:
+        k, g = f.as_independent(symbol)
+        if k is not S.Zero:
+            return periodicity(g, symbol)
+
+        period = _periodicity(g.args, symbol)
+
+    elif isinstance(f, Mod):
+        a, n = f.args
+
+        if a == symbol:
+            period = n
+        elif isinstance(a, TrigonometricFunction):
+            period = periodicity(a, symbol)
+        #check if 'f' is linear in 'symbol'
+        elif (a.is_polynomial(symbol) and degree(a, symbol) == 1 and
+            symbol not in n.free_symbols):
+                period = Abs(n / a.diff(symbol))
+
+    elif isinstance(f, Piecewise):
+        pass  # not handling Piecewise yet as the return type is not favorable
+
+    elif period is None:
+        from sympy.solvers.decompogen import compogen, decompogen
+        g_s = decompogen(f, symbol)
+        num_of_gs = len(g_s)
+        if num_of_gs > 1:
+            for index, g in enumerate(reversed(g_s)):
+                start_index = num_of_gs - 1 - index
+                g = compogen(g_s[start_index:], symbol)
+                if g not in (orig_f, f): # Fix for issue 12620
+                    period = periodicity(g, symbol)
+                    if period is not None:
+                        break
+
+    if period is not None:
+        if check:
+            return _check(orig_f, period)
+        return period
+
+    return None
+
+
+def _periodicity(args, symbol):
+    """
+    Helper for `periodicity` to find the period of a list of simpler
+    functions.
+    It uses the `lcim` method to find the least common period of
+    all the functions.
+
+    Parameters
+    ==========
+
+    args : Tuple of :py:class:`~.Symbol`
+        All the symbols present in a function.
+
+    symbol : :py:class:`~.Symbol`
+        The symbol over which the function is to be evaluated.
+
+    Returns
+    =======
+
+    period
+        The least common period of the function for all the symbols
+        of the function.
+        ``None`` if for at least one of the symbols the function is aperiodic.
+
+    """
+    periods = []
+    for f in args:
+        period = periodicity(f, symbol)
+        if period is None:
+            return None
+
+        if period is not S.Zero:
+            periods.append(period)
+
+    if len(periods) > 1:
+        return lcim(periods)
+
+    if periods:
+        return periods[0]
+
+
+def lcim(numbers):
+    """Returns the least common integral multiple of a list of numbers.
+
+    The numbers can be rational or irrational or a mixture of both.
+    `None` is returned for incommensurable numbers.
+
+    Parameters
+    ==========
+
+    numbers : list
+        Numbers (rational and/or irrational) for which lcim is to be found.
+
+    Returns
+    =======
+
+    number
+        lcim if it exists, otherwise ``None`` for incommensurable numbers.
+
+    Examples
+    ========
+
+    >>> from sympy.calculus.util import lcim
+    >>> from sympy import S, pi
+    >>> lcim([S(1)/2, S(3)/4, S(5)/6])
+    15/2
+    >>> lcim([2*pi, 3*pi, pi, pi/2])
+    6*pi
+    >>> lcim([S(1), 2*pi])
+    """
+    result = None
+    if all(num.is_irrational for num in numbers):
+        factorized_nums = [num.factor() for num in numbers]
+        factors_num = [num.as_coeff_Mul() for num in factorized_nums]
+        term = factors_num[0][1]
+        if all(factor == term for coeff, factor in factors_num):
+            common_term = term
+            coeffs = [coeff for coeff, factor in factors_num]
+            result = lcm_list(coeffs) * common_term
+
+    elif all(num.is_rational for num in numbers):
+        result = lcm_list(numbers)
+
+    else:
+        pass
+
+    return result
+
+def is_convex(f, *syms, domain=S.Reals):
+    r"""Determines the  convexity of the function passed in the argument.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    syms : Tuple of :py:class:`~.Symbol`
+        The variables with respect to which the convexity is to be determined.
+    domain : :py:class:`~.Interval`, optional
+        The domain over which the convexity of the function has to be checked.
+        If unspecified, S.Reals will be the default domain.
+
+    Returns
+    =======
+
+    bool
+        The method returns ``True`` if the function is convex otherwise it
+        returns ``False``.
+
+    Raises
+    ======
+
+    NotImplementedError
+        The check for the convexity of multivariate functions is not implemented yet.
+
+    Notes
+    =====
+
+    To determine concavity of a function pass `-f` as the concerned function.
+    To determine logarithmic convexity of a function pass `\log(f)` as
+    concerned function.
+    To determine logarithmic concavity of a function pass `-\log(f)` as
+    concerned function.
+
+    Currently, convexity check of multivariate functions is not handled.
+
+    Examples
+    ========
+
+    >>> from sympy import is_convex, symbols, exp, oo, Interval
+    >>> x = symbols('x')
+    >>> is_convex(exp(x), x)
+    True
+    >>> is_convex(x**3, x, domain = Interval(-1, oo))
+    False
+    >>> is_convex(1/x**2, x, domain=Interval.open(0, oo))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Convex_function
+    .. [2] http://www.ifp.illinois.edu/~angelia/L3_convfunc.pdf
+    .. [3] https://en.wikipedia.org/wiki/Logarithmically_convex_function
+    .. [4] https://en.wikipedia.org/wiki/Logarithmically_concave_function
+    .. [5] https://en.wikipedia.org/wiki/Concave_function
+
+    """
+
+    if len(syms) > 1:
+        raise NotImplementedError(
+            "The check for the convexity of multivariate functions is not implemented yet.")
+
+    from sympy.solvers.inequalities import solve_univariate_inequality
+
+    f = _sympify(f)
+    var = syms[0]
+    if any(s in domain for s in singularities(f, var)):
+        return False
+
+    condition = f.diff(var, 2) < 0
+    if solve_univariate_inequality(condition, var, False, domain):
+        return False
+    return True
+
+
+def stationary_points(f, symbol, domain=S.Reals):
+    """
+    Returns the stationary points of a function (where derivative of the
+    function is 0) in the given domain.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the stationary points are to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the stationary points have to be checked.
+        If unspecified, ``S.Reals`` will be the default domain.
+
+    Returns
+    =======
+
+    Set
+        A set of stationary points for the function. If there are no
+        stationary point, an :py:class:`~.EmptySet` is returned.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, sin, pi, pprint, stationary_points
+    >>> x = Symbol('x')
+
+    >>> stationary_points(1/x, x, S.Reals)
+    EmptySet
+
+    >>> pprint(stationary_points(sin(x), x), use_unicode=False)
+              pi                              3*pi
+    {2*n*pi + -- | n in Integers} U {2*n*pi + ---- | n in Integers}
+              2                                2
+
+    >>> stationary_points(sin(x),x, Interval(0, 4*pi))
+    {pi/2, 3*pi/2, 5*pi/2, 7*pi/2}
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    if domain is S.EmptySet:
+        return S.EmptySet
+
+    domain = continuous_domain(f, symbol, domain)
+    set = solveset(diff(f, symbol), symbol, domain)
+
+    return set
+
+
+def maximum(f, symbol, domain=S.Reals):
+    """
+    Returns the maximum value of a function in the given domain.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for maximum value needs to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the maximum have to be checked.
+        If unspecified, then the global maximum is returned.
+
+    Returns
+    =======
+
+    number
+        Maximum value of the function in given domain.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, sin, cos, pi, maximum
+    >>> x = Symbol('x')
+
+    >>> f = -x**2 + 2*x + 5
+    >>> maximum(f, x, S.Reals)
+    6
+
+    >>> maximum(sin(x), x, Interval(-pi, pi/4))
+    sqrt(2)/2
+
+    >>> maximum(sin(x)*cos(x), x)
+    1/2
+
+    """
+    if isinstance(symbol, Symbol):
+        if domain is S.EmptySet:
+            raise ValueError("Maximum value not defined for empty domain.")
+
+        return function_range(f, symbol, domain).sup
+    else:
+        raise ValueError("%s is not a valid symbol." % symbol)
+
+
+def minimum(f, symbol, domain=S.Reals):
+    """
+    Returns the minimum value of a function in the given domain.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for minimum value needs to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the minimum have to be checked.
+        If unspecified, then the global minimum is returned.
+
+    Returns
+    =======
+
+    number
+        Minimum value of the function in the given domain.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, sin, cos, minimum
+    >>> x = Symbol('x')
+
+    >>> f = x**2 + 2*x + 5
+    >>> minimum(f, x, S.Reals)
+    4
+
+    >>> minimum(sin(x), x, Interval(2, 3))
+    sin(3)
+
+    >>> minimum(sin(x)*cos(x), x)
+    -1/2
+
+    """
+    if isinstance(symbol, Symbol):
+        if domain is S.EmptySet:
+            raise ValueError("Minimum value not defined for empty domain.")
+
+        return function_range(f, symbol, domain).inf
+    else:
+        raise ValueError("%s is not a valid symbol." % symbol)

shared/package-files/56/5625dde86e5d3428f96dd588a61155f28936505d3c537a4a448d967e716af150/blob

@@ -0,0 +1,212 @@
+#pragma once
+
+#include <c10/core/impl/DeviceGuardImplInterface.h>
+#include <c10/core/impl/GPUTrace.h>
+#include <c10/macros/Macros.h>
+#include <c10/util/Exception.h>
+
+#include <c10/cuda/CUDACachingAllocator.h>
+#include <c10/cuda/CUDAException.h>
+#include <c10/cuda/CUDAFunctions.h>
+#include <c10/cuda/CUDAStream.h>
+
+#include <c10/core/Device.h>
+#include <c10/core/DeviceType.h>
+#include <c10/core/Stream.h>
+#include <c10/core/impl/PyInterpreter.h>
+#include <c10/util/Optional.h>
+#include <cuda_runtime_api.h>
+#include <cstdint>
+
+namespace c10::cuda::impl {
+
+struct CUDAGuardImpl final : public c10::impl::DeviceGuardImplInterface {
+  static constexpr DeviceType static_type = DeviceType::CUDA;
+
+  CUDAGuardImpl() = default;
+  explicit CUDAGuardImpl(DeviceType t) {
+    TORCH_INTERNAL_ASSERT(t == DeviceType::CUDA);
+  }
+  DeviceType type() const override {
+    return DeviceType::CUDA;
+  }
+  Device exchangeDevice(Device d) const override {
+    TORCH_INTERNAL_ASSERT(d.is_cuda());
+    auto old_device_index = c10::cuda::ExchangeDevice(d.index());
+    return Device(DeviceType::CUDA, old_device_index);
+  }
+  Device getDevice() const override {
+    DeviceIndex device = 0;
+    C10_CUDA_CHECK(c10::cuda::GetDevice(&device));
+    return Device(DeviceType::CUDA, device);
+  }
+  c10::optional<Device> uncheckedGetDevice() const noexcept {
+    DeviceIndex device{-1};
+    const auto err = C10_CUDA_ERROR_HANDLED(c10::cuda::GetDevice(&device));
+    C10_CUDA_CHECK_WARN(err);
+    if (err != cudaSuccess) {
+      return c10::nullopt;
+    }
+    return Device(DeviceType::CUDA, device);
+  }
+  void setDevice(Device d) const override {
+    TORCH_INTERNAL_ASSERT(d.is_cuda());
+    C10_CUDA_CHECK(c10::cuda::SetDevice(d.index()));
+  }
+  void uncheckedSetDevice(Device d) const noexcept override {
+    C10_CUDA_CHECK_WARN(c10::cuda::MaybeSetDevice(d.index()));
+  }
+  Stream getStream(Device d) const noexcept override {
+    return getCurrentCUDAStream(d.index()).unwrap();
+  }
+  Stream getDefaultStream(Device d) const override {
+    return getDefaultCUDAStream(d.index());
+  }
+  Stream getStreamFromGlobalPool(Device d, bool isHighPriority = false)
+      const override {
+    return getStreamFromPool(isHighPriority, d.index());
+  }
+  // NB: These do NOT set the current device
+  Stream exchangeStream(Stream s) const noexcept override {
+    CUDAStream cs(s);
+    auto old_stream = getCurrentCUDAStream(s.device().index());
+    setCurrentCUDAStream(cs);
+    return old_stream.unwrap();
+  }
+  DeviceIndex deviceCount() const noexcept override {
+    return device_count();
+  }
+
+  // Event-related functions
+  void createEvent(cudaEvent_t* cuda_event, const EventFlag flag) const {
+    // Maps PyTorch's Event::Flag to CUDA flag
+    auto cuda_flag = cudaEventDefault;
+    switch (flag) {
+      case EventFlag::PYTORCH_DEFAULT:
+      case EventFlag::CUDA_EVENT_DISABLE_TIMING:
+        cuda_flag = cudaEventDisableTiming;
+        break;
+      case EventFlag::BACKEND_DEFAULT:
+      case EventFlag::CUDA_EVENT_DEFAULT:
+        cuda_flag = cudaEventDefault;
+        break;
+      default:
+        TORCH_CHECK(false, "CUDA event received unknown flag");
+    }
+
+    C10_CUDA_CHECK(cudaEventCreateWithFlags(cuda_event, cuda_flag));
+    const c10::impl::PyInterpreter* interp = c10::impl::GPUTrace::get_trace();
+    if (C10_UNLIKELY(interp)) {
+      (*interp)->trace_gpu_event_creation(
+          reinterpret_cast<uintptr_t>(cuda_event));
+    }
+  }
+
+  void destroyEvent(void* event, const DeviceIndex device_index)
+      const noexcept override {
+    if (!event)
+      return;
+    auto cuda_event = static_cast<cudaEvent_t>(event);
+    DeviceIndex orig_device{-1};
+    C10_CUDA_CHECK_WARN(c10::cuda::GetDevice(&orig_device));
+    C10_CUDA_CHECK_WARN(c10::cuda::SetDevice(device_index));
+    const c10::impl::PyInterpreter* interp = c10::impl::GPUTrace::get_trace();
+    if (C10_UNLIKELY(interp)) {
+      (*interp)->trace_gpu_event_deletion(
+          reinterpret_cast<uintptr_t>(cuda_event));
+    }
+    C10_CUDA_CHECK_WARN(cudaEventDestroy(cuda_event));
+    C10_CUDA_CHECK_WARN(c10::cuda::SetDevice(orig_device));
+  }
+
+  void record(
+      void** event,
+      const Stream& stream,
+      const DeviceIndex device_index,
+      const EventFlag flag) const override {
+    TORCH_CHECK(
+        device_index == -1 || device_index == stream.device_index(),
+        "Event device index ",
+        device_index,
+        " does not match recording stream's device index ",
+        stream.device_index(),
+        ".");
+
+    cudaEvent_t cuda_event = static_cast<cudaEvent_t>(*event);
+    CUDAStream cuda_stream{stream};
+
+    // Moves to stream's device to record
+    const auto orig_device = getDevice();
+    setDevice(stream.device());
+
+    // Creates the event (lazily)
+    if (!cuda_event)
+      createEvent(&cuda_event, flag);
+    C10_CUDA_CHECK(cudaEventRecord(cuda_event, cuda_stream));
+    // Makes the void* point to the (possibly just allocated) CUDA event
+    *event = cuda_event;
+    const c10::impl::PyInterpreter* interp = c10::impl::GPUTrace::get_trace();
+    if (C10_UNLIKELY(interp)) {
+      (*interp)->trace_gpu_event_record(
+          reinterpret_cast<uintptr_t>(cuda_event),
+          reinterpret_cast<uintptr_t>(cuda_stream.stream()));
+    }
+
+    // Resets device
+    setDevice(orig_device);
+  }
+
+  void block(void* event, const Stream& stream) const override {
+    if (!event)
+      return;
+    cudaEvent_t cuda_event = static_cast<cudaEvent_t>(event);
+    CUDAStream cuda_stream{stream};
+    const auto orig_device = getDevice();
+    setDevice(stream.device());
+    C10_CUDA_CHECK(cudaStreamWaitEvent(
+        cuda_stream,
+        cuda_event,
+        /*flags (must be zero)=*/0));
+    const c10::impl::PyInterpreter* interp = c10::impl::GPUTrace::get_trace();
+    if (C10_UNLIKELY(interp)) {
+      (*interp)->trace_gpu_event_wait(
+          reinterpret_cast<uintptr_t>(cuda_event),
+          reinterpret_cast<uintptr_t>(cuda_stream.stream()));
+    }
+    setDevice(orig_device);
+  }
+
+  // May be called from any device
+  bool queryEvent(void* event) const override {
+    if (!event)
+      return true;
+    cudaEvent_t cuda_event = static_cast<cudaEvent_t>(event);
+    const cudaError_t err = C10_CUDA_ERROR_HANDLED(cudaEventQuery(cuda_event));
+    if (err != cudaErrorNotReady) {
+      C10_CUDA_CHECK(err);
+    } else {
+      // ignore and clear the error if not ready
+      (void)cudaGetLastError();
+    }
+    return (err == cudaSuccess);
+  }
+
+  // Stream-related functions
+  bool queryStream(const Stream& stream) const override {
+    CUDAStream cuda_stream{stream};
+    return cuda_stream.query();
+  }
+
+  void synchronizeStream(const Stream& stream) const override {
+    CUDAStream cuda_stream{stream};
+    cuda_stream.synchronize();
+  }
+
+  void recordDataPtrOnStream(const c10::DataPtr& data_ptr, const Stream& stream)
+      const override {
+    CUDAStream cuda_stream{stream};
+    CUDACachingAllocator::recordStream(data_ptr, cuda_stream);
+  }
+};
+
+} // namespace c10::cuda::impl

shared/package-files/56/5627831bc850c2f3bb9ecaafe77e4a9afaa5c219ac19f0acdebde802a9078900/blob

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

shared/package-files/56/562825f936033f38d1b61561663a9b6f3352aeed36351d6259f65f9a1ed621f2/blob

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/softplus_backward_ops.h>
+
+namespace at {
+
+
+// aten::softplus_backward.grad_input(Tensor grad_output, Tensor self, Scalar beta, Scalar threshold, *, Tensor(a!) grad_input) -> Tensor(a!)
+inline at::Tensor & softplus_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold) {
+    return at::_ops::softplus_backward_grad_input::call(grad_output, self, beta, threshold, grad_input);
+}
+// aten::softplus_backward.grad_input(Tensor grad_output, Tensor self, Scalar beta, Scalar threshold, *, Tensor(a!) grad_input) -> Tensor(a!)
+inline at::Tensor & softplus_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold, at::Tensor & grad_input) {
+    return at::_ops::softplus_backward_grad_input::call(grad_output, self, beta, threshold, grad_input);
+}
+
+// aten::softplus_backward(Tensor grad_output, Tensor self, Scalar beta, Scalar threshold) -> Tensor
+inline at::Tensor softplus_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Scalar & beta, const at::Scalar & threshold) {
+    return at::_ops::softplus_backward::call(grad_output, self, beta, threshold);
+}
+
+}

shared/package-files/56/562d4b893ac95f9058d000cbc68264c02ec7dbb1f7d2d4cf33cf71674e00e465/blob

@@ -0,0 +1,2 @@
+#include <c10/util/Backtrace.h>
+#include <c10/util/Type.h>

shared/package-files/56/562d4d8bd25e6725fb9145fb60482f6a3d52ea4cba472532f2a2ff08e375520c/blob

@@ -0,0 +1,20 @@
+# coding: utf-8
+from __future__ import absolute_import
+from six.moves import cStringIO
+from .unparser import Unparser
+from .printer import Printer
+
+
+__version__ = '1.6.3'
+
+
+def unparse(tree):
+    v = cStringIO()
+    Unparser(tree, file=v)
+    return v.getvalue()
+
+
+def dump(tree):
+    v = cStringIO()
+    Printer(file=v).visit(tree)
+    return v.getvalue()

shared/package-files/56/562d986ed52133d57160f6373c1bf17eed31658afa7c1cac9798103c9128f3c9/blob

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from contourpy._contourpy import (
+    ContourGenerator,
+    FillType,
+    LineType,
+    Mpl2005ContourGenerator,
+    Mpl2014ContourGenerator,
+    SerialContourGenerator,
+    ThreadedContourGenerator,
+    ZInterp,
+    max_threads,
+)
+from contourpy._version import __version__
+from contourpy.chunk import calc_chunk_sizes
+from contourpy.convert import (
+    convert_filled,
+    convert_lines,
+    convert_multi_filled,
+    convert_multi_lines,
+)
+from contourpy.dechunk import (
+    dechunk_filled,
+    dechunk_lines,
+    dechunk_multi_filled,
+    dechunk_multi_lines,
+)
+from contourpy.enum_util import as_fill_type, as_line_type, as_z_interp
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from numpy.typing import ArrayLike
+
+    from ._contourpy import CoordinateArray, MaskArray
+
+__all__ = [
+    "__version__",
+    "contour_generator",
+    "convert_filled",
+    "convert_lines",
+    "convert_multi_filled",
+    "convert_multi_lines",
+    "dechunk_filled",
+    "dechunk_lines",
+    "dechunk_multi_filled",
+    "dechunk_multi_lines",
+    "max_threads",
+    "FillType",
+    "LineType",
+    "ContourGenerator",
+    "Mpl2005ContourGenerator",
+    "Mpl2014ContourGenerator",
+    "SerialContourGenerator",
+    "ThreadedContourGenerator",
+    "ZInterp",
+]
+
+
+# Simple mapping of algorithm name to class name.
+_class_lookup: dict[str, type[ContourGenerator]] = {
+    "mpl2005": Mpl2005ContourGenerator,
+    "mpl2014": Mpl2014ContourGenerator,
+    "serial": SerialContourGenerator,
+    "threaded": ThreadedContourGenerator,
+}
+
+
+def _remove_z_mask(
+    z: ArrayLike | np.ma.MaskedArray[Any, Any] | None,
+) -> tuple[CoordinateArray, MaskArray | None]:
+    # Preserve mask if present.
+    z_array = np.ma.asarray(z, dtype=np.float64)  # type: ignore[no-untyped-call]
+    z_masked = np.ma.masked_invalid(z_array, copy=False)  # type: ignore[no-untyped-call]
+
+    if np.ma.is_masked(z_masked):  # type: ignore[no-untyped-call]
+        mask = np.ma.getmask(z_masked)  # type: ignore[no-untyped-call]
+    else:
+        mask = None
+
+    return np.ma.getdata(z_masked), mask  # type: ignore[no-untyped-call]
+
+
+def contour_generator(
+    x: ArrayLike | None = None,
+    y: ArrayLike | None = None,
+    z: ArrayLike | np.ma.MaskedArray[Any, Any] | None = None,
+    *,
+    name: str = "serial",
+    corner_mask: bool | None = None,
+    line_type: LineType | str | None = None,
+    fill_type: FillType | str | None = None,
+    chunk_size: int | tuple[int, int] | None = None,
+    chunk_count: int | tuple[int, int] | None = None,
+    total_chunk_count: int | None = None,
+    quad_as_tri: bool = False,
+    z_interp: ZInterp | str | None = ZInterp.Linear,
+    thread_count: int = 0,
+) -> ContourGenerator:
+    """Create and return a :class:`~.ContourGenerator` object.
+
+    The class and properties of the returned :class:`~.ContourGenerator` are determined by the
+    function arguments, with sensible defaults.
+
+    Args:
+        x (array-like of shape (ny, nx) or (nx,), optional): The x-coordinates of the ``z`` values.
+            May be 2D with the same shape as ``z.shape``, or 1D with length ``nx = z.shape[1]``.
+            If not specified are assumed to be ``np.arange(nx)``. Must be ordered monotonically.
+        y (array-like of shape (ny, nx) or (ny,), optional): The y-coordinates of the ``z`` values.
+            May be 2D with the same shape as ``z.shape``, or 1D with length ``ny = z.shape[0]``.
+            If not specified are assumed to be ``np.arange(ny)``. Must be ordered monotonically.
+        z (array-like of shape (ny, nx), may be a masked array): The 2D gridded values to calculate
+            the contours of.  May be a masked array, and any invalid values (``np.inf`` or
+            ``np.nan``) will also be masked out.
+        name (str): Algorithm name, one of ``"serial"``, ``"threaded"``, ``"mpl2005"`` or
+            ``"mpl2014"``, default ``"serial"``.
+        corner_mask (bool, optional): Enable/disable corner masking, which only has an effect if
+            ``z`` is a masked array. If ``False``, any quad touching a masked point is masked out.
+            If ``True``, only the triangular corners of quads nearest these points are always masked
+            out, other triangular corners comprising three unmasked points are contoured as usual.
+            If not specified, uses the default provided by the algorithm ``name``.
+        line_type (LineType or str, optional): The format of contour line data returned from calls
+            to :meth:`~.ContourGenerator.lines`, specified either as a :class:`~.LineType` or its
+            string equivalent such as ``"SeparateCode"``.
+            If not specified, uses the default provided by the algorithm ``name``.
+            The relationship between the :class:`~.LineType` enum and the data format returned from
+            :meth:`~.ContourGenerator.lines` is explained at :ref:`line_type`.
+        fill_type (FillType or str, optional): The format of filled contour data returned from calls
+            to :meth:`~.ContourGenerator.filled`, specified either as a :class:`~.FillType` or its
+            string equivalent such as ``"OuterOffset"``.
+            If not specified, uses the default provided by the algorithm ``name``.
+            The relationship between the :class:`~.FillType` enum and the data format returned from
+            :meth:`~.ContourGenerator.filled` is explained at :ref:`fill_type`.
+        chunk_size (int or tuple(int, int), optional): Chunk size in (y, x) directions, or the same
+            size in both directions if only one value is specified.
+        chunk_count (int or tuple(int, int), optional): Chunk count in (y, x) directions, or the
+            same count in both directions if only one value is specified.
+        total_chunk_count (int, optional): Total number of chunks.
+        quad_as_tri (bool): Enable/disable treating quads as 4 triangles, default ``False``.
+            If ``False``, a contour line within a quad is a straight line between points on two of
+            its edges. If ``True``, each full quad is divided into 4 triangles using a virtual point
+            at the centre (mean x, y of the corner points) and a contour line is piecewise linear
+            within those triangles. Corner-masked triangles are not affected by this setting, only
+            full unmasked quads.
+        z_interp (ZInterp or str, optional): How to interpolate ``z`` values when determining where
+            contour lines intersect the edges of quads and the ``z`` values of the central points of
+            quads, specified either as a :class:`~contourpy.ZInterp` or its string equivalent such
+            as ``"Log"``. Default is ``ZInterp.Linear``.
+        thread_count (int): Number of threads to use for contour calculation, default 0. Threads can
+            only be used with an algorithm ``name`` that supports threads (currently only
+            ``name="threaded"``) and there must be at least the same number of chunks as threads.
+            If ``thread_count=0`` and ``name="threaded"`` then it uses the maximum number of threads
+            as determined by the C++11 call ``std::thread::hardware_concurrency()``. If ``name`` is
+            something other than ``"threaded"`` then the ``thread_count`` will be set to ``1``.
+
+    Return:
+        :class:`~.ContourGenerator`.
+
+    Note:
+        A maximum of one of ``chunk_size``, ``chunk_count`` and ``total_chunk_count`` may be
+        specified.
+
+    Warning:
+        The ``name="mpl2005"`` algorithm does not implement chunking for contour lines.
+    """
+    x = np.asarray(x, dtype=np.float64)
+    y = np.asarray(y, dtype=np.float64)
+    z, mask = _remove_z_mask(z)
+
+    # Check arguments: z.
+    if z.ndim != 2:
+        raise TypeError(f"Input z must be 2D, not {z.ndim}D")
+
+    if z.shape[0] < 2 or z.shape[1] < 2:
+        raise TypeError(f"Input z must be at least a (2, 2) shaped array, but has shape {z.shape}")
+
+    ny, nx = z.shape
+
+    # Check arguments: x and y.
+    if x.ndim != y.ndim:
+        raise TypeError(f"Number of dimensions of x ({x.ndim}) and y ({y.ndim}) do not match")
+
+    if x.ndim == 0:
+        x = np.arange(nx, dtype=np.float64)
+        y = np.arange(ny, dtype=np.float64)
+        x, y = np.meshgrid(x, y)
+    elif x.ndim == 1:
+        if len(x) != nx:
+            raise TypeError(f"Length of x ({len(x)}) must match number of columns in z ({nx})")
+        if len(y) != ny:
+            raise TypeError(f"Length of y ({len(y)}) must match number of rows in z ({ny})")
+        x, y = np.meshgrid(x, y)
+    elif x.ndim == 2:
+        if x.shape != z.shape:
+            raise TypeError(f"Shapes of x {x.shape} and z {z.shape} do not match")
+        if y.shape != z.shape:
+            raise TypeError(f"Shapes of y {y.shape} and z {z.shape} do not match")
+    else:
+        raise TypeError(f"Inputs x and y must be None, 1D or 2D, not {x.ndim}D")
+
+    # Check mask shape just in case.
+    if mask is not None and mask.shape != z.shape:
+        raise ValueError("If mask is set it must be a 2D array with the same shape as z")
+
+    # Check arguments: name.
+    if name not in _class_lookup:
+        raise ValueError(f"Unrecognised contour generator name: {name}")
+
+    # Check arguments: chunk_size, chunk_count and total_chunk_count.
+    y_chunk_size, x_chunk_size = calc_chunk_sizes(
+        chunk_size, chunk_count, total_chunk_count, ny, nx)
+
+    cls = _class_lookup[name]
+
+    # Check arguments: corner_mask.
+    if corner_mask is None:
+        # Set it to default, which is True if the algorithm supports it.
+        corner_mask = cls.supports_corner_mask()
+    elif corner_mask and not cls.supports_corner_mask():
+        raise ValueError(f"{name} contour generator does not support corner_mask=True")
+
+    # Check arguments: line_type.
+    if line_type is None:
+        line_type = cls.default_line_type
+    else:
+        line_type = as_line_type(line_type)
+
+    if not cls.supports_line_type(line_type):
+        raise ValueError(f"{name} contour generator does not support line_type {line_type}")
+
+    # Check arguments: fill_type.
+    if fill_type is None:
+        fill_type = cls.default_fill_type
+    else:
+        fill_type = as_fill_type(fill_type)
+
+    if not cls.supports_fill_type(fill_type):
+        raise ValueError(f"{name} contour generator does not support fill_type {fill_type}")
+
+    # Check arguments: quad_as_tri.
+    if quad_as_tri and not cls.supports_quad_as_tri():
+        raise ValueError(f"{name} contour generator does not support quad_as_tri=True")
+
+    # Check arguments: z_interp.
+    if z_interp is None:
+        z_interp = ZInterp.Linear
+    else:
+        z_interp = as_z_interp(z_interp)
+
+    if z_interp != ZInterp.Linear and not cls.supports_z_interp():
+        raise ValueError(f"{name} contour generator does not support z_interp {z_interp}")
+
+    # Check arguments: thread_count.
+    if thread_count not in (0, 1) and not cls.supports_threads():
+        raise ValueError(f"{name} contour generator does not support thread_count {thread_count}")
+
+    # Prepare args and kwargs for contour generator constructor.
+    args = [x, y, z, mask]
+    kwargs: dict[str, int | bool | LineType | FillType | ZInterp] = {
+        "x_chunk_size": x_chunk_size,
+        "y_chunk_size": y_chunk_size,
+    }
+
+    if name not in ("mpl2005", "mpl2014"):
+        kwargs["line_type"] = line_type
+        kwargs["fill_type"] = fill_type
+
+    if cls.supports_corner_mask():
+        kwargs["corner_mask"] = corner_mask
+
+    if cls.supports_quad_as_tri():
+        kwargs["quad_as_tri"] = quad_as_tri
+
+    if cls.supports_z_interp():
+        kwargs["z_interp"] = z_interp
+
+    if cls.supports_threads():
+        kwargs["thread_count"] = thread_count
+
+    # Create contour generator.
+    return cls(*args, **kwargs)

shared/package-files/56/56325687bbec94c348a1074f14d525019234131b8b155e8476bcb061a223a905/blob

@@ -0,0 +1,841 @@
+"""
+    pygments.lexers.dotnet
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for .net languages.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+import re
+
+from pygments.lexer import RegexLexer, DelegatingLexer, bygroups, include, \
+    using, this, default, words
+from pygments.token import Punctuation, Text, Comment, Operator, Keyword, \
+    Name, String, Number, Literal, Other, Whitespace
+from pygments.util import get_choice_opt
+from pygments import unistring as uni
+
+from pygments.lexers.html import XmlLexer
+
+__all__ = ['CSharpLexer', 'NemerleLexer', 'BooLexer', 'VbNetLexer',
+           'CSharpAspxLexer', 'VbNetAspxLexer', 'FSharpLexer', 'XppLexer']
+
+
+class CSharpLexer(RegexLexer):
+    """
+    For C# source code.
+
+    Additional options accepted:
+
+    `unicodelevel`
+      Determines which Unicode characters this lexer allows for identifiers.
+      The possible values are:
+
+      * ``none`` -- only the ASCII letters and numbers are allowed. This
+        is the fastest selection.
+      * ``basic`` -- all Unicode characters from the specification except
+        category ``Lo`` are allowed.
+      * ``full`` -- all Unicode characters as specified in the C# specs
+        are allowed.  Note that this means a considerable slowdown since the
+        ``Lo`` category has more than 40,000 characters in it!
+
+      The default value is ``basic``.
+
+      .. versionadded:: 0.8
+    """
+
+    name = 'C#'
+    url = 'https://docs.microsoft.com/en-us/dotnet/csharp/'
+    aliases = ['csharp', 'c#', 'cs']
+    filenames = ['*.cs']
+    mimetypes = ['text/x-csharp']  # inferred
+
+    flags = re.MULTILINE | re.DOTALL
+
+    # for the range of allowed unicode characters in identifiers, see
+    # http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-334.pdf
+
+    levels = {
+        'none': r'@?[_a-zA-Z]\w*',
+        'basic': ('@?[_' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Nl') + ']' +
+                  '[' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Nl', 'Nd', 'Pc',
+                                    'Cf', 'Mn', 'Mc') + ']*'),
+        'full': ('@?(?:_|[^' +
+                 uni.allexcept('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl') + '])' +
+                 '[^' + uni.allexcept('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl',
+                                      'Nd', 'Pc', 'Cf', 'Mn', 'Mc') + ']*'),
+    }
+
+    tokens = {}
+    token_variants = True
+
+    for levelname, cs_ident in levels.items():
+        tokens[levelname] = {
+            'root': [
+                # method names
+                (r'^([ \t]*)((?:' + cs_ident + r'(?:\[\])?\s+)+?)'  # return type
+                 r'(' + cs_ident + ')'                            # method name
+                 r'(\s*)(\()',                               # signature start
+                 bygroups(Whitespace, using(this), Name.Function, Whitespace,
+                          Punctuation)),
+                (r'^(\s*)(\[.*?\])', bygroups(Whitespace, Name.Attribute)),
+                (r'[^\S\n]+', Whitespace),
+                (r'(\\)(\n)', bygroups(Text, Whitespace)),  # line continuation
+                (r'//.*?\n', Comment.Single),
+                (r'/[*].*?[*]/', Comment.Multiline),
+                (r'\n', Whitespace),
+                (words((
+                    '>>>=', '>>=', '<<=', '<=', '>=', '+=', '-=', '*=', '/=',
+                    '%=', '&=', '|=', '^=', '??=', '=>', '??', '?.', '!=', '==',
+                    '&&', '||', '>>>', '>>', '<<', '++', '--', '+', '-', '*',
+                    '/', '%', '&', '|', '^', '<', '>', '?', '!', '~', '=',
+                )), Operator),
+                (r'=~|!=|==|<<|>>|[-+/*%=<>&^|]', Operator),
+                (r'[()\[\];:,.]', Punctuation),
+                (r'[{}]', Punctuation),
+                (r'@"(""|[^"])*"', String),
+                (r'\$?"(\\\\|\\[^\\]|[^"\\\n])*["\n]', String),
+                (r"'\\.'|'[^\\]'", String.Char),
+                (r"[0-9]+(\.[0-9]*)?([eE][+-][0-9]+)?"
+                 r"[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?", Number),
+                (r'(#)([ \t]*)(if|endif|else|elif|define|undef|'
+                 r'line|error|warning|region|endregion|pragma)\b(.*?)(\n)',
+                 bygroups(Comment.Preproc, Whitespace, Comment.Preproc,
+                          Comment.Preproc, Whitespace)),
+                (r'\b(extern)(\s+)(alias)\b', bygroups(Keyword, Whitespace,
+                 Keyword)),
+                (r'(abstract|as|async|await|base|break|by|case|catch|'
+                 r'checked|const|continue|default|delegate|'
+                 r'do|else|enum|event|explicit|extern|false|finally|'
+                 r'fixed|for|foreach|goto|if|implicit|in|interface|'
+                 r'internal|is|let|lock|new|null|on|operator|'
+                 r'out|override|params|private|protected|public|readonly|'
+                 r'ref|return|sealed|sizeof|stackalloc|static|'
+                 r'switch|this|throw|true|try|typeof|'
+                 r'unchecked|unsafe|virtual|void|while|'
+                 r'get|set|new|partial|yield|add|remove|value|alias|ascending|'
+                 r'descending|from|group|into|orderby|select|thenby|where|'
+                 r'join|equals)\b', Keyword),
+                (r'(global)(::)', bygroups(Keyword, Punctuation)),
+                (r'(bool|byte|char|decimal|double|dynamic|float|int|long|object|'
+                 r'sbyte|short|string|uint|ulong|ushort|var)\b\??', Keyword.Type),
+                (r'(class|struct)(\s+)', bygroups(Keyword, Whitespace), 'class'),
+                (r'(namespace|using)(\s+)', bygroups(Keyword, Whitespace), 'namespace'),
+                (cs_ident, Name),
+            ],
+            'class': [
+                (cs_ident, Name.Class, '#pop'),
+                default('#pop'),
+            ],
+            'namespace': [
+                (r'(?=\()', Text, '#pop'),  # using (resource)
+                ('(' + cs_ident + r'|\.)+', Name.Namespace, '#pop'),
+            ]
+        }
+
+    def __init__(self, **options):
+        level = get_choice_opt(options, 'unicodelevel', list(self.tokens), 'basic')
+        if level not in self._all_tokens:
+            # compile the regexes now
+            self._tokens = self.__class__.process_tokendef(level)
+        else:
+            self._tokens = self._all_tokens[level]
+
+        RegexLexer.__init__(self, **options)
+
+
+class NemerleLexer(RegexLexer):
+    """
+    For Nemerle source code.
+
+    Additional options accepted:
+
+    `unicodelevel`
+      Determines which Unicode characters this lexer allows for identifiers.
+      The possible values are:
+
+      * ``none`` -- only the ASCII letters and numbers are allowed. This
+        is the fastest selection.
+      * ``basic`` -- all Unicode characters from the specification except
+        category ``Lo`` are allowed.
+      * ``full`` -- all Unicode characters as specified in the C# specs
+        are allowed.  Note that this means a considerable slowdown since the
+        ``Lo`` category has more than 40,000 characters in it!
+
+      The default value is ``basic``.
+
+    .. versionadded:: 1.5
+    """
+
+    name = 'Nemerle'
+    url = 'http://nemerle.org'
+    aliases = ['nemerle']
+    filenames = ['*.n']
+    mimetypes = ['text/x-nemerle']  # inferred
+
+    flags = re.MULTILINE | re.DOTALL
+
+    # for the range of allowed unicode characters in identifiers, see
+    # http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-334.pdf
+
+    levels = {
+        'none': r'@?[_a-zA-Z]\w*',
+        'basic': ('@?[_' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Nl') + ']' +
+                  '[' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Nl', 'Nd', 'Pc',
+                                    'Cf', 'Mn', 'Mc') + ']*'),
+        'full': ('@?(?:_|[^' +
+                 uni.allexcept('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl') + '])' +
+                 '[^' + uni.allexcept('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl',
+                                      'Nd', 'Pc', 'Cf', 'Mn', 'Mc') + ']*'),
+    }
+
+    tokens = {}
+    token_variants = True
+
+    for levelname, cs_ident in levels.items():
+        tokens[levelname] = {
+            'root': [
+                # method names
+                (r'^([ \t]*)((?:' + cs_ident + r'(?:\[\])?\s+)+?)'  # return type
+                 r'(' + cs_ident + ')'                            # method name
+                 r'(\s*)(\()',                               # signature start
+                 bygroups(Whitespace, using(this), Name.Function, Whitespace, \
+                          Punctuation)),
+                (r'^(\s*)(\[.*?\])', bygroups(Whitespace, Name.Attribute)),
+                (r'[^\S\n]+', Whitespace),
+                (r'(\\)(\n)', bygroups(Text, Whitespace)),  # line continuation
+                (r'//.*?\n', Comment.Single),
+                (r'/[*].*?[*]/', Comment.Multiline),
+                (r'\n', Whitespace),
+                (r'(\$)(\s*)(")', bygroups(String, Whitespace, String),
+                    'splice-string'),
+                (r'(\$)(\s*)(<#)', bygroups(String, Whitespace, String),
+                    'splice-string2'),
+                (r'<#', String, 'recursive-string'),
+
+                (r'(<\[)(\s*)(' + cs_ident + ':)?',
+                 bygroups(Keyword, Whitespace, Keyword)),
+                (r'\]\>', Keyword),
+
+                # quasiquotation only
+                (r'\$' + cs_ident, Name),
+                (r'(\$)(\()', bygroups(Name, Punctuation),
+                 'splice-string-content'),
+
+                (r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation),
+                (r'[{}]', Punctuation),
+                (r'@"(""|[^"])*"', String),
+                (r'"(\\\\|\\[^\\]|[^"\\\n])*["\n]', String),
+                (r"'\\.'|'[^\\]'", String.Char),
+                (r"0[xX][0-9a-fA-F]+[Ll]?", Number),
+                (r"[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFLdD]?", Number),
+                (r'(#)([ \t]*)(if|endif|else|elif|define|undef|'
+                 r'line|error|warning|region|endregion|pragma)\b',
+                 bygroups(Comment.Preproc, Whitespace, Comment.Preproc), 'preproc'),
+                (r'\b(extern)(\s+)(alias)\b', bygroups(Keyword, Whitespace, Keyword)),
+                (r'(abstract|and|as|base|catch|def|delegate|'
+                 r'enum|event|extern|false|finally|'
+                 r'fun|implements|interface|internal|'
+                 r'is|macro|match|matches|module|mutable|new|'
+                 r'null|out|override|params|partial|private|'
+                 r'protected|public|ref|sealed|static|'
+                 r'syntax|this|throw|true|try|type|typeof|'
+                 r'virtual|volatile|when|where|with|'
+                 r'assert|assert2|async|break|checked|continue|do|else|'
+                 r'ensures|for|foreach|if|late|lock|new|nolate|'
+                 r'otherwise|regexp|repeat|requires|return|surroundwith|'
+                 r'unchecked|unless|using|while|yield)\b', Keyword),
+                (r'(global)(::)', bygroups(Keyword, Punctuation)),
+                (r'(bool|byte|char|decimal|double|float|int|long|object|sbyte|'
+                 r'short|string|uint|ulong|ushort|void|array|list)\b\??',
+                 Keyword.Type),
+                (r'(:>?)(\s*)(' + cs_ident + r'\??)',
+                 bygroups(Punctuation, Whitespace, Keyword.Type)),
+                (r'(class|struct|variant|module)(\s+)',
+                 bygroups(Keyword, Whitespace), 'class'),
+                (r'(namespace|using)(\s+)', bygroups(Keyword, Whitespace),
+                 'namespace'),
+                (cs_ident, Name),
+            ],
+            'class': [
+                (cs_ident, Name.Class, '#pop')
+            ],
+            'preproc': [
+                (r'\w+', Comment.Preproc),
+                (r'[ \t]+', Whitespace),
+                (r'\n', Whitespace, '#pop')
+            ],
+            'namespace': [
+                (r'(?=\()', Text, '#pop'),  # using (resource)
+                ('(' + cs_ident + r'|\.)+', Name.Namespace, '#pop')
+            ],
+            'splice-string': [
+                (r'[^"$]',  String),
+                (r'\$' + cs_ident, Name),
+                (r'(\$)(\()', bygroups(Name, Punctuation),
+                 'splice-string-content'),
+                (r'\\"',  String),
+                (r'"',  String, '#pop')
+            ],
+            'splice-string2': [
+                (r'[^#<>$]',  String),
+                (r'\$' + cs_ident, Name),
+                (r'(\$)(\()', bygroups(Name, Punctuation),
+                 'splice-string-content'),
+                (r'<#',  String, '#push'),
+                (r'#>',  String, '#pop')
+            ],
+            'recursive-string': [
+                (r'[^#<>]',  String),
+                (r'<#',  String, '#push'),
+                (r'#>',  String, '#pop')
+            ],
+            'splice-string-content': [
+                (r'if|match', Keyword),
+                (r'[~!%^&*+=|\[\]:;,.<>/?-\\"$ ]', Punctuation),
+                (cs_ident, Name),
+                (r'\d+', Number),
+                (r'\(', Punctuation, '#push'),
+                (r'\)', Punctuation, '#pop')
+            ]
+        }
+
+    def __init__(self, **options):
+        level = get_choice_opt(options, 'unicodelevel', list(self.tokens),
+                               'basic')
+        if level not in self._all_tokens:
+            # compile the regexes now
+            self._tokens = self.__class__.process_tokendef(level)
+        else:
+            self._tokens = self._all_tokens[level]
+
+        RegexLexer.__init__(self, **options)
+
+    def analyse_text(text):
+        """Nemerle is quite similar to Python, but @if is relatively uncommon
+        elsewhere."""
+        result = 0
+
+        if '@if' in text:
+            result += 0.1
+
+        return result
+
+
+class BooLexer(RegexLexer):
+    """
+    For Boo source code.
+    """
+
+    name = 'Boo'
+    url = 'https://github.com/boo-lang/boo'
+    aliases = ['boo']
+    filenames = ['*.boo']
+    mimetypes = ['text/x-boo']
+
+    tokens = {
+        'root': [
+            (r'\s+', Whitespace),
+            (r'(#|//).*$', Comment.Single),
+            (r'/[*]', Comment.Multiline, 'comment'),
+            (r'[]{}:(),.;[]', Punctuation),
+            (r'(\\)(\n)', bygroups(Text, Whitespace)),
+            (r'\\', Text),
+            (r'(in|is|and|or|not)\b', Operator.Word),
+            (r'/(\\\\|\\[^\\]|[^/\\\s])/', String.Regex),
+            (r'@/(\\\\|\\[^\\]|[^/\\])*/', String.Regex),
+            (r'=~|!=|==|<<|>>|[-+/*%=<>&^|]', Operator),
+            (r'(as|abstract|callable|constructor|destructor|do|import|'
+             r'enum|event|final|get|interface|internal|of|override|'
+             r'partial|private|protected|public|return|set|static|'
+             r'struct|transient|virtual|yield|super|and|break|cast|'
+             r'continue|elif|else|ensure|except|for|given|goto|if|in|'
+             r'is|isa|not|or|otherwise|pass|raise|ref|try|unless|when|'
+             r'while|from|as)\b', Keyword),
+            (r'def(?=\s+\(.*?\))', Keyword),
+            (r'(def)(\s+)', bygroups(Keyword, Whitespace), 'funcname'),
+            (r'(class)(\s+)', bygroups(Keyword, Whitespace), 'classname'),
+            (r'(namespace)(\s+)', bygroups(Keyword, Whitespace), 'namespace'),
+            (r'(?<!\.)(true|false|null|self|__eval__|__switch__|array|'
+             r'assert|checked|enumerate|filter|getter|len|lock|map|'
+             r'matrix|max|min|normalArrayIndexing|print|property|range|'
+             r'rawArrayIndexing|required|typeof|unchecked|using|'
+             r'yieldAll|zip)\b', Name.Builtin),
+            (r'"""(\\\\|\\"|.*?)"""', String.Double),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
+            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+            (r'[a-zA-Z_]\w*', Name),
+            (r'(\d+\.\d*|\d*\.\d+)([fF][+-]?[0-9]+)?', Number.Float),
+            (r'[0-9][0-9.]*(ms?|d|h|s)', Number),
+            (r'0\d+', Number.Oct),
+            (r'0x[a-fA-F0-9]+', Number.Hex),
+            (r'\d+L', Number.Integer.Long),
+            (r'\d+', Number.Integer),
+        ],
+        'comment': [
+            ('/[*]', Comment.Multiline, '#push'),
+            ('[*]/', Comment.Multiline, '#pop'),
+            ('[^/*]', Comment.Multiline),
+            ('[*/]', Comment.Multiline)
+        ],
+        'funcname': [
+            (r'[a-zA-Z_]\w*', Name.Function, '#pop')
+        ],
+        'classname': [
+            (r'[a-zA-Z_]\w*', Name.Class, '#pop')
+        ],
+        'namespace': [
+            (r'[a-zA-Z_][\w.]*', Name.Namespace, '#pop')
+        ]
+    }
+
+
+class VbNetLexer(RegexLexer):
+    """
+    For Visual Basic.NET source code.
+    Also LibreOffice Basic, OpenOffice Basic, and StarOffice Basic.
+    """
+
+    name = 'VB.net'
+    url = 'https://docs.microsoft.com/en-us/dotnet/visual-basic/'
+    aliases = ['vb.net', 'vbnet', 'lobas', 'oobas', 'sobas']
+    filenames = ['*.vb', '*.bas']
+    mimetypes = ['text/x-vbnet', 'text/x-vba']  # (?)
+
+    uni_name = '[_' + uni.combine('Ll', 'Lt', 'Lm', 'Nl') + ']' + \
+               '[' + uni.combine('Ll', 'Lt', 'Lm', 'Nl', 'Nd', 'Pc',
+                                 'Cf', 'Mn', 'Mc') + ']*'
+
+    flags = re.MULTILINE | re.IGNORECASE
+    tokens = {
+        'root': [
+            (r'^\s*<.*?>', Name.Attribute),
+            (r'\s+', Whitespace),
+            (r'\n', Whitespace),
+            (r'(rem\b.*?)(\n)', bygroups(Comment, Whitespace)),
+            (r"('.*?)(\n)", bygroups(Comment, Whitespace)),
+            (r'#If\s.*?\sThen|#ElseIf\s.*?\sThen|#Else|#End\s+If|#Const|'
+             r'#ExternalSource.*?\n|#End\s+ExternalSource|'
+             r'#Region.*?\n|#End\s+Region|#ExternalChecksum',
+             Comment.Preproc),
+            (r'[(){}!#,.:]', Punctuation),
+            (r'(Option)(\s+)(Strict|Explicit|Compare)(\s+)'
+             r'(On|Off|Binary|Text)',
+             bygroups(Keyword.Declaration, Whitespace, Keyword.Declaration,
+                      Whitespace, Keyword.Declaration)),
+            (words((
+                'AddHandler', 'Alias', 'ByRef', 'ByVal', 'Call', 'Case',
+                'Catch', 'CBool', 'CByte', 'CChar', 'CDate', 'CDec', 'CDbl',
+                'CInt', 'CLng', 'CObj', 'Continue', 'CSByte', 'CShort', 'CSng',
+                'CStr', 'CType', 'CUInt', 'CULng', 'CUShort', 'Declare',
+                'Default', 'Delegate', 'DirectCast', 'Do', 'Each', 'Else',
+                'ElseIf', 'EndIf', 'Erase', 'Error', 'Event', 'Exit', 'False',
+                'Finally', 'For', 'Friend', 'Get', 'Global', 'GoSub', 'GoTo',
+                'Handles', 'If', 'Implements', 'Inherits', 'Interface', 'Let',
+                'Lib', 'Loop', 'Me', 'MustInherit', 'MustOverride', 'MyBase',
+                'MyClass', 'Narrowing', 'New', 'Next', 'Not', 'Nothing',
+                'NotInheritable', 'NotOverridable', 'Of', 'On', 'Operator',
+                'Option', 'Optional', 'Overloads', 'Overridable', 'Overrides',
+                'ParamArray', 'Partial', 'Private', 'Protected', 'Public',
+                'RaiseEvent', 'ReadOnly', 'ReDim', 'RemoveHandler', 'Resume',
+                'Return', 'Select', 'Set', 'Shadows', 'Shared', 'Single',
+                'Static', 'Step', 'Stop', 'SyncLock', 'Then', 'Throw', 'To',
+                'True', 'Try', 'TryCast', 'Wend', 'Using', 'When', 'While',
+                'Widening', 'With', 'WithEvents', 'WriteOnly'),
+                   prefix=r'(?<!\.)', suffix=r'\b'), Keyword),
+            (r'(?<!\.)End\b', Keyword, 'end'),
+            (r'(?<!\.)(Dim|Const)\b', Keyword, 'dim'),
+            (r'(?<!\.)(Function|Sub|Property)(\s+)',
+             bygroups(Keyword, Whitespace), 'funcname'),
+            (r'(?<!\.)(Class|Structure|Enum)(\s+)',
+             bygroups(Keyword, Whitespace), 'classname'),
+            (r'(?<!\.)(Module|Namespace|Imports)(\s+)',
+             bygroups(Keyword, Whitespace), 'namespace'),
+            (r'(?<!\.)(Boolean|Byte|Char|Date|Decimal|Double|Integer|Long|'
+             r'Object|SByte|Short|Single|String|Variant|UInteger|ULong|'
+             r'UShort)\b', Keyword.Type),
+            (r'(?<!\.)(AddressOf|And|AndAlso|As|GetType|In|Is|IsNot|Like|Mod|'
+             r'Or|OrElse|TypeOf|Xor)\b', Operator.Word),
+            (r'&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|'
+             r'<=|>=|<>|[-&*/\\^+=<>\[\]]',
+             Operator),
+            ('"', String, 'string'),
+            (r'(_)(\n)', bygroups(Text, Whitespace)),  # Line continuation  (must be before Name)
+            (uni_name + '[%&@!#$]?', Name),
+            ('#.*?#', Literal.Date),
+            (r'(\d+\.\d*|\d*\.\d+)(F[+-]?[0-9]+)?', Number.Float),
+            (r'\d+([SILDFR]|US|UI|UL)?', Number.Integer),
+            (r'&H[0-9a-f]+([SILDFR]|US|UI|UL)?', Number.Integer),
+            (r'&O[0-7]+([SILDFR]|US|UI|UL)?', Number.Integer),
+        ],
+        'string': [
+            (r'""', String),
+            (r'"C?', String, '#pop'),
+            (r'[^"]+', String),
+        ],
+        'dim': [
+            (uni_name, Name.Variable, '#pop'),
+            default('#pop'),  # any other syntax
+        ],
+        'funcname': [
+            (uni_name, Name.Function, '#pop'),
+        ],
+        'classname': [
+            (uni_name, Name.Class, '#pop'),
+        ],
+        'namespace': [
+            (uni_name, Name.Namespace),
+            (r'\.', Name.Namespace),
+            default('#pop'),
+        ],
+        'end': [
+            (r'\s+', Whitespace),
+            (r'(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b',
+             Keyword, '#pop'),
+            default('#pop'),
+        ]
+    }
+
+    def analyse_text(text):
+        if re.search(r'^\s*(#If|Module|Namespace)', text, re.MULTILINE):
+            return 0.5
+
+
+class GenericAspxLexer(RegexLexer):
+    """
+    Lexer for ASP.NET pages.
+    """
+
+    name = 'aspx-gen'
+    filenames = []
+    mimetypes = []
+
+    flags = re.DOTALL
+
+    tokens = {
+        'root': [
+            (r'(<%[@=#]?)(.*?)(%>)', bygroups(Name.Tag, Other, Name.Tag)),
+            (r'(<script.*?>)(.*?)(</script>)', bygroups(using(XmlLexer),
+                                                        Other,
+                                                        using(XmlLexer))),
+            (r'(.+?)(?=<)', using(XmlLexer)),
+            (r'.+', using(XmlLexer)),
+        ],
+    }
+
+
+# TODO support multiple languages within the same source file
+class CSharpAspxLexer(DelegatingLexer):
+    """
+    Lexer for highlighting C# within ASP.NET pages.
+    """
+
+    name = 'aspx-cs'
+    aliases = ['aspx-cs']
+    filenames = ['*.aspx', '*.asax', '*.ascx', '*.ashx', '*.asmx', '*.axd']
+    mimetypes = []
+
+    def __init__(self, **options):
+        super().__init__(CSharpLexer, GenericAspxLexer, **options)
+
+    def analyse_text(text):
+        if re.search(r'Page\s*Language="C#"', text, re.I) is not None:
+            return 0.2
+        elif re.search(r'script[^>]+language=["\']C#', text, re.I) is not None:
+            return 0.15
+
+
+class VbNetAspxLexer(DelegatingLexer):
+    """
+    Lexer for highlighting Visual Basic.net within ASP.NET pages.
+    """
+
+    name = 'aspx-vb'
+    aliases = ['aspx-vb']
+    filenames = ['*.aspx', '*.asax', '*.ascx', '*.ashx', '*.asmx', '*.axd']
+    mimetypes = []
+
+    def __init__(self, **options):
+        super().__init__(VbNetLexer, GenericAspxLexer, **options)
+
+    def analyse_text(text):
+        if re.search(r'Page\s*Language="Vb"', text, re.I) is not None:
+            return 0.2
+        elif re.search(r'script[^>]+language=["\']vb', text, re.I) is not None:
+            return 0.15
+
+
+# Very close to functional.OcamlLexer
+class FSharpLexer(RegexLexer):
+    """
+    For the F# language (version 3.0).
+
+    .. versionadded:: 1.5
+    """
+
+    name = 'F#'
+    url = 'https://fsharp.org/'
+    aliases = ['fsharp', 'f#']
+    filenames = ['*.fs', '*.fsi', '*.fsx']
+    mimetypes = ['text/x-fsharp']
+
+    keywords = [
+        'abstract', 'as', 'assert', 'base', 'begin', 'class', 'default',
+        'delegate', 'do!', 'do', 'done', 'downcast', 'downto', 'elif', 'else',
+        'end', 'exception', 'extern', 'false', 'finally', 'for', 'function',
+        'fun', 'global', 'if', 'inherit', 'inline', 'interface', 'internal',
+        'in', 'lazy', 'let!', 'let', 'match', 'member', 'module', 'mutable',
+        'namespace', 'new', 'null', 'of', 'open', 'override', 'private', 'public',
+        'rec', 'return!', 'return', 'select', 'static', 'struct', 'then', 'to',
+        'true', 'try', 'type', 'upcast', 'use!', 'use', 'val', 'void', 'when',
+        'while', 'with', 'yield!', 'yield',
+    ]
+    # Reserved words; cannot hurt to color them as keywords too.
+    keywords += [
+        'atomic', 'break', 'checked', 'component', 'const', 'constraint',
+        'constructor', 'continue', 'eager', 'event', 'external', 'fixed',
+        'functor', 'include', 'method', 'mixin', 'object', 'parallel',
+        'process', 'protected', 'pure', 'sealed', 'tailcall', 'trait',
+        'virtual', 'volatile',
+    ]
+    keyopts = [
+        '!=', '#', '&&', '&', r'\(', r'\)', r'\*', r'\+', ',', r'-\.',
+        '->', '-', r'\.\.', r'\.', '::', ':=', ':>', ':', ';;', ';', '<-',
+        r'<\]', '<', r'>\]', '>', r'\?\?', r'\?', r'\[<', r'\[\|', r'\[', r'\]',
+        '_', '`', r'\{', r'\|\]', r'\|', r'\}', '~', '<@@', '<@', '=', '@>', '@@>',
+    ]
+
+    operators = r'[!$%&*+\./:<=>?@^|~-]'
+    word_operators = ['and', 'or', 'not']
+    prefix_syms = r'[!?~]'
+    infix_syms = r'[=<>@^|&+\*/$%-]'
+    primitives = [
+        'sbyte', 'byte', 'char', 'nativeint', 'unativeint', 'float32', 'single',
+        'float', 'double', 'int8', 'uint8', 'int16', 'uint16', 'int32',
+        'uint32', 'int64', 'uint64', 'decimal', 'unit', 'bool', 'string',
+        'list', 'exn', 'obj', 'enum',
+    ]
+
+    # See http://msdn.microsoft.com/en-us/library/dd233181.aspx and/or
+    # http://fsharp.org/about/files/spec.pdf for reference.  Good luck.
+
+    tokens = {
+        'escape-sequence': [
+            (r'\\[\\"\'ntbrafv]', String.Escape),
+            (r'\\[0-9]{3}', String.Escape),
+            (r'\\u[0-9a-fA-F]{4}', String.Escape),
+            (r'\\U[0-9a-fA-F]{8}', String.Escape),
+        ],
+        'root': [
+            (r'\s+', Whitespace),
+            (r'\(\)|\[\]', Name.Builtin.Pseudo),
+            (r'\b(?<!\.)([A-Z][\w\']*)(?=\s*\.)',
+             Name.Namespace, 'dotted'),
+            (r'\b([A-Z][\w\']*)', Name),
+            (r'(///.*?)(\n)', bygroups(String.Doc, Whitespace)),
+            (r'(//.*?)(\n)', bygroups(Comment.Single, Whitespace)),
+            (r'\(\*(?!\))', Comment, 'comment'),
+
+            (r'@"', String, 'lstring'),
+            (r'"""', String, 'tqs'),
+            (r'"', String, 'string'),
+
+            (r'\b(open|module)(\s+)([\w.]+)',
+             bygroups(Keyword, Whitespace, Name.Namespace)),
+            (r'\b(let!?)(\s+)(\w+)',
+             bygroups(Keyword, Whitespace, Name.Variable)),
+            (r'\b(type)(\s+)(\w+)',
+             bygroups(Keyword, Whitespace, Name.Class)),
+            (r'\b(member|override)(\s+)(\w+)(\.)(\w+)',
+             bygroups(Keyword, Whitespace, Name, Punctuation, Name.Function)),
+            (r'\b(%s)\b' % '|'.join(keywords), Keyword),
+            (r'``([^`\n\r\t]|`[^`\n\r\t])+``', Name),
+            (r'(%s)' % '|'.join(keyopts), Operator),
+            (r'(%s|%s)?%s' % (infix_syms, prefix_syms, operators), Operator),
+            (r'\b(%s)\b' % '|'.join(word_operators), Operator.Word),
+            (r'\b(%s)\b' % '|'.join(primitives), Keyword.Type),
+            (r'(#)([ \t]*)(if|endif|else|line|nowarn|light|\d+)\b(.*?)(\n)',
+             bygroups(Comment.Preproc, Whitespace, Comment.Preproc,
+                      Comment.Preproc, Whitespace)),
+
+            (r"[^\W\d][\w']*", Name),
+
+            (r'\d[\d_]*[uU]?[yslLnQRZINGmM]?', Number.Integer),
+            (r'0[xX][\da-fA-F][\da-fA-F_]*[uU]?[yslLn]?[fF]?', Number.Hex),
+            (r'0[oO][0-7][0-7_]*[uU]?[yslLn]?', Number.Oct),
+            (r'0[bB][01][01_]*[uU]?[yslLn]?', Number.Bin),
+            (r'-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)[fFmM]?',
+             Number.Float),
+
+            (r"'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'B?",
+             String.Char),
+            (r"'.'", String.Char),
+            (r"'", Keyword),  # a stray quote is another syntax element
+
+            (r'@?"', String.Double, 'string'),
+
+            (r'[~?][a-z][\w\']*:', Name.Variable),
+        ],
+        'dotted': [
+            (r'\s+', Whitespace),
+            (r'\.', Punctuation),
+            (r'[A-Z][\w\']*(?=\s*\.)', Name.Namespace),
+            (r'[A-Z][\w\']*', Name, '#pop'),
+            (r'[a-z_][\w\']*', Name, '#pop'),
+            # e.g. dictionary index access
+            default('#pop'),
+        ],
+        'comment': [
+            (r'[^(*)@"]+', Comment),
+            (r'\(\*', Comment, '#push'),
+            (r'\*\)', Comment, '#pop'),
+            # comments cannot be closed within strings in comments
+            (r'@"', String, 'lstring'),
+            (r'"""', String, 'tqs'),
+            (r'"', String, 'string'),
+            (r'[(*)@]', Comment),
+        ],
+        'string': [
+            (r'[^\\"]+', String),
+            include('escape-sequence'),
+            (r'\\\n', String),
+            (r'\n', String),  # newlines are allowed in any string
+            (r'"B?', String, '#pop'),
+        ],
+        'lstring': [
+            (r'[^"]+', String),
+            (r'\n', String),
+            (r'""', String),
+            (r'"B?', String, '#pop'),
+        ],
+        'tqs': [
+            (r'[^"]+', String),
+            (r'\n', String),
+            (r'"""B?', String, '#pop'),
+            (r'"', String),
+        ],
+    }
+
+    def analyse_text(text):
+        """F# doesn't have that many unique features -- |> and <| are weak
+        indicators."""
+        result = 0
+        if '|>' in text:
+            result += 0.05
+        if '<|' in text:
+            result += 0.05
+
+        return result
+
+
+class XppLexer(RegexLexer):
+
+    """
+    For X++ source code. This is based loosely on the CSharpLexer
+
+    .. versionadded:: 2.15
+    """
+
+    name = 'X++'
+    url = 'https://learn.microsoft.com/en-us/dynamics365/fin-ops-core/dev-itpro/dev-ref/xpp-language-reference'
+    aliases = ['xpp', 'x++']
+    filenames = ['*.xpp']
+
+    flags = re.MULTILINE
+
+    XPP_CHARS = ('@?(?:_|[^' +
+                 uni.allexcept('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl') + '])' +
+                 '[^' + uni.allexcept('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl',
+                                      'Nd', 'Pc', 'Cf', 'Mn', 'Mc') + ']*');
+    # Temporary, see
+    # https://github.com/thatch/regexlint/pull/49
+    XPP_CHARS = XPP_CHARS.replace('\x00', '\x01')
+
+    OPERATORS = (
+                    '<=', '>=', '+=', '-=', '*=', '/=', '!=', '==',
+                    '&&', '||', '>>', '<<', '++', '--', '+', '-', '*',
+                    '/', '%', '&', '|', '^', '<', '>', '?', '!', '~', '=',
+                )
+    KEYWORDS = ('abstract','anytype','as','async','asc','at','avg','break','breakpoint','by','byref','case','catch',
+                 'changecompany','client','container','continue','count','crosscompany','default','delegate',
+                 'delete_from','desc','display','div','do','edit','else','element','eventhandler','exists','false','final',
+                 'firstfast','firstonly','firstonly10','firstonly100','firstonly1000','flush','for','forceliterals',
+                 'forcenestedloop','forceplaceholders','forceselectorder','forupdate','from','group','if','insert_recordset',
+                 'interface','is','join','like','maxof','minof','mod','new','next','nofetch','notexists','null','optimisticlock','order',
+                 'outer','pause','pessimisticlock','print','private','protected','public','repeatableread','retry','return',
+                 'reverse','select','server','setting','static','sum','super','switch','tablelock','this','throw','true','try','ttsabort','ttsbegin',
+                 'ttscommit','update_recordset','validtimestate','void','where','while','window')
+    RUNTIME_FUNCTIONS = ('_duration','abs','acos','any2Date','any2Enum','any2Guid','any2Int','any2Int64','any2Real','any2Str','anytodate',
+                 'anytoenum','anytoguid','anytoint','anytoint64','anytoreal','anytostr','asin','atan','beep','cTerm','char2Num','classIdGet',
+                 'corrFlagGet','corrFlagSet','cos','cosh','curExt','curUserId','date2Num','date2Str','datetime2Str','dayName','dayOfMth',
+                 'dayOfWk','dayOfYr','ddb','decRound','dg','dimOf','endMth','enum2str','exp','exp10','fV','fieldId2Name','fieldId2PName',
+                 'fieldName2Id','frac','funcName','getCurrentPartition','getCurrentPartitionRecId','getPrefix','guid2Str','idg','indexId2Name',
+                 'indexName2Id','int2Str','int642Str','intvMax','intvName','intvNo','intvNorm','log10','logN','match','max','min','mkDate','mthName',
+                 'mthOfYr','newGuid','nextMth','nextQtr','nextYr','num2Char','num2Date','num2Str','pmt','power','prevMth','prevQtr','prevYr',
+                 'prmIsDefault','pt','pv','rate','refPrintAll','round','runAs','sessionId','setPrefix','sin','sinh','sleep','sln','str2Date',
+                 'str2Datetime','str2Enum','str2Guid','str2Int','str2Int64','str2Num','str2Time','strAlpha','strCmp','strColSeq','strDel',
+                 'strFind','strFmt','strIns','strKeep','strLTrim','strLen','strLine','strLwr','strNFind','strPoke','strPrompt','strRTrim',
+                 'strRem','strRep','strScan','strUpr','subStr','syd','systemDateGet','systemDateSet','tableId2Name',
+                 'tableId2PName','tableName2Id','tan','tanh','term','time2Str','timeNow','today','trunc','typeOf','uint2Str','wkOfYr','year')
+    COMPILE_FUNCTIONS = ('attributeStr','classNum','classStr','configurationKeyNum','configurationKeyStr','dataEntityDataSourceStr','delegateStr',
+                 'dimensionHierarchyLevelStr','dimensionHierarchyStr','dimensionReferenceStr','dutyStr','enumCnt','enumLiteralStr','enumNum','enumStr',
+                 'extendedTypeNum','extendedTypeStr','fieldNum','fieldPName','fieldStr','formControlStr','formDataFieldStr','formDataSourceStr',
+                 'formMethodStr','formStr','identifierStr','indexNum','indexStr','licenseCodeNum','licenseCodeStr','literalStr','maxDate','maxInt',
+                 'measureStr','measurementStr','menuItemActionStr','menuItemDisplayStr','menuItemOutputStr','menuStr','methodStr','minInt','privilegeStr',
+                 'queryDatasourceStr','queryMethodStr','queryStr','reportStr','resourceStr','roleStr','ssrsReportStr','staticDelegateStr','staticMethodStr',
+                 'tableCollectionStr','tableFieldGroupStr','tableMethodStr','tableNum','tablePName','tableStaticMethodStr','tableStr','tileStr','varStr',
+                 'webActionItemStr','webDisplayContentItemStr','webFormStr','webMenuStr','webOutputContentItemStr','webReportStr','webSiteTempStr',
+                 'webStaticFileStr','webUrlItemStr','webWebPartStr','webletItemStr','webpageDefStr','websiteDefStr','workflowApprovalStr',
+                 'workflowCategoryStr','workflowTaskStr','workflowTypeStr')
+
+    tokens = {}
+
+    tokens = {
+        'root': [
+            # method names
+            (r'(\s*)\b(else|if)\b([^\n])', bygroups(Whitespace, Keyword, using(this))), # ensure that if is not treated like a function
+            (r'^([ \t]*)((?:' + XPP_CHARS + r'(?:\[\])?\s+)+?)'  # return type
+                r'(' + XPP_CHARS + ')'                            # method name
+                r'(\s*)(\()',                               # signature start
+                bygroups(Whitespace, using(this), Name.Function, Whitespace,
+                        Punctuation)),
+            (r'^(\s*)(\[)([^\n]*?)(\])', bygroups(Whitespace, Name.Attribute, Name.Variable.Class, Name.Attribute)),
+            (r'[^\S\n]+', Whitespace),
+            (r'(\\)(\n)', bygroups(Text, Whitespace)),  # line continuation
+            (r'//[^\n]*?\n', Comment.Single),
+            (r'/[*][^\n]*?[*]/', Comment.Multiline),
+            (r'\n', Whitespace),
+            (words(OPERATORS), Operator),
+            (r'=~|!=|==|<<|>>|[-+/*%=<>&^|]', Operator),
+            (r'[()\[\];:,.#@]', Punctuation),
+            (r'[{}]', Punctuation),
+            (r'@"(""|[^"])*"', String),
+            (r'\$?"(\\\\|\\[^\\]|[^"\\\n])*["\n]', String),
+            (r"'\\.'|'[^\\]'", String.Char),
+            (r"[0-9]+(\.[0-9]*)?([eE][+-][0-9]+)?"
+                r"[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?", Number),
+            (words(KEYWORDS, suffix=r'\b'), Keyword),
+            (r'(boolean|int|int64|str|real|guid|date)\b\??', Keyword.Type),
+            (r'(class|struct|extends|implements)(\s+)', bygroups(Keyword, Whitespace), 'class'),
+            (r'('+XPP_CHARS+')(::)', bygroups(Name.Variable.Class, Punctuation)),
+            (r'(\s*)(\w+)(\s+\w+(,|=)?[^\n]*;)', bygroups(Whitespace, Name.Variable.Class, using(this))), # declaration
+            # x++ specific function to get field should highlight the classname
+            (r'(fieldNum\()('+XPP_CHARS+r')(\s*,\s*)('+XPP_CHARS+r')(\s*\))',
+                bygroups(using(this), Name.Variable.Class, using(this), Name.Property, using(this))),
+            # x++ specific function to get table should highlight the classname
+            (r'(tableNum\()('+XPP_CHARS+r')(\s*\))',
+                bygroups(using(this), Name.Variable.Class, using(this))),
+            (words(RUNTIME_FUNCTIONS, suffix=r'(?=\()'), Name.Function.Magic),
+            (words(COMPILE_FUNCTIONS, suffix=r'(?=\()'), Name.Function.Magic),
+            (XPP_CHARS, Name),
+        ],
+        'class': [
+            (XPP_CHARS, Name.Class, '#pop'),
+            default('#pop'),
+        ],
+        'namespace': [
+            (r'(?=\()', Text, '#pop'),  # using (resource)
+            ('(' + XPP_CHARS + r'|\.)+', Name.Namespace, '#pop'),
+        ]
+    }

shared/package-files/56/5637254ab13a7f25d7584d074a6c0fa33cde89d8b7a9f397d94291ce47025fd0/blob

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

shared/package-files/56/563906875503fa2d734c3035757a35b9e712b3a3f11dd190e6f94293f982098b/blob

@@ -0,0 +1,35 @@
+import sys
+
+
+def main(args=None):
+    if args is None:
+        args = sys.argv[1:]
+
+    # TODO Handle library-wide options. Eg.:
+    # --unicodedata
+    # --verbose / other logging stuff
+
+    # TODO Allow a way to run arbitrary modules? Useful for setting
+    # library-wide options and calling another library. Eg.:
+    #
+    #   $ fonttools --unicodedata=... fontmake ...
+    #
+    # This allows for a git-like command where thirdparty commands
+    # can be added.  Should we just try importing the fonttools
+    # module first and try without if it fails?
+
+    if len(sys.argv) < 2:
+        sys.argv.append("help")
+    if sys.argv[1] == "-h" or sys.argv[1] == "--help":
+        sys.argv[1] = "help"
+    mod = "fontTools." + sys.argv[1]
+    sys.argv[1] = sys.argv[0] + " " + sys.argv[1]
+    del sys.argv[0]
+
+    import runpy
+
+    runpy.run_module(mod, run_name="__main__")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

shared/package-files/56/56396fd018eb070fa3025504ec0605f95dfe1aa31824ef3068d3a92c144ab373/blob

@@ -0,0 +1,104 @@
+import sys
+from typing import Any, AsyncIterator, Awaitable, Callable, Iterable, Optional, Tuple, Union
+
+from . import events, protocols, transports
+
+_ClientConnectedCallback = Callable[[StreamReader, StreamWriter], Optional[Awaitable[None]]]
+
+if sys.version_info < (3, 8):
+    class IncompleteReadError(EOFError):
+        expected: Optional[int]
+        partial: bytes
+        def __init__(self, partial: bytes, expected: Optional[int]) -> None: ...
+    class LimitOverrunError(Exception):
+        consumed: int
+        def __init__(self, message: str, consumed: int) -> None: ...
+
+async def open_connection(
+    host: Optional[str] = ...,
+    port: Optional[Union[int, str]] = ...,
+    *,
+    loop: Optional[events.AbstractEventLoop] = ...,
+    limit: int = ...,
+    ssl_handshake_timeout: Optional[float] = ...,
+    **kwds: Any,
+) -> Tuple[StreamReader, StreamWriter]: ...
+async def start_server(
+    client_connected_cb: _ClientConnectedCallback,
+    host: Optional[str] = ...,
+    port: Optional[Union[int, str]] = ...,
+    *,
+    loop: Optional[events.AbstractEventLoop] = ...,
+    limit: int = ...,
+    ssl_handshake_timeout: Optional[float] = ...,
+    **kwds: Any,
+) -> events.AbstractServer: ...
+
+if sys.platform != "win32":
+    if sys.version_info >= (3, 7):
+        from os import PathLike
+
+        _PathType = Union[str, PathLike[str]]
+    else:
+        _PathType = str
+    async def open_unix_connection(
+        path: Optional[_PathType] = ..., *, loop: Optional[events.AbstractEventLoop] = ..., limit: int = ..., **kwds: Any
+    ) -> Tuple[StreamReader, StreamWriter]: ...
+    async def start_unix_server(
+        client_connected_cb: _ClientConnectedCallback,
+        path: Optional[_PathType] = ...,
+        *,
+        loop: Optional[events.AbstractEventLoop] = ...,
+        limit: int = ...,
+        **kwds: Any,
+    ) -> events.AbstractServer: ...
+
+class FlowControlMixin(protocols.Protocol): ...
+
+class StreamReaderProtocol(FlowControlMixin, protocols.Protocol):
+    def __init__(
+        self,
+        stream_reader: StreamReader,
+        client_connected_cb: Optional[_ClientConnectedCallback] = ...,
+        loop: Optional[events.AbstractEventLoop] = ...,
+    ) -> None: ...
+    def connection_made(self, transport: transports.BaseTransport) -> None: ...
+    def connection_lost(self, exc: Optional[Exception]) -> None: ...
+    def data_received(self, data: bytes) -> None: ...
+    def eof_received(self) -> bool: ...
+
+class StreamWriter:
+    def __init__(
+        self,
+        transport: transports.BaseTransport,
+        protocol: protocols.BaseProtocol,
+        reader: Optional[StreamReader],
+        loop: events.AbstractEventLoop,
+    ) -> None: ...
+    @property
+    def transport(self) -> transports.BaseTransport: ...
+    def write(self, data: bytes) -> None: ...
+    def writelines(self, data: Iterable[bytes]) -> None: ...
+    def write_eof(self) -> None: ...
+    def can_write_eof(self) -> bool: ...
+    def close(self) -> None: ...
+    if sys.version_info >= (3, 7):
+        def is_closing(self) -> bool: ...
+        async def wait_closed(self) -> None: ...
+    def get_extra_info(self, name: str, default: Any = ...) -> Any: ...
+    async def drain(self) -> None: ...
+
+class StreamReader:
+    def __init__(self, limit: int = ..., loop: Optional[events.AbstractEventLoop] = ...) -> None: ...
+    def exception(self) -> Exception: ...
+    def set_exception(self, exc: Exception) -> None: ...
+    def set_transport(self, transport: transports.BaseTransport) -> None: ...
+    def feed_eof(self) -> None: ...
+    def at_eof(self) -> bool: ...
+    def feed_data(self, data: bytes) -> None: ...
+    async def readline(self) -> bytes: ...
+    async def readuntil(self, separator: bytes = ...) -> bytes: ...
+    async def read(self, n: int = ...) -> bytes: ...
+    async def readexactly(self, n: int) -> bytes: ...
+    def __aiter__(self) -> AsyncIterator[bytes]: ...
+    async def __anext__(self) -> bytes: ...

shared/package-files/56/5639df194837f65be5083c4ea0649e626f142f5db0642e724399fcf96f76783d/blob

@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+import importlib
+import types
+import warnings
+
+__all__ = ["registry", "get_filesystem_class", "default"]
+
+# internal, mutable
+_registry: dict[str, type] = {}
+
+# external, immutable
+registry = types.MappingProxyType(_registry)
+default = "file"
+
+
+def register_implementation(name, cls, clobber=False, errtxt=None):
+    """Add implementation class to the registry
+
+    Parameters
+    ----------
+    name: str
+        Protocol name to associate with the class
+    cls: class or str
+        if a class: fsspec-compliant implementation class (normally inherits from
+        ``fsspec.AbstractFileSystem``, gets added straight to the registry. If a
+        str, the full path to an implementation class like package.module.class,
+        which gets added to known_implementations,
+        so the import is deferred until the filesystem is actually used.
+    clobber: bool (optional)
+        Whether to overwrite a protocol with the same name; if False, will raise
+        instead.
+    errtxt: str (optional)
+        If given, then a failure to import the given class will result in this
+        text being given.
+    """
+    if isinstance(cls, str):
+        if name in known_implementations and clobber is False:
+            if cls != known_implementations[name]["class"]:
+                raise ValueError(
+                    f"Name ({name}) already in the known_implementations and clobber "
+                    f"is False"
+                )
+        else:
+            known_implementations[name] = {
+                "class": cls,
+                "err": errtxt or f"{cls} import failed for protocol {name}",
+            }
+
+    else:
+        if name in registry and clobber is False:
+            if _registry[name] is not cls:
+                raise ValueError(
+                    f"Name ({name}) already in the registry and clobber is False"
+                )
+        else:
+            _registry[name] = cls
+
+
+# protocols mapped to the class which implements them. This dict can be
+# updated with register_implementation
+known_implementations = {
+    "abfs": {
+        "class": "adlfs.AzureBlobFileSystem",
+        "err": "Install adlfs to access Azure Datalake Gen2 and Azure Blob Storage",
+    },
+    "adl": {
+        "class": "adlfs.AzureDatalakeFileSystem",
+        "err": "Install adlfs to access Azure Datalake Gen1",
+    },
+    "arrow_hdfs": {
+        "class": "fsspec.implementations.arrow.HadoopFileSystem",
+        "err": "pyarrow and local java libraries required for HDFS",
+    },
+    "asynclocal": {
+        "class": "morefs.asyn_local.AsyncLocalFileSystem",
+        "err": "Install 'morefs[asynclocalfs]' to use AsyncLocalFileSystem",
+    },
+    "az": {
+        "class": "adlfs.AzureBlobFileSystem",
+        "err": "Install adlfs to access Azure Datalake Gen2 and Azure Blob Storage",
+    },
+    "blockcache": {"class": "fsspec.implementations.cached.CachingFileSystem"},
+    "box": {
+        "class": "boxfs.BoxFileSystem",
+        "err": "Please install boxfs to access BoxFileSystem",
+    },
+    "cached": {"class": "fsspec.implementations.cached.CachingFileSystem"},
+    "dask": {
+        "class": "fsspec.implementations.dask.DaskWorkerFileSystem",
+        "err": "Install dask distributed to access worker file system",
+    },
+    "data": {"class": "fsspec.implementations.data.DataFileSystem"},
+    "dbfs": {
+        "class": "fsspec.implementations.dbfs.DatabricksFileSystem",
+        "err": "Install the requests package to use the DatabricksFileSystem",
+    },
+    "dir": {"class": "fsspec.implementations.dirfs.DirFileSystem"},
+    "dropbox": {
+        "class": "dropboxdrivefs.DropboxDriveFileSystem",
+        "err": (
+            'DropboxFileSystem requires "dropboxdrivefs","requests" and "'
+            '"dropbox" to be installed'
+        ),
+    },
+    "dvc": {
+        "class": "dvc.api.DVCFileSystem",
+        "err": "Install dvc to access DVCFileSystem",
+    },
+    "file": {"class": "fsspec.implementations.local.LocalFileSystem"},
+    "filecache": {"class": "fsspec.implementations.cached.WholeFileCacheFileSystem"},
+    "ftp": {"class": "fsspec.implementations.ftp.FTPFileSystem"},
+    "gcs": {
+        "class": "gcsfs.GCSFileSystem",
+        "err": "Please install gcsfs to access Google Storage",
+    },
+    "gdrive": {
+        "class": "gdrivefs.GoogleDriveFileSystem",
+        "err": "Please install gdrivefs for access to Google Drive",
+    },
+    "generic": {"class": "fsspec.generic.GenericFileSystem"},
+    "git": {
+        "class": "fsspec.implementations.git.GitFileSystem",
+        "err": "Install pygit2 to browse local git repos",
+    },
+    "github": {
+        "class": "fsspec.implementations.github.GithubFileSystem",
+        "err": "Install the requests package to use the github FS",
+    },
+    "gs": {
+        "class": "gcsfs.GCSFileSystem",
+        "err": "Please install gcsfs to access Google Storage",
+    },
+    "hdfs": {
+        "class": "fsspec.implementations.arrow.HadoopFileSystem",
+        "err": "pyarrow and local java libraries required for HDFS",
+    },
+    "hf": {
+        "class": "huggingface_hub.HfFileSystem",
+        "err": "Install huggingface_hub to access HfFileSystem",
+    },
+    "http": {
+        "class": "fsspec.implementations.http.HTTPFileSystem",
+        "err": 'HTTPFileSystem requires "requests" and "aiohttp" to be installed',
+    },
+    "https": {
+        "class": "fsspec.implementations.http.HTTPFileSystem",
+        "err": 'HTTPFileSystem requires "requests" and "aiohttp" to be installed',
+    },
+    "jlab": {
+        "class": "fsspec.implementations.jupyter.JupyterFileSystem",
+        "err": "Jupyter FS requires requests to be installed",
+    },
+    "jupyter": {
+        "class": "fsspec.implementations.jupyter.JupyterFileSystem",
+        "err": "Jupyter FS requires requests to be installed",
+    },
+    "lakefs": {
+        "class": "lakefs_spec.LakeFSFileSystem",
+        "err": "Please install lakefs-spec to access LakeFSFileSystem",
+    },
+    "libarchive": {
+        "class": "fsspec.implementations.libarchive.LibArchiveFileSystem",
+        "err": "LibArchive requires to be installed",
+    },
+    "local": {"class": "fsspec.implementations.local.LocalFileSystem"},
+    "memory": {"class": "fsspec.implementations.memory.MemoryFileSystem"},
+    "oci": {
+        "class": "ocifs.OCIFileSystem",
+        "err": "Install ocifs to access OCI Object Storage",
+    },
+    "ocilake": {
+        "class": "ocifs.OCIFileSystem",
+        "err": "Install ocifs to access OCI Data Lake",
+    },
+    "oss": {
+        "class": "ossfs.OSSFileSystem",
+        "err": "Install ossfs to access Alibaba Object Storage System",
+    },
+    "reference": {"class": "fsspec.implementations.reference.ReferenceFileSystem"},
+    "root": {
+        "class": "fsspec_xrootd.XRootDFileSystem",
+        "err": (
+            "Install fsspec-xrootd to access xrootd storage system. "
+            "Note: 'root' is the protocol name for xrootd storage systems, "
+            "not referring to root directories"
+        ),
+    },
+    "s3": {"class": "s3fs.S3FileSystem", "err": "Install s3fs to access S3"},
+    "s3a": {"class": "s3fs.S3FileSystem", "err": "Install s3fs to access S3"},
+    "sftp": {
+        "class": "fsspec.implementations.sftp.SFTPFileSystem",
+        "err": 'SFTPFileSystem requires "paramiko" to be installed',
+    },
+    "simplecache": {"class": "fsspec.implementations.cached.SimpleCacheFileSystem"},
+    "smb": {
+        "class": "fsspec.implementations.smb.SMBFileSystem",
+        "err": 'SMB requires "smbprotocol" or "smbprotocol[kerberos]" installed',
+    },
+    "ssh": {
+        "class": "fsspec.implementations.sftp.SFTPFileSystem",
+        "err": 'SFTPFileSystem requires "paramiko" to be installed',
+    },
+    "tar": {"class": "fsspec.implementations.tar.TarFileSystem"},
+    "wandb": {"class": "wandbfs.WandbFS", "err": "Install wandbfs to access wandb"},
+    "webdav": {
+        "class": "webdav4.fsspec.WebdavFileSystem",
+        "err": "Install webdav4 to access WebDAV",
+    },
+    "webhdfs": {
+        "class": "fsspec.implementations.webhdfs.WebHDFS",
+        "err": 'webHDFS access requires "requests" to be installed',
+    },
+    "zip": {"class": "fsspec.implementations.zip.ZipFileSystem"},
+}
+
+
+def get_filesystem_class(protocol):
+    """Fetch named protocol implementation from the registry
+
+    The dict ``known_implementations`` maps protocol names to the locations
+    of classes implementing the corresponding file-system. When used for the
+    first time, appropriate imports will happen and the class will be placed in
+    the registry. All subsequent calls will fetch directly from the registry.
+
+    Some protocol implementations require additional dependencies, and so the
+    import may fail. In this case, the string in the "err" field of the
+    ``known_implementations`` will be given as the error message.
+    """
+    if not protocol:
+        protocol = default
+
+    if protocol not in registry:
+        if protocol not in known_implementations:
+            raise ValueError(f"Protocol not known: {protocol}")
+        bit = known_implementations[protocol]
+        try:
+            register_implementation(protocol, _import_class(bit["class"]))
+        except ImportError as e:
+            raise ImportError(bit["err"]) from e
+    cls = registry[protocol]
+    if getattr(cls, "protocol", None) in ("abstract", None):
+        cls.protocol = protocol
+
+    return cls
+
+
+s3_msg = """Your installed version of s3fs is very old and known to cause
+severe performance issues, see also https://github.com/dask/dask/issues/10276
+
+To fix, you should specify a lower version bound on s3fs, or
+update the current installation.
+"""
+
+
+def _import_class(cls, minv=None):
+    """Take a string FQP and return the imported class or identifier
+
+    cls is of the form "package.module.klass" or "package.module:subobject.klass"
+    """
+    if ":" in cls:
+        mod, name = cls.rsplit(":", 1)
+        s3 = mod == "s3fs"
+        mod = importlib.import_module(mod)
+        if s3 and mod.__version__.split(".") < ["0", "5"]:
+            warnings.warn(s3_msg)
+        for part in name.split("."):
+            mod = getattr(mod, part)
+        return mod
+    else:
+        mod, name = cls.rsplit(".", 1)
+        s3 = mod == "s3fs"
+        mod = importlib.import_module(mod)
+        if s3 and mod.__version__.split(".") < ["0", "5"]:
+            warnings.warn(s3_msg)
+        return getattr(mod, name)
+
+
+def filesystem(protocol, **storage_options):
+    """Instantiate filesystems for given protocol and arguments
+
+    ``storage_options`` are specific to the protocol being chosen, and are
+    passed directly to the class.
+    """
+    if protocol == "arrow_hdfs":
+        warnings.warn(
+            "The 'arrow_hdfs' protocol has been deprecated and will be "
+            "removed in the future. Specify it as 'hdfs'.",
+            DeprecationWarning,
+        )
+
+    cls = get_filesystem_class(protocol)
+    return cls(**storage_options)
+
+
+def available_protocols():
+    """Return a list of the implemented protocols.
+
+    Note that any given protocol may require extra packages to be importable.
+    """
+    return list(known_implementations)

shared/package-files/56/563a1e1c187330875efa2ccd66fae72633c03e07e5497df26d155b2eb6f2a38b/blob

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

shared/package-files/56/563b9821194c63e2bbf616ab92d863cdc8052fbae59242cea00c0d7c4088959c/blob

@@ -0,0 +1,857 @@
+"""Principal Component Analysis."""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+from math import lgamma, log, sqrt
+from numbers import Integral, Real
+
+import numpy as np
+from scipy import linalg
+from scipy.sparse import issparse
+from scipy.sparse.linalg import svds
+
+from ..base import _fit_context
+from ..utils import check_random_state
+from ..utils._arpack import _init_arpack_v0
+from ..utils._array_api import _convert_to_numpy, get_namespace
+from ..utils._param_validation import Interval, RealNotInt, StrOptions
+from ..utils.extmath import _randomized_svd, fast_logdet, stable_cumsum, svd_flip
+from ..utils.sparsefuncs import _implicit_column_offset, mean_variance_axis
+from ..utils.validation import check_is_fitted, validate_data
+from ._base import _BasePCA
+
+
+def _assess_dimension(spectrum, rank, n_samples):
+    """Compute the log-likelihood of a rank ``rank`` dataset.
+
+    The dataset is assumed to be embedded in gaussian noise of shape(n,
+    dimf) having spectrum ``spectrum``. This implements the method of
+    T. P. Minka.
+
+    Parameters
+    ----------
+    spectrum : ndarray of shape (n_features,)
+        Data spectrum.
+    rank : int
+        Tested rank value. It should be strictly lower than n_features,
+        otherwise the method isn't specified (division by zero in equation
+        (31) from the paper).
+    n_samples : int
+        Number of samples.
+
+    Returns
+    -------
+    ll : float
+        The log-likelihood.
+
+    References
+    ----------
+    This implements the method of `Thomas P. Minka:
+    Automatic Choice of Dimensionality for PCA. NIPS 2000: 598-604
+    <https://proceedings.neurips.cc/paper/2000/file/7503cfacd12053d309b6bed5c89de212-Paper.pdf>`_
+    """
+    xp, _ = get_namespace(spectrum)
+
+    n_features = spectrum.shape[0]
+    if not 1 <= rank < n_features:
+        raise ValueError("the tested rank should be in [1, n_features - 1]")
+
+    eps = 1e-15
+
+    if spectrum[rank - 1] < eps:
+        # When the tested rank is associated with a small eigenvalue, there's
+        # no point in computing the log-likelihood: it's going to be very
+        # small and won't be the max anyway. Also, it can lead to numerical
+        # issues below when computing pa, in particular in log((spectrum[i] -
+        # spectrum[j]) because this will take the log of something very small.
+        return -xp.inf
+
+    pu = -rank * log(2.0)
+    for i in range(1, rank + 1):
+        pu += (
+            lgamma((n_features - i + 1) / 2.0) - log(xp.pi) * (n_features - i + 1) / 2.0
+        )
+
+    pl = xp.sum(xp.log(spectrum[:rank]))
+    pl = -pl * n_samples / 2.0
+
+    v = max(eps, xp.sum(spectrum[rank:]) / (n_features - rank))
+    pv = -log(v) * n_samples * (n_features - rank) / 2.0
+
+    m = n_features * rank - rank * (rank + 1.0) / 2.0
+    pp = log(2.0 * xp.pi) * (m + rank) / 2.0
+
+    pa = 0.0
+    spectrum_ = xp.asarray(spectrum, copy=True)
+    spectrum_[rank:n_features] = v
+    for i in range(rank):
+        for j in range(i + 1, spectrum.shape[0]):
+            pa += log(
+                (spectrum[i] - spectrum[j]) * (1.0 / spectrum_[j] - 1.0 / spectrum_[i])
+            ) + log(n_samples)
+
+    ll = pu + pl + pv + pp - pa / 2.0 - rank * log(n_samples) / 2.0
+
+    return ll
+
+
+def _infer_dimension(spectrum, n_samples):
+    """Infers the dimension of a dataset with a given spectrum.
+
+    The returned value will be in [1, n_features - 1].
+    """
+    xp, _ = get_namespace(spectrum)
+
+    ll = xp.empty_like(spectrum)
+    ll[0] = -xp.inf  # we don't want to return n_components = 0
+    for rank in range(1, spectrum.shape[0]):
+        ll[rank] = _assess_dimension(spectrum, rank, n_samples)
+    return xp.argmax(ll)
+
+
+class PCA(_BasePCA):
+    """Principal component analysis (PCA).
+
+    Linear dimensionality reduction using Singular Value Decomposition of the
+    data to project it to a lower dimensional space. The input data is centered
+    but not scaled for each feature before applying the SVD.
+
+    It uses the LAPACK implementation of the full SVD or a randomized truncated
+    SVD by the method of Halko et al. 2009, depending on the shape of the input
+    data and the number of components to extract.
+
+    With sparse inputs, the ARPACK implementation of the truncated SVD can be
+    used (i.e. through :func:`scipy.sparse.linalg.svds`). Alternatively, one
+    may consider :class:`TruncatedSVD` where the data are not centered.
+
+    Notice that this class only supports sparse inputs for some solvers such as
+    "arpack" and "covariance_eigh". See :class:`TruncatedSVD` for an
+    alternative with sparse data.
+
+    For a usage example, see
+    :ref:`sphx_glr_auto_examples_decomposition_plot_pca_iris.py`
+
+    Read more in the :ref:`User Guide <PCA>`.
+
+    Parameters
+    ----------
+    n_components : int, float or 'mle', default=None
+        Number of components to keep.
+        if n_components is not set all components are kept::
+
+            n_components == min(n_samples, n_features)
+
+        If ``n_components == 'mle'`` and ``svd_solver == 'full'``, Minka's
+        MLE is used to guess the dimension. Use of ``n_components == 'mle'``
+        will interpret ``svd_solver == 'auto'`` as ``svd_solver == 'full'``.
+
+        If ``0 < n_components < 1`` and ``svd_solver == 'full'``, select the
+        number of components such that the amount of variance that needs to be
+        explained is greater than the percentage specified by n_components.
+
+        If ``svd_solver == 'arpack'``, the number of components must be
+        strictly less than the minimum of n_features and n_samples.
+
+        Hence, the None case results in::
+
+            n_components == min(n_samples, n_features) - 1
+
+    copy : bool, default=True
+        If False, data passed to fit are overwritten and running
+        fit(X).transform(X) will not yield the expected results,
+        use fit_transform(X) instead.
+
+    whiten : bool, default=False
+        When True (False by default) the `components_` vectors are multiplied
+        by the square root of n_samples and then divided by the singular values
+        to ensure uncorrelated outputs with unit component-wise variances.
+
+        Whitening will remove some information from the transformed signal
+        (the relative variance scales of the components) but can sometime
+        improve the predictive accuracy of the downstream estimators by
+        making their data respect some hard-wired assumptions.
+
+    svd_solver : {'auto', 'full', 'covariance_eigh', 'arpack', 'randomized'},\
+            default='auto'
+        "auto" :
+            The solver is selected by a default 'auto' policy is based on `X.shape` and
+            `n_components`: if the input data has fewer than 1000 features and
+            more than 10 times as many samples, then the "covariance_eigh"
+            solver is used. Otherwise, if the input data is larger than 500x500
+            and the number of components to extract is lower than 80% of the
+            smallest dimension of the data, then the more efficient
+            "randomized" method is selected. Otherwise the exact "full" SVD is
+            computed and optionally truncated afterwards.
+        "full" :
+            Run exact full SVD calling the standard LAPACK solver via
+            `scipy.linalg.svd` and select the components by postprocessing
+        "covariance_eigh" :
+            Precompute the covariance matrix (on centered data), run a
+            classical eigenvalue decomposition on the covariance matrix
+            typically using LAPACK and select the components by postprocessing.
+            This solver is very efficient for n_samples >> n_features and small
+            n_features. It is, however, not tractable otherwise for large
+            n_features (large memory footprint required to materialize the
+            covariance matrix). Also note that compared to the "full" solver,
+            this solver effectively doubles the condition number and is
+            therefore less numerical stable (e.g. on input data with a large
+            range of singular values).
+        "arpack" :
+            Run SVD truncated to `n_components` calling ARPACK solver via
+            `scipy.sparse.linalg.svds`. It requires strictly
+            `0 < n_components < min(X.shape)`
+        "randomized" :
+            Run randomized SVD by the method of Halko et al.
+
+        .. versionadded:: 0.18.0
+
+        .. versionchanged:: 1.5
+            Added the 'covariance_eigh' solver.
+
+    tol : float, default=0.0
+        Tolerance for singular values computed by svd_solver == 'arpack'.
+        Must be of range [0.0, infinity).
+
+        .. versionadded:: 0.18.0
+
+    iterated_power : int or 'auto', default='auto'
+        Number of iterations for the power method computed by
+        svd_solver == 'randomized'.
+        Must be of range [0, infinity).
+
+        .. versionadded:: 0.18.0
+
+    n_oversamples : int, default=10
+        This parameter is only relevant when `svd_solver="randomized"`.
+        It corresponds to the additional number of random vectors to sample the
+        range of `X` so as to ensure proper conditioning. See
+        :func:`~sklearn.utils.extmath.randomized_svd` for more details.
+
+        .. versionadded:: 1.1
+
+    power_iteration_normalizer : {'auto', 'QR', 'LU', 'none'}, default='auto'
+        Power iteration normalizer for randomized SVD solver.
+        Not used by ARPACK. See :func:`~sklearn.utils.extmath.randomized_svd`
+        for more details.
+
+        .. versionadded:: 1.1
+
+    random_state : int, RandomState instance or None, default=None
+        Used when the 'arpack' or 'randomized' solvers are used. Pass an int
+        for reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+        .. versionadded:: 0.18.0
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Principal axes in feature space, representing the directions of
+        maximum variance in the data. Equivalently, the right singular
+        vectors of the centered input data, parallel to its eigenvectors.
+        The components are sorted by decreasing ``explained_variance_``.
+
+    explained_variance_ : ndarray of shape (n_components,)
+        The amount of variance explained by each of the selected components.
+        The variance estimation uses `n_samples - 1` degrees of freedom.
+
+        Equal to n_components largest eigenvalues
+        of the covariance matrix of X.
+
+        .. versionadded:: 0.18
+
+    explained_variance_ratio_ : ndarray of shape (n_components,)
+        Percentage of variance explained by each of the selected components.
+
+        If ``n_components`` is not set then all components are stored and the
+        sum of the ratios is equal to 1.0.
+
+    singular_values_ : ndarray of shape (n_components,)
+        The singular values corresponding to each of the selected components.
+        The singular values are equal to the 2-norms of the ``n_components``
+        variables in the lower-dimensional space.
+
+        .. versionadded:: 0.19
+
+    mean_ : ndarray of shape (n_features,)
+        Per-feature empirical mean, estimated from the training set.
+
+        Equal to `X.mean(axis=0)`.
+
+    n_components_ : int
+        The estimated number of components. When n_components is set
+        to 'mle' or a number between 0 and 1 (with svd_solver == 'full') this
+        number is estimated from input data. Otherwise it equals the parameter
+        n_components, or the lesser value of n_features and n_samples
+        if n_components is None.
+
+    n_samples_ : int
+        Number of samples in the training data.
+
+    noise_variance_ : float
+        The estimated noise covariance following the Probabilistic PCA model
+        from Tipping and Bishop 1999. See "Pattern Recognition and
+        Machine Learning" by C. Bishop, 12.2.1 p. 574 or
+        http://www.miketipping.com/papers/met-mppca.pdf. It is required to
+        compute the estimated data covariance and score samples.
+
+        Equal to the average of (min(n_features, n_samples) - n_components)
+        smallest eigenvalues of the covariance matrix of X.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    KernelPCA : Kernel Principal Component Analysis.
+    SparsePCA : Sparse Principal Component Analysis.
+    TruncatedSVD : Dimensionality reduction using truncated SVD.
+    IncrementalPCA : Incremental Principal Component Analysis.
+
+    References
+    ----------
+    For n_components == 'mle', this class uses the method from:
+    `Minka, T. P.. "Automatic choice of dimensionality for PCA".
+    In NIPS, pp. 598-604 <https://tminka.github.io/papers/pca/minka-pca.pdf>`_
+
+    Implements the probabilistic PCA model from:
+    `Tipping, M. E., and Bishop, C. M. (1999). "Probabilistic principal
+    component analysis". Journal of the Royal Statistical Society:
+    Series B (Statistical Methodology), 61(3), 611-622.
+    <http://www.miketipping.com/papers/met-mppca.pdf>`_
+    via the score and score_samples methods.
+
+    For svd_solver == 'arpack', refer to `scipy.sparse.linalg.svds`.
+
+    For svd_solver == 'randomized', see:
+    :doi:`Halko, N., Martinsson, P. G., and Tropp, J. A. (2011).
+    "Finding structure with randomness: Probabilistic algorithms for
+    constructing approximate matrix decompositions".
+    SIAM review, 53(2), 217-288.
+    <10.1137/090771806>`
+    and also
+    :doi:`Martinsson, P. G., Rokhlin, V., and Tygert, M. (2011).
+    "A randomized algorithm for the decomposition of matrices".
+    Applied and Computational Harmonic Analysis, 30(1), 47-68.
+    <10.1016/j.acha.2010.02.003>`
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.decomposition import PCA
+    >>> X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
+    >>> pca = PCA(n_components=2)
+    >>> pca.fit(X)
+    PCA(n_components=2)
+    >>> print(pca.explained_variance_ratio_)
+    [0.9924 0.0075]
+    >>> print(pca.singular_values_)
+    [6.30061 0.54980]
+
+    >>> pca = PCA(n_components=2, svd_solver='full')
+    >>> pca.fit(X)
+    PCA(n_components=2, svd_solver='full')
+    >>> print(pca.explained_variance_ratio_)
+    [0.9924 0.00755]
+    >>> print(pca.singular_values_)
+    [6.30061 0.54980]
+
+    >>> pca = PCA(n_components=1, svd_solver='arpack')
+    >>> pca.fit(X)
+    PCA(n_components=1, svd_solver='arpack')
+    >>> print(pca.explained_variance_ratio_)
+    [0.99244]
+    >>> print(pca.singular_values_)
+    [6.30061]
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [
+            Interval(Integral, 0, None, closed="left"),
+            Interval(RealNotInt, 0, 1, closed="neither"),
+            StrOptions({"mle"}),
+            None,
+        ],
+        "copy": ["boolean"],
+        "whiten": ["boolean"],
+        "svd_solver": [
+            StrOptions({"auto", "full", "covariance_eigh", "arpack", "randomized"})
+        ],
+        "tol": [Interval(Real, 0, None, closed="left")],
+        "iterated_power": [
+            StrOptions({"auto"}),
+            Interval(Integral, 0, None, closed="left"),
+        ],
+        "n_oversamples": [Interval(Integral, 1, None, closed="left")],
+        "power_iteration_normalizer": [StrOptions({"auto", "QR", "LU", "none"})],
+        "random_state": ["random_state"],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        copy=True,
+        whiten=False,
+        svd_solver="auto",
+        tol=0.0,
+        iterated_power="auto",
+        n_oversamples=10,
+        power_iteration_normalizer="auto",
+        random_state=None,
+    ):
+        self.n_components = n_components
+        self.copy = copy
+        self.whiten = whiten
+        self.svd_solver = svd_solver
+        self.tol = tol
+        self.iterated_power = iterated_power
+        self.n_oversamples = n_oversamples
+        self.power_iteration_normalizer = power_iteration_normalizer
+        self.random_state = random_state
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the model with X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Ignored.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        self._fit(X)
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit_transform(self, X, y=None):
+        """Fit the model with X and apply the dimensionality reduction on X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Ignored.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Transformed values.
+
+        Notes
+        -----
+        This method returns a Fortran-ordered array. To convert it to a
+        C-ordered array, use 'np.ascontiguousarray'.
+        """
+        U, S, _, X, x_is_centered, xp = self._fit(X)
+        if U is not None:
+            U = U[:, : self.n_components_]
+
+            if self.whiten:
+                # X_new = X * V / S * sqrt(n_samples) = U * sqrt(n_samples)
+                U *= sqrt(X.shape[0] - 1)
+            else:
+                # X_new = X * V = U * S * Vt * V = U * S
+                U *= S[: self.n_components_]
+
+            return U
+        else:  # solver="covariance_eigh" does not compute U at fit time.
+            return self._transform(X, xp, x_is_centered=x_is_centered)
+
+    def _fit(self, X):
+        """Dispatch to the right submethod depending on the chosen solver."""
+        xp, is_array_api_compliant = get_namespace(X)
+
+        # Raise an error for sparse input and unsupported svd_solver
+        if issparse(X) and self.svd_solver not in ["auto", "arpack", "covariance_eigh"]:
+            raise TypeError(
+                'PCA only support sparse inputs with the "arpack" and'
+                f' "covariance_eigh" solvers, while "{self.svd_solver}" was passed. See'
+                " TruncatedSVD for a possible alternative."
+            )
+        if self.svd_solver == "arpack" and is_array_api_compliant:
+            raise ValueError(
+                "PCA with svd_solver='arpack' is not supported for Array API inputs."
+            )
+
+        # Validate the data, without ever forcing a copy as any solver that
+        # supports sparse input data and the `covariance_eigh` solver are
+        # written in a way to avoid the need for any inplace modification of
+        # the input data contrary to the other solvers.
+        # The copy will happen
+        # later, only if needed, once the solver negotiation below is done.
+        X = validate_data(
+            self,
+            X,
+            dtype=[xp.float64, xp.float32],
+            force_writeable=True,
+            accept_sparse=("csr", "csc"),
+            ensure_2d=True,
+            copy=False,
+        )
+        self._fit_svd_solver = self.svd_solver
+        if self._fit_svd_solver == "auto" and issparse(X):
+            self._fit_svd_solver = "arpack"
+
+        if self.n_components is None:
+            if self._fit_svd_solver != "arpack":
+                n_components = min(X.shape)
+            else:
+                n_components = min(X.shape) - 1
+        else:
+            n_components = self.n_components
+
+        if self._fit_svd_solver == "auto":
+            # Tall and skinny problems are best handled by precomputing the
+            # covariance matrix.
+            if X.shape[1] <= 1_000 and X.shape[0] >= 10 * X.shape[1]:
+                self._fit_svd_solver = "covariance_eigh"
+            # Small problem or n_components == 'mle', just call full PCA
+            elif max(X.shape) <= 500 or n_components == "mle":
+                self._fit_svd_solver = "full"
+            elif 1 <= n_components < 0.8 * min(X.shape):
+                self._fit_svd_solver = "randomized"
+            # This is also the case of n_components in (0, 1)
+            else:
+                self._fit_svd_solver = "full"
+
+        # Call different fits for either full or truncated SVD
+        if self._fit_svd_solver in ("full", "covariance_eigh"):
+            return self._fit_full(X, n_components, xp, is_array_api_compliant)
+        elif self._fit_svd_solver in ["arpack", "randomized"]:
+            return self._fit_truncated(X, n_components, xp)
+
+    def _fit_full(self, X, n_components, xp, is_array_api_compliant):
+        """Fit the model by computing full SVD on X."""
+        n_samples, n_features = X.shape
+
+        if n_components == "mle":
+            if n_samples < n_features:
+                raise ValueError(
+                    "n_components='mle' is only supported if n_samples >= n_features"
+                )
+        elif not 0 <= n_components <= min(n_samples, n_features):
+            raise ValueError(
+                f"n_components={n_components} must be between 0 and "
+                f"min(n_samples, n_features)={min(n_samples, n_features)} with "
+                f"svd_solver={self._fit_svd_solver!r}"
+            )
+
+        self.mean_ = xp.mean(X, axis=0)
+        # When X is a scipy sparse matrix, self.mean_ is a numpy matrix, so we need
+        # to transform it to a 1D array. Note that this is not the case when X
+        # is a scipy sparse array.
+        # TODO: remove the following two lines when scikit-learn only depends
+        # on scipy versions that no longer support scipy.sparse matrices.
+        self.mean_ = xp.reshape(xp.asarray(self.mean_), (-1,))
+
+        if self._fit_svd_solver == "full":
+            X_centered = xp.asarray(X, copy=True) if self.copy else X
+            X_centered -= self.mean_
+            x_is_centered = not self.copy
+
+            if not is_array_api_compliant:
+                # Use scipy.linalg with NumPy/SciPy inputs for the sake of not
+                # introducing unanticipated behavior changes. In the long run we
+                # could instead decide to always use xp.linalg.svd for all inputs,
+                # but that would make this code rely on numpy's SVD instead of
+                # scipy's. It's not 100% clear whether they use the same LAPACK
+                # solver by default though (assuming both are built against the
+                # same BLAS).
+                U, S, Vt = linalg.svd(X_centered, full_matrices=False)
+            else:
+                U, S, Vt = xp.linalg.svd(X_centered, full_matrices=False)
+            explained_variance_ = (S**2) / (n_samples - 1)
+
+        else:
+            assert self._fit_svd_solver == "covariance_eigh"
+            # In the following, we center the covariance matrix C afterwards
+            # (without centering the data X first) to avoid an unnecessary copy
+            # of X. Note that the mean_ attribute is still needed to center
+            # test data in the transform method.
+            #
+            # Note: at the time of writing, `xp.cov` does not exist in the
+            # Array API standard:
+            # https://github.com/data-apis/array-api/issues/43
+            #
+            # Besides, using `numpy.cov`, as of numpy 1.26.0, would not be
+            # memory efficient for our use case when `n_samples >> n_features`:
+            # `numpy.cov` centers a copy of the data before computing the
+            # matrix product instead of subtracting a small `(n_features,
+            # n_features)` square matrix from the gram matrix X.T @ X, as we do
+            # below.
+            x_is_centered = False
+            C = X.T @ X
+            C -= (
+                n_samples
+                * xp.reshape(self.mean_, (-1, 1))
+                * xp.reshape(self.mean_, (1, -1))
+            )
+            C /= n_samples - 1
+            eigenvals, eigenvecs = xp.linalg.eigh(C)
+
+            # When X is a scipy sparse matrix, the following two datastructures
+            # are returned as instances of the soft-deprecated numpy.matrix
+            # class. Note that this problem does not occur when X is a scipy
+            # sparse array (or another other kind of supported array).
+            # TODO: remove the following two lines when scikit-learn only
+            # depends on scipy versions that no longer support scipy.sparse
+            # matrices.
+            eigenvals = xp.reshape(xp.asarray(eigenvals), (-1,))
+            eigenvecs = xp.asarray(eigenvecs)
+
+            eigenvals = xp.flip(eigenvals, axis=0)
+            eigenvecs = xp.flip(eigenvecs, axis=1)
+
+            # The covariance matrix C is positive semi-definite by
+            # construction. However, the eigenvalues returned by xp.linalg.eigh
+            # can be slightly negative due to numerical errors. This would be
+            # an issue for the subsequent sqrt, hence the manual clipping.
+            eigenvals[eigenvals < 0.0] = 0.0
+            explained_variance_ = eigenvals
+
+            # Re-construct SVD of centered X indirectly and make it consistent
+            # with the other solvers.
+            S = xp.sqrt(eigenvals * (n_samples - 1))
+            Vt = eigenvecs.T
+            U = None
+
+        # flip eigenvectors' sign to enforce deterministic output
+        U, Vt = svd_flip(U, Vt, u_based_decision=False)
+
+        components_ = Vt
+
+        # Get variance explained by singular values
+        total_var = xp.sum(explained_variance_)
+        explained_variance_ratio_ = explained_variance_ / total_var
+        singular_values_ = xp.asarray(S, copy=True)  # Store the singular values.
+
+        # Postprocess the number of components required
+        if n_components == "mle":
+            n_components = _infer_dimension(explained_variance_, n_samples)
+        elif 0 < n_components < 1.0:
+            # number of components for which the cumulated explained
+            # variance percentage is superior to the desired threshold
+            # side='right' ensures that number of features selected
+            # their variance is always greater than n_components float
+            # passed. More discussion in issue: #15669
+            if is_array_api_compliant:
+                # Convert to numpy as xp.cumsum and xp.searchsorted are not
+                # part of the Array API standard yet:
+                #
+                # https://github.com/data-apis/array-api/issues/597
+                # https://github.com/data-apis/array-api/issues/688
+                #
+                # Furthermore, it's not always safe to call them for namespaces
+                # that already implement them: for instance as
+                # cupy.searchsorted does not accept a float as second argument.
+                explained_variance_ratio_np = _convert_to_numpy(
+                    explained_variance_ratio_, xp=xp
+                )
+            else:
+                explained_variance_ratio_np = explained_variance_ratio_
+            ratio_cumsum = stable_cumsum(explained_variance_ratio_np)
+            n_components = np.searchsorted(ratio_cumsum, n_components, side="right") + 1
+
+        # Compute noise covariance using Probabilistic PCA model
+        # The sigma2 maximum likelihood (cf. eq. 12.46)
+        if n_components < min(n_features, n_samples):
+            self.noise_variance_ = xp.mean(explained_variance_[n_components:])
+        else:
+            self.noise_variance_ = 0.0
+
+        self.n_samples_ = n_samples
+        self.n_components_ = n_components
+        # Assign a copy of the result of the truncation of the components in
+        # order to:
+        # - release the memory used by the discarded components,
+        # - ensure that the kept components are allocated contiguously in
+        #   memory to make the transform method faster by leveraging cache
+        #   locality.
+        self.components_ = xp.asarray(components_[:n_components, :], copy=True)
+
+        # We do the same for the other arrays for the sake of consistency.
+        self.explained_variance_ = xp.asarray(
+            explained_variance_[:n_components], copy=True
+        )
+        self.explained_variance_ratio_ = xp.asarray(
+            explained_variance_ratio_[:n_components], copy=True
+        )
+        self.singular_values_ = xp.asarray(singular_values_[:n_components], copy=True)
+
+        return U, S, Vt, X, x_is_centered, xp
+
+    def _fit_truncated(self, X, n_components, xp):
+        """Fit the model by computing truncated SVD (by ARPACK or randomized)
+        on X.
+        """
+        n_samples, n_features = X.shape
+
+        svd_solver = self._fit_svd_solver
+        if isinstance(n_components, str):
+            raise ValueError(
+                "n_components=%r cannot be a string with svd_solver='%s'"
+                % (n_components, svd_solver)
+            )
+        elif not 1 <= n_components <= min(n_samples, n_features):
+            raise ValueError(
+                "n_components=%r must be between 1 and "
+                "min(n_samples, n_features)=%r with "
+                "svd_solver='%s'"
+                % (n_components, min(n_samples, n_features), svd_solver)
+            )
+        elif svd_solver == "arpack" and n_components == min(n_samples, n_features):
+            raise ValueError(
+                "n_components=%r must be strictly less than "
+                "min(n_samples, n_features)=%r with "
+                "svd_solver='%s'"
+                % (n_components, min(n_samples, n_features), svd_solver)
+            )
+
+        random_state = check_random_state(self.random_state)
+
+        # Center data
+        total_var = None
+        if issparse(X):
+            self.mean_, var = mean_variance_axis(X, axis=0)
+            total_var = var.sum() * n_samples / (n_samples - 1)  # ddof=1
+            X_centered = _implicit_column_offset(X, self.mean_)
+            x_is_centered = False
+        else:
+            self.mean_ = xp.mean(X, axis=0)
+            X_centered = xp.asarray(X, copy=True) if self.copy else X
+            X_centered -= self.mean_
+            x_is_centered = not self.copy
+
+        if svd_solver == "arpack":
+            v0 = _init_arpack_v0(min(X.shape), random_state)
+            U, S, Vt = svds(X_centered, k=n_components, tol=self.tol, v0=v0)
+            # svds doesn't abide by scipy.linalg.svd/randomized_svd
+            # conventions, so reverse its outputs.
+            S = S[::-1]
+            # flip eigenvectors' sign to enforce deterministic output
+            U, Vt = svd_flip(U[:, ::-1], Vt[::-1], u_based_decision=False)
+
+        elif svd_solver == "randomized":
+            # sign flipping is done inside
+            U, S, Vt = _randomized_svd(
+                X_centered,
+                n_components=n_components,
+                n_oversamples=self.n_oversamples,
+                n_iter=self.iterated_power,
+                power_iteration_normalizer=self.power_iteration_normalizer,
+                flip_sign=False,
+                random_state=random_state,
+            )
+            U, Vt = svd_flip(U, Vt, u_based_decision=False)
+
+        self.n_samples_ = n_samples
+        self.components_ = Vt
+        self.n_components_ = n_components
+
+        # Get variance explained by singular values
+        self.explained_variance_ = (S**2) / (n_samples - 1)
+
+        # Workaround in-place variance calculation since at the time numpy
+        # did not have a way to calculate variance in-place.
+        #
+        # TODO: update this code to either:
+        # * Use the array-api variance calculation, unless memory usage suffers
+        # * Update sklearn.utils.extmath._incremental_mean_and_var to support array-api
+        # See: https://github.com/scikit-learn/scikit-learn/pull/18689#discussion_r1335540991
+        if total_var is None:
+            N = X.shape[0] - 1
+            X_centered **= 2
+            total_var = xp.sum(X_centered) / N
+
+        self.explained_variance_ratio_ = self.explained_variance_ / total_var
+        self.singular_values_ = xp.asarray(S, copy=True)  # Store the singular values.
+
+        if self.n_components_ < min(n_features, n_samples):
+            self.noise_variance_ = total_var - xp.sum(self.explained_variance_)
+            self.noise_variance_ /= min(n_features, n_samples) - n_components
+        else:
+            self.noise_variance_ = 0.0
+
+        return U, S, Vt, X, x_is_centered, xp
+
+    def score_samples(self, X):
+        """Return the log-likelihood of each sample.
+
+        See. "Pattern Recognition and Machine Learning"
+        by C. Bishop, 12.2.1 p. 574
+        or http://www.miketipping.com/papers/met-mppca.pdf
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The data.
+
+        Returns
+        -------
+        ll : ndarray of shape (n_samples,)
+            Log-likelihood of each sample under the current model.
+        """
+        check_is_fitted(self)
+        xp, _ = get_namespace(X)
+        X = validate_data(self, X, dtype=[xp.float64, xp.float32], reset=False)
+        Xr = X - self.mean_
+        n_features = X.shape[1]
+        precision = self.get_precision()
+        log_like = -0.5 * xp.sum(Xr * (Xr @ precision), axis=1)
+        log_like -= 0.5 * (n_features * log(2.0 * np.pi) - fast_logdet(precision))
+        return log_like
+
+    def score(self, X, y=None):
+        """Return the average log-likelihood of all samples.
+
+        See. "Pattern Recognition and Machine Learning"
+        by C. Bishop, 12.2.1 p. 574
+        or http://www.miketipping.com/papers/met-mppca.pdf
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The data.
+
+        y : Ignored
+            Ignored.
+
+        Returns
+        -------
+        ll : float
+            Average log-likelihood of the samples under the current model.
+        """
+        xp, _ = get_namespace(X)
+        return float(xp.mean(self.score_samples(X)))
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.transformer_tags.preserves_dtype = ["float64", "float32"]
+        tags.array_api_support = True
+        tags.input_tags.sparse = self.svd_solver in (
+            "auto",
+            "arpack",
+            "covariance_eigh",
+        )
+        return tags

shared/package-files/56/563bae0d769e16d7de0c6d77333e35c68f398272b7223c3890bbdfadbc2d0d76/blob

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:563bae0d769e16d7de0c6d77333e35c68f398272b7223c3890bbdfadbc2d0d76
+size 912912

shared/package-files/56/563cf6e58e87fe2874884136006d246b13bd53c3f07174aba1fcea9cde170702/blob

@@ -0,0 +1,551 @@
+import pytest
+
+import numpy as np
+from numpy.testing import (
+    assert_, assert_equal, assert_array_equal, assert_almost_equal,
+    assert_array_almost_equal, assert_raises, assert_raises_regex,
+    )
+from numpy.lib.index_tricks import (
+    mgrid, ogrid, ndenumerate, fill_diagonal, diag_indices, diag_indices_from,
+    index_exp, ndindex, r_, s_, ix_
+    )
+
+
+class TestRavelUnravelIndex:
+    def test_basic(self):
+        assert_equal(np.unravel_index(2, (2, 2)), (1, 0))
+
+        # test that new shape argument works properly
+        assert_equal(np.unravel_index(indices=2,
+                                      shape=(2, 2)),
+                                      (1, 0))
+
+        # test that an invalid second keyword argument
+        # is properly handled, including the old name `dims`.
+        with assert_raises(TypeError):
+            np.unravel_index(indices=2, hape=(2, 2))
+
+        with assert_raises(TypeError):
+            np.unravel_index(2, hape=(2, 2))
+
+        with assert_raises(TypeError):
+            np.unravel_index(254, ims=(17, 94))
+
+        with assert_raises(TypeError):
+            np.unravel_index(254, dims=(17, 94))
+
+        assert_equal(np.ravel_multi_index((1, 0), (2, 2)), 2)
+        assert_equal(np.unravel_index(254, (17, 94)), (2, 66))
+        assert_equal(np.ravel_multi_index((2, 66), (17, 94)), 254)
+        assert_raises(ValueError, np.unravel_index, -1, (2, 2))
+        assert_raises(TypeError, np.unravel_index, 0.5, (2, 2))
+        assert_raises(ValueError, np.unravel_index, 4, (2, 2))
+        assert_raises(ValueError, np.ravel_multi_index, (-3, 1), (2, 2))
+        assert_raises(ValueError, np.ravel_multi_index, (2, 1), (2, 2))
+        assert_raises(ValueError, np.ravel_multi_index, (0, -3), (2, 2))
+        assert_raises(ValueError, np.ravel_multi_index, (0, 2), (2, 2))
+        assert_raises(TypeError, np.ravel_multi_index, (0.1, 0.), (2, 2))
+
+        assert_equal(np.unravel_index((2*3 + 1)*6 + 4, (4, 3, 6)), [2, 1, 4])
+        assert_equal(
+            np.ravel_multi_index([2, 1, 4], (4, 3, 6)), (2*3 + 1)*6 + 4)
+
+        arr = np.array([[3, 6, 6], [4, 5, 1]])
+        assert_equal(np.ravel_multi_index(arr, (7, 6)), [22, 41, 37])
+        assert_equal(
+            np.ravel_multi_index(arr, (7, 6), order='F'), [31, 41, 13])
+        assert_equal(
+            np.ravel_multi_index(arr, (4, 6), mode='clip'), [22, 23, 19])
+        assert_equal(np.ravel_multi_index(arr, (4, 4), mode=('clip', 'wrap')),
+                     [12, 13, 13])
+        assert_equal(np.ravel_multi_index((3, 1, 4, 1), (6, 7, 8, 9)), 1621)
+
+        assert_equal(np.unravel_index(np.array([22, 41, 37]), (7, 6)),
+                     [[3, 6, 6], [4, 5, 1]])
+        assert_equal(
+            np.unravel_index(np.array([31, 41, 13]), (7, 6), order='F'),
+            [[3, 6, 6], [4, 5, 1]])
+        assert_equal(np.unravel_index(1621, (6, 7, 8, 9)), [3, 1, 4, 1])
+
+    def test_empty_indices(self):
+        msg1 = 'indices must be integral: the provided empty sequence was'
+        msg2 = 'only int indices permitted'
+        assert_raises_regex(TypeError, msg1, np.unravel_index, [], (10, 3, 5))
+        assert_raises_regex(TypeError, msg1, np.unravel_index, (), (10, 3, 5))
+        assert_raises_regex(TypeError, msg2, np.unravel_index, np.array([]),
+                            (10, 3, 5))
+        assert_equal(np.unravel_index(np.array([],dtype=int), (10, 3, 5)),
+                     [[], [], []])
+        assert_raises_regex(TypeError, msg1, np.ravel_multi_index, ([], []),
+                            (10, 3))
+        assert_raises_regex(TypeError, msg1, np.ravel_multi_index, ([], ['abc']),
+                            (10, 3))
+        assert_raises_regex(TypeError, msg2, np.ravel_multi_index,
+                    (np.array([]), np.array([])), (5, 3))
+        assert_equal(np.ravel_multi_index(
+                (np.array([], dtype=int), np.array([], dtype=int)), (5, 3)), [])
+        assert_equal(np.ravel_multi_index(np.array([[], []], dtype=int),
+                     (5, 3)), [])
+
+    def test_big_indices(self):
+        # ravel_multi_index for big indices (issue #7546)
+        if np.intp == np.int64:
+            arr = ([1, 29], [3, 5], [3, 117], [19, 2],
+                   [2379, 1284], [2, 2], [0, 1])
+            assert_equal(
+                np.ravel_multi_index(arr, (41, 7, 120, 36, 2706, 8, 6)),
+                [5627771580, 117259570957])
+
+        # test unravel_index for big indices (issue #9538)
+        assert_raises(ValueError, np.unravel_index, 1, (2**32-1, 2**31+1))
+
+        # test overflow checking for too big array (issue #7546)
+        dummy_arr = ([0],[0])
+        half_max = np.iinfo(np.intp).max // 2
+        assert_equal(
+            np.ravel_multi_index(dummy_arr, (half_max, 2)), [0])
+        assert_raises(ValueError,
+            np.ravel_multi_index, dummy_arr, (half_max+1, 2))
+        assert_equal(
+            np.ravel_multi_index(dummy_arr, (half_max, 2), order='F'), [0])
+        assert_raises(ValueError,
+            np.ravel_multi_index, dummy_arr, (half_max+1, 2), order='F')
+
+    def test_dtypes(self):
+        # Test with different data types
+        for dtype in [np.int16, np.uint16, np.int32,
+                      np.uint32, np.int64, np.uint64]:
+            coords = np.array(
+                [[1, 0, 1, 2, 3, 4], [1, 6, 1, 3, 2, 0]], dtype=dtype)
+            shape = (5, 8)
+            uncoords = 8*coords[0]+coords[1]
+            assert_equal(np.ravel_multi_index(coords, shape), uncoords)
+            assert_equal(coords, np.unravel_index(uncoords, shape))
+            uncoords = coords[0]+5*coords[1]
+            assert_equal(
+                np.ravel_multi_index(coords, shape, order='F'), uncoords)
+            assert_equal(coords, np.unravel_index(uncoords, shape, order='F'))
+
+            coords = np.array(
+                [[1, 0, 1, 2, 3, 4], [1, 6, 1, 3, 2, 0], [1, 3, 1, 0, 9, 5]],
+                dtype=dtype)
+            shape = (5, 8, 10)
+            uncoords = 10*(8*coords[0]+coords[1])+coords[2]
+            assert_equal(np.ravel_multi_index(coords, shape), uncoords)
+            assert_equal(coords, np.unravel_index(uncoords, shape))
+            uncoords = coords[0]+5*(coords[1]+8*coords[2])
+            assert_equal(
+                np.ravel_multi_index(coords, shape, order='F'), uncoords)
+            assert_equal(coords, np.unravel_index(uncoords, shape, order='F'))
+
+    def test_clipmodes(self):
+        # Test clipmodes
+        assert_equal(
+            np.ravel_multi_index([5, 1, -1, 2], (4, 3, 7, 12), mode='wrap'),
+            np.ravel_multi_index([1, 1, 6, 2], (4, 3, 7, 12)))
+        assert_equal(np.ravel_multi_index([5, 1, -1, 2], (4, 3, 7, 12),
+                                          mode=(
+                                              'wrap', 'raise', 'clip', 'raise')),
+                     np.ravel_multi_index([1, 1, 0, 2], (4, 3, 7, 12)))
+        assert_raises(
+            ValueError, np.ravel_multi_index, [5, 1, -1, 2], (4, 3, 7, 12))
+
+    def test_writeability(self):
+        # See gh-7269
+        x, y = np.unravel_index([1, 2, 3], (4, 5))
+        assert_(x.flags.writeable)
+        assert_(y.flags.writeable)
+
+    def test_0d(self):
+        # gh-580
+        x = np.unravel_index(0, ())
+        assert_equal(x, ())
+
+        assert_raises_regex(ValueError, "0d array", np.unravel_index, [0], ())
+        assert_raises_regex(
+            ValueError, "out of bounds", np.unravel_index, [1], ())
+
+    @pytest.mark.parametrize("mode", ["clip", "wrap", "raise"])
+    def test_empty_array_ravel(self, mode):
+        res = np.ravel_multi_index(
+                    np.zeros((3, 0), dtype=np.intp), (2, 1, 0), mode=mode)
+        assert(res.shape == (0,))
+
+        with assert_raises(ValueError):
+            np.ravel_multi_index(
+                    np.zeros((3, 1), dtype=np.intp), (2, 1, 0), mode=mode)
+
+    def test_empty_array_unravel(self):
+        res = np.unravel_index(np.zeros(0, dtype=np.intp), (2, 1, 0))
+        # res is a tuple of three empty arrays
+        assert(len(res) == 3)
+        assert(all(a.shape == (0,) for a in res))
+
+        with assert_raises(ValueError):
+            np.unravel_index([1], (2, 1, 0))
+
+class TestGrid:
+    def test_basic(self):
+        a = mgrid[-1:1:10j]
+        b = mgrid[-1:1:0.1]
+        assert_(a.shape == (10,))
+        assert_(b.shape == (20,))
+        assert_(a[0] == -1)
+        assert_almost_equal(a[-1], 1)
+        assert_(b[0] == -1)
+        assert_almost_equal(b[1]-b[0], 0.1, 11)
+        assert_almost_equal(b[-1], b[0]+19*0.1, 11)
+        assert_almost_equal(a[1]-a[0], 2.0/9.0, 11)
+
+    def test_linspace_equivalence(self):
+        y, st = np.linspace(2, 10, retstep=True)
+        assert_almost_equal(st, 8/49.0)
+        assert_array_almost_equal(y, mgrid[2:10:50j], 13)
+
+    def test_nd(self):
+        c = mgrid[-1:1:10j, -2:2:10j]
+        d = mgrid[-1:1:0.1, -2:2:0.2]
+        assert_(c.shape == (2, 10, 10))
+        assert_(d.shape == (2, 20, 20))
+        assert_array_equal(c[0][0, :], -np.ones(10, 'd'))
+        assert_array_equal(c[1][:, 0], -2*np.ones(10, 'd'))
+        assert_array_almost_equal(c[0][-1, :], np.ones(10, 'd'), 11)
+        assert_array_almost_equal(c[1][:, -1], 2*np.ones(10, 'd'), 11)
+        assert_array_almost_equal(d[0, 1, :] - d[0, 0, :],
+                                  0.1*np.ones(20, 'd'), 11)
+        assert_array_almost_equal(d[1, :, 1] - d[1, :, 0],
+                                  0.2*np.ones(20, 'd'), 11)
+
+    def test_sparse(self):
+        grid_full   = mgrid[-1:1:10j, -2:2:10j]
+        grid_sparse = ogrid[-1:1:10j, -2:2:10j]
+
+        # sparse grids can be made dense by broadcasting
+        grid_broadcast = np.broadcast_arrays(*grid_sparse)
+        for f, b in zip(grid_full, grid_broadcast):
+            assert_equal(f, b)
+
+    @pytest.mark.parametrize("start, stop, step, expected", [
+        (None, 10, 10j, (200, 10)),
+        (-10, 20, None, (1800, 30)),
+        ])
+    def test_mgrid_size_none_handling(self, start, stop, step, expected):
+        # regression test None value handling for
+        # start and step values used by mgrid;
+        # internally, this aims to cover previously
+        # unexplored code paths in nd_grid()
+        grid = mgrid[start:stop:step, start:stop:step]
+        # need a smaller grid to explore one of the
+        # untested code paths
+        grid_small = mgrid[start:stop:step]
+        assert_equal(grid.size, expected[0])
+        assert_equal(grid_small.size, expected[1])
+
+    def test_accepts_npfloating(self):
+        # regression test for #16466
+        grid64 = mgrid[0.1:0.33:0.1, ]
+        grid32 = mgrid[np.float32(0.1):np.float32(0.33):np.float32(0.1), ]
+        assert_(grid32.dtype == np.float64)
+        assert_array_almost_equal(grid64, grid32)
+
+        # different code path for single slice
+        grid64 = mgrid[0.1:0.33:0.1]
+        grid32 = mgrid[np.float32(0.1):np.float32(0.33):np.float32(0.1)]
+        assert_(grid32.dtype == np.float64)
+        assert_array_almost_equal(grid64, grid32)
+
+    def test_accepts_longdouble(self):
+        # regression tests for #16945
+        grid64 = mgrid[0.1:0.33:0.1, ]
+        grid128 = mgrid[
+            np.longdouble(0.1):np.longdouble(0.33):np.longdouble(0.1),
+        ]
+        assert_(grid128.dtype == np.longdouble)
+        assert_array_almost_equal(grid64, grid128)
+
+        grid128c_a = mgrid[0:np.longdouble(1):3.4j]
+        grid128c_b = mgrid[0:np.longdouble(1):3.4j, ]
+        assert_(grid128c_a.dtype == grid128c_b.dtype == np.longdouble)
+        assert_array_equal(grid128c_a, grid128c_b[0])
+
+        # different code path for single slice
+        grid64 = mgrid[0.1:0.33:0.1]
+        grid128 = mgrid[
+            np.longdouble(0.1):np.longdouble(0.33):np.longdouble(0.1)
+        ]
+        assert_(grid128.dtype == np.longdouble)
+        assert_array_almost_equal(grid64, grid128)
+
+    def test_accepts_npcomplexfloating(self):
+        # Related to #16466
+        assert_array_almost_equal(
+            mgrid[0.1:0.3:3j, ], mgrid[0.1:0.3:np.complex64(3j), ]
+        )
+
+        # different code path for single slice
+        assert_array_almost_equal(
+            mgrid[0.1:0.3:3j], mgrid[0.1:0.3:np.complex64(3j)]
+        )
+
+        # Related to #16945
+        grid64_a = mgrid[0.1:0.3:3.3j]
+        grid64_b = mgrid[0.1:0.3:3.3j, ][0]
+        assert_(grid64_a.dtype == grid64_b.dtype == np.float64)
+        assert_array_equal(grid64_a, grid64_b)
+
+        grid128_a = mgrid[0.1:0.3:np.clongdouble(3.3j)]
+        grid128_b = mgrid[0.1:0.3:np.clongdouble(3.3j), ][0]
+        assert_(grid128_a.dtype == grid128_b.dtype == np.longdouble)
+        assert_array_equal(grid64_a, grid64_b)
+
+
+class TestConcatenator:
+    def test_1d(self):
+        assert_array_equal(r_[1, 2, 3, 4, 5, 6], np.array([1, 2, 3, 4, 5, 6]))
+        b = np.ones(5)
+        c = r_[b, 0, 0, b]
+        assert_array_equal(c, [1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1])
+
+    def test_mixed_type(self):
+        g = r_[10.1, 1:10]
+        assert_(g.dtype == 'f8')
+
+    def test_more_mixed_type(self):
+        g = r_[-10.1, np.array([1]), np.array([2, 3, 4]), 10.0]
+        assert_(g.dtype == 'f8')
+
+    def test_complex_step(self):
+        # Regression test for #12262
+        g = r_[0:36:100j]
+        assert_(g.shape == (100,))
+
+        # Related to #16466
+        g = r_[0:36:np.complex64(100j)]
+        assert_(g.shape == (100,))
+
+    def test_2d(self):
+        b = np.random.rand(5, 5)
+        c = np.random.rand(5, 5)
+        d = r_['1', b, c]  # append columns
+        assert_(d.shape == (5, 10))
+        assert_array_equal(d[:, :5], b)
+        assert_array_equal(d[:, 5:], c)
+        d = r_[b, c]
+        assert_(d.shape == (10, 5))
+        assert_array_equal(d[:5, :], b)
+        assert_array_equal(d[5:, :], c)
+
+    def test_0d(self):
+        assert_equal(r_[0, np.array(1), 2], [0, 1, 2])
+        assert_equal(r_[[0, 1, 2], np.array(3)], [0, 1, 2, 3])
+        assert_equal(r_[np.array(0), [1, 2, 3]], [0, 1, 2, 3])
+
+
+class TestNdenumerate:
+    def test_basic(self):
+        a = np.array([[1, 2], [3, 4]])
+        assert_equal(list(ndenumerate(a)),
+                     [((0, 0), 1), ((0, 1), 2), ((1, 0), 3), ((1, 1), 4)])
+
+
+class TestIndexExpression:
+    def test_regression_1(self):
+        # ticket #1196
+        a = np.arange(2)
+        assert_equal(a[:-1], a[s_[:-1]])
+        assert_equal(a[:-1], a[index_exp[:-1]])
+
+    def test_simple_1(self):
+        a = np.random.rand(4, 5, 6)
+
+        assert_equal(a[:, :3, [1, 2]], a[index_exp[:, :3, [1, 2]]])
+        assert_equal(a[:, :3, [1, 2]], a[s_[:, :3, [1, 2]]])
+
+
+class TestIx_:
+    def test_regression_1(self):
+        # Test empty untyped inputs create outputs of indexing type, gh-5804
+        a, = np.ix_(range(0))
+        assert_equal(a.dtype, np.intp)
+
+        a, = np.ix_([])
+        assert_equal(a.dtype, np.intp)
+
+        # but if the type is specified, don't change it
+        a, = np.ix_(np.array([], dtype=np.float32))
+        assert_equal(a.dtype, np.float32)
+
+    def test_shape_and_dtype(self):
+        sizes = (4, 5, 3, 2)
+        # Test both lists and arrays
+        for func in (range, np.arange):
+            arrays = np.ix_(*[func(sz) for sz in sizes])
+            for k, (a, sz) in enumerate(zip(arrays, sizes)):
+                assert_equal(a.shape[k], sz)
+                assert_(all(sh == 1 for j, sh in enumerate(a.shape) if j != k))
+                assert_(np.issubdtype(a.dtype, np.integer))
+
+    def test_bool(self):
+        bool_a = [True, False, True, True]
+        int_a, = np.nonzero(bool_a)
+        assert_equal(np.ix_(bool_a)[0], int_a)
+
+    def test_1d_only(self):
+        idx2d = [[1, 2, 3], [4, 5, 6]]
+        assert_raises(ValueError, np.ix_, idx2d)
+
+    def test_repeated_input(self):
+        length_of_vector = 5
+        x = np.arange(length_of_vector)
+        out = ix_(x, x)
+        assert_equal(out[0].shape, (length_of_vector, 1))
+        assert_equal(out[1].shape, (1, length_of_vector))
+        # check that input shape is not modified
+        assert_equal(x.shape, (length_of_vector,))
+
+
+def test_c_():
+    a = np.c_[np.array([[1, 2, 3]]), 0, 0, np.array([[4, 5, 6]])]
+    assert_equal(a, [[1, 2, 3, 0, 0, 4, 5, 6]])
+
+
+class TestFillDiagonal:
+    def test_basic(self):
+        a = np.zeros((3, 3), int)
+        fill_diagonal(a, 5)
+        assert_array_equal(
+            a, np.array([[5, 0, 0],
+                         [0, 5, 0],
+                         [0, 0, 5]])
+            )
+
+    def test_tall_matrix(self):
+        a = np.zeros((10, 3), int)
+        fill_diagonal(a, 5)
+        assert_array_equal(
+            a, np.array([[5, 0, 0],
+                         [0, 5, 0],
+                         [0, 0, 5],
+                         [0, 0, 0],
+                         [0, 0, 0],
+                         [0, 0, 0],
+                         [0, 0, 0],
+                         [0, 0, 0],
+                         [0, 0, 0],
+                         [0, 0, 0]])
+            )
+
+    def test_tall_matrix_wrap(self):
+        a = np.zeros((10, 3), int)
+        fill_diagonal(a, 5, True)
+        assert_array_equal(
+            a, np.array([[5, 0, 0],
+                         [0, 5, 0],
+                         [0, 0, 5],
+                         [0, 0, 0],
+                         [5, 0, 0],
+                         [0, 5, 0],
+                         [0, 0, 5],
+                         [0, 0, 0],
+                         [5, 0, 0],
+                         [0, 5, 0]])
+            )
+
+    def test_wide_matrix(self):
+        a = np.zeros((3, 10), int)
+        fill_diagonal(a, 5)
+        assert_array_equal(
+            a, np.array([[5, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                         [0, 5, 0, 0, 0, 0, 0, 0, 0, 0],
+                         [0, 0, 5, 0, 0, 0, 0, 0, 0, 0]])
+            )
+
+    def test_operate_4d_array(self):
+        a = np.zeros((3, 3, 3, 3), int)
+        fill_diagonal(a, 4)
+        i = np.array([0, 1, 2])
+        assert_equal(np.where(a != 0), (i, i, i, i))
+
+    def test_low_dim_handling(self):
+        # raise error with low dimensionality
+        a = np.zeros(3, int)
+        with assert_raises_regex(ValueError, "at least 2-d"):
+            fill_diagonal(a, 5)
+
+    def test_hetero_shape_handling(self):
+        # raise error with high dimensionality and
+        # shape mismatch
+        a = np.zeros((3,3,7,3), int)
+        with assert_raises_regex(ValueError, "equal length"):
+            fill_diagonal(a, 2)
+
+
+def test_diag_indices():
+    di = diag_indices(4)
+    a = np.array([[1, 2, 3, 4],
+                  [5, 6, 7, 8],
+                  [9, 10, 11, 12],
+                  [13, 14, 15, 16]])
+    a[di] = 100
+    assert_array_equal(
+        a, np.array([[100, 2, 3, 4],
+                     [5, 100, 7, 8],
+                     [9, 10, 100, 12],
+                     [13, 14, 15, 100]])
+        )
+
+    # Now, we create indices to manipulate a 3-d array:
+    d3 = diag_indices(2, 3)
+
+    # And use it to set the diagonal of a zeros array to 1:
+    a = np.zeros((2, 2, 2), int)
+    a[d3] = 1
+    assert_array_equal(
+        a, np.array([[[1, 0],
+                      [0, 0]],
+                     [[0, 0],
+                      [0, 1]]])
+        )
+
+
+class TestDiagIndicesFrom:
+
+    def test_diag_indices_from(self):
+        x = np.random.random((4, 4))
+        r, c = diag_indices_from(x)
+        assert_array_equal(r, np.arange(4))
+        assert_array_equal(c, np.arange(4))
+
+    def test_error_small_input(self):
+        x = np.ones(7)
+        with assert_raises_regex(ValueError, "at least 2-d"):
+            diag_indices_from(x)
+
+    def test_error_shape_mismatch(self):
+        x = np.zeros((3, 3, 2, 3), int)
+        with assert_raises_regex(ValueError, "equal length"):
+            diag_indices_from(x)
+
+
+def test_ndindex():
+    x = list(ndindex(1, 2, 3))
+    expected = [ix for ix, e in ndenumerate(np.zeros((1, 2, 3)))]
+    assert_array_equal(x, expected)
+
+    x = list(ndindex((1, 2, 3)))
+    assert_array_equal(x, expected)
+
+    # Test use of scalars and tuples
+    x = list(ndindex((3,)))
+    assert_array_equal(x, list(ndindex(3)))
+
+    # Make sure size argument is optional
+    x = list(ndindex())
+    assert_equal(x, [()])
+
+    x = list(ndindex(()))
+    assert_equal(x, [()])
+
+    # Make sure 0-sized ndindex works correctly
+    x = list(ndindex(*[0]))
+    assert_equal(x, [])

shared/package-files/56/563dcf55580ef635d85c2c376da6f3269d00624d3d914e0cde871258b0929f8b/blob

@@ -0,0 +1,1297 @@
+import numpy as np
+
+from statsmodels.tools.tools import Bunch
+
+llf = np.array([-242.89663276735])
+
+nobs = np.array([202])
+
+k = np.array([3])
+
+k_exog = np.array([1])
+
+sigma = np.array([.8053519404535])
+
+chi2 = np.array([15723.381396967])
+
+df_model = np.array([2])
+
+k_ar = np.array([1])
+
+k_ma = np.array([1])
+
+params = np.array([
+    .99479180506163,
+    -.84461527652809,
+    .64859174799221])
+
+cov_params = np.array([
+    .00008904968254,
+    -.00023560410507,
+    .00012795903324,
+    -.00023560410507,
+    .00131628534915,
+    -.00022462340695,
+    .00012795903324,
+    -.00022462340695,
+    .0005651128627]).reshape(3, 3)
+
+xb = np.array([
+    0,
+    0,
+    .02869686298072,
+    .05651443824172,
+    .0503994859755,
+    .06887971609831,
+    .05940540507436,
+    .08067328482866,
+    .08167565613985,
+    .06429278105497,
+    .07087650150061,
+    .06886467337608,
+    .06716959923506,
+    .08230647444725,
+    .07099691033363,
+    .08401278406382,
+    .07996553182602,
+    .07354256510735,
+    .09366323798895,
+    .08811800926924,
+    .10296355187893,
+    .08846370875835,
+    .0852297320962,
+    .08700425922871,
+    .09751411527395,
+    .09737934917212,
+    .11228405684233,
+    .1053489819169,
+    .12352022528648,
+    .16439816355705,
+    .1643835157156,
+    .19891132414341,
+    .17551273107529,
+    .17827558517456,
+    .19562774896622,
+    .21028305590153,
+    .23767858743668,
+    .24580039083958,
+    .28269505500793,
+    .29883882403374,
+    .31247469782829,
+    .35402658581734,
+    .37410452961922,
+    .39106267690659,
+    .42040377855301,
+    .44518512487411,
+    .43608102202415,
+    .44340893626213,
+    .44959822297096,
+    .40977239608765,
+    .42118826508522,
+    .40079545974731,
+    .38357082009315,
+    .36902260780334,
+    .35673499107361,
+    .36137464642525,
+    .38031083345413,
+    .47139286994934,
+    .47323387861252,
+    .60994738340378,
+    .69538277387619,
+    .7825602889061,
+    .84117436408997,
+    .9657689332962,
+    1.0109325647354,
+    .95897275209427,
+    .96013957262039,
+    .9461076259613,
+    .9342554807663,
+    .83413934707642,
+    .83968591690063,
+    .84437066316605,
+    .83330947160721,
+    .8990553021431,
+    .87949693202972,
+    .86297762393951,
+    .89407861232758,
+    .93536442518234,
+    1.0303052663803,
+    1.1104937791824,
+    1.1481873989105,
+    1.2851470708847,
+    1.4458787441254,
+    1.5515991449356,
+    1.7309991121292,
+    1.8975404500961,
+    1.8579913377762,
+    1.8846583366394,
+    1.9672524929047,
+    1.9469071626663,
+    2.0048115253448,
+    1.9786299467087,
+    1.8213576078415,
+    1.6284521818161,
+    1.7508568763733,
+    1.5689061880112,
+    1.2950873374939,
+    1.2290096282959,
+    1.1882168054581,
+    1.1537625789642,
+    1.1697143316269,
+    1.1681711673737,
+    1.106795668602,
+    1.0849931240082,
+    1.006507396698,
+    1.0453414916992,
+    .98803448677063,
+    .95465070009232,
+    1.0165599584579,
+    .67838954925537,
+    .69311982393265,
+    .69054269790649,
+    .76345545053482,
+    .84005492925644,
+    .87471830844879,
+    .91901183128357,
+    .92638796567917,
+    .96265280246735,
+    1.0083012580872,
+    1.0618740320206,
+    1.0921038389206,
+    1.2077431678772,
+    1.2303256988525,
+    1.174311041832,
+    1.3072115182877,
+    1.314337015152,
+    1.3503924608231,
+    1.5760731697083,
+    1.5264053344727,
+    1.34929728508,
+    1.304829955101,
+    1.2522557973862,
+    1.222869515419,
+    1.198047041893,
+    1.1770839691162,
+    1.1743944883347,
+    1.1571066379547,
+    1.1274864673615,
+    1.0574153661728,
+    1.058304309845,
+    .99898308515549,
+    .9789143204689,
+    1.0070173740387,
+    1.000718832016,
+    1.0104174613953,
+    1.0486439466476,
+    1.0058424472809,
+    .98470783233643,
+    1.0119106769562,
+    1.0649236440659,
+    1.0346088409424,
+    1.0540577173233,
+    1.0704846382141,
+    .97923594713211,
+    .90216588973999,
+    .9271782040596,
+    .85819715261459,
+    .75488126277924,
+    .78776079416275,
+    .77047789096832,
+    .77089905738831,
+    .8313245177269,
+    .82229107618332,
+    .90476810932159,
+    .94439232349396,
+    1.0379292964935,
+    1.1469690799713,
+    1.1489590406418,
+    1.2257302999496,
+    1.1554099321365,
+    1.1260533332825,
+    .9811190366745,
+    .8436843752861,
+    .95287209749222,
+    .90993344783783,
+    .94875508546829,
+    1.0115815401077,
+    .94450175762177,
+    .87282890081406,
+    .91741597652435,
+    .98511207103729,
+    .9972335100174,
+    1.0975805521011,
+    1.1823329925537,
+    1.1487929821014,
+    1.270641207695,
+    1.2083609104156,
+    1.696394443512,
+    1.4628355503082,
+    1.4307631254196,
+    1.5087975263596,
+    1.1542117595673,
+    1.2262620925903,
+    1.3880327939987,
+    1.3853038549423,
+    1.4396153688431,
+    1.7208145856857,
+    1.678991317749,
+    2.110867023468,
+    1.524417757988,
+    .57946246862411,
+    .56406193971634,
+    .74643105268478])
+
+y = np.array([
+    np.nan,
+    28.979999542236,
+    29.178695678711,
+    29.40651512146,
+    29.420400619507,
+    29.608880996704,
+    29.609405517578,
+    29.830673217773,
+    29.921676635742,
+    29.874292373657,
+    29.990877151489,
+    30.048864364624,
+    30.10717010498,
+    30.292304992676,
+    30.290996551514,
+    30.464012145996,
+    30.519966125488,
+    30.553541183472,
+    30.783664703369,
+    30.838117599487,
+    31.042964935303,
+    31.038463592529,
+    31.105230331421,
+    31.207004547119,
+    31.377513885498,
+    31.477378845215,
+    31.692283630371,
+    31.755348205566,
+    32.003520965576,
+    32.444396972656,
+    32.61438369751,
+    33.048908233643,
+    33.07551574707,
+    33.278274536133,
+    33.595630645752,
+    33.91028213501,
+    34.337677001953,
+    34.645801544189,
+    35.182697296143,
+    35.598838806152,
+    36.012474060059,
+    36.654026031494,
+    37.174102783203,
+    37.691062927246,
+    38.320404052734,
+    38.94518661499,
+    39.336082458496,
+    39.843410491943,
+    40.349597930908,
+    40.509769439697,
+    41.021186828613,
+    41.300796508789,
+    41.583572387695,
+    41.869022369385,
+    42.156734466553,
+    42.561374664307,
+    43.080310821533,
+    44.171394348145,
+    44.673233032227,
+    46.209945678711,
+    47.495380401611,
+    48.882556915283,
+    50.141174316406,
+    51.965770721436,
+    53.310932159424,
+    53.958972930908,
+    54.960140228271,
+    55.84610748291,
+    56.734252929688,
+    56.934139251709,
+    57.839687347412,
+    58.744373321533,
+    59.533309936523,
+    60.899055480957,
+    61.679496765137,
+    62.46297454834,
+    63.594078063965,
+    64.83536529541,
+    66.530303955078,
+    68.210494995117,
+    69.64818572998,
+    71.885147094727,
+    74.445877075195,
+    76.751594543457,
+    79.731002807617,
+    82.797538757324,
+    84.457992553711,
+    86.584655761719,
+    89.167251586914,
+    91.046905517578,
+    93.504814147949,
+    95.378631591797,
+    96.22135925293,
+    96.628448486328,
+    99.250854492188,
+    99.668907165527,
+    99.195091247559,
+    100.0290145874,
+    100.98822021484,
+    101.95376586914,
+    103.26971435547,
+    104.46817779541,
+    105.20679473877,
+    106.1849899292,
+    106.70650482178,
+    108.0453414917,
+    108.68803405762,
+    109.45465087891,
+    110.91656494141,
+    109.37838745117,
+    110.19312286377,
+    110.89054107666,
+    112.16345977783,
+    113.54005432129,
+    114.67472076416,
+    115.91901397705,
+    116.92639160156,
+    118.16265106201,
+    119.50830078125,
+    120.96187591553,
+    122.29209899902,
+    124.30773925781,
+    125.7303237915,
+    126.57431030273,
+    128.8072052002,
+    130.21432495117,
+    131.85038757324,
+    134.97607421875,
+    136.22640991211,
+    136.44931030273,
+    137.50482177734,
+    138.45225524902,
+    139.5228729248,
+    140.59803771973,
+    141.67707824707,
+    142.87438964844,
+    143.95710754395,
+    144.92749023438,
+    145.55741882324,
+    146.65830993652,
+    147.29898071289,
+    148.17890930176,
+    149.40701293945,
+    150.40071105957,
+    151.51042175293,
+    152.84864807129,
+    153.60585021973,
+    154.48471069336,
+    155.7119140625,
+    157.16493225098,
+    158.03460693359,
+    159.25405883789,
+    160.47047424316,
+    160.87922668457,
+    161.30215454102,
+    162.42718505859,
+    162.85820007324,
+    162.95487976074,
+    163.98776245117,
+    164.67047119141,
+    165.47090148926,
+    166.73132324219,
+    167.52229309082,
+    169.00477600098,
+    170.24440002441,
+    171.93792724609,
+    173.84696960449,
+    175.04895019531,
+    176.82572937012,
+    177.55540466309,
+    178.52604675293,
+    178.58113098145,
+    178.54368591309,
+    180.25286865234,
+    180.90992736816,
+    182.14875793457,
+    183.61158752441,
+    184.14450073242,
+    184.5728302002,
+    185.81741333008,
+    187.28511047363,
+    188.39723205566,
+    190.19758605957,
+    191.98233032227,
+    192.94879150391,
+    195.07064819336,
+    195.90835571289,
+    200.89639282227,
+    200.86282348633,
+    202.13075256348,
+    204.20880126953,
+    203.05419921875,
+    204.80026245117,
+    207.3080291748,
+    208.72329711914,
+    210.57261657715,
+    214.21580505371,
+    215.67597961426,
+    220.72087097168,
+    218.41342163086,
+    212.75346374512,
+    213.23506164551,
+    215.21542358398])
+
+resid = np.array([
+    np.nan,
+    .17000007629395,
+    .17130389809608,
+    -.03651398047805,
+    .11960058659315,
+    -.05888139456511,
+    .14059536159039,
+    .00932686589658,
+    -.11167634278536,
+    .04570783302188,
+    -.0108770346269,
+    -.00886330008507,
+    .10282856971025,
+    -.07230624556541,
+    .08900293707848,
+    -.0240114107728,
+    -.03996651992202,
+    .13645842671394,
+    -.03366377204657,
+    .10188252478838,
+    -.09296332299709,
+    -.01846401393414,
+    .01477065030485,
+    .0729955881834,
+    .00248436117545,
+    .10262141376734,
+    -.04228436201811,
+    .12465056031942,
+    .27647939324379,
+    .00560382334515,
+    .23561419546604,
+    -.1489082723856,
+    .02448422275484,
+    .12172746658325,
+    .10437148809433,
+    .18971465528011,
+    .06232447177172,
+    .25419962406158,
+    .11730266362429,
+    .10116269439459,
+    .2875237762928,
+    .14597341418266,
+    .12589547038078,
+    .20893961191177,
+    .17959471046925,
+    -.04518361017108,
+    .06391899287701,
+    .05659105628729,
+    -.24960128962994,
+    .09022761881351,
+    -.12118522822857,
+    -.10079623758793,
+    -.08357158303261,
+    -.06902338564396,
+    .04326653853059,
+    .13862533867359,
+    .61968916654587,
+    .02860714122653,
+    .92676383256912,
+    .59005337953568,
+    .60461646318436,
+    .41744044423103,
+    .85882639884949,
+    .33423033356667,
+    -.31093180179596,
+    .04102724045515,
+    -.06013804674149,
+    -.04610994458199,
+    -.63425624370575,
+    .06586220860481,
+    .06031560897827,
+    -.04437142238021,
+    .46668976545334,
+    -.09905604273081,
+    -.07949769496918,
+    .23702463507652,
+    .30592212080956,
+    .66463404893875,
+    .56969320774078,
+    .28950771689415,
+    .95181107521057,
+    1.1148544549942,
+    .75411820411682,
+    1.2484039068222,
+    1.1690024137497,
+    -.1975435167551,
+    .24200716614723,
+    .6153416633606,
+    -.06725100427866,
+    .45309436321259,
+    -.10480991750956,
+    -.97863000631332,
+    -1.2213591337204,
+    .8715478181839,
+    -1.1508584022522,
+    -1.7689031362534,
+    -.39508575201035,
+    -.22900961339474,
+    -.18821682035923,
+    .14623281359673,
+    .03029025532305,
+    -.36817568540573,
+    -.10679569840431,
+    -.48499462008476,
+    .29349562525749,
+    -.34534454345703,
+    -.18803144991398,
+    .44535079598427,
+    -2.2165644168854,
+    .12161350995302,
+    .00687709869817,
+    .50946187973022,
+    .53653997182846,
+    .25995117425919,
+    .32527860999107,
+    .08098815381527,
+    .27360898256302,
+    .33735024929047,
+    .39170032739639,
+    .23812144994736,
+    .80789774656296,
+    .19225835800171,
+    -.33032417297363,
+    .92568749189377,
+    .09278241544962,
+    .28566908836365,
+    1.5496014356613,
+    -.27607008814812,
+    -1.1263961791992,
+    -.24930645525455,
+    -.30482992529869,
+    -.15224970877171,
+    -.12287864089012,
+    -.09804095327854,
+    .02291300706565,
+    -.07438835501671,
+    -.15710659325123,
+    -.42748948931694,
+    .04259072244167,
+    -.35830733180046,
+    -.09898918122053,
+    .22108262777328,
+    -.00701736938208,
+    .0992873236537,
+    .28958559036255,
+    -.24864092469215,
+    -.10584850609303,
+    .21528913080692,
+    .38809850811958,
+    -.16492980718613,
+    .16538816690445,
+    .1459391862154,
+    -.57048463821411,
+    -.47923597693443,
+    .19784018397331,
+    -.4271782040596,
+    -.65820020437241,
+    .24511873722076,
+    -.0877638310194,
+    .02952514961362,
+    .42909786105156,
+    -.03132146969438,
+    .57771807909012,
+    .29522883892059,
+    .6555985212326,
+    .76207375526428,
+    .05302781611681,
+    .55105316638947,
+    -.42574247717857,
+    -.15540990233421,
+    -.92604118585587,
+    -.88112819194794,
+    .75632172822952,
+    -.25287514925003,
+    .29006350040436,
+    .45125409960747,
+    -.41159069538116,
+    -.44450175762177,
+    .32716807723045,
+    .48259317874908,
+    .11487878113985,
+    .70277869701385,
+    .60241633653641,
+    -.18233296275139,
+    .85120695829391,
+    -.37064728140831,
+    3.2916390895844,
+    -1.4963974952698,
+    -.16283248364925,
+    .56923681497574,
+    -2.3088004589081,
+    .51979947090149,
+    1.1197309494019,
+    .02996650896966,
+    .40969428420067,
+    1.9223841428757,
+    -.21881568431854,
+    2.9340152740479,
+    -3.8318600654602,
+    -6.239429473877,
+    -.08245316892862,
+    1.2339268922806,
+    1.1695692539215])
+
+yr = np.array([
+    np.nan,
+    .17000007629395,
+    .17130389809608,
+    -.03651398047805,
+    .11960058659315,
+    -.05888139456511,
+    .14059536159039,
+    .00932686589658,
+    -.11167634278536,
+    .04570783302188,
+    -.0108770346269,
+    -.00886330008507,
+    .10282856971025,
+    -.07230624556541,
+    .08900293707848,
+    -.0240114107728,
+    -.03996651992202,
+    .13645842671394,
+    -.03366377204657,
+    .10188252478838,
+    -.09296332299709,
+    -.01846401393414,
+    .01477065030485,
+    .0729955881834,
+    .00248436117545,
+    .10262141376734,
+    -.04228436201811,
+    .12465056031942,
+    .27647939324379,
+    .00560382334515,
+    .23561419546604,
+    -.1489082723856,
+    .02448422275484,
+    .12172746658325,
+    .10437148809433,
+    .18971465528011,
+    .06232447177172,
+    .25419962406158,
+    .11730266362429,
+    .10116269439459,
+    .2875237762928,
+    .14597341418266,
+    .12589547038078,
+    .20893961191177,
+    .17959471046925,
+    -.04518361017108,
+    .06391899287701,
+    .05659105628729,
+    -.24960128962994,
+    .09022761881351,
+    -.12118522822857,
+    -.10079623758793,
+    -.08357158303261,
+    -.06902338564396,
+    .04326653853059,
+    .13862533867359,
+    .61968916654587,
+    .02860714122653,
+    .92676383256912,
+    .59005337953568,
+    .60461646318436,
+    .41744044423103,
+    .85882639884949,
+    .33423033356667,
+    -.31093180179596,
+    .04102724045515,
+    -.06013804674149,
+    -.04610994458199,
+    -.63425624370575,
+    .06586220860481,
+    .06031560897827,
+    -.04437142238021,
+    .46668976545334,
+    -.09905604273081,
+    -.07949769496918,
+    .23702463507652,
+    .30592212080956,
+    .66463404893875,
+    .56969320774078,
+    .28950771689415,
+    .95181107521057,
+    1.1148544549942,
+    .75411820411682,
+    1.2484039068222,
+    1.1690024137497,
+    -.1975435167551,
+    .24200716614723,
+    .6153416633606,
+    -.06725100427866,
+    .45309436321259,
+    -.10480991750956,
+    -.97863000631332,
+    -1.2213591337204,
+    .8715478181839,
+    -1.1508584022522,
+    -1.7689031362534,
+    -.39508575201035,
+    -.22900961339474,
+    -.18821682035923,
+    .14623281359673,
+    .03029025532305,
+    -.36817568540573,
+    -.10679569840431,
+    -.48499462008476,
+    .29349562525749,
+    -.34534454345703,
+    -.18803144991398,
+    .44535079598427,
+    -2.2165644168854,
+    .12161350995302,
+    .00687709869817,
+    .50946187973022,
+    .53653997182846,
+    .25995117425919,
+    .32527860999107,
+    .08098815381527,
+    .27360898256302,
+    .33735024929047,
+    .39170032739639,
+    .23812144994736,
+    .80789774656296,
+    .19225835800171,
+    -.33032417297363,
+    .92568749189377,
+    .09278241544962,
+    .28566908836365,
+    1.5496014356613,
+    -.27607008814812,
+    -1.1263961791992,
+    -.24930645525455,
+    -.30482992529869,
+    -.15224970877171,
+    -.12287864089012,
+    -.09804095327854,
+    .02291300706565,
+    -.07438835501671,
+    -.15710659325123,
+    -.42748948931694,
+    .04259072244167,
+    -.35830733180046,
+    -.09898918122053,
+    .22108262777328,
+    -.00701736938208,
+    .0992873236537,
+    .28958559036255,
+    -.24864092469215,
+    -.10584850609303,
+    .21528913080692,
+    .38809850811958,
+    -.16492980718613,
+    .16538816690445,
+    .1459391862154,
+    -.57048463821411,
+    -.47923597693443,
+    .19784018397331,
+    -.4271782040596,
+    -.65820020437241,
+    .24511873722076,
+    -.0877638310194,
+    .02952514961362,
+    .42909786105156,
+    -.03132146969438,
+    .57771807909012,
+    .29522883892059,
+    .6555985212326,
+    .76207375526428,
+    .05302781611681,
+    .55105316638947,
+    -.42574247717857,
+    -.15540990233421,
+    -.92604118585587,
+    -.88112819194794,
+    .75632172822952,
+    -.25287514925003,
+    .29006350040436,
+    .45125409960747,
+    -.41159069538116,
+    -.44450175762177,
+    .32716807723045,
+    .48259317874908,
+    .11487878113985,
+    .70277869701385,
+    .60241633653641,
+    -.18233296275139,
+    .85120695829391,
+    -.37064728140831,
+    3.2916390895844,
+    -1.4963974952698,
+    -.16283248364925,
+    .56923681497574,
+    -2.3088004589081,
+    .51979947090149,
+    1.1197309494019,
+    .02996650896966,
+    .40969428420067,
+    1.9223841428757,
+    -.21881568431854,
+    2.9340152740479,
+    -3.8318600654602,
+    -6.239429473877,
+    -.08245316892862,
+    1.2339268922806,
+    1.1695692539215])
+
+mse = np.array([
+    1.1112809181213,
+    .6632194519043,
+    .65879660844803,
+    .65575885772705,
+    .65364873409271,
+    .65217137336731,
+    .65113133192062,
+    .6503963470459,
+    .64987552165985,
+    .64950579404831,
+    .64924287796021,
+    .64905577898026,
+    .64892256259918,
+    .64882761240005,
+    .64875996112823,
+    .64871168136597,
+    .64867728948593,
+    .64865279197693,
+    .64863526821136,
+    .64862281084061,
+    .64861387014389,
+    .64860755205154,
+    .64860302209854,
+    .64859980344772,
+    .64859747886658,
+    .64859586954117,
+    .64859467744827,
+    .64859384298325,
+    .6485932469368,
+    .64859282970428,
+    .64859253168106,
+    .64859229326248,
+    .64859211444855,
+    .64859199523926,
+    .64859193563461,
+    .64859187602997,
+    .64859187602997,
+    .64859181642532,
+    .64859181642532,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068,
+    .64859175682068])
+
+stdp = np.array([
+    0,
+    0,
+    .02869686298072,
+    .05651443824172,
+    .0503994859755,
+    .06887971609831,
+    .05940540507436,
+    .08067328482866,
+    .08167565613985,
+    .06429278105497,
+    .07087650150061,
+    .06886467337608,
+    .06716959923506,
+    .08230647444725,
+    .07099691033363,
+    .08401278406382,
+    .07996553182602,
+    .07354256510735,
+    .09366323798895,
+    .08811800926924,
+    .10296355187893,
+    .08846370875835,
+    .0852297320962,
+    .08700425922871,
+    .09751411527395,
+    .09737934917212,
+    .11228405684233,
+    .1053489819169,
+    .12352022528648,
+    .16439816355705,
+    .1643835157156,
+    .19891132414341,
+    .17551273107529,
+    .17827558517456,
+    .19562774896622,
+    .21028305590153,
+    .23767858743668,
+    .24580039083958,
+    .28269505500793,
+    .29883882403374,
+    .31247469782829,
+    .35402658581734,
+    .37410452961922,
+    .39106267690659,
+    .42040377855301,
+    .44518512487411,
+    .43608102202415,
+    .44340893626213,
+    .44959822297096,
+    .40977239608765,
+    .42118826508522,
+    .40079545974731,
+    .38357082009315,
+    .36902260780334,
+    .35673499107361,
+    .36137464642525,
+    .38031083345413,
+    .47139286994934,
+    .47323387861252,
+    .60994738340378,
+    .69538277387619,
+    .7825602889061,
+    .84117436408997,
+    .9657689332962,
+    1.0109325647354,
+    .95897275209427,
+    .96013957262039,
+    .9461076259613,
+    .9342554807663,
+    .83413934707642,
+    .83968591690063,
+    .84437066316605,
+    .83330947160721,
+    .8990553021431,
+    .87949693202972,
+    .86297762393951,
+    .89407861232758,
+    .93536442518234,
+    1.0303052663803,
+    1.1104937791824,
+    1.1481873989105,
+    1.2851470708847,
+    1.4458787441254,
+    1.5515991449356,
+    1.7309991121292,
+    1.8975404500961,
+    1.8579913377762,
+    1.8846583366394,
+    1.9672524929047,
+    1.9469071626663,
+    2.0048115253448,
+    1.9786299467087,
+    1.8213576078415,
+    1.6284521818161,
+    1.7508568763733,
+    1.5689061880112,
+    1.2950873374939,
+    1.2290096282959,
+    1.1882168054581,
+    1.1537625789642,
+    1.1697143316269,
+    1.1681711673737,
+    1.106795668602,
+    1.0849931240082,
+    1.006507396698,
+    1.0453414916992,
+    .98803448677063,
+    .95465070009232,
+    1.0165599584579,
+    .67838954925537,
+    .69311982393265,
+    .69054269790649,
+    .76345545053482,
+    .84005492925644,
+    .87471830844879,
+    .91901183128357,
+    .92638796567917,
+    .96265280246735,
+    1.0083012580872,
+    1.0618740320206,
+    1.0921038389206,
+    1.2077431678772,
+    1.2303256988525,
+    1.174311041832,
+    1.3072115182877,
+    1.314337015152,
+    1.3503924608231,
+    1.5760731697083,
+    1.5264053344727,
+    1.34929728508,
+    1.304829955101,
+    1.2522557973862,
+    1.222869515419,
+    1.198047041893,
+    1.1770839691162,
+    1.1743944883347,
+    1.1571066379547,
+    1.1274864673615,
+    1.0574153661728,
+    1.058304309845,
+    .99898308515549,
+    .9789143204689,
+    1.0070173740387,
+    1.000718832016,
+    1.0104174613953,
+    1.0486439466476,
+    1.0058424472809,
+    .98470783233643,
+    1.0119106769562,
+    1.0649236440659,
+    1.0346088409424,
+    1.0540577173233,
+    1.0704846382141,
+    .97923594713211,
+    .90216588973999,
+    .9271782040596,
+    .85819715261459,
+    .75488126277924,
+    .78776079416275,
+    .77047789096832,
+    .77089905738831,
+    .8313245177269,
+    .82229107618332,
+    .90476810932159,
+    .94439232349396,
+    1.0379292964935,
+    1.1469690799713,
+    1.1489590406418,
+    1.2257302999496,
+    1.1554099321365,
+    1.1260533332825,
+    .9811190366745,
+    .8436843752861,
+    .95287209749222,
+    .90993344783783,
+    .94875508546829,
+    1.0115815401077,
+    .94450175762177,
+    .87282890081406,
+    .91741597652435,
+    .98511207103729,
+    .9972335100174,
+    1.0975805521011,
+    1.1823329925537,
+    1.1487929821014,
+    1.270641207695,
+    1.2083609104156,
+    1.696394443512,
+    1.4628355503082,
+    1.4307631254196,
+    1.5087975263596,
+    1.1542117595673,
+    1.2262620925903,
+    1.3880327939987,
+    1.3853038549423,
+    1.4396153688431,
+    1.7208145856857,
+    1.678991317749,
+    2.110867023468,
+    1.524417757988,
+    .57946246862411,
+    .56406193971634,
+    .74643105268478])
+
+icstats = np.array([
+    202,
+    np.nan,
+    -242.89663276735,
+    3,
+    491.79326553469,
+    501.7180686269])
+
+
+results = Bunch(
+    llf=llf,
+    nobs=nobs,
+    k=k,
+    k_exog=k_exog,
+    sigma=sigma,
+    chi2=chi2,
+    df_model=df_model,
+    k_ar=k_ar,
+    k_ma=k_ma,
+    params=params,
+    cov_params=cov_params,
+    xb=xb,
+    y=y,
+    resid=resid,
+    yr=yr,
+    mse=mse,
+    stdp=stdp,
+    icstats=icstats
+)

shared/package-files/56/563e1558fcad6e16795bbefe59ab34fffabc06bf514d4d6f467045ac7f0cdf3c/blob

@@ -0,0 +1,227 @@
+#pragma once
+
+#include <c10/util/BFloat16.h>
+#include <c10/util/Float8_e4m3fn.h>
+#include <c10/util/Float8_e4m3fnuz.h>
+#include <c10/util/Float8_e5m2.h>
+#include <c10/util/Float8_e5m2fnuz.h>
+#include <c10/util/Half.h>
+#include <torch/csrc/Export.h>
+#include <cstddef>
+#include <cstdint>
+
+#ifdef __FreeBSD__
+#include <sys/endian.h>
+#include <sys/types.h>
+#define thp_bswap16(x) bswap16(x)
+#define thp_bswap32(x) bswap32(x)
+#define thp_bswap64(x) bswap64(x)
+#elif defined(__APPLE__)
+#include <libkern/OSByteOrder.h>
+#define thp_bswap16(x) OSSwapInt16(x)
+#define thp_bswap32(x) OSSwapInt32(x)
+#define thp_bswap64(x) OSSwapInt64(x)
+#elif defined(__GNUC__) && !defined(__MINGW32__)
+#include <byteswap.h>
+#define thp_bswap16(x) bswap_16(x)
+#define thp_bswap32(x) bswap_32(x)
+#define thp_bswap64(x) bswap_64(x)
+#elif defined _WIN32 || defined _WIN64
+#define thp_bswap16(x) _byteswap_ushort(x)
+#define thp_bswap32(x) _byteswap_ulong(x)
+#define thp_bswap64(x) _byteswap_uint64(x)
+#endif
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define to_be16(x) thp_bswap16(x)
+#define from_be16(x) thp_bswap16(x)
+#define to_be32(x) thp_bswap32(x)
+#define from_be32(x) thp_bswap32(x)
+#define to_be64(x) thp_bswap64(x)
+#define from_be64(x) thp_bswap64(x)
+#define to_le16(x) (x)
+#define from_le16(x) (x)
+#define to_le32(x) (x)
+#define from_le32(x) (x)
+#define to_le64(x) (x)
+#define from_le64(x) (x)
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#define to_be16(x) (x)
+#define from_be16(x) (x)
+#define to_be32(x) (x)
+#define from_be32(x) (x)
+#define to_be64(x) (x)
+#define from_be64(x) (x)
+#define to_le16(x) thp_bswap16(x)
+#define from_le16(x) thp_bswap16(x)
+#define to_le32(x) thp_bswap32(x)
+#define from_le32(x) thp_bswap32(x)
+#define to_le64(x) thp_bswap64(x)
+#define from_le64(x) thp_bswap64(x)
+#else
+#error Unexpected or undefined __BYTE_ORDER__
+#endif
+
+namespace torch {
+namespace utils {
+
+enum THPByteOrder { THP_LITTLE_ENDIAN = 0, THP_BIG_ENDIAN = 1 };
+
+TORCH_API THPByteOrder THP_nativeByteOrder();
+
+TORCH_API void THP_decodeInt16Buffer(
+    int16_t* dst,
+    const uint8_t* src,
+    bool do_byte_swap,
+    size_t len);
+TORCH_API void THP_decodeInt32Buffer(
+    int32_t* dst,
+    const uint8_t* src,
+    bool do_byte_swap,
+    size_t len);
+TORCH_API void THP_decodeInt64Buffer(
+    int64_t* dst,
+    const uint8_t* src,
+    bool do_byte_swap,
+    size_t len);
+TORCH_API void THP_decodeHalfBuffer(
+    c10::Half* dst,
+    const uint8_t* src,
+    bool do_byte_swap,
+    size_t len);
+TORCH_API void THP_decodeFloatBuffer(
+    float* dst,
+    const uint8_t* src,
+    bool do_byte_swap,
+    size_t len);
+TORCH_API void THP_decodeDoubleBuffer(
+    double* dst,
+    const uint8_t* src,
+    bool do_byte_swap,
+    size_t len);
+TORCH_API void THP_decodeBoolBuffer(
+    bool* dst,
+    const uint8_t* src,
+    bool do_byte_swap,
+    size_t len);
+TORCH_API void THP_decodeBFloat16Buffer(
+    at::BFloat16* dst,
+    const uint8_t* src,
+    bool do_byte_swap,
+    size_t len);
+TORCH_API void THP_decodeComplexFloatBuffer(
+    c10::complex<float>* dst,
+    const uint8_t* src,
+    bool do_byte_swap,
+    size_t len);
+TORCH_API void THP_decodeComplexDoubleBuffer(
+    c10::complex<double>* dst,
+    const uint8_t* src,
+    bool do_byte_swap,
+    size_t len);
+
+TORCH_API void THP_decodeInt16Buffer(
+    int16_t* dst,
+    const uint8_t* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_decodeInt32Buffer(
+    int32_t* dst,
+    const uint8_t* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_decodeInt64Buffer(
+    int64_t* dst,
+    const uint8_t* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_decodeHalfBuffer(
+    c10::Half* dst,
+    const uint8_t* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_decodeFloatBuffer(
+    float* dst,
+    const uint8_t* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_decodeDoubleBuffer(
+    double* dst,
+    const uint8_t* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_decodeBoolBuffer(
+    bool* dst,
+    const uint8_t* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_decodeBFloat16Buffer(
+    at::BFloat16* dst,
+    const uint8_t* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_decodeFloat8_e5m2Buffer(
+    at::Float8_e5m2* dst,
+    const uint8_t* src,
+    size_t len);
+TORCH_API void THP_decodeFloat8_e4m3fnBuffer(
+    at::Float8_e4m3fn* dst,
+    const uint8_t* src,
+    size_t len);
+TORCH_API void THP_decodeFloat8_e5m2fnuzBuffer(
+    at::Float8_e5m2fnuz* dst,
+    const uint8_t* src,
+    size_t len);
+TORCH_API void THP_decodeFloat8_e4m3fnuzBuffer(
+    at::Float8_e4m3fnuz* dst,
+    const uint8_t* src,
+    size_t len);
+TORCH_API void THP_decodeComplexFloatBuffer(
+    c10::complex<float>* dst,
+    const uint8_t* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_decodeComplexDoubleBuffer(
+    c10::complex<double>* dst,
+    const uint8_t* src,
+    THPByteOrder order,
+    size_t len);
+
+TORCH_API void THP_encodeInt16Buffer(
+    uint8_t* dst,
+    const int16_t* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_encodeInt32Buffer(
+    uint8_t* dst,
+    const int32_t* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_encodeInt64Buffer(
+    uint8_t* dst,
+    const int64_t* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_encodeFloatBuffer(
+    uint8_t* dst,
+    const float* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_encodeDoubleBuffer(
+    uint8_t* dst,
+    const double* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_encodeComplexFloatBuffer(
+    uint8_t* dst,
+    const c10::complex<float>* src,
+    THPByteOrder order,
+    size_t len);
+TORCH_API void THP_encodeComplexDoubleBuffer(
+    uint8_t* dst,
+    const c10::complex<double>* src,
+    THPByteOrder order,
+    size_t len);
+
+} // namespace utils
+} // namespace torch

shared/package-files/56/563e435ddf0f296b765370c217a43555179ae3317e4104ce4494b5b4c3b59e4b/blob

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

shared/package-files/56/563fa8988b3ade8702d35f49f4e1940ba66e3adae9fe83cd64743e2e400353a9/blob

@@ -0,0 +1,189 @@
+"""
+Key bindings, for scrolling up and down through pages.
+
+This are separate bindings, because GNU readline doesn't have them, but
+they are very useful for navigating through long multiline buffers, like in
+Vi, Emacs, etc...
+"""
+from __future__ import annotations
+
+from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+
+__all__ = [
+    "scroll_forward",
+    "scroll_backward",
+    "scroll_half_page_up",
+    "scroll_half_page_down",
+    "scroll_one_line_up",
+    "scroll_one_line_down",
+]
+
+E = KeyPressEvent
+
+
+def scroll_forward(event: E, half: bool = False) -> None:
+    """
+    Scroll window down.
+    """
+    w = event.app.layout.current_window
+    b = event.app.current_buffer
+
+    if w and w.render_info:
+        info = w.render_info
+        ui_content = info.ui_content
+
+        # Height to scroll.
+        scroll_height = info.window_height
+        if half:
+            scroll_height //= 2
+
+        # Calculate how many lines is equivalent to that vertical space.
+        y = b.document.cursor_position_row + 1
+        height = 0
+        while y < ui_content.line_count:
+            line_height = info.get_height_for_line(y)
+
+            if height + line_height < scroll_height:
+                height += line_height
+                y += 1
+            else:
+                break
+
+        b.cursor_position = b.document.translate_row_col_to_index(y, 0)
+
+
+def scroll_backward(event: E, half: bool = False) -> None:
+    """
+    Scroll window up.
+    """
+    w = event.app.layout.current_window
+    b = event.app.current_buffer
+
+    if w and w.render_info:
+        info = w.render_info
+
+        # Height to scroll.
+        scroll_height = info.window_height
+        if half:
+            scroll_height //= 2
+
+        # Calculate how many lines is equivalent to that vertical space.
+        y = max(0, b.document.cursor_position_row - 1)
+        height = 0
+        while y > 0:
+            line_height = info.get_height_for_line(y)
+
+            if height + line_height < scroll_height:
+                height += line_height
+                y -= 1
+            else:
+                break
+
+        b.cursor_position = b.document.translate_row_col_to_index(y, 0)
+
+
+def scroll_half_page_down(event: E) -> None:
+    """
+    Same as ControlF, but only scroll half a page.
+    """
+    scroll_forward(event, half=True)
+
+
+def scroll_half_page_up(event: E) -> None:
+    """
+    Same as ControlB, but only scroll half a page.
+    """
+    scroll_backward(event, half=True)
+
+
+def scroll_one_line_down(event: E) -> None:
+    """
+    scroll_offset += 1
+    """
+    w = event.app.layout.current_window
+    b = event.app.current_buffer
+
+    if w:
+        # When the cursor is at the top, move to the next line. (Otherwise, only scroll.)
+        if w.render_info:
+            info = w.render_info
+
+            if w.vertical_scroll < info.content_height - info.window_height:
+                if info.cursor_position.y <= info.configured_scroll_offsets.top:
+                    b.cursor_position += b.document.get_cursor_down_position()
+
+                w.vertical_scroll += 1
+
+
+def scroll_one_line_up(event: E) -> None:
+    """
+    scroll_offset -= 1
+    """
+    w = event.app.layout.current_window
+    b = event.app.current_buffer
+
+    if w:
+        # When the cursor is at the bottom, move to the previous line. (Otherwise, only scroll.)
+        if w.render_info:
+            info = w.render_info
+
+            if w.vertical_scroll > 0:
+                first_line_height = info.get_height_for_line(info.first_visible_line())
+
+                cursor_up = info.cursor_position.y - (
+                    info.window_height
+                    - 1
+                    - first_line_height
+                    - info.configured_scroll_offsets.bottom
+                )
+
+                # Move cursor up, as many steps as the height of the first line.
+                # TODO: not entirely correct yet, in case of line wrapping and many long lines.
+                for _ in range(max(0, cursor_up)):
+                    b.cursor_position += b.document.get_cursor_up_position()
+
+                # Scroll window
+                w.vertical_scroll -= 1
+
+
+def scroll_page_down(event: E) -> None:
+    """
+    Scroll page down. (Prefer the cursor at the top of the page, after scrolling.)
+    """
+    w = event.app.layout.current_window
+    b = event.app.current_buffer
+
+    if w and w.render_info:
+        # Scroll down one page.
+        line_index = max(w.render_info.last_visible_line(), w.vertical_scroll + 1)
+        w.vertical_scroll = line_index
+
+        b.cursor_position = b.document.translate_row_col_to_index(line_index, 0)
+        b.cursor_position += b.document.get_start_of_line_position(
+            after_whitespace=True
+        )
+
+
+def scroll_page_up(event: E) -> None:
+    """
+    Scroll page up. (Prefer the cursor at the bottom of the page, after scrolling.)
+    """
+    w = event.app.layout.current_window
+    b = event.app.current_buffer
+
+    if w and w.render_info:
+        # Put cursor at the first visible line. (But make sure that the cursor
+        # moves at least one line up.)
+        line_index = max(
+            0,
+            min(w.render_info.first_visible_line(), b.document.cursor_position_row - 1),
+        )
+
+        b.cursor_position = b.document.translate_row_col_to_index(line_index, 0)
+        b.cursor_position += b.document.get_start_of_line_position(
+            after_whitespace=True
+        )
+
+        # Set the scroll offset. We can safely set it to zero; the Window will
+        # make sure that it scrolls at least until the cursor becomes visible.
+        w.vertical_scroll = 0

shared/package-files/56/5641a9e909f66d0b990a6d4fb2093bc4490352081f4974b9844e06dbfdfb5822/blob

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <ATen/native/DispatchStub.h>
+#include <cstdint>
+
+namespace at {
+struct TensorIterator;
+
+namespace native {
+
+using _compute_linear_combination_fn = void(*)(
+  TensorIterator& iter,
+  int64_t in_stride,
+  int64_t coeff_stride,
+  int64_t num_summations
+);
+
+DECLARE_DISPATCH(_compute_linear_combination_fn, _compute_linear_combination_stub);
+
+}} // namespace at::native

shared/package-files/56/5643ad9376af2ed3a5d23bdae0172e6ec19fbb325d68d62661e90050f4cf118f/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 cuda {
+
+TORCH_API at::Tensor bmm(const at::Tensor & self, const at::Tensor & mat2);
+TORCH_API at::Tensor & bmm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat2);
+TORCH_API at::Tensor & bmm_outf(const at::Tensor & self, const at::Tensor & mat2, at::Tensor & out);
+
+} // namespace cuda
+} // namespace at

shared/package-files/56/5646119d7e7043b4628400fa918aa2748fe16fd36028948013419a62e94da476/blob

@@ -0,0 +1,359 @@
+from typing import Optional, Union
+from urllib.parse import urlparse
+
+import dns.asyncbackend
+import dns.asyncquery
+import dns.inet
+import dns.message
+import dns.query
+
+
+class Nameserver:
+    def __init__(self):
+        pass
+
+    def __str__(self):
+        raise NotImplementedError
+
+    def kind(self) -> str:
+        raise NotImplementedError
+
+    def is_always_max_size(self) -> bool:
+        raise NotImplementedError
+
+    def answer_nameserver(self) -> str:
+        raise NotImplementedError
+
+    def answer_port(self) -> int:
+        raise NotImplementedError
+
+    def query(
+        self,
+        request: dns.message.QueryMessage,
+        timeout: float,
+        source: Optional[str],
+        source_port: int,
+        max_size: bool,
+        one_rr_per_rrset: bool = False,
+        ignore_trailing: bool = False,
+    ) -> dns.message.Message:
+        raise NotImplementedError
+
+    async def async_query(
+        self,
+        request: dns.message.QueryMessage,
+        timeout: float,
+        source: Optional[str],
+        source_port: int,
+        max_size: bool,
+        backend: dns.asyncbackend.Backend,
+        one_rr_per_rrset: bool = False,
+        ignore_trailing: bool = False,
+    ) -> dns.message.Message:
+        raise NotImplementedError
+
+
+class AddressAndPortNameserver(Nameserver):
+    def __init__(self, address: str, port: int):
+        super().__init__()
+        self.address = address
+        self.port = port
+
+    def kind(self) -> str:
+        raise NotImplementedError
+
+    def is_always_max_size(self) -> bool:
+        return False
+
+    def __str__(self):
+        ns_kind = self.kind()
+        return f"{ns_kind}:{self.address}@{self.port}"
+
+    def answer_nameserver(self) -> str:
+        return self.address
+
+    def answer_port(self) -> int:
+        return self.port
+
+
+class Do53Nameserver(AddressAndPortNameserver):
+    def __init__(self, address: str, port: int = 53):
+        super().__init__(address, port)
+
+    def kind(self):
+        return "Do53"
+
+    def query(
+        self,
+        request: dns.message.QueryMessage,
+        timeout: float,
+        source: Optional[str],
+        source_port: int,
+        max_size: bool,
+        one_rr_per_rrset: bool = False,
+        ignore_trailing: bool = False,
+    ) -> dns.message.Message:
+        if max_size:
+            response = dns.query.tcp(
+                request,
+                self.address,
+                timeout=timeout,
+                port=self.port,
+                source=source,
+                source_port=source_port,
+                one_rr_per_rrset=one_rr_per_rrset,
+                ignore_trailing=ignore_trailing,
+            )
+        else:
+            response = dns.query.udp(
+                request,
+                self.address,
+                timeout=timeout,
+                port=self.port,
+                source=source,
+                source_port=source_port,
+                raise_on_truncation=True,
+                one_rr_per_rrset=one_rr_per_rrset,
+                ignore_trailing=ignore_trailing,
+                ignore_errors=True,
+                ignore_unexpected=True,
+            )
+        return response
+
+    async def async_query(
+        self,
+        request: dns.message.QueryMessage,
+        timeout: float,
+        source: Optional[str],
+        source_port: int,
+        max_size: bool,
+        backend: dns.asyncbackend.Backend,
+        one_rr_per_rrset: bool = False,
+        ignore_trailing: bool = False,
+    ) -> dns.message.Message:
+        if max_size:
+            response = await dns.asyncquery.tcp(
+                request,
+                self.address,
+                timeout=timeout,
+                port=self.port,
+                source=source,
+                source_port=source_port,
+                backend=backend,
+                one_rr_per_rrset=one_rr_per_rrset,
+                ignore_trailing=ignore_trailing,
+            )
+        else:
+            response = await dns.asyncquery.udp(
+                request,
+                self.address,
+                timeout=timeout,
+                port=self.port,
+                source=source,
+                source_port=source_port,
+                raise_on_truncation=True,
+                backend=backend,
+                one_rr_per_rrset=one_rr_per_rrset,
+                ignore_trailing=ignore_trailing,
+                ignore_errors=True,
+                ignore_unexpected=True,
+            )
+        return response
+
+
+class DoHNameserver(Nameserver):
+    def __init__(
+        self,
+        url: str,
+        bootstrap_address: Optional[str] = None,
+        verify: Union[bool, str] = True,
+        want_get: bool = False,
+    ):
+        super().__init__()
+        self.url = url
+        self.bootstrap_address = bootstrap_address
+        self.verify = verify
+        self.want_get = want_get
+
+    def kind(self):
+        return "DoH"
+
+    def is_always_max_size(self) -> bool:
+        return True
+
+    def __str__(self):
+        return self.url
+
+    def answer_nameserver(self) -> str:
+        return self.url
+
+    def answer_port(self) -> int:
+        port = urlparse(self.url).port
+        if port is None:
+            port = 443
+        return port
+
+    def query(
+        self,
+        request: dns.message.QueryMessage,
+        timeout: float,
+        source: Optional[str],
+        source_port: int,
+        max_size: bool = False,
+        one_rr_per_rrset: bool = False,
+        ignore_trailing: bool = False,
+    ) -> dns.message.Message:
+        return dns.query.https(
+            request,
+            self.url,
+            timeout=timeout,
+            source=source,
+            source_port=source_port,
+            bootstrap_address=self.bootstrap_address,
+            one_rr_per_rrset=one_rr_per_rrset,
+            ignore_trailing=ignore_trailing,
+            verify=self.verify,
+            post=(not self.want_get),
+        )
+
+    async def async_query(
+        self,
+        request: dns.message.QueryMessage,
+        timeout: float,
+        source: Optional[str],
+        source_port: int,
+        max_size: bool,
+        backend: dns.asyncbackend.Backend,
+        one_rr_per_rrset: bool = False,
+        ignore_trailing: bool = False,
+    ) -> dns.message.Message:
+        return await dns.asyncquery.https(
+            request,
+            self.url,
+            timeout=timeout,
+            source=source,
+            source_port=source_port,
+            bootstrap_address=self.bootstrap_address,
+            one_rr_per_rrset=one_rr_per_rrset,
+            ignore_trailing=ignore_trailing,
+            verify=self.verify,
+            post=(not self.want_get),
+        )
+
+
+class DoTNameserver(AddressAndPortNameserver):
+    def __init__(
+        self,
+        address: str,
+        port: int = 853,
+        hostname: Optional[str] = None,
+        verify: Union[bool, str] = True,
+    ):
+        super().__init__(address, port)
+        self.hostname = hostname
+        self.verify = verify
+
+    def kind(self):
+        return "DoT"
+
+    def query(
+        self,
+        request: dns.message.QueryMessage,
+        timeout: float,
+        source: Optional[str],
+        source_port: int,
+        max_size: bool = False,
+        one_rr_per_rrset: bool = False,
+        ignore_trailing: bool = False,
+    ) -> dns.message.Message:
+        return dns.query.tls(
+            request,
+            self.address,
+            port=self.port,
+            timeout=timeout,
+            one_rr_per_rrset=one_rr_per_rrset,
+            ignore_trailing=ignore_trailing,
+            server_hostname=self.hostname,
+            verify=self.verify,
+        )
+
+    async def async_query(
+        self,
+        request: dns.message.QueryMessage,
+        timeout: float,
+        source: Optional[str],
+        source_port: int,
+        max_size: bool,
+        backend: dns.asyncbackend.Backend,
+        one_rr_per_rrset: bool = False,
+        ignore_trailing: bool = False,
+    ) -> dns.message.Message:
+        return await dns.asyncquery.tls(
+            request,
+            self.address,
+            port=self.port,
+            timeout=timeout,
+            one_rr_per_rrset=one_rr_per_rrset,
+            ignore_trailing=ignore_trailing,
+            server_hostname=self.hostname,
+            verify=self.verify,
+        )
+
+
+class DoQNameserver(AddressAndPortNameserver):
+    def __init__(
+        self,
+        address: str,
+        port: int = 853,
+        verify: Union[bool, str] = True,
+        server_hostname: Optional[str] = None,
+    ):
+        super().__init__(address, port)
+        self.verify = verify
+        self.server_hostname = server_hostname
+
+    def kind(self):
+        return "DoQ"
+
+    def query(
+        self,
+        request: dns.message.QueryMessage,
+        timeout: float,
+        source: Optional[str],
+        source_port: int,
+        max_size: bool = False,
+        one_rr_per_rrset: bool = False,
+        ignore_trailing: bool = False,
+    ) -> dns.message.Message:
+        return dns.query.quic(
+            request,
+            self.address,
+            port=self.port,
+            timeout=timeout,
+            one_rr_per_rrset=one_rr_per_rrset,
+            ignore_trailing=ignore_trailing,
+            verify=self.verify,
+            server_hostname=self.server_hostname,
+        )
+
+    async def async_query(
+        self,
+        request: dns.message.QueryMessage,
+        timeout: float,
+        source: Optional[str],
+        source_port: int,
+        max_size: bool,
+        backend: dns.asyncbackend.Backend,
+        one_rr_per_rrset: bool = False,
+        ignore_trailing: bool = False,
+    ) -> dns.message.Message:
+        return await dns.asyncquery.quic(
+            request,
+            self.address,
+            port=self.port,
+            timeout=timeout,
+            one_rr_per_rrset=one_rr_per_rrset,
+            ignore_trailing=ignore_trailing,
+            verify=self.verify,
+            server_hostname=self.server_hostname,
+        )

shared/package-files/56/56496724da7238138ed04b02aa5dfd17e03f3830063abcc620bc2f92b5436833/blob

@@ -0,0 +1,161 @@
+"""Machinery for documenting traitlets config options with Sphinx.
+
+This includes:
+
+- A Sphinx extension defining directives and roles for config options.
+- A function to generate an rst file given an Application instance.
+
+To make this documentation, first set this module as an extension in Sphinx's
+conf.py::
+
+    extensions = [
+        # ...
+        'traitlets.config.sphinxdoc',
+    ]
+
+Autogenerate the config documentation by running code like this before
+Sphinx builds::
+
+    from traitlets.config.sphinxdoc import write_doc
+    from myapp import MyApplication
+
+    writedoc('config/options.rst',    # File to write
+             'MyApp config options',  # Title
+             MyApplication()
+            )
+
+The generated rST syntax looks like this::
+
+    .. configtrait:: Application.log_datefmt
+
+        Description goes here.
+
+    Cross reference like this: :configtrait:`Application.log_datefmt`.
+"""
+from collections import defaultdict
+from textwrap import dedent
+
+from traitlets import Undefined
+from traitlets.utils.text import indent
+
+
+def setup(app):
+    """Registers the Sphinx extension.
+
+    You shouldn't need to call this directly; configure Sphinx to use this
+    module instead.
+    """
+    app.add_object_type("configtrait", "configtrait", objname="Config option")
+    metadata = {"parallel_read_safe": True, "parallel_write_safe": True}
+    return metadata
+
+
+def interesting_default_value(dv):
+    if (dv is None) or (dv is Undefined):
+        return False
+    if isinstance(dv, (str, list, tuple, dict, set)):
+        return bool(dv)
+    return True
+
+
+def format_aliases(aliases):
+    fmted = []
+    for a in aliases:
+        dashes = "-" if len(a) == 1 else "--"
+        fmted.append(f"``{dashes}{a}``")
+    return ", ".join(fmted)
+
+
+def class_config_rst_doc(cls, trait_aliases):
+    """Generate rST documentation for this class' config options.
+
+    Excludes traits defined on parent classes.
+    """
+    lines = []
+    classname = cls.__name__
+    for _, trait in sorted(cls.class_traits(config=True).items()):
+        ttype = trait.__class__.__name__
+
+        fullname = classname + "." + trait.name
+        lines += [".. configtrait:: " + fullname, ""]
+
+        help = trait.help.rstrip() or "No description"
+        lines.append(indent(dedent(help)) + "\n")
+
+        # Choices or type
+        if "Enum" in ttype:
+            # include Enum choices
+            lines.append(indent(":options: " + ", ".join("``%r``" % x for x in trait.values)))
+        else:
+            lines.append(indent(":trait type: " + ttype))
+
+        # Default value
+        # Ignore boring default values like None, [] or ''
+        if interesting_default_value(trait.default_value):
+            try:
+                dvr = trait.default_value_repr()
+            except Exception:
+                dvr = None  # ignore defaults we can't construct
+            if dvr is not None:
+                if len(dvr) > 64:
+                    dvr = dvr[:61] + "..."
+                # Double up backslashes, so they get to the rendered docs
+                dvr = dvr.replace("\\n", "\\\\n")
+                lines.append(indent(":default: ``%s``" % dvr))
+
+        # Command line aliases
+        if trait_aliases[fullname]:
+            fmt_aliases = format_aliases(trait_aliases[fullname])
+            lines.append(indent(":CLI option: " + fmt_aliases))
+
+        # Blank line
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def reverse_aliases(app):
+    """Produce a mapping of trait names to lists of command line aliases."""
+    res = defaultdict(list)
+    for alias, trait in app.aliases.items():
+        res[trait].append(alias)
+
+    # Flags also often act as aliases for a boolean trait.
+    # Treat flags which set one trait to True as aliases.
+    for flag, (cfg, _) in app.flags.items():
+        if len(cfg) == 1:
+            classname = list(cfg)[0]
+            cls_cfg = cfg[classname]
+            if len(cls_cfg) == 1:
+                traitname = list(cls_cfg)[0]
+                if cls_cfg[traitname] is True:
+                    res[classname + "." + traitname].append(flag)
+
+    return res
+
+
+def write_doc(path, title, app, preamble=None):
+    """Write a rst file documenting config options for a traitlets application.
+
+    Parameters
+    ----------
+    path : str
+        The file to be written
+    title : str
+        The human-readable title of the document
+    app : traitlets.config.Application
+        An instance of the application class to be documented
+    preamble : str
+        Extra text to add just after the title (optional)
+    """
+    trait_aliases = reverse_aliases(app)
+    with open(path, "w") as f:
+        f.write(title + "\n")
+        f.write(("=" * len(title)) + "\n")
+        f.write("\n")
+        if preamble is not None:
+            f.write(preamble + "\n\n")
+
+        for c in app._classes_inc_parents():
+            f.write(class_config_rst_doc(c, trait_aliases))
+            f.write("\n")

shared/package-files/56/564c14cab191be17a8429c304e53fe65b464a83d6175f5d304e3232bab785e97/blob

@@ -0,0 +1,1505 @@
+from __future__ import annotations
+
+import ast
+import builtins
+import collections
+import dataclasses
+import enum
+import functools
+import importlib
+import inspect
+import itertools
+import logging
+import math
+import os
+import re
+import sys
+import textwrap
+import types
+import weakref
+from inspect import currentframe, getframeinfo
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+from weakref import ReferenceType
+
+
+try:
+    import numpy as np
+except ModuleNotFoundError:
+    np = None  # type: ignore[assignment]
+
+import torch
+import torch.utils._device
+from torch._dynamo.source import (
+    is_from_local_source,
+    TensorProperty,
+    TensorPropertySource,
+)
+
+from torch._guards import (
+    DuplicateInputs,
+    Guard,
+    GuardBuilderBase,
+    GuardEnvExpr,
+    GuardSource,
+    Source,
+)
+
+from torch._logging import structured
+from torch.fx.experimental.symbolic_shapes import (
+    EqualityConstraint,
+    is_symbolic,
+    SYMPY_INTERP,
+)
+from torch.utils._traceback import format_frame, report_compile_source_on_error
+from torch.utils.weak import TensorWeakRef
+
+from . import config, convert_frame, exc, mutation_guard
+from .eval_frame import set_guard_error_hook
+from .source import AttrSource, DefaultsSource, LocalSource, TypeSource
+from .types import CacheEntry, ExtraState, GuardedCode, GuardFail, GuardFn  # noqa: F401
+from .utils import (
+    common_constant_types,
+    dict_keys_repr,
+    guard_failures,
+    istype,
+    key_is_id,
+    key_to_id,
+    orig_code_map,
+    tensor_always_has_static_shape,
+    tuple_iterator_getitem,
+    tuple_iterator_len,
+)
+
+log = logging.getLogger(__name__)
+guards_log = torch._logging.getArtifactLogger(__name__, "guards")
+recompiles_log = torch._logging.getArtifactLogger(__name__, "recompiles")
+recompiles_verbose_log = torch._logging.getArtifactLogger(
+    __name__, "recompiles_verbose"
+)
+verbose_guards_log = torch._logging.getArtifactLogger(__name__, "verbose_guards")
+
+TensorGuards = torch._C._dynamo.guards.TensorGuards
+check_obj_id = torch._C._dynamo.guards.check_obj_id
+check_type_id = torch._C._dynamo.guards.check_type_id
+dict_version = torch._C._dynamo.guards.dict_version
+
+
+# For user stack printing
+@functools.lru_cache(None)
+def uninteresting_files():
+    import torch._dynamo.external_utils
+
+    mods = [
+        torch._dynamo.external_utils,
+    ]
+    return {inspect.getfile(m) for m in mods}
+
+
+CLOSURE_VARS = {
+    "___check_type_id": check_type_id,
+    "___check_obj_id": check_obj_id,
+    "___odict_getitem": collections.OrderedDict.__getitem__,
+    "___key_to_id": key_to_id,
+    "___dict_version": dict_version,
+    "___dict_contains": lambda a, b: a in b,
+    "___tuple_iterator_len": tuple_iterator_len,
+    "___tuple_iterator_getitem": tuple_iterator_getitem,
+    "__math_isnan": math.isnan,
+    "__numpy_isnan": None if np is None else np.isnan,
+    "inf": float("inf"),
+    "__load_module": importlib.import_module,
+    "utils_device": torch.utils._device,
+    "device": torch.device,
+    "___from_numpy":
+    # If not numpy array, piggy back on e.g. tensor guards to check type
+    (lambda a: torch.as_tensor(a) if isinstance(a, (np.generic, np.ndarray)) else a),
+    "torch": torch,
+    "inspect": inspect,
+}
+
+if sys.version_info[:2] <= (3, 8):
+    # [Note: Python Version <= 3.8]
+    # This branch should be dropped when we drop support for Python 3.8.
+    # Reason: 'ast.unparse' function was introduced in Python 3.9.
+
+    try:
+        import astunparse  # type: ignore[import]
+
+        def _ast_unparse(node: ast.AST) -> str:
+            return astunparse.unparse(node).replace("\n", "")
+
+        HAS_UNPARSE_FUNCTIONS = True
+    except ImportError:
+        HAS_UNPARSE_FUNCTIONS = False
+        pass
+else:
+    HAS_UNPARSE_FUNCTIONS = True
+
+    def _ast_unparse(node: ast.AST) -> str:
+        return ast.unparse(node).replace("\n", "")
+
+
+def strip_function_call(name):
+    """
+    "___odict_getitem(a, 1)" => "a"
+    "a.layers[slice(2)][0]._xyz" ==> "a"
+    "getattr(a.layers[slice(2)][0]._abc, '0')" ==> "a"
+    "getattr(getattr(a.x[3], '0'), '3')" ==> "a"
+    "a.layers[slice(None, -1, None)][0]._xyz" ==> "a"
+    """
+    # recursively find valid object name in function
+    valid_name = re.compile("[A-Za-z_].*")
+    curr = ""
+    for char in name:
+        if char in " (":
+            curr = ""
+        elif char in "),[]":
+            if curr and curr != "None" and valid_name.match(curr):
+                return strip_function_call(curr)
+        else:
+            curr += char
+
+    return strip_getattr_getitem(name)
+
+
+def strip_getattr_getitem(name):
+    """
+    "a[1]" => "a"
+    "a.foo" => "a"
+    """
+    return re.split(r"[.\[]", name)[0]
+
+
+def get_verbose_code_part(code_part, guard):
+    extra = ""
+    if guard.user_stack:
+        for fs in reversed(guard.user_stack):
+            if fs.filename not in uninteresting_files():
+                extra = f"  # {format_frame(fs, line=True)}"
+                break
+    elif guard.stack:
+        extra = f"  # {format_frame(guard.stack.summary()[-1])}"
+
+    return f"{code_part:<60}{extra}"
+
+
+def convert_to_concrete_values(size_or_stride):
+    converted: List[Optional[int]] = []
+    for dim in size_or_stride:
+        if not is_symbolic(dim):
+            converted.append(dim)
+        else:
+            assert isinstance(dim, torch.SymInt)
+            converted.append(dim.node.maybe_as_int())
+    return converted
+
+
+def get_tensor_guard_code_part(value, name, sizes, strides):
+    pytype = type(value)
+    dispatch_key = (
+        torch._C._dispatch_keys(value) | torch._C._dispatch_tls_local_include_set()
+    ) - torch._C._dispatch_tls_local_exclude_set()
+    dtype = value.dtype
+    device_index = value.device.index
+    requires_grad = value.requires_grad
+    guard_str = (
+        f"check_tensor({name}, {pytype.__qualname__}, {dispatch_key}, {dtype}, "
+        f"device={device_index}, requires_grad={requires_grad}, size={sizes}, stride={strides})"
+    )
+    return guard_str
+
+
+# The ready to eval generated code (possibly multiple parts) for a guard, plus
+# the original guard object that created it for provenance
+@dataclasses.dataclass
+class GuardCodeList:
+    code_list: List[str]
+    guard: Guard
+
+
+class GuardBuilder(GuardBuilderBase):
+    def __init__(
+        self,
+        id_ref: Callable[[Any], str],
+        source_ref: Callable[[Source], str],
+        lookup_weakrefs: Callable[[object], ReferenceType[object]],
+        local_scope: Dict[str, object],
+        global_scope: Dict[str, object],
+        check_fn_manager: CheckFunctionManager,
+    ):
+        self.id_ref = id_ref
+        self.source_ref = source_ref
+        self.lookup_weakrefs = lookup_weakrefs
+        self.scope: Dict[str, Dict[str, object]] = {"L": local_scope, "G": global_scope}
+        self.scope["__builtins__"] = builtins.__dict__.copy()
+        for (
+            name,
+            package_module,
+        ) in torch.package.package_importer._package_imported_modules.items():
+            name = name.replace(">", "_").replace("<", "_").replace(".", "_dot_")
+            # Write the package module into the scope so that we can import it
+            self.scope["__builtins__"][name] = package_module
+            # Write the demangled name to the scope so that we can use it
+            self.scope[name] = package_module
+
+        self.argnames: List[str] = []
+        # Code is python expression strings generated for each guard
+        self.code: List[GuardCodeList] = []
+        # shape_env_code is only used by builder and is used for
+        # shape env code.  This exists only because we need to make sure
+        # shape env guards get run after tensor match guards (since the
+        # tensor match guards make sure we actually have tensors)
+        self.shape_env_code: List[GuardCodeList] = []
+
+        # [Note - On Eager Tensor Guards]
+        # Most of the time, we generate Python code in a guard to directly
+        # check various properties.  However, tensors are a bit special;
+        # it is too slow to check their properties one-by-one in Python.
+        # Instead, there is a C++ function TensorGuards.check which takes
+        # all of the tensor arguments and checks them all against compile-time
+        # examples entirely in C++.  Thus, every time we process a
+        # TENSOR_MATCH guard, we just add another entry to
+        # tensor_check_names/tensor_check_examples, saying "for this local,
+        # check it against this example", and it all ends up getting
+        # swept up into a single call to ___check_tensors.  Invariant:
+        # len(tensor_check_names) == len(tensor_check_examples).
+        # TODO: something here
+        self.tensor_check_names: List[str] = []
+        self.tensor_check_examples: List[torch.Tensor] = []
+        self.tensor_check_guards: List[Guard] = []
+
+        self.check_fn_manager: CheckFunctionManager = check_fn_manager
+        # Keep track of weak references of objects with ID_MATCH guard. This
+        # info is stored alongside optimized_code and check_fn and is used to
+        # limit the number of cache entries with same ID_MATCH'd object.
+        self.id_matched_objs: Dict[str, ReferenceType[object]] = {}
+
+    # Warning: use this with care!  This lets you access what the current
+    # value of the value you are guarding on is.  You probably don't want
+    # to actually durably save this value though (because it's specific
+    # to this frame!)  Instead, you should be reading out some property
+    # (like its type) which is what you permanently install into the
+    # guard code.
+    def get(self, name: str) -> Any:
+        return eval(name, self.scope, CLOSURE_VARS)
+
+    # Registers the usage of the source name referenced by the
+    # string (or stored in the Guard) as being guarded upon.  It's important
+    # to call this before generating some code that makes use of 'guard',
+    # because without this call, we won't actually bind the variable
+    # you reference in the actual guard closure (oops!)
+    def arg_ref(self, guard: Union[str, Guard]) -> str:
+        name: str
+        if isinstance(guard, str):
+            name = guard
+        else:
+            name = guard.name
+        base = strip_getattr_getitem(strip_function_call(name))
+        if base not in self.argnames:
+            if re.match(r"[a-zA-Z0-9_]+", base):
+                if re.match(r"^\d+$", base):
+                    log.warning("invalid var name: %s", guard)
+                self.argnames.append(base)
+
+        return name
+
+    def _guard_on_attribute(self, guard: Guard, attr_name: str, guard_fn):
+        attr_source = AttrSource(guard.originating_source, attr_name)
+        # Copy the stack info
+        new_guard = Guard(
+            attr_source, guard_fn, stack=guard.stack, user_stack=guard.user_stack
+        )
+        new_guard.create(self)
+
+    def TYPE_MATCH(self, guard: Guard) -> None:
+        # ___check_type_id is same as `id(type(x)) == y`
+        t = type(self.get(guard.name))
+        obj_id = self.id_ref(t)
+        code = f"___check_type_id({self.arg_ref(guard)}, {obj_id})"
+        self._produce_guard_code(guard, [code])
+
+    def DICT_VERSION(self, guard: Guard):
+        # ___check_dict_version is same as `dict_version(x) == y`
+        ref = self.arg_ref(guard)
+        version = dict_version(self.get(guard.name))
+        code = f"___dict_version({ref}) == {version}"
+        self._produce_guard_code(guard, [code])
+
+    def DICT_CONTAINS(self, guard: Guard, key: str, invert: bool):
+        dict_ref = self.arg_ref(guard)
+
+        maybe_not = "not " if invert else ""
+        code = f"{maybe_not}___dict_contains({key!r}, {dict_ref})"
+        return self._produce_guard_code(guard, [code])
+
+    def BOOL_FALSE(self, guard: Guard):
+        # Guard on the runtime value being 'False',
+        # can be faster than seemingly equivalent checks like DICT_KEYS for empty dict
+        #
+        # WARNING: this guard is not safe to use generally.  It only works if the runtime
+        # value is of a type that supports bool(), and some types e.g. Tensor do not.
+        # Only use this guard in cases you can guarantee the runtime type will be friendly.
+        # (e.g. Specialized NNModule with mutation protection via setattr)
+        #
+        # Why not simply check the runtime type inside this guard?  It's slow enough to defeat
+        # the purpose of using this guard, which itself is supposed to be a faster alternative
+        # to DICT_KEYS.
+        ref = self.arg_ref(guard)
+        code = f"not {ref}"
+        self._produce_guard_code(guard, [code])
+
+    def ID_MATCH(self, guard: Guard):
+        # ___check_obj_id is same as `id(x) == y`
+        if isinstance(guard.originating_source, TypeSource):
+            # optional optimization to produce cleaner/faster guard code
+            return self.TYPE_MATCH(
+                Guard(guard.originating_source.base, GuardBuilder.TYPE_MATCH)  # type: ignore[arg-type]
+            )
+
+        ref = self.arg_ref(guard)
+        val = self.get(guard.name)
+        code = f"___check_obj_id({ref}, {self.id_ref(val)})"
+        self._produce_guard_code(guard, [code])
+
+        # Keep track of ID_MATCH'd objects. This will be used to modify the
+        # cache size logic
+        if isinstance(guard.originating_source, LocalSource):
+            # TODO(janimesh) - This is currently restricted to nn.Module objects
+            # because many other ID_MATCH'd objects fail - like DeviceMesh.
+            # Increase the scope of ID_MATCH'd objects.
+            if isinstance(val, torch.nn.Module):
+                local_name = guard.originating_source.local_name
+                weak_id = self.lookup_weakrefs(val)
+                if weak_id is not None:
+                    self.id_matched_objs[local_name] = weak_id
+
+    def NAME_MATCH(self, guard: Guard):
+        obj = self.get(guard.name)
+        self._guard_on_attribute(guard, "__name__", GuardBuilder.EQUALS_MATCH)
+
+    def DATA_PTR_MATCH(self, guard: Guard):
+        obj = self.get(guard.name)
+        code = f"{self.arg_ref(guard)}.data_ptr() == {obj.data_ptr()}"
+        self._produce_guard_code(guard, [code])
+
+    def HASATTR(self, guard: Guard):
+        assert isinstance(
+            guard.originating_source, AttrSource
+        ), f"invalid source {guard.name}"
+        base_source = guard.originating_source.base
+        base = base_source.name()
+        attr = guard.originating_source.member
+
+        ref = self.arg_ref(base)
+        val = hasattr(self.get(base), attr)
+        code = None
+        if val:
+            code = f"hasattr({ref}, {attr!r})"
+        else:
+            code = f"not hasattr({ref}, {attr!r})"
+
+        self._produce_guard_code(guard, [code], provided_guarded_object=self.get(base))
+
+    def FUNCTORCH_STACK_MATCH(self, guard: Guard):
+        # Invalidate functorch code if current level is different than
+        # the one when FX graph was generated
+        # if torch._C._functorch.peek_interpreter_stack() is not None:
+        cis = torch._functorch.pyfunctorch.retrieve_all_functorch_interpreters()
+        states = [ci.get_state() for ci in cis]
+        code = [f"torch._functorch.pyfunctorch.compare_functorch_state({states})"]
+        self._produce_guard_code(guard, code)
+
+    def EQUALS_MATCH(self, guard: Guard):
+        ref = self.arg_ref(guard)
+        val = self.get(guard.name)
+        t = type(val)
+        if np:
+            np_types: Tuple[Type[Any], ...] = (
+                np.int8,
+                np.int16,
+                np.int32,
+                np.int64,
+                np.uint8,
+                np.uint16,
+                np.uint32,
+                np.uint64,
+                np.float16,
+                np.float32,
+                np.float64,
+            )
+        else:
+            np_types = ()
+        ok_types = tuple(
+            common_constant_types
+            | {
+                type,
+                list,
+                tuple,
+                set,
+                frozenset,
+                slice,
+                range,
+                torch.Size,
+                *np_types,
+            }
+        )
+        if istype(val, dict):
+            assert all(
+                istype(x, ok_types) for x in itertools.chain(val.keys(), val.values())
+            )
+        else:
+            assert istype(
+                val,
+                ok_types,
+            ), f"Unexpected type {type(val)}, not in {ok_types}"
+
+        # Special case for nan because float("nan") == float("nan") evaluates to False
+        if istype(val, float) and math.isnan(val):
+            self.TYPE_MATCH(guard)
+            code = list()
+            code.append(f"__math_isnan({ref})")
+            self._produce_guard_code(guard, code)
+            return
+        # Python math library doesn't support complex nan, so we need to use numpy
+        elif istype(val, complex) and np.isnan(val):
+            self.TYPE_MATCH(guard)
+            code = list()
+            code.append(f"__numpy_isnan({ref})")
+            self._produce_guard_code(guard, code)
+            return
+
+        code = list()
+
+        # If matching equality against list/tuple, we must also check that
+        # the internal types match.  (TODO: what about nested lists?)
+        if istype(val, (list, tuple)):
+            # NB: SEQUENCE_LENGTH takes care of the outer __check_type_id test
+            self.SEQUENCE_LENGTH(guard)
+
+            for idx, elem in enumerate(val):
+                code.append(
+                    f"___check_type_id({ref}[{idx}], {self.id_ref(type(elem))})"
+                )
+        else:
+            # Add type check to prevent equality check between tensor and non-tensor.
+            self.TYPE_MATCH(guard)
+
+        if istype(val, torch.Size):
+            val = tuple(val)
+
+        # Code object can not be compared against their string representation
+        # I.e `eval(f"{compile('2+2','','exec')!r}")` raises SyntaxError
+        assert not istype(val, types.CodeType)
+
+        # TODO: It feels like it would be better to just implement our own
+        # equality test in C that handles all of the necessary type checking
+        # and NaN tests
+        code.append(f"{ref} == {val!r}")
+        self._produce_guard_code(guard, code)
+
+    def CONSTANT_MATCH(self, guard: Guard):
+        val = self.get(guard.name)
+        if istype(val, (bool, type(None), types.CodeType)):
+            self.ID_MATCH(guard)
+        else:
+            self.EQUALS_MATCH(guard)
+
+    def NN_MODULE(self, guard: Guard):
+        self.ID_MATCH(guard)
+        ref = self.arg_ref(guard)
+        val = self.get(guard.name)
+
+        def setup_guard():
+            assert istype(val.training, bool)
+            self._guard_on_attribute(guard, "training", GuardBuilder.CONSTANT_MATCH)
+
+        if hasattr(val, "training"):
+            # There are cases where a monkeypatched object has a guard made between __new__ and __init__
+            setup_guard()
+        else:
+            exc.unimplemented(f"Guard setup for uninitialized class {type(val)}")
+
+    def FUNCTION_MATCH(self, guard: Guard):
+        """things like torch.add and user defined functions"""
+        if guard.is_local():
+            return self.ID_MATCH(guard)
+
+    def CLOSURE_MATCH(self, guard: Guard):
+        """matches a closure by __code__ id."""
+        if guard.is_local():
+            val = self.get(guard.name)
+            # Strictly only want user-defined functions
+            if type(val) == types.FunctionType and hasattr(val, "__code__"):
+                self._guard_on_attribute(guard, "__code__", GuardBuilder.HASATTR)
+                self._guard_on_attribute(guard, "__code__", GuardBuilder.FUNCTION_MATCH)
+            else:
+                self.FUNCTION_MATCH(guard)
+
+    def BUILTIN_MATCH(self, guard: Guard):
+        return self.FUNCTION_MATCH(guard)
+
+    def PYMODULE_MATCH(self, guard: Guard):
+        return self.FUNCTION_MATCH(guard)
+
+    def SEQUENCE_LENGTH(self, guard):
+        # This guard is used to check lenght of PySequence objects like list,
+        # tuple, collections.deque etc
+        ref = self.arg_ref(guard)
+        value = self.get(guard.name)
+        t = type(value)
+
+        self.TYPE_MATCH(guard)
+        code = list()
+        if len(value) == 0:
+            code.append(f"not {ref}")
+        else:
+            code.append(f"len({ref}) == {len(value)}")
+
+        self._produce_guard_code(guard, code)
+
+    def DICT_LENGTH(self, guard):
+        self.SEQUENCE_LENGTH(guard)
+
+    def TUPLE_ITERATOR_LEN(self, guard):
+        ref = self.arg_ref(guard)
+        value = self.get(guard.name)
+        t = type(value)
+
+        self.TYPE_MATCH(guard)
+        code = list()
+        code.append(f"___tuple_iterator_len({ref}) == {tuple_iterator_len(value)}")
+
+        self._produce_guard_code(guard, code)
+
+    # TODO(voz): Deduplicate w/ AOTAutograd dupe input guards
+    def DUPLICATE_INPUT(self, guard, source_b):
+        ref_a = self.arg_ref(guard)
+        ref_b = self.arg_ref(source_b.name())
+
+        code = [f"{ref_b} is {ref_a}"]
+        self._produce_guard_code(guard, code)
+
+    def DICT_KEYS(self, guard):
+        # Guard on the keys and their order
+        ref = self.arg_ref(guard)
+        value = self.get(guard.name)
+        t = type(value)
+
+        self.TYPE_MATCH(guard)
+        code = list()
+        any_key_is_id = any(key_is_id(k) for k in value.keys())
+        const_keys_repr = dict_keys_repr(
+            key_to_id(value),
+            local=is_from_local_source(guard.originating_source),
+        )
+        if any_key_is_id:
+            code.append(f"___key_to_id({ref}) == {const_keys_repr}")
+        else:
+            code.append(f"list({ref}.keys()) == {const_keys_repr}")
+
+        self._produce_guard_code(guard, code)
+
+    def WEAKREF_ALIVE(self, guard):
+        self._produce_guard_code(guard, [f"{self.arg_ref(guard)} is not None"])
+
+    def NN_MODULE_PARAM_NAMES(self, guard):
+        ref = self.arg_ref(guard)
+        value = self.get(guard.name)
+        t = type(value)
+        keys = {k for k, v in value.named_parameters()}
+
+        self.TYPE_MATCH(guard)
+        code = list()
+        code.append(f"{{k for k, v in {ref}.named_parameters()}} == {keys!r}")
+
+        self._produce_guard_code(guard, code)
+
+    def DICT_CONST_KEYS(self, guard):
+        """Constant keys match"""
+        ref = self.arg_ref(guard)
+        value = self.get(guard.name)
+        t = type(value)
+
+        self.TYPE_MATCH(guard)
+        code = list()
+        code.append(f"list({ref}.keys()) == {list(value.keys())!r}")
+
+        self._produce_guard_code(guard, code)
+
+    def OBJECT_MUTATION(self, guard: Guard):
+        mutation_guard.watch(self.get(guard.name), self.check_fn_manager)
+
+    def GRAD_MODE(self, guard: Guard):
+        pass  # we always guard on this via GlobalStateGuard()
+
+    def DETERMINISTIC_ALGORITHMS(self, guard: Guard):
+        pass  # we always guard on this via GlobalStateGuard()
+
+    def TORCH_FUNCTION_STATE(self, guard: Guard):
+        pass  # we always guard on this via GlobalStateGuard()
+
+    def DEFAULT_DEVICE(self, guard: Guard):
+        """Guard on CURRENT_DEVICE per torch.utils._device"""
+        assert guard.source is GuardSource.GLOBAL
+        import torch.utils._device as m
+
+        self._produce_guard_code(
+            guard, [f"utils_device.CURRENT_DEVICE == {m.CURRENT_DEVICE!r}"]
+        )
+
+    def BACKEND_MATCH(self, guard: Guard):
+        """Guard on backend matching based on id of current_backend"""
+        assert guard.source is GuardSource.GLOBAL
+        backend_id = (
+            f"{id(torch._dynamo.eval_frame.guarded_backend_cache.current_backend)}"
+        )
+        code = [f"___check_current_backend({backend_id})"]
+        self._produce_guard_code(guard, code)
+
+    def SHAPE_ENV(self, guard: Guard):
+        # Let's handle ShapeEnv guards.  To do this, we will resolve
+        # shape variables to sources from tracked_fakes.  This must happen after
+        # tensor checks.
+        assert guard.name == ""
+        output_graph = self.check_fn_manager.output_graph
+        # NB: self.output_graph can be None in the debug_nops tests
+        fs = output_graph.tracked_fakes
+        input_contexts = [a.symbolic_context for a in fs]
+
+        def get_sources(t_id, dim):
+            # Looks up base sources mapped to a tensor id and uses them to create
+            # sources for the corresponding tensor dimension.
+            return [
+                TensorPropertySource(source, TensorProperty.SIZE, dim)
+                for source in output_graph.tracked_fakes_id_to_source[t_id]
+            ]
+
+        if output_graph.export_constraints:
+            from sympy import Symbol
+
+            source_pairs: List[Tuple[Source, Source]] = []
+            derived_equalities: List[  # type: ignore[type-arg]
+                Tuple[Source, Union[Source, Symbol], Callable]
+            ] = []
+            phantom_symbols: Dict[str, Symbol] = {}
+            for constraint in output_graph.export_constraints:
+                if constraint.t_id in output_graph.tracked_fakes_id_to_source:
+                    torch.export.dynamic_shapes._process_equalities(
+                        constraint,
+                        get_sources,
+                        output_graph.shape_env,
+                        source_pairs,
+                        derived_equalities,
+                        phantom_symbols,
+                    )
+                else:
+                    log.warning("Untracked tensor used in export constraints")
+            equalities_inputs = EqualityConstraint(
+                source_pairs=source_pairs,
+                derived_equalities=derived_equalities,
+                phantom_symbols=list(phantom_symbols.values()),
+                warn_only=False,
+            )
+        else:
+            equalities_inputs = None
+        guards = output_graph.shape_env.produce_guards(
+            [a.fake for a in fs],
+            [a.source for a in fs],
+            input_contexts=input_contexts,
+            equalities_inputs=equalities_inputs,
+            source_ref=self.source_ref,
+            # Export keeps static.
+            ignore_static=(not self.check_fn_manager.output_graph.export),
+        )
+        # When exporting, we may work with the shape constraints some more in
+        # postprocessing, so don't freeze yet
+        if not self.check_fn_manager.output_graph.export:
+            output_graph.shape_env.freeze()
+        for shape_guard in guards:
+            self._produce_guard_code(guard, [shape_guard], shape_env=True)
+
+    def TENSOR_MATCH(self, guard: Guard, value=None):
+        if guard.is_nn_module() or guard.originating_source.is_dict_key():
+            self.ID_MATCH(guard)
+        else:
+            if isinstance(value, TensorWeakRef):
+                value = value()
+
+            value = value if value is not None else self.get(guard.name)
+            assert isinstance(value, torch.Tensor)
+
+            tensor_name = self.arg_ref(guard)
+            # [Note - On Export Tensor Guards]
+            #
+            # In eager mode, tensor guards are evaluated through C++, in guards.cpp
+            # see [Note - On Eager Tensor Guards] for more info.
+            #
+            # In export mode, we instead maintain parallel logic between C++ and python
+            # here, with an exception of checking the dispatch key - with the idea that a dispatch key
+            # is an entirely runtime notion that would make no sense to keep in an exported graph.
+            #
+            # Now, this idea is okay, but to paraphrase @ezyang, this mental model is sufficient for now, although
+            # not entirely true.
+            # For example, suppose one of the input tensors had the negative dispatch key.
+            # You should end up with a graph that is specialized for tensors that have a negative dispatch key.
+            # If you allow a Tensor that does NOT have this bit set, you will accidentally run it "as if" it were negated.
+            # Now, negative key only shows up for complex numbers, and most likely, the exported to target doesn't
+            # support this feature at all, but the point stands that :some: tensor state only shows up on dispatch key.
+            # TODO(voz): Either populate a dispatch_key check into the guards, or error on users passing in an unsupported
+            # subset of keys during export.
+            #
+            # The list of tensor fields and calls we care about can be found in `terms` below.
+            # TODO(voz): We are missing storage offset in all our tensor guards?
+            code: List[str] = list()
+            if self.check_fn_manager.output_graph.export:
+                self.TYPE_MATCH(guard)
+                terms = [
+                    "dtype",
+                    "device",
+                    "requires_grad",
+                    "ndimension()",
+                ]
+
+                for term in terms:
+                    real_value = self.get(tensor_name + "." + term)
+                    if istype(real_value, (torch.device, torch.dtype)):
+                        # copy pasted from EQUALS_MATCH
+                        code.append(f"str({tensor_name}.{term}) == {str(real_value)!r}")
+                    else:
+                        code.append(f"{tensor_name}.{term} == {real_value}")
+            else:
+                self.tensor_check_names.append(tensor_name)
+                self.tensor_check_examples.append(value)
+                self.tensor_check_guards.append(guard)
+
+            # A frame is valid for reuse with dynamic dimensions if the new
+            # (user-requested) dynamic dimensions are a subset of the old
+            # (already compiled) dynamic dimensions.
+            #
+            # It's a little non-obvious why you'd want this: in particular,
+            # if an already compiled frame matches all of the guards, why
+            # not just use it, why force a recompile?
+            #
+            # We force it for two reasons:
+            #
+            #   - The user *required* us to compile with a new dynamic dimension,
+            #     we should not ignore that and serve up the old, specialized
+            #     frame.  Listen to the user!
+            #
+            #   - In fact, we are obligated to *raise an error* if we fail to
+            #     make the requested dimension dynamic.  If we don't
+            #     recompile, we can't tell if that dimension can actually be
+            #     made dynamic.
+            #
+            # If the new dynamic dims are a subset of the old, we already know
+            # we can make them dynamic (since we made them dynamic in old).
+            # This is slightly unsound, because maybe your input size is
+            # [s0, s0, s1] and so you can do it dynamic if you say dynamic
+            # dims {0, 1, 2} but you can't if you only do {0, 2} (because now
+            # the second s0 is specialized).  But we're not entirely sure if
+            # this is a good idea anyway lol... (if you want to try removing
+            # this logic, be my guest!  -- ezyang 2024)
+            #
+            assert guard.source is not None
+            static, reason = tensor_always_has_static_shape(
+                value, is_tensor=True, guard_source=guard.source
+            )
+            if not static:
+                if hasattr(value, "_dynamo_dynamic_indices"):
+                    code.append(
+                        f"(({tensor_name}._dynamo_dynamic_indices.issubset({value._dynamo_dynamic_indices})) if hasattr({tensor_name}, '_dynamo_dynamic_indices') else True)"  # noqa: B950
+                    )
+                # In the case of us not having any dynamic dimension indices, we compiled the frame with no chance of
+                # raising for this specific tensor - and any inputs with more dynamic user directives specified must be recompiled.
+                else:
+                    code.append(
+                        f"hasattr({tensor_name}, '_dynamo_dynamic_indices') == False"
+                    )
+            if len(code) > 0:
+                self._produce_guard_code(guard, code)
+
+    # A util that appends guarded code, or, in the case of export, adds data onto guards
+    def _produce_guard_code(
+        self, guard, code_list, provided_guarded_object=None, shape_env=False
+    ):
+        # WARNING: It is important that cur_frame/caller do NOT stay in
+        # the current frame, because they will keep things live longer
+        # than they should.  See TestMisc.test_release_module_memory
+        cur_frame = currentframe()
+        assert cur_frame is not None
+        caller = cur_frame.f_back
+        del cur_frame
+        assert caller is not None
+        func_name = getframeinfo(caller)[2]
+        del caller
+        # We use func_name for export, so might as well get a nice defensive check out of it
+        assert func_name in dir(
+            self.__class__
+        ), f"_produce_guard_code must be called from inside GuardedCode. Called from {func_name}"
+
+        if shape_env:
+            self.shape_env_code.append(GuardCodeList(code_list, guard))
+        else:
+            self.code.append(GuardCodeList(code_list, guard))
+
+        # Not all guards have names, some can be installed globally (see asserts on HAS_GRAD)
+        if provided_guarded_object is None:
+            name_valid = guard.name is not None and guard.name != ""
+
+            guarded_object = self.get(guard.name) if name_valid else None
+        else:
+            guarded_object = provided_guarded_object
+
+        guarded_object_type = (
+            weakref.ref(type(guarded_object)) if guarded_object is not None else None
+        )
+        obj_ref = None
+        # Not necessary to have weakref for Enum type, but there is a bug that
+        # makes hasattr(guarded_object.__class__, "__weakref__") return True.
+        if hasattr(guarded_object.__class__, "__weakref__") and not isinstance(
+            guarded_object, enum.Enum
+        ):
+            obj_ref = weakref.ref(guarded_object)
+
+        guard.set_export_info(
+            func_name,
+            guarded_object_type,
+            code_list,
+            obj_ref,
+        )
+
+
+# Common Sub-Expression Elimination for Python expressions.
+#
+# There are 2 steps to this pass:
+#     1. Count the frequency of each sub-expression (i.e. inner
+#        node in the AST tree)
+#
+#     2. Replace those that occur more than once by a fresh variable 'v'.
+#        'v' will be defined in the 'preface' list (output argument to
+#        'NodeTransformer')
+#
+# NB: the use of 'ast.unparse' while visiting the nodes makes this pass
+# quadratic on the depth of the tree.
+#
+# NB: this pass creates a new variable for each AST node that is repeated
+# more than 'USE_THRESHOLD'. e.g. if 'a.b.c.d' is used 10 times, 'a.b.c'
+# and 'a.b' are also used 10 times. So, there will be a new variable for
+# each of them.
+class PyExprCSEPass:
+    # Maximum number of times a given expression can be used without being
+    # replaced by a fresh variable.
+    USE_THRESHOLD = 1
+
+    # Ad-Hoc: AST nodes this pass focuses on.
+    ALLOWED_NODE_TYPES = (ast.Attribute, ast.Call, ast.Subscript)
+
+    @dataclasses.dataclass
+    class Config:
+        expr_count: Dict[str, int]
+        expr_to_name: Dict[str, str]
+
+    class ExprCounter(ast.NodeVisitor):
+        def __init__(self, config: PyExprCSEPass.Config) -> None:
+            self._config = config
+
+        def visit(self, node: ast.AST) -> Any:
+            if isinstance(node, PyExprCSEPass.ALLOWED_NODE_TYPES):
+                self._config.expr_count[_ast_unparse(node)] += 1
+            super().visit(node)
+
+    class Replacer(ast.NodeTransformer):
+        def __init__(
+            self,
+            config: PyExprCSEPass.Config,
+            gen_name: Callable[[], str],
+        ) -> None:
+            super().__init__()
+            self._config = config
+            self._gen_name = gen_name
+            self.preface: List[str] = []
+
+        def visit(self, node: ast.AST) -> Any:
+            if isinstance(node, PyExprCSEPass.ALLOWED_NODE_TYPES):
+                expr = _ast_unparse(node)
+
+                # Replacement only occurs if a given expression is used more
+                # than once.
+                if self._config.expr_count[expr] > PyExprCSEPass.USE_THRESHOLD:
+                    if expr not in self._config.expr_to_name:
+                        # Parent 'visit' is called so that we CSE the inner expressions first.
+                        #
+                        # The resulting expression is used as right-hand-side of the variable
+                        # assignment. i.e. we are CSE-ing the children before the parents.
+                        #
+                        # Indexing still uses the old 'node', since that's what was counted
+                        # by the 'NodeVisitor'.
+                        node_ = super().visit(node)
+                        expr_ = _ast_unparse(node_)
+                        var_name = self._gen_name()
+                        self.preface.append(f"{var_name} = {expr_}")
+                        self._config.expr_to_name[expr] = var_name
+                    else:
+                        var_name = self._config.expr_to_name[expr]
+                    return ast.Name(var_name, ast.Load())
+
+            return super().visit(node)
+
+    def __init__(self) -> None:
+        self._counter = 0
+        self._config = self.Config(
+            expr_count=collections.defaultdict(lambda: 0), expr_to_name={}
+        )
+
+    def _new_var(self, prefix: str = "_var") -> str:
+        name = f"{prefix}{self._counter}"
+        self._counter += 1
+        return name
+
+    def count(self, exprs: List[str]) -> None:
+        counter = self.ExprCounter(self._config)
+        for e in exprs:
+            try:
+                counter.visit(ast.parse(e))
+            except SyntaxError as ex:
+                log.exception("Failed to visit expr at line %s.\n%s", ex.lineno, e)
+                raise
+
+    def replace(self, expr: str) -> Tuple[List[str], str]:
+        replacer = self.Replacer(self._config, self._new_var)
+        new_node = replacer.visit(ast.parse(expr))
+        return replacer.preface, _ast_unparse(new_node)
+
+
+def must_add_nn_module_guards(guard):
+    # For config.guard_nn_modules=False, we can skip all the guards that
+    # originate from inside of nn module except for a few categories.
+    return (
+        # Guard for defaults
+        isinstance(guard.originating_source, DefaultsSource)
+        # Guard using dict tags if the config flag is set
+        or (
+            config.guard_nn_modules_using_dict_tags
+            and guard.create_fn is GuardBuilder.NN_MODULE
+        )
+    )
+
+
+class DeletedGuardFn:
+    pass
+
+
+# NB: Naively, you'd expect this to only be a function that produces
+# the callable that constitutes the guard.  However, there is some
+# delicate handling for invalidating this check function when the
+# locals/globals get invalidated, so there's some extra state
+# we have to hold in this manager class.
+class CheckFunctionManager:
+    def __init__(
+        self,
+        output_graph=None,
+        guard_fail_fn: Optional[Callable[[GuardFail], None]] = None,
+    ):
+        guards = output_graph.guards if output_graph else None
+        self._weakrefs: Dict[int, ReferenceType[object]] = {}
+        self.output_graph = output_graph
+        w_builder = None
+
+        def source_ref(source):
+            guard_source = source.guard_source()
+            if guard_source is GuardSource.CONSTANT:
+                # No need to track constants
+                return source.name()
+            assert w_builder
+            r_builder = w_builder()
+            assert r_builder is not None
+            return r_builder.arg_ref(source.name())
+
+        builder = GuardBuilder(
+            self.id_ref,
+            source_ref,
+            self.lookup_weakrefs,
+            output_graph.local_scope,
+            output_graph.global_scope,
+            self,
+        )
+
+        # Break retain cycle. See test_release_scope_memory
+        def cleanup_builder(weak_b):
+            b = weak_b()
+            if b:
+                b.scope = None
+
+        # Break retain cycle. See test_release_input_memory
+        w_builder = weakref.ref(builder, cleanup_builder)
+
+        for guard in sorted(guards or [], key=Guard.sort_key):
+            if (
+                not config.guard_nn_modules
+                and guard.is_nn_module()
+                # Default func args must be guarded on.
+                # TODO: we could make use of 'DefaultsSource' and offer a .guard.is_defaults() API
+                and "__defaults__" not in guard.name
+                and "__kwdefaults__" not in guard.name
+                and (config.skip_nnmodule_hook_guards or "hooks" not in guard.name)
+            ):
+                continue
+
+            guard.create(builder)
+        self.check_fn = self.compile_check_fn(builder, guards, guard_fail_fn)
+        # Keep track of weak references of objects with ID_MATCH guard. This
+        # info is stored alongside optimized_code and check_fn and is used to
+        # limit the number of cache entries with same ID_MATCH'd object.
+        # TODO(janimesh) - Currently this information is stored as an attr on
+        # the check_fn itself to avoid changing CacehEntry datastructure in
+        # eval_frame.c. In future, we should probably replace check_fn with a
+        # queryable data structure such that this information is already present
+        # in some form.
+        self.check_fn.id_matched_objs = builder.id_matched_objs
+
+        # NB - We have to very careful of cleaning up here. Because of the
+        # invalidate function, we can create a weakref finalizer that keeps
+        # `self` alive for very long. Sometimes by mistake, we can run
+        # invalidate for a type/object (check id_ref method) that Python can
+        # leak by design, preventing us from calling the finalizer. In that
+        # case, the `self` will be alive even though the cache entry will be
+        # deleted (check invalidate method), which can cause a memory leak,
+        # e.g., not setting output_graph = None can keep hold of nn_modules.
+        self._weakrefs.clear()
+        self.output_graph = None
+
+    def compile_check_fn(self, builder, guards_out, guard_fail_fn):
+        # see parallel handling of ".0" / "___implicit0" in _eval_frame.c
+        largs = builder.argnames
+        largs += ["**___kwargs_ignored"]
+
+        guards_log.debug("GUARDS:")
+
+        # Don't report this guard, it's always the same, useless!
+        code_parts = ["___check_global_state()"]
+        verbose_code_parts = code_parts[:]
+        structured_guard_fns = []
+
+        def add_code_part(code_part, guard, log_only=False):
+            verbose_code_part = get_verbose_code_part(code_part, guard)
+            guards_log.debug("%s", verbose_code_part)
+
+            structured_guard_fns.append(
+                lambda: {
+                    "code": code_part,
+                    "stack": structured.from_traceback(guard.stack.summary())
+                    if guard.stack
+                    else None,
+                    "user_stack": structured.from_traceback(guard.user_stack)
+                    if guard.user_stack
+                    else None,
+                }
+            )
+
+            if verbose_guards_log.isEnabledFor(logging.DEBUG):
+                maybe_stack = ""
+                maybe_user_stack = ""
+                if guard is not None:
+                    if guard.stack:
+                        maybe_stack = f"\nStack:\n{''.join(guard.stack.format())}"
+                    if guard.user_stack:
+                        maybe_user_stack = (
+                            f"\nUser stack:\n{''.join(guard.user_stack.format())}"
+                        )
+                verbose_guards_log.debug(
+                    "Guard: %s%s%s",
+                    code_part,
+                    maybe_stack,
+                    maybe_user_stack,
+                )
+
+            if not log_only:
+                code_parts.append(code_part)
+                verbose_code_parts.append(verbose_code_part)
+
+        seen = set()
+        for gcl in builder.code:
+            for code in gcl.code_list:
+                if code not in seen:
+                    add_code_part(code, gcl.guard)
+                    seen.add(code)
+
+        tensor_check_names = builder.tensor_check_names
+        check_tensors_fn = None
+        check_tensors_verbose_fn = None
+        if tensor_check_names:
+            assert (
+                not self.output_graph.export
+            ), "Illegal to set tensor_check_names in export."
+            tensor_check_examples = builder.tensor_check_examples
+
+            dynamic_dims_sizes = [
+                convert_to_concrete_values(
+                    self.output_graph.tensor_weakref_to_sizes_strides[t]["size"]
+                )
+                for t in tensor_check_examples
+            ]
+
+            dynamic_dims_strides = [
+                convert_to_concrete_values(
+                    self.output_graph.tensor_weakref_to_sizes_strides[t]["stride"]
+                )
+                for t in tensor_check_examples
+            ]
+
+            tensor_guards = TensorGuards(
+                *tensor_check_examples,
+                dynamic_dims_sizes=dynamic_dims_sizes,
+                dynamic_dims_strides=dynamic_dims_strides,
+            )
+            check_tensors_fn = tensor_guards.check
+            check_tensors_verbose_fn = tensor_guards.check_verbose
+            tensor_check_args = ", ".join(
+                tensor_check_names + ["tensor_check_names=tensor_check_names"]
+            )
+            # Do this manually, to un-stagger the guards in log message
+            code_parts.append(f"___check_tensors({tensor_check_args})")
+            verbose_code_parts.append(f"___check_tensors({tensor_check_args})")
+            tensor_check_guards = builder.tensor_check_guards
+
+            for i, name in enumerate(tensor_check_names):
+                # This is a copy of what guards.cpp checks against
+                # Keep this in sync with TensorCheck constructor
+                t = tensor_check_examples[i]
+                sizes = dynamic_dims_sizes[i]
+                strides = dynamic_dims_strides[i]
+                code_part = get_tensor_guard_code_part(t, name, sizes, strides)
+                add_code_part(code_part, tensor_check_guards[i], log_only=True)
+
+        aotautograd_guards: List[GuardEnvExpr] = (
+            self.output_graph.tracing_context.guards_context.aotautograd_guards
+            if self.output_graph
+            else []
+        )
+        for guard in aotautograd_guards:
+            if isinstance(guard, DuplicateInputs):
+                source_a = guard.input_source_a
+                source_b = guard.input_source_b
+                add_code_part(f"{source_a.name()} is {source_b.name()}", None)
+            else:
+                raise RuntimeError(f"Unknown GuardEnvExpr: {guard}")
+
+        # TODO: the "guard" here is actually just the top level SHAPE_ENV
+        # which is useless.  Get ShapeEnv to pass in more provenance.
+        for gcl in builder.shape_env_code:
+            for code in gcl.code_list:
+                add_code_part(code, gcl.guard)
+
+        # OK, all done generating guards
+        torch._logging.trace_structured(
+            "dynamo_guards", payload_fn=lambda: [f() for f in structured_guard_fns]
+        )
+
+        global_state = convert_frame.initial_global_state
+        if global_state is None:
+            # we should only hit this case in NopTests()
+            global_state = convert_frame.GlobalStateGuard()
+        closure_vars = {
+            "___check_tensors": check_tensors_fn,
+            "___check_tensors_verbose": check_tensors_verbose_fn,
+            "___check_global_state": global_state.check,
+            "___check_current_backend": torch._dynamo.eval_frame.check_current_backend,
+            "tensor_check_names": tensor_check_names,
+            **SYMPY_INTERP,
+            **CLOSURE_VARS,
+        }
+
+        unique_code_parts = list(unique(code_parts))
+        make_guard_fn_args = ", ".join(closure_vars.keys())
+        guard_body, pycode = build_guard_function(unique_code_parts, make_guard_fn_args)
+
+        if os.environ.get("TORCHDYNAMO_PRINT_GUARDS", None) == "1":
+            print("GUARDS\n", guard_body)
+
+        out: Dict[str, Any] = dict()
+
+        # We don't put builder.scope as the globals in exec call because
+        # guard_fn.__globals__ becomes equal to builder.scope. This causes
+        # guard_fn to hold a referece to f_locals sitting in builder.scope["L"]
+        globals_for_guard_fn = {"G": builder.scope["G"]}
+        try:
+            exec(pycode, globals_for_guard_fn, out)
+        except SyntaxError as ex:
+            log.exception("Failed to exec guard at line %s.\n%s", ex.lineno, pycode)
+            raise
+        guard_fn = out["___make_guard_fn"](*closure_vars.values())
+        guard_fn.closure_vars = closure_vars
+        # TODO(whc) maybe '.code_parts' was only kept around for the guard callback? so we don't need both
+        guard_fn.args = largs
+        guard_fn.code_parts = code_parts
+        guard_fn.verbose_code_parts = verbose_code_parts
+        # Grab only G, but preserve "G" because guards access it as "G"
+        guard_fn.global_scope = globals_for_guard_fn
+        guard_fn.guard_fail_fn = guard_fail_fn
+        # will be populated by a non-owning reference to CacheEntry/ExtraState
+        # when the CacheEntry is constructed
+        guard_fn.cache_entry = None
+        guard_fn.extra_state = None
+        return guard_fn
+
+    def invalidate(self):
+        # Some tests reveal that CheckFunctionManager has no attribute
+        # check_fn, but this case should not be of any concern.
+        # This case doesn't seem easy to repro.
+        if (
+            hasattr(self, "check_fn")
+            and self.check_fn is not DeletedGuardFn
+            and (cache_entry := self.check_fn.cache_entry) is not None
+            and (extra_state := self.check_fn.extra_state) is not None
+        ):
+            assert isinstance(cache_entry, CacheEntry)
+            assert isinstance(extra_state, ExtraState)
+            extra_state.invalidate(cache_entry)
+            self.check_fn.cache_entry = None
+            self.check_fn.extra_state = None
+            self.check_fn = DeletedGuardFn
+
+    def id_ref(self, obj):
+        """add a weakref, return the id"""
+        try:
+            if id(obj) not in self._weakrefs:
+                # We will clear the _weakrefs dict at the end of __init__
+                # function, which will delete the callbacks as well. Therefore,
+                # we are using a finalizer which is kept alive.
+                self._weakrefs[id(obj)] = weakref.ref(obj)
+                weakref.finalize(obj, self.invalidate)
+        except TypeError:
+            pass  # cannot weakref bool object
+        return id(obj)
+
+    def lookup_weakrefs(self, obj):
+        """Lookup the _weakrefs created in id_ref function for ID_MATCH'd objects"""
+        if id(obj) in self._weakrefs:
+            return self._weakrefs[id(obj)]
+        return None
+
+
+def build_guard_function(code_parts, closure_args) -> Tuple[str, str]:
+    from torch._inductor.utils import IndentedBuffer
+
+    if HAS_UNPARSE_FUNCTIONS:
+        csepass = PyExprCSEPass()
+        csepass.count(code_parts)
+
+        def replace(expr: str) -> Tuple[List[str], str]:
+            return csepass.replace(expr)
+
+    else:
+
+        def replace(expr: str) -> Tuple[List[str], str]:
+            return [], expr
+
+    # Generate the inner body of the guard function.
+    # i.e. if-chain of the guard expressions.
+    guard_body = IndentedBuffer()
+    for expr in code_parts:
+        preface, expr = replace(expr)
+        guard_body.writelines(preface)
+        guard_body.writeline(f"if not ({expr}):")
+        with guard_body.indent():
+            guard_body.writeline("return False")
+
+    # Wrap the inner body into the actual guard function.
+    guard = IndentedBuffer()
+    guard.writeline("def guard(L):")
+    with guard.indent():
+        guard.splice(guard_body)
+        guard.writeline("return True")
+
+    # Wrap the whole guard function into another function
+    # with the closure variables.
+    make_guard_fn = IndentedBuffer()
+    make_guard_fn.writeline(f"def ___make_guard_fn({closure_args}):")
+    with make_guard_fn.indent():
+        make_guard_fn.splice(guard)
+        make_guard_fn.writeline("return guard")
+
+    return guard_body.getvalue(), make_guard_fn.getvalue()
+
+
+def is_recompiles_enabled():
+    return torch._logging._internal.log_state.is_artifact_enabled("recompiles")
+
+
+def is_recompiles_verbose_enabled():
+    return torch._logging._internal.log_state.is_artifact_enabled("recompiles_verbose")
+
+
+def get_guard_fail_reason(
+    guard_fn: GuardFn,
+    code: types.CodeType,
+    f_locals: Dict[str, object],
+) -> str:
+    """
+    Return the reason why `guard_fn` failed.
+    Updates `guard_failures` with the generated reason.
+    Only the first failed check of guard_fn is reported.
+    """
+    scope = {"L": f_locals, "G": guard_fn.global_scope["G"]}
+    scope.update(guard_fn.closure_vars)
+    scope["___check_tensors"] = scope["___check_tensors_verbose"]
+    reasons: List[str] = []
+    for part in guard_fn.verbose_code_parts:
+        global_scope = dict(guard_fn.global_scope)
+        global_scope["__compile_source__"] = part
+        with report_compile_source_on_error():
+            try:
+                fail_reason = eval(part, global_scope, scope)
+            except Exception as e:
+                if is_recompiles_verbose_enabled():
+                    continue
+                else:
+                    raise
+        # Only ___check_tensors knows how to return a fancy fail reason;
+        # for everything else we just report the code that failed
+
+        if isinstance(fail_reason, bool) and not fail_reason:
+            fail_reason = part
+        if isinstance(fail_reason, str):
+            reasons.append(fail_reason)
+            if not is_recompiles_verbose_enabled():
+                break
+
+    reason_str = "\n".join(reasons)
+    guard_failures[orig_code_map[code]].append(reason_str)
+
+    try:
+        if guard_fn.guard_fail_fn is not None:
+            guard_fn.guard_fail_fn(
+                GuardFail(reason_str or "unknown reason", orig_code_map[code])
+            )
+    except Exception as e:
+        log.exception(
+            "Failure in guard_fail_fn callback - raising here will cause a NULL Error on guard eval",
+        )
+
+    return reason_str
+
+
+def get_and_maybe_log_recompilation_reason(
+    cache_entry, frame: types.FrameType
+) -> List[str]:
+    """
+    Return the list of guard failure reasons using cache_entry.
+    Logs the recompilation reason if `recompiles` logging is enabled.
+    Raises a RecompileError if `config.error_on_recompile` is enabled.
+    """
+    reasons = []
+    while cache_entry is not None:
+        reason = get_guard_fail_reason(
+            cache_entry.check_fn, cache_entry.code, frame.f_locals
+        )
+        if reason:
+            reasons.append(reason)
+        cache_entry = cache_entry.next
+
+    code = frame.f_code
+
+    # at least one of "recompiles" or "recompiles_verbose" is enabled
+    do_recompiles_log = is_recompiles_enabled() or is_recompiles_verbose_enabled()
+
+    if do_recompiles_log or config.error_on_recompile:
+        if is_recompiles_verbose_enabled():
+            failures = "\n\n".join(
+                f"guard {i} failures:\n" + textwrap.indent(reason, "- ")
+                for i, reason in enumerate(reasons)
+            )
+        else:
+            failures = textwrap.indent("\n".join(reasons), "- ")
+        guard_failure_details = (
+            f"triggered by the following guard failure(s):\n{failures}"
+        )
+        message = (
+            f"Recompiling function {code.co_name} in {code.co_filename}:{code.co_firstlineno}\n"
+            f"{textwrap.indent(guard_failure_details, '    ')}"
+        )
+        if do_recompiles_log:
+            if is_recompiles_verbose_enabled():
+                recompiles_verbose_log.debug(message)
+            else:
+                recompiles_log.debug(message)
+        if config.error_on_recompile:
+            raise exc.RecompileError(message)
+
+    return reasons
+
+
+def guard_error_hook(
+    guard_fn: GuardFn,
+    code: types.CodeType,
+    f_locals: Dict[str, object],
+    index: int,
+    last: bool,
+):
+    print(
+        f"ERROR RUNNING GUARDS {code.co_name} {code.co_filename}:{code.co_firstlineno}"
+    )
+    print("lambda " + ", ".join(guard_fn.args) + ":")
+    print(" ", " and\n  ".join(guard_fn.code_parts))
+    local_scope = {"L": f_locals, **guard_fn.closure_vars}
+    for guard in guard_fn.code_parts:
+        try:
+            eval(guard, guard_fn.global_scope, local_scope)
+        except:  # noqa: B001,E722
+            print(f"Malformed guard:\n{guard}")
+
+
+set_guard_error_hook(guard_error_hook)
+
+
+def unique(seq):
+    seen = set()
+    for x in seq:
+        if x not in seen:
+            yield x
+            seen.add(x)
+
+
+def make_dupe_guard(obj_source, dupe_source):
+    # Note - we may end up in a situation where we invoke something like
+    # def fn(x, y)
+    # with fn(x, x)
+    # Prior to the addition of tracking to all relevant objects, we would handle this just fine by
+    # eagerly re-entering VB and rewrapping inputs, correctly creating graphargs and placeholders. However,
+    # with tracking on inputs, duplicate inputs or aliased relationships may end up getting erased here -
+    # In the fn(x, x) example call above look like a graph with a single input.
+    # In order to ensure that we do not reuse fn(x, x) for fn(x, y), we create a duplicate input guard.
+
+    # Note - we may not have a source, that is fine, it just means we had an object that is safe to have
+    # leave unsourced - like a local list created and discharged entirely within a local scope.
+    if dupe_source and dupe_source != obj_source:
+        ser_source_is_local = is_from_local_source(dupe_source)
+        source_is_local = is_from_local_source(obj_source)
+        # Note - both must be local, or global, or we will run afoul of a lack of merging in how we currently
+        # reconcile guards builder scopes in compile_check_fn. This technically means we miss a guard here,
+        # so maybe we should do this refactor before we land this...
+        # TODO(voz): Combine local and global guard builders.
+        if ser_source_is_local == source_is_local:
+            # Note - this is a little aggressive - these being duplicate input does not always matter.
+            # However, this should always be a sound guard to add here.
+            return functools.partial(GuardBuilder.DUPLICATE_INPUT, source_b=dupe_source)
+    return None
+
+
+def install_guard(*guards, skip=0):
+    """
+    Add dynamo guards to the current tracing context.
+
+    Args:
+        guards: guard(s) to add
+        skip: number of stack frames to ignore for debug stack trace
+    """
+    from torch._guards import TracingContext
+
+    collect_debug_stack = guards_log.isEnabledFor(
+        logging.DEBUG
+    ) or verbose_guards_log.isEnabledFor(logging.DEBUG)
+    add = TracingContext.get().guards_context.dynamo_guards.add
+    for guard in guards:
+        assert isinstance(guard, Guard)
+        add(guard, collect_debug_stack=collect_debug_stack, skip=skip + 1)

shared/package-files/56/564d6cca251b3adad0ba10b91ca657e113d82ad7406f2a53b17f9f668c7c1ad7/blob

@@ -0,0 +1,114 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+from google.protobuf.descriptor import (
+    Descriptor as google___protobuf___descriptor___Descriptor,
+    FileDescriptor as google___protobuf___descriptor___FileDescriptor,
+)
+
+from google.protobuf.internal.containers import (
+    RepeatedCompositeFieldContainer as google___protobuf___internal___containers___RepeatedCompositeFieldContainer,
+)
+
+from google.protobuf.message import (
+    Message as google___protobuf___message___Message,
+)
+
+from google.protobuf.source_context_pb2 import (
+    SourceContext as google___protobuf___source_context_pb2___SourceContext,
+)
+
+from google.protobuf.type_pb2 import (
+    Option as google___protobuf___type_pb2___Option,
+    SyntaxValue as google___protobuf___type_pb2___SyntaxValue,
+)
+
+from typing import (
+    Iterable as typing___Iterable,
+    Optional as typing___Optional,
+    Text as typing___Text,
+)
+
+from typing_extensions import (
+    Literal as typing_extensions___Literal,
+)
+
+
+builtin___bool = bool
+builtin___bytes = bytes
+builtin___float = float
+builtin___int = int
+
+
+DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ...
+
+class Api(google___protobuf___message___Message):
+    DESCRIPTOR: google___protobuf___descriptor___Descriptor = ...
+    name: typing___Text = ...
+    version: typing___Text = ...
+    syntax: google___protobuf___type_pb2___SyntaxValue = ...
+
+    @property
+    def methods(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___Method]: ...
+
+    @property
+    def options(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[google___protobuf___type_pb2___Option]: ...
+
+    @property
+    def source_context(self) -> google___protobuf___source_context_pb2___SourceContext: ...
+
+    @property
+    def mixins(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___Mixin]: ...
+
+    def __init__(self,
+        *,
+        name : typing___Optional[typing___Text] = None,
+        methods : typing___Optional[typing___Iterable[type___Method]] = None,
+        options : typing___Optional[typing___Iterable[google___protobuf___type_pb2___Option]] = None,
+        version : typing___Optional[typing___Text] = None,
+        source_context : typing___Optional[google___protobuf___source_context_pb2___SourceContext] = None,
+        mixins : typing___Optional[typing___Iterable[type___Mixin]] = None,
+        syntax : typing___Optional[google___protobuf___type_pb2___SyntaxValue] = None,
+        ) -> None: ...
+    def HasField(self, field_name: typing_extensions___Literal[u"source_context",b"source_context"]) -> builtin___bool: ...
+    def ClearField(self, field_name: typing_extensions___Literal[u"methods",b"methods",u"mixins",b"mixins",u"name",b"name",u"options",b"options",u"source_context",b"source_context",u"syntax",b"syntax",u"version",b"version"]) -> None: ...
+type___Api = Api
+
+class Method(google___protobuf___message___Message):
+    DESCRIPTOR: google___protobuf___descriptor___Descriptor = ...
+    name: typing___Text = ...
+    request_type_url: typing___Text = ...
+    request_streaming: builtin___bool = ...
+    response_type_url: typing___Text = ...
+    response_streaming: builtin___bool = ...
+    syntax: google___protobuf___type_pb2___SyntaxValue = ...
+
+    @property
+    def options(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[google___protobuf___type_pb2___Option]: ...
+
+    def __init__(self,
+        *,
+        name : typing___Optional[typing___Text] = None,
+        request_type_url : typing___Optional[typing___Text] = None,
+        request_streaming : typing___Optional[builtin___bool] = None,
+        response_type_url : typing___Optional[typing___Text] = None,
+        response_streaming : typing___Optional[builtin___bool] = None,
+        options : typing___Optional[typing___Iterable[google___protobuf___type_pb2___Option]] = None,
+        syntax : typing___Optional[google___protobuf___type_pb2___SyntaxValue] = None,
+        ) -> None: ...
+    def ClearField(self, field_name: typing_extensions___Literal[u"name",b"name",u"options",b"options",u"request_streaming",b"request_streaming",u"request_type_url",b"request_type_url",u"response_streaming",b"response_streaming",u"response_type_url",b"response_type_url",u"syntax",b"syntax"]) -> None: ...
+type___Method = Method
+
+class Mixin(google___protobuf___message___Message):
+    DESCRIPTOR: google___protobuf___descriptor___Descriptor = ...
+    name: typing___Text = ...
+    root: typing___Text = ...
+
+    def __init__(self,
+        *,
+        name : typing___Optional[typing___Text] = None,
+        root : typing___Optional[typing___Text] = None,
+        ) -> None: ...
+    def ClearField(self, field_name: typing_extensions___Literal[u"name",b"name",u"root",b"root"]) -> None: ...
+type___Mixin = Mixin

shared/package-files/56/564f153bbe095146991ef7a3be45890519e693ece9987c2392c3026680435837/blob

@@ -0,0 +1,130 @@
+import os.path
+from pathlib import Path
+from typing import Any, Callable, Optional, Tuple, Union
+
+import numpy as np
+from PIL import Image
+
+from .utils import check_integrity, download_url, verify_str_arg
+from .vision import VisionDataset
+
+
+class SVHN(VisionDataset):
+    """`SVHN <http://ufldl.stanford.edu/housenumbers/>`_ Dataset.
+    Note: The SVHN dataset assigns the label `10` to the digit `0`. However, in this Dataset,
+    we assign the label `0` to the digit `0` to be compatible with PyTorch loss functions which
+    expect the class labels to be in the range `[0, C-1]`
+
+    .. warning::
+
+        This class needs `scipy <https://docs.scipy.org/doc/>`_ to load data from `.mat` format.
+
+    Args:
+        root (str or ``pathlib.Path``): Root directory of the dataset where the data is stored.
+        split (string): One of {'train', 'test', 'extra'}.
+            Accordingly dataset is selected. 'extra' is Extra training set.
+        transform (callable, optional): A function/transform that takes in a PIL image
+            and returns a transformed version. E.g, ``transforms.RandomCrop``
+        target_transform (callable, optional): A function/transform that takes in the
+            target and transforms it.
+        download (bool, optional): If true, downloads the dataset from the internet and
+            puts it in root directory. If dataset is already downloaded, it is not
+            downloaded again.
+
+    """
+
+    split_list = {
+        "train": [
+            "http://ufldl.stanford.edu/housenumbers/train_32x32.mat",
+            "train_32x32.mat",
+            "e26dedcc434d2e4c54c9b2d4a06d8373",
+        ],
+        "test": [
+            "http://ufldl.stanford.edu/housenumbers/test_32x32.mat",
+            "test_32x32.mat",
+            "eb5a983be6a315427106f1b164d9cef3",
+        ],
+        "extra": [
+            "http://ufldl.stanford.edu/housenumbers/extra_32x32.mat",
+            "extra_32x32.mat",
+            "a93ce644f1a588dc4d68dda5feec44a7",
+        ],
+    }
+
+    def __init__(
+        self,
+        root: Union[str, Path],
+        split: str = "train",
+        transform: Optional[Callable] = None,
+        target_transform: Optional[Callable] = None,
+        download: bool = False,
+    ) -> None:
+        super().__init__(root, transform=transform, target_transform=target_transform)
+        self.split = verify_str_arg(split, "split", tuple(self.split_list.keys()))
+        self.url = self.split_list[split][0]
+        self.filename = self.split_list[split][1]
+        self.file_md5 = self.split_list[split][2]
+
+        if download:
+            self.download()
+
+        if not self._check_integrity():
+            raise RuntimeError("Dataset not found or corrupted. You can use download=True to download it")
+
+        # import here rather than at top of file because this is
+        # an optional dependency for torchvision
+        import scipy.io as sio
+
+        # reading(loading) mat file as array
+        loaded_mat = sio.loadmat(os.path.join(self.root, self.filename))
+
+        self.data = loaded_mat["X"]
+        # loading from the .mat file gives an np.ndarray of type np.uint8
+        # converting to np.int64, so that we have a LongTensor after
+        # the conversion from the numpy array
+        # the squeeze is needed to obtain a 1D tensor
+        self.labels = loaded_mat["y"].astype(np.int64).squeeze()
+
+        # the svhn dataset assigns the class label "10" to the digit 0
+        # this makes it inconsistent with several loss functions
+        # which expect the class labels to be in the range [0, C-1]
+        np.place(self.labels, self.labels == 10, 0)
+        self.data = np.transpose(self.data, (3, 2, 0, 1))
+
+    def __getitem__(self, index: int) -> Tuple[Any, Any]:
+        """
+        Args:
+            index (int): Index
+
+        Returns:
+            tuple: (image, target) where target is index of the target class.
+        """
+        img, target = self.data[index], int(self.labels[index])
+
+        # doing this so that it is consistent with all other datasets
+        # to return a PIL Image
+        img = Image.fromarray(np.transpose(img, (1, 2, 0)))
+
+        if self.transform is not None:
+            img = self.transform(img)
+
+        if self.target_transform is not None:
+            target = self.target_transform(target)
+
+        return img, target
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def _check_integrity(self) -> bool:
+        root = self.root
+        md5 = self.split_list[self.split][2]
+        fpath = os.path.join(root, self.filename)
+        return check_integrity(fpath, md5)
+
+    def download(self) -> None:
+        md5 = self.split_list[self.split][2]
+        download_url(self.url, self.root, self.filename, md5)
+
+    def extra_repr(self) -> str:
+        return "Split: {split}".format(**self.__dict__)

shared/package-files/56/5652bcc2d84bb33915968e96a2b1f17c53beb242a11ed79abd839a80779d0821/blob

@@ -0,0 +1,51 @@
+# NOTE: This test is sensitive to line numbers as it checks breakpoints
+from numba import njit, types
+import numpy as np
+from numba.tests.gdb_support import GdbMIDriver
+from numba.tests.support import TestCase, needs_subprocess
+import unittest
+
+
+@needs_subprocess
+class Test(TestCase):
+
+    def test(self):
+        @njit(debug=True)
+        def foo(x):
+            z = np.ones_like(x) # break here
+            return x, z
+
+        tmp = np.ones(5)
+        foo(tmp)
+
+        driver = GdbMIDriver(__file__)
+        driver.set_breakpoint(line=15)
+        driver.run()
+        driver.check_hit_breakpoint(1)
+        driver.stack_list_arguments(2)
+        llvm_intp = f"i{types.intp.bitwidth}"
+        expect = (
+            '[frame={level="0",args=[{name="x",type="array(float64, 1d, C) '
+            f'({{i8*, i8*, {llvm_intp}, {llvm_intp}, double*, '
+            f'[1 x {llvm_intp}], [1 x {llvm_intp}]}})"}}]}}]'
+        )
+        driver.assert_output(expect)
+        driver.stack_list_variables(1)
+        # 'z' should be zero-init
+        expect = ('{name="z",value="{meminfo = 0x0, parent = 0x0, nitems = 0, '
+                  'itemsize = 0, data = 0x0, shape = {0}, strides = {0}}"}')
+        driver.assert_output(expect)
+        driver.set_breakpoint(line=16)
+        driver.cont()
+        driver.check_hit_breakpoint(2)
+        driver.stack_list_variables(1)
+        # 'z' should be populated
+        expect = (r'^.*\{name="z",value="\{meminfo = 0x[0-9a-f]+ .*, '
+                  r'parent = 0x0, nitems = 5, itemsize = 8, '
+                  r'data = 0x[0-9a-f]+, shape = \{5\}, strides = \{8\}\}.*$')
+        driver.assert_regex_output(expect)
+        driver.quit()
+
+
+if __name__ == '__main__':
+    unittest.main()

shared/package-files/56/565454d155b79ca728b997f7ca4b7c23e8ad2bd520ed89561831c99d8b95b438/blob

@@ -0,0 +1,27 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeMetaFunction.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/TensorIterator.h>
+#include <ATen/TensorMeta.h>
+#include <tuple>
+#include <vector>
+
+namespace at {
+namespace meta {
+
+struct TORCH_API structured_scatter_reduce_two : public at::impl::MetaBase {
+    
+    
+    void meta(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, bool include_self);
+};
+
+} // namespace native
+} // namespace at

shared/package-files/56/5659af72d45a42d8ee62f42ea1edaddae7e26fbe13b9affbaac895aecde3fa9d/blob

@@ -0,0 +1,9 @@
+import numpy as np
+from pytest import raises as assert_raises
+
+import scipy.sparse.linalg._isolve.utils as utils
+
+
+def test_make_system_bad_shape():
+    assert_raises(ValueError,
+                  utils.make_system, np.zeros((5,3)), None, np.zeros(4), np.zeros(4))

shared/package-files/56/565b18e09c1951c905e6ec43ad596b2510559ef4e6bae6a3774877ec13246cea/blob

@@ -0,0 +1,447 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import io
+import os
+import re
+import sys
+import types
+
+import pytest
+from unittest import mock
+
+import pyarrow as pa
+
+try:
+    import pyarrow.parquet as pq
+    from pyarrow.tests.parquet.common import _write_table
+except ImportError:
+    pq = None
+
+try:
+    import pandas as pd
+    import pandas.testing as tm
+
+    from pyarrow.tests.parquet.common import alltypes_sample
+except ImportError:
+    pd = tm = None
+
+
+# Marks all of the tests in this module
+# Ignore these with pytest ... -m 'not parquet'
+pytestmark = pytest.mark.parquet
+
+
+@pytest.mark.pandas
+def test_pass_separate_metadata():
+    # ARROW-471
+    df = alltypes_sample(size=10000)
+
+    a_table = pa.Table.from_pandas(df)
+
+    buf = io.BytesIO()
+    _write_table(a_table, buf, compression='snappy', version='2.6')
+
+    buf.seek(0)
+    metadata = pq.read_metadata(buf)
+
+    buf.seek(0)
+
+    fileh = pq.ParquetFile(buf, metadata=metadata)
+
+    tm.assert_frame_equal(df, fileh.read().to_pandas())
+
+
+@pytest.mark.pandas
+def test_read_single_row_group():
+    # ARROW-471
+    N, K = 10000, 4
+    df = alltypes_sample(size=N)
+
+    a_table = pa.Table.from_pandas(df)
+
+    buf = io.BytesIO()
+    _write_table(a_table, buf, row_group_size=N / K,
+                 compression='snappy', version='2.6')
+
+    buf.seek(0)
+
+    pf = pq.ParquetFile(buf)
+
+    assert pf.num_row_groups == K
+
+    row_groups = [pf.read_row_group(i) for i in range(K)]
+    result = pa.concat_tables(row_groups)
+    tm.assert_frame_equal(df, result.to_pandas())
+
+
+@pytest.mark.pandas
+def test_read_single_row_group_with_column_subset():
+    N, K = 10000, 4
+    df = alltypes_sample(size=N)
+    a_table = pa.Table.from_pandas(df)
+
+    buf = io.BytesIO()
+    _write_table(a_table, buf, row_group_size=N / K,
+                 compression='snappy', version='2.6')
+
+    buf.seek(0)
+    pf = pq.ParquetFile(buf)
+
+    cols = list(df.columns[:2])
+    row_groups = [pf.read_row_group(i, columns=cols) for i in range(K)]
+    result = pa.concat_tables(row_groups)
+    tm.assert_frame_equal(df[cols], result.to_pandas())
+
+    # ARROW-4267: Selection of duplicate columns still leads to these columns
+    # being read uniquely.
+    row_groups = [pf.read_row_group(i, columns=cols + cols) for i in range(K)]
+    result = pa.concat_tables(row_groups)
+    tm.assert_frame_equal(df[cols], result.to_pandas())
+
+
+@pytest.mark.pandas
+def test_read_multiple_row_groups():
+    N, K = 10000, 4
+    df = alltypes_sample(size=N)
+
+    a_table = pa.Table.from_pandas(df)
+
+    buf = io.BytesIO()
+    _write_table(a_table, buf, row_group_size=N / K,
+                 compression='snappy', version='2.6')
+
+    buf.seek(0)
+
+    pf = pq.ParquetFile(buf)
+
+    assert pf.num_row_groups == K
+
+    result = pf.read_row_groups(range(K))
+    tm.assert_frame_equal(df, result.to_pandas())
+
+
+@pytest.mark.pandas
+def test_read_multiple_row_groups_with_column_subset():
+    N, K = 10000, 4
+    df = alltypes_sample(size=N)
+    a_table = pa.Table.from_pandas(df)
+
+    buf = io.BytesIO()
+    _write_table(a_table, buf, row_group_size=N / K,
+                 compression='snappy', version='2.6')
+
+    buf.seek(0)
+    pf = pq.ParquetFile(buf)
+
+    cols = list(df.columns[:2])
+    result = pf.read_row_groups(range(K), columns=cols)
+    tm.assert_frame_equal(df[cols], result.to_pandas())
+
+    # ARROW-4267: Selection of duplicate columns still leads to these columns
+    # being read uniquely.
+    result = pf.read_row_groups(range(K), columns=cols + cols)
+    tm.assert_frame_equal(df[cols], result.to_pandas())
+
+
+@pytest.mark.pandas
+def test_scan_contents():
+    N, K = 10000, 4
+    df = alltypes_sample(size=N)
+    a_table = pa.Table.from_pandas(df)
+
+    buf = io.BytesIO()
+    _write_table(a_table, buf, row_group_size=N / K,
+                 compression='snappy', version='2.6')
+
+    buf.seek(0)
+    pf = pq.ParquetFile(buf)
+
+    assert pf.scan_contents() == 10000
+    assert pf.scan_contents(df.columns[:4]) == 10000
+
+
+def test_parquet_file_pass_directory_instead_of_file(tempdir):
+    # ARROW-7208
+    path = tempdir / 'directory'
+    os.mkdir(str(path))
+
+    msg = f"Cannot open for reading: path '{str(path)}' is a directory"
+    with pytest.raises(IOError) as exc:
+        pq.ParquetFile(path)
+    if exc.errisinstance(PermissionError) and sys.platform == 'win32':
+        return  # Windows CI can get a PermissionError here.
+    exc.match(msg)
+
+
+def test_read_column_invalid_index():
+    table = pa.table([pa.array([4, 5]), pa.array(["foo", "bar"])],
+                     names=['ints', 'strs'])
+    bio = pa.BufferOutputStream()
+    pq.write_table(table, bio)
+    f = pq.ParquetFile(bio.getvalue())
+    assert f.reader.read_column(0).to_pylist() == [4, 5]
+    assert f.reader.read_column(1).to_pylist() == ["foo", "bar"]
+    for index in (-1, 2):
+        with pytest.raises((ValueError, IndexError)):
+            f.reader.read_column(index)
+
+
+@pytest.mark.pandas
+@pytest.mark.parametrize('batch_size', [300, 1000, 1300])
+def test_iter_batches_columns_reader(tempdir, batch_size):
+    total_size = 3000
+    chunk_size = 1000
+    # TODO: Add categorical support
+    df = alltypes_sample(size=total_size)
+
+    filename = tempdir / 'pandas_roundtrip.parquet'
+    arrow_table = pa.Table.from_pandas(df)
+    _write_table(arrow_table, filename, version='2.6',
+                 chunk_size=chunk_size)
+
+    file_ = pq.ParquetFile(filename)
+    for columns in [df.columns[:10], df.columns[10:]]:
+        batches = file_.iter_batches(batch_size=batch_size, columns=columns)
+        batch_starts = range(0, total_size+batch_size, batch_size)
+        for batch, start in zip(batches, batch_starts):
+            end = min(total_size, start + batch_size)
+            tm.assert_frame_equal(
+                batch.to_pandas(),
+                df.iloc[start:end, :].loc[:, columns].reset_index(drop=True)
+            )
+
+
+@pytest.mark.pandas
+@pytest.mark.parametrize('chunk_size', [1000])
+def test_iter_batches_reader(tempdir, chunk_size):
+    df = alltypes_sample(size=10000, categorical=True)
+
+    filename = tempdir / 'pandas_roundtrip.parquet'
+    arrow_table = pa.Table.from_pandas(df)
+    assert arrow_table.schema.pandas_metadata is not None
+
+    _write_table(arrow_table, filename, version='2.6',
+                 chunk_size=chunk_size)
+
+    file_ = pq.ParquetFile(filename)
+
+    def get_all_batches(f):
+        for row_group in range(f.num_row_groups):
+            batches = f.iter_batches(
+                batch_size=900,
+                row_groups=[row_group],
+            )
+
+            for batch in batches:
+                yield batch
+
+    batches = list(get_all_batches(file_))
+    batch_no = 0
+
+    for i in range(file_.num_row_groups):
+        tm.assert_frame_equal(
+            batches[batch_no].to_pandas(),
+            file_.read_row_groups([i]).to_pandas().head(900)
+        )
+
+        batch_no += 1
+
+        tm.assert_frame_equal(
+            batches[batch_no].to_pandas().reset_index(drop=True),
+            file_.read_row_groups([i]).to_pandas().iloc[900:].reset_index(
+                drop=True
+            )
+        )
+
+        batch_no += 1
+
+
+@pytest.mark.pandas
+@pytest.mark.parametrize('pre_buffer', [False, True])
+def test_pre_buffer(pre_buffer):
+    N, K = 10000, 4
+    df = alltypes_sample(size=N)
+    a_table = pa.Table.from_pandas(df)
+
+    buf = io.BytesIO()
+    _write_table(a_table, buf, row_group_size=N / K,
+                 compression='snappy', version='2.6')
+
+    buf.seek(0)
+    pf = pq.ParquetFile(buf, pre_buffer=pre_buffer)
+    assert pf.read().num_rows == N
+
+
+def test_parquet_file_explicitly_closed(tempdir):
+    """
+    Unopened files should be closed explicitly after use,
+    and previously opened files should be left open.
+    Applies to read_table, ParquetDataset, and ParquetFile
+    """
+    # create test parquet file
+    fn = tempdir.joinpath('file.parquet')
+    table = pa.table({'col1': [0, 1], 'col2': [0, 1]})
+    pq.write_table(table, fn)
+
+    # ParquetFile with opened file (will leave open)
+    with open(fn, 'rb') as f:
+        with pq.ParquetFile(f) as p:
+            p.read()
+            assert not f.closed
+            assert not p.closed
+        assert not f.closed  # opened input file was not closed
+        assert not p.closed  # parquet file obj reports as not closed
+    assert f.closed
+    assert p.closed  # parquet file being closed reflects underlying file
+
+    # ParquetFile with unopened file (will close)
+    with pq.ParquetFile(fn) as p:
+        p.read()
+        assert not p.closed
+    assert p.closed  # parquet file obj reports as closed
+
+
+@pytest.mark.s3
+@pytest.mark.parametrize("use_uri", (True, False))
+def test_parquet_file_with_filesystem(s3_example_fs, use_uri):
+    s3_fs, s3_uri, s3_path = s3_example_fs
+
+    args = (s3_uri if use_uri else s3_path,)
+    kwargs = {} if use_uri else dict(filesystem=s3_fs)
+
+    table = pa.table({"a": range(10)})
+    pq.write_table(table, s3_path, filesystem=s3_fs)
+
+    parquet_file = pq.ParquetFile(*args, **kwargs)
+    assert parquet_file.read() == table
+    assert not parquet_file.closed
+    parquet_file.close()
+    assert parquet_file.closed
+
+    with pq.ParquetFile(*args, **kwargs) as f:
+        assert f.read() == table
+        assert not f.closed
+    assert f.closed
+
+
+def test_read_statistics():
+    table = pa.table({"value": pa.array([-1, None, 3])})
+    buf = io.BytesIO()
+    _write_table(table, buf)
+    buf.seek(0)
+
+    statistics = pq.ParquetFile(buf).read().columns[0].chunks[0].statistics
+    assert statistics.is_null_count_exact is True
+    assert statistics.null_count == 1
+    assert statistics.distinct_count is None
+    # TODO: add tests for is_distinct_count_exact == None and True
+    # once Python API allows
+    assert statistics.is_distinct_count_exact is False
+    assert statistics.min == -1
+    assert statistics.is_min_exact
+    assert statistics.max == 3
+    assert statistics.is_max_exact
+    assert repr(statistics) == ("arrow.ArrayStatistics<"
+                                "null_count=1, distinct_count=None, "
+                                "min=-1, is_min_exact=True, "
+                                "max=3, is_max_exact=True>")
+
+
+def test_read_undefined_logical_type(parquet_test_datadir):
+    test_file = f"{parquet_test_datadir}/unknown-logical-type.parquet"
+
+    table = pq.ParquetFile(test_file).read()
+    assert table.column_names == ["column with known type", "column with unknown type"]
+    assert table["column with unknown type"].to_pylist() == [
+        b"unknown string 1",
+        b"unknown string 2",
+        b"unknown string 3"
+    ]
+
+
+def test_parquet_file_fsspec_support():
+    pytest.importorskip("fsspec")
+
+    table = pa.table({"a": range(10)})
+    pq.write_table(table, "fsspec+memory://example.parquet")
+    table2 = pq.read_table("fsspec+memory://example.parquet")
+    assert table.equals(table2)
+
+    msg = "Unrecognized filesystem type in URI"
+    with pytest.raises(pa.ArrowInvalid, match=msg):
+        pq.read_table("non-existing://example.parquet")
+
+
+def test_parquet_file_fsspec_support_through_filesystem_argument():
+    try:
+        from fsspec.implementations.memory import MemoryFileSystem
+    except ImportError:
+        pytest.skip("fsspec is not installed, skipping test")
+
+    table = pa.table({"b": range(10)})
+
+    fs = MemoryFileSystem()
+    fs.mkdir("/path/to/prefix", create_parents=True)
+    assert fs.exists("/path/to/prefix")
+
+    fs_str = "fsspec+memory://path/to/prefix"
+    pq.write_table(table, "b.parquet", filesystem=fs_str)
+    table2 = pq.read_table("fsspec+memory://path/to/prefix/b.parquet")
+    assert table.equals(table2)
+
+
+def test_parquet_file_hugginface_support():
+    try:
+        from fsspec.implementations.memory import MemoryFileSystem
+    except ImportError:
+        pytest.skip("fsspec is not installed, skipping Hugging Face test")
+
+    fake_hf_module = types.ModuleType("huggingface_hub")
+    fake_hf_module.HfFileSystem = MemoryFileSystem
+    with mock.patch.dict("sys.modules", {"huggingface_hub": fake_hf_module}):
+        uri = "hf://datasets/apache/arrow/test.parquet"
+        table = pa.table({"a": range(10)})
+        pq.write_table(table, uri)
+        table2 = pq.read_table(uri)
+        assert table.equals(table2)
+
+
+def test_fsspec_uri_raises_if_fsspec_is_not_available():
+    # sadly cannot patch sys.modules because cython will still be able to import fsspec
+    try:
+        import fsspec  # noqa: F401
+    except ImportError:
+        pass
+    else:
+        pytest.skip("fsspec is available, skipping test")
+
+    msg = re.escape(
+        "`fsspec` is required to handle `fsspec+<filesystem>://` and `hf://` URIs.")
+    with pytest.raises(ImportError, match=msg):
+        pq.read_table("fsspec+memory://example.parquet")
+
+
+def test_iter_batches_raises_batch_size_zero(tempdir):
+    # See https://github.com/apache/arrow/issues/46811
+    schema = pa.schema([])
+    empty_table = pa.Table.from_batches([], schema=schema)
+    parquet_file_path = tempdir / "empty_file.parquet"
+    pq.write_table(empty_table, parquet_file_path)
+    parquet_file = pq.ParquetFile(parquet_file_path)
+    with pytest.raises(ValueError):
+        parquet_file.iter_batches(batch_size=0)

shared/package-files/56/565ef8fb81829dc98a4be79bd3ac584d2e4a66d9a63a5ff80e55dc78583f95b6/blob

@@ -0,0 +1,17 @@
+from typing import Any
+
+from yaml.error import MarkedYAMLError
+
+class ComposerError(MarkedYAMLError): ...
+
+class Composer:
+    anchors: Any
+    def __init__(self) -> None: ...
+    def check_node(self): ...
+    def get_node(self): ...
+    def get_single_node(self): ...
+    def compose_document(self): ...
+    def compose_node(self, parent, index): ...
+    def compose_scalar_node(self, anchor): ...
+    def compose_sequence_node(self, anchor): ...
+    def compose_mapping_node(self, anchor): ...

shared/package-files/56/566141a62fbfb4d6bccb3366bbf7ee7dec263d39c253ac9c34219c377e1405c7/blob

@@ -0,0 +1,14 @@
+from .geometry import cauchy_geometry, spider_geometry
+from .optim import (
+    tangential_byrd_omojokun,
+    constrained_tangential_byrd_omojokun,
+    normal_byrd_omojokun,
+)
+
+__all__ = [
+    "cauchy_geometry",
+    "spider_geometry",
+    "tangential_byrd_omojokun",
+    "constrained_tangential_byrd_omojokun",
+    "normal_byrd_omojokun",
+]

shared/package-files/56/566520ef07b56189e8e87e331e08c2a0f63ba533b7cf314792714c0bca18c047/blob

@@ -0,0 +1,67 @@
+from socket import _RetAddress, socket
+from threading import Thread
+from typing import Dict, Protocol, Tuple
+
+from paramiko.channel import Channel
+from paramiko.message import Message
+from paramiko.pkey import PKey
+from paramiko.transport import Transport
+
+class _AgentProxy(Protocol):
+    def connect(self) -> None: ...
+    def close(self) -> None: ...
+
+cSSH2_AGENTC_REQUEST_IDENTITIES: bytes
+SSH2_AGENT_IDENTITIES_ANSWER: int
+cSSH2_AGENTC_SIGN_REQUEST: bytes
+SSH2_AGENT_SIGN_RESPONSE: int
+
+class AgentSSH:
+    def __init__(self) -> None: ...
+    def get_keys(self) -> Tuple[AgentKey, ...]: ...
+
+class AgentProxyThread(Thread):
+    def __init__(self, agent: _AgentProxy) -> None: ...
+    def run(self) -> None: ...
+
+class AgentLocalProxy(AgentProxyThread):
+    def __init__(self, agent: AgentServerProxy) -> None: ...
+    def get_connection(self) -> Tuple[socket, _RetAddress]: ...
+
+class AgentRemoteProxy(AgentProxyThread):
+    def __init__(self, agent: AgentClientProxy, chan: Channel) -> None: ...
+    def get_connection(self) -> Tuple[socket, _RetAddress]: ...
+
+class AgentClientProxy:
+    thread: Thread
+    def __init__(self, chanRemote: Channel) -> None: ...
+    def __del__(self) -> None: ...
+    def connect(self) -> None: ...
+    def close(self) -> None: ...
+
+class AgentServerProxy(AgentSSH):
+    thread: Thread
+    def __init__(self, t: Transport) -> None: ...
+    def __del__(self) -> None: ...
+    def connect(self) -> None: ...
+    def close(self) -> None: ...
+    def get_env(self) -> Dict[str, str]: ...
+
+class AgentRequestHandler:
+    def __init__(self, chanClient: Channel) -> None: ...
+    def __del__(self) -> None: ...
+    def close(self) -> None: ...
+
+class Agent(AgentSSH):
+    def __init__(self) -> None: ...
+    def close(self) -> None: ...
+
+class AgentKey(PKey):
+    agent: AgentSSH
+    blob: bytes
+    public_blob: None
+    name: str
+    def __init__(self, agent: AgentSSH, blob: bytes) -> None: ...
+    def asbytes(self) -> bytes: ...
+    def get_name(self) -> str: ...
+    def sign_ssh_data(self, data: bytes) -> Message: ...

shared/package-files/56/5666bb7eda54f19534e85cecf9cca49fce014790c8cd7bb2eaf3b1646851eba8/blob

@@ -0,0 +1,661 @@
+from abc import ABC, abstractmethod
+import getpass
+import sys, os, pickle
+import tempfile
+import types
+import re
+from typing import (
+    TypeVar, Type, List, Dict, Iterator, Callable, Union, Optional, Sequence,
+    Tuple, Iterable, IO, Any, TYPE_CHECKING, Collection
+)
+if TYPE_CHECKING:
+    from .parsers.lalr_interactive_parser import InteractiveParser
+    from .tree import ParseTree
+    from .visitors import Transformer
+    if sys.version_info >= (3, 8):
+        from typing import Literal
+    else:
+        from typing_extensions import Literal
+    from .parser_frontends import ParsingFrontend
+
+from .exceptions import ConfigurationError, assert_config, UnexpectedInput
+from .utils import Serialize, SerializeMemoizer, FS, isascii, logger
+from .load_grammar import load_grammar, FromPackageLoader, Grammar, verify_used_files, PackageResource, sha256_digest
+from .tree import Tree
+from .common import LexerConf, ParserConf, _ParserArgType, _LexerArgType
+
+from .lexer import Lexer, BasicLexer, TerminalDef, LexerThread, Token
+from .parse_tree_builder import ParseTreeBuilder
+from .parser_frontends import _validate_frontend_args, _get_lexer_callbacks, _deserialize_parsing_frontend, _construct_parsing_frontend
+from .grammar import Rule
+
+
+try:
+    import regex
+    _has_regex = True
+except ImportError:
+    _has_regex = False
+
+
+###{standalone
+
+
+class PostLex(ABC):
+    @abstractmethod
+    def process(self, stream: Iterator[Token]) -> Iterator[Token]:
+        return stream
+
+    always_accept: Iterable[str] = ()
+
+class LarkOptions(Serialize):
+    """Specifies the options for Lark
+
+    """
+
+    start: List[str]
+    debug: bool
+    strict: bool
+    transformer: 'Optional[Transformer]'
+    propagate_positions: Union[bool, str]
+    maybe_placeholders: bool
+    cache: Union[bool, str]
+    regex: bool
+    g_regex_flags: int
+    keep_all_tokens: bool
+    tree_class: Optional[Callable[[str, List], Any]]
+    parser: _ParserArgType
+    lexer: _LexerArgType
+    ambiguity: 'Literal["auto", "resolve", "explicit", "forest"]'
+    postlex: Optional[PostLex]
+    priority: 'Optional[Literal["auto", "normal", "invert"]]'
+    lexer_callbacks: Dict[str, Callable[[Token], Token]]
+    use_bytes: bool
+    ordered_sets: bool
+    edit_terminals: Optional[Callable[[TerminalDef], TerminalDef]]
+    import_paths: 'List[Union[str, Callable[[Union[None, str, PackageResource], str], Tuple[str, str]]]]'
+    source_path: Optional[str]
+
+    OPTIONS_DOC = r"""
+    **===  General Options  ===**
+
+    start
+            The start symbol. Either a string, or a list of strings for multiple possible starts (Default: "start")
+    debug
+            Display debug information and extra warnings. Use only when debugging (Default: ``False``)
+            When used with Earley, it generates a forest graph as "sppf.png", if 'dot' is installed.
+    strict
+            Throw an exception on any potential ambiguity, including shift/reduce conflicts, and regex collisions.
+    transformer
+            Applies the transformer to every parse tree (equivalent to applying it after the parse, but faster)
+    propagate_positions
+            Propagates positional attributes into the 'meta' attribute of all tree branches.
+            Sets attributes: (line, column, end_line, end_column, start_pos, end_pos,
+                              container_line, container_column, container_end_line, container_end_column)
+            Accepts ``False``, ``True``, or a callable, which will filter which nodes to ignore when propagating.
+    maybe_placeholders
+            When ``True``, the ``[]`` operator returns ``None`` when not matched.
+            When ``False``,  ``[]`` behaves like the ``?`` operator, and returns no value at all.
+            (default= ``True``)
+    cache
+            Cache the results of the Lark grammar analysis, for x2 to x3 faster loading. LALR only for now.
+
+            - When ``False``, does nothing (default)
+            - When ``True``, caches to a temporary file in the local directory
+            - When given a string, caches to the path pointed by the string
+    regex
+            When True, uses the ``regex`` module instead of the stdlib ``re``.
+    g_regex_flags
+            Flags that are applied to all terminals (both regex and strings)
+    keep_all_tokens
+            Prevent the tree builder from automagically removing "punctuation" tokens (Default: ``False``)
+    tree_class
+            Lark will produce trees comprised of instances of this class instead of the default ``lark.Tree``.
+
+    **=== Algorithm Options ===**
+
+    parser
+            Decides which parser engine to use. Accepts "earley" or "lalr". (Default: "earley").
+            (there is also a "cyk" option for legacy)
+    lexer
+            Decides whether or not to use a lexer stage
+
+            - "auto" (default): Choose for me based on the parser
+            - "basic": Use a basic lexer
+            - "contextual": Stronger lexer (only works with parser="lalr")
+            - "dynamic": Flexible and powerful (only with parser="earley")
+            - "dynamic_complete": Same as dynamic, but tries *every* variation of tokenizing possible.
+    ambiguity
+            Decides how to handle ambiguity in the parse. Only relevant if parser="earley"
+
+            - "resolve": The parser will automatically choose the simplest derivation
+              (it chooses consistently: greedy for tokens, non-greedy for rules)
+            - "explicit": The parser will return all derivations wrapped in "_ambig" tree nodes (i.e. a forest).
+            - "forest": The parser will return the root of the shared packed parse forest.
+
+    **=== Misc. / Domain Specific Options ===**
+
+    postlex
+            Lexer post-processing (Default: ``None``) Only works with the basic and contextual lexers.
+    priority
+            How priorities should be evaluated - "auto", ``None``, "normal", "invert" (Default: "auto")
+    lexer_callbacks
+            Dictionary of callbacks for the lexer. May alter tokens during lexing. Use with caution.
+    use_bytes
+            Accept an input of type ``bytes`` instead of ``str``.
+    ordered_sets
+            Should Earley use ordered-sets to achieve stable output (~10% slower than regular sets. Default: True)
+    edit_terminals
+            A callback for editing the terminals before parse.
+    import_paths
+            A List of either paths or loader functions to specify from where grammars are imported
+    source_path
+            Override the source of from where the grammar was loaded. Useful for relative imports and unconventional grammar loading
+    **=== End of Options ===**
+    """
+    if __doc__:
+        __doc__ += OPTIONS_DOC
+
+
+    # Adding a new option needs to be done in multiple places:
+    # - In the dictionary below. This is the primary truth of which options `Lark.__init__` accepts
+    # - In the docstring above. It is used both for the docstring of `LarkOptions` and `Lark`, and in readthedocs
+    # - As an attribute of `LarkOptions` above
+    # - Potentially in `_LOAD_ALLOWED_OPTIONS` below this class, when the option doesn't change how the grammar is loaded
+    # - Potentially in `lark.tools.__init__`, if it makes sense, and it can easily be passed as a cmd argument
+    _defaults: Dict[str, Any] = {
+        'debug': False,
+        'strict': False,
+        'keep_all_tokens': False,
+        'tree_class': None,
+        'cache': False,
+        'postlex': None,
+        'parser': 'earley',
+        'lexer': 'auto',
+        'transformer': None,
+        'start': 'start',
+        'priority': 'auto',
+        'ambiguity': 'auto',
+        'regex': False,
+        'propagate_positions': False,
+        'lexer_callbacks': {},
+        'maybe_placeholders': True,
+        'edit_terminals': None,
+        'g_regex_flags': 0,
+        'use_bytes': False,
+        'ordered_sets': True,
+        'import_paths': [],
+        'source_path': None,
+        '_plugins': {},
+    }
+
+    def __init__(self, options_dict: Dict[str, Any]) -> None:
+        o = dict(options_dict)
+
+        options = {}
+        for name, default in self._defaults.items():
+            if name in o:
+                value = o.pop(name)
+                if isinstance(default, bool) and name not in ('cache', 'use_bytes', 'propagate_positions'):
+                    value = bool(value)
+            else:
+                value = default
+
+            options[name] = value
+
+        if isinstance(options['start'], str):
+            options['start'] = [options['start']]
+
+        self.__dict__['options'] = options
+
+
+        assert_config(self.parser, ('earley', 'lalr', 'cyk', None))
+
+        if self.parser == 'earley' and self.transformer:
+            raise ConfigurationError('Cannot specify an embedded transformer when using the Earley algorithm. '
+                             'Please use your transformer on the resulting parse tree, or use a different algorithm (i.e. LALR)')
+
+        if o:
+            raise ConfigurationError("Unknown options: %s" % o.keys())
+
+    def __getattr__(self, name: str) -> Any:
+        try:
+            return self.__dict__['options'][name]
+        except KeyError as e:
+            raise AttributeError(e)
+
+    def __setattr__(self, name: str, value: str) -> None:
+        assert_config(name, self.options.keys(), "%r isn't a valid option. Expected one of: %s")
+        self.options[name] = value
+
+    def serialize(self, memo = None) -> Dict[str, Any]:
+        return self.options
+
+    @classmethod
+    def deserialize(cls, data: Dict[str, Any], memo: Dict[int, Union[TerminalDef, Rule]]) -> "LarkOptions":
+        return cls(data)
+
+
+# Options that can be passed to the Lark parser, even when it was loaded from cache/standalone.
+# These options are only used outside of `load_grammar`.
+_LOAD_ALLOWED_OPTIONS = {'postlex', 'transformer', 'lexer_callbacks', 'use_bytes', 'debug', 'g_regex_flags', 'regex', 'propagate_positions', 'tree_class', '_plugins'}
+
+_VALID_PRIORITY_OPTIONS = ('auto', 'normal', 'invert', None)
+_VALID_AMBIGUITY_OPTIONS = ('auto', 'resolve', 'explicit', 'forest')
+
+
+_T = TypeVar('_T', bound="Lark")
+
+class Lark(Serialize):
+    """Main interface for the library.
+
+    It's mostly a thin wrapper for the many different parsers, and for the tree constructor.
+
+    Parameters:
+        grammar: a string or file-object containing the grammar spec (using Lark's ebnf syntax)
+        options: a dictionary controlling various aspects of Lark.
+
+    Example:
+        >>> Lark(r'''start: "foo" ''')
+        Lark(...)
+    """
+
+    source_path: str
+    source_grammar: str
+    grammar: 'Grammar'
+    options: LarkOptions
+    lexer: Lexer
+    parser: 'ParsingFrontend'
+    terminals: Collection[TerminalDef]
+
+    def __init__(self, grammar: 'Union[Grammar, str, IO[str]]', **options) -> None:
+        self.options = LarkOptions(options)
+        re_module: types.ModuleType
+
+        # Set regex or re module
+        use_regex = self.options.regex
+        if use_regex:
+            if _has_regex:
+                re_module = regex
+            else:
+                raise ImportError('`regex` module must be installed if calling `Lark(regex=True)`.')
+        else:
+            re_module = re
+
+        # Some, but not all file-like objects have a 'name' attribute
+        if self.options.source_path is None:
+            try:
+                self.source_path = grammar.name  # type: ignore[union-attr]
+            except AttributeError:
+                self.source_path = '<string>'
+        else:
+            self.source_path = self.options.source_path
+
+        # Drain file-like objects to get their contents
+        try:
+            read = grammar.read  # type: ignore[union-attr]
+        except AttributeError:
+            pass
+        else:
+            grammar = read()
+
+        cache_fn = None
+        cache_sha256 = None
+        if isinstance(grammar, str):
+            self.source_grammar = grammar
+            if self.options.use_bytes:
+                if not isascii(grammar):
+                    raise ConfigurationError("Grammar must be ascii only, when use_bytes=True")
+
+            if self.options.cache:
+                if self.options.parser != 'lalr':
+                    raise ConfigurationError("cache only works with parser='lalr' for now")
+
+                unhashable = ('transformer', 'postlex', 'lexer_callbacks', 'edit_terminals', '_plugins')
+                options_str = ''.join(k+str(v) for k, v in options.items() if k not in unhashable)
+                from . import __version__
+                s = grammar + options_str + __version__ + str(sys.version_info[:2])
+                cache_sha256 = sha256_digest(s)
+
+                if isinstance(self.options.cache, str):
+                    cache_fn = self.options.cache
+                else:
+                    if self.options.cache is not True:
+                        raise ConfigurationError("cache argument must be bool or str")
+
+                    try:
+                        username = getpass.getuser()
+                    except Exception:
+                        # The exception raised may be ImportError or OSError in
+                        # the future.  For the cache, we don't care about the
+                        # specific reason - we just want a username.
+                        username = "unknown"
+
+                    cache_fn = tempfile.gettempdir() + "/.lark_cache_%s_%s_%s_%s.tmp" % (username, cache_sha256, *sys.version_info[:2])
+
+                old_options = self.options
+                try:
+                    with FS.open(cache_fn, 'rb') as f:
+                        logger.debug('Loading grammar from cache: %s', cache_fn)
+                        # Remove options that aren't relevant for loading from cache
+                        for name in (set(options) - _LOAD_ALLOWED_OPTIONS):
+                            del options[name]
+                        file_sha256 = f.readline().rstrip(b'\n')
+                        cached_used_files = pickle.load(f)
+                        if file_sha256 == cache_sha256.encode('utf8') and verify_used_files(cached_used_files):
+                            cached_parser_data = pickle.load(f)
+                            self._load(cached_parser_data, **options)
+                            return
+                except FileNotFoundError:
+                    # The cache file doesn't exist; parse and compose the grammar as normal
+                    pass
+                except Exception: # We should probably narrow done which errors we catch here.
+                    logger.exception("Failed to load Lark from cache: %r. We will try to carry on.", cache_fn)
+
+                    # In theory, the Lark instance might have been messed up by the call to `_load`.
+                    # In practice the only relevant thing that might have been overwritten should be `options`
+                    self.options = old_options
+
+
+            # Parse the grammar file and compose the grammars
+            self.grammar, used_files = load_grammar(grammar, self.source_path, self.options.import_paths, self.options.keep_all_tokens)
+        else:
+            assert isinstance(grammar, Grammar)
+            self.grammar = grammar
+
+
+        if self.options.lexer == 'auto':
+            if self.options.parser == 'lalr':
+                self.options.lexer = 'contextual'
+            elif self.options.parser == 'earley':
+                if self.options.postlex is not None:
+                    logger.info("postlex can't be used with the dynamic lexer, so we use 'basic' instead. "
+                                "Consider using lalr with contextual instead of earley")
+                    self.options.lexer = 'basic'
+                else:
+                    self.options.lexer = 'dynamic'
+            elif self.options.parser == 'cyk':
+                self.options.lexer = 'basic'
+            else:
+                assert False, self.options.parser
+        lexer = self.options.lexer
+        if isinstance(lexer, type):
+            assert issubclass(lexer, Lexer)     # XXX Is this really important? Maybe just ensure interface compliance
+        else:
+            assert_config(lexer, ('basic', 'contextual', 'dynamic', 'dynamic_complete'))
+            if self.options.postlex is not None and 'dynamic' in lexer:
+                raise ConfigurationError("Can't use postlex with a dynamic lexer. Use basic or contextual instead")
+
+        if self.options.ambiguity == 'auto':
+            if self.options.parser == 'earley':
+                self.options.ambiguity = 'resolve'
+        else:
+            assert_config(self.options.parser, ('earley', 'cyk'), "%r doesn't support disambiguation. Use one of these parsers instead: %s")
+
+        if self.options.priority == 'auto':
+            self.options.priority = 'normal'
+
+        if self.options.priority not in _VALID_PRIORITY_OPTIONS:
+            raise ConfigurationError("invalid priority option: %r. Must be one of %r" % (self.options.priority, _VALID_PRIORITY_OPTIONS))
+        if self.options.ambiguity not in _VALID_AMBIGUITY_OPTIONS:
+            raise ConfigurationError("invalid ambiguity option: %r. Must be one of %r" % (self.options.ambiguity, _VALID_AMBIGUITY_OPTIONS))
+
+        if self.options.parser is None:
+            terminals_to_keep = '*'
+        elif self.options.postlex is not None:
+            terminals_to_keep = set(self.options.postlex.always_accept)
+        else:
+            terminals_to_keep = set()
+
+        # Compile the EBNF grammar into BNF
+        self.terminals, self.rules, self.ignore_tokens = self.grammar.compile(self.options.start, terminals_to_keep)
+
+        if self.options.edit_terminals:
+            for t in self.terminals:
+                self.options.edit_terminals(t)
+
+        self._terminals_dict = {t.name: t for t in self.terminals}
+
+        # If the user asked to invert the priorities, negate them all here.
+        if self.options.priority == 'invert':
+            for rule in self.rules:
+                if rule.options.priority is not None:
+                    rule.options.priority = -rule.options.priority
+            for term in self.terminals:
+                term.priority = -term.priority
+        # Else, if the user asked to disable priorities, strip them from the
+        # rules and terminals. This allows the Earley parsers to skip an extra forest walk
+        # for improved performance, if you don't need them (or didn't specify any).
+        elif self.options.priority is None:
+            for rule in self.rules:
+                if rule.options.priority is not None:
+                    rule.options.priority = None
+            for term in self.terminals:
+                term.priority = 0
+
+        # TODO Deprecate lexer_callbacks?
+        self.lexer_conf = LexerConf(
+                self.terminals, re_module, self.ignore_tokens, self.options.postlex,
+                self.options.lexer_callbacks, self.options.g_regex_flags, use_bytes=self.options.use_bytes, strict=self.options.strict
+            )
+
+        if self.options.parser:
+            self.parser = self._build_parser()
+        elif lexer:
+            self.lexer = self._build_lexer()
+
+        if cache_fn:
+            logger.debug('Saving grammar to cache: %s', cache_fn)
+            try:
+                with FS.open(cache_fn, 'wb') as f:
+                    assert cache_sha256 is not None
+                    f.write(cache_sha256.encode('utf8') + b'\n')
+                    pickle.dump(used_files, f)
+                    self.save(f, _LOAD_ALLOWED_OPTIONS)
+            except IOError as e:
+                logger.exception("Failed to save Lark to cache: %r.", cache_fn, e)
+
+    if __doc__:
+        __doc__ += "\n\n" + LarkOptions.OPTIONS_DOC
+
+    __serialize_fields__ = 'parser', 'rules', 'options'
+
+    def _build_lexer(self, dont_ignore: bool=False) -> BasicLexer:
+        lexer_conf = self.lexer_conf
+        if dont_ignore:
+            from copy import copy
+            lexer_conf = copy(lexer_conf)
+            lexer_conf.ignore = ()
+        return BasicLexer(lexer_conf)
+
+    def _prepare_callbacks(self) -> None:
+        self._callbacks = {}
+        # we don't need these callbacks if we aren't building a tree
+        if self.options.ambiguity != 'forest':
+            self._parse_tree_builder = ParseTreeBuilder(
+                    self.rules,
+                    self.options.tree_class or Tree,
+                    self.options.propagate_positions,
+                    self.options.parser != 'lalr' and self.options.ambiguity == 'explicit',
+                    self.options.maybe_placeholders
+                )
+            self._callbacks = self._parse_tree_builder.create_callback(self.options.transformer)
+        self._callbacks.update(_get_lexer_callbacks(self.options.transformer, self.terminals))
+
+    def _build_parser(self) -> "ParsingFrontend":
+        self._prepare_callbacks()
+        _validate_frontend_args(self.options.parser, self.options.lexer)
+        parser_conf = ParserConf(self.rules, self._callbacks, self.options.start)
+        return _construct_parsing_frontend(
+            self.options.parser,
+            self.options.lexer,
+            self.lexer_conf,
+            parser_conf,
+            options=self.options
+        )
+
+    def save(self, f, exclude_options: Collection[str] = ()) -> None:
+        """Saves the instance into the given file object
+
+        Useful for caching and multiprocessing.
+        """
+        if self.options.parser != 'lalr':
+            raise NotImplementedError("Lark.save() is only implemented for the LALR(1) parser.")
+        data, m = self.memo_serialize([TerminalDef, Rule])
+        if exclude_options:
+            data["options"] = {n: v for n, v in data["options"].items() if n not in exclude_options}
+        pickle.dump({'data': data, 'memo': m}, f, protocol=pickle.HIGHEST_PROTOCOL)
+
+    @classmethod
+    def load(cls: Type[_T], f) -> _T:
+        """Loads an instance from the given file object
+
+        Useful for caching and multiprocessing.
+        """
+        inst = cls.__new__(cls)
+        return inst._load(f)
+
+    def _deserialize_lexer_conf(self, data: Dict[str, Any], memo: Dict[int, Union[TerminalDef, Rule]], options: LarkOptions) -> LexerConf:
+        lexer_conf = LexerConf.deserialize(data['lexer_conf'], memo)
+        lexer_conf.callbacks = options.lexer_callbacks or {}
+        lexer_conf.re_module = regex if options.regex else re
+        lexer_conf.use_bytes = options.use_bytes
+        lexer_conf.g_regex_flags = options.g_regex_flags
+        lexer_conf.skip_validation = True
+        lexer_conf.postlex = options.postlex
+        return lexer_conf
+
+    def _load(self: _T, f: Any, **kwargs) -> _T:
+        if isinstance(f, dict):
+            d = f
+        else:
+            d = pickle.load(f)
+        memo_json = d['memo']
+        data = d['data']
+
+        assert memo_json
+        memo = SerializeMemoizer.deserialize(memo_json, {'Rule': Rule, 'TerminalDef': TerminalDef}, {})
+        options = dict(data['options'])
+        if (set(kwargs) - _LOAD_ALLOWED_OPTIONS) & set(LarkOptions._defaults):
+            raise ConfigurationError("Some options are not allowed when loading a Parser: {}"
+                             .format(set(kwargs) - _LOAD_ALLOWED_OPTIONS))
+        options.update(kwargs)
+        self.options = LarkOptions.deserialize(options, memo)
+        self.rules = [Rule.deserialize(r, memo) for r in data['rules']]
+        self.source_path = '<deserialized>'
+        _validate_frontend_args(self.options.parser, self.options.lexer)
+        self.lexer_conf = self._deserialize_lexer_conf(data['parser'], memo, self.options)
+        self.terminals = self.lexer_conf.terminals
+        self._prepare_callbacks()
+        self._terminals_dict = {t.name: t for t in self.terminals}
+        self.parser = _deserialize_parsing_frontend(
+            data['parser'],
+            memo,
+            self.lexer_conf,
+            self._callbacks,
+            self.options,  # Not all, but multiple attributes are used
+        )
+        return self
+
+    @classmethod
+    def _load_from_dict(cls, data, memo, **kwargs):
+        inst = cls.__new__(cls)
+        return inst._load({'data': data, 'memo': memo}, **kwargs)
+
+    @classmethod
+    def open(cls: Type[_T], grammar_filename: str, rel_to: Optional[str]=None, **options) -> _T:
+        """Create an instance of Lark with the grammar given by its filename
+
+        If ``rel_to`` is provided, the function will find the grammar filename in relation to it.
+
+        Example:
+
+            >>> Lark.open("grammar_file.lark", rel_to=__file__, parser="lalr")
+            Lark(...)
+
+        """
+        if rel_to:
+            basepath = os.path.dirname(rel_to)
+            grammar_filename = os.path.join(basepath, grammar_filename)
+        with open(grammar_filename, encoding='utf8') as f:
+            return cls(f, **options)
+
+    @classmethod
+    def open_from_package(cls: Type[_T], package: str, grammar_path: str, search_paths: 'Sequence[str]'=[""], **options) -> _T:
+        """Create an instance of Lark with the grammar loaded from within the package `package`.
+        This allows grammar loading from zipapps.
+
+        Imports in the grammar will use the `package` and `search_paths` provided, through `FromPackageLoader`
+
+        Example:
+
+            Lark.open_from_package(__name__, "example.lark", ("grammars",), parser=...)
+        """
+        package_loader = FromPackageLoader(package, search_paths)
+        full_path, text = package_loader(None, grammar_path)
+        options.setdefault('source_path', full_path)
+        options.setdefault('import_paths', [])
+        options['import_paths'].append(package_loader)
+        return cls(text, **options)
+
+    def __repr__(self):
+        return 'Lark(open(%r), parser=%r, lexer=%r, ...)' % (self.source_path, self.options.parser, self.options.lexer)
+
+
+    def lex(self, text: str, dont_ignore: bool=False) -> Iterator[Token]:
+        """Only lex (and postlex) the text, without parsing it. Only relevant when lexer='basic'
+
+        When dont_ignore=True, the lexer will return all tokens, even those marked for %ignore.
+
+        :raises UnexpectedCharacters: In case the lexer cannot find a suitable match.
+        """
+        lexer: Lexer
+        if not hasattr(self, 'lexer') or dont_ignore:
+            lexer = self._build_lexer(dont_ignore)
+        else:
+            lexer = self.lexer
+        lexer_thread = LexerThread.from_text(lexer, text)
+        stream = lexer_thread.lex(None)
+        if self.options.postlex:
+            return self.options.postlex.process(stream)
+        return stream
+
+    def get_terminal(self, name: str) -> TerminalDef:
+        """Get information about a terminal"""
+        return self._terminals_dict[name]
+
+    def parse_interactive(self, text: Optional[str]=None, start: Optional[str]=None) -> 'InteractiveParser':
+        """Start an interactive parsing session.
+
+        Parameters:
+            text (str, optional): Text to be parsed. Required for ``resume_parse()``.
+            start (str, optional): Start symbol
+
+        Returns:
+            A new InteractiveParser instance.
+
+        See Also: ``Lark.parse()``
+        """
+        return self.parser.parse_interactive(text, start=start)
+
+    def parse(self, text: str, start: Optional[str]=None, on_error: 'Optional[Callable[[UnexpectedInput], bool]]'=None) -> 'ParseTree':
+        """Parse the given text, according to the options provided.
+
+        Parameters:
+            text (str): Text to be parsed.
+            start (str, optional): Required if Lark was given multiple possible start symbols (using the start option).
+            on_error (function, optional): if provided, will be called on UnexpectedToken error. Return true to resume parsing.
+                LALR only. See examples/advanced/error_handling.py for an example of how to use on_error.
+
+        Returns:
+            If a transformer is supplied to ``__init__``, returns whatever is the
+            result of the transformation. Otherwise, returns a Tree instance.
+
+        :raises UnexpectedInput: On a parse error, one of these sub-exceptions will rise:
+                ``UnexpectedCharacters``, ``UnexpectedToken``, or ``UnexpectedEOF``.
+                For convenience, these sub-exceptions also inherit from ``ParserError`` and ``LexerError``.
+
+        """
+        return self.parser.parse(text, start=start, on_error=on_error)
+
+
+###}

shared/package-files/56/56678668d6a1892cc1253e114d7301f010ea40bbce65c8d67bfc518a620f3f62/blob

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

shared/package-files/56/5667c31dcece0b6d20cad709faa0d16a2a57ee42563742cfa16ea8c0cca4dc48/blob

@@ -0,0 +1,1331 @@
+from __future__ import annotations
+
+from datetime import timedelta
+import operator
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Literal,
+    TypeVar,
+    cast,
+    overload,
+)
+import warnings
+
+import numpy as np
+
+from pandas._libs import (
+    algos as libalgos,
+    lib,
+)
+from pandas._libs.arrays import NDArrayBacked
+from pandas._libs.tslibs import (
+    BaseOffset,
+    NaT,
+    NaTType,
+    Timedelta,
+    add_overflowsafe,
+    astype_overflowsafe,
+    dt64arr_to_periodarr as c_dt64arr_to_periodarr,
+    get_unit_from_dtype,
+    iNaT,
+    parsing,
+    period as libperiod,
+    to_offset,
+)
+from pandas._libs.tslibs.dtypes import (
+    FreqGroup,
+    PeriodDtypeBase,
+    freq_to_period_freqstr,
+)
+from pandas._libs.tslibs.fields import isleapyear_arr
+from pandas._libs.tslibs.offsets import (
+    Tick,
+    delta_to_tick,
+)
+from pandas._libs.tslibs.period import (
+    DIFFERENT_FREQ,
+    IncompatibleFrequency,
+    Period,
+    get_period_field_arr,
+    period_asfreq_arr,
+)
+from pandas.util._decorators import (
+    cache_readonly,
+    doc,
+)
+from pandas.util._exceptions import find_stack_level
+
+from pandas.core.dtypes.common import (
+    ensure_object,
+    pandas_dtype,
+)
+from pandas.core.dtypes.dtypes import (
+    DatetimeTZDtype,
+    PeriodDtype,
+)
+from pandas.core.dtypes.generic import (
+    ABCIndex,
+    ABCPeriodIndex,
+    ABCSeries,
+    ABCTimedeltaArray,
+)
+from pandas.core.dtypes.missing import isna
+
+from pandas.core.arrays import datetimelike as dtl
+import pandas.core.common as com
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from pandas._typing import (
+        AnyArrayLike,
+        Dtype,
+        FillnaOptions,
+        NpDtype,
+        NumpySorter,
+        NumpyValueArrayLike,
+        Self,
+        npt,
+    )
+
+    from pandas.core.arrays import (
+        DatetimeArray,
+        TimedeltaArray,
+    )
+    from pandas.core.arrays.base import ExtensionArray
+
+
+BaseOffsetT = TypeVar("BaseOffsetT", bound=BaseOffset)
+
+
+_shared_doc_kwargs = {
+    "klass": "PeriodArray",
+}
+
+
+def _field_accessor(name: str, docstring: str | None = None):
+    def f(self):
+        base = self.dtype._dtype_code
+        result = get_period_field_arr(name, self.asi8, base)
+        return result
+
+    f.__name__ = name
+    f.__doc__ = docstring
+    return property(f)
+
+
+# error: Definition of "_concat_same_type" in base class "NDArrayBacked" is
+# incompatible with definition in base class "ExtensionArray"
+class PeriodArray(dtl.DatelikeOps, libperiod.PeriodMixin):  # type: ignore[misc]
+    """
+    Pandas ExtensionArray for storing Period data.
+
+    Users should use :func:`~pandas.array` to create new instances.
+
+    Parameters
+    ----------
+    values : Union[PeriodArray, Series[period], ndarray[int], PeriodIndex]
+        The data to store. These should be arrays that can be directly
+        converted to ordinals without inference or copy (PeriodArray,
+        ndarray[int64]), or a box around such an array (Series[period],
+        PeriodIndex).
+    dtype : PeriodDtype, optional
+        A PeriodDtype instance from which to extract a `freq`. If both
+        `freq` and `dtype` are specified, then the frequencies must match.
+    freq : str or DateOffset
+        The `freq` to use for the array. Mostly applicable when `values`
+        is an ndarray of integers, when `freq` is required. When `values`
+        is a PeriodArray (or box around), it's checked that ``values.freq``
+        matches `freq`.
+    copy : bool, default False
+        Whether to copy the ordinals before storing.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    None
+
+    See Also
+    --------
+    Period: Represents a period of time.
+    PeriodIndex : Immutable Index for period data.
+    period_range: Create a fixed-frequency PeriodArray.
+    array: Construct a pandas array.
+
+    Notes
+    -----
+    There are two components to a PeriodArray
+
+    - ordinals : integer ndarray
+    - freq : pd.tseries.offsets.Offset
+
+    The values are physically stored as a 1-D ndarray of integers. These are
+    called "ordinals" and represent some kind of offset from a base.
+
+    The `freq` indicates the span covered by each element of the array.
+    All elements in the PeriodArray have the same `freq`.
+
+    Examples
+    --------
+    >>> pd.arrays.PeriodArray(pd.PeriodIndex(['2023-01-01',
+    ...                                       '2023-01-02'], freq='D'))
+    <PeriodArray>
+    ['2023-01-01', '2023-01-02']
+    Length: 2, dtype: period[D]
+    """
+
+    # array priority higher than numpy scalars
+    __array_priority__ = 1000
+    _typ = "periodarray"  # ABCPeriodArray
+    _internal_fill_value = np.int64(iNaT)
+    _recognized_scalars = (Period,)
+    _is_recognized_dtype = lambda x: isinstance(
+        x, PeriodDtype
+    )  # check_compatible_with checks freq match
+    _infer_matches = ("period",)
+
+    @property
+    def _scalar_type(self) -> type[Period]:
+        return Period
+
+    # Names others delegate to us
+    _other_ops: list[str] = []
+    _bool_ops: list[str] = ["is_leap_year"]
+    _object_ops: list[str] = ["start_time", "end_time", "freq"]
+    _field_ops: list[str] = [
+        "year",
+        "month",
+        "day",
+        "hour",
+        "minute",
+        "second",
+        "weekofyear",
+        "weekday",
+        "week",
+        "dayofweek",
+        "day_of_week",
+        "dayofyear",
+        "day_of_year",
+        "quarter",
+        "qyear",
+        "days_in_month",
+        "daysinmonth",
+    ]
+    _datetimelike_ops: list[str] = _field_ops + _object_ops + _bool_ops
+    _datetimelike_methods: list[str] = ["strftime", "to_timestamp", "asfreq"]
+
+    _dtype: PeriodDtype
+
+    # --------------------------------------------------------------------
+    # Constructors
+
+    def __init__(
+        self, values, dtype: Dtype | None = None, freq=None, copy: bool = False
+    ) -> None:
+        if freq is not None:
+            # GH#52462
+            warnings.warn(
+                "The 'freq' keyword in the PeriodArray constructor is deprecated "
+                "and will be removed in a future version. Pass 'dtype' instead",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+            freq = validate_dtype_freq(dtype, freq)
+            dtype = PeriodDtype(freq)
+
+        if dtype is not None:
+            dtype = pandas_dtype(dtype)
+            if not isinstance(dtype, PeriodDtype):
+                raise ValueError(f"Invalid dtype {dtype} for PeriodArray")
+
+        if isinstance(values, ABCSeries):
+            values = values._values
+            if not isinstance(values, type(self)):
+                raise TypeError("Incorrect dtype")
+
+        elif isinstance(values, ABCPeriodIndex):
+            values = values._values
+
+        if isinstance(values, type(self)):
+            if dtype is not None and dtype != values.dtype:
+                raise raise_on_incompatible(values, dtype.freq)
+            values, dtype = values._ndarray, values.dtype
+
+        if not copy:
+            values = np.asarray(values, dtype="int64")
+        else:
+            values = np.array(values, dtype="int64", copy=copy)
+        if dtype is None:
+            raise ValueError("dtype is not specified and cannot be inferred")
+        dtype = cast(PeriodDtype, dtype)
+        NDArrayBacked.__init__(self, values, dtype)
+
+    # error: Signature of "_simple_new" incompatible with supertype "NDArrayBacked"
+    @classmethod
+    def _simple_new(  # type: ignore[override]
+        cls,
+        values: npt.NDArray[np.int64],
+        dtype: PeriodDtype,
+    ) -> Self:
+        # alias for PeriodArray.__init__
+        assertion_msg = "Should be numpy array of type i8"
+        assert isinstance(values, np.ndarray) and values.dtype == "i8", assertion_msg
+        return cls(values, dtype=dtype)
+
+    @classmethod
+    def _from_sequence(
+        cls,
+        scalars,
+        *,
+        dtype: Dtype | None = None,
+        copy: bool = False,
+    ) -> Self:
+        if dtype is not None:
+            dtype = pandas_dtype(dtype)
+        if dtype and isinstance(dtype, PeriodDtype):
+            freq = dtype.freq
+        else:
+            freq = None
+
+        if isinstance(scalars, cls):
+            validate_dtype_freq(scalars.dtype, freq)
+            if copy:
+                scalars = scalars.copy()
+            return scalars
+
+        periods = np.asarray(scalars, dtype=object)
+
+        freq = freq or libperiod.extract_freq(periods)
+        ordinals = libperiod.extract_ordinals(periods, freq)
+        dtype = PeriodDtype(freq)
+        return cls(ordinals, dtype=dtype)
+
+    @classmethod
+    def _from_sequence_of_strings(
+        cls, strings, *, dtype: Dtype | None = None, copy: bool = False
+    ) -> Self:
+        return cls._from_sequence(strings, dtype=dtype, copy=copy)
+
+    @classmethod
+    def _from_datetime64(cls, data, freq, tz=None) -> Self:
+        """
+        Construct a PeriodArray from a datetime64 array
+
+        Parameters
+        ----------
+        data : ndarray[datetime64[ns], datetime64[ns, tz]]
+        freq : str or Tick
+        tz : tzinfo, optional
+
+        Returns
+        -------
+        PeriodArray[freq]
+        """
+        if isinstance(freq, BaseOffset):
+            freq = freq_to_period_freqstr(freq.n, freq.name)
+        data, freq = dt64arr_to_periodarr(data, freq, tz)
+        dtype = PeriodDtype(freq)
+        return cls(data, dtype=dtype)
+
+    @classmethod
+    def _generate_range(cls, start, end, periods, freq):
+        periods = dtl.validate_periods(periods)
+
+        if freq is not None:
+            freq = Period._maybe_convert_freq(freq)
+
+        if start is not None or end is not None:
+            subarr, freq = _get_ordinal_range(start, end, periods, freq)
+        else:
+            raise ValueError("Not enough parameters to construct Period range")
+
+        return subarr, freq
+
+    @classmethod
+    def _from_fields(cls, *, fields: dict, freq) -> Self:
+        subarr, freq = _range_from_fields(freq=freq, **fields)
+        dtype = PeriodDtype(freq)
+        return cls._simple_new(subarr, dtype=dtype)
+
+    # -----------------------------------------------------------------
+    # DatetimeLike Interface
+
+    # error: Argument 1 of "_unbox_scalar" is incompatible with supertype
+    # "DatetimeLikeArrayMixin"; supertype defines the argument type as
+    # "Union[Union[Period, Any, Timedelta], NaTType]"
+    def _unbox_scalar(  # type: ignore[override]
+        self,
+        value: Period | NaTType,
+    ) -> np.int64:
+        if value is NaT:
+            # error: Item "Period" of "Union[Period, NaTType]" has no attribute "value"
+            return np.int64(value._value)  # type: ignore[union-attr]
+        elif isinstance(value, self._scalar_type):
+            self._check_compatible_with(value)
+            return np.int64(value.ordinal)
+        else:
+            raise ValueError(f"'value' should be a Period. Got '{value}' instead.")
+
+    def _scalar_from_string(self, value: str) -> Period:
+        return Period(value, freq=self.freq)
+
+    # error: Argument 1 of "_check_compatible_with" is incompatible with
+    # supertype "DatetimeLikeArrayMixin"; supertype defines the argument type
+    # as "Period | Timestamp | Timedelta | NaTType"
+    def _check_compatible_with(self, other: Period | NaTType | PeriodArray) -> None:  # type: ignore[override]
+        if other is NaT:
+            return
+        # error: Item "NaTType" of "Period | NaTType | PeriodArray" has no
+        # attribute "freq"
+        self._require_matching_freq(other.freq)  # type: ignore[union-attr]
+
+    # --------------------------------------------------------------------
+    # Data / Attributes
+
+    @cache_readonly
+    def dtype(self) -> PeriodDtype:
+        return self._dtype
+
+    # error: Cannot override writeable attribute with read-only property
+    @property  # type: ignore[override]
+    def freq(self) -> BaseOffset:
+        """
+        Return the frequency object for this PeriodArray.
+        """
+        return self.dtype.freq
+
+    @property
+    def freqstr(self) -> str:
+        return freq_to_period_freqstr(self.freq.n, self.freq.name)
+
+    def __array__(
+        self, dtype: NpDtype | None = None, copy: bool | None = None
+    ) -> np.ndarray:
+        if dtype == "i8":
+            # For NumPy 1.x compatibility we cannot use copy=None.  And
+            # `copy=False` has the meaning of `copy=None` here:
+            if not copy:
+                return np.asarray(self.asi8, dtype=dtype)
+            else:
+                return np.array(self.asi8, dtype=dtype)
+
+        if copy is False:
+            warnings.warn(
+                "Starting with NumPy 2.0, the behavior of the 'copy' keyword has "
+                "changed and passing 'copy=False' raises an error when returning "
+                "a zero-copy NumPy array is not possible. pandas will follow "
+                "this behavior starting with pandas 3.0.\nThis conversion to "
+                "NumPy requires a copy, but 'copy=False' was passed. Consider "
+                "using 'np.asarray(..)' instead.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+
+        if dtype == bool:
+            return ~self._isnan
+
+        # This will raise TypeError for non-object dtypes
+        return np.array(list(self), dtype=object)
+
+    def __arrow_array__(self, type=None):
+        """
+        Convert myself into a pyarrow Array.
+        """
+        import pyarrow
+
+        from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
+
+        if type is not None:
+            if pyarrow.types.is_integer(type):
+                return pyarrow.array(self._ndarray, mask=self.isna(), type=type)
+            elif isinstance(type, ArrowPeriodType):
+                # ensure we have the same freq
+                if self.freqstr != type.freq:
+                    raise TypeError(
+                        "Not supported to convert PeriodArray to array with different "
+                        f"'freq' ({self.freqstr} vs {type.freq})"
+                    )
+            else:
+                raise TypeError(
+                    f"Not supported to convert PeriodArray to '{type}' type"
+                )
+
+        period_type = ArrowPeriodType(self.freqstr)
+        storage_array = pyarrow.array(self._ndarray, mask=self.isna(), type="int64")
+        return pyarrow.ExtensionArray.from_storage(period_type, storage_array)
+
+    # --------------------------------------------------------------------
+    # Vectorized analogues of Period properties
+
+    year = _field_accessor(
+        "year",
+        """
+        The year of the period.
+
+        Examples
+        --------
+        >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y")
+        >>> idx.year
+        Index([2023, 2024, 2025], dtype='int64')
+        """,
+    )
+    month = _field_accessor(
+        "month",
+        """
+        The month as January=1, December=12.
+
+        Examples
+        --------
+        >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M")
+        >>> idx.month
+        Index([1, 2, 3], dtype='int64')
+        """,
+    )
+    day = _field_accessor(
+        "day",
+        """
+        The days of the period.
+
+        Examples
+        --------
+        >>> idx = pd.PeriodIndex(['2020-01-31', '2020-02-28'], freq='D')
+        >>> idx.day
+        Index([31, 28], dtype='int64')
+        """,
+    )
+    hour = _field_accessor(
+        "hour",
+        """
+        The hour of the period.
+
+        Examples
+        --------
+        >>> idx = pd.PeriodIndex(["2023-01-01 10:00", "2023-01-01 11:00"], freq='h')
+        >>> idx.hour
+        Index([10, 11], dtype='int64')
+        """,
+    )
+    minute = _field_accessor(
+        "minute",
+        """
+        The minute of the period.
+
+        Examples
+        --------
+        >>> idx = pd.PeriodIndex(["2023-01-01 10:30:00",
+        ...                       "2023-01-01 11:50:00"], freq='min')
+        >>> idx.minute
+        Index([30, 50], dtype='int64')
+        """,
+    )
+    second = _field_accessor(
+        "second",
+        """
+        The second of the period.
+
+        Examples
+        --------
+        >>> idx = pd.PeriodIndex(["2023-01-01 10:00:30",
+        ...                       "2023-01-01 10:00:31"], freq='s')
+        >>> idx.second
+        Index([30, 31], dtype='int64')
+        """,
+    )
+    weekofyear = _field_accessor(
+        "week",
+        """
+        The week ordinal of the year.
+
+        Examples
+        --------
+        >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M")
+        >>> idx.week  # It can be written `weekofyear`
+        Index([5, 9, 13], dtype='int64')
+        """,
+    )
+    week = weekofyear
+    day_of_week = _field_accessor(
+        "day_of_week",
+        """
+        The day of the week with Monday=0, Sunday=6.
+
+        Examples
+        --------
+        >>> idx = pd.PeriodIndex(["2023-01-01", "2023-01-02", "2023-01-03"], freq="D")
+        >>> idx.weekday
+        Index([6, 0, 1], dtype='int64')
+        """,
+    )
+    dayofweek = day_of_week
+    weekday = dayofweek
+    dayofyear = day_of_year = _field_accessor(
+        "day_of_year",
+        """
+        The ordinal day of the year.
+
+        Examples
+        --------
+        >>> idx = pd.PeriodIndex(["2023-01-10", "2023-02-01", "2023-03-01"], freq="D")
+        >>> idx.dayofyear
+        Index([10, 32, 60], dtype='int64')
+
+        >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y")
+        >>> idx
+        PeriodIndex(['2023', '2024', '2025'], dtype='period[Y-DEC]')
+        >>> idx.dayofyear
+        Index([365, 366, 365], dtype='int64')
+        """,
+    )
+    quarter = _field_accessor(
+        "quarter",
+        """
+        The quarter of the date.
+
+        Examples
+        --------
+        >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M")
+        >>> idx.quarter
+        Index([1, 1, 1], dtype='int64')
+        """,
+    )
+    qyear = _field_accessor("qyear")
+    days_in_month = _field_accessor(
+        "days_in_month",
+        """
+        The number of days in the month.
+
+        Examples
+        --------
+        For Series:
+
+        >>> period = pd.period_range('2020-1-1 00:00', '2020-3-1 00:00', freq='M')
+        >>> s = pd.Series(period)
+        >>> s
+        0   2020-01
+        1   2020-02
+        2   2020-03
+        dtype: period[M]
+        >>> s.dt.days_in_month
+        0    31
+        1    29
+        2    31
+        dtype: int64
+
+        For PeriodIndex:
+
+        >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M")
+        >>> idx.days_in_month   # It can be also entered as `daysinmonth`
+        Index([31, 28, 31], dtype='int64')
+        """,
+    )
+    daysinmonth = days_in_month
+
+    @property
+    def is_leap_year(self) -> npt.NDArray[np.bool_]:
+        """
+        Logical indicating if the date belongs to a leap year.
+
+        Examples
+        --------
+        >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y")
+        >>> idx.is_leap_year
+        array([False,  True, False])
+        """
+        return isleapyear_arr(np.asarray(self.year))
+
+    def to_timestamp(self, freq=None, how: str = "start") -> DatetimeArray:
+        """
+        Cast to DatetimeArray/Index.
+
+        Parameters
+        ----------
+        freq : str or DateOffset, optional
+            Target frequency. The default is 'D' for week or longer,
+            's' otherwise.
+        how : {'s', 'e', 'start', 'end'}
+            Whether to use the start or end of the time period being converted.
+
+        Returns
+        -------
+        DatetimeArray/Index
+
+        Examples
+        --------
+        >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M")
+        >>> idx.to_timestamp()
+        DatetimeIndex(['2023-01-01', '2023-02-01', '2023-03-01'],
+        dtype='datetime64[ns]', freq='MS')
+        """
+        from pandas.core.arrays import DatetimeArray
+
+        how = libperiod.validate_end_alias(how)
+
+        end = how == "E"
+        if end:
+            if freq == "B" or self.freq == "B":
+                # roll forward to ensure we land on B date
+                adjust = Timedelta(1, "D") - Timedelta(1, "ns")
+                return self.to_timestamp(how="start") + adjust
+            else:
+                adjust = Timedelta(1, "ns")
+                return (self + self.freq).to_timestamp(how="start") - adjust
+
+        if freq is None:
+            freq_code = self._dtype._get_to_timestamp_base()
+            dtype = PeriodDtypeBase(freq_code, 1)
+            freq = dtype._freqstr
+            base = freq_code
+        else:
+            freq = Period._maybe_convert_freq(freq)
+            base = freq._period_dtype_code
+
+        new_parr = self.asfreq(freq, how=how)
+
+        new_data = libperiod.periodarr_to_dt64arr(new_parr.asi8, base)
+        dta = DatetimeArray._from_sequence(new_data)
+
+        if self.freq.name == "B":
+            # See if we can retain BDay instead of Day in cases where
+            #  len(self) is too small for infer_freq to distinguish between them
+            diffs = libalgos.unique_deltas(self.asi8)
+            if len(diffs) == 1:
+                diff = diffs[0]
+                if diff == self.dtype._n:
+                    dta._freq = self.freq
+                elif diff == 1:
+                    dta._freq = self.freq.base
+                # TODO: other cases?
+            return dta
+        else:
+            return dta._with_freq("infer")
+
+    # --------------------------------------------------------------------
+
+    def _box_func(self, x) -> Period | NaTType:
+        return Period._from_ordinal(ordinal=x, freq=self.freq)
+
+    @doc(**_shared_doc_kwargs, other="PeriodIndex", other_name="PeriodIndex")
+    def asfreq(self, freq=None, how: str = "E") -> Self:
+        """
+        Convert the {klass} to the specified frequency `freq`.
+
+        Equivalent to applying :meth:`pandas.Period.asfreq` with the given arguments
+        to each :class:`~pandas.Period` in this {klass}.
+
+        Parameters
+        ----------
+        freq : str
+            A frequency.
+        how : str {{'E', 'S'}}, default 'E'
+            Whether the elements should be aligned to the end
+            or start within pa period.
+
+            * 'E', 'END', or 'FINISH' for end,
+            * 'S', 'START', or 'BEGIN' for start.
+
+            January 31st ('END') vs. January 1st ('START') for example.
+
+        Returns
+        -------
+        {klass}
+            The transformed {klass} with the new frequency.
+
+        See Also
+        --------
+        {other}.asfreq: Convert each Period in a {other_name} to the given frequency.
+        Period.asfreq : Convert a :class:`~pandas.Period` object to the given frequency.
+
+        Examples
+        --------
+        >>> pidx = pd.period_range('2010-01-01', '2015-01-01', freq='Y')
+        >>> pidx
+        PeriodIndex(['2010', '2011', '2012', '2013', '2014', '2015'],
+        dtype='period[Y-DEC]')
+
+        >>> pidx.asfreq('M')
+        PeriodIndex(['2010-12', '2011-12', '2012-12', '2013-12', '2014-12',
+        '2015-12'], dtype='period[M]')
+
+        >>> pidx.asfreq('M', how='S')
+        PeriodIndex(['2010-01', '2011-01', '2012-01', '2013-01', '2014-01',
+        '2015-01'], dtype='period[M]')
+        """
+        how = libperiod.validate_end_alias(how)
+        if isinstance(freq, BaseOffset) and hasattr(freq, "_period_dtype_code"):
+            freq = PeriodDtype(freq)._freqstr
+        freq = Period._maybe_convert_freq(freq)
+
+        base1 = self._dtype._dtype_code
+        base2 = freq._period_dtype_code
+
+        asi8 = self.asi8
+        # self.freq.n can't be negative or 0
+        end = how == "E"
+        if end:
+            ordinal = asi8 + self.dtype._n - 1
+        else:
+            ordinal = asi8
+
+        new_data = period_asfreq_arr(ordinal, base1, base2, end)
+
+        if self._hasna:
+            new_data[self._isnan] = iNaT
+
+        dtype = PeriodDtype(freq)
+        return type(self)(new_data, dtype=dtype)
+
+    # ------------------------------------------------------------------
+    # Rendering Methods
+
+    def _formatter(self, boxed: bool = False):
+        if boxed:
+            return str
+        return "'{}'".format
+
+    def _format_native_types(
+        self, *, na_rep: str | float = "NaT", date_format=None, **kwargs
+    ) -> npt.NDArray[np.object_]:
+        """
+        actually format my specific types
+        """
+        return libperiod.period_array_strftime(
+            self.asi8, self.dtype._dtype_code, na_rep, date_format
+        )
+
+    # ------------------------------------------------------------------
+
+    def astype(self, dtype, copy: bool = True):
+        # We handle Period[T] -> Period[U]
+        # Our parent handles everything else.
+        dtype = pandas_dtype(dtype)
+        if dtype == self._dtype:
+            if not copy:
+                return self
+            else:
+                return self.copy()
+        if isinstance(dtype, PeriodDtype):
+            return self.asfreq(dtype.freq)
+
+        if lib.is_np_dtype(dtype, "M") or isinstance(dtype, DatetimeTZDtype):
+            # GH#45038 match PeriodIndex behavior.
+            tz = getattr(dtype, "tz", None)
+            unit = dtl.dtype_to_unit(dtype)
+            return self.to_timestamp().tz_localize(tz).as_unit(unit)
+
+        return super().astype(dtype, copy=copy)
+
+    def searchsorted(
+        self,
+        value: NumpyValueArrayLike | ExtensionArray,
+        side: Literal["left", "right"] = "left",
+        sorter: NumpySorter | None = None,
+    ) -> npt.NDArray[np.intp] | np.intp:
+        npvalue = self._validate_setitem_value(value).view("M8[ns]")
+
+        # Cast to M8 to get datetime-like NaT placement,
+        #  similar to dtl._period_dispatch
+        m8arr = self._ndarray.view("M8[ns]")
+        return m8arr.searchsorted(npvalue, side=side, sorter=sorter)
+
+    def _pad_or_backfill(
+        self,
+        *,
+        method: FillnaOptions,
+        limit: int | None = None,
+        limit_area: Literal["inside", "outside"] | None = None,
+        copy: bool = True,
+    ) -> Self:
+        # view as dt64 so we get treated as timelike in core.missing,
+        #  similar to dtl._period_dispatch
+        dta = self.view("M8[ns]")
+        result = dta._pad_or_backfill(
+            method=method, limit=limit, limit_area=limit_area, copy=copy
+        )
+        if copy:
+            return cast("Self", result.view(self.dtype))
+        else:
+            return self
+
+    def fillna(
+        self, value=None, method=None, limit: int | None = None, copy: bool = True
+    ) -> Self:
+        if method is not None:
+            # view as dt64 so we get treated as timelike in core.missing,
+            #  similar to dtl._period_dispatch
+            dta = self.view("M8[ns]")
+            result = dta.fillna(value=value, method=method, limit=limit, copy=copy)
+            # error: Incompatible return value type (got "Union[ExtensionArray,
+            # ndarray[Any, Any]]", expected "PeriodArray")
+            return result.view(self.dtype)  # type: ignore[return-value]
+        return super().fillna(value=value, method=method, limit=limit, copy=copy)
+
+    # ------------------------------------------------------------------
+    # Arithmetic Methods
+
+    def _addsub_int_array_or_scalar(
+        self, other: np.ndarray | int, op: Callable[[Any, Any], Any]
+    ) -> Self:
+        """
+        Add or subtract array of integers.
+
+        Parameters
+        ----------
+        other : np.ndarray[int64] or int
+        op : {operator.add, operator.sub}
+
+        Returns
+        -------
+        result : PeriodArray
+        """
+        assert op in [operator.add, operator.sub]
+        if op is operator.sub:
+            other = -other
+        res_values = add_overflowsafe(self.asi8, np.asarray(other, dtype="i8"))
+        return type(self)(res_values, dtype=self.dtype)
+
+    def _add_offset(self, other: BaseOffset):
+        assert not isinstance(other, Tick)
+
+        self._require_matching_freq(other, base=True)
+        return self._addsub_int_array_or_scalar(other.n, operator.add)
+
+    # TODO: can we de-duplicate with Period._add_timedeltalike_scalar?
+    def _add_timedeltalike_scalar(self, other):
+        """
+        Parameters
+        ----------
+        other : timedelta, Tick, np.timedelta64
+
+        Returns
+        -------
+        PeriodArray
+        """
+        if not isinstance(self.freq, Tick):
+            # We cannot add timedelta-like to non-tick PeriodArray
+            raise raise_on_incompatible(self, other)
+
+        if isna(other):
+            # i.e. np.timedelta64("NaT")
+            return super()._add_timedeltalike_scalar(other)
+
+        td = np.asarray(Timedelta(other).asm8)
+        return self._add_timedelta_arraylike(td)
+
+    def _add_timedelta_arraylike(
+        self, other: TimedeltaArray | npt.NDArray[np.timedelta64]
+    ) -> Self:
+        """
+        Parameters
+        ----------
+        other : TimedeltaArray or ndarray[timedelta64]
+
+        Returns
+        -------
+        PeriodArray
+        """
+        if not self.dtype._is_tick_like():
+            # We cannot add timedelta-like to non-tick PeriodArray
+            raise TypeError(
+                f"Cannot add or subtract timedelta64[ns] dtype from {self.dtype}"
+            )
+
+        dtype = np.dtype(f"m8[{self.dtype._td64_unit}]")
+
+        # Similar to _check_timedeltalike_freq_compat, but we raise with a
+        #  more specific exception message if necessary.
+        try:
+            delta = astype_overflowsafe(
+                np.asarray(other), dtype=dtype, copy=False, round_ok=False
+            )
+        except ValueError as err:
+            # e.g. if we have minutes freq and try to add 30s
+            # "Cannot losslessly convert units"
+            raise IncompatibleFrequency(
+                "Cannot add/subtract timedelta-like from PeriodArray that is "
+                "not an integer multiple of the PeriodArray's freq."
+            ) from err
+
+        res_values = add_overflowsafe(self.asi8, np.asarray(delta.view("i8")))
+        return type(self)(res_values, dtype=self.dtype)
+
+    def _check_timedeltalike_freq_compat(self, other):
+        """
+        Arithmetic operations with timedelta-like scalars or array `other`
+        are only valid if `other` is an integer multiple of `self.freq`.
+        If the operation is valid, find that integer multiple.  Otherwise,
+        raise because the operation is invalid.
+
+        Parameters
+        ----------
+        other : timedelta, np.timedelta64, Tick,
+                ndarray[timedelta64], TimedeltaArray, TimedeltaIndex
+
+        Returns
+        -------
+        multiple : int or ndarray[int64]
+
+        Raises
+        ------
+        IncompatibleFrequency
+        """
+        assert self.dtype._is_tick_like()  # checked by calling function
+
+        dtype = np.dtype(f"m8[{self.dtype._td64_unit}]")
+
+        if isinstance(other, (timedelta, np.timedelta64, Tick)):
+            td = np.asarray(Timedelta(other).asm8)
+        else:
+            td = np.asarray(other)
+
+        try:
+            delta = astype_overflowsafe(td, dtype=dtype, copy=False, round_ok=False)
+        except ValueError as err:
+            raise raise_on_incompatible(self, other) from err
+
+        delta = delta.view("i8")
+        return lib.item_from_zerodim(delta)
+
+
+def raise_on_incompatible(left, right) -> IncompatibleFrequency:
+    """
+    Helper function to render a consistent error message when raising
+    IncompatibleFrequency.
+
+    Parameters
+    ----------
+    left : PeriodArray
+    right : None, DateOffset, Period, ndarray, or timedelta-like
+
+    Returns
+    -------
+    IncompatibleFrequency
+        Exception to be raised by the caller.
+    """
+    # GH#24283 error message format depends on whether right is scalar
+    if isinstance(right, (np.ndarray, ABCTimedeltaArray)) or right is None:
+        other_freq = None
+    elif isinstance(right, BaseOffset):
+        other_freq = freq_to_period_freqstr(right.n, right.name)
+    elif isinstance(right, (ABCPeriodIndex, PeriodArray, Period)):
+        other_freq = right.freqstr
+    else:
+        other_freq = delta_to_tick(Timedelta(right)).freqstr
+
+    own_freq = freq_to_period_freqstr(left.freq.n, left.freq.name)
+    msg = DIFFERENT_FREQ.format(
+        cls=type(left).__name__, own_freq=own_freq, other_freq=other_freq
+    )
+    return IncompatibleFrequency(msg)
+
+
+# -------------------------------------------------------------------
+# Constructor Helpers
+
+
+def period_array(
+    data: Sequence[Period | str | None] | AnyArrayLike,
+    freq: str | Tick | BaseOffset | None = None,
+    copy: bool = False,
+) -> PeriodArray:
+    """
+    Construct a new PeriodArray from a sequence of Period scalars.
+
+    Parameters
+    ----------
+    data : Sequence of Period objects
+        A sequence of Period objects. These are required to all have
+        the same ``freq.`` Missing values can be indicated by ``None``
+        or ``pandas.NaT``.
+    freq : str, Tick, or Offset
+        The frequency of every element of the array. This can be specified
+        to avoid inferring the `freq` from `data`.
+    copy : bool, default False
+        Whether to ensure a copy of the data is made.
+
+    Returns
+    -------
+    PeriodArray
+
+    See Also
+    --------
+    PeriodArray
+    pandas.PeriodIndex
+
+    Examples
+    --------
+    >>> period_array([pd.Period('2017', freq='Y'),
+    ...               pd.Period('2018', freq='Y')])
+    <PeriodArray>
+    ['2017', '2018']
+    Length: 2, dtype: period[Y-DEC]
+
+    >>> period_array([pd.Period('2017', freq='Y'),
+    ...               pd.Period('2018', freq='Y'),
+    ...               pd.NaT])
+    <PeriodArray>
+    ['2017', '2018', 'NaT']
+    Length: 3, dtype: period[Y-DEC]
+
+    Integers that look like years are handled
+
+    >>> period_array([2000, 2001, 2002], freq='D')
+    <PeriodArray>
+    ['2000-01-01', '2001-01-01', '2002-01-01']
+    Length: 3, dtype: period[D]
+
+    Datetime-like strings may also be passed
+
+    >>> period_array(['2000-Q1', '2000-Q2', '2000-Q3', '2000-Q4'], freq='Q')
+    <PeriodArray>
+    ['2000Q1', '2000Q2', '2000Q3', '2000Q4']
+    Length: 4, dtype: period[Q-DEC]
+    """
+    data_dtype = getattr(data, "dtype", None)
+
+    if lib.is_np_dtype(data_dtype, "M"):
+        return PeriodArray._from_datetime64(data, freq)
+    if isinstance(data_dtype, PeriodDtype):
+        out = PeriodArray(data)
+        if freq is not None:
+            if freq == data_dtype.freq:
+                return out
+            return out.asfreq(freq)
+        return out
+
+    # other iterable of some kind
+    if not isinstance(data, (np.ndarray, list, tuple, ABCSeries)):
+        data = list(data)
+
+    arrdata = np.asarray(data)
+
+    dtype: PeriodDtype | None
+    if freq:
+        dtype = PeriodDtype(freq)
+    else:
+        dtype = None
+
+    if arrdata.dtype.kind == "f" and len(arrdata) > 0:
+        raise TypeError("PeriodIndex does not allow floating point in construction")
+
+    if arrdata.dtype.kind in "iu":
+        arr = arrdata.astype(np.int64, copy=False)
+        # error: Argument 2 to "from_ordinals" has incompatible type "Union[str,
+        # Tick, None]"; expected "Union[timedelta, BaseOffset, str]"
+        ordinals = libperiod.from_ordinals(arr, freq)  # type: ignore[arg-type]
+        return PeriodArray(ordinals, dtype=dtype)
+
+    data = ensure_object(arrdata)
+    if freq is None:
+        freq = libperiod.extract_freq(data)
+    dtype = PeriodDtype(freq)
+    return PeriodArray._from_sequence(data, dtype=dtype)
+
+
+@overload
+def validate_dtype_freq(dtype, freq: BaseOffsetT) -> BaseOffsetT:
+    ...
+
+
+@overload
+def validate_dtype_freq(dtype, freq: timedelta | str | None) -> BaseOffset:
+    ...
+
+
+def validate_dtype_freq(
+    dtype, freq: BaseOffsetT | BaseOffset | timedelta | str | None
+) -> BaseOffsetT:
+    """
+    If both a dtype and a freq are available, ensure they match.  If only
+    dtype is available, extract the implied freq.
+
+    Parameters
+    ----------
+    dtype : dtype
+    freq : DateOffset or None
+
+    Returns
+    -------
+    freq : DateOffset
+
+    Raises
+    ------
+    ValueError : non-period dtype
+    IncompatibleFrequency : mismatch between dtype and freq
+    """
+    if freq is not None:
+        freq = to_offset(freq, is_period=True)
+
+    if dtype is not None:
+        dtype = pandas_dtype(dtype)
+        if not isinstance(dtype, PeriodDtype):
+            raise ValueError("dtype must be PeriodDtype")
+        if freq is None:
+            freq = dtype.freq
+        elif freq != dtype.freq:
+            raise IncompatibleFrequency("specified freq and dtype are different")
+    # error: Incompatible return value type (got "Union[BaseOffset, Any, None]",
+    # expected "BaseOffset")
+    return freq  # type: ignore[return-value]
+
+
+def dt64arr_to_periodarr(
+    data, freq, tz=None
+) -> tuple[npt.NDArray[np.int64], BaseOffset]:
+    """
+    Convert an datetime-like array to values Period ordinals.
+
+    Parameters
+    ----------
+    data : Union[Series[datetime64[ns]], DatetimeIndex, ndarray[datetime64ns]]
+    freq : Optional[Union[str, Tick]]
+        Must match the `freq` on the `data` if `data` is a DatetimeIndex
+        or Series.
+    tz : Optional[tzinfo]
+
+    Returns
+    -------
+    ordinals : ndarray[int64]
+    freq : Tick
+        The frequency extracted from the Series or DatetimeIndex if that's
+        used.
+
+    """
+    if not isinstance(data.dtype, np.dtype) or data.dtype.kind != "M":
+        raise ValueError(f"Wrong dtype: {data.dtype}")
+
+    if freq is None:
+        if isinstance(data, ABCIndex):
+            data, freq = data._values, data.freq
+        elif isinstance(data, ABCSeries):
+            data, freq = data._values, data.dt.freq
+
+    elif isinstance(data, (ABCIndex, ABCSeries)):
+        data = data._values
+
+    reso = get_unit_from_dtype(data.dtype)
+    freq = Period._maybe_convert_freq(freq)
+    base = freq._period_dtype_code
+    return c_dt64arr_to_periodarr(data.view("i8"), base, tz, reso=reso), freq
+
+
+def _get_ordinal_range(start, end, periods, freq, mult: int = 1):
+    if com.count_not_none(start, end, periods) != 2:
+        raise ValueError(
+            "Of the three parameters: start, end, and periods, "
+            "exactly two must be specified"
+        )
+
+    if freq is not None:
+        freq = to_offset(freq, is_period=True)
+        mult = freq.n
+
+    if start is not None:
+        start = Period(start, freq)
+    if end is not None:
+        end = Period(end, freq)
+
+    is_start_per = isinstance(start, Period)
+    is_end_per = isinstance(end, Period)
+
+    if is_start_per and is_end_per and start.freq != end.freq:
+        raise ValueError("start and end must have same freq")
+    if start is NaT or end is NaT:
+        raise ValueError("start and end must not be NaT")
+
+    if freq is None:
+        if is_start_per:
+            freq = start.freq
+        elif is_end_per:
+            freq = end.freq
+        else:  # pragma: no cover
+            raise ValueError("Could not infer freq from start/end")
+        mult = freq.n
+
+    if periods is not None:
+        periods = periods * mult
+        if start is None:
+            data = np.arange(
+                end.ordinal - periods + mult, end.ordinal + 1, mult, dtype=np.int64
+            )
+        else:
+            data = np.arange(
+                start.ordinal, start.ordinal + periods, mult, dtype=np.int64
+            )
+    else:
+        data = np.arange(start.ordinal, end.ordinal + 1, mult, dtype=np.int64)
+
+    return data, freq
+
+
+def _range_from_fields(
+    year=None,
+    month=None,
+    quarter=None,
+    day=None,
+    hour=None,
+    minute=None,
+    second=None,
+    freq=None,
+) -> tuple[np.ndarray, BaseOffset]:
+    if hour is None:
+        hour = 0
+    if minute is None:
+        minute = 0
+    if second is None:
+        second = 0
+    if day is None:
+        day = 1
+
+    ordinals = []
+
+    if quarter is not None:
+        if freq is None:
+            freq = to_offset("Q", is_period=True)
+            base = FreqGroup.FR_QTR.value
+        else:
+            freq = to_offset(freq, is_period=True)
+            base = libperiod.freq_to_dtype_code(freq)
+            if base != FreqGroup.FR_QTR.value:
+                raise AssertionError("base must equal FR_QTR")
+
+        freqstr = freq.freqstr
+        year, quarter = _make_field_arrays(year, quarter)
+        for y, q in zip(year, quarter):
+            calendar_year, calendar_month = parsing.quarter_to_myear(y, q, freqstr)
+            val = libperiod.period_ordinal(
+                calendar_year, calendar_month, 1, 1, 1, 1, 0, 0, base
+            )
+            ordinals.append(val)
+    else:
+        freq = to_offset(freq, is_period=True)
+        base = libperiod.freq_to_dtype_code(freq)
+        arrays = _make_field_arrays(year, month, day, hour, minute, second)
+        for y, mth, d, h, mn, s in zip(*arrays):
+            ordinals.append(libperiod.period_ordinal(y, mth, d, h, mn, s, 0, 0, base))
+
+    return np.array(ordinals, dtype=np.int64), freq
+
+
+def _make_field_arrays(*fields) -> list[np.ndarray]:
+    length = None
+    for x in fields:
+        if isinstance(x, (list, np.ndarray, ABCSeries)):
+            if length is not None and len(x) != length:
+                raise ValueError("Mismatched Period array lengths")
+            if length is None:
+                length = len(x)
+
+    # error: Argument 2 to "repeat" has incompatible type "Optional[int]"; expected
+    # "Union[Union[int, integer[Any]], Union[bool, bool_], ndarray, Sequence[Union[int,
+    # integer[Any]]], Sequence[Union[bool, bool_]], Sequence[Sequence[Any]]]"
+    return [
+        np.asarray(x)
+        if isinstance(x, (np.ndarray, list, ABCSeries))
+        else np.repeat(x, length)  # type: ignore[arg-type]
+        for x in fields
+    ]