Add files using upload-large-folder tool

shared/package-files/0d/0d42d2b355c4b47ac2c8b84dfe0f89f0f8af557b6f4b128dd97cf98116ca9122/__init__.py

@@ -0,0 +1,42 @@
+# --------------------------------------------------------------------------------------
+# Copyright (c) 2013-2026, Nucleic Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file LICENSE, distributed with this software.
+# --------------------------------------------------------------------------------------
+from ._cext import (
+    Constraint,
+    Expression,
+    Solver,
+    Term,
+    Variable,
+    __kiwi_version__,
+    __version__,
+    strength,
+)
+from .exceptions import (
+    BadRequiredStrength,
+    DuplicateConstraint,
+    DuplicateEditVariable,
+    UnknownConstraint,
+    UnknownEditVariable,
+    UnsatisfiableConstraint,
+)
+
+__all__ = [
+    "BadRequiredStrength",
+    "Constraint",
+    "DuplicateConstraint",
+    "DuplicateEditVariable",
+    "Expression",
+    "Solver",
+    "Term",
+    "UnknownConstraint",
+    "UnknownEditVariable",
+    "UnsatisfiableConstraint",
+    "Variable",
+    "__kiwi_version__",
+    "__version__",
+    "strength",
+]

shared/package-files/0d/0d85ddbbe8cc487ed7713a216dcf31f0d88a44bb695fd2142df636d288647df0/benchmark.pxi

@@ -0,0 +1,20 @@
+# 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.
+
+
+def benchmark_PandasObjectIsNull(list obj):
+    Benchmark_PandasObjectIsNull(obj)

shared/package-files/33/3300593114fb9286af9360cc9d871a40e5dcbea4aedc24b832607d1dd71c7b96/two_canvases.py

@@ -0,0 +1,54 @@
+"""turtledemo.two_canvases
+
+Use TurtleScreen and RawTurtle to draw on two
+distinct canvases in a separate window. The
+new window must be separately closed in
+addition to pressing the STOP button.
+"""
+
+from turtle import TurtleScreen, RawTurtle, TK
+
+def main():
+    root = TK.Tk()
+    cv1 = TK.Canvas(root, width=300, height=200, bg="#ddffff")
+    cv2 = TK.Canvas(root, width=300, height=200, bg="#ffeeee")
+    cv1.pack()
+    cv2.pack()
+
+    s1 = TurtleScreen(cv1)
+    s1.bgcolor(0.85, 0.85, 1)
+    s2 = TurtleScreen(cv2)
+    s2.bgcolor(1, 0.85, 0.85)
+
+    p = RawTurtle(s1)
+    q = RawTurtle(s2)
+
+    p.color("red", (1, 0.85, 0.85))
+    p.width(3)
+    q.color("blue", (0.85, 0.85, 1))
+    q.width(3)
+
+    for t in p,q:
+        t.shape("turtle")
+        t.lt(36)
+
+    q.lt(180)
+
+    for t in p, q:
+        t.begin_fill()
+    for i in range(5):
+        for t in p, q:
+            t.fd(50)
+            t.lt(72)
+    for t in p,q:
+        t.end_fill()
+        t.lt(54)
+        t.pu()
+        t.bk(50)
+
+    return "EVENTLOOP"
+
+
+if __name__ == '__main__':
+    main()
+    TK.mainloop()  # keep window open until user closes it

shared/package-files/33/33005b05ab9a5233626a36b6e6864ab7bbc8f5b4465df17994ad69fbc010ebb5/ciphers.py

@@ -0,0 +1,282 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+from __future__ import annotations
+
+import typing
+
+from cryptography.exceptions import InvalidTag, UnsupportedAlgorithm, _Reasons
+from cryptography.hazmat.primitives import ciphers
+from cryptography.hazmat.primitives.ciphers import algorithms, modes
+
+if typing.TYPE_CHECKING:
+    from cryptography.hazmat.backends.openssl.backend import Backend
+
+
+class _CipherContext:
+    _ENCRYPT = 1
+    _DECRYPT = 0
+    _MAX_CHUNK_SIZE = 2**29
+
+    def __init__(self, backend: Backend, cipher, mode, operation: int) -> None:
+        self._backend = backend
+        self._cipher = cipher
+        self._mode = mode
+        self._operation = operation
+        self._tag: bytes | None = None
+
+        if isinstance(self._cipher, ciphers.BlockCipherAlgorithm):
+            self._block_size_bytes = self._cipher.block_size // 8
+        else:
+            self._block_size_bytes = 1
+
+        ctx = self._backend._lib.EVP_CIPHER_CTX_new()
+        ctx = self._backend._ffi.gc(
+            ctx, self._backend._lib.EVP_CIPHER_CTX_free
+        )
+
+        registry = self._backend._cipher_registry
+        try:
+            adapter = registry[type(cipher), type(mode)]
+        except KeyError:
+            raise UnsupportedAlgorithm(
+                "cipher {} in {} mode is not supported "
+                "by this backend.".format(
+                    cipher.name, mode.name if mode else mode
+                ),
+                _Reasons.UNSUPPORTED_CIPHER,
+            )
+
+        evp_cipher = adapter(self._backend, cipher, mode)
+        if evp_cipher == self._backend._ffi.NULL:
+            msg = f"cipher {cipher.name} "
+            if mode is not None:
+                msg += f"in {mode.name} mode "
+            msg += (
+                "is not supported by this backend (Your version of OpenSSL "
+                "may be too old. Current version: {}.)"
+            ).format(self._backend.openssl_version_text())
+            raise UnsupportedAlgorithm(msg, _Reasons.UNSUPPORTED_CIPHER)
+
+        if isinstance(mode, modes.ModeWithInitializationVector):
+            iv_nonce = self._backend._ffi.from_buffer(
+                mode.initialization_vector
+            )
+        elif isinstance(mode, modes.ModeWithTweak):
+            iv_nonce = self._backend._ffi.from_buffer(mode.tweak)
+        elif isinstance(mode, modes.ModeWithNonce):
+            iv_nonce = self._backend._ffi.from_buffer(mode.nonce)
+        elif isinstance(cipher, algorithms.ChaCha20):
+            iv_nonce = self._backend._ffi.from_buffer(cipher.nonce)
+        else:
+            iv_nonce = self._backend._ffi.NULL
+        # begin init with cipher and operation type
+        res = self._backend._lib.EVP_CipherInit_ex(
+            ctx,
+            evp_cipher,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            operation,
+        )
+        self._backend.openssl_assert(res != 0)
+        # set the key length to handle variable key ciphers
+        res = self._backend._lib.EVP_CIPHER_CTX_set_key_length(
+            ctx, len(cipher.key)
+        )
+        self._backend.openssl_assert(res != 0)
+        if isinstance(mode, modes.GCM):
+            res = self._backend._lib.EVP_CIPHER_CTX_ctrl(
+                ctx,
+                self._backend._lib.EVP_CTRL_AEAD_SET_IVLEN,
+                len(iv_nonce),
+                self._backend._ffi.NULL,
+            )
+            self._backend.openssl_assert(res != 0)
+            if mode.tag is not None:
+                res = self._backend._lib.EVP_CIPHER_CTX_ctrl(
+                    ctx,
+                    self._backend._lib.EVP_CTRL_AEAD_SET_TAG,
+                    len(mode.tag),
+                    mode.tag,
+                )
+                self._backend.openssl_assert(res != 0)
+                self._tag = mode.tag
+
+        # pass key/iv
+        res = self._backend._lib.EVP_CipherInit_ex(
+            ctx,
+            self._backend._ffi.NULL,
+            self._backend._ffi.NULL,
+            self._backend._ffi.from_buffer(cipher.key),
+            iv_nonce,
+            operation,
+        )
+
+        # Check for XTS mode duplicate keys error
+        errors = self._backend._consume_errors()
+        lib = self._backend._lib
+        if res == 0 and (
+            (
+                not lib.CRYPTOGRAPHY_IS_LIBRESSL
+                and errors[0]._lib_reason_match(
+                    lib.ERR_LIB_EVP, lib.EVP_R_XTS_DUPLICATED_KEYS
+                )
+            )
+            or (
+                lib.Cryptography_HAS_PROVIDERS
+                and errors[0]._lib_reason_match(
+                    lib.ERR_LIB_PROV, lib.PROV_R_XTS_DUPLICATED_KEYS
+                )
+            )
+        ):
+            raise ValueError("In XTS mode duplicated keys are not allowed")
+
+        self._backend.openssl_assert(res != 0, errors=errors)
+
+        # We purposely disable padding here as it's handled higher up in the
+        # API.
+        self._backend._lib.EVP_CIPHER_CTX_set_padding(ctx, 0)
+        self._ctx = ctx
+
+    def update(self, data: bytes) -> bytes:
+        buf = bytearray(len(data) + self._block_size_bytes - 1)
+        n = self.update_into(data, buf)
+        return bytes(buf[:n])
+
+    def update_into(self, data: bytes, buf: bytes) -> int:
+        total_data_len = len(data)
+        if len(buf) < (total_data_len + self._block_size_bytes - 1):
+            raise ValueError(
+                "buffer must be at least {} bytes for this payload".format(
+                    len(data) + self._block_size_bytes - 1
+                )
+            )
+
+        data_processed = 0
+        total_out = 0
+        outlen = self._backend._ffi.new("int *")
+        baseoutbuf = self._backend._ffi.from_buffer(buf, require_writable=True)
+        baseinbuf = self._backend._ffi.from_buffer(data)
+
+        while data_processed != total_data_len:
+            outbuf = baseoutbuf + total_out
+            inbuf = baseinbuf + data_processed
+            inlen = min(self._MAX_CHUNK_SIZE, total_data_len - data_processed)
+
+            res = self._backend._lib.EVP_CipherUpdate(
+                self._ctx, outbuf, outlen, inbuf, inlen
+            )
+            if res == 0 and isinstance(self._mode, modes.XTS):
+                self._backend._consume_errors()
+                raise ValueError(
+                    "In XTS mode you must supply at least a full block in the "
+                    "first update call. For AES this is 16 bytes."
+                )
+            else:
+                self._backend.openssl_assert(res != 0)
+            data_processed += inlen
+            total_out += outlen[0]
+
+        return total_out
+
+    def finalize(self) -> bytes:
+        if (
+            self._operation == self._DECRYPT
+            and isinstance(self._mode, modes.ModeWithAuthenticationTag)
+            and self.tag is None
+        ):
+            raise ValueError(
+                "Authentication tag must be provided when decrypting."
+            )
+
+        buf = self._backend._ffi.new("unsigned char[]", self._block_size_bytes)
+        outlen = self._backend._ffi.new("int *")
+        res = self._backend._lib.EVP_CipherFinal_ex(self._ctx, buf, outlen)
+        if res == 0:
+            errors = self._backend._consume_errors()
+
+            if not errors and isinstance(self._mode, modes.GCM):
+                raise InvalidTag
+
+            lib = self._backend._lib
+            self._backend.openssl_assert(
+                errors[0]._lib_reason_match(
+                    lib.ERR_LIB_EVP,
+                    lib.EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH,
+                )
+                or (
+                    lib.Cryptography_HAS_PROVIDERS
+                    and errors[0]._lib_reason_match(
+                        lib.ERR_LIB_PROV,
+                        lib.PROV_R_WRONG_FINAL_BLOCK_LENGTH,
+                    )
+                )
+                or (
+                    lib.CRYPTOGRAPHY_IS_BORINGSSL
+                    and errors[0].reason
+                    == lib.CIPHER_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH
+                ),
+                errors=errors,
+            )
+            raise ValueError(
+                "The length of the provided data is not a multiple of "
+                "the block length."
+            )
+
+        if (
+            isinstance(self._mode, modes.GCM)
+            and self._operation == self._ENCRYPT
+        ):
+            tag_buf = self._backend._ffi.new(
+                "unsigned char[]", self._block_size_bytes
+            )
+            res = self._backend._lib.EVP_CIPHER_CTX_ctrl(
+                self._ctx,
+                self._backend._lib.EVP_CTRL_AEAD_GET_TAG,
+                self._block_size_bytes,
+                tag_buf,
+            )
+            self._backend.openssl_assert(res != 0)
+            self._tag = self._backend._ffi.buffer(tag_buf)[:]
+
+        res = self._backend._lib.EVP_CIPHER_CTX_reset(self._ctx)
+        self._backend.openssl_assert(res == 1)
+        return self._backend._ffi.buffer(buf)[: outlen[0]]
+
+    def finalize_with_tag(self, tag: bytes) -> bytes:
+        tag_len = len(tag)
+        if tag_len < self._mode._min_tag_length:
+            raise ValueError(
+                "Authentication tag must be {} bytes or longer.".format(
+                    self._mode._min_tag_length
+                )
+            )
+        elif tag_len > self._block_size_bytes:
+            raise ValueError(
+                "Authentication tag cannot be more than {} bytes.".format(
+                    self._block_size_bytes
+                )
+            )
+        res = self._backend._lib.EVP_CIPHER_CTX_ctrl(
+            self._ctx, self._backend._lib.EVP_CTRL_AEAD_SET_TAG, len(tag), tag
+        )
+        self._backend.openssl_assert(res != 0)
+        self._tag = tag
+        return self.finalize()
+
+    def authenticate_additional_data(self, data: bytes) -> None:
+        outlen = self._backend._ffi.new("int *")
+        res = self._backend._lib.EVP_CipherUpdate(
+            self._ctx,
+            self._backend._ffi.NULL,
+            outlen,
+            self._backend._ffi.from_buffer(data),
+            len(data),
+        )
+        self._backend.openssl_assert(res != 0)
+
+    @property
+    def tag(self) -> bytes | None:
+        return self._tag

shared/package-files/33/33085245aa389b0dcda728610cc30321790a8f619b3eeda03e24f17cccf8fccc/linalg_vander.h

@@ -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/linalg_vander_ops.h>
+
+namespace at {
+
+
+// aten::linalg_vander(Tensor x, *, SymInt? N=None) -> Tensor
+inline at::Tensor linalg_vander(const at::Tensor & x, c10::optional<int64_t> N=c10::nullopt) {
+    return at::_ops::linalg_vander::call(x, N.has_value() ? c10::make_optional(c10::SymInt(*N)) : c10::nullopt);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor linalg_vander(const at::Tensor & x, c10::optional<int64_t> N=c10::nullopt) {
+    return at::_ops::linalg_vander::call(x, N.has_value() ? c10::make_optional(c10::SymInt(*N)) : c10::nullopt);
+  }
+}
+
+// aten::linalg_vander(Tensor x, *, SymInt? N=None) -> Tensor
+inline at::Tensor linalg_vander_symint(const at::Tensor & x, c10::optional<c10::SymInt> N=c10::nullopt) {
+    return at::_ops::linalg_vander::call(x, N);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor linalg_vander(const at::Tensor & x, c10::optional<c10::SymInt> N=c10::nullopt) {
+    return at::_ops::linalg_vander::call(x, N);
+  }
+}
+
+}

shared/package-files/33/330fa9d3b183cadb415ca68d0794aee61c34d434176608c465ee4cd5eecf9611/ed448.pyi

@@ -0,0 +1,25 @@
+from abc import ABCMeta, abstractmethod
+
+from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat
+
+class Ed448PrivateKey(metaclass=ABCMeta):
+    @classmethod
+    def generate(cls) -> Ed448PrivateKey: ...
+    @classmethod
+    def from_private_bytes(cls, data: bytes) -> Ed448PrivateKey: ...
+    @abstractmethod
+    def private_bytes(
+        self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption
+    ) -> bytes: ...
+    @abstractmethod
+    def public_key(self) -> Ed448PublicKey: ...
+    @abstractmethod
+    def sign(self, data: bytes) -> bytes: ...
+
+class Ed448PublicKey(metaclass=ABCMeta):
+    @classmethod
+    def from_public_bytes(cls, data: bytes) -> Ed448PublicKey: ...
+    @abstractmethod
+    def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ...
+    @abstractmethod
+    def verify(self, signature: bytes, data: bytes) -> None: ...

shared/package-files/33/3311dac7a97de32aa54d5665780a86efb20b11b5bac14e68b0f707cf127ce67b/multiarray.py

@@ -0,0 +1,76 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_f8: npt.NDArray[np.float64] = np.array([1.0])
+AR_i4 = np.array([1], dtype=np.int32)
+AR_u1 = np.array([1], dtype=np.uint8)
+
+AR_LIKE_f = [1.5]
+AR_LIKE_i = [1]
+
+b_f8 = np.broadcast(AR_f8)
+b_i4_f8_f8 = np.broadcast(AR_i4, AR_f8, AR_f8)
+
+next(b_f8)
+b_f8.reset()
+b_f8.index
+b_f8.iters
+b_f8.nd
+b_f8.ndim
+b_f8.numiter
+b_f8.shape
+b_f8.size
+
+next(b_i4_f8_f8)
+b_i4_f8_f8.reset()
+b_i4_f8_f8.ndim
+b_i4_f8_f8.index
+b_i4_f8_f8.iters
+b_i4_f8_f8.nd
+b_i4_f8_f8.numiter
+b_i4_f8_f8.shape
+b_i4_f8_f8.size
+
+np.inner(AR_f8, AR_i4)
+
+np.where([True, True, False])
+np.where([True, True, False], 1, 0)
+
+np.lexsort([0, 1, 2])
+
+np.can_cast(np.dtype("i8"), int)
+np.can_cast(AR_f8, "f8")
+np.can_cast(AR_f8, np.complex128, casting="unsafe")
+
+np.min_scalar_type([1])
+np.min_scalar_type(AR_f8)
+
+np.result_type(int, AR_i4)
+np.result_type(AR_f8, AR_u1)
+np.result_type(AR_f8, np.complex128)
+
+np.dot(AR_LIKE_f, AR_i4)
+np.dot(AR_u1, 1)
+np.dot(1.5j, 1)
+np.dot(AR_u1, 1, out=AR_f8)
+
+np.vdot(AR_LIKE_f, AR_i4)
+np.vdot(AR_u1, 1)
+np.vdot(1.5j, 1)
+
+np.bincount(AR_i4)
+
+np.copyto(AR_f8, [1.6])
+
+np.putmask(AR_f8, [True], 1.5)
+
+np.packbits(AR_i4)
+np.packbits(AR_u1)
+
+np.unpackbits(AR_u1)
+
+np.shares_memory(1, 2)
+np.shares_memory(AR_f8, AR_f8, max_work=1)
+
+np.may_share_memory(1, 2)
+np.may_share_memory(AR_f8, AR_f8, max_work=1)

shared/package-files/33/331296a1aed4a094512e29b9dc7e8ea3261fcfcecfdfff585171983d39271954/histograms.pyi

@@ -0,0 +1,27 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+
+assert_type(np.histogram_bin_edges(AR_i8, bins="auto"), npt.NDArray[Any])
+assert_type(np.histogram_bin_edges(AR_i8, bins="rice", range=(0, 3)), npt.NDArray[Any])
+assert_type(np.histogram_bin_edges(AR_i8, bins="scott", weights=AR_f8), npt.NDArray[Any])
+
+assert_type(np.histogram(AR_i8, bins="auto"), tuple[npt.NDArray[Any], npt.NDArray[Any]])
+assert_type(np.histogram(AR_i8, bins="rice", range=(0, 3)), tuple[npt.NDArray[Any], npt.NDArray[Any]])
+assert_type(np.histogram(AR_i8, bins="scott", weights=AR_f8), tuple[npt.NDArray[Any], npt.NDArray[Any]])
+assert_type(np.histogram(AR_f8, bins=1, density=True), tuple[npt.NDArray[Any], npt.NDArray[Any]])
+
+assert_type(np.histogramdd(AR_i8, bins=[1]), tuple[npt.NDArray[Any], list[npt.NDArray[Any]]])
+assert_type(np.histogramdd(AR_i8, range=[(0, 3)]), tuple[npt.NDArray[Any], list[npt.NDArray[Any]]])
+assert_type(np.histogramdd(AR_i8, weights=AR_f8), tuple[npt.NDArray[Any], list[npt.NDArray[Any]]])
+assert_type(np.histogramdd(AR_f8, density=True), tuple[npt.NDArray[Any], list[npt.NDArray[Any]]])

shared/package-files/33/3313b8d0e4e0ff9cff1273326fac1e4078e1b732f55a04b07e3097734ce5f366/parasail.py

@@ -0,0 +1,79 @@
+"""
+    pygments.lexers.parasail
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for ParaSail.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, include
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Literal
+
+__all__ = ['ParaSailLexer']
+
+
+class ParaSailLexer(RegexLexer):
+    """
+    For ParaSail source code.
+
+    .. versionadded:: 2.1
+    """
+
+    name = 'ParaSail'
+    url = 'http://www.parasail-lang.org'
+    aliases = ['parasail']
+    filenames = ['*.psi', '*.psl']
+    mimetypes = ['text/x-parasail']
+
+    flags = re.MULTILINE
+
+    tokens = {
+        'root': [
+            (r'[^\S\n]+', Text),
+            (r'//.*?\n', Comment.Single),
+            (r'\b(and|or|xor)=', Operator.Word),
+            (r'\b(and(\s+then)?|or(\s+else)?|xor|rem|mod|'
+             r'(is|not)\s+null)\b',
+             Operator.Word),
+            # Keywords
+            (r'\b(abs|abstract|all|block|class|concurrent|const|continue|'
+             r'each|end|exit|extends|exports|forward|func|global|implements|'
+             r'import|in|interface|is|lambda|locked|new|not|null|of|op|'
+             r'optional|private|queued|ref|return|reverse|separate|some|'
+             r'type|until|var|with|'
+             # Control flow
+             r'if|then|else|elsif|case|for|while|loop)\b',
+             Keyword.Reserved),
+            (r'(abstract\s+)?(interface|class|op|func|type)',
+             Keyword.Declaration),
+            # Literals
+            (r'"[^"]*"', String),
+            (r'\\[\'ntrf"0]', String.Escape),
+            (r'#[a-zA-Z]\w*', Literal),       # Enumeration
+            include('numbers'),
+            (r"'[^']'", String.Char),
+            (r'[a-zA-Z]\w*', Name),
+            # Operators and Punctuation
+            (r'(<==|==>|<=>|\*\*=|<\|=|<<=|>>=|==|!=|=\?|<=|>=|'
+             r'\*\*|<<|>>|=>|:=|\+=|-=|\*=|\|=|\||/=|\+|-|\*|/|'
+             r'\.\.|<\.\.|\.\.<|<\.\.<)',
+             Operator),
+            (r'(<|>|\[|\]|\(|\)|\||:|;|,|.|\{|\}|->)',
+             Punctuation),
+            (r'\n+', Text),
+        ],
+        'numbers': [
+            (r'\d[0-9_]*#[0-9a-fA-F][0-9a-fA-F_]*#', Number.Hex),  # any base
+            (r'0[xX][0-9a-fA-F][0-9a-fA-F_]*', Number.Hex),        # C-like hex
+            (r'0[bB][01][01_]*', Number.Bin),                      # C-like bin
+            (r'\d[0-9_]*\.\d[0-9_]*[eE][+-]\d[0-9_]*',             # float exp
+             Number.Float),
+            (r'\d[0-9_]*\.\d[0-9_]*', Number.Float),               # float
+            (r'\d[0-9_]*', Number.Integer),                        # integer
+        ],
+    }

shared/package-files/33/3318448046c83c176f95a97c33b5cd82e0076bee038d72810bef3dac1085e590/tree.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""      turtle-example-suite:
+
+             tdemo_tree.py
+
+Displays a 'breadth-first-tree' - in contrast
+to the classical Logo tree drawing programs,
+which use a depth-first-algorithm.
+
+Uses:
+(1) a tree-generator, where the drawing is
+quasi the side-effect, whereas the generator
+always yields None.
+(2) Turtle-cloning: At each branching point
+the current pen is cloned. So in the end
+there are 1024 turtles.
+"""
+from turtle import Turtle, mainloop
+from time import perf_counter as clock
+
+def tree(plist, l, a, f):
+    """ plist is list of pens
+    l is length of branch
+    a is half of the angle between 2 branches
+    f is factor by which branch is shortened
+    from level to level."""
+    if l > 3:
+        lst = []
+        for p in plist:
+            p.forward(l)
+            q = p.clone()
+            p.left(a)
+            q.right(a)
+            lst.append(p)
+            lst.append(q)
+        for x in tree(lst, l*f, a, f):
+            yield None
+
+def maketree():
+    p = Turtle()
+    p.setundobuffer(None)
+    p.hideturtle()
+    p.speed(0)
+    p.getscreen().tracer(30,0)
+    p.left(90)
+    p.penup()
+    p.forward(-210)
+    p.pendown()
+    t = tree([p], 200, 65, 0.6375)
+    for x in t:
+        pass
+
+def main():
+    a=clock()
+    maketree()
+    b=clock()
+    return "done: %.2f sec." % (b-a)
+
+if __name__ == "__main__":
+    msg = main()
+    print(msg)
+    mainloop()

shared/package-files/33/331c770f5e07eb18d510cfe34f14da5b2f5620d82b4662d65c9a47e5281797e7/test_base.py

@@ -0,0 +1,69 @@
+# Copyright (C) 2012 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+import random
+import types
+import unittest
+from contextlib import contextmanager
+from unittest import mock
+
+from conda.exceptions import SpecNotFound
+from conda_env import specs
+
+true_func = mock.Mock(return_value=True)
+false_func = mock.Mock(return_value=False)
+
+
+@contextmanager
+def patched_specs(*new_specs):
+    with mock.patch.object(specs, "all_specs") as all_specs:
+        all_specs.__iter__.return_value = new_specs
+        yield all_specs
+
+
+def generate_two_specs():
+    spec1 = mock.Mock(can_handle=false_func)
+    spec1.return_value = spec1
+    spec2 = mock.Mock(can_handle=true_func)
+    spec2.return_value = spec2
+    return spec1, spec2
+
+
+class DetectTestCase(unittest.TestCase):
+    def test_has_detect_function(self):
+        self.assertTrue(hasattr(specs, "detect"))
+        self.assertIsInstance(specs.detect, types.FunctionType)
+
+    def test_dispatches_to_registered_specs(self):
+        spec1, spec2 = generate_two_specs()
+        with patched_specs(spec1, spec2):
+            actual = specs.detect(name="foo")
+            self.assertEqual(actual, spec2)
+
+    def test_passes_kwargs_to_all_specs(self):
+        random_kwargs = {
+            "foo": random.randint(100, 200),
+            "bar%d" % random.randint(100, 200): True,
+        }
+
+        spec1, spec2 = generate_two_specs()
+        with patched_specs(spec1, spec2):
+            specs.detect(**random_kwargs)
+        spec1.assert_called_with(**random_kwargs)
+        spec2.assert_called_with(**random_kwargs)
+
+    def test_raises_exception_if_no_detection(self):
+        spec1 = generate_two_specs()[0]
+        spec1.msg = "msg"
+        with patched_specs(spec1):
+            with self.assertRaises(SpecNotFound):
+                specs.detect(name="foo")
+
+    def test_has_build_msg_function(self):
+        self.assertTrue(hasattr(specs, "build_message"))
+        self.assertIsInstance(specs.build_message, types.FunctionType)
+
+    def test_build_msg(self):
+        spec3 = mock.Mock(msg="error 3")
+        spec4 = mock.Mock(msg="error 4")
+        spec5 = mock.Mock(msg=None)
+        self.assertEqual(specs.build_message([spec3, spec4, spec5]), "error 3\nerror 4")

shared/package-files/33/331ca6c70946040dcfc76145cb321212d027915a317aaf9b24cd5f9368e412db/mpelements.py

@@ -0,0 +1,172 @@
+"""Real and complex elements. """
+
+
+from sympy.polys.domains.domainelement import DomainElement
+from sympy.utilities import public
+
+from mpmath.ctx_mp_python import PythonMPContext, _mpf, _mpc, _constant
+from mpmath.libmp import (MPZ_ONE, fzero, fone, finf, fninf, fnan,
+    round_nearest, mpf_mul, repr_dps, int_types,
+    from_int, from_float, from_str, to_rational)
+from mpmath.rational import mpq
+
+
+@public
+class RealElement(_mpf, DomainElement):
+    """An element of a real domain. """
+
+    __slots__ = ('__mpf__',)
+
+    def _set_mpf(self, val):
+        self.__mpf__ = val
+
+    _mpf_ = property(lambda self: self.__mpf__, _set_mpf)
+
+    def parent(self):
+        return self.context._parent
+
+@public
+class ComplexElement(_mpc, DomainElement):
+    """An element of a complex domain. """
+
+    __slots__ = ('__mpc__',)
+
+    def _set_mpc(self, val):
+        self.__mpc__ = val
+
+    _mpc_ = property(lambda self: self.__mpc__, _set_mpc)
+
+    def parent(self):
+        return self.context._parent
+
+new = object.__new__
+
+@public
+class MPContext(PythonMPContext):
+
+    def __init__(ctx, prec=53, dps=None, tol=None, real=False):
+        ctx._prec_rounding = [prec, round_nearest]
+
+        if dps is None:
+            ctx._set_prec(prec)
+        else:
+            ctx._set_dps(dps)
+
+        ctx.mpf = RealElement
+        ctx.mpc = ComplexElement
+        ctx.mpf._ctxdata = [ctx.mpf, new, ctx._prec_rounding]
+        ctx.mpc._ctxdata = [ctx.mpc, new, ctx._prec_rounding]
+
+        if real:
+            ctx.mpf.context = ctx
+        else:
+            ctx.mpc.context = ctx
+
+        ctx.constant = _constant
+        ctx.constant._ctxdata = [ctx.mpf, new, ctx._prec_rounding]
+        ctx.constant.context = ctx
+
+        ctx.types = [ctx.mpf, ctx.mpc, ctx.constant]
+        ctx.trap_complex = True
+        ctx.pretty = True
+
+        if tol is None:
+            ctx.tol = ctx._make_tol()
+        elif tol is False:
+            ctx.tol = fzero
+        else:
+            ctx.tol = ctx._convert_tol(tol)
+
+        ctx.tolerance = ctx.make_mpf(ctx.tol)
+
+        if not ctx.tolerance:
+            ctx.max_denom = 1000000
+        else:
+            ctx.max_denom = int(1/ctx.tolerance)
+
+        ctx.zero = ctx.make_mpf(fzero)
+        ctx.one = ctx.make_mpf(fone)
+        ctx.j = ctx.make_mpc((fzero, fone))
+        ctx.inf = ctx.make_mpf(finf)
+        ctx.ninf = ctx.make_mpf(fninf)
+        ctx.nan = ctx.make_mpf(fnan)
+
+    def _make_tol(ctx):
+        hundred = (0, 25, 2, 5)
+        eps = (0, MPZ_ONE, 1-ctx.prec, 1)
+        return mpf_mul(hundred, eps)
+
+    def make_tol(ctx):
+        return ctx.make_mpf(ctx._make_tol())
+
+    def _convert_tol(ctx, tol):
+        if isinstance(tol, int_types):
+            return from_int(tol)
+        if isinstance(tol, float):
+            return from_float(tol)
+        if hasattr(tol, "_mpf_"):
+            return tol._mpf_
+        prec, rounding = ctx._prec_rounding
+        if isinstance(tol, str):
+            return from_str(tol, prec, rounding)
+        raise ValueError("expected a real number, got %s" % tol)
+
+    def _convert_fallback(ctx, x, strings):
+        raise TypeError("cannot create mpf from " + repr(x))
+
+    @property
+    def _repr_digits(ctx):
+        return repr_dps(ctx._prec)
+
+    @property
+    def _str_digits(ctx):
+        return ctx._dps
+
+    def to_rational(ctx, s, limit=True):
+        p, q = to_rational(s._mpf_)
+
+        if not limit or q <= ctx.max_denom:
+            return p, q
+
+        p0, q0, p1, q1 = 0, 1, 1, 0
+        n, d = p, q
+
+        while True:
+            a = n//d
+            q2 = q0 + a*q1
+            if q2 > ctx.max_denom:
+                break
+            p0, q0, p1, q1 = p1, q1, p0 + a*p1, q2
+            n, d = d, n - a*d
+
+        k = (ctx.max_denom - q0)//q1
+
+        number = mpq(p, q)
+        bound1 = mpq(p0 + k*p1, q0 + k*q1)
+        bound2 = mpq(p1, q1)
+
+        if not bound2 or not bound1:
+            return p, q
+        elif abs(bound2 - number) <= abs(bound1 - number):
+            return bound2._mpq_
+        else:
+            return bound1._mpq_
+
+    def almosteq(ctx, s, t, rel_eps=None, abs_eps=None):
+        t = ctx.convert(t)
+        if abs_eps is None and rel_eps is None:
+            rel_eps = abs_eps = ctx.tolerance or ctx.make_tol()
+        if abs_eps is None:
+            abs_eps = ctx.convert(rel_eps)
+        elif rel_eps is None:
+            rel_eps = ctx.convert(abs_eps)
+        diff = abs(s-t)
+        if diff <= abs_eps:
+            return True
+        abss = abs(s)
+        abst = abs(t)
+        if abss < abst:
+            err = diff/abst
+        else:
+            err = diff/abss
+        return err <= rel_eps

shared/package-files/33/331f3a5c201fc345c41baedd53bdc68d96598b7f0464c244af0be0ae6efe4e15/test_constrainedlayout.py

@@ -0,0 +1,743 @@
+import gc
+import platform
+
+import numpy as np
+import pytest
+
+import matplotlib as mpl
+from matplotlib.testing.decorators import image_comparison
+import matplotlib.pyplot as plt
+import matplotlib.transforms as mtransforms
+from matplotlib import gridspec, ticker
+
+
+pytestmark = [
+    pytest.mark.usefixtures('text_placeholders')
+]
+
+
+def example_plot(ax, fontsize=12, nodec=False):
+    ax.plot([1, 2])
+    ax.locator_params(nbins=3)
+    if not nodec:
+        ax.set_xlabel('x-label', fontsize=fontsize)
+        ax.set_ylabel('y-label', fontsize=fontsize)
+        ax.set_title('Title', fontsize=fontsize)
+    else:
+        ax.set_xticklabels([])
+        ax.set_yticklabels([])
+
+
+def example_pcolor(ax, fontsize=12):
+    dx, dy = 0.6, 0.6
+    y, x = np.mgrid[slice(-3, 3 + dy, dy),
+                    slice(-3, 3 + dx, dx)]
+    z = (1 - x / 2. + x ** 5 + y ** 3) * np.exp(-x ** 2 - y ** 2)
+    pcm = ax.pcolormesh(x, y, z[:-1, :-1], cmap='RdBu_r', vmin=-1., vmax=1.,
+                        rasterized=True)
+    ax.set_xlabel('x-label', fontsize=fontsize)
+    ax.set_ylabel('y-label', fontsize=fontsize)
+    ax.set_title('Title', fontsize=fontsize)
+    return pcm
+
+
+@image_comparison(['constrained_layout1.png'], style='mpl20')
+def test_constrained_layout1():
+    """Test constrained_layout for a single subplot"""
+    fig = plt.figure(layout="constrained")
+    ax = fig.add_subplot()
+    example_plot(ax, fontsize=24)
+
+
+@image_comparison(['constrained_layout2.png'], style='mpl20')
+def test_constrained_layout2():
+    """Test constrained_layout for 2x2 subplots"""
+    fig, axs = plt.subplots(2, 2, layout="constrained")
+    for ax in axs.flat:
+        example_plot(ax, fontsize=24)
+
+
+@image_comparison(['constrained_layout3.png'], style='mpl20')
+def test_constrained_layout3():
+    """Test constrained_layout for colorbars with subplots"""
+
+    fig, axs = plt.subplots(2, 2, layout="constrained")
+    for nn, ax in enumerate(axs.flat):
+        pcm = example_pcolor(ax, fontsize=24)
+        if nn == 3:
+            pad = 0.08
+        else:
+            pad = 0.02  # default
+        fig.colorbar(pcm, ax=ax, pad=pad)
+
+
+@image_comparison(['constrained_layout4.png'], style='mpl20')
+def test_constrained_layout4():
+    """Test constrained_layout for a single colorbar with subplots"""
+
+    fig, axs = plt.subplots(2, 2, layout="constrained")
+    for ax in axs.flat:
+        pcm = example_pcolor(ax, fontsize=24)
+    fig.colorbar(pcm, ax=axs, pad=0.01, shrink=0.6)
+
+
+@image_comparison(['constrained_layout5.png'], style='mpl20')
+def test_constrained_layout5():
+    """
+    Test constrained_layout for a single colorbar with subplots,
+    colorbar bottom
+    """
+
+    fig, axs = plt.subplots(2, 2, layout="constrained")
+    for ax in axs.flat:
+        pcm = example_pcolor(ax, fontsize=24)
+    fig.colorbar(pcm, ax=axs,
+                 use_gridspec=False, pad=0.01, shrink=0.6,
+                 location='bottom')
+
+
+@image_comparison(['constrained_layout6.png'], style='mpl20')
+def test_constrained_layout6():
+    """Test constrained_layout for nested gridspecs"""
+    fig = plt.figure(layout="constrained")
+    gs = fig.add_gridspec(1, 2, figure=fig)
+    gsl = gs[0].subgridspec(2, 2)
+    gsr = gs[1].subgridspec(1, 2)
+    axsl = []
+    for gs in gsl:
+        ax = fig.add_subplot(gs)
+        axsl += [ax]
+        example_plot(ax, fontsize=12)
+    ax.set_xlabel('x-label\nMultiLine')
+    axsr = []
+    for gs in gsr:
+        ax = fig.add_subplot(gs)
+        axsr += [ax]
+        pcm = example_pcolor(ax, fontsize=12)
+
+    fig.colorbar(pcm, ax=axsr,
+                 pad=0.01, shrink=0.99, location='bottom',
+                 ticks=ticker.MaxNLocator(nbins=5))
+
+
+def test_identical_subgridspec():
+
+    fig = plt.figure(constrained_layout=True)
+
+    GS = fig.add_gridspec(2, 1)
+
+    GSA = GS[0].subgridspec(1, 3)
+    GSB = GS[1].subgridspec(1, 3)
+
+    axa = []
+    axb = []
+    for i in range(3):
+        axa += [fig.add_subplot(GSA[i])]
+        axb += [fig.add_subplot(GSB[i])]
+
+    fig.draw_without_rendering()
+    # check first row above second
+    assert axa[0].get_position().y0 > axb[0].get_position().y1
+
+
+def test_constrained_layout7():
+    """Test for proper warning if fig not set in GridSpec"""
+    with pytest.warns(
+        UserWarning, match=('There are no gridspecs with layoutgrids. '
+                            'Possibly did not call parent GridSpec with '
+                            'the "figure" keyword')):
+        fig = plt.figure(layout="constrained")
+        gs = gridspec.GridSpec(1, 2)
+        gsl = gridspec.GridSpecFromSubplotSpec(2, 2, gs[0])
+        gsr = gridspec.GridSpecFromSubplotSpec(1, 2, gs[1])
+        for gs in gsl:
+            fig.add_subplot(gs)
+        # need to trigger a draw to get warning
+        fig.draw_without_rendering()
+
+
+@image_comparison(['constrained_layout8.png'], style='mpl20')
+def test_constrained_layout8():
+    """Test for gridspecs that are not completely full"""
+
+    fig = plt.figure(figsize=(10, 5), layout="constrained")
+    gs = gridspec.GridSpec(3, 5, figure=fig)
+    axs = []
+    for j in [0, 1]:
+        if j == 0:
+            ilist = [1]
+        else:
+            ilist = [0, 4]
+        for i in ilist:
+            ax = fig.add_subplot(gs[j, i])
+            axs += [ax]
+            example_pcolor(ax, fontsize=9)
+            if i > 0:
+                ax.set_ylabel('')
+            if j < 1:
+                ax.set_xlabel('')
+            ax.set_title('')
+    ax = fig.add_subplot(gs[2, :])
+    axs += [ax]
+    pcm = example_pcolor(ax, fontsize=9)
+
+    fig.colorbar(pcm, ax=axs, pad=0.01, shrink=0.6)
+
+
+@image_comparison(['constrained_layout9.png'], style='mpl20')
+def test_constrained_layout9():
+    """Test for handling suptitle and for sharex and sharey"""
+
+    fig, axs = plt.subplots(2, 2, layout="constrained",
+                            sharex=False, sharey=False)
+    for ax in axs.flat:
+        pcm = example_pcolor(ax, fontsize=24)
+        ax.set_xlabel('')
+        ax.set_ylabel('')
+    ax.set_aspect(2.)
+    fig.colorbar(pcm, ax=axs, pad=0.01, shrink=0.6)
+    fig.suptitle('Test Suptitle', fontsize=28)
+
+
+@image_comparison(['constrained_layout10.png'], style='mpl20',
+                  tol=0 if platform.machine() == 'x86_64' else 0.032)
+def test_constrained_layout10():
+    """Test for handling legend outside axis"""
+    fig, axs = plt.subplots(2, 2, layout="constrained")
+    for ax in axs.flat:
+        ax.plot(np.arange(12), label='This is a label')
+    ax.legend(loc='center left', bbox_to_anchor=(0.8, 0.5))
+
+
+@image_comparison(['constrained_layout11.png'], style='mpl20')
+def test_constrained_layout11():
+    """Test for multiple nested gridspecs"""
+
+    fig = plt.figure(layout="constrained", figsize=(13, 3))
+    gs0 = gridspec.GridSpec(1, 2, figure=fig)
+    gsl = gridspec.GridSpecFromSubplotSpec(1, 2, gs0[0])
+    gsl0 = gridspec.GridSpecFromSubplotSpec(2, 2, gsl[1])
+    ax = fig.add_subplot(gs0[1])
+    example_plot(ax, fontsize=9)
+    axs = []
+    for gs in gsl0:
+        ax = fig.add_subplot(gs)
+        axs += [ax]
+        pcm = example_pcolor(ax, fontsize=9)
+    fig.colorbar(pcm, ax=axs, shrink=0.6, aspect=70.)
+    ax = fig.add_subplot(gsl[0])
+    example_plot(ax, fontsize=9)
+
+
+@image_comparison(['constrained_layout11rat.png'], style='mpl20')
+def test_constrained_layout11rat():
+    """Test for multiple nested gridspecs with width_ratios"""
+
+    fig = plt.figure(layout="constrained", figsize=(10, 3))
+    gs0 = gridspec.GridSpec(1, 2, figure=fig, width_ratios=[6, 1])
+    gsl = gridspec.GridSpecFromSubplotSpec(1, 2, gs0[0])
+    gsl0 = gridspec.GridSpecFromSubplotSpec(2, 2, gsl[1], height_ratios=[2, 1])
+    ax = fig.add_subplot(gs0[1])
+    example_plot(ax, fontsize=9)
+    axs = []
+    for gs in gsl0:
+        ax = fig.add_subplot(gs)
+        axs += [ax]
+        pcm = example_pcolor(ax, fontsize=9)
+    fig.colorbar(pcm, ax=axs, shrink=0.6, aspect=70.)
+    ax = fig.add_subplot(gsl[0])
+    example_plot(ax, fontsize=9)
+
+
+@image_comparison(['constrained_layout12.png'], style='mpl20')
+def test_constrained_layout12():
+    """Test that very unbalanced labeling still works."""
+    fig = plt.figure(layout="constrained", figsize=(6, 8))
+
+    gs0 = gridspec.GridSpec(6, 2, figure=fig)
+
+    ax1 = fig.add_subplot(gs0[:3, 1])
+    ax2 = fig.add_subplot(gs0[3:, 1])
+
+    example_plot(ax1, fontsize=18)
+    example_plot(ax2, fontsize=18)
+
+    ax = fig.add_subplot(gs0[0:2, 0])
+    example_plot(ax, nodec=True)
+    ax = fig.add_subplot(gs0[2:4, 0])
+    example_plot(ax, nodec=True)
+    ax = fig.add_subplot(gs0[4:, 0])
+    example_plot(ax, nodec=True)
+    ax.set_xlabel('x-label')
+
+
+@image_comparison(['constrained_layout13.png'], style='mpl20')
+def test_constrained_layout13():
+    """Test that padding works."""
+    fig, axs = plt.subplots(2, 2, layout="constrained")
+    for ax in axs.flat:
+        pcm = example_pcolor(ax, fontsize=12)
+        fig.colorbar(pcm, ax=ax, shrink=0.6, aspect=20., pad=0.02)
+    with pytest.raises(TypeError):
+        fig.get_layout_engine().set(wpad=1, hpad=2)
+    fig.get_layout_engine().set(w_pad=24./72., h_pad=24./72.)
+
+
+@image_comparison(['constrained_layout14.png'], style='mpl20')
+def test_constrained_layout14():
+    """Test that padding works."""
+    fig, axs = plt.subplots(2, 2, layout="constrained")
+    for ax in axs.flat:
+        pcm = example_pcolor(ax, fontsize=12)
+        fig.colorbar(pcm, ax=ax, shrink=0.6, aspect=20., pad=0.02)
+    fig.get_layout_engine().set(
+            w_pad=3./72., h_pad=3./72.,
+            hspace=0.2, wspace=0.2)
+
+
+@image_comparison(['constrained_layout15.png'], style='mpl20')
+def test_constrained_layout15():
+    """Test that rcparams work."""
+    mpl.rcParams['figure.constrained_layout.use'] = True
+    fig, axs = plt.subplots(2, 2)
+    for ax in axs.flat:
+        example_plot(ax, fontsize=12)
+
+
+@image_comparison(['constrained_layout16.png'], style='mpl20')
+def test_constrained_layout16():
+    """Test ax.set_position."""
+    fig, ax = plt.subplots(layout="constrained")
+    example_plot(ax, fontsize=12)
+    ax2 = fig.add_axes([0.2, 0.2, 0.4, 0.4])
+
+
+@image_comparison(['constrained_layout17.png'], style='mpl20')
+def test_constrained_layout17():
+    """Test uneven gridspecs"""
+    fig = plt.figure(layout="constrained")
+    gs = gridspec.GridSpec(3, 3, figure=fig)
+
+    ax1 = fig.add_subplot(gs[0, 0])
+    ax2 = fig.add_subplot(gs[0, 1:])
+    ax3 = fig.add_subplot(gs[1:, 0:2])
+    ax4 = fig.add_subplot(gs[1:, -1])
+
+    example_plot(ax1)
+    example_plot(ax2)
+    example_plot(ax3)
+    example_plot(ax4)
+
+
+def test_constrained_layout18():
+    """Test twinx"""
+    fig, ax = plt.subplots(layout="constrained")
+    ax2 = ax.twinx()
+    example_plot(ax)
+    example_plot(ax2, fontsize=24)
+    fig.draw_without_rendering()
+    assert all(ax.get_position().extents == ax2.get_position().extents)
+
+
+def test_constrained_layout19():
+    """Test twiny"""
+    fig, ax = plt.subplots(layout="constrained")
+    ax2 = ax.twiny()
+    example_plot(ax)
+    example_plot(ax2, fontsize=24)
+    ax2.set_title('')
+    ax.set_title('')
+    fig.draw_without_rendering()
+    assert all(ax.get_position().extents == ax2.get_position().extents)
+
+
+def test_constrained_layout20():
+    """Smoke test cl does not mess up added Axes"""
+    gx = np.linspace(-5, 5, 4)
+    img = np.hypot(gx, gx[:, None])
+
+    fig = plt.figure()
+    ax = fig.add_axes([0, 0, 1, 1])
+    mesh = ax.pcolormesh(gx, gx, img[:-1, :-1])
+    fig.colorbar(mesh)
+
+
+def test_constrained_layout21():
+    """#11035: repeated calls to suptitle should not alter the layout"""
+    fig, ax = plt.subplots(layout="constrained")
+
+    fig.suptitle("Suptitle0")
+    fig.draw_without_rendering()
+    extents0 = np.copy(ax.get_position().extents)
+
+    fig.suptitle("Suptitle1")
+    fig.draw_without_rendering()
+    extents1 = np.copy(ax.get_position().extents)
+
+    np.testing.assert_allclose(extents0, extents1)
+
+
+def test_constrained_layout22():
+    """#11035: suptitle should not be include in CL if manually positioned"""
+    fig, ax = plt.subplots(layout="constrained")
+
+    fig.draw_without_rendering()
+    extents0 = np.copy(ax.get_position().extents)
+
+    fig.suptitle("Suptitle", y=0.5)
+    fig.draw_without_rendering()
+    extents1 = np.copy(ax.get_position().extents)
+
+    np.testing.assert_allclose(extents0, extents1)
+
+
+def test_constrained_layout23():
+    """
+    Comment in #11035: suptitle used to cause an exception when
+    reusing a figure w/ CL with ``clear=True``.
+    """
+
+    for i in range(2):
+        fig = plt.figure(layout="constrained", clear=True, num="123")
+        gs = fig.add_gridspec(1, 2)
+        sub = gs[0].subgridspec(2, 2)
+        fig.suptitle(f"Suptitle{i}")
+
+
+@image_comparison(['test_colorbar_location.png'],
+                  remove_text=True, style='mpl20')
+def test_colorbar_location():
+    """
+    Test that colorbar handling is as expected for various complicated
+    cases...
+    """
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['pcolormesh.snap'] = False
+
+    fig, axs = plt.subplots(4, 5, layout="constrained")
+    for ax in axs.flat:
+        pcm = example_pcolor(ax)
+        ax.set_xlabel('')
+        ax.set_ylabel('')
+    fig.colorbar(pcm, ax=axs[:, 1], shrink=0.4)
+    fig.colorbar(pcm, ax=axs[-1, :2], shrink=0.5, location='bottom')
+    fig.colorbar(pcm, ax=axs[0, 2:], shrink=0.5, location='bottom', pad=0.05)
+    fig.colorbar(pcm, ax=axs[-2, 3:], shrink=0.5, location='top')
+    fig.colorbar(pcm, ax=axs[0, 0], shrink=0.5, location='left')
+    fig.colorbar(pcm, ax=axs[1:3, 2], shrink=0.5, location='right')
+
+
+def test_hidden_axes():
+    # test that if we make an Axes not visible that constrained_layout
+    # still works.  Note the axes still takes space in the layout
+    # (as does a gridspec slot that is empty)
+    fig, axs = plt.subplots(2, 2, layout="constrained")
+    axs[0, 1].set_visible(False)
+    fig.draw_without_rendering()
+    extents1 = np.copy(axs[0, 0].get_position().extents)
+
+    np.testing.assert_allclose(
+        extents1, [0.046918, 0.541204, 0.477409, 0.980555], rtol=1e-5)
+
+
+def test_colorbar_align():
+    for location in ['right', 'left', 'top', 'bottom']:
+        fig, axs = plt.subplots(2, 2, layout="constrained")
+        cbs = []
+        for nn, ax in enumerate(axs.flat):
+            ax.tick_params(direction='in')
+            pc = example_pcolor(ax)
+            cb = fig.colorbar(pc, ax=ax, location=location, shrink=0.6,
+                              pad=0.04)
+            cbs += [cb]
+            cb.ax.tick_params(direction='in')
+            if nn != 1:
+                cb.ax.xaxis.set_ticks([])
+                cb.ax.yaxis.set_ticks([])
+                ax.set_xticklabels([])
+                ax.set_yticklabels([])
+        fig.get_layout_engine().set(w_pad=4 / 72, h_pad=4 / 72,
+                                    hspace=0.1, wspace=0.1)
+
+        fig.draw_without_rendering()
+        if location in ['left', 'right']:
+            np.testing.assert_allclose(cbs[0].ax.get_position().x0,
+                                       cbs[2].ax.get_position().x0)
+            np.testing.assert_allclose(cbs[1].ax.get_position().x0,
+                                       cbs[3].ax.get_position().x0)
+        else:
+            np.testing.assert_allclose(cbs[0].ax.get_position().y0,
+                                       cbs[1].ax.get_position().y0)
+            np.testing.assert_allclose(cbs[2].ax.get_position().y0,
+                                       cbs[3].ax.get_position().y0)
+
+
+@image_comparison(['test_colorbars_no_overlapV.png'], style='mpl20')
+def test_colorbars_no_overlapV():
+    fig = plt.figure(figsize=(2, 4), layout="constrained")
+    axs = fig.subplots(2, 1, sharex=True, sharey=True)
+    for ax in axs:
+        ax.yaxis.set_major_formatter(ticker.NullFormatter())
+        ax.tick_params(axis='both', direction='in')
+        im = ax.imshow([[1, 2], [3, 4]])
+        fig.colorbar(im, ax=ax, orientation="vertical")
+    fig.suptitle("foo")
+
+
+@image_comparison(['test_colorbars_no_overlapH.png'], style='mpl20')
+def test_colorbars_no_overlapH():
+    fig = plt.figure(figsize=(4, 2), layout="constrained")
+    fig.suptitle("foo")
+    axs = fig.subplots(1, 2, sharex=True, sharey=True)
+    for ax in axs:
+        ax.yaxis.set_major_formatter(ticker.NullFormatter())
+        ax.tick_params(axis='both', direction='in')
+        im = ax.imshow([[1, 2], [3, 4]])
+        fig.colorbar(im, ax=ax, orientation="horizontal")
+
+
+def test_manually_set_position():
+    fig, axs = plt.subplots(1, 2, layout="constrained")
+    axs[0].set_position([0.2, 0.2, 0.3, 0.3])
+    fig.draw_without_rendering()
+    pp = axs[0].get_position()
+    np.testing.assert_allclose(pp, [[0.2, 0.2], [0.5, 0.5]])
+
+    fig, axs = plt.subplots(1, 2, layout="constrained")
+    axs[0].set_position([0.2, 0.2, 0.3, 0.3])
+    pc = axs[0].pcolormesh(np.random.rand(20, 20))
+    fig.colorbar(pc, ax=axs[0])
+    fig.draw_without_rendering()
+    pp = axs[0].get_position()
+    np.testing.assert_allclose(pp, [[0.2, 0.2], [0.44, 0.5]])
+
+
+@image_comparison(['test_bboxtight.png'],
+                  remove_text=True, style='mpl20',
+                  savefig_kwarg={'bbox_inches': 'tight'})
+def test_bboxtight():
+    fig, ax = plt.subplots(layout="constrained")
+    ax.set_aspect(1.)
+
+
+@image_comparison(['test_bbox.png'],
+                  remove_text=True, style='mpl20',
+                  savefig_kwarg={'bbox_inches':
+                                 mtransforms.Bbox([[0.5, 0], [2.5, 2]])})
+def test_bbox():
+    fig, ax = plt.subplots(layout="constrained")
+    ax.set_aspect(1.)
+
+
+def test_align_labels():
+    """
+    Tests for a bug in which constrained layout and align_ylabels on
+    three unevenly sized subplots, one of whose y tick labels include
+    negative numbers, drives the non-negative subplots' y labels off
+    the edge of the plot
+    """
+    fig, (ax3, ax1, ax2) = plt.subplots(3, 1, layout="constrained",
+                                        figsize=(6.4, 8),
+                                        gridspec_kw={"height_ratios": (1, 1,
+                                                                       0.7)})
+
+    ax1.set_ylim(0, 1)
+    ax1.set_ylabel("Label")
+
+    ax2.set_ylim(-1.5, 1.5)
+    ax2.set_ylabel("Label")
+
+    ax3.set_ylim(0, 1)
+    ax3.set_ylabel("Label")
+
+    fig.align_ylabels(axs=(ax3, ax1, ax2))
+
+    fig.draw_without_rendering()
+    after_align = [ax1.yaxis.label.get_window_extent(),
+                   ax2.yaxis.label.get_window_extent(),
+                   ax3.yaxis.label.get_window_extent()]
+    # ensure labels are approximately aligned
+    np.testing.assert_allclose([after_align[0].x0, after_align[2].x0],
+                               after_align[1].x0, rtol=0, atol=1e-05)
+    # ensure labels do not go off the edge
+    assert after_align[0].x0 >= 1
+
+
+def test_suplabels():
+    fig, ax = plt.subplots(layout="constrained")
+    fig.draw_without_rendering()
+    pos0 = ax.get_tightbbox(fig.canvas.get_renderer())
+    fig.supxlabel('Boo')
+    fig.supylabel('Booy')
+    fig.draw_without_rendering()
+    pos = ax.get_tightbbox(fig.canvas.get_renderer())
+    assert pos.y0 > pos0.y0 + 10.0
+    assert pos.x0 > pos0.x0 + 10.0
+
+    fig, ax = plt.subplots(layout="constrained")
+    fig.draw_without_rendering()
+    pos0 = ax.get_tightbbox(fig.canvas.get_renderer())
+    # check that specifying x (y) doesn't ruin the layout
+    fig.supxlabel('Boo', x=0.5)
+    fig.supylabel('Boo', y=0.5)
+    fig.draw_without_rendering()
+    pos = ax.get_tightbbox(fig.canvas.get_renderer())
+    assert pos.y0 > pos0.y0 + 10.0
+    assert pos.x0 > pos0.x0 + 10.0
+
+
+def test_gridspec_addressing():
+    fig = plt.figure()
+    gs = fig.add_gridspec(3, 3)
+    sp = fig.add_subplot(gs[0:, 1:])
+    fig.draw_without_rendering()
+
+
+def test_discouraged_api():
+    fig, ax = plt.subplots(constrained_layout=True)
+    fig.draw_without_rendering()
+
+    with pytest.warns(PendingDeprecationWarning,
+                      match="will be deprecated"):
+        fig, ax = plt.subplots()
+        fig.set_constrained_layout(True)
+        fig.draw_without_rendering()
+
+    with pytest.warns(PendingDeprecationWarning,
+                      match="will be deprecated"):
+        fig, ax = plt.subplots()
+        fig.set_constrained_layout({'w_pad': 0.02, 'h_pad': 0.02})
+        fig.draw_without_rendering()
+
+
+def test_kwargs():
+    fig, ax = plt.subplots(constrained_layout={'h_pad': 0.02})
+    fig.draw_without_rendering()
+
+
+def test_rect():
+    fig, ax = plt.subplots(layout='constrained')
+    fig.get_layout_engine().set(rect=[0, 0, 0.5, 0.5])
+    fig.draw_without_rendering()
+    ppos = ax.get_position()
+    assert ppos.x1 < 0.5
+    assert ppos.y1 < 0.5
+
+    fig, ax = plt.subplots(layout='constrained')
+    fig.get_layout_engine().set(rect=[0.2, 0.2, 0.3, 0.3])
+    fig.draw_without_rendering()
+    ppos = ax.get_position()
+    assert ppos.x1 < 0.5
+    assert ppos.y1 < 0.5
+    assert ppos.x0 > 0.2
+    assert ppos.y0 > 0.2
+
+
+def test_compressed1():
+    fig, axs = plt.subplots(3, 2, layout='compressed',
+                            sharex=True, sharey=True)
+    for ax in axs.flat:
+        pc = ax.imshow(np.random.randn(20, 20))
+
+    fig.colorbar(pc, ax=axs)
+    fig.draw_without_rendering()
+
+    pos = axs[0, 0].get_position()
+    np.testing.assert_allclose(pos.x0, 0.2381, atol=1e-2)
+    pos = axs[0, 1].get_position()
+    np.testing.assert_allclose(pos.x1, 0.7024, atol=1e-3)
+
+    # wider than tall
+    fig, axs = plt.subplots(2, 3, layout='compressed',
+                            sharex=True, sharey=True, figsize=(5, 4))
+    for ax in axs.flat:
+        pc = ax.imshow(np.random.randn(20, 20))
+
+    fig.colorbar(pc, ax=axs)
+    fig.draw_without_rendering()
+
+    pos = axs[0, 0].get_position()
+    np.testing.assert_allclose(pos.x0, 0.05653, atol=1e-3)
+    np.testing.assert_allclose(pos.y1, 0.8603, atol=1e-2)
+    pos = axs[1, 2].get_position()
+    np.testing.assert_allclose(pos.x1, 0.8728, atol=1e-3)
+    np.testing.assert_allclose(pos.y0, 0.1808, atol=1e-2)
+
+
+def test_compressed_suptitle():
+    fig, (ax0, ax1) = plt.subplots(
+        nrows=2, figsize=(4, 10), layout="compressed",
+        gridspec_kw={"height_ratios": (1 / 4, 3 / 4), "hspace": 0})
+
+    ax0.axis("equal")
+    ax0.set_box_aspect(1/3)
+
+    ax1.axis("equal")
+    ax1.set_box_aspect(1)
+
+    title = fig.suptitle("Title")
+    fig.draw_without_rendering()
+    assert title.get_position()[1] == pytest.approx(0.7491, abs=1e-3)
+
+    title = fig.suptitle("Title", y=0.98)
+    fig.draw_without_rendering()
+    assert title.get_position()[1] == 0.98
+
+    title = fig.suptitle("Title", in_layout=False)
+    fig.draw_without_rendering()
+    assert title.get_position()[1] == 0.98
+
+
+@pytest.mark.parametrize('arg, state', [
+    (True, True),
+    (False, False),
+    ({}, True),
+    ({'rect': None}, True)
+])
+def test_set_constrained_layout(arg, state):
+    fig, ax = plt.subplots(constrained_layout=arg)
+    assert fig.get_constrained_layout() is state
+
+
+def test_constrained_toggle():
+    fig, ax = plt.subplots()
+    with pytest.warns(PendingDeprecationWarning):
+        fig.set_constrained_layout(True)
+        assert fig.get_constrained_layout()
+        fig.set_constrained_layout(False)
+        assert not fig.get_constrained_layout()
+        fig.set_constrained_layout(True)
+        assert fig.get_constrained_layout()
+
+
+def test_layout_leak():
+    # Make sure there aren't any cyclic references when using LayoutGrid
+    # GH #25853
+    fig = plt.figure(constrained_layout=True, figsize=(10, 10))
+    fig.add_subplot()
+    fig.draw_without_rendering()
+    plt.close("all")
+    del fig
+    gc.collect()
+    assert not any(isinstance(obj, mpl._layoutgrid.LayoutGrid)
+                   for obj in gc.get_objects())
+
+
+def test_submerged_subfig():
+    """
+    Test that the submerged margin logic does not get called multiple times
+    on same axes if it is already in a subfigure
+    """
+    fig = plt.figure(figsize=(4, 5), layout='constrained')
+    figures = fig.subfigures(3, 1)
+    axs = []
+    for f in figures.flatten():
+        gs = f.add_gridspec(2, 2)
+        for i in range(2):
+            axs += [f.add_subplot(gs[i, 0])]
+            axs[-1].plot()
+        f.add_subplot(gs[:, 1]).plot()
+    fig.draw_without_rendering()
+    for ax in axs[1:]:
+        assert np.allclose(ax.get_position().bounds[-1],
+                           axs[0].get_position().bounds[-1], atol=1e-6)

shared/package-files/33/331ff95d94552759b94ad3b6a79ad52bd0ffcf2a6b3dbd8e0bc9b6aa5afae36f/fractional_max_pool2d_backward_meta_dispatch.h

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

shared/package-files/33/332288615a542442c1306223657cfe72a25c1a86204933385049efc483bd6b70/abstract.py

@@ -0,0 +1,516 @@
+from abc import ABCMeta, abstractmethod
+from typing import Dict as ptDict, Type as ptType
+import itertools
+import weakref
+from functools import cached_property
+
+import numpy as np
+
+from numba.core.utils import get_hashable_key
+
+# Types are added to a global registry (_typecache) in order to assign
+# them unique integer codes for fast matching in _dispatcher.c.
+# However, we also want types to be disposable, therefore we ensure
+# each type is interned as a weak reference, so that it lives only as
+# long as necessary to keep a stable type code.
+# NOTE: some types can still be made immortal elsewhere (for example
+# in _dispatcher.c's internal caches).
+_typecodes = itertools.count()
+
+def _autoincr():
+    n = next(_typecodes)
+    # 4 billion types should be enough, right?
+    assert n < 2 ** 32, "Limited to 4 billion types"
+    return n
+
+_typecache: ptDict[weakref.ref, weakref.ref] = {}
+
+def _on_type_disposal(wr, _pop=_typecache.pop):
+    _pop(wr, None)
+
+
+class _TypeMetaclass(ABCMeta):
+    """
+    A metaclass that will intern instances after they are created.
+    This is done by first creating a new instance (including calling
+    __init__, which sets up the required attributes for equality
+    and hashing), then looking it up in the _typecache registry.
+    """
+
+    def __init__(cls, name, bases, orig_vars):
+        # __init__ is hooked to mark whether a Type class being defined is a
+        # Numba internal type (one which is defined somewhere under the `numba`
+        # module) or an external type (one which is defined elsewhere, for
+        # example a user defined type).
+        super(_TypeMetaclass, cls).__init__(name, bases, orig_vars)
+        root = (cls.__module__.split('.'))[0]
+        cls._is_internal = root == "numba"
+
+    def _intern(cls, inst):
+        # Try to intern the created instance
+        wr = weakref.ref(inst, _on_type_disposal)
+        orig = _typecache.get(wr)
+        orig = orig and orig()
+        if orig is not None:
+            return orig
+        else:
+            inst._code = _autoincr()
+            _typecache[wr] = wr
+            return inst
+
+    def __call__(cls, *args, **kwargs):
+        """
+        Instantiate *cls* (a Type subclass, presumably) and intern it.
+        If an interned instance already exists, it is returned, otherwise
+        the new instance is returned.
+        """
+        inst = type.__call__(cls, *args, **kwargs)
+        return cls._intern(inst)
+
+
+def _type_reconstructor(reconstructor, reconstructor_args, state):
+    """
+    Rebuild function for unpickling types.
+    """
+    obj = reconstructor(*reconstructor_args)
+    if state:
+        obj.__dict__.update(state)
+    return type(obj)._intern(obj)
+
+
+class Type(metaclass=_TypeMetaclass):
+    """
+    The base class for all Numba types.
+    It is essential that proper equality comparison is implemented.  The
+    default implementation uses the "key" property (overridable in subclasses)
+    for both comparison and hashing, to ensure sane behaviour.
+    """
+
+    mutable = False
+    # Rather the type is reflected at the python<->nopython boundary
+    reflected = False
+
+    def __init__(self, name):
+        self.name = name
+
+    @property
+    def key(self):
+        """
+        A property used for __eq__, __ne__ and __hash__.  Can be overridden
+        in subclasses.
+        """
+        return self.name
+
+    @property
+    def mangling_args(self):
+        """
+        Returns `(basename, args)` where `basename` is the name of the type
+        and `args` is a sequence of parameters of the type.
+
+        Subclass should override to specialize the behavior.
+        By default, this returns `(self.name, ())`.
+        """
+        return self.name, ()
+
+    def __repr__(self):
+        return self.name
+
+    def __str__(self):
+        return self.name
+
+    def __hash__(self):
+        return hash(self.key)
+
+    def __eq__(self, other):
+        return self.__class__ is other.__class__ and self.key == other.key
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __reduce__(self):
+        reconstructor, args, state = super(Type, self).__reduce__()
+        return (_type_reconstructor, (reconstructor, args, state))
+
+    def unify(self, typingctx, other):
+        """
+        Try to unify this type with the *other*.  A third type must
+        be returned, or None if unification is not possible.
+        Only override this if the coercion logic cannot be expressed
+        as simple casting rules.
+        """
+        return None
+
+    def can_convert_to(self, typingctx, other):
+        """
+        Check whether this type can be converted to the *other*.
+        If successful, must return a string describing the conversion, e.g.
+        "exact", "promote", "unsafe", "safe"; otherwise None is returned.
+        """
+        return None
+
+    def can_convert_from(self, typingctx, other):
+        """
+        Similar to *can_convert_to*, but in reverse.  Only needed if
+        the type provides conversion from other types.
+        """
+        return None
+
+    def is_precise(self):
+        """
+        Whether this type is precise, i.e. can be part of a successful
+        type inference.  Default implementation returns True.
+        """
+        return True
+
+    def augment(self, other):
+        """
+        Augment this type with the *other*.  Return the augmented type,
+        or None if not supported.
+        """
+        return None
+
+    # User-facing helpers.  These are not part of the core Type API but
+    # are provided so that users can write e.g. `numba.boolean(1.5)`
+    # (returns True) or `types.int32(types.int32[:])` (returns something
+    # usable as a function signature).
+
+    def __call__(self, *args):
+        from numba.core.typing import signature
+        if len(args) == 1 and not isinstance(args[0], Type):
+            return self.cast_python_value(args[0])
+        return signature(self, # return_type
+                         *args)
+
+    def __getitem__(self, args, /):
+        """
+        Return an array of this type.
+        """
+        from numba.core.types import Array
+        ndim, layout = self._determine_array_spec(args)
+        return Array(dtype=self, ndim=ndim, layout=layout)
+
+    def _determine_array_spec(self, args):
+        # XXX non-contiguous by default, even for 1d arrays,
+        # doesn't sound very intuitive
+        def validate_slice(s):
+            return isinstance(s, slice) and s.start is None and s.stop is None
+
+        if isinstance(args, (tuple, list)) and all(map(validate_slice, args)):
+            ndim = len(args)
+            if args[0].step == 1:
+                layout = 'F'
+            elif args[-1].step == 1:
+                layout = 'C'
+            else:
+                layout = 'A'
+        elif validate_slice(args):
+            ndim = 1
+            if args.step == 1:
+                layout = 'C'
+            else:
+                layout = 'A'
+        else:
+            # Raise a KeyError to not be handled by collection constructors (e.g. list).
+            raise KeyError(f"Can only index numba types with slices with no start or stop, got {args}.")
+
+        return ndim, layout
+
+    def cast_python_value(self, args, /):
+        raise NotImplementedError
+
+
+    @property
+    def is_internal(self):
+        """ Returns True if this class is an internally defined Numba type by
+        virtue of the module in which it is instantiated, False else."""
+        return self._is_internal
+
+    def dump(self, tab=''):
+        print(f'{tab}DUMP {type(self).__name__}[code={self._code}, name={self.name}]')
+
+# XXX we should distinguish between Dummy (no meaningful
+# representation, e.g. None or a builtin function) and Opaque (has a
+# meaningful representation, e.g. ExternalFunctionPointer)
+
+class Dummy(Type):
+    """
+    Base class for types that do not really have a representation and are
+    compatible with a void*.
+    """
+
+
+class Hashable(Type):
+    """
+    Base class for hashable types.
+    """
+
+
+class Number(Hashable):
+    """
+    Base class for number types.
+    """
+
+    def unify(self, typingctx, other):
+        """
+        Unify the two number types using Numpy's rules.
+        """
+        from numba.np import numpy_support
+        if isinstance(other, Number):
+            # XXX: this can produce unsafe conversions,
+            # e.g. would unify {int64, uint64} to float64
+            a = numpy_support.as_dtype(self)
+            b = numpy_support.as_dtype(other)
+            sel = np.promote_types(a, b)
+            return numpy_support.from_dtype(sel)
+
+
+class Callable(Type):
+    """
+    Base class for callables.
+    """
+
+    @abstractmethod
+    def get_call_type(self, context, args, kws):
+        """
+        Using the typing *context*, resolve the callable's signature for
+        the given arguments.  A signature object is returned, or None.
+        """
+
+    @abstractmethod
+    def get_call_signatures(self):
+        """
+        Returns a tuple of (list of signatures, parameterized)
+        """
+
+    @abstractmethod
+    def get_impl_key(self, sig):
+        """
+        Returns the impl key for the given signature
+        """
+
+
+class DTypeSpec(Type):
+    """
+    Base class for types usable as "dtype" arguments to various Numpy APIs
+    (e.g. np.empty()).
+    """
+
+    @property
+    @abstractmethod
+    def dtype(self):
+        """
+        The actual dtype denoted by this dtype spec (a Type instance).
+        """
+
+
+class IterableType(Type):
+    """
+    Base class for iterable types.
+    """
+
+    @property
+    @abstractmethod
+    def iterator_type(self):
+        """
+        The iterator type obtained when calling iter() (explicitly or implicitly).
+        """
+
+
+class Sized(Type):
+    """
+    Base class for objects that support len()
+    """
+
+
+class ConstSized(Sized):
+    """
+    For types that have a constant size
+    """
+    @abstractmethod
+    def __len__(self):
+        pass
+
+
+class IteratorType(IterableType):
+    """
+    Base class for all iterator types.
+    Derived classes should implement the *yield_type* attribute.
+    """
+
+    def __init__(self, name, **kwargs):
+        super(IteratorType, self).__init__(name, **kwargs)
+
+    @property
+    @abstractmethod
+    def yield_type(self):
+        """
+        The type of values yielded by the iterator.
+        """
+
+    # This is a property to avoid recursivity (for pickling)
+
+    @property
+    def iterator_type(self):
+        return self
+
+
+class Container(Sized, IterableType):
+    """
+    Base class for container types.
+    """
+
+
+class Sequence(Container):
+    """
+    Base class for 1d sequence types.  Instances should have the *dtype*
+    attribute.
+    """
+
+
+class MutableSequence(Sequence):
+    """
+    Base class for 1d mutable sequence types.  Instances should have the
+    *dtype* attribute.
+    """
+
+    mutable = True
+
+class ArrayCompatible(Type):
+    """
+    Type class for Numpy array-compatible objects (typically, objects
+    exposing an __array__ method).
+    Derived classes should implement the *as_array* attribute.
+    """
+    # If overridden by a subclass, it should also implement typing
+    # for '__array_wrap__' with arguments (input, formal result).
+    array_priority = 0.0
+
+    @property
+    @abstractmethod
+    def as_array(self):
+        """
+        The equivalent array type, for operations supporting array-compatible
+        objects (such as ufuncs).
+        """
+
+    # For compatibility with types.Array
+
+    @cached_property
+    def ndim(self):
+        return self.as_array.ndim
+
+    @cached_property
+    def layout(self):
+        return self.as_array.layout
+
+    @cached_property
+    def dtype(self):
+        return self.as_array.dtype
+
+
+class Literal(Type):
+    """Base class for Literal types.
+    Literal types contain the original Python value in the type.
+
+    A literal type should always be constructed from the `literal(val)`
+    function.
+    """
+
+    # *ctor_map* is a dictionary mapping Python types to Literal subclasses
+    # for constructing a numba type for a given Python type.
+    # It is used in `literal(val)` function.
+    # To add new Literal subclass, register a new mapping to this dict.
+    ctor_map: ptDict[type, ptType['Literal']] = {}
+
+    # *_literal_type_cache* is used to cache the numba type of the given value.
+    _literal_type_cache = None
+
+    def __init__(self, value):
+        if type(self) is Literal:
+            raise TypeError(
+                "Cannot be constructed directly. "
+                "Use `numba.types.literal(value)` instead",
+            )
+        self._literal_init(value)
+        fmt = "Literal[{}]({})"
+        super(Literal, self).__init__(fmt.format(type(value).__name__, value))
+
+    def _literal_init(self, value):
+        self._literal_value = value
+        # We want to support constants of non-hashable values, therefore
+        # fall back on the value's id() if necessary.
+        self._key = get_hashable_key(value)
+
+    @property
+    def literal_value(self):
+        return self._literal_value
+
+    @property
+    def literal_type(self):
+        if self._literal_type_cache is None:
+            from numba.core import typing
+            ctx = typing.Context()
+            try:
+                res = ctx.resolve_value_type(self.literal_value)
+            except ValueError as e:
+
+                if "Int value is too large" in str(e):
+                    # If a string literal cannot create an IntegerLiteral
+                    # because of overflow we generate this message.
+                    msg = f"Cannot create literal type. {str(e)}"
+                    raise TypeError(msg)
+                # Not all literal types have a literal_value that can be
+                # resolved to a type, for example, LiteralStrKeyDict has a
+                # literal_value that is a python dict for which there's no
+                # `typeof` support.
+                msg = "{} has no attribute 'literal_type'".format(self)
+                raise AttributeError(msg)
+            self._literal_type_cache = res
+
+        return self._literal_type_cache
+
+
+
+class TypeRef(Dummy):
+    """Reference to a type.
+
+    Used when a type is passed as a value.
+    """
+    def __init__(self, instance_type):
+        self.instance_type = instance_type
+        super(TypeRef, self).__init__('typeref[{}]'.format(self.instance_type))
+
+    @property
+    def key(self):
+        return self.instance_type
+
+
+class InitialValue(object):
+    """
+    Used as a mixin for a type will potentially have an initial value that will
+    be carried in the .initial_value attribute.
+    """
+    def __init__(self, initial_value):
+        self._initial_value = initial_value
+
+    @property
+    def initial_value(self):
+        return self._initial_value
+
+
+class Poison(Type):
+    """
+    This is the "bottom" type in the type system. It won't unify and it's
+    unliteral version is Poison of itself. It's advisable for debugging purposes
+    to call the constructor with the type that's being poisoned (for whatever
+    reason) but this isn't strictly required.
+    """
+    def __init__(self, ty):
+        self.ty = ty
+        super(Poison, self).__init__(name="Poison<%s>" % ty)
+
+    def __unliteral__(self):
+        return Poison(self)
+
+    def unify(self, typingctx, other):
+        return None

shared/package-files/33/3328083ba04a22cc3e487194398ac0684af6f903c1c40ef827e71e91b324c224/scatter_reduce_cuda_dispatch.h

@@ -0,0 +1,26 @@
+#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 scatter_reduce(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, bool include_self=true);
+TORCH_API at::Tensor & scatter_reduce_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, bool include_self=true);
+TORCH_API at::Tensor & scatter_reduce_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, bool include_self, at::Tensor & out);
+TORCH_API at::Tensor & scatter_reduce_(at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & src, c10::string_view reduce, bool include_self=true);
+
+} // namespace cuda
+} // namespace at

shared/package-files/33/3328cb027cca61175005fa1fd56de4fe17f7d0cbea3a4a8bfff1b6da6439c70c/pzdr.afm

@@ -0,0 +1,222 @@
+StartFontMetrics 2.0
+Comment Copyright (c) 1985, 1987, 1988, 1989 Adobe Systems Incorporated.  All rights reserved.
+Comment Creation Date: Fri Dec  1 12:57:42 1989
+Comment UniqueID 26200
+Comment VMusage 39281 49041
+FontName ZapfDingbats
+FullName ITC Zapf Dingbats
+FamilyName ITC Zapf Dingbats
+Weight Medium
+ItalicAngle 0
+IsFixedPitch false
+FontBBox -1 -143 981 820
+UnderlinePosition -98
+UnderlineThickness 54
+Version 001.004
+Notice Copyright (c) 1985, 1987, 1988, 1989 Adobe Systems Incorporated.  All rights reserved.ITC Zapf Dingbats is a registered trademark of International Typeface Corporation.
+EncodingScheme FontSpecific
+StartCharMetrics 202
+C 32 ; WX 278 ; N space ; B 0 0 0 0 ;
+C 33 ; WX 974 ; N a1 ; B 35 72 939 621 ;
+C 34 ; WX 961 ; N a2 ; B 35 81 927 611 ;
+C 35 ; WX 974 ; N a202 ; B 35 72 939 621 ;
+C 36 ; WX 980 ; N a3 ; B 35 0 945 692 ;
+C 37 ; WX 719 ; N a4 ; B 34 139 685 566 ;
+C 38 ; WX 789 ; N a5 ; B 35 -14 755 705 ;
+C 39 ; WX 790 ; N a119 ; B 35 -14 755 705 ;
+C 40 ; WX 791 ; N a118 ; B 35 -13 761 705 ;
+C 41 ; WX 690 ; N a117 ; B 35 138 655 553 ;
+C 42 ; WX 960 ; N a11 ; B 35 123 925 568 ;
+C 43 ; WX 939 ; N a12 ; B 35 134 904 559 ;
+C 44 ; WX 549 ; N a13 ; B 29 -11 516 705 ;
+C 45 ; WX 855 ; N a14 ; B 34 59 820 632 ;
+C 46 ; WX 911 ; N a15 ; B 35 50 876 642 ;
+C 47 ; WX 933 ; N a16 ; B 35 139 899 550 ;
+C 48 ; WX 911 ; N a105 ; B 35 50 876 642 ;
+C 49 ; WX 945 ; N a17 ; B 35 139 909 553 ;
+C 50 ; WX 974 ; N a18 ; B 35 104 938 587 ;
+C 51 ; WX 755 ; N a19 ; B 34 -13 721 705 ;
+C 52 ; WX 846 ; N a20 ; B 36 -14 811 705 ;
+C 53 ; WX 762 ; N a21 ; B 35 0 727 692 ;
+C 54 ; WX 761 ; N a22 ; B 35 0 727 692 ;
+C 55 ; WX 571 ; N a23 ; B -1 -68 571 661 ;
+C 56 ; WX 677 ; N a24 ; B 36 -13 642 705 ;
+C 57 ; WX 763 ; N a25 ; B 35 0 728 692 ;
+C 58 ; WX 760 ; N a26 ; B 35 0 726 692 ;
+C 59 ; WX 759 ; N a27 ; B 35 0 725 692 ;
+C 60 ; WX 754 ; N a28 ; B 35 0 720 692 ;
+C 61 ; WX 494 ; N a6 ; B 35 0 460 692 ;
+C 62 ; WX 552 ; N a7 ; B 35 0 517 692 ;
+C 63 ; WX 537 ; N a8 ; B 35 0 503 692 ;
+C 64 ; WX 577 ; N a9 ; B 35 96 542 596 ;
+C 65 ; WX 692 ; N a10 ; B 35 -14 657 705 ;
+C 66 ; WX 786 ; N a29 ; B 35 -14 751 705 ;
+C 67 ; WX 788 ; N a30 ; B 35 -14 752 705 ;
+C 68 ; WX 788 ; N a31 ; B 35 -14 753 705 ;
+C 69 ; WX 790 ; N a32 ; B 35 -14 756 705 ;
+C 70 ; WX 793 ; N a33 ; B 35 -13 759 705 ;
+C 71 ; WX 794 ; N a34 ; B 35 -13 759 705 ;
+C 72 ; WX 816 ; N a35 ; B 35 -14 782 705 ;
+C 73 ; WX 823 ; N a36 ; B 35 -14 787 705 ;
+C 74 ; WX 789 ; N a37 ; B 35 -14 754 705 ;
+C 75 ; WX 841 ; N a38 ; B 35 -14 807 705 ;
+C 76 ; WX 823 ; N a39 ; B 35 -14 789 705 ;
+C 77 ; WX 833 ; N a40 ; B 35 -14 798 705 ;
+C 78 ; WX 816 ; N a41 ; B 35 -13 782 705 ;
+C 79 ; WX 831 ; N a42 ; B 35 -14 796 705 ;
+C 80 ; WX 923 ; N a43 ; B 35 -14 888 705 ;
+C 81 ; WX 744 ; N a44 ; B 35 0 710 692 ;
+C 82 ; WX 723 ; N a45 ; B 35 0 688 692 ;
+C 83 ; WX 749 ; N a46 ; B 35 0 714 692 ;
+C 84 ; WX 790 ; N a47 ; B 34 -14 756 705 ;
+C 85 ; WX 792 ; N a48 ; B 35 -14 758 705 ;
+C 86 ; WX 695 ; N a49 ; B 35 -14 661 706 ;
+C 87 ; WX 776 ; N a50 ; B 35 -6 741 699 ;
+C 88 ; WX 768 ; N a51 ; B 35 -7 734 699 ;
+C 89 ; WX 792 ; N a52 ; B 35 -14 757 705 ;
+C 90 ; WX 759 ; N a53 ; B 35 0 725 692 ;
+C 91 ; WX 707 ; N a54 ; B 35 -13 672 704 ;
+C 92 ; WX 708 ; N a55 ; B 35 -14 672 705 ;
+C 93 ; WX 682 ; N a56 ; B 35 -14 647 705 ;
+C 94 ; WX 701 ; N a57 ; B 35 -14 666 705 ;
+C 95 ; WX 826 ; N a58 ; B 35 -14 791 705 ;
+C 96 ; WX 815 ; N a59 ; B 35 -14 780 705 ;
+C 97 ; WX 789 ; N a60 ; B 35 -14 754 705 ;
+C 98 ; WX 789 ; N a61 ; B 35 -14 754 705 ;
+C 99 ; WX 707 ; N a62 ; B 34 -14 673 705 ;
+C 100 ; WX 687 ; N a63 ; B 36 0 651 692 ;
+C 101 ; WX 696 ; N a64 ; B 35 0 661 691 ;
+C 102 ; WX 689 ; N a65 ; B 35 0 655 692 ;
+C 103 ; WX 786 ; N a66 ; B 34 -14 751 705 ;
+C 104 ; WX 787 ; N a67 ; B 35 -14 752 705 ;
+C 105 ; WX 713 ; N a68 ; B 35 -14 678 705 ;
+C 106 ; WX 791 ; N a69 ; B 35 -14 756 705 ;
+C 107 ; WX 785 ; N a70 ; B 36 -14 751 705 ;
+C 108 ; WX 791 ; N a71 ; B 35 -14 757 705 ;
+C 109 ; WX 873 ; N a72 ; B 35 -14 838 705 ;
+C 110 ; WX 761 ; N a73 ; B 35 0 726 692 ;
+C 111 ; WX 762 ; N a74 ; B 35 0 727 692 ;
+C 112 ; WX 762 ; N a203 ; B 35 0 727 692 ;
+C 113 ; WX 759 ; N a75 ; B 35 0 725 692 ;
+C 114 ; WX 759 ; N a204 ; B 35 0 725 692 ;
+C 115 ; WX 892 ; N a76 ; B 35 0 858 705 ;
+C 116 ; WX 892 ; N a77 ; B 35 -14 858 692 ;
+C 117 ; WX 788 ; N a78 ; B 35 -14 754 705 ;
+C 118 ; WX 784 ; N a79 ; B 35 -14 749 705 ;
+C 119 ; WX 438 ; N a81 ; B 35 -14 403 705 ;
+C 120 ; WX 138 ; N a82 ; B 35 0 104 692 ;
+C 121 ; WX 277 ; N a83 ; B 35 0 242 692 ;
+C 122 ; WX 415 ; N a84 ; B 35 0 380 692 ;
+C 123 ; WX 392 ; N a97 ; B 35 263 357 705 ;
+C 124 ; WX 392 ; N a98 ; B 34 263 357 705 ;
+C 125 ; WX 668 ; N a99 ; B 35 263 633 705 ;
+C 126 ; WX 668 ; N a100 ; B 36 263 634 705 ;
+C 161 ; WX 732 ; N a101 ; B 35 -143 697 806 ;
+C 162 ; WX 544 ; N a102 ; B 56 -14 488 706 ;
+C 163 ; WX 544 ; N a103 ; B 34 -14 508 705 ;
+C 164 ; WX 910 ; N a104 ; B 35 40 875 651 ;
+C 165 ; WX 667 ; N a106 ; B 35 -14 633 705 ;
+C 166 ; WX 760 ; N a107 ; B 35 -14 726 705 ;
+C 167 ; WX 760 ; N a108 ; B 0 121 758 569 ;
+C 168 ; WX 776 ; N a112 ; B 35 0 741 705 ;
+C 169 ; WX 595 ; N a111 ; B 34 -14 560 705 ;
+C 170 ; WX 694 ; N a110 ; B 35 -14 659 705 ;
+C 171 ; WX 626 ; N a109 ; B 34 0 591 705 ;
+C 172 ; WX 788 ; N a120 ; B 35 -14 754 705 ;
+C 173 ; WX 788 ; N a121 ; B 35 -14 754 705 ;
+C 174 ; WX 788 ; N a122 ; B 35 -14 754 705 ;
+C 175 ; WX 788 ; N a123 ; B 35 -14 754 705 ;
+C 176 ; WX 788 ; N a124 ; B 35 -14 754 705 ;
+C 177 ; WX 788 ; N a125 ; B 35 -14 754 705 ;
+C 178 ; WX 788 ; N a126 ; B 35 -14 754 705 ;
+C 179 ; WX 788 ; N a127 ; B 35 -14 754 705 ;
+C 180 ; WX 788 ; N a128 ; B 35 -14 754 705 ;
+C 181 ; WX 788 ; N a129 ; B 35 -14 754 705 ;
+C 182 ; WX 788 ; N a130 ; B 35 -14 754 705 ;
+C 183 ; WX 788 ; N a131 ; B 35 -14 754 705 ;
+C 184 ; WX 788 ; N a132 ; B 35 -14 754 705 ;
+C 185 ; WX 788 ; N a133 ; B 35 -14 754 705 ;
+C 186 ; WX 788 ; N a134 ; B 35 -14 754 705 ;
+C 187 ; WX 788 ; N a135 ; B 35 -14 754 705 ;
+C 188 ; WX 788 ; N a136 ; B 35 -14 754 705 ;
+C 189 ; WX 788 ; N a137 ; B 35 -14 754 705 ;
+C 190 ; WX 788 ; N a138 ; B 35 -14 754 705 ;
+C 191 ; WX 788 ; N a139 ; B 35 -14 754 705 ;
+C 192 ; WX 788 ; N a140 ; B 35 -14 754 705 ;
+C 193 ; WX 788 ; N a141 ; B 35 -14 754 705 ;
+C 194 ; WX 788 ; N a142 ; B 35 -14 754 705 ;
+C 195 ; WX 788 ; N a143 ; B 35 -14 754 705 ;
+C 196 ; WX 788 ; N a144 ; B 35 -14 754 705 ;
+C 197 ; WX 788 ; N a145 ; B 35 -14 754 705 ;
+C 198 ; WX 788 ; N a146 ; B 35 -14 754 705 ;
+C 199 ; WX 788 ; N a147 ; B 35 -14 754 705 ;
+C 200 ; WX 788 ; N a148 ; B 35 -14 754 705 ;
+C 201 ; WX 788 ; N a149 ; B 35 -14 754 705 ;
+C 202 ; WX 788 ; N a150 ; B 35 -14 754 705 ;
+C 203 ; WX 788 ; N a151 ; B 35 -14 754 705 ;
+C 204 ; WX 788 ; N a152 ; B 35 -14 754 705 ;
+C 205 ; WX 788 ; N a153 ; B 35 -14 754 705 ;
+C 206 ; WX 788 ; N a154 ; B 35 -14 754 705 ;
+C 207 ; WX 788 ; N a155 ; B 35 -14 754 705 ;
+C 208 ; WX 788 ; N a156 ; B 35 -14 754 705 ;
+C 209 ; WX 788 ; N a157 ; B 35 -14 754 705 ;
+C 210 ; WX 788 ; N a158 ; B 35 -14 754 705 ;
+C 211 ; WX 788 ; N a159 ; B 35 -14 754 705 ;
+C 212 ; WX 894 ; N a160 ; B 35 58 860 634 ;
+C 213 ; WX 838 ; N a161 ; B 35 152 803 540 ;
+C 214 ; WX 1016 ; N a163 ; B 34 152 981 540 ;
+C 215 ; WX 458 ; N a164 ; B 35 -127 422 820 ;
+C 216 ; WX 748 ; N a196 ; B 35 94 698 597 ;
+C 217 ; WX 924 ; N a165 ; B 35 140 890 552 ;
+C 218 ; WX 748 ; N a192 ; B 35 94 698 597 ;
+C 219 ; WX 918 ; N a166 ; B 35 166 884 526 ;
+C 220 ; WX 927 ; N a167 ; B 35 32 892 660 ;
+C 221 ; WX 928 ; N a168 ; B 35 129 891 562 ;
+C 222 ; WX 928 ; N a169 ; B 35 128 893 563 ;
+C 223 ; WX 834 ; N a170 ; B 35 155 799 537 ;
+C 224 ; WX 873 ; N a171 ; B 35 93 838 599 ;
+C 225 ; WX 828 ; N a172 ; B 35 104 791 588 ;
+C 226 ; WX 924 ; N a173 ; B 35 98 889 594 ;
+C 227 ; WX 924 ; N a162 ; B 35 98 889 594 ;
+C 228 ; WX 917 ; N a174 ; B 35 0 882 692 ;
+C 229 ; WX 930 ; N a175 ; B 35 84 896 608 ;
+C 230 ; WX 931 ; N a176 ; B 35 84 896 608 ;
+C 231 ; WX 463 ; N a177 ; B 35 -99 429 791 ;
+C 232 ; WX 883 ; N a178 ; B 35 71 848 623 ;
+C 233 ; WX 836 ; N a179 ; B 35 44 802 648 ;
+C 234 ; WX 836 ; N a193 ; B 35 44 802 648 ;
+C 235 ; WX 867 ; N a180 ; B 35 101 832 591 ;
+C 236 ; WX 867 ; N a199 ; B 35 101 832 591 ;
+C 237 ; WX 696 ; N a181 ; B 35 44 661 648 ;
+C 238 ; WX 696 ; N a200 ; B 35 44 661 648 ;
+C 239 ; WX 874 ; N a182 ; B 35 77 840 619 ;
+C 241 ; WX 874 ; N a201 ; B 35 73 840 615 ;
+C 242 ; WX 760 ; N a183 ; B 35 0 725 692 ;
+C 243 ; WX 946 ; N a184 ; B 35 160 911 533 ;
+C 244 ; WX 771 ; N a197 ; B 34 37 736 655 ;
+C 245 ; WX 865 ; N a185 ; B 35 207 830 481 ;
+C 246 ; WX 771 ; N a194 ; B 34 37 736 655 ;
+C 247 ; WX 888 ; N a198 ; B 34 -19 853 712 ;
+C 248 ; WX 967 ; N a186 ; B 35 124 932 568 ;
+C 249 ; WX 888 ; N a195 ; B 34 -19 853 712 ;
+C 250 ; WX 831 ; N a187 ; B 35 113 796 579 ;
+C 251 ; WX 873 ; N a188 ; B 36 118 838 578 ;
+C 252 ; WX 927 ; N a189 ; B 35 150 891 542 ;
+C 253 ; WX 970 ; N a190 ; B 35 76 931 616 ;
+C 254 ; WX 918 ; N a191 ; B 34 99 884 593 ;
+C -1 ; WX 410 ; N a86 ; B 35 0 375 692 ;
+C -1 ; WX 509 ; N a85 ; B 35 0 475 692 ;
+C -1 ; WX 334 ; N a95 ; B 35 0 299 692 ;
+C -1 ; WX 509 ; N a205 ; B 35 0 475 692 ;
+C -1 ; WX 390 ; N a89 ; B 35 -14 356 705 ;
+C -1 ; WX 234 ; N a87 ; B 35 -14 199 705 ;
+C -1 ; WX 276 ; N a91 ; B 35 0 242 692 ;
+C -1 ; WX 390 ; N a90 ; B 35 -14 355 705 ;
+C -1 ; WX 410 ; N a206 ; B 35 0 375 692 ;
+C -1 ; WX 317 ; N a94 ; B 35 0 283 692 ;
+C -1 ; WX 317 ; N a93 ; B 35 0 283 692 ;
+C -1 ; WX 276 ; N a92 ; B 35 0 242 692 ;
+C -1 ; WX 334 ; N a96 ; B 35 0 299 692 ;
+C -1 ; WX 234 ; N a88 ; B 35 -14 199 705 ;
+EndCharMetrics
+EndFontMetrics

shared/package-files/33/33293b3dd4ae5a2346be22cdad57f7f288da5dd40d34f36ababe8c84cf320264/NativeMetaFunctions.h

@@ -0,0 +1,1303 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeMetaFunctions.h
+
+#include <ATen/core/Tensor.h>
+#include <ATen/core/IListRef.h>
+#include <ATen/TensorMeta.h>
+#include <ATen/TensorIterator.h>
+
+#include <ATen/ops/_adaptive_avg_pool2d_meta.h>
+#include <ATen/ops/_adaptive_avg_pool2d_backward_meta.h>
+#include <ATen/ops/_adaptive_avg_pool3d_meta.h>
+#include <ATen/ops/_adaptive_avg_pool3d_backward_meta.h>
+#include <ATen/ops/_add_batch_dim_meta.h>
+#include <ATen/ops/_add_relu_meta.h>
+#include <ATen/ops/_addmm_activation_meta.h>
+#include <ATen/ops/_aminmax_meta.h>
+#include <ATen/ops/_amp_foreach_non_finite_check_and_unscale_meta.h>
+#include <ATen/ops/_amp_update_scale_meta.h>
+#include <ATen/ops/_assert_async_meta.h>
+#include <ATen/ops/_assert_scalar_meta.h>
+#include <ATen/ops/_assert_tensor_metadata_meta.h>
+#include <ATen/ops/_autocast_to_full_precision_meta.h>
+#include <ATen/ops/_autocast_to_reduced_precision_meta.h>
+#include <ATen/ops/_backward_meta.h>
+#include <ATen/ops/_batch_norm_impl_index_meta.h>
+#include <ATen/ops/_batch_norm_impl_index_backward_meta.h>
+#include <ATen/ops/_cast_Byte_meta.h>
+#include <ATen/ops/_cast_Char_meta.h>
+#include <ATen/ops/_cast_Double_meta.h>
+#include <ATen/ops/_cast_Float_meta.h>
+#include <ATen/ops/_cast_Half_meta.h>
+#include <ATen/ops/_cast_Int_meta.h>
+#include <ATen/ops/_cast_Long_meta.h>
+#include <ATen/ops/_cast_Short_meta.h>
+#include <ATen/ops/_cdist_backward_meta.h>
+#include <ATen/ops/_cdist_forward_meta.h>
+#include <ATen/ops/_cholesky_solve_helper_meta.h>
+#include <ATen/ops/_choose_qparams_per_tensor_meta.h>
+#include <ATen/ops/_chunk_cat_meta.h>
+#include <ATen/ops/_coalesce_meta.h>
+#include <ATen/ops/_coalesced_meta.h>
+#include <ATen/ops/_compute_linear_combination_meta.h>
+#include <ATen/ops/_conj_meta.h>
+#include <ATen/ops/_conj_copy_meta.h>
+#include <ATen/ops/_conj_physical_meta.h>
+#include <ATen/ops/_conv_depthwise2d_meta.h>
+#include <ATen/ops/_convert_indices_from_coo_to_csr_meta.h>
+#include <ATen/ops/_convert_indices_from_csr_to_coo_meta.h>
+#include <ATen/ops/_convert_weight_to_int4pack_meta.h>
+#include <ATen/ops/_convolution_meta.h>
+#include <ATen/ops/_convolution_double_backward_meta.h>
+#include <ATen/ops/_convolution_mode_meta.h>
+#include <ATen/ops/_copy_from_meta.h>
+#include <ATen/ops/_copy_from_and_resize_meta.h>
+#include <ATen/ops/_cslt_compress_meta.h>
+#include <ATen/ops/_cslt_sparse_mm_meta.h>
+#include <ATen/ops/_cslt_sparse_mm_search_meta.h>
+#include <ATen/ops/_ctc_loss_meta.h>
+#include <ATen/ops/_ctc_loss_backward_meta.h>
+#include <ATen/ops/_cudnn_ctc_loss_meta.h>
+#include <ATen/ops/_cudnn_init_dropout_state_meta.h>
+#include <ATen/ops/_cudnn_rnn_meta.h>
+#include <ATen/ops/_cudnn_rnn_backward_meta.h>
+#include <ATen/ops/_cudnn_rnn_flatten_weight_meta.h>
+#include <ATen/ops/_cufft_clear_plan_cache_meta.h>
+#include <ATen/ops/_cufft_get_plan_cache_max_size_meta.h>
+#include <ATen/ops/_cufft_get_plan_cache_size_meta.h>
+#include <ATen/ops/_cufft_set_plan_cache_max_size_meta.h>
+#include <ATen/ops/_cummax_helper_meta.h>
+#include <ATen/ops/_cummin_helper_meta.h>
+#include <ATen/ops/_debug_has_internal_overlap_meta.h>
+#include <ATen/ops/_dimI_meta.h>
+#include <ATen/ops/_dimV_meta.h>
+#include <ATen/ops/_dim_arange_meta.h>
+#include <ATen/ops/_dirichlet_grad_meta.h>
+#include <ATen/ops/_efficient_attention_backward_meta.h>
+#include <ATen/ops/_efficient_attention_forward_meta.h>
+#include <ATen/ops/_efficientzerotensor_meta.h>
+#include <ATen/ops/_embedding_bag_meta.h>
+#include <ATen/ops/_embedding_bag_backward_meta.h>
+#include <ATen/ops/_embedding_bag_dense_backward_meta.h>
+#include <ATen/ops/_embedding_bag_forward_only_meta.h>
+#include <ATen/ops/_embedding_bag_per_sample_weights_backward_meta.h>
+#include <ATen/ops/_embedding_bag_sparse_backward_meta.h>
+#include <ATen/ops/_empty_affine_quantized_meta.h>
+#include <ATen/ops/_empty_per_channel_affine_quantized_meta.h>
+#include <ATen/ops/_euclidean_dist_meta.h>
+#include <ATen/ops/_fake_quantize_learnable_per_channel_affine_meta.h>
+#include <ATen/ops/_fake_quantize_learnable_per_channel_affine_backward_meta.h>
+#include <ATen/ops/_fake_quantize_learnable_per_tensor_affine_meta.h>
+#include <ATen/ops/_fake_quantize_learnable_per_tensor_affine_backward_meta.h>
+#include <ATen/ops/_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_meta.h>
+#include <ATen/ops/_fft_c2c_meta.h>
+#include <ATen/ops/_fft_c2r_meta.h>
+#include <ATen/ops/_fft_r2c_meta.h>
+#include <ATen/ops/_fill_mem_eff_dropout_mask_meta.h>
+#include <ATen/ops/_flash_attention_backward_meta.h>
+#include <ATen/ops/_flash_attention_forward_meta.h>
+#include <ATen/ops/_foobar_meta.h>
+#include <ATen/ops/_foreach_abs_meta.h>
+#include <ATen/ops/_foreach_acos_meta.h>
+#include <ATen/ops/_foreach_add_meta.h>
+#include <ATen/ops/_foreach_addcdiv_meta.h>
+#include <ATen/ops/_foreach_addcmul_meta.h>
+#include <ATen/ops/_foreach_asin_meta.h>
+#include <ATen/ops/_foreach_atan_meta.h>
+#include <ATen/ops/_foreach_ceil_meta.h>
+#include <ATen/ops/_foreach_clamp_max_meta.h>
+#include <ATen/ops/_foreach_clamp_min_meta.h>
+#include <ATen/ops/_foreach_copy_meta.h>
+#include <ATen/ops/_foreach_cos_meta.h>
+#include <ATen/ops/_foreach_cosh_meta.h>
+#include <ATen/ops/_foreach_div_meta.h>
+#include <ATen/ops/_foreach_erf_meta.h>
+#include <ATen/ops/_foreach_erfc_meta.h>
+#include <ATen/ops/_foreach_exp_meta.h>
+#include <ATen/ops/_foreach_expm1_meta.h>
+#include <ATen/ops/_foreach_floor_meta.h>
+#include <ATen/ops/_foreach_frac_meta.h>
+#include <ATen/ops/_foreach_lerp_meta.h>
+#include <ATen/ops/_foreach_lgamma_meta.h>
+#include <ATen/ops/_foreach_log_meta.h>
+#include <ATen/ops/_foreach_log10_meta.h>
+#include <ATen/ops/_foreach_log1p_meta.h>
+#include <ATen/ops/_foreach_log2_meta.h>
+#include <ATen/ops/_foreach_maximum_meta.h>
+#include <ATen/ops/_foreach_minimum_meta.h>
+#include <ATen/ops/_foreach_mul_meta.h>
+#include <ATen/ops/_foreach_neg_meta.h>
+#include <ATen/ops/_foreach_norm_meta.h>
+#include <ATen/ops/_foreach_pow_meta.h>
+#include <ATen/ops/_foreach_reciprocal_meta.h>
+#include <ATen/ops/_foreach_round_meta.h>
+#include <ATen/ops/_foreach_sigmoid_meta.h>
+#include <ATen/ops/_foreach_sign_meta.h>
+#include <ATen/ops/_foreach_sin_meta.h>
+#include <ATen/ops/_foreach_sinh_meta.h>
+#include <ATen/ops/_foreach_sqrt_meta.h>
+#include <ATen/ops/_foreach_sub_meta.h>
+#include <ATen/ops/_foreach_tan_meta.h>
+#include <ATen/ops/_foreach_tanh_meta.h>
+#include <ATen/ops/_foreach_trunc_meta.h>
+#include <ATen/ops/_foreach_zero_meta.h>
+#include <ATen/ops/_functional_assert_async_meta.h>
+#include <ATen/ops/_functional_assert_scalar_meta.h>
+#include <ATen/ops/_functional_sym_constrain_range_meta.h>
+#include <ATen/ops/_functional_sym_constrain_range_for_size_meta.h>
+#include <ATen/ops/_fused_adam_meta.h>
+#include <ATen/ops/_fused_adamw_meta.h>
+#include <ATen/ops/_fused_dropout_meta.h>
+#include <ATen/ops/_fused_moving_avg_obs_fq_helper_meta.h>
+#include <ATen/ops/_fused_sdp_choice_meta.h>
+#include <ATen/ops/_fused_sgd_meta.h>
+#include <ATen/ops/_fw_primal_meta.h>
+#include <ATen/ops/_fw_primal_copy_meta.h>
+#include <ATen/ops/_gather_sparse_backward_meta.h>
+#include <ATen/ops/_grid_sampler_2d_cpu_fallback_meta.h>
+#include <ATen/ops/_grid_sampler_2d_cpu_fallback_backward_meta.h>
+#include <ATen/ops/_has_compatible_shallow_copy_type_meta.h>
+#include <ATen/ops/_has_same_storage_numel_meta.h>
+#include <ATen/ops/_histogramdd_bin_edges_meta.h>
+#include <ATen/ops/_histogramdd_from_bin_cts_meta.h>
+#include <ATen/ops/_histogramdd_from_bin_tensors_meta.h>
+#include <ATen/ops/_index_put_impl_meta.h>
+#include <ATen/ops/_indices_meta.h>
+#include <ATen/ops/_indices_copy_meta.h>
+#include <ATen/ops/_int_mm_meta.h>
+#include <ATen/ops/_is_all_true_meta.h>
+#include <ATen/ops/_is_any_true_meta.h>
+#include <ATen/ops/_is_zerotensor_meta.h>
+#include <ATen/ops/_lazy_clone_meta.h>
+#include <ATen/ops/_linalg_check_errors_meta.h>
+#include <ATen/ops/_linalg_det_meta.h>
+#include <ATen/ops/_linalg_eigh_meta.h>
+#include <ATen/ops/_linalg_eigvals_meta.h>
+#include <ATen/ops/_linalg_slogdet_meta.h>
+#include <ATen/ops/_linalg_solve_ex_meta.h>
+#include <ATen/ops/_linalg_svd_meta.h>
+#include <ATen/ops/_local_scalar_dense_meta.h>
+#include <ATen/ops/_log_softmax_meta.h>
+#include <ATen/ops/_log_softmax_backward_data_meta.h>
+#include <ATen/ops/_logcumsumexp_meta.h>
+#include <ATen/ops/_lstm_mps_meta.h>
+#include <ATen/ops/_lu_with_info_meta.h>
+#include <ATen/ops/_make_dep_token_meta.h>
+#include <ATen/ops/_make_dual_meta.h>
+#include <ATen/ops/_make_dual_copy_meta.h>
+#include <ATen/ops/_make_per_channel_quantized_tensor_meta.h>
+#include <ATen/ops/_make_per_tensor_quantized_tensor_meta.h>
+#include <ATen/ops/_masked_scale_meta.h>
+#include <ATen/ops/_masked_softmax_meta.h>
+#include <ATen/ops/_masked_softmax_backward_meta.h>
+#include <ATen/ops/_mixed_dtypes_linear_meta.h>
+#include <ATen/ops/_mkldnn_reshape_meta.h>
+#include <ATen/ops/_mkldnn_transpose_meta.h>
+#include <ATen/ops/_mps_convolution_meta.h>
+#include <ATen/ops/_mps_convolution_transpose_meta.h>
+#include <ATen/ops/_native_batch_norm_legit_meta.h>
+#include <ATen/ops/_native_batch_norm_legit_no_training_meta.h>
+#include <ATen/ops/_native_multi_head_attention_meta.h>
+#include <ATen/ops/_neg_view_meta.h>
+#include <ATen/ops/_neg_view_copy_meta.h>
+#include <ATen/ops/_nested_from_padded_meta.h>
+#include <ATen/ops/_nested_from_padded_and_nested_example_meta.h>
+#include <ATen/ops/_nested_get_jagged_dummy_meta.h>
+#include <ATen/ops/_nested_get_lengths_meta.h>
+#include <ATen/ops/_nested_get_offsets_meta.h>
+#include <ATen/ops/_nested_get_ragged_idx_meta.h>
+#include <ATen/ops/_nested_get_values_meta.h>
+#include <ATen/ops/_nested_get_values_copy_meta.h>
+#include <ATen/ops/_nested_select_backward_meta.h>
+#include <ATen/ops/_nested_sum_backward_meta.h>
+#include <ATen/ops/_nested_tensor_from_mask_meta.h>
+#include <ATen/ops/_nested_tensor_from_mask_left_aligned_meta.h>
+#include <ATen/ops/_nested_tensor_from_tensor_list_meta.h>
+#include <ATen/ops/_nested_tensor_size_meta.h>
+#include <ATen/ops/_nested_tensor_softmax_with_shape_meta.h>
+#include <ATen/ops/_nested_tensor_storage_offsets_meta.h>
+#include <ATen/ops/_nested_tensor_strides_meta.h>
+#include <ATen/ops/_nested_view_from_buffer_meta.h>
+#include <ATen/ops/_nested_view_from_buffer_copy_meta.h>
+#include <ATen/ops/_nested_view_from_jagged_meta.h>
+#include <ATen/ops/_nested_view_from_jagged_copy_meta.h>
+#include <ATen/ops/_new_zeros_with_same_feature_meta_meta.h>
+#include <ATen/ops/_nnpack_available_meta.h>
+#include <ATen/ops/_nnpack_spatial_convolution_meta.h>
+#include <ATen/ops/_nnz_meta.h>
+#include <ATen/ops/_pack_padded_sequence_meta.h>
+#include <ATen/ops/_pack_padded_sequence_backward_meta.h>
+#include <ATen/ops/_pad_circular_meta.h>
+#include <ATen/ops/_pad_enum_meta.h>
+#include <ATen/ops/_pad_packed_sequence_meta.h>
+#include <ATen/ops/_pdist_backward_meta.h>
+#include <ATen/ops/_pdist_forward_meta.h>
+#include <ATen/ops/_pin_memory_meta.h>
+#include <ATen/ops/_prelu_kernel_meta.h>
+#include <ATen/ops/_prelu_kernel_backward_meta.h>
+#include <ATen/ops/_print_meta.h>
+#include <ATen/ops/_propagate_xla_data_meta.h>
+#include <ATen/ops/_remove_batch_dim_meta.h>
+#include <ATen/ops/_reshape_alias_meta.h>
+#include <ATen/ops/_reshape_alias_copy_meta.h>
+#include <ATen/ops/_reshape_copy_meta.h>
+#include <ATen/ops/_reshape_from_tensor_meta.h>
+#include <ATen/ops/_resize_output_meta.h>
+#include <ATen/ops/_rowwise_prune_meta.h>
+#include <ATen/ops/_sample_dirichlet_meta.h>
+#include <ATen/ops/_saturate_weight_to_fp16_meta.h>
+#include <ATen/ops/_scaled_dot_product_attention_math_meta.h>
+#include <ATen/ops/_scaled_dot_product_cudnn_attention_meta.h>
+#include <ATen/ops/_scaled_dot_product_efficient_attention_meta.h>
+#include <ATen/ops/_scaled_dot_product_efficient_attention_backward_meta.h>
+#include <ATen/ops/_scaled_dot_product_flash_attention_meta.h>
+#include <ATen/ops/_scaled_dot_product_flash_attention_backward_meta.h>
+#include <ATen/ops/_scaled_dot_product_flash_attention_for_cpu_meta.h>
+#include <ATen/ops/_scaled_dot_product_flash_attention_for_cpu_backward_meta.h>
+#include <ATen/ops/_scaled_mm_meta.h>
+#include <ATen/ops/_segment_reduce_backward_meta.h>
+#include <ATen/ops/_shape_as_tensor_meta.h>
+#include <ATen/ops/_slow_conv2d_backward_meta.h>
+#include <ATen/ops/_slow_conv2d_forward_meta.h>
+#include <ATen/ops/_sobol_engine_draw_meta.h>
+#include <ATen/ops/_sobol_engine_ff_meta.h>
+#include <ATen/ops/_sobol_engine_initialize_state_meta.h>
+#include <ATen/ops/_sobol_engine_scramble_meta.h>
+#include <ATen/ops/_softmax_meta.h>
+#include <ATen/ops/_softmax_backward_data_meta.h>
+#include <ATen/ops/_sparse_addmm_meta.h>
+#include <ATen/ops/_sparse_broadcast_to_meta.h>
+#include <ATen/ops/_sparse_broadcast_to_copy_meta.h>
+#include <ATen/ops/_sparse_bsc_tensor_unsafe_meta.h>
+#include <ATen/ops/_sparse_bsr_tensor_unsafe_meta.h>
+#include <ATen/ops/_sparse_compressed_tensor_unsafe_meta.h>
+#include <ATen/ops/_sparse_coo_tensor_unsafe_meta.h>
+#include <ATen/ops/_sparse_coo_tensor_with_dims_meta.h>
+#include <ATen/ops/_sparse_coo_tensor_with_dims_and_tensors_meta.h>
+#include <ATen/ops/_sparse_csc_tensor_unsafe_meta.h>
+#include <ATen/ops/_sparse_csr_prod_meta.h>
+#include <ATen/ops/_sparse_csr_sum_meta.h>
+#include <ATen/ops/_sparse_csr_tensor_unsafe_meta.h>
+#include <ATen/ops/_sparse_log_softmax_meta.h>
+#include <ATen/ops/_sparse_log_softmax_backward_data_meta.h>
+#include <ATen/ops/_sparse_mask_projection_meta.h>
+#include <ATen/ops/_sparse_mm_meta.h>
+#include <ATen/ops/_sparse_mm_reduce_impl_meta.h>
+#include <ATen/ops/_sparse_mm_reduce_impl_backward_meta.h>
+#include <ATen/ops/_sparse_semi_structured_linear_meta.h>
+#include <ATen/ops/_sparse_softmax_meta.h>
+#include <ATen/ops/_sparse_softmax_backward_data_meta.h>
+#include <ATen/ops/_sparse_sparse_matmul_meta.h>
+#include <ATen/ops/_sparse_sum_meta.h>
+#include <ATen/ops/_sparse_sum_backward_meta.h>
+#include <ATen/ops/_spdiags_meta.h>
+#include <ATen/ops/_stack_meta.h>
+#include <ATen/ops/_standard_gamma_meta.h>
+#include <ATen/ops/_standard_gamma_grad_meta.h>
+#include <ATen/ops/_test_ambiguous_defaults_meta.h>
+#include <ATen/ops/_test_autograd_multiple_dispatch_meta.h>
+#include <ATen/ops/_test_autograd_multiple_dispatch_view_meta.h>
+#include <ATen/ops/_test_autograd_multiple_dispatch_view_copy_meta.h>
+#include <ATen/ops/_test_check_tensor_meta.h>
+#include <ATen/ops/_test_functorch_fallback_meta.h>
+#include <ATen/ops/_test_optional_filled_intlist_meta.h>
+#include <ATen/ops/_test_optional_floatlist_meta.h>
+#include <ATen/ops/_test_optional_intlist_meta.h>
+#include <ATen/ops/_test_parallel_materialize_meta.h>
+#include <ATen/ops/_test_serialization_subcmul_meta.h>
+#include <ATen/ops/_test_string_default_meta.h>
+#include <ATen/ops/_test_warn_in_autograd_meta.h>
+#include <ATen/ops/_thnn_differentiable_gru_cell_backward_meta.h>
+#include <ATen/ops/_thnn_differentiable_lstm_cell_backward_meta.h>
+#include <ATen/ops/_thnn_fused_gru_cell_meta.h>
+#include <ATen/ops/_thnn_fused_gru_cell_backward_meta.h>
+#include <ATen/ops/_thnn_fused_lstm_cell_meta.h>
+#include <ATen/ops/_thnn_fused_lstm_cell_backward_meta.h>
+#include <ATen/ops/_thnn_fused_lstm_cell_backward_impl_meta.h>
+#include <ATen/ops/_to_copy_meta.h>
+#include <ATen/ops/_to_cpu_meta.h>
+#include <ATen/ops/_to_dense_meta.h>
+#include <ATen/ops/_to_sparse_meta.h>
+#include <ATen/ops/_to_sparse_bsc_meta.h>
+#include <ATen/ops/_to_sparse_bsr_meta.h>
+#include <ATen/ops/_to_sparse_csc_meta.h>
+#include <ATen/ops/_to_sparse_csr_meta.h>
+#include <ATen/ops/_to_sparse_semi_structured_meta.h>
+#include <ATen/ops/_transform_bias_rescale_qkv_meta.h>
+#include <ATen/ops/_transformer_encoder_layer_fwd_meta.h>
+#include <ATen/ops/_trilinear_meta.h>
+#include <ATen/ops/_triton_multi_head_attention_meta.h>
+#include <ATen/ops/_triton_scaled_dot_attention_meta.h>
+#include <ATen/ops/_unique_meta.h>
+#include <ATen/ops/_unique2_meta.h>
+#include <ATen/ops/_unpack_dual_meta.h>
+#include <ATen/ops/_unsafe_index_meta.h>
+#include <ATen/ops/_unsafe_index_put_meta.h>
+#include <ATen/ops/_unsafe_view_meta.h>
+#include <ATen/ops/_upsample_bicubic2d_aa_meta.h>
+#include <ATen/ops/_upsample_bicubic2d_aa_backward_meta.h>
+#include <ATen/ops/_upsample_bilinear2d_aa_meta.h>
+#include <ATen/ops/_upsample_bilinear2d_aa_backward_meta.h>
+#include <ATen/ops/_upsample_nearest_exact1d_meta.h>
+#include <ATen/ops/_upsample_nearest_exact1d_backward_meta.h>
+#include <ATen/ops/_upsample_nearest_exact2d_meta.h>
+#include <ATen/ops/_upsample_nearest_exact2d_backward_meta.h>
+#include <ATen/ops/_upsample_nearest_exact3d_meta.h>
+#include <ATen/ops/_upsample_nearest_exact3d_backward_meta.h>
+#include <ATen/ops/_use_cudnn_ctc_loss_meta.h>
+#include <ATen/ops/_use_cudnn_rnn_flatten_weight_meta.h>
+#include <ATen/ops/_validate_compressed_sparse_indices_meta.h>
+#include <ATen/ops/_validate_sparse_bsc_tensor_args_meta.h>
+#include <ATen/ops/_validate_sparse_bsr_tensor_args_meta.h>
+#include <ATen/ops/_validate_sparse_compressed_tensor_args_meta.h>
+#include <ATen/ops/_validate_sparse_coo_tensor_args_meta.h>
+#include <ATen/ops/_validate_sparse_csc_tensor_args_meta.h>
+#include <ATen/ops/_validate_sparse_csr_tensor_args_meta.h>
+#include <ATen/ops/_values_meta.h>
+#include <ATen/ops/_values_copy_meta.h>
+#include <ATen/ops/_version_meta.h>
+#include <ATen/ops/_weight_int4pack_mm_meta.h>
+#include <ATen/ops/_weight_int8pack_mm_meta.h>
+#include <ATen/ops/_weight_norm_meta.h>
+#include <ATen/ops/_weight_norm_differentiable_backward_meta.h>
+#include <ATen/ops/_weight_norm_interface_meta.h>
+#include <ATen/ops/_weight_norm_interface_backward_meta.h>
+#include <ATen/ops/abs_meta.h>
+#include <ATen/ops/absolute_meta.h>
+#include <ATen/ops/acos_meta.h>
+#include <ATen/ops/acosh_meta.h>
+#include <ATen/ops/adaptive_avg_pool1d_meta.h>
+#include <ATen/ops/adaptive_avg_pool2d_meta.h>
+#include <ATen/ops/adaptive_avg_pool3d_meta.h>
+#include <ATen/ops/adaptive_avg_pool3d_backward_meta.h>
+#include <ATen/ops/adaptive_max_pool1d_meta.h>
+#include <ATen/ops/adaptive_max_pool2d_meta.h>
+#include <ATen/ops/adaptive_max_pool2d_backward_meta.h>
+#include <ATen/ops/adaptive_max_pool3d_meta.h>
+#include <ATen/ops/adaptive_max_pool3d_backward_meta.h>
+#include <ATen/ops/add_meta.h>
+#include <ATen/ops/addbmm_meta.h>
+#include <ATen/ops/addcdiv_meta.h>
+#include <ATen/ops/addcmul_meta.h>
+#include <ATen/ops/addmm_meta.h>
+#include <ATen/ops/addmv_meta.h>
+#include <ATen/ops/addr_meta.h>
+#include <ATen/ops/adjoint_meta.h>
+#include <ATen/ops/affine_grid_generator_meta.h>
+#include <ATen/ops/affine_grid_generator_backward_meta.h>
+#include <ATen/ops/alias_meta.h>
+#include <ATen/ops/alias_copy_meta.h>
+#include <ATen/ops/align_as_meta.h>
+#include <ATen/ops/align_tensors_meta.h>
+#include <ATen/ops/align_to_meta.h>
+#include <ATen/ops/all_meta.h>
+#include <ATen/ops/allclose_meta.h>
+#include <ATen/ops/alpha_dropout_meta.h>
+#include <ATen/ops/amax_meta.h>
+#include <ATen/ops/amin_meta.h>
+#include <ATen/ops/aminmax_meta.h>
+#include <ATen/ops/and_meta.h>
+#include <ATen/ops/angle_meta.h>
+#include <ATen/ops/any_meta.h>
+#include <ATen/ops/arange_meta.h>
+#include <ATen/ops/arccos_meta.h>
+#include <ATen/ops/arccosh_meta.h>
+#include <ATen/ops/arcsin_meta.h>
+#include <ATen/ops/arcsinh_meta.h>
+#include <ATen/ops/arctan_meta.h>
+#include <ATen/ops/arctan2_meta.h>
+#include <ATen/ops/arctanh_meta.h>
+#include <ATen/ops/argmax_meta.h>
+#include <ATen/ops/argmin_meta.h>
+#include <ATen/ops/argsort_meta.h>
+#include <ATen/ops/argwhere_meta.h>
+#include <ATen/ops/as_strided_meta.h>
+#include <ATen/ops/as_strided_copy_meta.h>
+#include <ATen/ops/as_strided_scatter_meta.h>
+#include <ATen/ops/asin_meta.h>
+#include <ATen/ops/asinh_meta.h>
+#include <ATen/ops/atan_meta.h>
+#include <ATen/ops/atan2_meta.h>
+#include <ATen/ops/atanh_meta.h>
+#include <ATen/ops/atleast_1d_meta.h>
+#include <ATen/ops/atleast_2d_meta.h>
+#include <ATen/ops/atleast_3d_meta.h>
+#include <ATen/ops/avg_pool1d_meta.h>
+#include <ATen/ops/avg_pool2d_meta.h>
+#include <ATen/ops/avg_pool2d_backward_meta.h>
+#include <ATen/ops/avg_pool3d_meta.h>
+#include <ATen/ops/avg_pool3d_backward_meta.h>
+#include <ATen/ops/baddbmm_meta.h>
+#include <ATen/ops/bartlett_window_meta.h>
+#include <ATen/ops/batch_norm_meta.h>
+#include <ATen/ops/batch_norm_backward_elemt_meta.h>
+#include <ATen/ops/batch_norm_backward_reduce_meta.h>
+#include <ATen/ops/batch_norm_elemt_meta.h>
+#include <ATen/ops/batch_norm_gather_stats_meta.h>
+#include <ATen/ops/batch_norm_gather_stats_with_counts_meta.h>
+#include <ATen/ops/batch_norm_stats_meta.h>
+#include <ATen/ops/batch_norm_update_stats_meta.h>
+#include <ATen/ops/bernoulli_meta.h>
+#include <ATen/ops/bilinear_meta.h>
+#include <ATen/ops/binary_cross_entropy_meta.h>
+#include <ATen/ops/binary_cross_entropy_backward_meta.h>
+#include <ATen/ops/binary_cross_entropy_with_logits_meta.h>
+#include <ATen/ops/bincount_meta.h>
+#include <ATen/ops/binomial_meta.h>
+#include <ATen/ops/bitwise_and_meta.h>
+#include <ATen/ops/bitwise_left_shift_meta.h>
+#include <ATen/ops/bitwise_not_meta.h>
+#include <ATen/ops/bitwise_or_meta.h>
+#include <ATen/ops/bitwise_right_shift_meta.h>
+#include <ATen/ops/bitwise_xor_meta.h>
+#include <ATen/ops/blackman_window_meta.h>
+#include <ATen/ops/block_diag_meta.h>
+#include <ATen/ops/bmm_meta.h>
+#include <ATen/ops/broadcast_tensors_meta.h>
+#include <ATen/ops/broadcast_to_meta.h>
+#include <ATen/ops/bucketize_meta.h>
+#include <ATen/ops/can_cast_meta.h>
+#include <ATen/ops/cartesian_prod_meta.h>
+#include <ATen/ops/cat_meta.h>
+#include <ATen/ops/cauchy_meta.h>
+#include <ATen/ops/ccol_indices_meta.h>
+#include <ATen/ops/ccol_indices_copy_meta.h>
+#include <ATen/ops/cdist_meta.h>
+#include <ATen/ops/ceil_meta.h>
+#include <ATen/ops/celu_meta.h>
+#include <ATen/ops/chain_matmul_meta.h>
+#include <ATen/ops/chalf_meta.h>
+#include <ATen/ops/channel_shuffle_meta.h>
+#include <ATen/ops/cholesky_meta.h>
+#include <ATen/ops/cholesky_inverse_meta.h>
+#include <ATen/ops/cholesky_solve_meta.h>
+#include <ATen/ops/choose_qparams_optimized_meta.h>
+#include <ATen/ops/chunk_meta.h>
+#include <ATen/ops/clamp_meta.h>
+#include <ATen/ops/clamp_max_meta.h>
+#include <ATen/ops/clamp_min_meta.h>
+#include <ATen/ops/clip_meta.h>
+#include <ATen/ops/clone_meta.h>
+#include <ATen/ops/coalesce_meta.h>
+#include <ATen/ops/col2im_meta.h>
+#include <ATen/ops/col_indices_meta.h>
+#include <ATen/ops/col_indices_copy_meta.h>
+#include <ATen/ops/column_stack_meta.h>
+#include <ATen/ops/combinations_meta.h>
+#include <ATen/ops/complex_meta.h>
+#include <ATen/ops/concat_meta.h>
+#include <ATen/ops/concatenate_meta.h>
+#include <ATen/ops/conj_meta.h>
+#include <ATen/ops/conj_physical_meta.h>
+#include <ATen/ops/constant_pad_nd_meta.h>
+#include <ATen/ops/contiguous_meta.h>
+#include <ATen/ops/conv1d_meta.h>
+#include <ATen/ops/conv2d_meta.h>
+#include <ATen/ops/conv3d_meta.h>
+#include <ATen/ops/conv_depthwise3d_meta.h>
+#include <ATen/ops/conv_tbc_meta.h>
+#include <ATen/ops/conv_tbc_backward_meta.h>
+#include <ATen/ops/conv_transpose1d_meta.h>
+#include <ATen/ops/conv_transpose2d_meta.h>
+#include <ATen/ops/conv_transpose3d_meta.h>
+#include <ATen/ops/convolution_meta.h>
+#include <ATen/ops/convolution_backward_meta.h>
+#include <ATen/ops/convolution_backward_overrideable_meta.h>
+#include <ATen/ops/convolution_overrideable_meta.h>
+#include <ATen/ops/copy_meta.h>
+#include <ATen/ops/copy_sparse_to_sparse_meta.h>
+#include <ATen/ops/copysign_meta.h>
+#include <ATen/ops/corrcoef_meta.h>
+#include <ATen/ops/cos_meta.h>
+#include <ATen/ops/cosh_meta.h>
+#include <ATen/ops/cosine_embedding_loss_meta.h>
+#include <ATen/ops/cosine_similarity_meta.h>
+#include <ATen/ops/count_nonzero_meta.h>
+#include <ATen/ops/cov_meta.h>
+#include <ATen/ops/cross_meta.h>
+#include <ATen/ops/cross_entropy_loss_meta.h>
+#include <ATen/ops/crow_indices_meta.h>
+#include <ATen/ops/crow_indices_copy_meta.h>
+#include <ATen/ops/ctc_loss_meta.h>
+#include <ATen/ops/cudnn_affine_grid_generator_meta.h>
+#include <ATen/ops/cudnn_affine_grid_generator_backward_meta.h>
+#include <ATen/ops/cudnn_batch_norm_meta.h>
+#include <ATen/ops/cudnn_batch_norm_backward_meta.h>
+#include <ATen/ops/cudnn_convolution_meta.h>
+#include <ATen/ops/cudnn_convolution_add_relu_meta.h>
+#include <ATen/ops/cudnn_convolution_relu_meta.h>
+#include <ATen/ops/cudnn_convolution_transpose_meta.h>
+#include <ATen/ops/cudnn_grid_sampler_meta.h>
+#include <ATen/ops/cudnn_grid_sampler_backward_meta.h>
+#include <ATen/ops/cudnn_is_acceptable_meta.h>
+#include <ATen/ops/cummax_meta.h>
+#include <ATen/ops/cummaxmin_backward_meta.h>
+#include <ATen/ops/cummin_meta.h>
+#include <ATen/ops/cumprod_meta.h>
+#include <ATen/ops/cumprod_backward_meta.h>
+#include <ATen/ops/cumsum_meta.h>
+#include <ATen/ops/cumulative_trapezoid_meta.h>
+#include <ATen/ops/data_meta.h>
+#include <ATen/ops/deg2rad_meta.h>
+#include <ATen/ops/dense_dim_meta.h>
+#include <ATen/ops/dequantize_meta.h>
+#include <ATen/ops/det_meta.h>
+#include <ATen/ops/detach_meta.h>
+#include <ATen/ops/detach_copy_meta.h>
+#include <ATen/ops/diag_meta.h>
+#include <ATen/ops/diag_embed_meta.h>
+#include <ATen/ops/diagflat_meta.h>
+#include <ATen/ops/diagonal_meta.h>
+#include <ATen/ops/diagonal_backward_meta.h>
+#include <ATen/ops/diagonal_copy_meta.h>
+#include <ATen/ops/diagonal_scatter_meta.h>
+#include <ATen/ops/diff_meta.h>
+#include <ATen/ops/digamma_meta.h>
+#include <ATen/ops/dist_meta.h>
+#include <ATen/ops/div_meta.h>
+#include <ATen/ops/divide_meta.h>
+#include <ATen/ops/dot_meta.h>
+#include <ATen/ops/dropout_meta.h>
+#include <ATen/ops/dsplit_meta.h>
+#include <ATen/ops/dstack_meta.h>
+#include <ATen/ops/einsum_meta.h>
+#include <ATen/ops/elu_meta.h>
+#include <ATen/ops/elu_backward_meta.h>
+#include <ATen/ops/embedding_meta.h>
+#include <ATen/ops/embedding_backward_meta.h>
+#include <ATen/ops/embedding_bag_meta.h>
+#include <ATen/ops/embedding_dense_backward_meta.h>
+#include <ATen/ops/embedding_renorm_meta.h>
+#include <ATen/ops/embedding_sparse_backward_meta.h>
+#include <ATen/ops/empty_meta.h>
+#include <ATen/ops/empty_like_meta.h>
+#include <ATen/ops/empty_permuted_meta.h>
+#include <ATen/ops/empty_quantized_meta.h>
+#include <ATen/ops/empty_strided_meta.h>
+#include <ATen/ops/eq_meta.h>
+#include <ATen/ops/equal_meta.h>
+#include <ATen/ops/erf_meta.h>
+#include <ATen/ops/erfc_meta.h>
+#include <ATen/ops/erfinv_meta.h>
+#include <ATen/ops/exp_meta.h>
+#include <ATen/ops/exp2_meta.h>
+#include <ATen/ops/expand_meta.h>
+#include <ATen/ops/expand_as_meta.h>
+#include <ATen/ops/expand_copy_meta.h>
+#include <ATen/ops/expm1_meta.h>
+#include <ATen/ops/exponential_meta.h>
+#include <ATen/ops/eye_meta.h>
+#include <ATen/ops/fake_quantize_per_channel_affine_meta.h>
+#include <ATen/ops/fake_quantize_per_channel_affine_cachemask_meta.h>
+#include <ATen/ops/fake_quantize_per_channel_affine_cachemask_backward_meta.h>
+#include <ATen/ops/fake_quantize_per_tensor_affine_meta.h>
+#include <ATen/ops/fake_quantize_per_tensor_affine_cachemask_meta.h>
+#include <ATen/ops/fake_quantize_per_tensor_affine_cachemask_backward_meta.h>
+#include <ATen/ops/fbgemm_linear_fp16_weight_meta.h>
+#include <ATen/ops/fbgemm_linear_fp16_weight_fp32_activation_meta.h>
+#include <ATen/ops/fbgemm_linear_int8_weight_meta.h>
+#include <ATen/ops/fbgemm_linear_int8_weight_fp32_activation_meta.h>
+#include <ATen/ops/fbgemm_linear_quantize_weight_meta.h>
+#include <ATen/ops/fbgemm_pack_gemm_matrix_fp16_meta.h>
+#include <ATen/ops/fbgemm_pack_quantized_matrix_meta.h>
+#include <ATen/ops/feature_alpha_dropout_meta.h>
+#include <ATen/ops/feature_dropout_meta.h>
+#include <ATen/ops/fft_fft_meta.h>
+#include <ATen/ops/fft_fft2_meta.h>
+#include <ATen/ops/fft_fftfreq_meta.h>
+#include <ATen/ops/fft_fftn_meta.h>
+#include <ATen/ops/fft_fftshift_meta.h>
+#include <ATen/ops/fft_hfft_meta.h>
+#include <ATen/ops/fft_hfft2_meta.h>
+#include <ATen/ops/fft_hfftn_meta.h>
+#include <ATen/ops/fft_ifft_meta.h>
+#include <ATen/ops/fft_ifft2_meta.h>
+#include <ATen/ops/fft_ifftn_meta.h>
+#include <ATen/ops/fft_ifftshift_meta.h>
+#include <ATen/ops/fft_ihfft_meta.h>
+#include <ATen/ops/fft_ihfft2_meta.h>
+#include <ATen/ops/fft_ihfftn_meta.h>
+#include <ATen/ops/fft_irfft_meta.h>
+#include <ATen/ops/fft_irfft2_meta.h>
+#include <ATen/ops/fft_irfftn_meta.h>
+#include <ATen/ops/fft_rfft_meta.h>
+#include <ATen/ops/fft_rfft2_meta.h>
+#include <ATen/ops/fft_rfftfreq_meta.h>
+#include <ATen/ops/fft_rfftn_meta.h>
+#include <ATen/ops/fill_meta.h>
+#include <ATen/ops/fill_diagonal_meta.h>
+#include <ATen/ops/fix_meta.h>
+#include <ATen/ops/flatten_meta.h>
+#include <ATen/ops/flatten_dense_tensors_meta.h>
+#include <ATen/ops/flip_meta.h>
+#include <ATen/ops/fliplr_meta.h>
+#include <ATen/ops/flipud_meta.h>
+#include <ATen/ops/float_power_meta.h>
+#include <ATen/ops/floor_meta.h>
+#include <ATen/ops/floor_divide_meta.h>
+#include <ATen/ops/fmax_meta.h>
+#include <ATen/ops/fmin_meta.h>
+#include <ATen/ops/fmod_meta.h>
+#include <ATen/ops/frac_meta.h>
+#include <ATen/ops/fractional_max_pool2d_meta.h>
+#include <ATen/ops/fractional_max_pool2d_backward_meta.h>
+#include <ATen/ops/fractional_max_pool3d_meta.h>
+#include <ATen/ops/fractional_max_pool3d_backward_meta.h>
+#include <ATen/ops/frexp_meta.h>
+#include <ATen/ops/frobenius_norm_meta.h>
+#include <ATen/ops/from_file_meta.h>
+#include <ATen/ops/full_meta.h>
+#include <ATen/ops/full_like_meta.h>
+#include <ATen/ops/fused_moving_avg_obs_fake_quant_meta.h>
+#include <ATen/ops/gather_meta.h>
+#include <ATen/ops/gather_backward_meta.h>
+#include <ATen/ops/gcd_meta.h>
+#include <ATen/ops/ge_meta.h>
+#include <ATen/ops/gelu_meta.h>
+#include <ATen/ops/gelu_backward_meta.h>
+#include <ATen/ops/geometric_meta.h>
+#include <ATen/ops/geqrf_meta.h>
+#include <ATen/ops/ger_meta.h>
+#include <ATen/ops/glu_meta.h>
+#include <ATen/ops/glu_backward_meta.h>
+#include <ATen/ops/glu_backward_jvp_meta.h>
+#include <ATen/ops/glu_jvp_meta.h>
+#include <ATen/ops/gradient_meta.h>
+#include <ATen/ops/greater_meta.h>
+#include <ATen/ops/greater_equal_meta.h>
+#include <ATen/ops/grid_sampler_meta.h>
+#include <ATen/ops/grid_sampler_2d_meta.h>
+#include <ATen/ops/grid_sampler_2d_backward_meta.h>
+#include <ATen/ops/grid_sampler_3d_meta.h>
+#include <ATen/ops/grid_sampler_3d_backward_meta.h>
+#include <ATen/ops/group_norm_meta.h>
+#include <ATen/ops/gru_meta.h>
+#include <ATen/ops/gru_cell_meta.h>
+#include <ATen/ops/gt_meta.h>
+#include <ATen/ops/hamming_window_meta.h>
+#include <ATen/ops/hann_window_meta.h>
+#include <ATen/ops/hardshrink_meta.h>
+#include <ATen/ops/hardshrink_backward_meta.h>
+#include <ATen/ops/hardsigmoid_meta.h>
+#include <ATen/ops/hardsigmoid_backward_meta.h>
+#include <ATen/ops/hardswish_meta.h>
+#include <ATen/ops/hardswish_backward_meta.h>
+#include <ATen/ops/hardtanh_meta.h>
+#include <ATen/ops/hardtanh_backward_meta.h>
+#include <ATen/ops/heaviside_meta.h>
+#include <ATen/ops/hinge_embedding_loss_meta.h>
+#include <ATen/ops/histc_meta.h>
+#include <ATen/ops/histogram_meta.h>
+#include <ATen/ops/histogramdd_meta.h>
+#include <ATen/ops/hsplit_meta.h>
+#include <ATen/ops/hspmm_meta.h>
+#include <ATen/ops/hstack_meta.h>
+#include <ATen/ops/huber_loss_meta.h>
+#include <ATen/ops/huber_loss_backward_meta.h>
+#include <ATen/ops/hypot_meta.h>
+#include <ATen/ops/i0_meta.h>
+#include <ATen/ops/igamma_meta.h>
+#include <ATen/ops/igammac_meta.h>
+#include <ATen/ops/im2col_meta.h>
+#include <ATen/ops/imag_meta.h>
+#include <ATen/ops/index_meta.h>
+#include <ATen/ops/index_add_meta.h>
+#include <ATen/ops/index_copy_meta.h>
+#include <ATen/ops/index_fill_meta.h>
+#include <ATen/ops/index_put_meta.h>
+#include <ATen/ops/index_reduce_meta.h>
+#include <ATen/ops/index_select_meta.h>
+#include <ATen/ops/index_select_backward_meta.h>
+#include <ATen/ops/indices_meta.h>
+#include <ATen/ops/indices_copy_meta.h>
+#include <ATen/ops/infinitely_differentiable_gelu_backward_meta.h>
+#include <ATen/ops/inner_meta.h>
+#include <ATen/ops/instance_norm_meta.h>
+#include <ATen/ops/int_repr_meta.h>
+#include <ATen/ops/inverse_meta.h>
+#include <ATen/ops/is_coalesced_meta.h>
+#include <ATen/ops/is_complex_meta.h>
+#include <ATen/ops/is_conj_meta.h>
+#include <ATen/ops/is_distributed_meta.h>
+#include <ATen/ops/is_floating_point_meta.h>
+#include <ATen/ops/is_inference_meta.h>
+#include <ATen/ops/is_leaf_meta.h>
+#include <ATen/ops/is_neg_meta.h>
+#include <ATen/ops/is_nonzero_meta.h>
+#include <ATen/ops/is_pinned_meta.h>
+#include <ATen/ops/is_same_size_meta.h>
+#include <ATen/ops/is_set_to_meta.h>
+#include <ATen/ops/is_signed_meta.h>
+#include <ATen/ops/is_vulkan_available_meta.h>
+#include <ATen/ops/isclose_meta.h>
+#include <ATen/ops/isfinite_meta.h>
+#include <ATen/ops/isin_meta.h>
+#include <ATen/ops/isinf_meta.h>
+#include <ATen/ops/isnan_meta.h>
+#include <ATen/ops/isneginf_meta.h>
+#include <ATen/ops/isposinf_meta.h>
+#include <ATen/ops/isreal_meta.h>
+#include <ATen/ops/istft_meta.h>
+#include <ATen/ops/item_meta.h>
+#include <ATen/ops/kaiser_window_meta.h>
+#include <ATen/ops/kl_div_meta.h>
+#include <ATen/ops/kron_meta.h>
+#include <ATen/ops/kthvalue_meta.h>
+#include <ATen/ops/l1_loss_meta.h>
+#include <ATen/ops/layer_norm_meta.h>
+#include <ATen/ops/lcm_meta.h>
+#include <ATen/ops/ldexp_meta.h>
+#include <ATen/ops/le_meta.h>
+#include <ATen/ops/leaky_relu_meta.h>
+#include <ATen/ops/leaky_relu_backward_meta.h>
+#include <ATen/ops/lerp_meta.h>
+#include <ATen/ops/less_meta.h>
+#include <ATen/ops/less_equal_meta.h>
+#include <ATen/ops/lgamma_meta.h>
+#include <ATen/ops/lift_meta.h>
+#include <ATen/ops/lift_fresh_meta.h>
+#include <ATen/ops/lift_fresh_copy_meta.h>
+#include <ATen/ops/linalg_cholesky_meta.h>
+#include <ATen/ops/linalg_cholesky_ex_meta.h>
+#include <ATen/ops/linalg_cond_meta.h>
+#include <ATen/ops/linalg_cross_meta.h>
+#include <ATen/ops/linalg_det_meta.h>
+#include <ATen/ops/linalg_diagonal_meta.h>
+#include <ATen/ops/linalg_eig_meta.h>
+#include <ATen/ops/linalg_eigh_meta.h>
+#include <ATen/ops/linalg_eigvals_meta.h>
+#include <ATen/ops/linalg_eigvalsh_meta.h>
+#include <ATen/ops/linalg_householder_product_meta.h>
+#include <ATen/ops/linalg_inv_meta.h>
+#include <ATen/ops/linalg_inv_ex_meta.h>
+#include <ATen/ops/linalg_ldl_factor_meta.h>
+#include <ATen/ops/linalg_ldl_factor_ex_meta.h>
+#include <ATen/ops/linalg_ldl_solve_meta.h>
+#include <ATen/ops/linalg_lstsq_meta.h>
+#include <ATen/ops/linalg_lu_meta.h>
+#include <ATen/ops/linalg_lu_factor_meta.h>
+#include <ATen/ops/linalg_lu_factor_ex_meta.h>
+#include <ATen/ops/linalg_lu_solve_meta.h>
+#include <ATen/ops/linalg_matmul_meta.h>
+#include <ATen/ops/linalg_matrix_exp_meta.h>
+#include <ATen/ops/linalg_matrix_norm_meta.h>
+#include <ATen/ops/linalg_matrix_power_meta.h>
+#include <ATen/ops/linalg_matrix_rank_meta.h>
+#include <ATen/ops/linalg_multi_dot_meta.h>
+#include <ATen/ops/linalg_norm_meta.h>
+#include <ATen/ops/linalg_pinv_meta.h>
+#include <ATen/ops/linalg_qr_meta.h>
+#include <ATen/ops/linalg_slogdet_meta.h>
+#include <ATen/ops/linalg_solve_meta.h>
+#include <ATen/ops/linalg_solve_ex_meta.h>
+#include <ATen/ops/linalg_solve_triangular_meta.h>
+#include <ATen/ops/linalg_svd_meta.h>
+#include <ATen/ops/linalg_svdvals_meta.h>
+#include <ATen/ops/linalg_tensorinv_meta.h>
+#include <ATen/ops/linalg_tensorsolve_meta.h>
+#include <ATen/ops/linalg_vander_meta.h>
+#include <ATen/ops/linalg_vecdot_meta.h>
+#include <ATen/ops/linalg_vector_norm_meta.h>
+#include <ATen/ops/linear_meta.h>
+#include <ATen/ops/linear_backward_meta.h>
+#include <ATen/ops/linspace_meta.h>
+#include <ATen/ops/log_meta.h>
+#include <ATen/ops/log10_meta.h>
+#include <ATen/ops/log1p_meta.h>
+#include <ATen/ops/log2_meta.h>
+#include <ATen/ops/log_normal_meta.h>
+#include <ATen/ops/log_sigmoid_meta.h>
+#include <ATen/ops/log_sigmoid_backward_meta.h>
+#include <ATen/ops/log_sigmoid_forward_meta.h>
+#include <ATen/ops/log_softmax_meta.h>
+#include <ATen/ops/logaddexp_meta.h>
+#include <ATen/ops/logaddexp2_meta.h>
+#include <ATen/ops/logcumsumexp_meta.h>
+#include <ATen/ops/logdet_meta.h>
+#include <ATen/ops/logical_and_meta.h>
+#include <ATen/ops/logical_not_meta.h>
+#include <ATen/ops/logical_or_meta.h>
+#include <ATen/ops/logical_xor_meta.h>
+#include <ATen/ops/logit_meta.h>
+#include <ATen/ops/logit_backward_meta.h>
+#include <ATen/ops/logspace_meta.h>
+#include <ATen/ops/logsumexp_meta.h>
+#include <ATen/ops/lshift_meta.h>
+#include <ATen/ops/lstm_meta.h>
+#include <ATen/ops/lstm_cell_meta.h>
+#include <ATen/ops/lstm_mps_backward_meta.h>
+#include <ATen/ops/lt_meta.h>
+#include <ATen/ops/lu_solve_meta.h>
+#include <ATen/ops/lu_unpack_meta.h>
+#include <ATen/ops/mH_meta.h>
+#include <ATen/ops/mT_meta.h>
+#include <ATen/ops/margin_ranking_loss_meta.h>
+#include <ATen/ops/masked_fill_meta.h>
+#include <ATen/ops/masked_scatter_meta.h>
+#include <ATen/ops/masked_scatter_backward_meta.h>
+#include <ATen/ops/masked_select_meta.h>
+#include <ATen/ops/masked_select_backward_meta.h>
+#include <ATen/ops/matmul_meta.h>
+#include <ATen/ops/matmul_backward_meta.h>
+#include <ATen/ops/matrix_H_meta.h>
+#include <ATen/ops/matrix_exp_meta.h>
+#include <ATen/ops/matrix_exp_backward_meta.h>
+#include <ATen/ops/matrix_power_meta.h>
+#include <ATen/ops/max_meta.h>
+#include <ATen/ops/max_pool1d_meta.h>
+#include <ATen/ops/max_pool1d_with_indices_meta.h>
+#include <ATen/ops/max_pool2d_meta.h>
+#include <ATen/ops/max_pool2d_backward_meta.h>
+#include <ATen/ops/max_pool2d_with_indices_meta.h>
+#include <ATen/ops/max_pool2d_with_indices_backward_meta.h>
+#include <ATen/ops/max_pool3d_meta.h>
+#include <ATen/ops/max_pool3d_with_indices_meta.h>
+#include <ATen/ops/max_pool3d_with_indices_backward_meta.h>
+#include <ATen/ops/max_unpool2d_meta.h>
+#include <ATen/ops/max_unpool3d_meta.h>
+#include <ATen/ops/maximum_meta.h>
+#include <ATen/ops/mean_meta.h>
+#include <ATen/ops/median_meta.h>
+#include <ATen/ops/meshgrid_meta.h>
+#include <ATen/ops/min_meta.h>
+#include <ATen/ops/minimum_meta.h>
+#include <ATen/ops/miopen_batch_norm_meta.h>
+#include <ATen/ops/miopen_batch_norm_backward_meta.h>
+#include <ATen/ops/miopen_convolution_meta.h>
+#include <ATen/ops/miopen_convolution_add_relu_meta.h>
+#include <ATen/ops/miopen_convolution_relu_meta.h>
+#include <ATen/ops/miopen_convolution_transpose_meta.h>
+#include <ATen/ops/miopen_depthwise_convolution_meta.h>
+#include <ATen/ops/miopen_rnn_meta.h>
+#include <ATen/ops/miopen_rnn_backward_meta.h>
+#include <ATen/ops/mish_meta.h>
+#include <ATen/ops/mish_backward_meta.h>
+#include <ATen/ops/mkldnn_adaptive_avg_pool2d_meta.h>
+#include <ATen/ops/mkldnn_adaptive_avg_pool2d_backward_meta.h>
+#include <ATen/ops/mkldnn_convolution_meta.h>
+#include <ATen/ops/mkldnn_linear_meta.h>
+#include <ATen/ops/mkldnn_linear_backward_meta.h>
+#include <ATen/ops/mkldnn_linear_backward_input_meta.h>
+#include <ATen/ops/mkldnn_linear_backward_weights_meta.h>
+#include <ATen/ops/mkldnn_max_pool2d_meta.h>
+#include <ATen/ops/mkldnn_max_pool2d_backward_meta.h>
+#include <ATen/ops/mkldnn_max_pool3d_meta.h>
+#include <ATen/ops/mkldnn_max_pool3d_backward_meta.h>
+#include <ATen/ops/mkldnn_reorder_conv2d_weight_meta.h>
+#include <ATen/ops/mkldnn_reorder_conv3d_weight_meta.h>
+#include <ATen/ops/mkldnn_rnn_layer_meta.h>
+#include <ATen/ops/mkldnn_rnn_layer_backward_meta.h>
+#include <ATen/ops/mm_meta.h>
+#include <ATen/ops/mode_meta.h>
+#include <ATen/ops/moveaxis_meta.h>
+#include <ATen/ops/movedim_meta.h>
+#include <ATen/ops/mps_convolution_backward_meta.h>
+#include <ATen/ops/mps_convolution_transpose_backward_meta.h>
+#include <ATen/ops/mse_loss_meta.h>
+#include <ATen/ops/mse_loss_backward_meta.h>
+#include <ATen/ops/msort_meta.h>
+#include <ATen/ops/mul_meta.h>
+#include <ATen/ops/multi_margin_loss_meta.h>
+#include <ATen/ops/multi_margin_loss_backward_meta.h>
+#include <ATen/ops/multilabel_margin_loss_meta.h>
+#include <ATen/ops/multilabel_margin_loss_backward_meta.h>
+#include <ATen/ops/multilabel_margin_loss_forward_meta.h>
+#include <ATen/ops/multinomial_meta.h>
+#include <ATen/ops/multiply_meta.h>
+#include <ATen/ops/mv_meta.h>
+#include <ATen/ops/mvlgamma_meta.h>
+#include <ATen/ops/nan_to_num_meta.h>
+#include <ATen/ops/nanmean_meta.h>
+#include <ATen/ops/nanmedian_meta.h>
+#include <ATen/ops/nanquantile_meta.h>
+#include <ATen/ops/nansum_meta.h>
+#include <ATen/ops/narrow_meta.h>
+#include <ATen/ops/narrow_copy_meta.h>
+#include <ATen/ops/native_batch_norm_meta.h>
+#include <ATen/ops/native_batch_norm_backward_meta.h>
+#include <ATen/ops/native_channel_shuffle_meta.h>
+#include <ATen/ops/native_dropout_meta.h>
+#include <ATen/ops/native_dropout_backward_meta.h>
+#include <ATen/ops/native_group_norm_meta.h>
+#include <ATen/ops/native_group_norm_backward_meta.h>
+#include <ATen/ops/native_layer_norm_meta.h>
+#include <ATen/ops/native_layer_norm_backward_meta.h>
+#include <ATen/ops/native_norm_meta.h>
+#include <ATen/ops/ne_meta.h>
+#include <ATen/ops/neg_meta.h>
+#include <ATen/ops/negative_meta.h>
+#include <ATen/ops/nested_to_padded_tensor_meta.h>
+#include <ATen/ops/new_empty_meta.h>
+#include <ATen/ops/new_empty_strided_meta.h>
+#include <ATen/ops/new_full_meta.h>
+#include <ATen/ops/new_ones_meta.h>
+#include <ATen/ops/new_zeros_meta.h>
+#include <ATen/ops/nextafter_meta.h>
+#include <ATen/ops/nll_loss_meta.h>
+#include <ATen/ops/nll_loss2d_meta.h>
+#include <ATen/ops/nll_loss2d_backward_meta.h>
+#include <ATen/ops/nll_loss2d_forward_meta.h>
+#include <ATen/ops/nll_loss_backward_meta.h>
+#include <ATen/ops/nll_loss_forward_meta.h>
+#include <ATen/ops/nll_loss_nd_meta.h>
+#include <ATen/ops/nonzero_meta.h>
+#include <ATen/ops/nonzero_numpy_meta.h>
+#include <ATen/ops/nonzero_static_meta.h>
+#include <ATen/ops/norm_meta.h>
+#include <ATen/ops/norm_except_dim_meta.h>
+#include <ATen/ops/normal_meta.h>
+#include <ATen/ops/not_equal_meta.h>
+#include <ATen/ops/nuclear_norm_meta.h>
+#include <ATen/ops/numpy_T_meta.h>
+#include <ATen/ops/one_hot_meta.h>
+#include <ATen/ops/ones_meta.h>
+#include <ATen/ops/ones_like_meta.h>
+#include <ATen/ops/or_meta.h>
+#include <ATen/ops/orgqr_meta.h>
+#include <ATen/ops/ormqr_meta.h>
+#include <ATen/ops/outer_meta.h>
+#include <ATen/ops/output_nr_meta.h>
+#include <ATen/ops/pad_meta.h>
+#include <ATen/ops/pad_sequence_meta.h>
+#include <ATen/ops/pairwise_distance_meta.h>
+#include <ATen/ops/pdist_meta.h>
+#include <ATen/ops/permute_meta.h>
+#include <ATen/ops/permute_copy_meta.h>
+#include <ATen/ops/pin_memory_meta.h>
+#include <ATen/ops/pinverse_meta.h>
+#include <ATen/ops/pixel_shuffle_meta.h>
+#include <ATen/ops/pixel_unshuffle_meta.h>
+#include <ATen/ops/poisson_meta.h>
+#include <ATen/ops/poisson_nll_loss_meta.h>
+#include <ATen/ops/polar_meta.h>
+#include <ATen/ops/polygamma_meta.h>
+#include <ATen/ops/positive_meta.h>
+#include <ATen/ops/pow_meta.h>
+#include <ATen/ops/prelu_meta.h>
+#include <ATen/ops/prod_meta.h>
+#include <ATen/ops/promote_types_meta.h>
+#include <ATen/ops/put_meta.h>
+#include <ATen/ops/q_per_channel_axis_meta.h>
+#include <ATen/ops/q_per_channel_scales_meta.h>
+#include <ATen/ops/q_per_channel_zero_points_meta.h>
+#include <ATen/ops/q_scale_meta.h>
+#include <ATen/ops/q_zero_point_meta.h>
+#include <ATen/ops/qr_meta.h>
+#include <ATen/ops/qscheme_meta.h>
+#include <ATen/ops/quantile_meta.h>
+#include <ATen/ops/quantize_per_channel_meta.h>
+#include <ATen/ops/quantize_per_tensor_meta.h>
+#include <ATen/ops/quantize_per_tensor_dynamic_meta.h>
+#include <ATen/ops/quantized_batch_norm_meta.h>
+#include <ATen/ops/quantized_gru_cell_meta.h>
+#include <ATen/ops/quantized_lstm_cell_meta.h>
+#include <ATen/ops/quantized_max_pool1d_meta.h>
+#include <ATen/ops/quantized_max_pool2d_meta.h>
+#include <ATen/ops/quantized_max_pool3d_meta.h>
+#include <ATen/ops/quantized_rnn_relu_cell_meta.h>
+#include <ATen/ops/quantized_rnn_tanh_cell_meta.h>
+#include <ATen/ops/rad2deg_meta.h>
+#include <ATen/ops/rand_meta.h>
+#include <ATen/ops/rand_like_meta.h>
+#include <ATen/ops/randint_meta.h>
+#include <ATen/ops/randint_like_meta.h>
+#include <ATen/ops/randn_meta.h>
+#include <ATen/ops/randn_like_meta.h>
+#include <ATen/ops/random_meta.h>
+#include <ATen/ops/randperm_meta.h>
+#include <ATen/ops/range_meta.h>
+#include <ATen/ops/ravel_meta.h>
+#include <ATen/ops/real_meta.h>
+#include <ATen/ops/reciprocal_meta.h>
+#include <ATen/ops/record_stream_meta.h>
+#include <ATen/ops/refine_names_meta.h>
+#include <ATen/ops/reflection_pad1d_meta.h>
+#include <ATen/ops/reflection_pad1d_backward_meta.h>
+#include <ATen/ops/reflection_pad2d_meta.h>
+#include <ATen/ops/reflection_pad2d_backward_meta.h>
+#include <ATen/ops/reflection_pad3d_meta.h>
+#include <ATen/ops/reflection_pad3d_backward_meta.h>
+#include <ATen/ops/relu_meta.h>
+#include <ATen/ops/relu6_meta.h>
+#include <ATen/ops/remainder_meta.h>
+#include <ATen/ops/rename_meta.h>
+#include <ATen/ops/renorm_meta.h>
+#include <ATen/ops/repeat_meta.h>
+#include <ATen/ops/repeat_interleave_meta.h>
+#include <ATen/ops/replication_pad1d_meta.h>
+#include <ATen/ops/replication_pad1d_backward_meta.h>
+#include <ATen/ops/replication_pad2d_meta.h>
+#include <ATen/ops/replication_pad2d_backward_meta.h>
+#include <ATen/ops/replication_pad3d_meta.h>
+#include <ATen/ops/replication_pad3d_backward_meta.h>
+#include <ATen/ops/requires_grad_meta.h>
+#include <ATen/ops/reshape_meta.h>
+#include <ATen/ops/reshape_as_meta.h>
+#include <ATen/ops/resize_meta.h>
+#include <ATen/ops/resize_as_meta.h>
+#include <ATen/ops/resize_as_sparse_meta.h>
+#include <ATen/ops/resolve_conj_meta.h>
+#include <ATen/ops/resolve_neg_meta.h>
+#include <ATen/ops/result_type_meta.h>
+#include <ATen/ops/retain_grad_meta.h>
+#include <ATen/ops/retains_grad_meta.h>
+#include <ATen/ops/rnn_relu_meta.h>
+#include <ATen/ops/rnn_relu_cell_meta.h>
+#include <ATen/ops/rnn_tanh_meta.h>
+#include <ATen/ops/rnn_tanh_cell_meta.h>
+#include <ATen/ops/roll_meta.h>
+#include <ATen/ops/rot90_meta.h>
+#include <ATen/ops/round_meta.h>
+#include <ATen/ops/row_indices_meta.h>
+#include <ATen/ops/row_indices_copy_meta.h>
+#include <ATen/ops/row_stack_meta.h>
+#include <ATen/ops/rrelu_meta.h>
+#include <ATen/ops/rrelu_with_noise_meta.h>
+#include <ATen/ops/rrelu_with_noise_backward_meta.h>
+#include <ATen/ops/rshift_meta.h>
+#include <ATen/ops/rsqrt_meta.h>
+#include <ATen/ops/rsub_meta.h>
+#include <ATen/ops/scalar_tensor_meta.h>
+#include <ATen/ops/scaled_dot_product_attention_meta.h>
+#include <ATen/ops/scatter_meta.h>
+#include <ATen/ops/scatter_add_meta.h>
+#include <ATen/ops/scatter_reduce_meta.h>
+#include <ATen/ops/searchsorted_meta.h>
+#include <ATen/ops/segment_reduce_meta.h>
+#include <ATen/ops/select_meta.h>
+#include <ATen/ops/select_backward_meta.h>
+#include <ATen/ops/select_copy_meta.h>
+#include <ATen/ops/select_scatter_meta.h>
+#include <ATen/ops/selu_meta.h>
+#include <ATen/ops/set_meta.h>
+#include <ATen/ops/set_data_meta.h>
+#include <ATen/ops/sgn_meta.h>
+#include <ATen/ops/sigmoid_meta.h>
+#include <ATen/ops/sigmoid_backward_meta.h>
+#include <ATen/ops/sign_meta.h>
+#include <ATen/ops/signbit_meta.h>
+#include <ATen/ops/silu_meta.h>
+#include <ATen/ops/silu_backward_meta.h>
+#include <ATen/ops/sin_meta.h>
+#include <ATen/ops/sinc_meta.h>
+#include <ATen/ops/sinh_meta.h>
+#include <ATen/ops/size_meta.h>
+#include <ATen/ops/slice_meta.h>
+#include <ATen/ops/slice_backward_meta.h>
+#include <ATen/ops/slice_copy_meta.h>
+#include <ATen/ops/slice_inverse_meta.h>
+#include <ATen/ops/slice_scatter_meta.h>
+#include <ATen/ops/slogdet_meta.h>
+#include <ATen/ops/slow_conv3d_meta.h>
+#include <ATen/ops/slow_conv3d_forward_meta.h>
+#include <ATen/ops/slow_conv_dilated2d_meta.h>
+#include <ATen/ops/slow_conv_dilated3d_meta.h>
+#include <ATen/ops/slow_conv_transpose2d_meta.h>
+#include <ATen/ops/slow_conv_transpose3d_meta.h>
+#include <ATen/ops/smm_meta.h>
+#include <ATen/ops/smooth_l1_loss_meta.h>
+#include <ATen/ops/smooth_l1_loss_backward_meta.h>
+#include <ATen/ops/soft_margin_loss_meta.h>
+#include <ATen/ops/soft_margin_loss_backward_meta.h>
+#include <ATen/ops/softmax_meta.h>
+#include <ATen/ops/softplus_meta.h>
+#include <ATen/ops/softplus_backward_meta.h>
+#include <ATen/ops/softshrink_meta.h>
+#include <ATen/ops/softshrink_backward_meta.h>
+#include <ATen/ops/sort_meta.h>
+#include <ATen/ops/sparse_bsc_tensor_meta.h>
+#include <ATen/ops/sparse_bsr_tensor_meta.h>
+#include <ATen/ops/sparse_compressed_tensor_meta.h>
+#include <ATen/ops/sparse_coo_tensor_meta.h>
+#include <ATen/ops/sparse_csc_tensor_meta.h>
+#include <ATen/ops/sparse_csr_tensor_meta.h>
+#include <ATen/ops/sparse_dim_meta.h>
+#include <ATen/ops/sparse_mask_meta.h>
+#include <ATen/ops/sparse_resize_meta.h>
+#include <ATen/ops/sparse_resize_and_clear_meta.h>
+#include <ATen/ops/sparse_sampled_addmm_meta.h>
+#include <ATen/ops/special_airy_ai_meta.h>
+#include <ATen/ops/special_bessel_j0_meta.h>
+#include <ATen/ops/special_bessel_j1_meta.h>
+#include <ATen/ops/special_bessel_y0_meta.h>
+#include <ATen/ops/special_bessel_y1_meta.h>
+#include <ATen/ops/special_chebyshev_polynomial_t_meta.h>
+#include <ATen/ops/special_chebyshev_polynomial_u_meta.h>
+#include <ATen/ops/special_chebyshev_polynomial_v_meta.h>
+#include <ATen/ops/special_chebyshev_polynomial_w_meta.h>
+#include <ATen/ops/special_digamma_meta.h>
+#include <ATen/ops/special_entr_meta.h>
+#include <ATen/ops/special_erf_meta.h>
+#include <ATen/ops/special_erfc_meta.h>
+#include <ATen/ops/special_erfcx_meta.h>
+#include <ATen/ops/special_erfinv_meta.h>
+#include <ATen/ops/special_exp2_meta.h>
+#include <ATen/ops/special_expit_meta.h>
+#include <ATen/ops/special_expm1_meta.h>
+#include <ATen/ops/special_gammainc_meta.h>
+#include <ATen/ops/special_gammaincc_meta.h>
+#include <ATen/ops/special_gammaln_meta.h>
+#include <ATen/ops/special_hermite_polynomial_h_meta.h>
+#include <ATen/ops/special_hermite_polynomial_he_meta.h>
+#include <ATen/ops/special_i0_meta.h>
+#include <ATen/ops/special_i0e_meta.h>
+#include <ATen/ops/special_i1_meta.h>
+#include <ATen/ops/special_i1e_meta.h>
+#include <ATen/ops/special_laguerre_polynomial_l_meta.h>
+#include <ATen/ops/special_legendre_polynomial_p_meta.h>
+#include <ATen/ops/special_log1p_meta.h>
+#include <ATen/ops/special_log_ndtr_meta.h>
+#include <ATen/ops/special_log_softmax_meta.h>
+#include <ATen/ops/special_logit_meta.h>
+#include <ATen/ops/special_logsumexp_meta.h>
+#include <ATen/ops/special_modified_bessel_i0_meta.h>
+#include <ATen/ops/special_modified_bessel_i1_meta.h>
+#include <ATen/ops/special_modified_bessel_k0_meta.h>
+#include <ATen/ops/special_modified_bessel_k1_meta.h>
+#include <ATen/ops/special_multigammaln_meta.h>
+#include <ATen/ops/special_ndtr_meta.h>
+#include <ATen/ops/special_ndtri_meta.h>
+#include <ATen/ops/special_polygamma_meta.h>
+#include <ATen/ops/special_psi_meta.h>
+#include <ATen/ops/special_round_meta.h>
+#include <ATen/ops/special_scaled_modified_bessel_k0_meta.h>
+#include <ATen/ops/special_scaled_modified_bessel_k1_meta.h>
+#include <ATen/ops/special_shifted_chebyshev_polynomial_t_meta.h>
+#include <ATen/ops/special_shifted_chebyshev_polynomial_u_meta.h>
+#include <ATen/ops/special_shifted_chebyshev_polynomial_v_meta.h>
+#include <ATen/ops/special_shifted_chebyshev_polynomial_w_meta.h>
+#include <ATen/ops/special_sinc_meta.h>
+#include <ATen/ops/special_softmax_meta.h>
+#include <ATen/ops/special_spherical_bessel_j0_meta.h>
+#include <ATen/ops/special_xlog1py_meta.h>
+#include <ATen/ops/special_xlogy_meta.h>
+#include <ATen/ops/special_zeta_meta.h>
+#include <ATen/ops/split_meta.h>
+#include <ATen/ops/split_copy_meta.h>
+#include <ATen/ops/split_with_sizes_meta.h>
+#include <ATen/ops/split_with_sizes_copy_meta.h>
+#include <ATen/ops/sqrt_meta.h>
+#include <ATen/ops/square_meta.h>
+#include <ATen/ops/squeeze_meta.h>
+#include <ATen/ops/squeeze_copy_meta.h>
+#include <ATen/ops/sspaddmm_meta.h>
+#include <ATen/ops/stack_meta.h>
+#include <ATen/ops/std_meta.h>
+#include <ATen/ops/std_mean_meta.h>
+#include <ATen/ops/stft_meta.h>
+#include <ATen/ops/stride_meta.h>
+#include <ATen/ops/sub_meta.h>
+#include <ATen/ops/subtract_meta.h>
+#include <ATen/ops/sum_meta.h>
+#include <ATen/ops/sum_to_size_meta.h>
+#include <ATen/ops/svd_meta.h>
+#include <ATen/ops/swapaxes_meta.h>
+#include <ATen/ops/swapdims_meta.h>
+#include <ATen/ops/sym_constrain_range_meta.h>
+#include <ATen/ops/sym_constrain_range_for_size_meta.h>
+#include <ATen/ops/sym_numel_meta.h>
+#include <ATen/ops/sym_size_meta.h>
+#include <ATen/ops/sym_storage_offset_meta.h>
+#include <ATen/ops/sym_stride_meta.h>
+#include <ATen/ops/t_meta.h>
+#include <ATen/ops/t_copy_meta.h>
+#include <ATen/ops/take_meta.h>
+#include <ATen/ops/take_along_dim_meta.h>
+#include <ATen/ops/tan_meta.h>
+#include <ATen/ops/tanh_meta.h>
+#include <ATen/ops/tanh_backward_meta.h>
+#include <ATen/ops/tensor_split_meta.h>
+#include <ATen/ops/tensordot_meta.h>
+#include <ATen/ops/thnn_conv2d_meta.h>
+#include <ATen/ops/threshold_meta.h>
+#include <ATen/ops/threshold_backward_meta.h>
+#include <ATen/ops/tile_meta.h>
+#include <ATen/ops/to_meta.h>
+#include <ATen/ops/to_dense_meta.h>
+#include <ATen/ops/to_dense_backward_meta.h>
+#include <ATen/ops/to_mkldnn_meta.h>
+#include <ATen/ops/to_mkldnn_backward_meta.h>
+#include <ATen/ops/to_padded_tensor_meta.h>
+#include <ATen/ops/to_sparse_meta.h>
+#include <ATen/ops/to_sparse_bsc_meta.h>
+#include <ATen/ops/to_sparse_bsr_meta.h>
+#include <ATen/ops/to_sparse_csc_meta.h>
+#include <ATen/ops/to_sparse_csr_meta.h>
+#include <ATen/ops/topk_meta.h>
+#include <ATen/ops/trace_meta.h>
+#include <ATen/ops/trace_backward_meta.h>
+#include <ATen/ops/transpose_meta.h>
+#include <ATen/ops/transpose_copy_meta.h>
+#include <ATen/ops/trapezoid_meta.h>
+#include <ATen/ops/trapz_meta.h>
+#include <ATen/ops/triangular_solve_meta.h>
+#include <ATen/ops/tril_meta.h>
+#include <ATen/ops/tril_indices_meta.h>
+#include <ATen/ops/triplet_margin_loss_meta.h>
+#include <ATen/ops/triu_meta.h>
+#include <ATen/ops/triu_indices_meta.h>
+#include <ATen/ops/true_divide_meta.h>
+#include <ATen/ops/trunc_meta.h>
+#include <ATen/ops/type_as_meta.h>
+#include <ATen/ops/unbind_meta.h>
+#include <ATen/ops/unbind_copy_meta.h>
+#include <ATen/ops/unflatten_meta.h>
+#include <ATen/ops/unflatten_dense_tensors_meta.h>
+#include <ATen/ops/unfold_meta.h>
+#include <ATen/ops/unfold_backward_meta.h>
+#include <ATen/ops/unfold_copy_meta.h>
+#include <ATen/ops/uniform_meta.h>
+#include <ATen/ops/unique_consecutive_meta.h>
+#include <ATen/ops/unique_dim_meta.h>
+#include <ATen/ops/unique_dim_consecutive_meta.h>
+#include <ATen/ops/unsafe_chunk_meta.h>
+#include <ATen/ops/unsafe_split_meta.h>
+#include <ATen/ops/unsafe_split_with_sizes_meta.h>
+#include <ATen/ops/unsqueeze_meta.h>
+#include <ATen/ops/unsqueeze_copy_meta.h>
+#include <ATen/ops/upsample_bicubic2d_meta.h>
+#include <ATen/ops/upsample_bicubic2d_backward_meta.h>
+#include <ATen/ops/upsample_bilinear2d_meta.h>
+#include <ATen/ops/upsample_bilinear2d_backward_meta.h>
+#include <ATen/ops/upsample_linear1d_meta.h>
+#include <ATen/ops/upsample_linear1d_backward_meta.h>
+#include <ATen/ops/upsample_nearest1d_meta.h>
+#include <ATen/ops/upsample_nearest1d_backward_meta.h>
+#include <ATen/ops/upsample_nearest2d_meta.h>
+#include <ATen/ops/upsample_nearest2d_backward_meta.h>
+#include <ATen/ops/upsample_nearest3d_meta.h>
+#include <ATen/ops/upsample_nearest3d_backward_meta.h>
+#include <ATen/ops/upsample_trilinear3d_meta.h>
+#include <ATen/ops/upsample_trilinear3d_backward_meta.h>
+#include <ATen/ops/value_selecting_reduction_backward_meta.h>
+#include <ATen/ops/values_meta.h>
+#include <ATen/ops/values_copy_meta.h>
+#include <ATen/ops/vander_meta.h>
+#include <ATen/ops/var_meta.h>
+#include <ATen/ops/var_mean_meta.h>
+#include <ATen/ops/vdot_meta.h>
+#include <ATen/ops/view_meta.h>
+#include <ATen/ops/view_as_meta.h>
+#include <ATen/ops/view_as_complex_meta.h>
+#include <ATen/ops/view_as_complex_copy_meta.h>
+#include <ATen/ops/view_as_real_meta.h>
+#include <ATen/ops/view_as_real_copy_meta.h>
+#include <ATen/ops/view_copy_meta.h>
+#include <ATen/ops/vsplit_meta.h>
+#include <ATen/ops/vstack_meta.h>
+#include <ATen/ops/where_meta.h>
+#include <ATen/ops/xlogy_meta.h>
+#include <ATen/ops/xor_meta.h>
+#include <ATen/ops/zero_meta.h>
+#include <ATen/ops/zeros_meta.h>
+#include <ATen/ops/zeros_like_meta.h>
+
+namespace at {
+
+namespace meta {
+
+
+
+} // namespace meta
+} // namespace at

shared/package-files/33/332cbd2657d64c9dbd27c3b28aafaea6a6a0f957ec3c78378ecbaaec71d4f621/baseconv.pyi

@@ -0,0 +1,24 @@
+from typing import Any, Tuple, Union
+
+BASE2_ALPHABET: str
+BASE16_ALPHABET: str
+BASE56_ALPHABET: str
+BASE36_ALPHABET: str
+BASE62_ALPHABET: str
+BASE64_ALPHABET: Any
+
+class BaseConverter:
+    decimal_digits: str = ...
+    sign: str = ...
+    digits: str = ...
+    def __init__(self, digits: str, sign: str = ...) -> None: ...
+    def encode(self, i: int) -> str: ...
+    def decode(self, s: str) -> int: ...
+    def convert(self, number: Union[int, str], from_digits: str, to_digits: str, sign: str) -> Tuple[int, str]: ...
+
+base2: Any
+base16: Any
+base36: Any
+base56: Any
+base62: Any
+base64: Any

shared/package-files/33/332cea5d4b963f5f8181b6c207327220b892fe389c64ed8b3543148efeef861d/scope.py

@@ -0,0 +1,91 @@
+"""
+Scope definition and related utilities.
+
+Those are defined here, instead of in the 'fixtures' module because
+their use is spread across many other pytest modules, and centralizing it in 'fixtures'
+would cause circular references.
+
+Also this makes the module light to import, as it should.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+from functools import total_ordering
+from typing import Literal
+
+
+_ScopeName = Literal["session", "package", "module", "class", "function"]
+
+
+@total_ordering
+class Scope(Enum):
+    """
+    Represents one of the possible fixture scopes in pytest.
+
+    Scopes are ordered from lower to higher, that is:
+
+              ->>> higher ->>>
+
+    Function < Class < Module < Package < Session
+
+              <<<- lower  <<<-
+    """
+
+    # Scopes need to be listed from lower to higher.
+    Function: _ScopeName = "function"
+    Class: _ScopeName = "class"
+    Module: _ScopeName = "module"
+    Package: _ScopeName = "package"
+    Session: _ScopeName = "session"
+
+    def next_lower(self) -> Scope:
+        """Return the next lower scope."""
+        index = _SCOPE_INDICES[self]
+        if index == 0:
+            raise ValueError(f"{self} is the lower-most scope")
+        return _ALL_SCOPES[index - 1]
+
+    def next_higher(self) -> Scope:
+        """Return the next higher scope."""
+        index = _SCOPE_INDICES[self]
+        if index == len(_SCOPE_INDICES) - 1:
+            raise ValueError(f"{self} is the upper-most scope")
+        return _ALL_SCOPES[index + 1]
+
+    def __lt__(self, other: Scope) -> bool:
+        self_index = _SCOPE_INDICES[self]
+        other_index = _SCOPE_INDICES[other]
+        return self_index < other_index
+
+    @classmethod
+    def from_user(
+        cls, scope_name: _ScopeName, descr: str, where: str | None = None
+    ) -> Scope:
+        """
+        Given a scope name from the user, return the equivalent Scope enum. Should be used
+        whenever we want to convert a user provided scope name to its enum object.
+
+        If the scope name is invalid, construct a user friendly message and call pytest.fail.
+        """
+        from _pytest.outcomes import fail
+
+        try:
+            # Holding this reference is necessary for mypy at the moment.
+            scope = Scope(scope_name)
+        except ValueError:
+            fail(
+                "{} {}got an unexpected scope value '{}'".format(
+                    descr, f"from {where} " if where else "", scope_name
+                ),
+                pytrace=False,
+            )
+        return scope
+
+
+_ALL_SCOPES = list(Scope)
+_SCOPE_INDICES = {scope: index for index, scope in enumerate(_ALL_SCOPES)}
+
+
+# Ordered list of scopes which can contain many tests (in practice all except Function).
+HIGH_SCOPES = [x for x in Scope if x is not Scope.Function]

shared/package-files/33/332e5db8799453cbb47dadc745a0693bfb78cb9b190bc01ec503b8981ea82623/slow_conv_transpose2d_meta.h

@@ -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_slow_conv_transpose2d : public at::impl::MetaBase {
+    
+    
+    void meta(const at::Tensor & self, const at::Tensor & weight, at::ArrayRef<int64_t> kernel_size, at::OptionalTensorRef bias, at::ArrayRef<int64_t> stride, at::ArrayRef<int64_t> padding, at::ArrayRef<int64_t> output_padding, at::ArrayRef<int64_t> dilation);
+};
+
+} // namespace native
+} // namespace at

shared/package-files/33/333231626133ad5f4d3f3559893f5fcd756b564fbd83564997ad3757ee28159f/_make_per_tensor_quantized_tensor_ops.h

@@ -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 _make_per_tensor_quantized_tensor {
+  using schema = at::Tensor (const at::Tensor &, double, int64_t);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_make_per_tensor_quantized_tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_make_per_tensor_quantized_tensor(Tensor self, float scale, int zero_point) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, double scale, int64_t zero_point);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, double scale, int64_t zero_point);
+};
+
+struct TORCH_API _make_per_tensor_quantized_tensor_out {
+  using schema = at::Tensor & (const at::Tensor &, double, int64_t, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_make_per_tensor_quantized_tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_make_per_tensor_quantized_tensor.out(Tensor self, float scale, int zero_point, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, double scale, int64_t zero_point, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, double scale, int64_t zero_point, at::Tensor & out);
+};
+
+}} // namespace at::_ops

shared/package-files/33/3333f5c213bd28025dfac3d303ed03990166e2773bc2e7615787c4ae2826e114/digamma_cpu_dispatch.h

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

shared/package-files/33/33347744575c5b047abf7344e1ae392834abd33659ea190eba92109525d32de4/_monitoring.py

@@ -0,0 +1,81 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import scipy.stats
+
+from . import colors
+from ._labels import labels
+
+
+def truncate_text(text, max_len):
+    if len(text) > max_len:
+        return text[: int(max_len / 2) - 2] + "..." + text[-int(max_len / 2) + 1 :]
+    else:
+        return text
+
+
+def monitoring(ind, shap_values, features, feature_names=None, show=True):
+    """Create a SHAP monitoring plot.
+
+    (Note this function is preliminary and subject to change!!)
+    A SHAP monitoring plot is meant to display the behavior of a model
+    over time. Often the shap_values given to this plot explain the loss
+    of a model, so changes in a feature's impact on the model's loss over
+    time can help in monitoring the model's performance.
+
+    Parameters
+    ----------
+    ind : int
+        Index of the feature to plot.
+
+    shap_values : numpy.array
+        Matrix of SHAP values (# samples x # features)
+
+    features : numpy.array or pandas.DataFrame
+        Matrix of feature values (# samples x # features)
+
+    feature_names : list
+        Names of the features (length # features)
+
+    """
+    if isinstance(features, pd.DataFrame):
+        if feature_names is None:
+            feature_names = features.columns
+        features = features.values
+
+    num_features = shap_values.shape[1]
+
+    if feature_names is None:
+        feature_names = np.array([labels["FEATURE"] % str(i) for i in range(num_features)])
+
+    plt.figure(figsize=(10, 3))
+    ys = shap_values[:, ind]
+    xs = np.arange(len(ys))  # np.linspace(0, 12*2, len(ys))
+
+    pvals = []
+    inc = 50
+    for i in range(inc, len(ys) - inc, inc):
+        # stat, pval = scipy.stats.mannwhitneyu(v[:i], v[i:], alternative="two-sided")
+        _, pval = scipy.stats.ttest_ind(ys[:i], ys[i:])
+        pvals.append(pval)
+    min_pval = np.min(pvals)
+    min_pval_ind = float(np.argmin(pvals) * inc + inc)
+
+    if min_pval < 0.05 / shap_values.shape[1]:
+        plt.axvline(min_pval_ind, linestyle="dashed", color="#666666", alpha=0.2)
+
+    plt.scatter(xs, ys, s=10, c=features[:, ind], cmap=colors.red_blue)
+
+    plt.xlabel("Sample index")
+    plt.ylabel(truncate_text(feature_names[ind], 30) + "\nSHAP value", size=13)
+    plt.gca().xaxis.set_ticks_position("bottom")
+    plt.gca().yaxis.set_ticks_position("left")
+    plt.gca().spines["right"].set_visible(False)
+    plt.gca().spines["top"].set_visible(False)
+    cb = plt.colorbar()
+    cb.outline.set_visible(False)  # type: ignore
+    bbox = cb.ax.get_window_extent().transformed(plt.gcf().dpi_scale_trans.inverted())
+    cb.ax.set_aspect((bbox.height - 0.7) * 20)
+    cb.set_label(truncate_text(feature_names[ind], 30), size=13)
+    if show:
+        plt.show()

shared/package-files/33/3334dd5e9e21c3a272819e5db1b49137efc74076d129087d390b8941855b1ec7/compat.py

@@ -0,0 +1,43 @@
+# This file is part of Patsy
+# Copyright (C) 2012 Nathaniel Smith <njs@pobox.com>
+# See file LICENSE.txt for license information.
+
+# This file contains compatibility code for supporting old versions of Python
+# and numpy. (If we can concentrate it here, hopefully it'll make it easier to
+# get rid of weird hacks once we drop support for old versions).
+
+##### Numpy
+
+import os
+
+# To force use of the compat code, set this env var to a non-empty value:
+optional_dep_ok = not os.environ.get("PATSY_AVOID_OPTIONAL_DEPENDENCIES")
+
+##### Python standard library
+
+# The Python license requires that all derivative works contain a "brief
+# summary of the changes made to Python". Both for license compliance, and for
+# our own sanity, therefore, please add a note at the top of any snippets you
+# add here explaining their provenance, any changes made, and what versions of
+# Python require them:
+
+# OrderedDict is only available in Python 2.7+. compat_ordereddict.py has
+# comments at the top.
+import collections
+
+if optional_dep_ok and hasattr(collections, "OrderedDict"):
+    from collections import OrderedDict
+else:
+    from patsy.compat_ordereddict import OrderedDict
+
+# 'raise from' available in Python 3+
+import sys
+from patsy import PatsyError
+
+
+def call_and_wrap_exc(msg, origin, f, *args, **kwargs):
+    try:
+        return f(*args, **kwargs)
+    except Exception as e:
+        new_exc = PatsyError("%s: %s: %s" % (msg, e.__class__.__name__, e), origin)
+        raise new_exc from e

shared/package-files/33/333555ba99cb1c4beec255429fa991ecb43da4b78d896336956c0d948c28a3df/test_shift.py

@@ -0,0 +1,76 @@
+import pytest
+
+from pandas.errors import NullFrequencyError
+
+import pandas as pd
+from pandas import TimedeltaIndex
+import pandas._testing as tm
+
+
+class TestTimedeltaIndexShift:
+    # -------------------------------------------------------------
+    # TimedeltaIndex.shift is used by __add__/__sub__
+
+    def test_tdi_shift_empty(self):
+        # GH#9903
+        idx = TimedeltaIndex([], name="xxx")
+        tm.assert_index_equal(idx.shift(0, freq="h"), idx)
+        tm.assert_index_equal(idx.shift(3, freq="h"), idx)
+
+    def test_tdi_shift_hours(self):
+        # GH#9903
+        idx = TimedeltaIndex(["5 hours", "6 hours", "9 hours"], name="xxx")
+        tm.assert_index_equal(idx.shift(0, freq="h"), idx)
+        exp = TimedeltaIndex(["8 hours", "9 hours", "12 hours"], name="xxx")
+        tm.assert_index_equal(idx.shift(3, freq="h"), exp)
+        exp = TimedeltaIndex(["2 hours", "3 hours", "6 hours"], name="xxx")
+        tm.assert_index_equal(idx.shift(-3, freq="h"), exp)
+
+    def test_tdi_shift_minutes(self):
+        # GH#9903
+        idx = TimedeltaIndex(["5 hours", "6 hours", "9 hours"], name="xxx")
+        tm.assert_index_equal(idx.shift(0, freq="min"), idx)
+        exp = TimedeltaIndex(["05:03:00", "06:03:00", "9:03:00"], name="xxx")
+        tm.assert_index_equal(idx.shift(3, freq="min"), exp)
+        exp = TimedeltaIndex(["04:57:00", "05:57:00", "8:57:00"], name="xxx")
+        tm.assert_index_equal(idx.shift(-3, freq="min"), exp)
+
+    def test_tdi_shift_int(self):
+        # GH#8083
+        tdi = pd.to_timedelta(range(5), unit="d")
+        trange = tdi._with_freq("infer") + pd.offsets.Hour(1)
+        result = trange.shift(1)
+        expected = TimedeltaIndex(
+            [
+                "1 days 01:00:00",
+                "2 days 01:00:00",
+                "3 days 01:00:00",
+                "4 days 01:00:00",
+                "5 days 01:00:00",
+            ],
+            freq="D",
+        )
+        tm.assert_index_equal(result, expected)
+
+    def test_tdi_shift_nonstandard_freq(self):
+        # GH#8083
+        tdi = pd.to_timedelta(range(5), unit="d")
+        trange = tdi._with_freq("infer") + pd.offsets.Hour(1)
+        result = trange.shift(3, freq="2D 1s")
+        expected = TimedeltaIndex(
+            [
+                "6 days 01:00:03",
+                "7 days 01:00:03",
+                "8 days 01:00:03",
+                "9 days 01:00:03",
+                "10 days 01:00:03",
+            ],
+            freq="D",
+        )
+        tm.assert_index_equal(result, expected)
+
+    def test_shift_no_freq(self):
+        # GH#19147
+        tdi = TimedeltaIndex(["1 days 01:00:00", "2 days 01:00:00"], freq=None)
+        with pytest.raises(NullFrequencyError, match="Cannot shift with no freq"):
+            tdi.shift(2)

shared/package-files/33/3339f39dd38edd0a1c71c20cc9d74eeefd7211c0804be1cb6cb42a026adfcd67/_kalman_filter.pxd

@@ -0,0 +1,690 @@
+#cython: boundscheck=False
+#cython: wraparound=False
+#cython: cdivision=False
+"""
+Kalman Filter declarations
+
+Author: Chad Fulton 
+License: Simplified-BSD
+"""
+
+include "statsmodels/tsa/statespace/_blas_int.pxi"
+
+# ## Constants
+
+# ### Filters
+cdef int FILTER_CONVENTIONAL     # Durbin and Koopman (2012), Chapter 4
+cdef int FILTER_EXACT_INITIAL    # ibid., Chapter 5.6
+cdef int FILTER_AUGMENTED        # ibid., Chapter 5.7
+cdef int FILTER_SQUARE_ROOT      # ibid., Chapter 6.3
+cdef int FILTER_UNIVARIATE       # ibid., Chapter 6.4
+cdef int FILTER_COLLAPSED        # ibid., Chapter 6.5
+cdef int FILTER_EXTENDED         # ibid., Chapter 10.2
+cdef int FILTER_UNSCENTED        # ibid., Chapter 10.3
+cdef int FILTER_CONCENTRATED     # Harvey (1989), Chapter 3.4
+cdef int FILTER_CHANDRASEKHAR    # Herbst (2015)
+
+# ### Inversion methods
+# Methods by which the terms using the inverse of the forecast error
+# covariance matrix are solved.
+cdef int INVERT_UNIVARIATE
+cdef int SOLVE_LU
+cdef int INVERT_LU
+cdef int SOLVE_CHOLESKY
+cdef int INVERT_CHOLESKY
+
+# ### Numerical Stability methods
+# Methods to improve numerical stability
+cdef int STABILITY_FORCE_SYMMETRY
+
+# ### Memory conservation options
+cdef int MEMORY_STORE_ALL
+cdef int MEMORY_NO_FORECAST_MEAN
+cdef int MEMORY_NO_FORECAST_COV
+cdef int MEMORY_NO_FORECAST
+cdef int MEMORY_NO_PREDICTED_MEAN
+cdef int MEMORY_NO_PREDICTED_COV
+cdef int MEMORY_NO_PREDICTED
+cdef int MEMORY_NO_FILTERED_MEAN
+cdef int MEMORY_NO_FILTERED_COV
+cdef int MEMORY_NO_FILTERED
+cdef int MEMORY_NO_LIKELIHOOD
+cdef int MEMORY_NO_GAIN
+cdef int MEMORY_NO_SMOOTHING
+cdef int MEMORY_NO_STD_FORECAST
+cdef int MEMORY_CONSERVE
+
+# ### Timing options
+cdef int TIMING_INIT_FILTERED
+cdef int TIMING_INIT_PREDICTED
+
+# Typical imports
+
+cimport numpy as np
+
+from statsmodels.tsa.statespace._representation cimport (
+    cStatespace,
+    dStatespace,
+    sStatespace,
+    zStatespace,
+)
+
+
+# Single precision
+cdef class sKalmanFilter(object):
+    # Statespace object
+    cdef readonly sStatespace model
+
+    # ### Filter parameters
+    cdef readonly int t
+    cdef public np.float64_t tolerance, tolerance_diffuse
+    cdef readonly int nobs_diffuse
+    cdef readonly int nobs_kendog_diffuse_nonsingular
+    cdef readonly int nobs_kendog_univariate_singular
+    cdef readonly int converged
+    cdef readonly int period_converged
+    cdef readonly int time_invariant
+    cdef readonly int filter_method
+    cdef public int inversion_method
+    cdef public int stability_method
+    cdef readonly int conserve_memory
+    cdef public int filter_timing
+    cdef readonly int loglikelihood_burn
+
+    cdef public int [:] univariate_filter
+
+    # ### Kalman filter properties
+    cdef readonly np.float32_t [:] loglikelihood, scale
+    cdef readonly np.float32_t [::1,:] filtered_state, predicted_state, forecast, forecast_error, standardized_forecast_error
+    cdef readonly np.float32_t [::1,:,:] filtered_state_cov, predicted_state_cov, forecast_error_cov, predicted_diffuse_state_cov, forecast_error_diffuse_cov, M, M_inf
+    cdef readonly np.float32_t [::1,:,:] kalman_gain
+
+    # ### Steady State Values
+    cdef readonly np.float32_t [::1,:] converged_forecast_error_cov
+    cdef readonly np.float32_t [::1,:] converged_filtered_state_cov
+    cdef readonly np.float32_t [::1,:] converged_predicted_state_cov
+    cdef readonly np.float32_t [::1,:] converged_kalman_gain
+    cdef readonly np.float32_t [::1,:] converged_M
+    cdef readonly np.float32_t converged_determinant
+
+    # ### Temporary arrays
+    cdef readonly np.float32_t [::1,:] forecast_error_fac
+    cdef readonly blas_int [:] forecast_error_ipiv
+    cdef readonly np.float32_t [::1,:] forecast_error_work
+    cdef readonly np.float32_t [::1,:] tmp0, tmp00
+    cdef readonly np.float32_t [::1,:] tmp2
+    cdef readonly np.float32_t [::1,:,:] tmp1, tmp3, tmp4
+    cdef readonly np.float32_t [:] tmpK0, tmpK1
+    cdef readonly np.float32_t [::1,:] tmpL0, tmpL1
+
+    cdef readonly np.float32_t [::1,:] CW, CtmpW, CMW, CM, CprevFiZ, CtmpM, CMWZ
+
+
+    cdef readonly np.float32_t determinant
+
+    # ### Pointers to current-iteration arrays
+    # cdef np.float32_t * _obs
+    # cdef np.float32_t * _design
+    # cdef np.float32_t * _obs_intercept
+    # cdef np.float32_t * _obs_cov
+    # cdef np.float32_t * _transition
+    # cdef np.float32_t * _state_intercept
+    # cdef np.float32_t * _selection
+    # cdef np.float32_t * _state_cov
+    # cdef np.float32_t * _selected_state_cov
+    # cdef np.float32_t * _initial_state
+    # cdef np.float32_t * _initial_state_cov
+
+    cdef np.float32_t * _input_state
+    cdef np.float32_t * _input_state_cov
+    cdef np.float32_t * _input_diffuse_state_cov
+
+    cdef np.float32_t * _forecast
+    cdef np.float32_t * _forecast_error
+    cdef np.float32_t * _standardized_forecast_error
+    cdef np.float32_t * _forecast_error_cov
+    cdef np.float32_t * _filtered_state
+    cdef np.float32_t * _filtered_state_cov
+    cdef np.float32_t * _predicted_state
+    cdef np.float32_t * _predicted_state_cov
+
+    cdef np.float32_t * _forecast_error_diffuse_cov
+    cdef np.float32_t * _predicted_diffuse_state_cov
+    cdef np.float32_t * _M
+    cdef np.float32_t * _M_inf
+
+    cdef np.float32_t * _kalman_gain
+    cdef np.float32_t * _loglikelihood
+    cdef np.float32_t * _scale
+
+    cdef np.float32_t * _converged_forecast_error_cov
+    cdef np.float32_t * _converged_filtered_state_cov
+    cdef np.float32_t * _converged_predicted_state_cov
+    cdef np.float32_t * _converged_kalman_gain
+    cdef np.float32_t * _converged_M
+
+    cdef np.float32_t * _forecast_error_fac
+    cdef blas_int * _forecast_error_ipiv
+    cdef np.float32_t * _forecast_error_work
+
+    cdef np.float32_t * _tmp0
+    cdef np.float32_t * _tmp00
+    cdef np.float32_t * _tmp1
+    cdef np.float32_t * _tmp2
+    cdef np.float32_t * _tmp3
+    cdef np.float32_t * _tmp4
+
+    cdef np.float32_t * _tmpM_inf
+    cdef np.float32_t * _tmpK0
+    cdef np.float32_t * _tmpK1
+    cdef np.float32_t * _tmpL0
+    cdef np.float32_t * _tmpL1
+
+    # ### Pointers to current-iteration Kalman filtering functions
+    cdef int (*forecasting)(
+        sKalmanFilter, sStatespace
+    )
+    cdef np.float32_t (*inversion)(
+        sKalmanFilter, sStatespace, np.float32_t
+    ) except *
+    cdef int (*updating)(
+        sKalmanFilter, sStatespace
+    )
+    cdef np.float32_t (*calculate_loglikelihood)(
+        sKalmanFilter, sStatespace, np.float32_t
+    )
+    cdef np.float32_t (*calculate_scale)(
+        sKalmanFilter, sStatespace
+    )
+    cdef int (*prediction)(
+        sKalmanFilter, sStatespace
+    )
+
+    # ### Define some constants
+    cdef readonly int k_endog, k_states, k_posdef, k_endog2, k_states2, k_posdef2, k_endogstates, k_statesposdef
+    cdef readonly int ldwork
+
+    cdef allocate_arrays(self)
+    cdef void set_dimensions(self)
+    cpdef set_filter_method(self, int filter_method, int force_reset=*)
+    cpdef seek(self, unsigned int t, int reset=*)
+
+    cdef void initialize_statespace_object_pointers(self) except *
+    cdef void initialize_filter_object_pointers(self)
+    cdef void initialize_function_pointers(self) except *
+    cdef void post_convergence(self)
+    cdef void numerical_stability(self)
+    cdef int check_diffuse(self)
+    cdef void check_convergence(self)
+    cdef void migrate_storage(self)
+    cdef void _reinitialize_pointers(self) except *
+
+    cdef void _forecasting(self)
+    cdef np.float32_t _inversion(self)
+    cdef void _updating(self)
+    cdef np.float32_t _calculate_loglikelihood(self)
+    cdef void _prediction(self)
+
+# Double precision
+cdef class dKalmanFilter(object):
+    # Statespace object
+    cdef readonly dStatespace model
+
+    # ### Filter parameters
+    cdef readonly int t
+    cdef public np.float64_t tolerance, tolerance_diffuse
+    cdef readonly int nobs_diffuse
+    cdef readonly int nobs_kendog_diffuse_nonsingular
+    cdef readonly int nobs_kendog_univariate_singular
+    cdef readonly int converged
+    cdef readonly int period_converged
+    cdef readonly int time_invariant
+    cdef readonly int filter_method
+    cdef public int inversion_method
+    cdef public int stability_method
+    cdef readonly int conserve_memory
+    cdef public int filter_timing
+    cdef readonly int loglikelihood_burn
+
+    cdef public int [:] univariate_filter
+
+    # ### Kalman filter properties
+    cdef readonly np.float64_t [:] loglikelihood, scale
+    cdef readonly np.float64_t [::1,:] filtered_state, predicted_state, forecast, forecast_error, standardized_forecast_error
+    cdef readonly np.float64_t [::1,:,:] filtered_state_cov, predicted_state_cov, forecast_error_cov, predicted_diffuse_state_cov, forecast_error_diffuse_cov, M, M_inf
+    cdef readonly np.float64_t [::1,:,:] kalman_gain
+
+    # ### Steady State Values
+    cdef readonly np.float64_t [::1,:] converged_forecast_error_cov
+    cdef readonly np.float64_t [::1,:] converged_filtered_state_cov
+    cdef readonly np.float64_t [::1,:] converged_predicted_state_cov
+    cdef readonly np.float64_t [::1,:] converged_kalman_gain
+    cdef readonly np.float64_t [::1,:] converged_M
+    cdef readonly np.float64_t converged_determinant
+
+    # ### Temporary arrays
+    cdef readonly np.float64_t [::1,:] forecast_error_fac
+    cdef readonly blas_int [:] forecast_error_ipiv
+    cdef readonly np.float64_t [::1,:] forecast_error_work
+    cdef readonly np.float64_t [::1,:] tmp0, tmp00
+    cdef readonly np.float64_t [::1,:] tmp2
+    cdef readonly np.float64_t [::1,:,:] tmp1, tmp3, tmp4
+    cdef readonly np.float64_t [:] tmpM_inf, tmpK0, tmpK1
+    cdef readonly np.float64_t [::1,:] tmpL0, tmpL1
+
+    cdef readonly np.float64_t [::1,:] CW, CtmpW, CMW, CM, CprevFiZ, CtmpM, CMWZ
+
+    cdef readonly np.float64_t determinant
+
+    # ### Pointers to current-iteration arrays
+    # cdef np.float64_t * _obs
+    # cdef np.float64_t * _design
+    # cdef np.float64_t * _obs_intercept
+    # cdef np.float64_t * _obs_cov
+    # cdef np.float64_t * _transition
+    # cdef np.float64_t * _state_intercept
+    # cdef np.float64_t * _selection
+    # cdef np.float64_t * _state_cov
+    # cdef np.float64_t * _selected_state_cov
+    # cdef np.float64_t * _initial_state
+    # cdef np.float64_t * _initial_state_cov
+
+    cdef np.float64_t * _input_state
+    cdef np.float64_t * _input_state_cov
+    cdef np.float64_t * _input_diffuse_state_cov
+
+    cdef np.float64_t * _forecast
+    cdef np.float64_t * _forecast_error
+    cdef np.float64_t * _standardized_forecast_error
+    cdef np.float64_t * _forecast_error_cov
+    cdef np.float64_t * _filtered_state
+    cdef np.float64_t * _filtered_state_cov
+    cdef np.float64_t * _predicted_state
+    cdef np.float64_t * _predicted_state_cov
+
+    cdef np.float64_t * _forecast_error_diffuse_cov
+    cdef np.float64_t * _predicted_diffuse_state_cov
+    cdef np.float64_t * _M
+    cdef np.float64_t * _M_inf
+
+    cdef np.float64_t * _kalman_gain
+    cdef np.float64_t * _loglikelihood
+    cdef np.float64_t * _scale
+
+    cdef np.float64_t * _converged_forecast_error_cov
+    cdef np.float64_t * _converged_filtered_state_cov
+    cdef np.float64_t * _converged_predicted_state_cov
+    cdef np.float64_t * _converged_kalman_gain
+    cdef np.float64_t * _converged_M
+
+    cdef np.float64_t * _forecast_error_fac
+    cdef blas_int * _forecast_error_ipiv
+    cdef np.float64_t * _forecast_error_work
+
+    cdef np.float64_t * _tmp0
+    cdef np.float64_t * _tmp00
+    cdef np.float64_t * _tmp1
+    cdef np.float64_t * _tmp2
+    cdef np.float64_t * _tmp3
+    cdef np.float64_t * _tmp4
+
+    cdef np.float64_t * _tmpM_inf
+    cdef np.float64_t * _tmpK0
+    cdef np.float64_t * _tmpK1
+    cdef np.float64_t * _tmpL0
+    cdef np.float64_t * _tmpL1
+
+    # ### Pointers to current-iteration Kalman filtering functions
+    cdef int (*forecasting)(
+        dKalmanFilter, dStatespace
+    )
+    cdef np.float64_t (*inversion)(
+        dKalmanFilter, dStatespace, np.float64_t
+    ) except *
+    cdef int (*updating)(
+        dKalmanFilter, dStatespace
+    )
+    cdef np.float64_t (*calculate_loglikelihood)(
+        dKalmanFilter, dStatespace, np.float64_t
+    )
+    cdef np.float64_t (*calculate_scale)(
+        dKalmanFilter, dStatespace
+    )
+    cdef int (*prediction)(
+        dKalmanFilter, dStatespace
+    )
+
+    # ### Define some constants
+    cdef readonly int k_endog, k_states, k_posdef, k_endog2, k_states2, k_posdef2, k_endogstates, k_statesposdef
+    cdef readonly int ldwork
+
+    cdef allocate_arrays(self)
+    cdef void set_dimensions(self)
+    cpdef set_filter_method(self, int filter_method, int force_reset=*)
+    cpdef seek(self, unsigned int t, int reset=*)
+
+    cdef void initialize_statespace_object_pointers(self) except *
+    cdef void initialize_filter_object_pointers(self)
+    cdef void initialize_function_pointers(self) except *
+    cdef void post_convergence(self)
+    cdef void numerical_stability(self)
+    cdef int check_diffuse(self)
+    cdef void check_convergence(self)
+    cdef void migrate_storage(self)
+    cdef void _reinitialize_pointers(self) except *
+
+    cdef void _forecasting(self)
+    cdef np.float64_t _inversion(self)
+    cdef void _updating(self)
+    cdef np.float64_t _calculate_loglikelihood(self)
+    cdef void _prediction(self)
+
+# Single precision complex
+cdef class cKalmanFilter(object):
+    # Statespace object
+    cdef readonly cStatespace model
+
+    # ### Filter parameters
+    cdef readonly int t
+    cdef public np.float64_t tolerance, tolerance_diffuse
+    cdef readonly int nobs_diffuse
+    cdef readonly int nobs_kendog_diffuse_nonsingular
+    cdef readonly int nobs_kendog_univariate_singular
+    cdef readonly int converged
+    cdef readonly int period_converged
+    cdef readonly int time_invariant
+    cdef readonly int filter_method
+    cdef public int inversion_method
+    cdef public int stability_method
+    cdef readonly int conserve_memory
+    cdef public int filter_timing
+    cdef readonly int loglikelihood_burn
+
+    cdef public int [:] univariate_filter
+
+    # ### Kalman filter properties
+    cdef readonly np.complex64_t [:] loglikelihood, scale
+    cdef readonly np.complex64_t [::1,:] filtered_state, predicted_state, forecast, forecast_error, standardized_forecast_error
+    cdef readonly np.complex64_t [::1,:,:] filtered_state_cov, predicted_state_cov, forecast_error_cov, predicted_diffuse_state_cov, forecast_error_diffuse_cov, M, M_inf
+    cdef readonly np.complex64_t [::1,:,:] kalman_gain
+
+    # ### Steady State Values
+    cdef readonly np.complex64_t [::1,:] converged_forecast_error_cov
+    cdef readonly np.complex64_t [::1,:] converged_filtered_state_cov
+    cdef readonly np.complex64_t [::1,:] converged_predicted_state_cov
+    cdef readonly np.complex64_t [::1,:] converged_kalman_gain
+    cdef readonly np.complex64_t [::1,:] converged_M
+    cdef readonly np.complex64_t converged_determinant
+
+    # ### Temporary arrays
+    cdef readonly np.complex64_t [::1,:] forecast_error_fac
+    cdef readonly blas_int [:] forecast_error_ipiv
+    cdef readonly np.complex64_t [::1,:] forecast_error_work
+    cdef readonly np.complex64_t [::1,:] tmp0, tmp00
+    cdef readonly np.complex64_t [::1,:] tmp2
+    cdef readonly np.complex64_t [::1,:,:] tmp1, tmp3, tmp4
+    cdef readonly np.complex64_t [:] tmpM_inf, tmpK0, tmpK1
+    cdef readonly np.complex64_t [::1,:] tmpL0, tmpL1
+
+    cdef readonly np.complex64_t [::1,:] CW, CtmpW, CMW, CM, CprevFiZ, CtmpM, CMWZ
+
+
+    cdef readonly np.complex64_t determinant
+
+    # ### Pointers to current-iteration arrays
+    # cdef np.complex64_t * _obs
+    # cdef np.complex64_t * _design
+    # cdef np.complex64_t * _obs_intercept
+    # cdef np.complex64_t * _obs_cov
+    # cdef np.complex64_t * _transition
+    # cdef np.complex64_t * _state_intercept
+    # cdef np.complex64_t * _selection
+    # cdef np.complex64_t * _state_cov
+    # cdef np.complex64_t * _selected_state_cov
+    # cdef np.complex64_t * _initial_state
+    # cdef np.complex64_t * _initial_state_cov
+
+    cdef np.complex64_t * _input_state
+    cdef np.complex64_t * _input_state_cov
+    cdef np.complex64_t * _input_diffuse_state_cov
+
+    cdef np.complex64_t * _forecast
+    cdef np.complex64_t * _forecast_error
+    cdef np.complex64_t * _standardized_forecast_error
+    cdef np.complex64_t * _forecast_error_cov
+    cdef np.complex64_t * _filtered_state
+    cdef np.complex64_t * _filtered_state_cov
+    cdef np.complex64_t * _predicted_state
+    cdef np.complex64_t * _predicted_state_cov
+
+    cdef np.complex64_t * _forecast_error_diffuse_cov
+    cdef np.complex64_t * _predicted_diffuse_state_cov
+    cdef np.complex64_t * _M
+    cdef np.complex64_t * _M_inf
+
+    cdef np.complex64_t * _kalman_gain
+    cdef np.complex64_t * _loglikelihood
+    cdef np.complex64_t * _scale
+
+    cdef np.complex64_t * _converged_forecast_error_cov
+    cdef np.complex64_t * _converged_filtered_state_cov
+    cdef np.complex64_t * _converged_predicted_state_cov
+    cdef np.complex64_t * _converged_kalman_gain
+    cdef np.complex64_t * _converged_M
+
+    cdef np.complex64_t * _forecast_error_fac
+    cdef blas_int * _forecast_error_ipiv
+    cdef np.complex64_t * _forecast_error_work
+
+    cdef np.complex64_t * _tmp0
+    cdef np.complex64_t * _tmp00
+    cdef np.complex64_t * _tmp1
+    cdef np.complex64_t * _tmp2
+    cdef np.complex64_t * _tmp3
+    cdef np.complex64_t * _tmp4
+
+    cdef np.complex64_t * _tmpM_inf
+    cdef np.complex64_t * _tmpK0
+    cdef np.complex64_t * _tmpK1
+    cdef np.complex64_t * _tmpL0
+    cdef np.complex64_t * _tmpL1
+
+    # ### Pointers to current-iteration Kalman filtering functions
+    cdef int (*forecasting)(
+        cKalmanFilter, cStatespace
+    )
+    cdef np.complex64_t (*inversion)(
+        cKalmanFilter, cStatespace, np.complex64_t
+    ) except *
+    cdef int (*updating)(
+        cKalmanFilter, cStatespace
+    )
+    cdef np.complex64_t (*calculate_loglikelihood)(
+        cKalmanFilter, cStatespace, np.complex64_t
+    )
+    cdef np.complex64_t (*calculate_scale)(
+        cKalmanFilter, cStatespace
+    )
+    cdef int (*prediction)(
+        cKalmanFilter, cStatespace
+    )
+
+    # ### Define some constants
+    cdef readonly int k_endog, k_states, k_posdef, k_endog2, k_states2, k_posdef2, k_endogstates, k_statesposdef
+    cdef readonly int ldwork
+
+    cdef allocate_arrays(self)
+    cdef void set_dimensions(self)
+    cpdef set_filter_method(self, int filter_method, int force_reset=*)
+    cpdef seek(self, unsigned int t, int reset=*)
+
+    cdef void initialize_statespace_object_pointers(self) except *
+    cdef void initialize_filter_object_pointers(self)
+    cdef void initialize_function_pointers(self) except *
+    cdef void post_convergence(self)
+    cdef void numerical_stability(self)
+    cdef int check_diffuse(self)
+    cdef void check_convergence(self)
+    cdef void migrate_storage(self)
+    cdef void _reinitialize_pointers(self) except *
+
+    cdef void _forecasting(self)
+    cdef np.complex64_t _inversion(self)
+    cdef void _updating(self)
+    cdef np.complex64_t _calculate_loglikelihood(self)
+    cdef void _prediction(self)
+
+# Double precision complex
+cdef class zKalmanFilter(object):
+    # Statespace object
+    cdef readonly zStatespace model
+
+    # ### Filter parameters
+    cdef readonly int t
+    cdef public np.float64_t tolerance, tolerance_diffuse
+    cdef readonly int nobs_diffuse
+    cdef readonly int nobs_kendog_diffuse_nonsingular
+    cdef readonly int nobs_kendog_univariate_singular
+    cdef readonly int converged
+    cdef readonly int period_converged
+    cdef readonly int time_invariant
+    cdef readonly int filter_method
+    cdef public int inversion_method
+    cdef public int stability_method
+    cdef readonly int conserve_memory
+    cdef public int filter_timing
+    cdef readonly int loglikelihood_burn
+
+    cdef public int [:] univariate_filter
+
+    # ### Kalman filter properties
+    cdef readonly np.complex128_t [:] loglikelihood, scale
+    cdef readonly np.complex128_t [::1,:] filtered_state, predicted_state, forecast, forecast_error, standardized_forecast_error
+    cdef readonly np.complex128_t [::1,:,:] filtered_state_cov, predicted_state_cov, forecast_error_cov, predicted_diffuse_state_cov, forecast_error_diffuse_cov, M, M_inf
+    cdef readonly np.complex128_t [::1,:,:] kalman_gain
+
+    # ### Steady State Values
+    cdef readonly np.complex128_t [::1,:] converged_forecast_error_cov
+    cdef readonly np.complex128_t [::1,:] converged_filtered_state_cov
+    cdef readonly np.complex128_t [::1,:] converged_predicted_state_cov
+    cdef readonly np.complex128_t [::1,:] converged_kalman_gain
+    cdef readonly np.complex128_t [::1,:] converged_M
+    cdef readonly np.complex128_t converged_determinant
+
+    # ### Temporary arrays
+    cdef readonly np.complex128_t [::1,:] forecast_error_fac
+    cdef readonly blas_int [:] forecast_error_ipiv
+    cdef readonly np.complex128_t [::1,:] forecast_error_work
+    cdef readonly np.complex128_t [::1,:] tmp0, tmp00
+    cdef readonly np.complex128_t [::1,:] tmp2
+    cdef readonly np.complex128_t [::1,:,:] tmp1, tmp3, tmp4
+    cdef readonly np.complex128_t [:] tmpM_inf, tmpK0, tmpK1
+    cdef readonly np.complex128_t [::1,:] tmpL0, tmpL1
+
+    cdef readonly np.complex128_t [::1,:] CW, CtmpW, CMW, CM, CprevFiZ, CtmpM, CMWZ
+
+
+    cdef readonly np.complex128_t determinant
+
+    # ### Pointers to current-iteration arrays
+    # cdef np.complex128_t * _obs
+    # cdef np.complex128_t * _design
+    # cdef np.complex128_t * _obs_intercept
+    # cdef np.complex128_t * _obs_cov
+    # cdef np.complex128_t * _transition
+    # cdef np.complex128_t * _state_intercept
+    # cdef np.complex128_t * _selection
+    # cdef np.complex128_t * _state_cov
+    # cdef np.complex128_t * _selected_state_cov
+    # cdef np.complex128_t * _initial_state
+    # cdef np.complex128_t * _initial_state_cov
+
+    cdef np.complex128_t * _input_state
+    cdef np.complex128_t * _input_state_cov
+    cdef np.complex128_t * _input_diffuse_state_cov
+
+    cdef np.complex128_t * _forecast
+    cdef np.complex128_t * _forecast_error
+    cdef np.complex128_t * _standardized_forecast_error
+    cdef np.complex128_t * _forecast_error_cov
+    cdef np.complex128_t * _filtered_state
+    cdef np.complex128_t * _filtered_state_cov
+    cdef np.complex128_t * _predicted_state
+    cdef np.complex128_t * _predicted_state_cov
+
+    cdef np.complex128_t * _forecast_error_diffuse_cov
+    cdef np.complex128_t * _predicted_diffuse_state_cov
+    cdef np.complex128_t * _M
+    cdef np.complex128_t * _M_inf
+
+    cdef np.complex128_t * _kalman_gain
+    cdef np.complex128_t * _loglikelihood
+    cdef np.complex128_t * _scale
+
+    cdef np.complex128_t * _converged_forecast_error_cov
+    cdef np.complex128_t * _converged_filtered_state_cov
+    cdef np.complex128_t * _converged_predicted_state_cov
+    cdef np.complex128_t * _converged_kalman_gain
+    cdef np.complex128_t * _converged_M
+
+    cdef np.complex128_t * _forecast_error_fac
+    cdef blas_int * _forecast_error_ipiv
+    cdef np.complex128_t * _forecast_error_work
+
+    cdef np.complex128_t * _tmp0
+    cdef np.complex128_t * _tmp00
+    cdef np.complex128_t * _tmp1
+    cdef np.complex128_t * _tmp2
+    cdef np.complex128_t * _tmp3
+    cdef np.complex128_t * _tmp4
+
+    cdef np.complex128_t * _tmpM_inf
+    cdef np.complex128_t * _tmpK0
+    cdef np.complex128_t * _tmpK1
+    cdef np.complex128_t * _tmpL0
+    cdef np.complex128_t * _tmpL1
+
+    # ### Pointers to current-iteration Kalman filtering functions
+    cdef int (*forecasting)(
+        zKalmanFilter, zStatespace
+    )
+    cdef np.complex128_t (*inversion)(
+        zKalmanFilter, zStatespace, np.complex128_t
+    ) except *
+    cdef int (*updating)(
+        zKalmanFilter, zStatespace
+    )
+    cdef np.complex128_t (*calculate_loglikelihood)(
+        zKalmanFilter, zStatespace, np.complex128_t
+    )
+    cdef np.complex128_t (*calculate_scale)(
+        zKalmanFilter, zStatespace
+    )
+    cdef int (*prediction)(
+        zKalmanFilter, zStatespace
+    )
+
+    # ### Define some constants
+    cdef readonly int k_endog, k_states, k_posdef, k_endog2, k_states2, k_posdef2, k_endogstates, k_statesposdef
+    cdef readonly int ldwork
+
+    cdef allocate_arrays(self)
+    cdef void set_dimensions(self)
+    cpdef set_filter_method(self, int filter_method, int force_reset=*)
+    cpdef seek(self, unsigned int t, int reset=*)
+
+    cdef void initialize_statespace_object_pointers(self) except *
+    cdef void initialize_filter_object_pointers(self)
+    cdef void initialize_function_pointers(self) except *
+    cdef void post_convergence(self)
+    cdef void numerical_stability(self)
+    cdef int check_diffuse(self)
+    cdef void check_convergence(self)
+    cdef void migrate_storage(self)
+    cdef void _reinitialize_pointers(self) except *
+
+    cdef void _forecasting(self)
+    cdef np.complex128_t _inversion(self)
+    cdef void _updating(self)
+    cdef np.complex128_t _calculate_loglikelihood(self)
+    cdef void _prediction(self)

shared/package-files/33/333dd019f806e7c875bae091f9bf6bfcfbfc2febc0f281f823834de8bea17c2d/user.pyi

@@ -0,0 +1,6 @@
+from typing import Any
+
+def __getattr__(name) -> Any: ...
+
+home: str
+pythonrc: str

shared/package-files/33/3341413075b40e3eae33a4254813f8c79a78b7c5261c11ef09667a1e846e2cd5/smooth_l1_loss.h

@@ -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/smooth_l1_loss_ops.h>
+
+namespace at {
+
+
+// aten::smooth_l1_loss.out(Tensor self, Tensor target, int reduction=Mean, float beta=1.0, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & smooth_l1_loss_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, int64_t reduction=at::Reduction::Mean, double beta=1.0) {
+    return at::_ops::smooth_l1_loss_out::call(self, target, reduction, beta, out);
+}
+// aten::smooth_l1_loss.out(Tensor self, Tensor target, int reduction=Mean, float beta=1.0, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & smooth_l1_loss_outf(const at::Tensor & self, const at::Tensor & target, int64_t reduction, double beta, at::Tensor & out) {
+    return at::_ops::smooth_l1_loss_out::call(self, target, reduction, beta, out);
+}
+
+// aten::smooth_l1_loss(Tensor self, Tensor target, int reduction=Mean, float beta=1.0) -> Tensor
+inline at::Tensor smooth_l1_loss(const at::Tensor & self, const at::Tensor & target, int64_t reduction=at::Reduction::Mean, double beta=1.0) {
+    return at::_ops::smooth_l1_loss::call(self, target, reduction, beta);
+}
+
+}

shared/package-files/33/3342d477dc64280b8dc7afc68ee13945b8b72927a8c79ba88b25e11fc72adb85/plotting.py

@@ -0,0 +1,494 @@
+from statsmodels.compat.python import lrange
+
+import numpy as np
+
+from statsmodels.graphics.utils import _import_mpl
+from statsmodels.tsa.vector_ar import util
+
+
+class MPLConfigurator:
+
+    def __init__(self):
+        self._inverse_actions = []
+
+    def revert(self):
+        for action in self._inverse_actions:
+            action()
+
+    def set_fontsize(self, size):
+        import matplotlib as mpl
+
+        old_size = mpl.rcParams["font.size"]
+        mpl.rcParams["font.size"] = size
+
+        def revert():
+            mpl.rcParams["font.size"] = old_size
+
+        self._inverse_actions.append(revert)
+
+
+#
+# Plotting functions
+#
+def plot_mts(Y, names=None, index=None):
+    """
+    Plot multiple time series
+
+    Parameters
+    ----------
+    Y : ndarray
+        2-d array of the time series to plot, of shape (nobs, neqs).
+    names : sequence of str, optional
+        Titles to use for each subplot. If None, subplots are not
+        given a title.
+    index : array_like, optional
+        Values to use for the x-axis of each subplot. If None, uses
+        the default integer index.
+
+    Returns
+    -------
+    Figure
+        The figure containing the grid of time series plots.
+    """
+    plt = _import_mpl()
+
+    k = Y.shape[1]
+    rows, cols = k, 1
+
+    fig = plt.figure(figsize=(10, 10))
+
+    for j in range(k):
+        ts = Y[:, j]
+
+        ax = fig.add_subplot(rows, cols, j + 1)
+        if index is not None:
+            ax.plot(index, ts)
+        else:
+            ax.plot(ts)
+
+        if names is not None:
+            ax.set_title(names[j])
+
+    return fig
+
+
+def plot_var_forc(
+    prior,
+    forc,
+    err_upper,
+    err_lower,
+    index=None,
+    names=None,
+    plot_stderr=True,
+    legend_options=None,
+):
+    """
+    Plot a forecast against the observed data, with optional error bands
+
+    Parameters
+    ----------
+    prior : ndarray
+        2-d array of the observed data prior to the forecast, of shape
+        (nobs, neqs).
+    forc : ndarray
+        2-d array of forecast values, of shape (steps, neqs).
+    err_upper : ndarray
+        2-d array of upper confidence interval bounds for the forecast,
+        of shape (steps, neqs).
+    err_lower : ndarray
+        2-d array of lower confidence interval bounds for the forecast,
+        of shape (steps, neqs).
+    index : array_like, optional
+        Currently unused.
+    names : sequence of str, optional
+        Titles to use for each subplot. If None, subplots are not
+        given a title.
+    plot_stderr : bool, optional
+        If True, plot the confidence interval around the forecast.
+    legend_options : dict, optional
+        Keyword arguments passed to ``ax.legend``. If None, uses
+        ``{"loc": "upper right"}``.
+
+    Returns
+    -------
+    Figure
+        The figure containing the grid of forecast plots.
+    """
+    plt = _import_mpl()
+
+    n, k = prior.shape
+    rows, cols = k, 1
+
+    fig = plt.figure(figsize=(10, 10))
+
+    prange = np.arange(n)
+    rng_f = np.arange(n - 1, n + len(forc))
+    rng_err = np.arange(n, n + len(forc))
+
+    for j in range(k):
+        ax = plt.subplot(rows, cols, j + 1)
+
+        ax.plot(prange, prior[:, j], "k", label="Observed")
+        ax.plot(rng_f, np.r_[prior[-1:, j], forc[:, j]], "k--", label="Forecast")
+
+        if plot_stderr:
+            ax.plot(rng_err, err_upper[:, j], "k-.", label="Forc 2 STD err")
+            ax.plot(rng_err, err_lower[:, j], "k-.")
+
+        if names is not None:
+            ax.set_title(names[j])
+
+        if legend_options is None:
+            legend_options = {"loc": "upper right"}
+        ax.legend(**legend_options)
+    return fig
+
+
+def plot_with_error(
+    y,
+    error,
+    x=None,
+    axes=None,
+    value_fmt="k",
+    error_fmt="k--",
+    alpha=0.05,
+    stderr_type="asym",
+):
+    """
+    Make plot with optional error bars
+
+    Parameters
+    ----------
+    y : array_like
+        The data to plot.
+    error : array_like, tuple of array_like, or None
+        The error used to plot error bars around `y`. If `stderr_type`
+        is "asym", an array the same shape as `y` combined with `alpha`
+        to compute the bands. If `stderr_type` is one of "mc", "sz1",
+        "sz2", "sz3", a 2-tuple of arrays giving the lower and upper
+        bands directly. If None, no error bars are plotted.
+    x : array_like, optional
+        The x-axis values to use. If None, uses a range the same length
+        as `y`.
+    axes : AxesSubplot, optional
+        Matplotlib axes to plot on. If None, uses the current axes.
+    value_fmt : str, optional
+        Matplotlib format string used to plot `y`.
+    error_fmt : str, optional
+        Matplotlib format string used to plot the error bars.
+    alpha : float, optional
+        The significance level to use when `stderr_type` is "asym".
+    stderr_type : {"asym", "mc", "sz1", "sz2", "sz3"}, optional
+        The kind of error bars being plotted.
+    """
+    plt = _import_mpl()
+
+    if axes is None:
+        axes = plt.gca()
+
+    x = x if x is not None else lrange(len(y))
+
+    def plot_action(y, fmt):
+        return axes.plot(x, y, fmt)
+
+    plot_action(y, value_fmt)
+
+    # changed this
+    if error is not None:
+        if stderr_type == "asym":
+            q = util.norm_signif_level(alpha)
+            plot_action(y - q * error, error_fmt)
+            plot_action(y + q * error, error_fmt)
+        if stderr_type in ("mc", "sz1", "sz2", "sz3"):
+            plot_action(error[0], error_fmt)
+            plot_action(error[1], error_fmt)
+
+
+def plot_full_acorr(acorr, fontsize=8, linewidth=8, xlabel=None, err_bound=None):
+    """
+    Plot the autocorrelations of a multivariate time series in a grid
+
+    Parameters
+    ----------
+    acorr : ndarray
+        Array of autocorrelations, shape (nlags, k, k).
+    fontsize : int, optional
+        Font size used for the plot labels.
+    linewidth : int, optional
+        Width of the lines used in the autocorrelation plots.
+    xlabel : array_like, optional
+        Labels to use for the x-axis of each subplot. If None, uses a
+        range the same length as `acorr`.
+    err_bound : float, optional
+        If provided, draws horizontal reference lines at +/- `err_bound`.
+
+    Returns
+    -------
+    Figure
+        The figure containing the grid of autocorrelation plots.
+    """
+    plt = _import_mpl()
+
+    config = MPLConfigurator()
+    config.set_fontsize(fontsize)
+
+    k = acorr.shape[1]
+    fig, axes = plt.subplots(k, k, figsize=(10, 10), squeeze=False)
+
+    for i in range(k):
+        for j in range(k):
+            ax = axes[i][j]
+            acorr_plot(acorr[:, i, j], linewidth=linewidth, xlabel=xlabel, ax=ax)
+
+            if err_bound is not None:
+                ax.axhline(err_bound, color="k", linestyle="--")
+                ax.axhline(-err_bound, color="k", linestyle="--")
+
+    adjust_subplots()
+    config.revert()
+
+    return fig
+
+
+def acorr_plot(acorr, linewidth=8, xlabel=None, ax=None):
+    """
+    Plot a single autocorrelation function as a stem plot
+
+    Parameters
+    ----------
+    acorr : array_like
+        1-d array of autocorrelations to plot.
+    linewidth : int, optional
+        Width of the vertical lines used in the plot.
+    xlabel : array_like, optional
+        Positions to use for the x-axis. If None, uses a range the
+        same length as `acorr`.
+    ax : AxesSubplot, optional
+        Matplotlib axes to plot on. If None, uses the current axes.
+    """
+    plt = _import_mpl()
+
+    if ax is None:
+        ax = plt.gca()
+
+    if xlabel is None:
+        xlabel = np.arange(len(acorr))
+
+    ax.vlines(xlabel, [0], acorr, lw=linewidth)
+
+    ax.axhline(0, color="k")
+    ax.set_ylim([-1, 1])
+
+    # hack?
+    ax.set_xlim([-1, xlabel[-1] + 1])
+
+
+def plot_acorr_with_error():
+    """Not implemented."""
+    raise NotImplementedError
+
+
+def adjust_subplots(**kwds):
+    """
+    Adjust subplot spacing using defaults suitable for the grid plots
+
+    Parameters
+    ----------
+    **kwds
+        Keyword arguments passed to ``matplotlib.pyplot.subplots_adjust``,
+        overriding the defaults.
+    """
+    plt = _import_mpl()
+
+    passed_kwds = {
+        "bottom": 0.05,
+        "top": 0.925,
+        "left": 0.05,
+        "right": 0.95,
+        "hspace": 0.2,
+    }
+    passed_kwds.update(kwds)
+    plt.subplots_adjust(**passed_kwds)
+
+
+#
+# Multiple impulse response (cum_effects, etc.) cplots
+#
+
+
+def irf_grid_plot(
+    values,
+    stderr,
+    impcol,
+    rescol,
+    names,
+    title,
+    signif=0.05,
+    hlines=None,
+    subplot_params=None,
+    plot_params=None,
+    figsize=(10, 10),
+    stderr_type="asym",
+):
+    """
+    Reusable function to make flexible grid plots of impulse responses and
+    cumulative effects
+
+    Parameters
+    ----------
+    values : ndarray
+        Array of values to plot, shape (T, k, k).
+    stderr : ndarray, tuple of ndarray, or None
+        Used to plot error bands around `values`. If `stderr_type` is
+        "asym", an array of shape (T, k ** 2, k ** 2) giving the
+        covariance matrix of the vectorized values at each period (as
+        returned by :meth:`~statsmodels.tsa.vector_ar.irf.IRAnalysis.cov`).
+        If `stderr_type` is one of "mc", "sz1", "sz2", "sz3", a 2-tuple
+        of arrays of shape (T, k, k) giving the lower and upper error
+        bands directly. If None, no error bands are plotted.
+    impcol : int, str, or None
+        Column of the impulse variable to plot. If None, plots impulses
+        from all variables.
+    rescol : int, str, or None
+        Column of the response variable to plot. If None, plots responses
+        of all variables.
+    names : sequence of str
+        Names of the variables in the system.
+    title : str
+        Title to use for the figure.
+    signif : float, optional
+        Significance level used when plotting error bands.
+    hlines : ndarray, optional
+        Array of horizontal reference lines to draw on each subplot,
+        shape (k, k).
+    subplot_params : dict, optional
+        May contain a "fontsize" key controlling the subplot title font
+        size.
+    plot_params : dict, optional
+        Additional keyword arguments (currently unused).
+    figsize : tuple of float, optional
+        The size of the figure to create.
+    stderr_type : {"asym", "mc", "sz1", "sz2", "sz3"}, optional
+        The kind of error bars being plotted.
+
+    Returns
+    -------
+    Figure
+        The figure containing the grid of impulse response plots.
+    """
+    plt = _import_mpl()
+
+    if subplot_params is None:
+        subplot_params = {}
+    if plot_params is None:
+        plot_params = {}
+
+    nrows, ncols, to_plot = _get_irf_plot_config(names, impcol, rescol)
+
+    fig, axes = plt.subplots(
+        nrows=nrows, ncols=ncols, sharex=True, squeeze=False, figsize=figsize
+    )
+
+    # fill out space
+    adjust_subplots()
+
+    fig.suptitle(title, fontsize=14)
+
+    subtitle_temp = r"%s$\rightarrow$%s"
+
+    k = len(names)
+
+    rng = lrange(len(values))
+    for j, i, ai, aj in to_plot:
+        ax = axes[ai][aj]
+
+        # HACK?
+        if stderr is not None:
+            if stderr_type == "asym":
+                sig = np.sqrt(stderr[:, j * k + i, j * k + i])
+                plot_with_error(
+                    values[:, i, j],
+                    sig,
+                    x=rng,
+                    axes=ax,
+                    alpha=signif,
+                    value_fmt="b",
+                    stderr_type=stderr_type,
+                )
+            if stderr_type in ("mc", "sz1", "sz2", "sz3"):
+                errs = stderr[0][:, i, j], stderr[1][:, i, j]
+                plot_with_error(
+                    values[:, i, j],
+                    errs,
+                    x=rng,
+                    axes=ax,
+                    alpha=signif,
+                    value_fmt="b",
+                    stderr_type=stderr_type,
+                )
+        else:
+            plot_with_error(values[:, i, j], None, x=rng, axes=ax, value_fmt="b")
+
+        ax.axhline(0, color="k")
+
+        if hlines is not None:
+            ax.axhline(hlines[i, j], color="k")
+
+        sz = subplot_params.get("fontsize", 12)
+        ax.set_title(subtitle_temp % (names[j], names[i]), fontsize=sz)
+
+    return fig
+
+
+def _get_irf_plot_config(names, impcol, rescol):
+    """
+    Determine the subplot grid layout for `irf_grid_plot`
+
+    Parameters
+    ----------
+    names : sequence of str
+        Names of the variables in the system.
+    impcol : int, str, or None
+        Column of the impulse variable to plot. If None, plots impulses
+        from all variables.
+    rescol : int, str, or None
+        Column of the response variable to plot. If None, plots responses
+        of all variables.
+
+    Returns
+    -------
+    nrows : int
+        Number of subplot rows.
+    ncols : int
+        Number of subplot columns.
+    to_plot : list of tuple
+        Each tuple is ``(j, i, ai, aj)`` giving the impulse index `j`,
+        response index `i`, and the subplot grid position (`ai`, `aj`)
+        to plot it at.
+    """
+    nrows = ncols = k = len(names)
+    if impcol is not None and rescol is not None:
+        # plot one impulse-response pair
+        nrows = ncols = 1
+        j = util.get_index(names, impcol)
+        i = util.get_index(names, rescol)
+        to_plot = [(j, i, 0, 0)]
+    elif impcol is not None:
+        # plot impacts of impulse in one variable
+        ncols = 1
+        j = util.get_index(names, impcol)
+        to_plot = [(j, i, i, 0) for i in range(k)]
+    elif rescol is not None:
+        # plot only things having impact on particular variable
+        ncols = 1
+        i = util.get_index(names, rescol)
+        to_plot = [(j, i, j, 0) for j in range(k)]
+    else:
+        # plot everything
+        to_plot = [(j, i, i, j) for i in range(k) for j in range(k)]
+
+    return nrows, ncols, to_plot
+
+
+#
+# Forecast error variance decomposition

shared/package-files/33/3343d3b7c20e21c557a903d67b6379d2c9b812ad9ba1d457578564774f1cad79/mutable_ndim_array.py

@@ -0,0 +1,13 @@
+from sympy.tensor.array.ndim_array import NDimArray
+
+
+class MutableNDimArray(NDimArray):
+
+    def as_immutable(self):
+        raise NotImplementedError("abstract method")
+
+    def as_mutable(self):
+        return self
+
+    def _sympy_(self):
+        return self.as_immutable()

shared/package-files/33/3344af465d1c008f91cb7852e15960800d16bacb2f764ad8e12e5327aceddb5a/css_parser.py

@@ -0,0 +1,1280 @@
+"""CSS selector parser."""
+from __future__ import annotations
+import re
+from functools import lru_cache
+from . import util
+from . import css_match as cm
+from . import css_types as ct
+from .util import SelectorSyntaxError
+import warnings
+from typing import Match, Any, Iterator, cast
+
+UNICODE_REPLACEMENT_CHAR = 0xFFFD
+
+# Simple pseudo classes that take no parameters
+PSEUDO_SIMPLE = {
+    ":any-link",
+    ":empty",
+    ":first-child",
+    ":first-of-type",
+    ":in-range",
+    ":out-of-range",
+    ":last-child",
+    ":last-of-type",
+    ":link",
+    ":only-child",
+    ":only-of-type",
+    ":root",
+    ':checked',
+    ':default',
+    ':disabled',
+    ':enabled',
+    ':indeterminate',
+    ':optional',
+    ':placeholder-shown',
+    ':read-only',
+    ':read-write',
+    ':required',
+    ':scope',
+    ':defined'
+}
+
+# Supported, simple pseudo classes that match nothing in the Soup Sieve environment
+PSEUDO_SIMPLE_NO_MATCH = {
+    ':active',
+    ':current',
+    ':focus',
+    ':focus-visible',
+    ':focus-within',
+    ':future',
+    ':host',
+    ':hover',
+    ':local-link',
+    ':past',
+    ':paused',
+    ':playing',
+    ':target',
+    ':target-within',
+    ':user-invalid',
+    ':visited'
+}
+
+# Complex pseudo classes that take selector lists
+PSEUDO_COMPLEX = {
+    ':contains',
+    ':-soup-contains',
+    ':-soup-contains-own',
+    ':has',
+    ':is',
+    ':matches',
+    ':not',
+    ':where'
+}
+
+PSEUDO_COMPLEX_NO_MATCH = {
+    ':current',
+    ':host',
+    ':host-context'
+}
+
+# Complex pseudo classes that take very specific parameters and are handled special
+PSEUDO_SPECIAL = {
+    ':dir',
+    ':lang',
+    ':nth-child',
+    ':nth-last-child',
+    ':nth-last-of-type',
+    ':nth-of-type'
+}
+
+PSEUDO_SUPPORTED = PSEUDO_SIMPLE | PSEUDO_SIMPLE_NO_MATCH | PSEUDO_COMPLEX | PSEUDO_COMPLEX_NO_MATCH | PSEUDO_SPECIAL
+
+# Sub-patterns parts
+# Whitespace
+NEWLINE = r'(?:\r\n|(?!\r\n)[\n\f\r])'
+WS = fr'(?:[ \t]|{NEWLINE})'
+# Comments
+COMMENTS = r'(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)'
+# Whitespace with comments included
+WSC = fr'(?:{WS}|{COMMENTS})'
+# CSS escapes
+CSS_ESCAPES = fr'(?:\\(?:[a-f0-9]{{1,6}}{WS}?|[^\r\n\f]|$))'
+CSS_STRING_ESCAPES = fr'(?:\\(?:[a-f0-9]{{1,6}}{WS}?|[^\r\n\f]|$|{NEWLINE}))'
+# CSS Identifier
+IDENTIFIER = fr'''
+(?:(?:-?(?:[^\x00-\x2f\x30-\x40\x5B-\x5E\x60\x7B-\x9f]|{CSS_ESCAPES})+|--)
+(?:[^\x00-\x2c\x2e\x2f\x3A-\x40\x5B-\x5E\x60\x7B-\x9f]|{CSS_ESCAPES})*)
+'''
+# `nth` content
+NTH = fr'(?:[-+])?(?:[0-9]+n?|n)(?:(?<=n){WSC}*(?:[-+]){WSC}*(?:[0-9]+))?'
+# Value: quoted string or identifier
+VALUE = fr'''(?:"(?:\\(?:.|{NEWLINE})|[^\\"\r\n\f]+)*?"|'(?:\\(?:.|{NEWLINE})|[^\\'\r\n\f]+)*?'|{IDENTIFIER}+)'''
+# Attribute value comparison. `!=` is handled special as it is non-standard.
+ATTR = fr'(?:{WSC}*(?P<cmp>[!~^|*$]?=){WSC}*(?P<value>{VALUE})(?:{WSC}*(?P<case>[is]))?)?{WSC}*\]'
+
+# Selector patterns
+# IDs (`#id`)
+PAT_ID = fr'\#{IDENTIFIER}'
+# Classes (`.class`)
+PAT_CLASS = fr'\.{IDENTIFIER}'
+# Prefix:Tag (`prefix|tag`)
+PAT_TAG = fr'(?P<tag_ns>(?:{IDENTIFIER}|\*)?\|)?(?P<tag_name>{IDENTIFIER}|\*)'
+# Attributes (`[attr]`, `[attr=value]`, etc.)
+PAT_ATTR = fr'\[{WSC}*(?P<attr_ns>(?:{IDENTIFIER}|\*)?\|)?(?P<attr_name>{IDENTIFIER}){ATTR}'
+# Pseudo class (`:pseudo-class`, `:pseudo-class(`)
+PAT_PSEUDO_CLASS = fr'(?P<name>:{IDENTIFIER})(?P<open>\({WSC}*)?'
+# Pseudo class special patterns. Matches `:pseudo-class(` for special case pseudo classes.
+PAT_PSEUDO_CLASS_SPECIAL = fr'(?P<name>:{IDENTIFIER})(?P<open>\({WSC}*)'
+# Custom pseudo class (`:--custom-pseudo`)
+PAT_PSEUDO_CLASS_CUSTOM = fr'(?P<name>:(?=--){IDENTIFIER})'
+# Closing pseudo group (`)`)
+PAT_PSEUDO_CLOSE = fr'{WSC}*\)'
+# Pseudo element (`::pseudo-element`)
+PAT_PSEUDO_ELEMENT = fr':{PAT_PSEUDO_CLASS}'
+# At rule (`@page`, etc.) (not supported)
+PAT_AT_RULE = fr'@P{IDENTIFIER}'
+# Pseudo class `nth-child` (`:nth-child(an+b [of S]?)`, `:first-child`, etc.)
+PAT_PSEUDO_NTH_CHILD = fr'''
+(?P<pseudo_nth_child>{PAT_PSEUDO_CLASS_SPECIAL}
+(?P<nth_child>{NTH}|even|odd))(?:{WSC}*\)|(?P<of>{COMMENTS}*{WS}{WSC}*of{COMMENTS}*{WS}{WSC}*))
+'''
+# Pseudo class `nth-of-type` (`:nth-of-type(an+b)`, `:first-of-type`, etc.)
+PAT_PSEUDO_NTH_TYPE = fr'''
+(?P<pseudo_nth_type>{PAT_PSEUDO_CLASS_SPECIAL}
+(?P<nth_type>{NTH}|even|odd)){WSC}*\)
+'''
+# Pseudo class language (`:lang("*-de", en)`)
+PAT_PSEUDO_LANG = fr'{PAT_PSEUDO_CLASS_SPECIAL}(?P<values>{VALUE}(?:{WSC}*,{WSC}*{VALUE})*){WSC}*\)'
+# Pseudo class direction (`:dir(ltr)`)
+PAT_PSEUDO_DIR = fr'{PAT_PSEUDO_CLASS_SPECIAL}(?P<dir>ltr|rtl){WSC}*\)'
+# Combining characters (`>`, `~`, ` `, `+`, `,`)
+PAT_COMBINE = fr'{WSC}*?(?P<relation>[,+>~]|{WS}(?![,+>~])){WSC}*'
+# Extra: Contains (`:contains(text)`)
+PAT_PSEUDO_CONTAINS = fr'{PAT_PSEUDO_CLASS_SPECIAL}(?P<values>{VALUE}(?:{WSC}*,{WSC}*{VALUE})*){WSC}*\)'
+
+# Regular expressions
+# CSS escape pattern
+RE_CSS_ESC = re.compile(fr'(?:(\\[a-f0-9]{{1,6}}{WSC}?)|(\\[^\r\n\f])|(\\$))', re.I)
+RE_CSS_STR_ESC = re.compile(fr'(?:(\\[a-f0-9]{{1,6}}{WS}?)|(\\[^\r\n\f])|(\\$)|(\\{NEWLINE}))', re.I)
+# Pattern to break up `nth` specifiers
+RE_NTH = re.compile(fr'(?P<s1>[-+])?(?P<a>[0-9]+n?|n)(?:(?<=n){WSC}*(?P<s2>[-+]){WSC}*(?P<b>[0-9]+))?', re.I)
+# Pattern to iterate multiple values.
+RE_VALUES = re.compile(fr'(?:(?P<value>{VALUE})|(?P<split>{WSC}*,{WSC}*))', re.X)
+# Whitespace checks
+RE_WS = re.compile(WS)
+RE_WS_BEGIN = re.compile(fr'^{WSC}*')
+RE_WS_END = re.compile(fr'{WSC}*$')
+RE_CUSTOM = re.compile(fr'^{PAT_PSEUDO_CLASS_CUSTOM}$', re.X)
+
+# Constants
+# List split token
+COMMA_COMBINATOR = ','
+# Relation token for descendant
+WS_COMBINATOR = " "
+
+# Parse flags
+FLG_PSEUDO = 0x01
+FLG_NOT = 0x02
+FLG_RELATIVE = 0x04
+FLG_DEFAULT = 0x08
+FLG_HTML = 0x10
+FLG_INDETERMINATE = 0x20
+FLG_OPEN = 0x40
+FLG_IN_RANGE = 0x80
+FLG_OUT_OF_RANGE = 0x100
+FLG_PLACEHOLDER_SHOWN = 0x200
+FLG_FORGIVE = 0x400
+
+# Maximum cached patterns to store
+_MAXCACHE = 500
+
+
+@lru_cache(maxsize=_MAXCACHE)
+def _cached_css_compile(
+    pattern: str,
+    namespaces: ct.Namespaces | None,
+    custom: ct.CustomSelectors | None,
+    flags: int
+) -> cm.SoupSieve:
+    """Cached CSS compile."""
+
+    custom_selectors = process_custom(custom)
+    return cm.SoupSieve(
+        pattern,
+        CSSParser(
+            pattern,
+            custom=custom_selectors,
+            flags=flags
+        ).process_selectors(),
+        namespaces,
+        custom,
+        flags
+    )
+
+
+def _purge_cache() -> None:
+    """Purge the cache."""
+
+    _cached_css_compile.cache_clear()
+
+
+def process_custom(custom: ct.CustomSelectors | None) -> dict[str, str | ct.SelectorList]:
+    """Process custom."""
+
+    custom_selectors = {}
+    if custom is not None:
+        for key, value in custom.items():
+            name = util.lower(key)
+            if RE_CUSTOM.match(name) is None:
+                raise SelectorSyntaxError(f"The name '{name}' is not a valid custom pseudo-class name")
+            if name in custom_selectors:
+                raise KeyError(f"The custom selector '{name}' has already been registered")
+            custom_selectors[css_unescape(name)] = value
+    return custom_selectors
+
+
+def css_unescape(content: str, string: bool = False) -> str:
+    """
+    Unescape CSS value.
+
+    Strings allow for spanning the value on multiple strings by escaping a new line.
+    """
+
+    def replace(m: Match[str]) -> str:
+        """Replace with the appropriate substitute."""
+
+        if m.group(1):
+            codepoint = int(m.group(1)[1:], 16)
+            if codepoint == 0:
+                codepoint = UNICODE_REPLACEMENT_CHAR
+            value = chr(codepoint)
+        elif m.group(2):
+            value = m.group(2)[1:]
+        elif m.group(3):
+            value = '\ufffd'
+        else:
+            value = ''
+
+        return value
+
+    return (RE_CSS_ESC if not string else RE_CSS_STR_ESC).sub(replace, content)
+
+
+def escape(ident: str) -> str:
+    """Escape identifier."""
+
+    string = []
+    length = len(ident)
+    start_dash = length > 0 and ident[0] == '-'
+    if length == 1 and start_dash:
+        # Need to escape identifier that is a single `-` with no other characters
+        string.append(f'\\{ident}')
+    else:
+        for index, c in enumerate(ident):
+            codepoint = ord(c)
+            if codepoint == 0x00:
+                string.append('\ufffd')
+            elif (0x01 <= codepoint <= 0x1F) or codepoint == 0x7F:
+                string.append(f'\\{codepoint:x} ')
+            elif (index == 0 or (start_dash and index == 1)) and (0x30 <= codepoint <= 0x39):
+                string.append(f'\\{codepoint:x} ')
+            elif (
+                codepoint in (0x2D, 0x5F) or codepoint >= 0x80 or (0x30 <= codepoint <= 0x39) or
+                (0x30 <= codepoint <= 0x39) or (0x41 <= codepoint <= 0x5A) or (0x61 <= codepoint <= 0x7A)
+            ):
+                string.append(c)
+            else:
+                string.append(f'\\{c}')
+    return ''.join(string)
+
+
+class SelectorPattern:
+    """Selector pattern."""
+
+    def __init__(self, name: str, pattern: str) -> None:
+        """Initialize."""
+
+        self.name = name
+        self.re_pattern = re.compile(pattern, re.I | re.X | re.U)
+
+    def get_name(self) -> str:
+        """Get name."""
+
+        return self.name
+
+    def match(self, selector: str, index: int, flags: int) -> Match[str] | None:
+        """Match the selector."""
+
+        return self.re_pattern.match(selector, index)
+
+
+class SpecialPseudoPattern(SelectorPattern):
+    """Selector pattern."""
+
+    def __init__(self, patterns: tuple[tuple[str, tuple[str, ...], str, type[SelectorPattern]], ...]) -> None:
+        """Initialize."""
+
+        self.patterns = {}
+        for p in patterns:
+            name = p[0]
+            pattern = p[3](name, p[2])
+            for pseudo in p[1]:
+                self.patterns[pseudo] = pattern
+
+        self.matched_name = None  # type: SelectorPattern | None
+        self.re_pseudo_name = re.compile(PAT_PSEUDO_CLASS_SPECIAL, re.I | re.X | re.U)
+
+    def get_name(self) -> str:
+        """Get name."""
+
+        return '' if self.matched_name is None else self.matched_name.get_name()
+
+    def match(self, selector: str, index: int, flags: int) -> Match[str] | None:
+        """Match the selector."""
+
+        pseudo = None
+        m = self.re_pseudo_name.match(selector, index)
+        if m:
+            name = util.lower(css_unescape(m.group('name')))
+            pattern = self.patterns.get(name)
+            if pattern:
+                pseudo = pattern.match(selector, index, flags)
+                if pseudo:
+                    self.matched_name = pattern
+
+        return pseudo
+
+
+class _Selector:
+    """
+    Intermediate selector class.
+
+    This stores selector data for a compound selector as we are acquiring them.
+    Once we are done collecting the data for a compound selector, we freeze
+    the data in an object that can be pickled and hashed.
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize."""
+
+        self.tag = kwargs.get('tag', None)  # type: ct.SelectorTag | None
+        self.ids = kwargs.get('ids', [])  # type: list[str]
+        self.classes = kwargs.get('classes', [])  # type: list[str]
+        self.attributes = kwargs.get('attributes', [])  # type: list[ct.SelectorAttribute]
+        self.nth = kwargs.get('nth', [])  # type: list[ct.SelectorNth]
+        self.selectors = kwargs.get('selectors', [])  # type: list[ct.SelectorList]
+        self.relations = kwargs.get('relations', [])  # type: list[_Selector]
+        self.rel_type = kwargs.get('rel_type', None)  # type: str | None
+        self.contains = kwargs.get('contains', [])  # type: list[ct.SelectorContains]
+        self.lang = kwargs.get('lang', [])  # type: list[ct.SelectorLang]
+        self.flags = kwargs.get('flags', 0)  # type: int
+        self.no_match = kwargs.get('no_match', False)  # type: bool
+
+    def _freeze_relations(self, relations: list[_Selector]) -> ct.SelectorList:
+        """Freeze relation."""
+
+        if relations:
+            sel = relations[0]
+            sel.relations.extend(relations[1:])
+            return ct.SelectorList([sel.freeze()])
+        else:
+            return ct.SelectorList()
+
+    def freeze(self) -> ct.Selector | ct.SelectorNull:
+        """Freeze self."""
+
+        if self.no_match:
+            return ct.SelectorNull()
+        else:
+            return ct.Selector(
+                self.tag,
+                tuple(self.ids),
+                tuple(self.classes),
+                tuple(self.attributes),
+                tuple(self.nth),
+                tuple(self.selectors),
+                self._freeze_relations(self.relations),
+                self.rel_type,
+                tuple(self.contains),
+                tuple(self.lang),
+                self.flags
+            )
+
+    def __str__(self) -> str:  # pragma: no cover
+        """String representation."""
+
+        return (
+            f'_Selector(tag={self.tag!r}, ids={self.ids!r}, classes={self.classes!r}, attributes={self.attributes!r}, '
+            f'nth={self.nth!r}, selectors={self.selectors!r}, relations={self.relations!r}, '
+            f'rel_type={self.rel_type!r}, contains={self.contains!r}, lang={self.lang!r}, flags={self.flags!r}, '
+            f'no_match={self.no_match!r})'
+        )
+
+    __repr__ = __str__
+
+
+class CSSParser:
+    """Parse CSS selectors."""
+
+    css_tokens = (
+        SelectorPattern("pseudo_close", PAT_PSEUDO_CLOSE),
+        SpecialPseudoPattern(
+            (
+                (
+                    "pseudo_contains",
+                    (':contains', ':-soup-contains', ':-soup-contains-own'),
+                    PAT_PSEUDO_CONTAINS,
+                    SelectorPattern
+                ),
+                ("pseudo_nth_child", (':nth-child', ':nth-last-child'), PAT_PSEUDO_NTH_CHILD, SelectorPattern),
+                ("pseudo_nth_type", (':nth-of-type', ':nth-last-of-type'), PAT_PSEUDO_NTH_TYPE, SelectorPattern),
+                ("pseudo_lang", (':lang',), PAT_PSEUDO_LANG, SelectorPattern),
+                ("pseudo_dir", (':dir',), PAT_PSEUDO_DIR, SelectorPattern)
+            )
+        ),
+        SelectorPattern("pseudo_class_custom", PAT_PSEUDO_CLASS_CUSTOM),
+        SelectorPattern("pseudo_class", PAT_PSEUDO_CLASS),
+        SelectorPattern("pseudo_element", PAT_PSEUDO_ELEMENT),
+        SelectorPattern("at_rule", PAT_AT_RULE),
+        SelectorPattern("id", PAT_ID),
+        SelectorPattern("class", PAT_CLASS),
+        SelectorPattern("tag", PAT_TAG),
+        SelectorPattern("attribute", PAT_ATTR),
+        SelectorPattern("combine", PAT_COMBINE)
+    )
+
+    def __init__(
+        self,
+        selector: str,
+        custom: dict[str, str | ct.SelectorList] | None = None,
+        flags: int = 0
+    ) -> None:
+        """Initialize."""
+
+        self.pattern = selector.replace('\x00', '\ufffd')
+        self.flags = flags
+        self.debug = self.flags & util.DEBUG
+        self.custom = {} if custom is None else custom
+
+    def parse_attribute_selector(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """Create attribute selector from the returned regex match."""
+
+        inverse = False
+        op = m.group('cmp')
+        case = util.lower(m.group('case')) if m.group('case') else None
+        ns = css_unescape(m.group('attr_ns')[:-1]) if m.group('attr_ns') else ''
+        attr = css_unescape(m.group('attr_name'))
+        is_type = False
+        pattern2 = None
+        value = ''
+
+        if case:
+            flags = (re.I if case == 'i' else 0) | re.DOTALL
+        elif util.lower(attr) == 'type':
+            flags = re.I | re.DOTALL
+            is_type = True
+        else:
+            flags = re.DOTALL
+
+        if op:
+            if m.group('value').startswith(('"', "'")):
+                value = css_unescape(m.group('value')[1:-1], True)
+            else:
+                value = css_unescape(m.group('value'))
+
+        if not op:
+            # Attribute name
+            pattern = None
+        elif op.startswith('^'):
+            # Value start with
+            pattern = re.compile(r'^%s.*' % re.escape(value), flags)
+        elif op.startswith('$'):
+            # Value ends with
+            pattern = re.compile(r'.*?%s$' % re.escape(value), flags)
+        elif op.startswith('*'):
+            # Value contains
+            pattern = re.compile(r'.*?%s.*' % re.escape(value), flags)
+        elif op.startswith('~'):
+            # Value contains word within space separated list
+            # `~=` should match nothing if it is empty or contains whitespace,
+            # so if either of these cases is present, use `[^\s\S]` which cannot be matched.
+            value = r'[^\s\S]' if not value or RE_WS.search(value) else re.escape(value)
+            pattern = re.compile(r'.*?(?:(?<=^)|(?<=[ \t\r\n\f]))%s(?=(?:[ \t\r\n\f]|$)).*' % value, flags)
+        elif op.startswith('|'):
+            # Value starts with word in dash separated list
+            pattern = re.compile(r'^%s(?:-.*)?$' % re.escape(value), flags)
+        else:
+            # Value matches
+            pattern = re.compile(r'^%s$' % re.escape(value), flags)
+            if op.startswith('!'):
+                # Equivalent to `:not([attr=value])`
+                inverse = True
+        if is_type and pattern:
+            pattern2 = re.compile(pattern.pattern)
+
+        # Append the attribute selector
+        sel_attr = ct.SelectorAttribute(attr, ns, pattern, pattern2)
+        if inverse:
+            # If we are using `!=`, we need to nest the pattern under a `:not()`.
+            sub_sel = _Selector()
+            sub_sel.attributes.append(sel_attr)
+            not_list = ct.SelectorList([sub_sel.freeze()], True, False)
+            sel.selectors.append(not_list)
+        else:
+            sel.attributes.append(sel_attr)
+
+        has_selector = True
+        return has_selector
+
+    def parse_tag_pattern(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """Parse tag pattern from regex match."""
+
+        prefix = css_unescape(m.group('tag_ns')[:-1]) if m.group('tag_ns') else None
+        tag = css_unescape(m.group('tag_name'))
+        sel.tag = ct.SelectorTag(tag, prefix)
+        has_selector = True
+        return has_selector
+
+    def parse_pseudo_class_custom(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """
+        Parse custom pseudo class alias.
+
+        Compile custom selectors as we need them. When compiling a custom selector,
+        set it to `None` in the dictionary so we can avoid an infinite loop.
+        """
+
+        pseudo = util.lower(css_unescape(m.group('name')))
+        selector = self.custom.get(pseudo)
+        if selector is None:
+            raise SelectorSyntaxError(
+                f"Undefined custom selector '{pseudo}' found at position {m.end(0)}",
+                self.pattern,
+                m.end(0)
+            )
+
+        if not isinstance(selector, ct.SelectorList):
+            del self.custom[pseudo]
+            selector = CSSParser(
+                selector, custom=self.custom, flags=self.flags
+            ).process_selectors(flags=FLG_PSEUDO)
+            self.custom[pseudo] = selector
+
+        sel.selectors.append(selector)
+        has_selector = True
+        return has_selector
+
+    def parse_pseudo_class(
+        self,
+        sel: _Selector,
+        m: Match[str],
+        has_selector: bool,
+        iselector: Iterator[tuple[str, Match[str]]],
+        is_html: bool
+    ) -> tuple[bool, bool]:
+        """Parse pseudo class."""
+
+        complex_pseudo = False
+        pseudo = util.lower(css_unescape(m.group('name')))
+        if m.group('open'):
+            complex_pseudo = True
+        if complex_pseudo and pseudo in PSEUDO_COMPLEX:
+            has_selector = self.parse_pseudo_open(sel, pseudo, has_selector, iselector, m.end(0))
+        elif not complex_pseudo and pseudo in PSEUDO_SIMPLE:
+            if pseudo == ':root':
+                sel.flags |= ct.SEL_ROOT
+            elif pseudo == ':defined':
+                sel.flags |= ct.SEL_DEFINED
+                is_html = True
+            elif pseudo == ':scope':
+                sel.flags |= ct.SEL_SCOPE
+            elif pseudo == ':empty':
+                sel.flags |= ct.SEL_EMPTY
+            elif pseudo in (':link', ':any-link'):
+                sel.selectors.append(CSS_LINK)
+            elif pseudo == ':checked':
+                sel.selectors.append(CSS_CHECKED)
+            elif pseudo == ':default':
+                sel.selectors.append(CSS_DEFAULT)
+            elif pseudo == ':indeterminate':
+                sel.selectors.append(CSS_INDETERMINATE)
+            elif pseudo == ":disabled":
+                sel.selectors.append(CSS_DISABLED)
+            elif pseudo == ":enabled":
+                sel.selectors.append(CSS_ENABLED)
+            elif pseudo == ":required":
+                sel.selectors.append(CSS_REQUIRED)
+            elif pseudo == ":optional":
+                sel.selectors.append(CSS_OPTIONAL)
+            elif pseudo == ":read-only":
+                sel.selectors.append(CSS_READ_ONLY)
+            elif pseudo == ":read-write":
+                sel.selectors.append(CSS_READ_WRITE)
+            elif pseudo == ":in-range":
+                sel.selectors.append(CSS_IN_RANGE)
+            elif pseudo == ":out-of-range":
+                sel.selectors.append(CSS_OUT_OF_RANGE)
+            elif pseudo == ":placeholder-shown":
+                sel.selectors.append(CSS_PLACEHOLDER_SHOWN)
+            elif pseudo == ':first-child':
+                sel.nth.append(ct.SelectorNth(1, False, 0, False, False, ct.SelectorList()))
+            elif pseudo == ':last-child':
+                sel.nth.append(ct.SelectorNth(1, False, 0, False, True, ct.SelectorList()))
+            elif pseudo == ':first-of-type':
+                sel.nth.append(ct.SelectorNth(1, False, 0, True, False, ct.SelectorList()))
+            elif pseudo == ':last-of-type':
+                sel.nth.append(ct.SelectorNth(1, False, 0, True, True, ct.SelectorList()))
+            elif pseudo == ':only-child':
+                sel.nth.extend(
+                    [
+                        ct.SelectorNth(1, False, 0, False, False, ct.SelectorList()),
+                        ct.SelectorNth(1, False, 0, False, True, ct.SelectorList())
+                    ]
+                )
+            elif pseudo == ':only-of-type':
+                sel.nth.extend(
+                    [
+                        ct.SelectorNth(1, False, 0, True, False, ct.SelectorList()),
+                        ct.SelectorNth(1, False, 0, True, True, ct.SelectorList())
+                    ]
+                )
+            has_selector = True
+        elif complex_pseudo and pseudo in PSEUDO_COMPLEX_NO_MATCH:
+            self.parse_selectors(iselector, m.end(0), FLG_PSEUDO | FLG_OPEN)
+            sel.no_match = True
+            has_selector = True
+        elif not complex_pseudo and pseudo in PSEUDO_SIMPLE_NO_MATCH:
+            sel.no_match = True
+            has_selector = True
+        elif pseudo in PSEUDO_SUPPORTED:
+            raise SelectorSyntaxError(
+                f"Invalid syntax for pseudo class '{pseudo}'",
+                self.pattern,
+                m.start(0)
+            )
+        else:
+            raise NotImplementedError(
+                f"'{pseudo}' pseudo-class is not implemented at this time"
+            )
+
+        return has_selector, is_html
+
+    def parse_pseudo_nth(
+        self,
+        sel: _Selector,
+        m: Match[str],
+        has_selector: bool,
+        iselector: Iterator[tuple[str, Match[str]]]
+    ) -> bool:
+        """Parse `nth` pseudo."""
+
+        mdict = m.groupdict()
+        if mdict.get('pseudo_nth_child'):
+            postfix = '_child'
+        else:
+            postfix = '_type'
+        mdict['name'] = util.lower(css_unescape(mdict['name']))
+        content = util.lower(mdict.get('nth' + postfix))
+        if content == 'even':
+            # 2n
+            s1 = 2
+            s2 = 0
+            var = True
+        elif content == 'odd':
+            # 2n+1
+            s1 = 2
+            s2 = 1
+            var = True
+        else:
+            nth_parts = cast(Match[str], RE_NTH.match(content))
+            _s1 = '-' if nth_parts.group('s1') and nth_parts.group('s1') == '-' else ''
+            a = nth_parts.group('a')
+            var = a.endswith('n')
+            if a.startswith('n'):
+                _s1 += '1'
+            elif var:
+                _s1 += a[:-1]
+            else:
+                _s1 += a
+            _s2 = '-' if nth_parts.group('s2') and nth_parts.group('s2') == '-' else ''
+            if nth_parts.group('b'):
+                _s2 += nth_parts.group('b')
+            else:
+                _s2 = '0'
+            s1 = int(_s1, 10)
+            s2 = int(_s2, 10)
+
+        pseudo_sel = mdict['name']
+        if postfix == '_child':
+            if m.group('of'):
+                # Parse the rest of `of S`.
+                nth_sel = self.parse_selectors(iselector, m.end(0), FLG_PSEUDO | FLG_OPEN)
+            else:
+                # Use default `*|*` for `of S`.
+                nth_sel = CSS_NTH_OF_S_DEFAULT
+            if pseudo_sel == ':nth-child':
+                sel.nth.append(ct.SelectorNth(s1, var, s2, False, False, nth_sel))
+            elif pseudo_sel == ':nth-last-child':
+                sel.nth.append(ct.SelectorNth(s1, var, s2, False, True, nth_sel))
+        else:
+            if pseudo_sel == ':nth-of-type':
+                sel.nth.append(ct.SelectorNth(s1, var, s2, True, False, ct.SelectorList()))
+            elif pseudo_sel == ':nth-last-of-type':
+                sel.nth.append(ct.SelectorNth(s1, var, s2, True, True, ct.SelectorList()))
+        has_selector = True
+        return has_selector
+
+    def parse_pseudo_open(
+        self,
+        sel: _Selector,
+        name: str,
+        has_selector: bool,
+        iselector: Iterator[tuple[str, Match[str]]],
+        index: int
+    ) -> bool:
+        """Parse pseudo with opening bracket."""
+
+        flags = FLG_PSEUDO | FLG_OPEN
+        if name == ':not':
+            flags |= FLG_NOT
+        elif name == ':has':
+            flags |= FLG_RELATIVE
+        elif name in (':where', ':is'):
+            flags |= FLG_FORGIVE
+
+        sel.selectors.append(self.parse_selectors(iselector, index, flags))
+        has_selector = True
+
+        return has_selector
+
+    def parse_has_combinator(
+        self,
+        sel: _Selector,
+        m: Match[str],
+        has_selector: bool,
+        selectors: list[_Selector],
+        rel_type: str,
+        index: int
+    ) -> tuple[bool, _Selector, str]:
+        """Parse combinator tokens."""
+
+        combinator = m.group('relation').strip()
+        if not combinator:
+            combinator = WS_COMBINATOR
+        if combinator == COMMA_COMBINATOR:
+            sel.rel_type = rel_type
+            selectors[-1].relations.append(sel)
+            rel_type = ":" + WS_COMBINATOR
+            selectors.append(_Selector())
+        else:
+            if has_selector:
+                # End the current selector and associate the leading combinator with this selector.
+                sel.rel_type = rel_type
+                selectors[-1].relations.append(sel)
+            elif rel_type[1:] != WS_COMBINATOR:
+                # It's impossible to have two whitespace combinators after each other as the patterns
+                # will gobble up trailing whitespace. It is also impossible to have a whitespace
+                # combinator after any other kind for the same reason. But we could have
+                # multiple non-whitespace combinators. So if the current combinator is not a whitespace,
+                # then we've hit the multiple combinator case, so we should fail.
+                raise SelectorSyntaxError(
+                    f'The multiple combinators at position {index}',
+                    self.pattern,
+                    index
+                )
+
+            # Set the leading combinator for the next selector.
+            rel_type = ':' + combinator
+
+        sel = _Selector()
+        has_selector = False
+        return has_selector, sel, rel_type
+
+    def parse_combinator(
+        self,
+        sel: _Selector,
+        m: Match[str],
+        has_selector: bool,
+        selectors: list[_Selector],
+        relations: list[_Selector],
+        is_pseudo: bool,
+        is_forgive: bool,
+        index: int
+    ) -> tuple[bool, _Selector]:
+        """Parse combinator tokens."""
+
+        combinator = m.group('relation').strip()
+        if not combinator:
+            combinator = WS_COMBINATOR
+        if not has_selector:
+            if not is_forgive or combinator != COMMA_COMBINATOR:
+                raise SelectorSyntaxError(
+                    f"The combinator '{combinator}' at position {index}, must have a selector before it",
+                    self.pattern,
+                    index
+                )
+
+            # If we are in a forgiving pseudo class, just make the selector a "no match"
+            if combinator == COMMA_COMBINATOR:
+                sel.no_match = True
+                del relations[:]
+                selectors.append(sel)
+        else:
+            if combinator == COMMA_COMBINATOR:
+                if not sel.tag and not is_pseudo:
+                    # Implied `*`
+                    sel.tag = ct.SelectorTag('*', None)
+                sel.relations.extend(relations)
+                selectors.append(sel)
+                del relations[:]
+            else:
+                sel.relations.extend(relations)
+                sel.rel_type = combinator
+                del relations[:]
+                relations.append(sel)
+
+        sel = _Selector()
+        has_selector = False
+
+        return has_selector, sel
+
+    def parse_class_id(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """Parse HTML classes and ids."""
+
+        selector = m.group(0)
+        if selector.startswith('.'):
+            sel.classes.append(css_unescape(selector[1:]))
+        else:
+            sel.ids.append(css_unescape(selector[1:]))
+        has_selector = True
+        return has_selector
+
+    def parse_pseudo_contains(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """Parse contains."""
+
+        pseudo = util.lower(css_unescape(m.group('name')))
+        if pseudo == ":contains":
+            warnings.warn(  # noqa: B028
+                "The pseudo class ':contains' is deprecated, ':-soup-contains' should be used moving forward.",
+                FutureWarning
+            )
+        contains_own = pseudo == ":-soup-contains-own"
+        values = css_unescape(m.group('values'))
+        patterns = []
+        for token in RE_VALUES.finditer(values):
+            if token.group('split'):
+                continue
+            value = token.group('value')
+            if value.startswith(("'", '"')):
+                value = css_unescape(value[1:-1], True)
+            else:
+                value = css_unescape(value)
+            patterns.append(value)
+        sel.contains.append(ct.SelectorContains(patterns, contains_own))
+        has_selector = True
+        return has_selector
+
+    def parse_pseudo_lang(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """Parse pseudo language."""
+
+        values = m.group('values')
+        patterns = []
+        for token in RE_VALUES.finditer(values):
+            if token.group('split'):
+                continue
+            value = token.group('value')
+            if value.startswith(('"', "'")):
+                value = css_unescape(value[1:-1], True)
+            else:
+                value = css_unescape(value)
+
+            patterns.append(value)
+
+        sel.lang.append(ct.SelectorLang(patterns))
+        has_selector = True
+
+        return has_selector
+
+    def parse_pseudo_dir(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """Parse pseudo direction."""
+
+        value = ct.SEL_DIR_LTR if util.lower(m.group('dir')) == 'ltr' else ct.SEL_DIR_RTL
+        sel.flags |= value
+        has_selector = True
+        return has_selector
+
+    def parse_selectors(
+        self,
+        iselector: Iterator[tuple[str, Match[str]]],
+        index: int = 0,
+        flags: int = 0
+    ) -> ct.SelectorList:
+        """Parse selectors."""
+
+        # Initialize important variables
+        sel = _Selector()
+        selectors = []
+        has_selector = False
+        closed = False
+        relations = []  # type: list[_Selector]
+        rel_type = ":" + WS_COMBINATOR
+
+        # Setup various flags
+        is_open = bool(flags & FLG_OPEN)
+        is_pseudo = bool(flags & FLG_PSEUDO)
+        is_relative = bool(flags & FLG_RELATIVE)
+        is_not = bool(flags & FLG_NOT)
+        is_html = bool(flags & FLG_HTML)
+        is_default = bool(flags & FLG_DEFAULT)
+        is_indeterminate = bool(flags & FLG_INDETERMINATE)
+        is_in_range = bool(flags & FLG_IN_RANGE)
+        is_out_of_range = bool(flags & FLG_OUT_OF_RANGE)
+        is_placeholder_shown = bool(flags & FLG_PLACEHOLDER_SHOWN)
+        is_forgive = bool(flags & FLG_FORGIVE)
+
+        # Print out useful debug stuff
+        if self.debug:  # pragma: no cover
+            if is_pseudo:
+                print('    is_pseudo: True')
+            if is_open:
+                print('    is_open: True')
+            if is_relative:
+                print('    is_relative: True')
+            if is_not:
+                print('    is_not: True')
+            if is_html:
+                print('    is_html: True')
+            if is_default:
+                print('    is_default: True')
+            if is_indeterminate:
+                print('    is_indeterminate: True')
+            if is_in_range:
+                print('    is_in_range: True')
+            if is_out_of_range:
+                print('    is_out_of_range: True')
+            if is_placeholder_shown:
+                print('    is_placeholder_shown: True')
+            if is_forgive:
+                print('    is_forgive: True')
+
+        # The algorithm for relative selectors require an initial selector in the selector list
+        if is_relative:
+            selectors.append(_Selector())
+
+        try:
+            while True:
+                key, m = next(iselector)
+
+                # Handle parts
+                if key == "at_rule":
+                    raise NotImplementedError(f"At-rules found at position {m.start(0)}")
+                elif key == 'pseudo_class_custom':
+                    has_selector = self.parse_pseudo_class_custom(sel, m, has_selector)
+                elif key == 'pseudo_class':
+                    has_selector, is_html = self.parse_pseudo_class(sel, m, has_selector, iselector, is_html)
+                elif key == 'pseudo_element':
+                    raise NotImplementedError(f"Pseudo-element found at position {m.start(0)}")
+                elif key == 'pseudo_contains':
+                    has_selector = self.parse_pseudo_contains(sel, m, has_selector)
+                elif key in ('pseudo_nth_type', 'pseudo_nth_child'):
+                    has_selector = self.parse_pseudo_nth(sel, m, has_selector, iselector)
+                elif key == 'pseudo_lang':
+                    has_selector = self.parse_pseudo_lang(sel, m, has_selector)
+                elif key == 'pseudo_dir':
+                    has_selector = self.parse_pseudo_dir(sel, m, has_selector)
+                    # Currently only supports HTML
+                    is_html = True
+                elif key == 'pseudo_close':
+                    if not has_selector:
+                        if not is_forgive:
+                            raise SelectorSyntaxError(
+                                f"Expected a selector at position {m.start(0)}",
+                                self.pattern,
+                                m.start(0)
+                            )
+                        sel.no_match = True
+                    if is_open:
+                        closed = True
+                        break
+                    else:
+                        raise SelectorSyntaxError(
+                            f"Unmatched pseudo-class close at position {m.start(0)}",
+                            self.pattern,
+                            m.start(0)
+                        )
+                elif key == 'combine':
+                    if is_relative:
+                        has_selector, sel, rel_type = self.parse_has_combinator(
+                            sel, m, has_selector, selectors, rel_type, index
+                        )
+                    else:
+                        has_selector, sel = self.parse_combinator(
+                            sel, m, has_selector, selectors, relations, is_pseudo, is_forgive, index
+                        )
+                elif key == 'attribute':
+                    has_selector = self.parse_attribute_selector(sel, m, has_selector)
+                elif key == 'tag':
+                    if has_selector:
+                        raise SelectorSyntaxError(
+                            f"Tag name found at position {m.start(0)} instead of at the start",
+                            self.pattern,
+                            m.start(0)
+                        )
+                    has_selector = self.parse_tag_pattern(sel, m, has_selector)
+                elif key in ('class', 'id'):
+                    has_selector = self.parse_class_id(sel, m, has_selector)
+
+                index = m.end(0)
+        except StopIteration:
+            pass
+
+        # Handle selectors that are not closed
+        if is_open and not closed:
+            raise SelectorSyntaxError(
+                f"Unclosed pseudo-class at position {index}",
+                self.pattern,
+                index
+            )
+
+        # Cleanup completed selector piece
+        if has_selector:
+            if not sel.tag and not is_pseudo:
+                # Implied `*`
+                sel.tag = ct.SelectorTag('*', None)
+            if is_relative:
+                sel.rel_type = rel_type
+                selectors[-1].relations.append(sel)
+            else:
+                sel.relations.extend(relations)
+                del relations[:]
+                selectors.append(sel)
+
+        # Forgive empty slots in pseudo-classes that have lists (and are forgiving)
+        elif is_forgive and (not selectors or not relations):
+            # Handle normal pseudo-classes with empty slots like `:is()` etc.
+            sel.no_match = True
+            del relations[:]
+            selectors.append(sel)
+            has_selector = True
+
+        if not has_selector:
+            # We will always need to finish a selector when `:has()` is used as it leads with combining.
+            # May apply to others as well.
+            raise SelectorSyntaxError(
+                f'Expected a selector at position {index}',
+                self.pattern,
+                index
+            )
+
+        # Some patterns require additional logic, such as default. We try to make these the
+        # last pattern, and append the appropriate flag to that selector which communicates
+        # to the matcher what additional logic is required.
+        if is_default:
+            selectors[-1].flags = ct.SEL_DEFAULT
+        if is_indeterminate:
+            selectors[-1].flags = ct.SEL_INDETERMINATE
+        if is_in_range:
+            selectors[-1].flags = ct.SEL_IN_RANGE
+        if is_out_of_range:
+            selectors[-1].flags = ct.SEL_OUT_OF_RANGE
+        if is_placeholder_shown:
+            selectors[-1].flags = ct.SEL_PLACEHOLDER_SHOWN
+
+        # Return selector list
+        return ct.SelectorList([s.freeze() for s in selectors], is_not, is_html)
+
+    def selector_iter(self, pattern: str) -> Iterator[tuple[str, Match[str]]]:
+        """Iterate selector tokens."""
+
+        # Ignore whitespace and comments at start and end of pattern
+        m = RE_WS_BEGIN.search(pattern)
+        index = m.end(0) if m else 0
+        m = RE_WS_END.search(pattern)
+        end = (m.start(0) - 1) if m else (len(pattern) - 1)
+
+        if self.debug:  # pragma: no cover
+            print(f'## PARSING: {pattern!r}')
+        while index <= end:
+            m = None
+            for v in self.css_tokens:
+                m = v.match(pattern, index, self.flags)
+                if m:
+                    name = v.get_name()
+                    if self.debug:  # pragma: no cover
+                        print(f"TOKEN: '{name}' --> {m.group(0)!r} at position {m.start(0)}")
+                    index = m.end(0)
+                    yield name, m
+                    break
+            if m is None:
+                c = pattern[index]
+                # If the character represents the start of one of the known selector types,
+                # throw an exception mentioning that the known selector type is in error;
+                # otherwise, report the invalid character.
+                if c == '[':
+                    msg = f"Malformed attribute selector at position {index}"
+                elif c == '.':
+                    msg = f"Malformed class selector at position {index}"
+                elif c == '#':
+                    msg = f"Malformed id selector at position {index}"
+                elif c == ':':
+                    msg = f"Malformed pseudo-class selector at position {index}"
+                else:
+                    msg = f"Invalid character {c!r} position {index}"
+                raise SelectorSyntaxError(msg, self.pattern, index)
+        if self.debug:  # pragma: no cover
+            print('## END PARSING')
+
+    def process_selectors(self, index: int = 0, flags: int = 0) -> ct.SelectorList:
+        """Process selectors."""
+
+        return self.parse_selectors(self.selector_iter(self.pattern), index, flags)
+
+
+# Precompile CSS selector lists for pseudo-classes (additional logic may be required beyond the pattern)
+# A few patterns are order dependent as they use patterns previous compiled.
+
+# CSS pattern for `:link` and `:any-link`
+CSS_LINK = CSSParser(
+    'html|*:is(a, area)[href]'
+).process_selectors(flags=FLG_PSEUDO | FLG_HTML)
+# CSS pattern for `:checked`
+CSS_CHECKED = CSSParser(
+    '''
+    html|*:is(input[type=checkbox], input[type=radio])[checked], html|option[selected]
+    '''
+).process_selectors(flags=FLG_PSEUDO | FLG_HTML)
+# CSS pattern for `:default` (must compile CSS_CHECKED first)
+CSS_DEFAULT = CSSParser(
+    '''
+    :checked,
+
+    /*
+    This pattern must be at the end.
+    Special logic is applied to the last selector.
+    */
+    html|form html|*:is(button, input)[type="submit"]
+    '''
+).process_selectors(flags=FLG_PSEUDO | FLG_HTML | FLG_DEFAULT)
+# CSS pattern for `:indeterminate`
+CSS_INDETERMINATE = CSSParser(
+    '''
+    html|input[type="checkbox"][indeterminate],
+    html|input[type="radio"]:is(:not([name]), [name=""]):not([checked]),
+    html|progress:not([value]),
+
+    /*
+    This pattern must be at the end.
+    Special logic is applied to the last selector.
+    */
+    html|input[type="radio"][name]:not([name='']):not([checked])
+    '''
+).process_selectors(flags=FLG_PSEUDO | FLG_HTML | FLG_INDETERMINATE)
+# CSS pattern for `:disabled`
+CSS_DISABLED = CSSParser(
+    '''
+    html|*:is(input:not([type=hidden]), button, select, textarea, fieldset, optgroup, option, fieldset)[disabled],
+    html|optgroup[disabled] > html|option,
+    html|fieldset[disabled] > html|*:is(input:not([type=hidden]), button, select, textarea, fieldset),
+    html|fieldset[disabled] >
+        html|*:not(legend:nth-of-type(1)) html|*:is(input:not([type=hidden]), button, select, textarea, fieldset)
+    '''
+).process_selectors(flags=FLG_PSEUDO | FLG_HTML)
+# CSS pattern for `:enabled`
+CSS_ENABLED = CSSParser(
+    '''
+    html|*:is(input:not([type=hidden]), button, select, textarea, fieldset, optgroup, option, fieldset):not(:disabled)
+    '''
+).process_selectors(flags=FLG_PSEUDO | FLG_HTML)
+# CSS pattern for `:required`
+CSS_REQUIRED = CSSParser(
+    'html|*:is(input, textarea, select)[required]'
+).process_selectors(flags=FLG_PSEUDO | FLG_HTML)
+# CSS pattern for `:optional`
+CSS_OPTIONAL = CSSParser(
+    'html|*:is(input, textarea, select):not([required])'
+).process_selectors(flags=FLG_PSEUDO | FLG_HTML)
+# CSS pattern for `:placeholder-shown`
+CSS_PLACEHOLDER_SHOWN = CSSParser(
+    '''
+    html|input:is(
+        :not([type]),
+        [type=""],
+        [type=text],
+        [type=search],
+        [type=url],
+        [type=tel],
+        [type=email],
+        [type=password],
+        [type=number]
+    )[placeholder]:not([placeholder='']):is(:not([value]), [value=""]),
+    html|textarea[placeholder]:not([placeholder=''])
+    '''
+).process_selectors(flags=FLG_PSEUDO | FLG_HTML | FLG_PLACEHOLDER_SHOWN)
+# CSS pattern default for `:nth-child` "of S" feature
+CSS_NTH_OF_S_DEFAULT = CSSParser(
+    '*|*'
+).process_selectors(flags=FLG_PSEUDO)
+# CSS pattern for `:read-write` (CSS_DISABLED must be compiled first)
+CSS_READ_WRITE = CSSParser(
+    '''
+    html|*:is(
+        textarea,
+        input:is(
+            :not([type]),
+            [type=""],
+            [type=text],
+            [type=search],
+            [type=url],
+            [type=tel],
+            [type=email],
+            [type=number],
+            [type=password],
+            [type=date],
+            [type=datetime-local],
+            [type=month],
+            [type=time],
+            [type=week]
+        )
+    ):not([readonly], :disabled),
+    html|*:is([contenteditable=""], [contenteditable="true" i])
+    '''
+).process_selectors(flags=FLG_PSEUDO | FLG_HTML)
+# CSS pattern for `:read-only`
+CSS_READ_ONLY = CSSParser(
+    '''
+    html|*:not(:read-write)
+    '''
+).process_selectors(flags=FLG_PSEUDO | FLG_HTML)
+# CSS pattern for `:in-range`
+CSS_IN_RANGE = CSSParser(
+    '''
+    html|input:is(
+        [type="date"],
+        [type="month"],
+        [type="week"],
+        [type="time"],
+        [type="datetime-local"],
+        [type="number"],
+        [type="range"]
+    ):is(
+        [min],
+        [max]
+    )
+    '''
+).process_selectors(flags=FLG_PSEUDO | FLG_IN_RANGE | FLG_HTML)
+# CSS pattern for `:out-of-range`
+CSS_OUT_OF_RANGE = CSSParser(
+    '''
+    html|input:is(
+        [type="date"],
+        [type="month"],
+        [type="week"],
+        [type="time"],
+        [type="datetime-local"],
+        [type="number"],
+        [type="range"]
+    ):is(
+        [min],
+        [max]
+    )
+    '''
+).process_selectors(flags=FLG_PSEUDO | FLG_OUT_OF_RANGE | FLG_HTML)

shared/package-files/33/33451c69e142a8b3e01ac17c379987c3bb376ecae56c37c9636ba12e8cc9f7b2/_compat.pyi

@@ -0,0 +1,40 @@
+"""Static type stubs for `_compat.py`."""
+
+# https://github.com/scikit-learn/scikit-learn/pull/27910#issuecomment-2568023972
+from __future__ import annotations
+
+from types import ModuleType
+
+# TODO import from typing (requires Python >=3.13)
+from typing_extensions import TypeIs
+
+from ._typing import Array, Device
+
+# pylint: disable=missing-class-docstring,unused-argument
+
+class Namespace(ModuleType):
+    def device(self, x: Array, /) -> Device: ...
+
+def array_namespace(
+    *xs: Array | complex | None,
+    api_version: str | None = None,
+    use_compat: bool | None = None,
+) -> Namespace: ...
+def device(x: Array, /) -> Device: ...
+def is_array_api_obj(x: object, /) -> TypeIs[Array]: ...
+def is_array_api_strict_namespace(xp: ModuleType, /) -> TypeIs[Namespace]: ...
+def is_cupy_namespace(xp: ModuleType, /) -> TypeIs[Namespace]: ...
+def is_dask_namespace(xp: ModuleType, /) -> TypeIs[Namespace]: ...
+def is_jax_namespace(xp: ModuleType, /) -> TypeIs[Namespace]: ...
+def is_numpy_namespace(xp: ModuleType, /) -> TypeIs[Namespace]: ...
+def is_pydata_sparse_namespace(xp: ModuleType, /) -> TypeIs[Namespace]: ...
+def is_torch_namespace(xp: ModuleType, /) -> TypeIs[Namespace]: ...
+def is_cupy_array(x: object, /) -> TypeIs[Array]: ...
+def is_dask_array(x: object, /) -> TypeIs[Array]: ...
+def is_jax_array(x: object, /) -> TypeIs[Array]: ...
+def is_numpy_array(x: object, /) -> TypeIs[Array]: ...
+def is_pydata_sparse_array(x: object, /) -> TypeIs[Array]: ...
+def is_torch_array(x: object, /) -> TypeIs[Array]: ...
+def is_lazy_array(x: object, /) -> TypeIs[Array]: ...
+def is_writeable_array(x: object, /) -> TypeIs[Array]: ...
+def size(x: Array, /) -> int | None: ...

shared/package-files/33/3348b29618eeaad3dc6ceda901574383d9fd7b5113df9f6743db7138412b98ca/__init__.py

@@ -0,0 +1 @@
+from .modules import *  # noqa: F403

shared/package-files/33/3348cd5dcc3c57790e839d3009ea86e17335a401228dc8666b1bb0cd3672d511/conv3d_native.h

@@ -0,0 +1,22 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor conv3d_symint(const at::Tensor & input, const at::Tensor & weight, const c10::optional<at::Tensor> & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0), c10::SymIntArrayRef dilation=c10::SymInt(1), c10::SymInt groups=1);
+TORCH_API at::Tensor conv3d_padding_symint(const at::Tensor & input, const at::Tensor & weight, const c10::optional<at::Tensor> & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::string_view padding="valid", c10::SymIntArrayRef dilation=c10::SymInt(1), c10::SymInt groups=1);
+} // namespace native
+} // namespace at

shared/package-files/33/334b52745a1434c677fadeed0991dc8144b7ee2058cd9af335a0ee8b8696a11e/elnino.dat

@@ -0,0 +1,733 @@
+ YR   MON  NINO1+2  ANOM   NINO3    ANOM   NINO4    ANOM   NINO3.4  ANOM
+1950   1   23.11   -1.42   23.74   -1.91   27.03   -1.12   24.83   -1.72
+1950   2   24.20   -1.71   24.92   -1.45   27.15   -0.92   25.20   -1.53
+1950   3   25.37   -1.00   26.33   -0.80   27.06   -1.11   26.03   -1.20
+1950   4   23.86   -1.71   26.46   -0.97   27.29   -1.10   26.36   -1.30
+1950   5   23.03   -1.39   25.72   -1.38   27.59   -1.10   26.19   -1.58
+1950   6   21.57   -1.50   25.55   -0.92   27.97   -0.70   26.52   -1.01
+1950   7   20.63   -1.34   24.97   -0.68   27.83   -0.78   26.42   -0.69
+1950   8   20.15   -0.86   24.61   -0.45   27.72   -0.78   25.98   -0.77
+1950   9   19.67   -1.10   24.22   -0.72   27.66   -0.85   25.78   -0.92
+1950  10   20.03   -1.04   24.39   -0.56   27.44   -1.07   25.96   -0.68
+1950  11   20.02   -1.72   24.00   -1.05   27.35   -1.11   25.64   -0.96
+1950  12   21.80   -1.11   24.30   -0.91   27.30   -1.05   25.50   -1.07
+1951   1   24.19   -0.35   25.00   -0.65   27.36   -0.79   25.46   -1.09
+1951   2   25.28   -0.64   25.80   -0.57   27.27   -0.80   25.78   -0.96
+1951   3   25.60   -0.78   26.91   -0.22   27.96   -0.21   26.72   -0.51
+1951   4   25.37   -0.20   27.31   -0.11   28.49    0.09   27.24   -0.43
+1951   5   24.79    0.37   27.08   -0.02   29.04    0.35   27.68   -0.09
+1951   6   24.69    1.62   26.57    0.10   28.74    0.07   27.46   -0.07
+1951   7   23.86    1.88   26.54    0.89   28.82    0.21   27.72    0.61
+1951   8   22.32    1.31   25.67    0.62   28.53    0.04   27.36    0.61
+1951   9   21.44    0.67   25.56    0.62   28.62    0.11   27.51    0.81
+1951  10   21.77    0.70   25.85    0.90   28.71    0.20   27.43    0.78
+1951  11   22.33    0.59   26.18    1.13   28.74    0.29   27.48    0.87
+1951  12   22.89   -0.01   25.98    0.77   28.53    0.19   27.12    0.55
+1952   1   24.52   -0.02   25.85    0.20   28.35    0.19   26.85    0.30
+1952   2   26.21    0.29   26.46    0.08   28.08    0.00   26.79    0.06
+1952   3   26.37    0.00   27.18    0.05   28.10   -0.07   27.32    0.09
+1952   4   24.73   -0.84   27.41   -0.02   28.52    0.12   27.88    0.21
+1952   5   23.71   -0.71   26.92   -0.18   28.69   -0.01   27.99    0.21
+1952   6   22.34   -0.73   25.84   -0.63   28.47   -0.20   27.33   -0.20
+1952   7   20.89   -1.09   24.92   -0.73   28.24   -0.37   26.72   -0.38
+1952   8   20.02   -0.99   24.50   -0.56   28.09   -0.40   26.46   -0.29
+1952   9   19.63   -1.14   24.43   -0.51   28.55    0.04   26.54   -0.17
+1952  10   20.40   -0.67   24.52   -0.42   28.25   -0.26   26.54   -0.10
+1952  11   20.77   -0.97   24.36   -0.69   28.28   -0.17   26.36   -0.24
+1952  12   22.39   -0.52   24.88   -0.33   28.30   -0.04   26.53   -0.04
+1953   1   24.15   -0.39   25.77    0.11   28.31    0.15   26.85    0.29
+1953   2   26.34    0.42   26.74    0.36   28.26    0.18   27.19    0.45
+1953   3   27.36    0.98   27.57    0.44   28.10   -0.07   27.68    0.45
+1953   4   27.03    1.46   27.91    0.49   28.53    0.14   28.19    0.53
+1953   5   25.47    1.05   27.39    0.28   28.92    0.23   28.29    0.52
+1953   6   23.49    0.42   26.77    0.30   29.18    0.51   28.02    0.49
+1953   7   22.20    0.23   25.81    0.16   29.02    0.41   27.52    0.42
+1953   8   21.45    0.44   25.20    0.14   28.83    0.34   27.16    0.41
+1953   9   21.25    0.49   25.17    0.24   28.61    0.09   27.13    0.43
+1953  10   20.95   -0.12   25.07    0.13   28.91    0.41   27.02    0.38
+1953  11   21.60   -0.14   25.25    0.19   28.91    0.46   26.96    0.36
+1953  12   22.44   -0.47   25.55    0.34   28.74    0.40   26.99    0.42
+1954   1   23.02   -1.52   25.73    0.07   28.30    0.14   27.03    0.47
+1954   2   25.00   -0.92   26.43    0.05   28.16    0.08   27.22    0.48
+1954   3   25.33   -1.05   26.85   -0.28   27.89   -0.28   27.21   -0.02
+1954   4   22.97   -2.60   25.85   -1.57   28.20   -0.19   26.87   -0.80
+1954   5   21.73   -2.69   25.67   -1.44   28.40   -0.30   27.06   -0.71
+1954   6   20.77   -2.30   25.20   -1.27   28.32   -0.35   26.93   -0.60
+1954   7   19.52   -2.46   24.47   -1.17   28.00   -0.61   26.37   -0.74
+1954   8   19.33   -1.68   23.83   -1.23   27.76   -0.73   25.73   -1.02
+1954   9   18.95   -1.82   23.51   -1.43   27.61   -0.90   25.38   -1.33
+1954  10   19.11   -1.96   23.63   -1.31   27.54   -0.97   25.51   -1.13
+1954  11   20.27   -1.47   23.86   -1.19   27.53   -0.92   25.67   -0.93
+1954  12   21.30   -1.61   23.79   -1.42   27.61   -0.74   25.37   -1.20
+1955   1   23.75   -0.79   24.79   -0.86   27.60   -0.56   25.54   -1.02
+1955   2   24.82   -1.10   25.76   -0.62   27.30   -0.77   25.90   -0.84
+1955   3   25.14   -1.23   26.35   -0.78   27.37   -0.81   26.37   -0.86
+1955   4   24.22   -1.35   26.32   -1.11   27.82   -0.57   26.66   -1.01
+1955   5   22.16   -2.26   25.52   -1.58   28.03   -0.66   26.66   -1.11
+1955   6   21.20   -1.87   25.08   -1.39   28.08   -0.59   26.56   -0.97
+1955   7   20.46   -1.52   24.55   -1.10   28.14   -0.47   26.31   -0.80
+1955   8   19.63   -1.38   23.69   -1.37   27.94   -0.55   25.60   -1.15
+1955   9   19.24   -1.53   23.36   -1.57   27.71   -0.81   25.63   -1.07
+1955  10   19.16   -1.91   22.71   -2.24   27.22   -1.29   24.66   -1.98
+1955  11   19.84   -1.90   22.66   -2.39   26.79   -1.66   24.29   -2.32
+1955  12   21.19   -1.71   23.08   -2.13   27.20   -1.15   24.58   -1.99
+1956   1   23.24   -1.30   24.47   -1.18   27.18   -0.97   25.28   -1.27
+1956   2   24.71   -1.20   25.80   -0.57   27.27   -0.81   26.00   -0.73
+1956   3   25.90   -0.47   26.84   -0.29   27.49   -0.68   26.62   -0.61
+1956   4   24.66   -0.91   27.12   -0.30   27.72   -0.68   26.96   -0.70
+1956   5   23.14   -1.28   26.63   -0.47   28.11   -0.58   27.23   -0.54
+1956   6   22.04   -1.03   25.87   -0.60   28.22   -0.46   26.99   -0.54
+1956   7   21.47   -0.51   24.82   -0.82   28.07   -0.54   26.37   -0.73
+1956   8   20.55   -0.46   24.16   -0.90   27.67   -0.82   25.91   -0.84
+1956   9   19.89   -0.88   23.97   -0.97   27.71   -0.80   25.91   -0.79
+1956  10   19.69   -1.39   24.01   -0.94   27.92   -0.59   25.83   -0.81
+1956  11   20.57   -1.17   23.91   -1.14   28.02   -0.43   25.64   -0.97
+1956  12   21.58   -1.32   24.06   -1.15   28.09   -0.26   25.71   -0.86
+1957   1   23.13   -1.40   25.05   -0.60   28.03   -0.12   26.09   -0.47
+1957   2   26.30    0.38   26.23   -0.15   28.10    0.02   26.58   -0.16
+1957   3   27.63    1.26   27.55    0.42   28.33    0.16   27.65    0.41
+1957   4   27.15    1.59   27.94    0.51   28.86    0.47   28.34    0.68
+1957   5   26.72    2.30   27.81    0.71   29.15    0.46   28.59    0.82
+1957   6   25.04    1.97   27.30    0.84   28.83    0.16   28.28    0.75
+1957   7   23.83    1.85   26.95    1.31   28.73    0.12   28.11    1.00
+1957   8   22.34    1.33   26.14    1.08   28.91    0.41   27.75    1.00
+1957   9   21.80    1.03   25.71    0.77   28.96    0.45   27.54    0.84
+1957  10   21.80    0.73   25.68    0.74   29.12    0.61   27.49    0.85
+1957  11   22.39    0.65   26.23    1.18   29.12    0.67   27.79    1.19
+1957  12   23.69    0.78   26.64    1.43   29.08    0.74   28.08    1.51
+1958   1   24.89    0.35   27.04    1.38   29.26    1.10   28.37    1.81
+1958   2   26.55    0.63   27.57    1.20   29.28    1.21   28.41    1.68
+1958   3   27.09    0.72   27.85    0.72   29.04    0.86   28.34    1.11
+1958   4   26.37    0.80   27.86    0.44   29.04    0.65   28.35    0.69
+1958   5   24.71    0.29   27.39    0.28   29.21    0.52   28.35    0.57
+1958   6   23.23    0.16   26.70    0.23   29.13    0.46   28.05    0.52
+1958   7   22.31    0.33   25.73    0.09   28.89    0.28   27.48    0.37
+1958   8   20.72   -0.29   24.97   -0.08   28.53    0.04   26.90    0.15
+1958   9   20.62   -0.14   24.45   -0.48   28.50   -0.02   26.50   -0.20
+1958  10   21.05   -0.02   24.65   -0.30   28.68    0.17   26.61   -0.03
+1958  11   21.52   -0.22   25.06    0.01   28.79    0.34   26.89    0.29
+1958  12   22.50   -0.40   25.02   -0.19   28.76    0.41   26.77    0.20
+1959   1   23.97   -0.57   25.75    0.10   28.63    0.48   27.14    0.58
+1959   2   25.90   -0.01   26.50    0.13   28.38    0.31   27.25    0.51
+1959   3   26.94    0.56   27.17    0.04   28.48    0.31   27.55    0.32
+1959   4   25.84    0.27   27.56    0.14   28.75    0.36   27.93    0.27
+1959   5   24.23   -0.19   26.94   -0.16   28.85    0.16   27.80    0.03
+1959   6   22.57   -0.50   26.07   -0.39   28.39   -0.28   27.34   -0.19
+1959   7   21.50   -0.47   24.94   -0.71   28.30   -0.31   26.56   -0.55
+1959   8   20.15   -0.86   24.40   -0.66   28.27   -0.22   26.32   -0.43
+1959   9   20.23   -0.54   24.37   -0.57   28.19   -0.32   26.17   -0.53
+1959  10   20.86   -0.21   24.67   -0.28   28.21   -0.30   26.42   -0.22
+1959  11   21.88    0.14   24.74   -0.31   28.12   -0.34   26.32   -0.28
+1959  12   22.55   -0.36   24.94   -0.27   28.07   -0.27   26.44   -0.13
+1960   1   24.40   -0.14   25.34   -0.32   27.77   -0.38   26.25   -0.31
+1960   2   25.59   -0.32   25.87   -0.50   27.49   -0.58   26.27   -0.47
+1960   3   26.01   -0.36   26.75   -0.38   27.77   -0.40   26.97   -0.26
+1960   4   24.66   -0.91   27.03   -0.39   28.08   -0.31   27.51   -0.16
+1960   5   23.53   -0.89   26.66   -0.45   28.52   -0.18   27.62   -0.16
+1960   6   21.83   -1.24   25.95   -0.52   28.35   -0.32   27.24   -0.29
+1960   7   20.73   -1.25   25.38   -0.26   28.31   -0.30   27.07   -0.04
+1960   8   20.10   -0.91   24.95   -0.11   28.19   -0.30   26.85    0.10
+1960   9   20.56   -0.20   24.70   -0.24   28.32   -0.20   26.60   -0.11
+1960  10   20.27   -0.80   24.24   -0.71   28.33   -0.17   26.35   -0.29
+1960  11   20.93   -0.81   24.31   -0.75   28.37   -0.09   26.34   -0.26
+1960  12   22.74   -0.17   24.73   -0.48   28.36    0.02   26.41   -0.16
+1961   1   24.58    0.04   25.19   -0.46   27.94   -0.21   26.38   -0.17
+1961   2   26.66    0.75   26.25   -0.13   27.85   -0.23   26.61   -0.13
+1961   3   25.95   -0.42   26.83   -0.30   27.92   -0.26   27.00   -0.24
+1961   4   25.17   -0.40   27.40   -0.02   27.96   -0.43   27.50   -0.16
+1961   5   23.60   -0.82   27.08   -0.02   28.38   -0.31   27.85    0.08
+1961   6   22.36   -0.71   26.37   -0.10   28.49   -0.18   27.86    0.33
+1961   7   20.52   -1.46   24.95   -0.70   28.33   -0.28   27.16    0.05
+1961   8   19.97   -1.04   24.20   -0.86   28.12   -0.37   26.43   -0.32
+1961   9   19.70   -1.07   23.65   -1.29   28.19   -0.33   25.97   -0.73
+1961  10   20.07   -1.01   23.89   -1.06   28.09   -0.42   25.94   -0.71
+1961  11   21.09   -0.65   24.38   -0.67   28.26   -0.19   26.20   -0.40
+1961  12   22.11   -0.80   24.75   -0.46   28.06   -0.28   26.20   -0.37
+1962   1   24.02   -0.52   25.23   -0.42   27.66   -0.49   26.12   -0.43
+1962   2   25.35   -0.56   26.07   -0.31   27.57   -0.51   26.28   -0.46
+1962   3   24.47   -1.90   26.49   -0.64   27.83   -0.34   26.80   -0.44
+1962   4   23.43   -2.14   26.59   -0.83   28.19   -0.20   27.22   -0.44
+1962   5   23.03   -1.39   26.28   -0.82   28.23   -0.47   27.23   -0.54
+1962   6   21.81   -1.26   25.83   -0.64   28.30   -0.37   27.18   -0.35
+1962   7   20.60   -1.37   25.21   -0.44   28.24   -0.37   26.93   -0.17
+1962   8   20.17   -0.84   24.72   -0.33   28.15   -0.34   26.52   -0.23
+1962   9   20.02   -0.75   24.20   -0.74   28.11   -0.40   26.07   -0.63
+1962  10   20.14   -0.93   24.23   -0.72   28.10   -0.41   26.06   -0.58
+1962  11   20.99   -0.75   24.10   -0.95   28.12   -0.33   25.88   -0.72
+1962  12   21.82   -1.09   24.12   -1.09   27.96   -0.38   25.75   -0.82
+1963   1   23.81   -0.73   24.96   -0.69   27.74   -0.41   25.86   -0.69
+1963   2   25.36   -0.55   25.91   -0.47   27.70   -0.38   26.39   -0.35
+1963   3   26.02   -0.36   27.06   -0.07   28.01   -0.16   27.31    0.08
+1963   4   24.67   -0.90   27.66    0.23   28.28   -0.11   27.87    0.20
+1963   5   23.97   -0.45   27.10    0.00   28.40   -0.30   27.71   -0.06
+1963   6   22.41   -0.66   26.74    0.27   28.38   -0.29   27.69    0.16
+1963   7   21.80   -0.18   26.36    0.71   28.72    0.11   27.91    0.80
+1963   8   21.31    0.30   25.80    0.74   29.01    0.51   27.63    0.88
+1963   9   21.00    0.23   25.41    0.48   29.03    0.52   27.47    0.76
+1963  10   21.13    0.06   25.58    0.63   29.07    0.56   27.56    0.92
+1963  11   21.64   -0.10   25.83    0.78   29.11    0.66   27.61    1.00
+1963  12   22.55   -0.35   26.08    0.87   28.87    0.52   27.71    1.14
+1964   1   24.15   -0.39   26.07    0.42   28.70    0.55   27.43    0.87
+1964   2   25.08   -0.83   26.41    0.04   28.39    0.31   27.27    0.53
+1964   3   25.30   -1.08   26.76   -0.37   28.08   -0.09   27.10   -0.13
+1964   4   24.61   -0.96   26.34   -1.09   28.24   -0.15   27.06   -0.60
+1964   5   21.93   -2.49   25.56   -1.54   28.39   -0.30   26.94   -0.84
+1964   6   21.44   -1.63   25.10   -1.37   28.06   -0.61   26.66   -0.87
+1964   7   20.25   -1.72   24.82   -0.82   27.87   -0.74   26.42   -0.69
+1964   8   19.48   -1.53   23.73   -1.33   27.64   -0.85   25.74   -1.01
+1964   9   19.67   -1.10   23.89   -1.04   27.38   -1.13   25.49   -1.22
+1964  10   19.79   -1.28   23.95   -0.99   27.38   -1.13   25.53   -1.11
+1964  11   20.88   -0.86   24.04   -1.02   27.34   -1.11   25.40   -1.20
+1964  12   21.83   -1.08   23.86   -1.35   27.25   -1.10   25.42   -1.15
+1965   1   24.22   -0.32   24.84   -0.81   27.57   -0.59   25.78   -0.77
+1965   2   26.17    0.26   25.96   -0.41   27.77   -0.31   26.37   -0.37
+1965   3   26.71    0.33   27.07   -0.06   27.93   -0.24   27.12   -0.11
+1965   4   27.01    1.45   27.66    0.23   28.06   -0.33   27.62   -0.05
+1965   5   26.09    1.67   27.68    0.57   28.70    0.01   28.07    0.29
+1965   6   24.60    1.54   27.24    0.78   29.02    0.35   28.19    0.66
+1965   7   23.26    1.29   26.64    0.99   29.08    0.47   28.02    0.91
+1965   8   22.54    1.53   26.25    1.20   29.19    0.70   28.07    1.32
+1965   9   21.26    0.49   26.07    1.13   29.11    0.60   28.03    1.32
+1965  10   21.57    0.50   26.15    1.21   29.30    0.80   28.26    1.62
+1965  11   22.29    0.55   26.50    1.45   29.17    0.72   28.29    1.69
+1965  12   23.35    0.44   26.59    1.38   29.03    0.68   28.07    1.50
+1966   1   25.15    0.62   26.70    1.05   28.87    0.71   27.75    1.19
+1966   2   25.88   -0.03   26.86    0.49   28.85    0.78   27.66    0.92
+1966   3   25.35   -1.02   27.26    0.13   29.18    1.01   28.22    0.99
+1966   4   24.26   -1.31   27.40   -0.03   28.99    0.60   28.24    0.58
+1966   5   22.92   -1.50   26.28   -0.82   29.08    0.39   27.67   -0.10
+1966   6   21.80   -1.27   26.08   -0.39   29.13    0.46   27.77    0.24
+1966   7   20.85   -1.13   25.42   -0.22   29.03    0.42   27.42    0.31
+1966   8   20.17   -0.84   24.51   -0.55   28.76    0.27   26.65   -0.10
+1966   9   20.04   -0.73   24.17   -0.77   28.71    0.20   26.49   -0.22
+1966  10   20.51   -0.56   24.42   -0.53   28.57    0.06   26.40   -0.25
+1966  11   21.03   -0.71   24.26   -0.79   28.65    0.20   26.42   -0.19
+1966  12   22.25   -0.66   24.30   -0.91   28.27   -0.07   26.21   -0.36
+1967   1   23.66   -0.88   25.09   -0.56   27.69   -0.46   26.18   -0.38
+1967   2   25.54   -0.37   26.09   -0.28   27.48   -0.60   26.35   -0.39
+1967   3   25.55   -0.83   26.46   -0.67   27.78   -0.39   26.67   -0.56
+1967   4   24.98   -0.59   26.46   -0.96   28.40    0.01   26.91   -0.76
+1967   5   23.77   -0.65   26.69   -0.41   28.80    0.11   27.49   -0.28
+1967   6   22.04   -1.03   26.40   -0.07   28.69    0.02   27.62    0.09
+1967   7   21.10   -0.88   25.32   -0.32   28.62    0.01   27.17    0.06
+1967   8   19.84   -1.17   24.30   -0.76   28.42   -0.07   26.62   -0.13
+1967   9   19.08   -1.68   23.69   -1.25   28.19   -0.32   26.10   -0.60
+1967  10   19.47   -1.60   23.80   -1.14   28.32   -0.19   26.19   -0.45
+1967  11   20.20   -1.54   24.01   -1.04   28.43   -0.02   26.26   -0.34
+1967  12   21.28   -1.62   24.14   -1.07   28.27   -0.08   26.10   -0.47
+1968   1   23.19   -1.35   24.40   -1.25   27.92   -0.24   25.78   -0.78
+1968   2   24.88   -1.04   25.00   -1.38   27.80   -0.28   25.79   -0.95
+1968   3   25.11   -1.27   25.86   -1.27   27.87   -0.30   26.38   -0.85
+1968   4   23.97   -1.60   26.57   -0.85   28.16   -0.24   27.09   -0.58
+1968   5   22.44   -1.98   26.19   -0.92   28.30   -0.40   27.15   -0.62
+1968   6   21.70   -1.36   26.22   -0.25   28.90    0.23   27.69    0.16
+1968   7   21.25   -0.72   26.00    0.35   28.70    0.09   27.61    0.51
+1968   8   20.97   -0.04   25.28    0.22   28.68    0.19   27.12    0.37
+1968   9   21.23    0.46   24.96    0.02   28.66    0.15   26.90    0.19
+1968  10   21.12    0.05   25.17    0.22   28.77    0.26   26.99    0.34
+1968  11   21.68   -0.06   25.35    0.29   29.17    0.72   27.38    0.78
+1968  12   23.20    0.29   25.79    0.58   29.17    0.83   27.42    0.85
+1969   1   24.67    0.13   26.27    0.62   29.11    0.95   27.55    0.99
+1969   2   25.56   -0.36   26.92    0.54   29.28    1.20   27.95    1.21
+1969   3   27.09    0.72   27.63    0.50   28.99    0.82   28.02    0.79
+1969   4   26.66    1.10   27.94    0.52   29.03    0.64   28.39    0.73
+1969   5   26.07    1.65   27.92    0.81   29.21    0.52   28.50    0.73
+1969   6   24.39    1.32   27.05    0.58   29.09    0.42   27.99    0.46
+1969   7   22.47    0.50   25.84    0.19   28.85    0.24   27.30    0.20
+1969   8   21.06    0.05   25.41    0.35   28.93    0.44   27.16    0.41
+1969   9   20.88    0.12   25.46    0.52   29.14    0.63   27.34    0.63
+1969  10   21.74    0.67   25.69    0.75   29.20    0.69   27.50    0.86
+1969  11   22.47    0.73   25.75    0.70   29.20    0.75   27.35    0.74
+1969  12   23.60    0.69   26.16    0.95   28.87    0.52   27.30    0.73
+1970   1   25.02    0.48   26.38    0.73   28.57    0.42   27.05    0.50
+1970   2   25.76   -0.16   26.52    0.14   28.57    0.50   27.02    0.29
+1970   3   25.53   -0.85   26.97   -0.16   28.52    0.35   27.35    0.12
+1970   4   24.76   -0.81   27.20   -0.23   28.73    0.34   27.96    0.29
+1970   5   22.94   -1.48   26.44   -0.66   28.97    0.28   27.77    0.00
+1970   6   21.27   -1.80   25.30   -1.17   28.75    0.08   27.14   -0.39
+1970   7   19.69   -2.28   24.18   -1.47   28.66    0.05   26.48   -0.63
+1970   8   19.27   -1.74   23.69   -1.37   28.16   -0.34   25.86   -0.89
+1970   9   19.50   -1.26   23.89   -1.05   27.88   -0.64   25.86   -0.84
+1970  10   20.16   -0.91   23.80   -1.14   27.86   -0.65   25.79   -0.85
+1970  11   20.61   -1.13   23.78   -1.28   27.91   -0.54   25.83   -0.77
+1970  12   21.77   -1.13   24.01   -1.20   27.44   -0.91   25.47   -1.10
+1971   1   23.33   -1.21   24.19   -1.47   26.94   -1.21   25.09   -1.46
+1971   2   24.58   -1.34   24.91   -1.47   27.07   -1.00   25.40   -1.34
+1971   3   25.24   -1.13   26.01   -1.11   27.25   -0.92   26.10   -1.13
+1971   4   24.95   -0.62   26.61   -0.81   27.63   -0.76   26.78   -0.89
+1971   5   23.29   -1.13   26.26   -0.85   28.02   -0.67   27.06   -0.71
+1971   6   21.60   -1.47   25.44   -1.03   28.03   -0.64   26.70   -0.83
+1971   7   21.01   -0.96   24.78   -0.86   27.93   -0.68   26.29   -0.82
+1971   8   19.97   -1.04   23.90   -1.16   27.84   -0.66   25.99   -0.76
+1971   9   19.74   -1.03   23.92   -1.02   27.75   -0.77   25.94   -0.76
+1971  10   19.88   -1.19   23.73   -1.21   27.80   -0.71   25.65   -0.99
+1971  11   20.94   -0.80   23.93   -1.12   27.87   -0.58   25.69   -0.91
+1971  12   21.99   -0.92   23.92   -1.29   27.98   -0.36   25.55   -1.02
+1972   1   24.51   -0.03   25.02   -0.63   27.97   -0.19   25.84   -0.72
+1972   2   26.66    0.75   26.04   -0.34   28.15    0.07   26.42   -0.32
+1972   3   27.09    0.72   27.12   -0.01   28.36    0.19   27.21   -0.02
+1972   4   26.25    0.68   27.78    0.35   28.82    0.43   27.93    0.26
+1972   5   25.47    1.05   27.62    0.52   29.21    0.52   28.27    0.49
+1972   6   25.01    1.95   27.37    0.90   29.19    0.52   28.23    0.70
+1972   7   24.11    2.13   27.14    1.49   29.09    0.48   28.18    1.07
+1972   8   23.42    2.41   26.86    1.81   28.92    0.43   28.10    1.35
+1972   9   22.12    1.35   26.48    1.54   29.10    0.58   28.10    1.40
+1972  10   22.58    1.51   26.83    1.89   29.44    0.93   28.46    1.82
+1972  11   23.32    1.58   27.17    2.11   29.48    1.03   28.69    2.09
+1972  12   24.89    1.99   27.60    2.39   29.35    1.00   28.81    2.24
+1973   1   26.03    1.49   27.52    1.86   29.03    0.88   28.44    1.88
+1973   2   26.48    0.56   27.24    0.87   28.77    0.70   28.00    1.26
+1973   3   26.27   -0.10   27.37    0.24   28.52    0.35   27.71    0.48
+1973   4   24.87   -0.70   26.87   -0.55   28.39    0.00   27.39   -0.28
+1973   5   23.44   -0.98   26.06   -1.04   28.51   -0.18   27.13   -0.65
+1973   6   21.76   -1.31   25.34   -1.12   28.23   -0.44   26.74   -0.79
+1973   7   20.84   -1.14   24.31   -1.34   28.01   -0.60   25.95   -1.16
+1973   8   19.47   -1.54   23.69   -1.36   27.65   -0.84   25.46   -1.29
+1973   9   19.49   -1.28   23.56   -1.38   27.53   -0.98   25.32   -1.39
+1973  10   19.80   -1.27   23.49   -1.46   27.32   -1.19   25.03   -1.61
+1973  11   20.71   -1.03   23.35   -1.71   26.97   -1.48   24.50   -2.11
+1973  12   21.74   -1.17   23.40   -1.81   26.69   -1.65   24.43   -2.14
+1974   1   23.29   -1.25   23.93   -1.72   26.50   -1.65   24.52   -2.04
+1974   2   24.87   -1.04   25.11   -1.27   26.87   -1.21   25.12   -1.61
+1974   3   25.69   -0.68   26.28   -0.85   27.21   -0.96   25.91   -1.32
+1974   4   25.28   -0.29   26.84   -0.58   27.46   -0.93   26.63   -1.03
+1974   5   24.35   -0.07   26.56   -0.54   27.94   -0.75   26.84   -0.93
+1974   6   22.48   -0.58   25.91   -0.55   27.97   -0.70   26.71   -0.82
+1974   7   21.58   -0.40   25.30   -0.35   27.83   -0.78   26.48   -0.63
+1974   8   20.73   -0.28   24.82   -0.24   27.97   -0.52   26.37   -0.38
+1974   9   20.15   -0.62   24.38   -0.56   27.91   -0.61   26.23   -0.47
+1974  10   19.88   -1.19   24.14   -0.81   27.74   -0.77   25.92   -0.73
+1974  11   20.68   -1.06   24.07   -0.98   27.72   -0.73   25.63   -0.97
+1974  12   21.41   -1.50   24.31   -0.90   27.61   -0.74   25.70   -0.87
+1975   1   23.55   -0.99   25.34   -0.31   27.86   -0.30   26.18   -0.37
+1975   2   24.95   -0.97   25.74   -0.64   27.96   -0.12   26.22   -0.52
+1975   3   26.06   -0.32   26.49   -0.64   27.76   -0.41   26.44   -0.79
+1975   4   25.53   -0.04   27.08   -0.34   27.83   -0.56   26.99   -0.67
+1975   5   23.71   -0.72   26.27   -0.83   27.95   -0.74   26.97   -0.80
+1975   6   21.84   -1.22   25.29   -1.18   27.71   -0.96   26.29   -1.24
+1975   7   21.05   -0.92   24.72   -0.93   27.57   -1.04   25.98   -1.12
+1975   8   19.97   -1.04   24.15   -0.91   27.29   -1.21   25.47   -1.28
+1975   9   19.14   -1.63   23.67   -1.27   26.91   -1.60   25.20   -1.50
+1975  10   19.17   -1.90   23.40   -1.54   26.76   -1.75   24.87   -1.77
+1975  11   19.44   -2.30   23.73   -1.33   26.80   -1.66   25.10   -1.50
+1975  12   21.05   -1.85   23.39   -1.82   26.84   -1.50   24.76   -1.81
+1976   1   23.51   -1.02   23.91   -1.74   26.92   -1.23   24.72   -1.84
+1976   2   25.36   -0.56   25.31   -1.07   27.19   -0.89   25.58   -1.16
+1976   3   25.88   -0.49   26.46   -0.66   27.56   -0.61   26.61   -0.62
+1976   4   25.72    0.15   26.94   -0.49   27.98   -0.42   26.99   -0.67
+1976   5   25.11    0.69   26.98   -0.12   28.32   -0.37   27.27   -0.50
+1976   6   24.46    1.39   26.95    0.48   28.32   -0.35   27.34   -0.19
+1976   7   23.30    1.33   26.29    0.65   28.42   -0.19   27.26    0.16
+1976   8   21.91    0.90   25.87    0.81   28.34   -0.15   27.09    0.34
+1976   9   21.56    0.79   25.76    0.83   28.50   -0.01   27.12    0.42
+1976  10   21.69    0.62   25.97    1.03   28.82    0.31   27.48    0.84
+1976  11   22.14    0.40   25.93    0.87   28.92    0.47   27.42    0.82
+1976  12   23.29    0.39   25.91    0.70   28.45    0.10   27.17    0.60
+1977   1   24.93    0.39   26.57    0.92   28.38    0.23   27.31    0.76
+1977   2   25.79   -0.13   27.03    0.65   28.11    0.04   27.15    0.41
+1977   3   26.13   -0.24   27.51    0.38   28.28    0.10   27.57    0.34
+1977   4   25.29   -0.28   27.02   -0.41   28.50    0.10   27.61   -0.05
+1977   5   23.88   -0.54   27.04   -0.06   28.78    0.09   27.97    0.19
+1977   6   22.70   -0.37   26.56    0.09   28.97    0.30   27.96    0.43
+1977   7   21.63   -0.34   25.70    0.05   29.13    0.52   27.56    0.45
+1977   8   20.25   -0.76   24.81   -0.25   28.87    0.38   26.93    0.18
+1977   9   19.82   -0.95   24.97    0.04   28.98    0.47   27.21    0.50
+1977  10   20.61   -0.46   25.34    0.39   28.96    0.45   27.37    0.73
+1977  11   21.29   -0.45   25.41    0.35   29.10    0.65   27.28    0.67
+1977  12   22.47   -0.44   25.54    0.33   29.11    0.76   27.37    0.80
+1978   1   24.32   -0.22   25.92    0.27   28.80    0.65   27.32    0.77
+1978   2   25.77   -0.15   26.46    0.09   28.48    0.41   27.17    0.43
+1978   3   25.39   -0.98   26.83   -0.30   28.26    0.09   27.24    0.01
+1978   4   24.73   -0.84   26.66   -0.77   28.28   -0.11   27.26   -0.41
+1978   5   23.15   -1.27   26.13   -0.97   28.72    0.03   27.36   -0.42
+1978   6   21.89   -1.18   25.68   -0.79   28.56   -0.11   27.16   -0.37
+1978   7   21.01   -0.96   25.08   -0.57   28.26   -0.35   26.81   -0.29
+1978   8   19.66   -1.35   24.35   -0.71   28.25   -0.24   26.23   -0.52
+1978   9   19.98   -0.79   24.33   -0.61   28.43   -0.08   26.20   -0.50
+1978  10   20.22   -0.86   24.72   -0.22   28.35   -0.16   26.40   -0.24
+1978  11   21.62   -0.12   24.94   -0.11   28.37   -0.09   26.43   -0.17
+1978  12   22.94    0.03   25.34    0.13   28.27   -0.08   26.48   -0.09
+1979   1   24.71    0.17   25.43   -0.23   28.40    0.25   26.45   -0.11
+1979   2   25.60   -0.32   26.19   -0.19   28.22    0.14   26.60   -0.13
+1979   3   25.93   -0.44   27.25    0.12   28.26    0.09   27.48    0.25
+1979   4   25.58    0.01   27.66    0.23   28.35   -0.05   27.87    0.20
+1979   5   24.52    0.10   27.26    0.16   28.70    0.01   27.74   -0.03
+1979   6   23.28    0.22   26.54    0.08   28.74    0.07   27.55    0.02
+1979   7   21.79   -0.19   25.56   -0.09   28.66    0.05   26.95   -0.15
+1979   8   21.05    0.04   25.29    0.23   28.36   -0.13   26.77    0.02
+1979   9   21.15    0.39   25.58    0.65   28.67    0.16   27.15    0.45
+1979  10   21.43    0.36   25.54    0.60   28.81    0.31   27.01    0.36
+1979  11   21.95    0.21   25.58    0.53   28.87    0.42   27.08    0.48
+1979  12   22.97    0.07   25.68    0.47   28.79    0.45   27.09    0.52
+1980   1   24.35   -0.18   26.12    0.47   28.62    0.47   27.10    0.54
+1980   2   25.73   -0.18   26.52    0.15   28.47    0.39   27.03    0.29
+1980   3   26.46    0.08   27.05   -0.07   28.51    0.34   27.38    0.15
+1980   4   25.71    0.14   27.33   -0.10   28.70    0.30   27.78    0.12
+1980   5   24.46    0.04   27.15    0.05   29.08    0.39   27.99    0.21
+1980   6   22.88   -0.19   26.76    0.29   29.15    0.48   27.99    0.46
+1980   7   21.26   -0.71   25.65    0.00   28.95    0.34   27.35    0.24
+1980   8   20.57   -0.44   24.87   -0.19   28.47   -0.02   26.62   -0.13
+1980   9   20.45   -0.32   24.86   -0.08   28.50   -0.01   26.57   -0.13
+1980  10   20.43   -0.64   24.62   -0.32   28.66    0.15   26.51   -0.13
+1980  11   21.23   -0.51   25.07    0.02   28.58    0.13   26.63    0.03
+1980  12   22.34   -0.56   25.28    0.07   28.44    0.10   26.58    0.01
+1981   1   22.98   -1.56   25.05   -0.61   28.08   -0.08   26.17   -0.39
+1981   2   24.90   -1.01   25.63   -0.75   27.94   -0.14   26.13   -0.60
+1981   3   25.94   -0.43   26.74   -0.39   28.08   -0.09   26.75   -0.48
+1981   4   24.89   -0.68   27.10   -0.32   28.17   -0.22   27.32   -0.34
+1981   5   23.90   -0.52   26.74   -0.37   28.34   -0.35   27.41   -0.36
+1981   6   22.57   -0.50   26.26   -0.20   28.36   -0.31   27.35   -0.18
+1981   7   21.10   -0.87   25.26   -0.39   28.29   -0.32   26.66   -0.44
+1981   8   20.03   -0.98   24.43   -0.63   28.22   -0.28   26.25   -0.50
+1981   9   20.09   -0.68   24.74   -0.20   28.30   -0.22   26.54   -0.17
+1981  10   20.58   -0.49   24.92   -0.03   28.45   -0.06   26.52   -0.12
+1981  11   21.26   -0.48   24.83   -0.22   28.47    0.02   26.41   -0.19
+1981  12   22.60   -0.30   25.23    0.03   28.43    0.09   26.47   -0.10
+1982   1   24.36   -0.18   25.96    0.30   28.19    0.03   26.69    0.14
+1982   2   25.42   -0.49   26.55    0.17   28.04   -0.04   26.71   -0.02
+1982   3   25.40   -0.98   27.06   -0.07   28.37    0.19   27.36    0.13
+1982   4   24.96   -0.61   27.52    0.10   28.78    0.39   27.90    0.24
+1982   5   24.21   -0.21   27.66    0.56   29.21    0.52   28.42    0.65
+1982   6   23.35    0.29   27.31    0.84   29.20    0.53   28.32    0.79
+1982   7   22.50    0.52   26.33    0.68   28.83    0.22   27.65    0.54
+1982   8   21.89    0.88   26.21    1.15   28.81    0.32   27.64    0.89
+1982   9   22.04    1.27   26.82    1.88   28.98    0.47   28.21    1.50
+1982  10   22.88    1.81   27.31    2.37   29.37    0.86   28.68    2.04
+1982  11   24.57    2.83   27.68    2.63   29.18    0.73   28.72    2.11
+1982  12   25.89    2.98   28.23    3.02   29.13    0.79   28.94    2.37
+1983   1   27.25    2.71   28.60    2.95   28.96    0.81   28.93    2.37
+1983   2   28.23    2.32   28.63    2.26   28.80    0.73   28.75    2.01
+1983   3   28.85    2.48   28.91    1.78   28.81    0.64   28.76    1.53
+1983   4   28.82    3.25   29.06    1.63   28.81    0.42   28.74    1.07
+1983   5   28.37    3.95   28.98    1.87   29.21    0.51   28.82    1.05
+1983   6   27.43    4.36   28.19    1.72   28.98    0.31   28.27    0.74
+1983   7   25.73    3.75   26.66    1.01   28.64    0.03   27.18    0.07
+1983   8   23.88    2.87   25.78    0.72   28.35   -0.14   26.51   -0.24
+1983   9   22.26    1.49   25.02    0.09   28.05   -0.46   26.18   -0.52
+1983  10   22.22    1.15   24.48   -0.46   27.92   -0.59   25.75   -0.89
+1983  11   22.21    0.47   24.19   -0.86   27.73   -0.73   25.54   -1.06
+1983  12   23.19    0.29   24.58   -0.63   27.75   -0.59   25.82   -0.75
+1984   1   24.32   -0.21   25.30   -0.35   27.64   -0.51   26.14   -0.42
+1984   2   25.12   -0.79   26.43    0.05   27.60   -0.48   26.72   -0.02
+1984   3   25.75   -0.63   27.14    0.01   27.59   -0.58   27.05   -0.19
+1984   4   25.40   -0.17   27.24   -0.18   27.78   -0.61   27.30   -0.37
+1984   5   23.58   -0.84   26.38   -0.72   28.19   -0.51   27.31   -0.47
+1984   6   22.30   -0.77   25.50   -0.97   28.38   -0.29   26.95   -0.58
+1984   7   21.53   -0.44   25.04   -0.60   28.47   -0.14   26.84   -0.26
+1984   8   20.64   -0.37   24.81   -0.25   28.30   -0.19   26.67   -0.08
+1984   9   20.73   -0.04   24.63   -0.30   28.26   -0.25   26.43   -0.27
+1984  10   20.62   -0.45   24.34   -0.61   28.19   -0.32   26.15   -0.49
+1984  11   21.70   -0.04   24.23   -0.83   27.92   -0.53   25.60   -1.00
+1984  12   22.47   -0.44   24.10   -1.11   27.60   -0.74   25.38   -1.19
+1985   1   23.84   -0.70   24.68   -0.97   27.55   -0.60   25.58   -0.98
+1985   2   24.83   -1.08   25.65   -0.72   27.68   -0.39   26.11   -0.63
+1985   3   25.60   -0.77   26.45   -0.68   27.59   -0.58   26.53   -0.71
+1985   4   24.28   -1.29   26.63   -0.79   27.78   -0.61   26.93   -0.74
+1985   5   22.67   -1.75   26.26   -0.84   27.99   -0.70   27.09   -0.68
+1985   6   21.84   -1.23   25.66   -0.81   28.09   -0.58   26.92   -0.61
+1985   7   20.75   -1.23   24.72   -0.93   28.32   -0.30   26.64   -0.46
+1985   8   19.90   -1.11   24.12   -0.94   28.34   -0.16   26.28   -0.47
+1985   9   19.86   -0.91   24.05   -0.88   28.32   -0.20   26.08   -0.62
+1985  10   20.26   -0.81   24.23   -0.71   28.40   -0.11   26.22   -0.42
+1985  11   20.97   -0.77   24.40   -0.65   28.48    0.03   26.39   -0.22
+1985  12   22.49   -0.41   24.56   -0.65   28.39    0.05   26.19   -0.38
+1986   1   24.31   -0.23   24.99   -0.67   27.96   -0.19   26.04   -0.52
+1986   2   25.90   -0.02   26.04   -0.33   27.95   -0.13   26.26   -0.48
+1986   3   25.78   -0.59   26.92   -0.21   28.11   -0.06   26.99   -0.24
+1986   4   24.86   -0.71   27.30   -0.13   28.23   -0.17   27.65   -0.02
+1986   5   23.35   -1.07   26.78   -0.32   28.53   -0.17   27.58   -0.20
+1986   6   22.03   -1.04   26.27   -0.20   28.76    0.09   27.56    0.03
+1986   7   21.64   -0.33   25.82    0.18   28.75    0.14   27.39    0.28
+1986   8   21.07    0.06   25.38    0.33   28.95    0.46   27.21    0.46
+1986   9   21.13    0.36   25.38    0.44   29.20    0.69   27.35    0.65
+1986  10   21.46    0.39   25.65    0.70   29.27    0.76   27.60    0.95
+1986  11   22.17    0.43   25.94    0.88   29.33    0.88   27.67    1.07
+1986  12   23.53    0.63   26.26    1.05   28.97    0.63   27.75    1.18
+1987   1   25.60    1.07   26.74    1.09   28.81    0.65   27.82    1.27
+1987   2   27.02    1.10   27.60    1.23   28.82    0.74   28.02    1.29
+1987   3   27.89    1.51   28.38    1.26   28.95    0.77   28.49    1.26
+1987   4   26.95    1.38   28.63    1.20   28.97    0.58   28.68    1.02
+1987   5   25.96    1.53   28.30    1.19   29.24    0.55   28.70    0.93
+1987   6   24.04    0.97   27.51    1.04   29.44    0.77   28.67    1.14
+1987   7   23.00    1.03   26.94    1.30   29.37    0.76   28.52    1.42
+1987   8   21.92    0.91   26.59    1.53   29.40    0.91   28.48    1.73
+1987   9   22.00    1.23   26.62    1.68   29.47    0.96   28.42    1.71
+1987  10   22.54    1.47   26.19    1.25   29.67    1.17   28.08    1.43
+1987  11   22.84    1.10   26.21    1.16   29.53    1.08   27.94    1.34
+1987  12   23.51    0.60   26.33    1.12   29.25    0.90   27.60    1.03
+1988   1   24.76    0.22   26.47    0.82   28.97    0.81   27.49    0.94
+1988   2   25.74   -0.18   26.43    0.05   28.54    0.46   27.01    0.28
+1988   3   25.71   -0.66   27.10   -0.03   28.46    0.29   27.45    0.22
+1988   4   24.68   -0.89   27.01   -0.41   28.41    0.02   27.56   -0.10
+1988   5   23.18   -1.24   25.88   -1.22   28.26   -0.43   26.97   -0.80
+1988   6   21.66   -1.41   24.61   -1.86   28.00   -0.67   26.21   -1.32
+1988   7   20.59   -1.38   23.79   -1.85   27.95   -0.67   25.66   -1.45
+1988   8   19.63   -1.38   23.71   -1.35   28.07   -0.43   25.71   -1.04
+1988   9   19.44   -1.32   23.88   -1.06   27.90   -0.61   25.72   -0.99
+1988  10   19.83   -1.24   23.41   -1.53   27.12   -1.39   24.82   -1.82
+1988  11   20.96   -0.78   23.45   -1.61   27.06   -1.39   24.73   -1.87
+1988  12   22.25   -0.66   23.50   -1.71   26.85   -1.49   24.68   -1.89
+1989   1   24.36   -0.18   24.27   -1.38   26.63   -1.52   24.70   -1.86
+1989   2   26.02    0.10   25.49   -0.89   26.75   -1.33   25.34   -1.40
+1989   3   26.21   -0.17   26.23   -0.90   27.25   -0.93   26.12   -1.12
+1989   4   25.54   -0.03   26.85   -0.57   27.71   -0.68   26.83   -0.83
+1989   5   23.36   -1.06   26.58   -0.53   28.24   -0.46   27.18   -0.60
+1989   6   22.14   -0.93   26.42   -0.05   28.12   -0.55   27.23   -0.30
+1989   7   21.27   -0.70   25.32   -0.32   28.23   -0.38   26.80   -0.31
+1989   8   20.86   -0.15   24.73   -0.33   28.10   -0.39   26.43   -0.32
+1989   9   20.17   -0.60   24.67   -0.27   28.37   -0.14   26.46   -0.24
+1989  10   20.52   -0.55   24.61   -0.34   28.27   -0.24   26.31   -0.34
+1989  11   21.44   -0.30   24.56   -0.49   28.10   -0.36   26.29   -0.31
+1989  12   22.61   -0.30   24.92   -0.29   28.51    0.17   26.58    0.01
+1990   1   24.22   -0.32   25.45   -0.20   28.49    0.33   26.63    0.07
+1990   2   26.17    0.26   26.54    0.16   28.58    0.50   27.03    0.29
+1990   3   26.15   -0.22   27.01   -0.12   28.69    0.51   27.39    0.16
+1990   4   25.15   -0.42   27.56    0.14   28.83    0.44   27.94    0.27
+1990   5   24.14   -0.29   27.42    0.32   28.93    0.23   28.08    0.30
+1990   6   22.76   -0.31   26.55    0.08   28.97    0.30   27.63    0.10
+1990   7   21.36   -0.61   25.82    0.18   29.01    0.40   27.42    0.31
+1990   8   20.70   -0.31   25.32    0.26   28.99    0.49   27.16    0.41
+1990   9   20.28   -0.49   25.15    0.21   28.92    0.41   26.96    0.25
+1990  10   20.40   -0.67   24.96    0.02   29.10    0.59   27.01    0.37
+1990  11   21.19   -0.55   25.00   -0.06   29.13    0.68   26.88    0.28
+1990  12   22.29   -0.61   25.23    0.02   29.16    0.81   26.96    0.39
+1991   1   23.99   -0.55   25.84    0.19   28.96    0.81   27.07    0.51
+1991   2   25.59   -0.33   26.50    0.12   28.71    0.63   27.12    0.38
+1991   3   26.31   -0.06   27.12   -0.01   28.58    0.40   27.38    0.15
+1991   4   25.15   -0.42   27.65    0.22   28.94    0.55   28.10    0.44
+1991   5   24.44    0.02   27.64    0.54   29.37    0.68   28.36    0.58
+1991   6   23.28    0.21   27.43    0.96   29.28    0.61   28.41    0.88
+1991   7   22.39    0.42   26.75    1.10   29.27    0.66   28.17    1.07
+1991   8   21.39    0.38   25.71    0.65   29.23    0.74   27.73    0.98
+1991   9   21.22    0.45   25.32    0.39   29.24    0.73   27.42    0.71
+1991  10   21.73    0.66   25.63    0.69   29.44    0.93   27.62    0.98
+1991  11   22.40    0.66   26.10    1.04   29.40    0.95   27.93    1.33
+1991  12   23.75    0.85   26.42    1.21   29.46    1.12   28.32    1.75
+1992   1   25.02    0.48   27.03    1.38   29.03    0.87   28.36    1.81
+1992   2   26.62    0.71   27.61    1.23   29.00    0.92   28.43    1.69
+1992   3   27.72    1.34   28.22    1.09   29.03    0.86   28.66    1.42
+1992   4   27.58    2.01   28.79    1.37   29.16    0.77   29.05    1.39
+1992   5   26.44    2.02   28.49    1.38   29.39    0.70   29.01    1.24
+1992   6   23.86    0.79   27.28    0.82   29.28    0.60   28.35    0.82
+1992   7   21.84   -0.14   25.84    0.19   29.15    0.54   27.56    0.45
+1992   8   20.87   -0.14   25.11    0.06   28.92    0.43   26.96    0.21
+1992   9   20.85    0.08   24.90   -0.03   28.83    0.32   26.66   -0.04
+1992  10   21.15    0.08   24.65   -0.29   28.69    0.18   26.39   -0.25
+1992  11   21.84    0.10   24.77   -0.29   28.67    0.21   26.60    0.00
+1992  12   22.79   -0.12   24.97   -0.24   28.82    0.47   26.72    0.15
+1993   1   24.68    0.15   25.79    0.14   28.71    0.56   26.87    0.31
+1993   2   26.46    0.55   26.94    0.57   28.37    0.29   27.20    0.46
+1993   3   27.07    0.69   27.64    0.51   28.50    0.32   27.71    0.48
+1993   4   26.84    1.28   28.43    1.00   28.78    0.38   28.50    0.83
+1993   5   25.60    1.18   28.33    1.23   29.03    0.34   28.70    0.93
+1993   6   24.11    1.04   27.03    0.56   29.03    0.36   28.08    0.55
+1993   7   22.61    0.64   26.19    0.54   29.01    0.40   27.59    0.49
+1993   8   21.65    0.64   25.52    0.46   28.86    0.37   27.01    0.26
+1993   9   21.11    0.34   25.25    0.31   29.02    0.51   27.14    0.43
+1993  10   21.71    0.64   25.28    0.33   28.84    0.33   27.01    0.36
+1993  11   22.07    0.33   25.20    0.14   28.88    0.43   26.92    0.32
+1993  12   22.86   -0.05   25.30    0.09   28.85    0.50   26.79    0.22
+1994   1   24.56    0.02   25.84    0.18   28.54    0.39   26.74    0.19
+1994   2   25.89   -0.03   26.40    0.02   28.27    0.20   26.97    0.23
+1994   3   25.75   -0.62   26.88   -0.24   28.46    0.28   27.52    0.29
+1994   4   24.49   -1.08   27.15   -0.28   28.82    0.43   28.13    0.46
+1994   5   23.52   -0.90   27.17    0.06   29.20    0.51   28.27    0.50
+1994   6   22.31   -0.76   26.63    0.17   29.27    0.60   28.09    0.56
+1994   7   21.17   -0.80   25.61   -0.04   29.49    0.88   27.68    0.57
+1994   8   20.22   -0.79   24.93   -0.13   29.51    1.02   27.40    0.65
+1994   9   20.65   -0.12   24.97    0.03   29.38    0.87   27.25    0.54
+1994  10   22.04    0.97   25.65    0.70   29.51    1.00   27.53    0.89
+1994  11   22.27    0.53   26.17    1.12   29.60    1.15   27.95    1.35
+1994  12   23.75    0.85   26.23    1.02   29.56    1.22   28.02    1.45
+1995   1   25.48    0.94   26.51    0.86   29.24    1.09   27.74    1.18
+1995   2   26.25    0.33   26.90    0.52   29.16    1.09   27.67    0.94
+1995   3   26.09   -0.28   27.26    0.13   29.23    1.05   27.91    0.68
+1995   4   24.32   -1.25   27.20   -0.23   29.26    0.87   28.17    0.50
+1995   5   23.37   -1.05   26.55   -0.55   29.36    0.67   27.87    0.10
+1995   6   22.43   -0.64   26.30   -0.17   29.21    0.54   27.80    0.27
+1995   7   21.42   -0.55   25.65    0.00   29.03    0.42   27.24    0.14
+1995   8   20.46   -0.55   24.36   -0.70   28.81    0.32   26.42   -0.33
+1995   9   20.50   -0.27   24.05   -0.89   28.59    0.08   26.20   -0.50
+1995  10   20.62   -0.45   24.16   -0.78   28.52    0.01   26.08   -0.57
+1995  11   21.49   -0.25   24.22   -0.84   28.32   -0.13   25.82   -0.78
+1995  12   22.03   -0.87   24.45   -0.76   28.13   -0.22   25.86   -0.71
+1996   1   23.81   -0.73   25.06   -0.59   27.89   -0.27   25.83   -0.73
+1996   2   25.52   -0.40   25.84   -0.54   27.61   -0.46   25.98   -0.76
+1996   3   26.28   -0.09   26.75   -0.38   27.91   -0.27   26.73   -0.50
+1996   4   24.00   -1.57   26.83   -0.59   28.25   -0.15   27.42   -0.25
+1996   5   23.11   -1.31   26.63   -0.47   28.62   -0.07   27.65   -0.12
+1996   6   21.66   -1.41   26.10   -0.37   28.71    0.04   27.49   -0.04
+1996   7   20.72   -1.26   25.29   -0.36   28.65    0.04   27.02   -0.09
+1996   8   20.23   -0.78   24.78   -0.28   28.62    0.12   26.75    0.00
+1996   9   20.43   -0.34   24.53   -0.41   28.57    0.05   26.44   -0.27
+1996  10   20.52   -0.55   24.52   -0.42   28.62    0.11   26.49   -0.15
+1996  11   20.77   -0.97   24.56   -0.49   28.62    0.17   26.43   -0.17
+1996  12   21.68   -1.22   24.31   -0.90   28.52    0.18   26.13   -0.44
+1997   1   23.70   -0.83   24.80   -0.85   28.42    0.26   26.09   -0.47
+1997   2   26.08    0.16   25.78   -0.60   28.53    0.45   26.46   -0.28
+1997   3   27.17    0.80   26.97   -0.16   28.73    0.56   27.13   -0.10
+1997   4   26.74    1.17   27.50    0.07   29.33    0.94   27.97    0.31
+1997   5   26.77    2.35   28.03    0.92   29.51    0.82   28.63    0.85
+1997   6   26.15    3.08   28.23    1.76   29.37    0.70   28.86    1.33
+1997   7   25.59    3.61   27.99    2.34   29.41    0.80   28.86    1.76
+1997   8   24.95    3.94   27.75    2.69   29.31    0.82   28.69    1.94
+1997   9   24.69    3.92   27.82    2.88   29.54    1.03   28.89    2.19
+1997  10   24.64    3.57   28.09    3.15   29.51    1.00   29.14    2.50
+1997  11   25.85    4.11   28.40    3.35   29.45    1.00   29.13    2.52
+1997  12   27.08    4.18   28.53    3.32   29.27    0.93   29.04    2.48
+1998   1   28.12    3.58   28.71    3.06   29.06    0.91   28.98    2.43
+1998   2   28.82    2.90   28.86    2.48   28.90    0.82   28.71    1.97
+1998   3   29.24    2.87   29.10    1.97   28.83    0.66   28.66    1.43
+1998   4   28.45    2.88   29.16    1.74   28.77    0.38   28.64    0.98
+1998   5   27.36    2.94   28.53    1.42   28.87    0.18   28.47    0.70
+1998   6   25.19    2.12   27.04    0.57   28.46   -0.21   27.41   -0.12
+1998   7   23.61    1.64   25.60   -0.05   28.30   -0.31   26.52   -0.59
+1998   8   22.27    1.26   24.78   -0.28   27.99   -0.50   25.91   -0.84
+1998   9   21.31    0.54   24.19   -0.75   27.83   -0.68   25.66   -1.05
+1998  10   21.37    0.30   24.08   -0.86   27.51   -1.00   25.46   -1.19
+1998  11   21.60   -0.14   24.40   -0.66   27.41   -1.04   25.48   -1.12
+1998  12   22.81   -0.10   24.25   -0.96   27.19   -1.16   25.12   -1.45
+1999   1   24.23   -0.31   24.41   -1.24   26.89   -1.26   24.96   -1.59
+1999   2   25.73   -0.19   25.56   -0.82   26.90   -1.18   25.58   -1.16
+1999   3   26.47    0.10   26.81   -0.32   27.14   -1.04   26.43   -0.80
+1999   4   24.53   -1.04   26.90   -0.52   27.66   -0.73   26.92   -0.75
+1999   5   23.64   -0.78   26.55   -0.56   28.14   -0.55   26.99   -0.78
+1999   6   22.09   -0.98   25.89   -0.58   28.05   -0.62   26.66   -0.87
+1999   7   21.36   -0.61   25.03   -0.62   27.89   -0.72   26.28   -0.83
+1999   8   20.67   -0.34   24.36   -0.70   27.77   -0.73   25.82   -0.93
+1999   9   20.08   -0.69   23.91   -1.03   27.96   -0.56   25.77   -0.94
+1999  10   20.46   -0.61   23.77   -1.18   27.93   -0.58   25.62   -1.03
+1999  11   20.62   -1.12   23.72   -1.34   27.54   -0.91   25.20   -1.40
+1999  12   22.42   -0.48   23.76   -1.45   27.30   -1.05   24.97   -1.60
+2000   1   24.01   -0.53   24.12   -1.53   27.17   -0.99   24.88   -1.68
+2000   2   25.38   -0.54   25.35   -1.03   26.88   -1.20   25.23   -1.50
+2000   3   25.67   -0.70   26.78   -0.35   26.95   -1.22   26.27   -0.96
+2000   4   25.53   -0.04   27.46    0.04   27.40   -0.99   26.99   -0.68
+2000   5   24.27   -0.15   26.85   -0.26   27.90   -0.79   27.10   -0.67
+2000   6   22.93   -0.13   26.01   -0.46   28.25   -0.42   26.97   -0.56
+2000   7   21.47   -0.50   25.24   -0.41   28.41   -0.20   26.69   -0.41
+2000   8   20.07   -0.94   24.74   -0.31   28.28   -0.21   26.46   -0.29
+2000   9   20.64   -0.13   24.73   -0.21   28.37   -0.14   26.32   -0.39
+2000  10   20.90   -0.17   24.60   -0.34   28.27   -0.24   26.11   -0.53
+2000  11   20.67   -1.07   24.43   -0.62   28.06   -0.39   26.01   -0.59
+2000  12   22.08   -0.83   24.73   -0.48   27.66   -0.68   25.83   -0.74
+2001   1   24.24   -0.29   25.37   -0.29   27.49   -0.66   25.93   -0.63
+2001   2   26.11    0.20   26.38    0.01   27.38   -0.70   26.24   -0.49
+2001   3   26.89    0.52   27.31    0.18   27.68   -0.50   26.89   -0.35
+2001   4   25.99    0.42   27.52    0.09   28.16   -0.23   27.38   -0.28
+2001   5   23.98   -0.44   27.21    0.11   28.65   -0.04   27.70   -0.08
+2001   6   22.71   -0.36   26.44   -0.03   28.91    0.24   27.60    0.07
+2001   7   21.48   -0.50   25.63   -0.02   29.12    0.51   27.37    0.26
+2001   8   20.24   -0.77   25.03   -0.03   28.98    0.48   26.95    0.20
+2001   9   19.73   -1.04   24.49   -0.45   29.11    0.60   26.74    0.04
+2001  10   20.14   -0.93   24.59   -0.36   29.08    0.58   26.66    0.02
+2001  11   20.68   -1.06   24.53   -0.53   28.93    0.48   26.47   -0.13
+2001  12   21.73   -1.17   24.79   -0.42   28.77    0.42   26.32   -0.25
+2002   1   24.09   -0.45   25.23   -0.42   28.84    0.69   26.49   -0.07
+2002   2   26.23    0.31   26.22   -0.15   28.70    0.63   26.83    0.09
+2002   3   27.39    1.01   27.51    0.38   28.62    0.44   27.48    0.25
+2002   4   26.44    0.87   27.71    0.28   29.14    0.75   28.00    0.34
+2002   5   25.29    0.87   27.68    0.58   29.61    0.92   28.44    0.66
+2002   6   23.28    0.21   27.30    0.83   29.58    0.91   28.48    0.95
+2002   7   21.64   -0.34   26.31    0.67   29.53    0.92   28.03    0.93
+2002   8   21.32    0.31   25.62    0.56   29.41    0.92   27.67    0.92
+2002   9   21.42    0.65   25.69    0.75   29.41    0.90   27.75    1.05
+2002  10   21.85    0.78   25.94    1.00   29.52    1.01   27.95    1.31
+2002  11   22.85    1.11   26.43    1.37   29.66    1.21   28.14    1.54
+2002  12   24.05    1.15   26.62    1.41   29.57    1.23   28.08    1.52
+2003   1   25.01    0.47   26.68    1.02   29.09    0.94   27.68    1.12
+2003   2   26.27    0.35   27.01    0.63   28.94    0.86   27.63    0.89
+2003   3   26.91    0.53   27.48    0.35   28.95    0.78   27.84    0.61
+2003   4   25.41   -0.15   27.22   -0.20   28.94    0.55   27.75    0.08
+2003   5   23.24   -1.18   26.44   -0.66   29.01    0.32   27.42   -0.36
+2003   6   22.15   -0.91   26.20   -0.27   29.17    0.50   27.56    0.03
+2003   7   21.50   -0.48   26.16    0.52   29.19    0.58   27.66    0.55
+2003   8   21.25    0.24   25.65    0.59   29.09    0.59   27.32    0.57
+2003   9   20.75   -0.02   25.20    0.26   29.05    0.54   27.10    0.40
+2003  10   21.70    0.63   25.58    0.63   29.22    0.71   27.33    0.69
+2003  11   22.33    0.59   25.85    0.80   29.08    0.62   27.13    0.53
+2003  12   23.60    0.70   26.07    0.86   28.97    0.63   27.04    0.47
+2004   1   25.09    0.55   26.23    0.58   28.71    0.56   26.90    0.35
+2004   2   26.47    0.55   26.81    0.44   28.61    0.53   27.04    0.31
+2004   3   26.12   -0.26   27.47    0.34   28.53    0.36   27.38    0.15
+2004   4   25.27   -0.30   27.62    0.19   28.82    0.43   27.91    0.24
+2004   5   23.44   -0.98   26.96   -0.14   29.18    0.49   28.02    0.24
+2004   6   22.54   -0.53   26.55    0.08   29.24    0.57   27.93    0.40
+2004   7   21.26   -0.72   25.94    0.30   29.36    0.75   27.86    0.75
+2004   8   20.79   -0.22   25.47    0.41   29.47    0.98   27.67    0.92
+2004   9   20.83    0.06   25.42    0.48   29.54    1.02   27.58    0.88
+2004  10   21.56    0.49   25.64    0.70   29.53    1.03   27.53    0.89
+2004  11   22.88    1.14   25.84    0.79   29.49    1.04   27.37    0.77
+2004  12   23.39    0.49   25.95    0.74   29.41    1.07   27.38    0.81
+2005   1   24.61    0.07   26.10    0.45   29.23    1.08   27.32    0.76
+2005   2   25.09   -0.83   26.38    0.00   28.91    0.83   27.17    0.43
+2005   3   25.23   -1.14   27.12   -0.01   28.89    0.71   27.63    0.40
+2005   4   25.21   -0.36   27.62    0.20   29.03    0.64   28.02    0.36
+2005   5   24.31   -0.11   27.56    0.46   29.24    0.55   28.30    0.52
+2005   6   22.60   -0.47   26.86    0.39   29.20    0.53   27.99    0.46
+2005   7   21.61   -0.37   26.07    0.42   28.93    0.32   27.45    0.34
+2005   8   20.47   -0.54   25.44    0.38   28.78    0.29   27.11    0.36
+2005   9   20.00   -0.77   24.88   -0.05   28.85    0.34   26.79    0.09
+2005  10   19.89   -1.18   24.83   -0.12   28.85    0.34   26.70    0.06
+2005  11   20.61   -1.13   23.92   -1.14   28.65    0.19   26.13   -0.48
+2005  12   22.20   -0.70   24.01   -1.20   28.34    0.00   25.80   -0.77
+2006   1   24.76    0.22   24.66   -0.99   27.91   -0.25   25.68   -0.87
+2006   2   26.52    0.60   26.02   -0.35   27.58   -0.50   26.15   -0.59
+2006   3   26.22   -0.15   26.83   -0.30   27.82   -0.35   26.80   -0.43
+2006   4   24.29   -1.28   27.18   -0.24   28.36   -0.04   27.54   -0.13
+2006   5   23.84   -0.58   27.30    0.19   28.91    0.21   27.91    0.13
+2006   6   22.82   -0.24   26.73    0.27   29.15    0.48   27.82    0.29
+2006   7   22.20    0.22   25.93    0.28   29.14    0.53   27.36    0.25
+2006   8   21.89    0.88   25.68    0.62   29.20    0.71   27.25    0.50
+2006   9   21.93    1.16   25.77    0.83   29.30    0.79   27.32    0.61
+2006  10   22.46    1.39   26.00    1.06   29.43    0.92   27.47    0.83
+2006  11   22.61    0.87   26.39    1.33   29.55    1.09   27.81    1.21
+2006  12   24.15    1.24   26.63    1.42   29.45    1.11   27.86    1.29
+2007   1   25.82    1.28   26.68    1.03   28.98    0.82   27.36    0.81
+2007   2   26.81    0.90   26.56    0.18   28.69    0.61   26.98    0.24
+2007   3   26.41    0.04   26.77   -0.36   28.81    0.64   27.25    0.02
+2007   4   24.96   -0.61   26.93   -0.50   28.88    0.49   27.56   -0.10
+2007   5   23.05   -1.37   26.40   -0.70   28.90    0.21   27.54   -0.23
+2007   6   21.61   -1.46   26.11   -0.35   28.92    0.25   27.54    0.01
+2007   7   21.05   -0.93   25.14   -0.51   28.80    0.19   26.99   -0.12
+2007   8   19.95   -1.06   24.24   -0.82   28.57    0.08   26.41   -0.34
+2007   9   19.85   -0.91   23.84   -1.10   28.21   -0.31   25.86   -0.84
+2007  10   19.31   -1.76   23.85   -1.09   28.09   -0.42   25.73   -0.92
+2007  11   19.82   -1.92   23.76   -1.30   27.90   -0.56   25.47   -1.14
+2007  12   21.15   -1.76   23.91   -1.30   27.70   -0.64   25.40   -1.17
+2008   1   24.24   -0.30   24.42   -1.23   27.18   -0.98   25.06   -1.50
+2008   2   26.39    0.47   25.34   -1.04   26.79   -1.29   25.19   -1.55
+2008   3   26.91    0.53   26.54   -0.59   27.22   -0.95   26.16   -1.07
+2008   4   25.68    0.12   27.36   -0.07   27.53   -0.86   26.97   -0.70
+2008   5   24.43    0.00   27.15    0.05   27.93   -0.76   27.19   -0.58
+2008   6   23.19    0.12   26.49    0.02   28.10   -0.57   27.15   -0.38
+2008   7   23.02    1.05   26.01    0.36   28.18   -0.43   27.00   -0.11
+2008   8   22.14    1.13   25.56    0.51   28.27   -0.22   26.81    0.06
+2008   9   21.60    0.84   25.36    0.42   28.25   -0.27   26.70    0.00
+2008  10   21.39    0.32   25.48    0.53   28.23   -0.28   26.66    0.02
+2008  11   21.54   -0.20   25.25    0.20   28.16   -0.29   26.52   -0.08
+2008  12   22.73   -0.18   24.59   -0.62   27.83   -0.52   25.78   -0.79
+2009   1   24.39   -0.15   25.26   -0.39   27.47   -0.69   25.69   -0.87
+2009   2   25.53   -0.38   26.16   -0.22   27.34   -0.74   26.02   -0.71
+2009   3   25.48   -0.89   26.62   -0.51   27.85   -0.32   26.66   -0.57
+2009   4   25.84    0.27   27.38   -0.04   28.36   -0.03   27.53   -0.13
+2009   5   24.95    0.52   27.57    0.47   29.09    0.40   28.10    0.33
+2009   6   24.09    1.02   27.15    0.68   29.15    0.48   28.06    0.53
+2009   7   23.09    1.12   26.56    0.91   29.13    0.52   27.88    0.78
+2009   8   22.03    1.02   25.90    0.84   29.20    0.71   27.51    0.76
+2009   9   21.48    0.71   25.74    0.80   29.24    0.73   27.48    0.78
+2009  10   21.64    0.57   25.82    0.87   29.68    1.17   27.73    1.09
+2009  11   21.99    0.25   26.13    1.07   29.90    1.44   28.17    1.57
+2009  12   23.21    0.31   26.69    1.48   29.80    1.45   28.51    1.94
+2010   1   24.70    0.17   26.86    1.21   29.58    1.42   28.32    1.76
+2010   2   26.16    0.24   27.37    1.00   29.25    1.18   28.19    1.45
+2010   3   26.54    0.16   28.04    0.91   29.18    1.01   28.46    1.23
+2010   4   26.04    0.47   28.08    0.66   29.28    0.89   28.49    0.82
+2010   5   24.75    0.33   27.34    0.24   29.27    0.57   28.13    0.36
+2010   6   23.26    0.19   26.32   -0.15   28.76    0.09   27.35   -0.18
+2010   7   21.11   -0.87   24.95   -0.70   28.33   -0.28   26.44   -0.67
+2010   8   19.49   -1.52   24.21   -0.85   27.82   -0.68   25.70   -1.05
+2010   9   19.28   -1.49   23.83   -1.11   27.47   -1.05   25.36   -1.34
+2010  10   19.73   -1.34   23.67   -1.28   27.35   -1.16   25.25   -1.40
+2010  11   20.44   -1.30   23.68   -1.37   27.47   -0.99   25.20   -1.41
+2010  12   22.07   -0.83   24.00   -1.21   27.54   -0.81   25.29   -1.28

shared/package-files/33/334bd92019e33c11d5e2f1549cf0482daaa247f7204ae539d24141fafee5d600/test_numbers.py

@@ -0,0 +1,202 @@
+"""Tests on algebraic numbers. """
+
+from sympy.core.containers import Tuple
+from sympy.core.numbers import (AlgebraicNumber, I, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys.polytools import Poly
+from sympy.polys.numberfields.subfield import to_number_field
+from sympy.polys.polyclasses import DMP
+from sympy.polys.domains import QQ
+from sympy.polys.rootoftools import CRootOf
+from sympy.abc import x, y
+
+
+def test_AlgebraicNumber():
+    minpoly, root = x**2 - 2, sqrt(2)
+
+    a = AlgebraicNumber(root, gen=x)
+
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+    assert a.root == root
+    assert a.alias is None
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is False
+
+    assert a.coeffs() == [S.One, S.Zero]
+    assert a.native_coeffs() == [QQ(1), QQ(0)]
+
+    a = AlgebraicNumber(root, gen=x, alias='y')
+
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+    assert a.root == root
+    assert a.alias == Symbol('y')
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is True
+
+    a = AlgebraicNumber(root, gen=x, alias=Symbol('y'))
+
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+    assert a.root == root
+    assert a.alias == Symbol('y')
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is True
+
+    assert AlgebraicNumber(sqrt(2), []).rep == DMP([], QQ)
+    assert AlgebraicNumber(sqrt(2), ()).rep == DMP([], QQ)
+    assert AlgebraicNumber(sqrt(2), (0, 0)).rep == DMP([], QQ)
+
+    assert AlgebraicNumber(sqrt(2), [8]).rep == DMP([QQ(8)], QQ)
+    assert AlgebraicNumber(sqrt(2), [Rational(8, 3)]).rep == DMP([QQ(8, 3)], QQ)
+
+    assert AlgebraicNumber(sqrt(2), [7, 3]).rep == DMP([QQ(7), QQ(3)], QQ)
+    assert AlgebraicNumber(
+        sqrt(2), [Rational(7, 9), Rational(3, 2)]).rep == DMP([QQ(7, 9), QQ(3, 2)], QQ)
+
+    assert AlgebraicNumber(sqrt(2), [1, 2, 3]).rep == DMP([QQ(2), QQ(5)], QQ)
+
+    a = AlgebraicNumber(AlgebraicNumber(root, gen=x), [1, 2])
+
+    assert a.rep == DMP([QQ(1), QQ(2)], QQ)
+    assert a.root == root
+    assert a.alias is None
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is False
+
+    assert a.coeffs() == [S.One, S(2)]
+    assert a.native_coeffs() == [QQ(1), QQ(2)]
+
+    a = AlgebraicNumber((minpoly, root), [1, 2])
+
+    assert a.rep == DMP([QQ(1), QQ(2)], QQ)
+    assert a.root == root
+    assert a.alias is None
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is False
+
+    a = AlgebraicNumber((Poly(minpoly), root), [1, 2])
+
+    assert a.rep == DMP([QQ(1), QQ(2)], QQ)
+    assert a.root == root
+    assert a.alias is None
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is False
+
+    assert AlgebraicNumber( sqrt(3)).rep == DMP([ QQ(1), QQ(0)], QQ)
+    assert AlgebraicNumber(-sqrt(3)).rep == DMP([ QQ(1), QQ(0)], QQ)
+
+    a = AlgebraicNumber(sqrt(2))
+    b = AlgebraicNumber(sqrt(2))
+
+    assert a == b
+
+    c = AlgebraicNumber(sqrt(2), gen=x)
+
+    assert a == b
+    assert a == c
+
+    a = AlgebraicNumber(sqrt(2), [1, 2])
+    b = AlgebraicNumber(sqrt(2), [1, 3])
+
+    assert a != b and a != sqrt(2) + 3
+
+    assert (a == x) is False and (a != x) is True
+
+    a = AlgebraicNumber(sqrt(2), [1, 0])
+    b = AlgebraicNumber(sqrt(2), [1, 0], alias=y)
+
+    assert a.as_poly(x) == Poly(x, domain='QQ')
+    assert b.as_poly() == Poly(y, domain='QQ')
+
+    assert a.as_expr() == sqrt(2)
+    assert a.as_expr(x) == x
+    assert b.as_expr() == sqrt(2)
+    assert b.as_expr(x) == x
+
+    a = AlgebraicNumber(sqrt(2), [2, 3])
+    b = AlgebraicNumber(sqrt(2), [2, 3], alias=y)
+
+    p = a.as_poly()
+
+    assert p == Poly(2*p.gen + 3)
+
+    assert a.as_poly(x) == Poly(2*x + 3, domain='QQ')
+    assert b.as_poly() == Poly(2*y + 3, domain='QQ')
+
+    assert a.as_expr() == 2*sqrt(2) + 3
+    assert a.as_expr(x) == 2*x + 3
+    assert b.as_expr() == 2*sqrt(2) + 3
+    assert b.as_expr(x) == 2*x + 3
+
+    a = AlgebraicNumber(sqrt(2))
+    b = to_number_field(sqrt(2))
+    assert a.args == b.args == (sqrt(2), Tuple(1, 0))
+    b = AlgebraicNumber(sqrt(2), alias='alpha')
+    assert b.args == (sqrt(2), Tuple(1, 0), Symbol('alpha'))
+
+    a = AlgebraicNumber(sqrt(2), [1, 2, 3])
+    assert a.args == (sqrt(2), Tuple(1, 2, 3))
+
+    a = AlgebraicNumber(sqrt(2), [1, 2], "alpha")
+    b = AlgebraicNumber(a)
+    c = AlgebraicNumber(a, alias="gamma")
+    assert a == b
+    assert c.alias.name == "gamma"
+
+    a = AlgebraicNumber(sqrt(2) + sqrt(3), [S(1)/2, 0, S(-9)/2, 0])
+    b = AlgebraicNumber(a, [1, 0, 0])
+    assert b.root == a.root
+    assert a.to_root() == sqrt(2)
+    assert b.to_root() == 2
+
+    a = AlgebraicNumber(2)
+    assert a.is_primitive_element is True
+
+
+def test_to_algebraic_integer():
+    a = AlgebraicNumber(sqrt(3), gen=x).to_algebraic_integer()
+
+    assert a.minpoly == x**2 - 3
+    assert a.root == sqrt(3)
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+
+    a = AlgebraicNumber(2*sqrt(3), gen=x).to_algebraic_integer()
+    assert a.minpoly == x**2 - 12
+    assert a.root == 2*sqrt(3)
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+
+    a = AlgebraicNumber(sqrt(3)/2, gen=x).to_algebraic_integer()
+
+    assert a.minpoly == x**2 - 12
+    assert a.root == 2*sqrt(3)
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+
+    a = AlgebraicNumber(sqrt(3)/2, [Rational(7, 19), 3], gen=x).to_algebraic_integer()
+
+    assert a.minpoly == x**2 - 12
+    assert a.root == 2*sqrt(3)
+    assert a.rep == DMP([QQ(7, 19), QQ(3)], QQ)
+
+
+def test_AlgebraicNumber_to_root():
+    assert AlgebraicNumber(sqrt(2)).to_root() == sqrt(2)
+
+    zeta5_squared = AlgebraicNumber(CRootOf(x**5 - 1, 4), coeffs=[1, 0, 0])
+    assert zeta5_squared.to_root() == CRootOf(x**4 + x**3 + x**2 + x + 1, 1)
+
+    zeta3_squared = AlgebraicNumber(CRootOf(x**3 - 1, 2), coeffs=[1, 0, 0])
+    assert zeta3_squared.to_root() == -S(1)/2 - sqrt(3)*I/2
+    assert zeta3_squared.to_root(radicals=False) == CRootOf(x**2 + x + 1, 0)

shared/package-files/33/3352c161f9ce47e35e01d8cdd20fb76753cfd89e71cbc402c338099e1f13c26d/_neg_view_compositeexplicitautograd_dispatch.h

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

shared/package-files/33/3353358982c168f4c099f0d278b065bc3af648d7a61dc7708c70c56b2d3fa1a3/regression.py

@@ -0,0 +1,940 @@
+"""Plotting functions for linear models (broadly construed)."""
+import copy
+from textwrap import dedent
+import warnings
+import numpy as np
+import pandas as pd
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+
+try:
+    import statsmodels
+    assert statsmodels
+    _has_statsmodels = True
+except ImportError:
+    _has_statsmodels = False
+
+from . import utils
+from . import algorithms as algo
+from .axisgrid import FacetGrid, _facet_docs
+
+
+__all__ = ["lmplot", "regplot", "residplot"]
+
+
+class _LinearPlotter:
+    """Base class for plotting relational data in tidy format.
+
+    To get anything useful done you'll have to inherit from this, but setup
+    code that can be abstracted out should be put here.
+
+    """
+    def establish_variables(self, data, **kws):
+        """Extract variables from data or use directly."""
+        self.data = data
+
+        # Validate the inputs
+        any_strings = any([isinstance(v, str) for v in kws.values()])
+        if any_strings and data is None:
+            raise ValueError("Must pass `data` if using named variables.")
+
+        # Set the variables
+        for var, val in kws.items():
+            if isinstance(val, str):
+                vector = data[val]
+            elif isinstance(val, list):
+                vector = np.asarray(val)
+            else:
+                vector = val
+            if vector is not None and vector.shape != (1,):
+                vector = np.squeeze(vector)
+            if np.ndim(vector) > 1:
+                err = "regplot inputs must be 1d"
+                raise ValueError(err)
+            setattr(self, var, vector)
+
+    def dropna(self, *vars):
+        """Remove observations with missing data."""
+        vals = [getattr(self, var) for var in vars]
+        vals = [v for v in vals if v is not None]
+        not_na = np.all(np.column_stack([pd.notnull(v) for v in vals]), axis=1)
+        for var in vars:
+            val = getattr(self, var)
+            if val is not None:
+                setattr(self, var, val[not_na])
+
+    def plot(self, ax):
+        raise NotImplementedError
+
+
+class _RegressionPlotter(_LinearPlotter):
+    """Plotter for numeric independent variables with regression model.
+
+    This does the computations and drawing for the `regplot` function, and
+    is thus also used indirectly by `lmplot`.
+    """
+    def __init__(self, x, y, data=None, x_estimator=None, x_bins=None,
+                 x_ci="ci", scatter=True, fit_reg=True, ci=95, n_boot=1000,
+                 units=None, seed=None, order=1, logistic=False, lowess=False,
+                 robust=False, logx=False, x_partial=None, y_partial=None,
+                 truncate=False, dropna=True, x_jitter=None, y_jitter=None,
+                 color=None, label=None):
+
+        # Set member attributes
+        self.x_estimator = x_estimator
+        self.ci = ci
+        self.x_ci = ci if x_ci == "ci" else x_ci
+        self.n_boot = n_boot
+        self.seed = seed
+        self.scatter = scatter
+        self.fit_reg = fit_reg
+        self.order = order
+        self.logistic = logistic
+        self.lowess = lowess
+        self.robust = robust
+        self.logx = logx
+        self.truncate = truncate
+        self.x_jitter = x_jitter
+        self.y_jitter = y_jitter
+        self.color = color
+        self.label = label
+
+        # Validate the regression options:
+        if sum((order > 1, logistic, robust, lowess, logx)) > 1:
+            raise ValueError("Mutually exclusive regression options.")
+
+        # Extract the data vals from the arguments or passed dataframe
+        self.establish_variables(data, x=x, y=y, units=units,
+                                 x_partial=x_partial, y_partial=y_partial)
+
+        # Drop null observations
+        if dropna:
+            self.dropna("x", "y", "units", "x_partial", "y_partial")
+
+        # Regress nuisance variables out of the data
+        if self.x_partial is not None:
+            self.x = self.regress_out(self.x, self.x_partial)
+        if self.y_partial is not None:
+            self.y = self.regress_out(self.y, self.y_partial)
+
+        # Possibly bin the predictor variable, which implies a point estimate
+        if x_bins is not None:
+            self.x_estimator = np.mean if x_estimator is None else x_estimator
+            x_discrete, x_bins = self.bin_predictor(x_bins)
+            self.x_discrete = x_discrete
+        else:
+            self.x_discrete = self.x
+
+        # Disable regression in case of singleton inputs
+        if len(self.x) <= 1:
+            self.fit_reg = False
+
+        # Save the range of the x variable for the grid later
+        if self.fit_reg:
+            self.x_range = self.x.min(), self.x.max()
+
+    @property
+    def scatter_data(self):
+        """Data where each observation is a point."""
+        x_j = self.x_jitter
+        if x_j is None:
+            x = self.x
+        else:
+            x = self.x + np.random.uniform(-x_j, x_j, len(self.x))
+
+        y_j = self.y_jitter
+        if y_j is None:
+            y = self.y
+        else:
+            y = self.y + np.random.uniform(-y_j, y_j, len(self.y))
+
+        return x, y
+
+    @property
+    def estimate_data(self):
+        """Data with a point estimate and CI for each discrete x value."""
+        x, y = self.x_discrete, self.y
+        vals = sorted(np.unique(x))
+        points, cis = [], []
+
+        for val in vals:
+
+            # Get the point estimate of the y variable
+            _y = y[x == val]
+            est = self.x_estimator(_y)
+            points.append(est)
+
+            # Compute the confidence interval for this estimate
+            if self.x_ci is None:
+                cis.append(None)
+            else:
+                units = None
+                if self.x_ci == "sd":
+                    sd = np.std(_y)
+                    _ci = est - sd, est + sd
+                else:
+                    if self.units is not None:
+                        units = self.units[x == val]
+                    boots = algo.bootstrap(_y,
+                                           func=self.x_estimator,
+                                           n_boot=self.n_boot,
+                                           units=units,
+                                           seed=self.seed)
+                    _ci = utils.ci(boots, self.x_ci)
+                cis.append(_ci)
+
+        return vals, points, cis
+
+    def _check_statsmodels(self):
+        """Check whether statsmodels is installed if any boolean options require it."""
+        options = "logistic", "robust", "lowess"
+        err = "`{}=True` requires statsmodels, an optional dependency, to be installed."
+        for option in options:
+            if getattr(self, option) and not _has_statsmodels:
+                raise RuntimeError(err.format(option))
+
+    def fit_regression(self, ax=None, x_range=None, grid=None):
+        """Fit the regression model."""
+        self._check_statsmodels()
+
+        # Create the grid for the regression
+        if grid is None:
+            if self.truncate:
+                x_min, x_max = self.x_range
+            else:
+                if ax is None:
+                    x_min, x_max = x_range
+                else:
+                    x_min, x_max = ax.get_xlim()
+            grid = np.linspace(x_min, x_max, 100)
+        ci = self.ci
+
+        # Fit the regression
+        if self.order > 1:
+            yhat, yhat_boots = self.fit_poly(grid, self.order)
+        elif self.logistic:
+            from statsmodels.genmod.generalized_linear_model import GLM
+            from statsmodels.genmod.families import Binomial
+            yhat, yhat_boots = self.fit_statsmodels(grid, GLM,
+                                                    family=Binomial())
+        elif self.lowess:
+            ci = None
+            grid, yhat = self.fit_lowess()
+        elif self.robust:
+            from statsmodels.robust.robust_linear_model import RLM
+            yhat, yhat_boots = self.fit_statsmodels(grid, RLM)
+        elif self.logx:
+            yhat, yhat_boots = self.fit_logx(grid)
+        else:
+            yhat, yhat_boots = self.fit_fast(grid)
+
+        # Compute the confidence interval at each grid point
+        if ci is None:
+            err_bands = None
+        else:
+            err_bands = utils.ci(yhat_boots, ci, axis=0)
+
+        return grid, yhat, err_bands
+
+    def fit_fast(self, grid):
+        """Low-level regression and prediction using linear algebra."""
+        def reg_func(_x, _y):
+            return np.linalg.pinv(_x).dot(_y)
+
+        X, y = np.c_[np.ones(len(self.x)), self.x], self.y
+        grid = np.c_[np.ones(len(grid)), grid]
+        yhat = grid.dot(reg_func(X, y))
+        if self.ci is None:
+            return yhat, None
+
+        beta_boots = algo.bootstrap(X, y,
+                                    func=reg_func,
+                                    n_boot=self.n_boot,
+                                    units=self.units,
+                                    seed=self.seed).T
+        yhat_boots = grid.dot(beta_boots).T
+        return yhat, yhat_boots
+
+    def fit_poly(self, grid, order):
+        """Regression using numpy polyfit for higher-order trends."""
+        def reg_func(_x, _y):
+            return np.polyval(np.polyfit(_x, _y, order), grid)
+
+        x, y = self.x, self.y
+        yhat = reg_func(x, y)
+        if self.ci is None:
+            return yhat, None
+
+        yhat_boots = algo.bootstrap(x, y,
+                                    func=reg_func,
+                                    n_boot=self.n_boot,
+                                    units=self.units,
+                                    seed=self.seed)
+        return yhat, yhat_boots
+
+    def fit_statsmodels(self, grid, model, **kwargs):
+        """More general regression function using statsmodels objects."""
+        import statsmodels.tools.sm_exceptions as sme
+        X, y = np.c_[np.ones(len(self.x)), self.x], self.y
+        grid = np.c_[np.ones(len(grid)), grid]
+
+        def reg_func(_x, _y):
+            err_classes = (sme.PerfectSeparationError,)
+            try:
+                with warnings.catch_warnings():
+                    if hasattr(sme, "PerfectSeparationWarning"):
+                        # statsmodels>=0.14.0
+                        warnings.simplefilter("error", sme.PerfectSeparationWarning)
+                        err_classes = (*err_classes, sme.PerfectSeparationWarning)
+                    yhat = model(_y, _x, **kwargs).fit().predict(grid)
+            except err_classes:
+                yhat = np.empty(len(grid))
+                yhat.fill(np.nan)
+            return yhat
+
+        yhat = reg_func(X, y)
+        if self.ci is None:
+            return yhat, None
+
+        yhat_boots = algo.bootstrap(X, y,
+                                    func=reg_func,
+                                    n_boot=self.n_boot,
+                                    units=self.units,
+                                    seed=self.seed)
+        return yhat, yhat_boots
+
+    def fit_lowess(self):
+        """Fit a locally-weighted regression, which returns its own grid."""
+        from statsmodels.nonparametric.smoothers_lowess import lowess
+        grid, yhat = lowess(self.y, self.x).T
+        return grid, yhat
+
+    def fit_logx(self, grid):
+        """Fit the model in log-space."""
+        X, y = np.c_[np.ones(len(self.x)), self.x], self.y
+        grid = np.c_[np.ones(len(grid)), np.log(grid)]
+
+        def reg_func(_x, _y):
+            _x = np.c_[_x[:, 0], np.log(_x[:, 1])]
+            return np.linalg.pinv(_x).dot(_y)
+
+        yhat = grid.dot(reg_func(X, y))
+        if self.ci is None:
+            return yhat, None
+
+        beta_boots = algo.bootstrap(X, y,
+                                    func=reg_func,
+                                    n_boot=self.n_boot,
+                                    units=self.units,
+                                    seed=self.seed).T
+        yhat_boots = grid.dot(beta_boots).T
+        return yhat, yhat_boots
+
+    def bin_predictor(self, bins):
+        """Discretize a predictor by assigning value to closest bin."""
+        x = np.asarray(self.x)
+        if np.isscalar(bins):
+            percentiles = np.linspace(0, 100, bins + 2)[1:-1]
+            bins = np.percentile(x, percentiles)
+        else:
+            bins = np.ravel(bins)
+
+        dist = np.abs(np.subtract.outer(x, bins))
+        x_binned = bins[np.argmin(dist, axis=1)].ravel()
+
+        return x_binned, bins
+
+    def regress_out(self, a, b):
+        """Regress b from a keeping a's original mean."""
+        a_mean = a.mean()
+        a = a - a_mean
+        b = b - b.mean()
+        b = np.c_[b]
+        a_prime = a - b.dot(np.linalg.pinv(b).dot(a))
+        return np.asarray(a_prime + a_mean).reshape(a.shape)
+
+    def plot(self, ax, scatter_kws, line_kws):
+        """Draw the full plot."""
+        # Insert the plot label into the correct set of keyword arguments
+        if self.scatter:
+            scatter_kws["label"] = self.label
+        else:
+            line_kws["label"] = self.label
+
+        # Use the current color cycle state as a default
+        if self.color is None:
+            lines, = ax.plot([], [])
+            color = lines.get_color()
+            lines.remove()
+        else:
+            color = self.color
+
+        # Ensure that color is hex to avoid matplotlib weirdness
+        color = mpl.colors.rgb2hex(mpl.colors.colorConverter.to_rgb(color))
+
+        # Let color in keyword arguments override overall plot color
+        scatter_kws.setdefault("color", color)
+        line_kws.setdefault("color", color)
+
+        # Draw the constituent plots
+        if self.scatter:
+            self.scatterplot(ax, scatter_kws)
+
+        if self.fit_reg:
+            self.lineplot(ax, line_kws)
+
+        # Label the axes
+        if hasattr(self.x, "name"):
+            ax.set_xlabel(self.x.name)
+        if hasattr(self.y, "name"):
+            ax.set_ylabel(self.y.name)
+
+    def scatterplot(self, ax, kws):
+        """Draw the data."""
+        # Treat the line-based markers specially, explicitly setting larger
+        # linewidth than is provided by the seaborn style defaults.
+        # This would ideally be handled better in matplotlib (i.e., distinguish
+        # between edgewidth for solid glyphs and linewidth for line glyphs
+        # but this should do for now.
+        line_markers = ["1", "2", "3", "4", "+", "x", "|", "_"]
+        if self.x_estimator is None:
+            if "marker" in kws and kws["marker"] in line_markers:
+                lw = mpl.rcParams["lines.linewidth"]
+            else:
+                lw = mpl.rcParams["lines.markeredgewidth"]
+            kws.setdefault("linewidths", lw)
+
+            if not hasattr(kws['color'], 'shape') or kws['color'].shape[1] < 4:
+                kws.setdefault("alpha", .8)
+
+            x, y = self.scatter_data
+            ax.scatter(x, y, **kws)
+        else:
+            # TODO abstraction
+            ci_kws = {"color": kws["color"]}
+            if "alpha" in kws:
+                ci_kws["alpha"] = kws["alpha"]
+            ci_kws["linewidth"] = mpl.rcParams["lines.linewidth"] * 1.75
+            kws.setdefault("s", 50)
+
+            xs, ys, cis = self.estimate_data
+            if [ci for ci in cis if ci is not None]:
+                for x, ci in zip(xs, cis):
+                    ax.plot([x, x], ci, **ci_kws)
+            ax.scatter(xs, ys, **kws)
+
+    def lineplot(self, ax, kws):
+        """Draw the model."""
+        # Fit the regression model
+        grid, yhat, err_bands = self.fit_regression(ax)
+        edges = grid[0], grid[-1]
+
+        # Get set default aesthetics
+        fill_color = kws["color"]
+        lw = kws.pop("lw", mpl.rcParams["lines.linewidth"] * 1.5)
+        kws.setdefault("linewidth", lw)
+
+        # Draw the regression line and confidence interval
+        line, = ax.plot(grid, yhat, **kws)
+        if not self.truncate:
+            line.sticky_edges.x[:] = edges  # Prevent mpl from adding margin
+        if err_bands is not None:
+            ax.fill_between(grid, *err_bands, facecolor=fill_color, alpha=.15)
+
+
+_regression_docs = dict(
+
+    model_api=dedent("""\
+    There are a number of mutually exclusive options for estimating the
+    regression model. See the :ref:`tutorial <regression_tutorial>` for more
+    information.\
+    """),
+    regplot_vs_lmplot=dedent("""\
+    The :func:`regplot` and :func:`lmplot` functions are closely related, but
+    the former is an axes-level function while the latter is a figure-level
+    function that combines :func:`regplot` and :class:`FacetGrid`.\
+    """),
+    x_estimator=dedent("""\
+    x_estimator : callable that maps vector -> scalar, optional
+        Apply this function to each unique value of ``x`` and plot the
+        resulting estimate. This is useful when ``x`` is a discrete variable.
+        If ``x_ci`` is given, this estimate will be bootstrapped and a
+        confidence interval will be drawn.\
+    """),
+    x_bins=dedent("""\
+    x_bins : int or vector, optional
+        Bin the ``x`` variable into discrete bins and then estimate the central
+        tendency and a confidence interval. This binning only influences how
+        the scatterplot is drawn; the regression is still fit to the original
+        data.  This parameter is interpreted either as the number of
+        evenly-sized (not necessary spaced) bins or the positions of the bin
+        centers. When this parameter is used, it implies that the default of
+        ``x_estimator`` is ``numpy.mean``.\
+    """),
+    x_ci=dedent("""\
+    x_ci : "ci", "sd", int in [0, 100] or None, optional
+        Size of the confidence interval used when plotting a central tendency
+        for discrete values of ``x``. If ``"ci"``, defer to the value of the
+        ``ci`` parameter. If ``"sd"``, skip bootstrapping and show the
+        standard deviation of the observations in each bin.\
+    """),
+    scatter=dedent("""\
+    scatter : bool, optional
+        If ``True``, draw a scatterplot with the underlying observations (or
+        the ``x_estimator`` values).\
+    """),
+    fit_reg=dedent("""\
+    fit_reg : bool, optional
+        If ``True``, estimate and plot a regression model relating the ``x``
+        and ``y`` variables.\
+    """),
+    ci=dedent("""\
+    ci : int in [0, 100] or None, optional
+        Size of the confidence interval for the regression estimate. This will
+        be drawn using translucent bands around the regression line. The
+        confidence interval is estimated using a bootstrap; for large
+        datasets, it may be advisable to avoid that computation by setting
+        this parameter to None.\
+    """),
+    n_boot=dedent("""\
+    n_boot : int, optional
+        Number of bootstrap resamples used to estimate the ``ci``. The default
+        value attempts to balance time and stability; you may want to increase
+        this value for "final" versions of plots.\
+    """),
+    units=dedent("""\
+    units : variable name in ``data``, optional
+        If the ``x`` and ``y`` observations are nested within sampling units,
+        those can be specified here. This will be taken into account when
+        computing the confidence intervals by performing a multilevel bootstrap
+        that resamples both units and observations (within unit). This does not
+        otherwise influence how the regression is estimated or drawn.\
+    """),
+    seed=dedent("""\
+    seed : int, numpy.random.Generator, or numpy.random.RandomState, optional
+        Seed or random number generator for reproducible bootstrapping.\
+    """),
+    order=dedent("""\
+    order : int, optional
+        If ``order`` is greater than 1, use ``numpy.polyfit`` to estimate a
+        polynomial regression.\
+    """),
+    logistic=dedent("""\
+    logistic : bool, optional
+        If ``True``, assume that ``y`` is a binary variable and use
+        ``statsmodels`` to estimate a logistic regression model. Note that this
+        is substantially more computationally intensive than linear regression,
+        so you may wish to decrease the number of bootstrap resamples
+        (``n_boot``) or set ``ci`` to None.\
+    """),
+    lowess=dedent("""\
+    lowess : bool, optional
+        If ``True``, use ``statsmodels`` to estimate a nonparametric lowess
+        model (locally weighted linear regression). Note that confidence
+        intervals cannot currently be drawn for this kind of model.\
+    """),
+    robust=dedent("""\
+    robust : bool, optional
+        If ``True``, use ``statsmodels`` to estimate a robust regression. This
+        will de-weight outliers. Note that this is substantially more
+        computationally intensive than standard linear regression, so you may
+        wish to decrease the number of bootstrap resamples (``n_boot``) or set
+        ``ci`` to None.\
+    """),
+    logx=dedent("""\
+    logx : bool, optional
+        If ``True``, estimate a linear regression of the form y ~ log(x), but
+        plot the scatterplot and regression model in the input space. Note that
+        ``x`` must be positive for this to work.\
+    """),
+    xy_partial=dedent("""\
+    {x,y}_partial : strings in ``data`` or matrices
+        Confounding variables to regress out of the ``x`` or ``y`` variables
+        before plotting.\
+    """),
+    truncate=dedent("""\
+    truncate : bool, optional
+        If ``True``, the regression line is bounded by the data limits. If
+        ``False``, it extends to the ``x`` axis limits.
+    """),
+    xy_jitter=dedent("""\
+    {x,y}_jitter : floats, optional
+        Add uniform random noise of this size to either the ``x`` or ``y``
+        variables. The noise is added to a copy of the data after fitting the
+        regression, and only influences the look of the scatterplot. This can
+        be helpful when plotting variables that take discrete values.\
+    """),
+    scatter_line_kws=dedent("""\
+    {scatter,line}_kws : dictionaries
+        Additional keyword arguments to pass to ``plt.scatter`` and
+        ``plt.plot``.\
+    """),
+)
+_regression_docs.update(_facet_docs)
+
+
+def lmplot(
+    data, *,
+    x=None, y=None, hue=None, col=None, row=None,
+    palette=None, col_wrap=None, height=5, aspect=1, markers="o",
+    sharex=None, sharey=None, hue_order=None, col_order=None, row_order=None,
+    legend=True, legend_out=None, x_estimator=None, x_bins=None,
+    x_ci="ci", scatter=True, fit_reg=True, ci=95, n_boot=1000,
+    units=None, seed=None, order=1, logistic=False, lowess=False,
+    robust=False, logx=False, x_partial=None, y_partial=None,
+    truncate=True, x_jitter=None, y_jitter=None, scatter_kws=None,
+    line_kws=None, facet_kws=None,
+):
+
+    if facet_kws is None:
+        facet_kws = {}
+
+    def facet_kw_deprecation(key, val):
+        msg = (
+            f"{key} is deprecated from the `lmplot` function signature. "
+            "Please update your code to pass it using `facet_kws`."
+        )
+        if val is not None:
+            warnings.warn(msg, UserWarning)
+            facet_kws[key] = val
+
+    facet_kw_deprecation("sharex", sharex)
+    facet_kw_deprecation("sharey", sharey)
+    facet_kw_deprecation("legend_out", legend_out)
+
+    if data is None:
+        raise TypeError("Missing required keyword argument `data`.")
+
+    # Reduce the dataframe to only needed columns
+    need_cols = [x, y, hue, col, row, units, x_partial, y_partial]
+    cols = np.unique([a for a in need_cols if a is not None]).tolist()
+    data = data[cols]
+
+    # Initialize the grid
+    facets = FacetGrid(
+        data, row=row, col=col, hue=hue,
+        palette=palette,
+        row_order=row_order, col_order=col_order, hue_order=hue_order,
+        height=height, aspect=aspect, col_wrap=col_wrap,
+        **facet_kws,
+    )
+
+    # Add the markers here as FacetGrid has figured out how many levels of the
+    # hue variable are needed and we don't want to duplicate that process
+    if facets.hue_names is None:
+        n_markers = 1
+    else:
+        n_markers = len(facets.hue_names)
+    if not isinstance(markers, list):
+        markers = [markers] * n_markers
+    if len(markers) != n_markers:
+        raise ValueError("markers must be a singleton or a list of markers "
+                         "for each level of the hue variable")
+    facets.hue_kws = {"marker": markers}
+
+    def update_datalim(data, x, y, ax, **kws):
+        xys = data[[x, y]].to_numpy().astype(float)
+        ax.update_datalim(xys, updatey=False)
+        ax.autoscale_view(scaley=False)
+
+    facets.map_dataframe(update_datalim, x=x, y=y)
+
+    # Draw the regression plot on each facet
+    regplot_kws = dict(
+        x_estimator=x_estimator, x_bins=x_bins, x_ci=x_ci,
+        scatter=scatter, fit_reg=fit_reg, ci=ci, n_boot=n_boot, units=units,
+        seed=seed, order=order, logistic=logistic, lowess=lowess,
+        robust=robust, logx=logx, x_partial=x_partial, y_partial=y_partial,
+        truncate=truncate, x_jitter=x_jitter, y_jitter=y_jitter,
+        scatter_kws=scatter_kws, line_kws=line_kws,
+    )
+    facets.map_dataframe(regplot, x=x, y=y, **regplot_kws)
+    facets.set_axis_labels(x, y)
+
+    # Add a legend
+    if legend and (hue is not None) and (hue not in [col, row]):
+        facets.add_legend()
+    return facets
+
+
+lmplot.__doc__ = dedent("""\
+    Plot data and regression model fits across a FacetGrid.
+
+    This function combines :func:`regplot` and :class:`FacetGrid`. It is
+    intended as a convenient interface to fit regression models across
+    conditional subsets of a dataset.
+
+    When thinking about how to assign variables to different facets, a general
+    rule is that it makes sense to use ``hue`` for the most important
+    comparison, followed by ``col`` and ``row``. However, always think about
+    your particular dataset and the goals of the visualization you are
+    creating.
+
+    {model_api}
+
+    The parameters to this function span most of the options in
+    :class:`FacetGrid`, although there may be occasional cases where you will
+    want to use that class and :func:`regplot` directly.
+
+    Parameters
+    ----------
+    {data}
+    x, y : strings, optional
+        Input variables; these should be column names in ``data``.
+    hue, col, row : strings
+        Variables that define subsets of the data, which will be drawn on
+        separate facets in the grid. See the ``*_order`` parameters to control
+        the order of levels of this variable.
+    {palette}
+    {col_wrap}
+    {height}
+    {aspect}
+    markers : matplotlib marker code or list of marker codes, optional
+        Markers for the scatterplot. If a list, each marker in the list will be
+        used for each level of the ``hue`` variable.
+    {share_xy}
+
+        .. deprecated:: 0.12.0
+            Pass using the `facet_kws` dictionary.
+
+    {{hue,col,row}}_order : lists, optional
+        Order for the levels of the faceting variables. By default, this will
+        be the order that the levels appear in ``data`` or, if the variables
+        are pandas categoricals, the category order.
+    legend : bool, optional
+        If ``True`` and there is a ``hue`` variable, add a legend.
+    {legend_out}
+
+        .. deprecated:: 0.12.0
+            Pass using the `facet_kws` dictionary.
+
+    {x_estimator}
+    {x_bins}
+    {x_ci}
+    {scatter}
+    {fit_reg}
+    {ci}
+    {n_boot}
+    {units}
+    {seed}
+    {order}
+    {logistic}
+    {lowess}
+    {robust}
+    {logx}
+    {xy_partial}
+    {truncate}
+    {xy_jitter}
+    {scatter_line_kws}
+    facet_kws : dict
+        Dictionary of keyword arguments for :class:`FacetGrid`.
+
+    See Also
+    --------
+    regplot : Plot data and a conditional model fit.
+    FacetGrid : Subplot grid for plotting conditional relationships.
+    pairplot : Combine :func:`regplot` and :class:`PairGrid` (when used with
+               ``kind="reg"``).
+
+    Notes
+    -----
+
+    {regplot_vs_lmplot}
+
+    Examples
+    --------
+
+    .. include:: ../docstrings/lmplot.rst
+
+    """).format(**_regression_docs)
+
+
+def regplot(
+    data=None, *, x=None, y=None,
+    x_estimator=None, x_bins=None, x_ci="ci",
+    scatter=True, fit_reg=True, ci=95, n_boot=1000, units=None,
+    seed=None, order=1, logistic=False, lowess=False, robust=False,
+    logx=False, x_partial=None, y_partial=None,
+    truncate=True, dropna=True, x_jitter=None, y_jitter=None,
+    label=None, color=None, marker="o",
+    scatter_kws=None, line_kws=None, ax=None
+):
+
+    plotter = _RegressionPlotter(x, y, data, x_estimator, x_bins, x_ci,
+                                 scatter, fit_reg, ci, n_boot, units, seed,
+                                 order, logistic, lowess, robust, logx,
+                                 x_partial, y_partial, truncate, dropna,
+                                 x_jitter, y_jitter, color, label)
+
+    if ax is None:
+        ax = plt.gca()
+
+    scatter_kws = {} if scatter_kws is None else copy.copy(scatter_kws)
+    scatter_kws["marker"] = marker
+    line_kws = {} if line_kws is None else copy.copy(line_kws)
+    plotter.plot(ax, scatter_kws, line_kws)
+    return ax
+
+
+regplot.__doc__ = dedent("""\
+    Plot data and a linear regression model fit.
+
+    {model_api}
+
+    Parameters
+    ----------
+    x, y: string, series, or vector array
+        Input variables. If strings, these should correspond with column names
+        in ``data``. When pandas objects are used, axes will be labeled with
+        the series name.
+    {data}
+    {x_estimator}
+    {x_bins}
+    {x_ci}
+    {scatter}
+    {fit_reg}
+    {ci}
+    {n_boot}
+    {units}
+    {seed}
+    {order}
+    {logistic}
+    {lowess}
+    {robust}
+    {logx}
+    {xy_partial}
+    {truncate}
+    {xy_jitter}
+    label : string
+        Label to apply to either the scatterplot or regression line (if
+        ``scatter`` is ``False``) for use in a legend.
+    color : matplotlib color
+        Color to apply to all plot elements; will be superseded by colors
+        passed in ``scatter_kws`` or ``line_kws``.
+    marker : matplotlib marker code
+        Marker to use for the scatterplot glyphs.
+    {scatter_line_kws}
+    ax : matplotlib Axes, optional
+        Axes object to draw the plot onto, otherwise uses the current Axes.
+
+    Returns
+    -------
+    ax : matplotlib Axes
+        The Axes object containing the plot.
+
+    See Also
+    --------
+    lmplot : Combine :func:`regplot` and :class:`FacetGrid` to plot multiple
+             linear relationships in a dataset.
+    jointplot : Combine :func:`regplot` and :class:`JointGrid` (when used with
+                ``kind="reg"``).
+    pairplot : Combine :func:`regplot` and :class:`PairGrid` (when used with
+               ``kind="reg"``).
+    residplot : Plot the residuals of a linear regression model.
+
+    Notes
+    -----
+
+    {regplot_vs_lmplot}
+
+
+    It's also easy to combine :func:`regplot` and :class:`JointGrid` or
+    :class:`PairGrid` through the :func:`jointplot` and :func:`pairplot`
+    functions, although these do not directly accept all of :func:`regplot`'s
+    parameters.
+
+    Examples
+    --------
+
+    .. include:: ../docstrings/regplot.rst
+
+    """).format(**_regression_docs)
+
+
+def residplot(
+    data=None, *, x=None, y=None,
+    x_partial=None, y_partial=None, lowess=False,
+    order=1, robust=False, dropna=True, label=None, color=None,
+    scatter_kws=None, line_kws=None, ax=None
+):
+    """Plot the residuals of a linear regression.
+
+    This function will regress y on x (possibly as a robust or polynomial
+    regression) and then draw a scatterplot of the residuals. You can
+    optionally fit a lowess smoother to the residual plot, which can
+    help in determining if there is structure to the residuals.
+
+    Parameters
+    ----------
+    data : DataFrame, optional
+        DataFrame to use if `x` and `y` are column names.
+    x : vector or string
+        Data or column name in `data` for the predictor variable.
+    y : vector or string
+        Data or column name in `data` for the response variable.
+    {x, y}_partial : vectors or string(s) , optional
+        These variables are treated as confounding and are removed from
+        the `x` or `y` variables before plotting.
+    lowess : boolean, optional
+        Fit a lowess smoother to the residual scatterplot.
+    order : int, optional
+        Order of the polynomial to fit when calculating the residuals.
+    robust : boolean, optional
+        Fit a robust linear regression when calculating the residuals.
+    dropna : boolean, optional
+        If True, ignore observations with missing data when fitting and
+        plotting.
+    label : string, optional
+        Label that will be used in any plot legends.
+    color : matplotlib color, optional
+        Color to use for all elements of the plot.
+    {scatter, line}_kws : dictionaries, optional
+        Additional keyword arguments passed to scatter() and plot() for drawing
+        the components of the plot.
+    ax : matplotlib axis, optional
+        Plot into this axis, otherwise grab the current axis or make a new
+        one if not existing.
+
+    Returns
+    -------
+    ax: matplotlib axes
+        Axes with the regression plot.
+
+    See Also
+    --------
+    regplot : Plot a simple linear regression model.
+    jointplot : Draw a :func:`residplot` with univariate marginal distributions
+                (when used with ``kind="resid"``).
+
+    Examples
+    --------
+
+    .. include:: ../docstrings/residplot.rst
+
+    """
+    plotter = _RegressionPlotter(x, y, data, ci=None,
+                                 order=order, robust=robust,
+                                 x_partial=x_partial, y_partial=y_partial,
+                                 dropna=dropna, color=color, label=label)
+
+    if ax is None:
+        ax = plt.gca()
+
+    # Calculate the residual from a linear regression
+    _, yhat, _ = plotter.fit_regression(grid=plotter.x)
+    plotter.y = plotter.y - yhat
+
+    # Set the regression option on the plotter
+    if lowess:
+        plotter.lowess = True
+    else:
+        plotter.fit_reg = False
+
+    # Plot a horizontal line at 0
+    ax.axhline(0, ls=":", c=".2")
+
+    # Draw the scatterplot
+    scatter_kws = {} if scatter_kws is None else scatter_kws.copy()
+    line_kws = {} if line_kws is None else line_kws.copy()
+    plotter.plot(ax, scatter_kws, line_kws)
+    return ax

shared/package-files/33/335449ddfb59e317ccded7a8fd45adfa06bb827e3bc9f24d9b80569a6a8da815/_rgi.py

@@ -0,0 +1,759 @@
+__all__ = ['RegularGridInterpolator', 'interpn']
+
+import itertools
+
+import numpy as np
+
+import scipy.sparse.linalg as ssl
+
+from ._interpnd import _ndim_coords_from_arrays
+from ._cubic import PchipInterpolator
+from ._rgi_cython import evaluate_linear_2d, find_indices
+from ._bsplines import make_interp_spline
+from ._fitpack2 import RectBivariateSpline
+from ._ndbspline import make_ndbspl
+
+
+def _check_points(points):
+    descending_dimensions = []
+    grid = []
+    for i, p in enumerate(points):
+        # early make points float
+        # see https://github.com/scipy/scipy/pull/17230
+        p = np.asarray(p, dtype=float)
+        if not np.all(p[1:] > p[:-1]):
+            if np.all(p[1:] < p[:-1]):
+                # input is descending, so make it ascending
+                descending_dimensions.append(i)
+                p = np.flip(p)
+            else:
+                raise ValueError(
+                    "The points in dimension %d must be strictly "
+                    "ascending or descending" % i)
+        # see https://github.com/scipy/scipy/issues/17716
+        p = np.ascontiguousarray(p)
+        grid.append(p)
+    return tuple(grid), tuple(descending_dimensions)
+
+
+def _check_dimensionality(points, values):
+    if len(points) > values.ndim:
+        raise ValueError("There are %d point arrays, but values has %d "
+                         "dimensions" % (len(points), values.ndim))
+    for i, p in enumerate(points):
+        if not np.asarray(p).ndim == 1:
+            raise ValueError("The points in dimension %d must be "
+                             "1-dimensional" % i)
+        if not values.shape[i] == len(p):
+            raise ValueError("There are %d points and %d values in "
+                             "dimension %d" % (len(p), values.shape[i], i))
+
+
+class RegularGridInterpolator:
+    """
+    Interpolator on a regular or rectilinear grid in arbitrary dimensions.
+
+    The data must be defined on a rectilinear grid; that is, a rectangular
+    grid with even or uneven spacing. Linear, nearest-neighbor, spline
+    interpolations are supported. After setting up the interpolator object,
+    the interpolation method may be chosen at each evaluation.
+
+    Parameters
+    ----------
+    points : tuple of ndarray of float, with shapes (m1, ), ..., (mn, )
+        The points defining the regular grid in n dimensions. The points in
+        each dimension (i.e. every elements of the points tuple) must be
+        strictly ascending or descending.
+
+    values : array_like, shape (m1, ..., mn, ...)
+        The data on the regular grid in n dimensions. Complex data is
+        accepted.
+
+    method : str, optional
+        The method of interpolation to perform. Supported are "linear",
+        "nearest", "slinear", "cubic", "quintic" and "pchip". This
+        parameter will become the default for the object's ``__call__``
+        method. Default is "linear".
+
+    bounds_error : bool, optional
+        If True, when interpolated values are requested outside of the
+        domain of the input data, a ValueError is raised.
+        If False, then `fill_value` is used.
+        Default is True.
+
+    fill_value : float or None, optional
+        The value to use for points outside of the interpolation domain.
+        If None, values outside the domain are extrapolated.
+        Default is ``np.nan``.
+
+    solver : callable, optional
+        Only used for methods "slinear", "cubic" and "quintic".
+        Sparse linear algebra solver for construction of the NdBSpline instance.
+        Default is the iterative solver `scipy.sparse.linalg.gcrotmk`.
+
+        .. versionadded:: 1.13
+
+    solver_args: dict, optional
+        Additional arguments to pass to `solver`, if any.
+
+        .. versionadded:: 1.13
+
+    Methods
+    -------
+    __call__
+
+    Attributes
+    ----------
+    grid : tuple of ndarrays
+        The points defining the regular grid in n dimensions.
+        This tuple defines the full grid via
+        ``np.meshgrid(*grid, indexing='ij')``
+    values : ndarray
+        Data values at the grid.
+    method : str
+        Interpolation method.
+    fill_value : float or ``None``
+        Use this value for out-of-bounds arguments to `__call__`.
+    bounds_error : bool
+        If ``True``, out-of-bounds argument raise a ``ValueError``.
+
+    Notes
+    -----
+    Contrary to `LinearNDInterpolator` and `NearestNDInterpolator`, this class
+    avoids expensive triangulation of the input data by taking advantage of the
+    regular grid structure.
+
+    In other words, this class assumes that the data is defined on a
+    *rectilinear* grid.
+
+    .. versionadded:: 0.14
+
+    The 'slinear'(k=1), 'cubic'(k=3), and 'quintic'(k=5) methods are
+    tensor-product spline interpolators, where `k` is the spline degree,
+    If any dimension has fewer points than `k` + 1, an error will be raised.
+
+    .. versionadded:: 1.9
+
+    If the input data is such that dimensions have incommensurate
+    units and differ by many orders of magnitude, the interpolant may have
+    numerical artifacts. Consider rescaling the data before interpolating.
+
+    **Choosing a solver for spline methods**
+
+    Spline methods, "slinear", "cubic" and "quintic" involve solving a
+    large sparse linear system at instantiation time. Depending on data,
+    the default solver may or may not be adequate. When it is not, you may
+    need to experiment with an optional `solver` argument, where you may
+    choose between the direct solver (`scipy.sparse.linalg.spsolve`) or
+    iterative solvers from `scipy.sparse.linalg`. You may need to supply
+    additional parameters via the optional `solver_args` parameter (for instance,
+    you may supply the starting value or target tolerance). See the
+    `scipy.sparse.linalg` documentation for the full list of available options.
+
+    Alternatively, you may instead use the legacy methods, "slinear_legacy",
+    "cubic_legacy" and "quintic_legacy". These methods allow faster construction
+    but evaluations will be much slower.
+
+    Examples
+    --------
+    **Evaluate a function on the points of a 3-D grid**
+
+    As a first example, we evaluate a simple example function on the points of
+    a 3-D grid:
+
+    >>> from scipy.interpolate import RegularGridInterpolator
+    >>> import numpy as np
+    >>> def f(x, y, z):
+    ...     return 2 * x**3 + 3 * y**2 - z
+    >>> x = np.linspace(1, 4, 11)
+    >>> y = np.linspace(4, 7, 22)
+    >>> z = np.linspace(7, 9, 33)
+    >>> xg, yg ,zg = np.meshgrid(x, y, z, indexing='ij', sparse=True)
+    >>> data = f(xg, yg, zg)
+
+    ``data`` is now a 3-D array with ``data[i, j, k] = f(x[i], y[j], z[k])``.
+    Next, define an interpolating function from this data:
+
+    >>> interp = RegularGridInterpolator((x, y, z), data)
+
+    Evaluate the interpolating function at the two points
+    ``(x,y,z) = (2.1, 6.2, 8.3)`` and ``(3.3, 5.2, 7.1)``:
+
+    >>> pts = np.array([[2.1, 6.2, 8.3],
+    ...                 [3.3, 5.2, 7.1]])
+    >>> interp(pts)
+    array([ 125.80469388,  146.30069388])
+
+    which is indeed a close approximation to
+
+    >>> f(2.1, 6.2, 8.3), f(3.3, 5.2, 7.1)
+    (125.54200000000002, 145.894)
+
+    **Interpolate and extrapolate a 2D dataset**
+
+    As a second example, we interpolate and extrapolate a 2D data set:
+
+    >>> x, y = np.array([-2, 0, 4]), np.array([-2, 0, 2, 5])
+    >>> def ff(x, y):
+    ...     return x**2 + y**2
+
+    >>> xg, yg = np.meshgrid(x, y, indexing='ij')
+    >>> data = ff(xg, yg)
+    >>> interp = RegularGridInterpolator((x, y), data,
+    ...                                  bounds_error=False, fill_value=None)
+
+    >>> import matplotlib.pyplot as plt
+    >>> fig = plt.figure()
+    >>> ax = fig.add_subplot(projection='3d')
+    >>> ax.scatter(xg.ravel(), yg.ravel(), data.ravel(),
+    ...            s=60, c='k', label='data')
+
+    Evaluate and plot the interpolator on a finer grid
+
+    >>> xx = np.linspace(-4, 9, 31)
+    >>> yy = np.linspace(-4, 9, 31)
+    >>> X, Y = np.meshgrid(xx, yy, indexing='ij')
+
+    >>> # interpolator
+    >>> ax.plot_wireframe(X, Y, interp((X, Y)), rstride=3, cstride=3,
+    ...                   alpha=0.4, color='m', label='linear interp')
+
+    >>> # ground truth
+    >>> ax.plot_wireframe(X, Y, ff(X, Y), rstride=3, cstride=3,
+    ...                   alpha=0.4, label='ground truth')
+    >>> plt.legend()
+    >>> plt.show()
+
+    Other examples are given
+    :ref:`in the tutorial <tutorial-interpolate_regular_grid_interpolator>`.
+
+    See Also
+    --------
+    NearestNDInterpolator : Nearest neighbor interpolator on *unstructured*
+                            data in N dimensions
+
+    LinearNDInterpolator : Piecewise linear interpolator on *unstructured* data
+                           in N dimensions
+
+    interpn : a convenience function which wraps `RegularGridInterpolator`
+
+    scipy.ndimage.map_coordinates : interpolation on grids with equal spacing
+                                    (suitable for e.g., N-D image resampling)
+
+    References
+    ----------
+    .. [1] Python package *regulargrid* by Johannes Buchner, see
+           https://pypi.python.org/pypi/regulargrid/
+    .. [2] Wikipedia, "Trilinear interpolation",
+           https://en.wikipedia.org/wiki/Trilinear_interpolation
+    .. [3] Weiser, Alan, and Sergio E. Zarantonello. "A note on piecewise linear
+           and multilinear table interpolation in many dimensions." MATH.
+           COMPUT. 50.181 (1988): 189-196.
+           https://www.ams.org/journals/mcom/1988-50-181/S0025-5718-1988-0917826-0/S0025-5718-1988-0917826-0.pdf
+           :doi:`10.1090/S0025-5718-1988-0917826-0`
+
+    """
+    # this class is based on code originally programmed by Johannes Buchner,
+    # see https://github.com/JohannesBuchner/regulargrid
+
+    _SPLINE_DEGREE_MAP = {"slinear": 1, "cubic": 3, "quintic": 5, 'pchip': 3,
+                          "slinear_legacy": 1, "cubic_legacy": 3, "quintic_legacy": 5,}
+    _SPLINE_METHODS_recursive = {"slinear_legacy", "cubic_legacy",
+                                "quintic_legacy", "pchip"}
+    _SPLINE_METHODS_ndbspl = {"slinear", "cubic", "quintic"}
+    _SPLINE_METHODS = list(_SPLINE_DEGREE_MAP.keys())
+    _ALL_METHODS = ["linear", "nearest"] + _SPLINE_METHODS
+
+    def __init__(self, points, values, method="linear", bounds_error=True,
+                 fill_value=np.nan, *, solver=None, solver_args=None):
+        if method not in self._ALL_METHODS:
+            raise ValueError(f"Method '{method}' is not defined")
+        elif method in self._SPLINE_METHODS:
+            self._validate_grid_dimensions(points, method)
+        self.method = method
+        self._spline = None
+        self.bounds_error = bounds_error
+        self.grid, self._descending_dimensions = _check_points(points)
+        self.values = self._check_values(values)
+        self._check_dimensionality(self.grid, self.values)
+        self.fill_value = self._check_fill_value(self.values, fill_value)
+        if self._descending_dimensions:
+            self.values = np.flip(values, axis=self._descending_dimensions)
+        if self.method == "pchip" and np.iscomplexobj(self.values):
+            msg = ("`PchipInterpolator` only works with real values. If you are trying "
+                   "to use the real components of the passed array, use `np.real` on "
+                   "the array before passing to `RegularGridInterpolator`.")
+            raise ValueError(msg)
+        if method in self._SPLINE_METHODS_ndbspl:
+            if solver_args is None:
+                solver_args = {}
+            self._spline = self._construct_spline(method, solver, **solver_args)
+        else:
+            if solver is not None or solver_args:
+                raise ValueError(
+                    f"{method =} does not accept the 'solver' argument. Got "
+                    f" {solver = } and with arguments {solver_args}."
+                )
+
+    def _construct_spline(self, method, solver=None, **solver_args):
+        if solver is None:
+            solver = ssl.gcrotmk
+        spl = make_ndbspl(
+                self.grid, self.values, self._SPLINE_DEGREE_MAP[method],
+                solver=solver, **solver_args
+              )
+        return spl
+
+    def _check_dimensionality(self, grid, values):
+        _check_dimensionality(grid, values)
+
+    def _check_points(self, points):
+        return _check_points(points)
+
+    def _check_values(self, values):
+        if not hasattr(values, 'ndim'):
+            # allow reasonable duck-typed values
+            values = np.asarray(values)
+
+        if hasattr(values, 'dtype') and hasattr(values, 'astype'):
+            if not np.issubdtype(values.dtype, np.inexact):
+                values = values.astype(float)
+
+        return values
+
+    def _check_fill_value(self, values, fill_value):
+        if fill_value is not None:
+            fill_value_dtype = np.asarray(fill_value).dtype
+            if (hasattr(values, 'dtype') and not
+                    np.can_cast(fill_value_dtype, values.dtype,
+                                casting='same_kind')):
+                raise ValueError("fill_value must be either 'None' or "
+                                 "of a type compatible with values")
+        return fill_value
+
+    def __call__(self, xi, method=None, *, nu=None):
+        """
+        Interpolation at coordinates.
+
+        Parameters
+        ----------
+        xi : ndarray of shape (..., ndim)
+            The coordinates to evaluate the interpolator at.
+
+        method : str, optional
+            The method of interpolation to perform. Supported are "linear",
+            "nearest", "slinear", "cubic", "quintic" and "pchip". Default is
+            the method chosen when the interpolator was created.
+
+        nu : sequence of ints, length ndim, optional
+            If not None, the orders of the derivatives to evaluate.
+            Each entry must be non-negative.
+            Only allowed for methods "slinear", "cubic" and "quintic".
+
+            .. versionadded:: 1.13
+
+        Returns
+        -------
+        values_x : ndarray, shape xi.shape[:-1] + values.shape[ndim:]
+            Interpolated values at `xi`. See notes for behaviour when
+            ``xi.ndim == 1``.
+
+        Notes
+        -----
+        In the case that ``xi.ndim == 1`` a new axis is inserted into
+        the 0 position of the returned array, values_x, so its shape is
+        instead ``(1,) + values.shape[ndim:]``.
+
+        Examples
+        --------
+        Here we define a nearest-neighbor interpolator of a simple function
+
+        >>> import numpy as np
+        >>> x, y = np.array([0, 1, 2]), np.array([1, 3, 7])
+        >>> def f(x, y):
+        ...     return x**2 + y**2
+        >>> data = f(*np.meshgrid(x, y, indexing='ij', sparse=True))
+        >>> from scipy.interpolate import RegularGridInterpolator
+        >>> interp = RegularGridInterpolator((x, y), data, method='nearest')
+
+        By construction, the interpolator uses the nearest-neighbor
+        interpolation
+
+        >>> interp([[1.5, 1.3], [0.3, 4.5]])
+        array([2., 9.])
+
+        We can however evaluate the linear interpolant by overriding the
+        `method` parameter
+
+        >>> interp([[1.5, 1.3], [0.3, 4.5]], method='linear')
+        array([ 4.7, 24.3])
+        """
+        _spline = self._spline
+        method = self.method if method is None else method
+        is_method_changed = self.method != method
+        if method not in self._ALL_METHODS:
+            raise ValueError(f"Method '{method}' is not defined")
+        if is_method_changed and method in self._SPLINE_METHODS_ndbspl:
+            _spline = self._construct_spline(method)
+
+        if nu is not None and method not in self._SPLINE_METHODS_ndbspl:
+            raise ValueError(
+                f"Can only compute derivatives for methods "
+                f"{self._SPLINE_METHODS_ndbspl}, got {method =}."
+            )
+
+        xi, xi_shape, ndim, nans, out_of_bounds = self._prepare_xi(xi)
+
+        if method == "linear":
+            indices, norm_distances = self._find_indices(xi.T)
+            if (ndim == 2 and hasattr(self.values, 'dtype') and
+                    self.values.ndim == 2 and self.values.flags.writeable and
+                    self.values.dtype in (np.float64, np.complex128) and
+                    self.values.dtype.byteorder == '='):
+                # until cython supports const fused types, the fast path
+                # cannot support non-writeable values
+                # a fast path
+                out = np.empty(indices.shape[1], dtype=self.values.dtype)
+                result = evaluate_linear_2d(self.values,
+                                            indices,
+                                            norm_distances,
+                                            self.grid,
+                                            out)
+            else:
+                result = self._evaluate_linear(indices, norm_distances)
+        elif method == "nearest":
+            indices, norm_distances = self._find_indices(xi.T)
+            result = self._evaluate_nearest(indices, norm_distances)
+        elif method in self._SPLINE_METHODS:
+            if is_method_changed:
+                self._validate_grid_dimensions(self.grid, method)
+            if method in self._SPLINE_METHODS_recursive:
+                result = self._evaluate_spline(xi, method)
+            else:
+                result = _spline(xi, nu=nu)
+
+        if not self.bounds_error and self.fill_value is not None:
+            result[out_of_bounds] = self.fill_value
+
+        # f(nan) = nan, if any
+        if np.any(nans):
+            result[nans] = np.nan
+        return result.reshape(xi_shape[:-1] + self.values.shape[ndim:])
+
+    def _prepare_xi(self, xi):
+        ndim = len(self.grid)
+        xi = _ndim_coords_from_arrays(xi, ndim=ndim)
+        if xi.shape[-1] != len(self.grid):
+            raise ValueError("The requested sample points xi have dimension "
+                             f"{xi.shape[-1]} but this "
+                             f"RegularGridInterpolator has dimension {ndim}")
+
+        xi_shape = xi.shape
+        xi = xi.reshape(-1, xi_shape[-1])
+        xi = np.asarray(xi, dtype=float)
+
+        # find nans in input
+        nans = np.any(np.isnan(xi), axis=-1)
+
+        if self.bounds_error:
+            for i, p in enumerate(xi.T):
+                if not np.logical_and(np.all(self.grid[i][0] <= p),
+                                      np.all(p <= self.grid[i][-1])):
+                    raise ValueError("One of the requested xi is out of bounds "
+                                     "in dimension %d" % i)
+            out_of_bounds = None
+        else:
+            out_of_bounds = self._find_out_of_bounds(xi.T)
+
+        return xi, xi_shape, ndim, nans, out_of_bounds
+
+    def _evaluate_linear(self, indices, norm_distances):
+        # slice for broadcasting over trailing dimensions in self.values
+        vslice = (slice(None),) + (None,)*(self.values.ndim - len(indices))
+
+        # Compute shifting up front before zipping everything together
+        shift_norm_distances = [1 - yi for yi in norm_distances]
+        shift_indices = [i + 1 for i in indices]
+
+        # The formula for linear interpolation in 2d takes the form:
+        # values = self.values[(i0, i1)] * (1 - y0) * (1 - y1) + \
+        #          self.values[(i0, i1 + 1)] * (1 - y0) * y1 + \
+        #          self.values[(i0 + 1, i1)] * y0 * (1 - y1) + \
+        #          self.values[(i0 + 1, i1 + 1)] * y0 * y1
+        # We pair i with 1 - yi (zipped1) and i + 1 with yi (zipped2)
+        zipped1 = zip(indices, shift_norm_distances)
+        zipped2 = zip(shift_indices, norm_distances)
+
+        # Take all products of zipped1 and zipped2 and iterate over them
+        # to get the terms in the above formula. This corresponds to iterating
+        # over the vertices of a hypercube.
+        hypercube = itertools.product(*zip(zipped1, zipped2))
+        value = np.array([0.])
+        for h in hypercube:
+            edge_indices, weights = zip(*h)
+            weight = np.array([1.])
+            for w in weights:
+                weight = weight * w
+            term = np.asarray(self.values[edge_indices]) * weight[vslice]
+            value = value + term   # cannot use += because broadcasting
+        return value
+
+    def _evaluate_nearest(self, indices, norm_distances):
+        idx_res = [np.where(yi <= .5, i, i + 1)
+                   for i, yi in zip(indices, norm_distances)]
+        return self.values[tuple(idx_res)]
+
+    def _validate_grid_dimensions(self, points, method):
+        k = self._SPLINE_DEGREE_MAP[method]
+        for i, point in enumerate(points):
+            ndim = len(np.atleast_1d(point))
+            if ndim <= k:
+                raise ValueError(f"There are {ndim} points in dimension {i},"
+                                 f" but method {method} requires at least "
+                                 f" {k+1} points per dimension.")
+
+    def _evaluate_spline(self, xi, method):
+        # ensure xi is 2D list of points to evaluate (`m` is the number of
+        # points and `n` is the number of interpolation dimensions,
+        # ``n == len(self.grid)``.)
+        if xi.ndim == 1:
+            xi = xi.reshape((1, xi.size))
+        m, n = xi.shape
+
+        # Reorder the axes: n-dimensional process iterates over the
+        # interpolation axes from the last axis downwards: E.g. for a 4D grid
+        # the order of axes is 3, 2, 1, 0. Each 1D interpolation works along
+        # the 0th axis of its argument array (for 1D routine it's its ``y``
+        # array). Thus permute the interpolation axes of `values` *and keep
+        # trailing dimensions trailing*.
+        axes = tuple(range(self.values.ndim))
+        axx = axes[:n][::-1] + axes[n:]
+        values = self.values.transpose(axx)
+
+        if method == 'pchip':
+            _eval_func = self._do_pchip
+        else:
+            _eval_func = self._do_spline_fit
+        k = self._SPLINE_DEGREE_MAP[method]
+
+        # Non-stationary procedure: difficult to vectorize this part entirely
+        # into numpy-level operations. Unfortunately this requires explicit
+        # looping over each point in xi.
+
+        # can at least vectorize the first pass across all points in the
+        # last variable of xi.
+        last_dim = n - 1
+        first_values = _eval_func(self.grid[last_dim],
+                                  values,
+                                  xi[:, last_dim],
+                                  k)
+
+        # the rest of the dimensions have to be on a per point-in-xi basis
+        shape = (m, *self.values.shape[n:])
+        result = np.empty(shape, dtype=self.values.dtype)
+        for j in range(m):
+            # Main process: Apply 1D interpolate in each dimension
+            # sequentially, starting with the last dimension.
+            # These are then "folded" into the next dimension in-place.
+            folded_values = first_values[j, ...]
+            for i in range(last_dim-1, -1, -1):
+                # Interpolate for each 1D from the last dimensions.
+                # This collapses each 1D sequence into a scalar.
+                folded_values = _eval_func(self.grid[i],
+                                           folded_values,
+                                           xi[j, i],
+                                           k)
+            result[j, ...] = folded_values
+
+        return result
+
+    @staticmethod
+    def _do_spline_fit(x, y, pt, k):
+        local_interp = make_interp_spline(x, y, k=k, axis=0)
+        values = local_interp(pt)
+        return values
+
+    @staticmethod
+    def _do_pchip(x, y, pt, k):
+        local_interp = PchipInterpolator(x, y, axis=0)
+        values = local_interp(pt)
+        return values
+
+    def _find_indices(self, xi):
+        return find_indices(self.grid, xi)
+
+    def _find_out_of_bounds(self, xi):
+        # check for out of bounds xi
+        out_of_bounds = np.zeros((xi.shape[1]), dtype=bool)
+        # iterate through dimensions
+        for x, grid in zip(xi, self.grid):
+            out_of_bounds += x < grid[0]
+            out_of_bounds += x > grid[-1]
+        return out_of_bounds
+
+
+def interpn(points, values, xi, method="linear", bounds_error=True,
+            fill_value=np.nan):
+    """
+    Multidimensional interpolation on regular or rectilinear grids.
+
+    Strictly speaking, not all regular grids are supported - this function
+    works on *rectilinear* grids, that is, a rectangular grid with even or
+    uneven spacing.
+
+    Parameters
+    ----------
+    points : tuple of ndarray of float, with shapes (m1, ), ..., (mn, )
+        The points defining the regular grid in n dimensions. The points in
+        each dimension (i.e. every elements of the points tuple) must be
+        strictly ascending or descending.
+
+    values : array_like, shape (m1, ..., mn, ...)
+        The data on the regular grid in n dimensions. Complex data is
+        accepted.
+
+        .. deprecated:: 1.13.0
+            Complex data is deprecated with ``method="pchip"`` and will raise an
+            error in SciPy 1.15.0. This is because ``PchipInterpolator`` only
+            works with real values. If you are trying to use the real components of
+            the passed array, use ``np.real`` on ``values``.
+
+    xi : ndarray of shape (..., ndim)
+        The coordinates to sample the gridded data at
+
+    method : str, optional
+        The method of interpolation to perform. Supported are "linear",
+        "nearest", "slinear", "cubic", "quintic", "pchip", and "splinef2d".
+        "splinef2d" is only supported for 2-dimensional data.
+
+    bounds_error : bool, optional
+        If True, when interpolated values are requested outside of the
+        domain of the input data, a ValueError is raised.
+        If False, then `fill_value` is used.
+
+    fill_value : number, optional
+        If provided, the value to use for points outside of the
+        interpolation domain. If None, values outside
+        the domain are extrapolated.  Extrapolation is not supported by method
+        "splinef2d".
+
+    Returns
+    -------
+    values_x : ndarray, shape xi.shape[:-1] + values.shape[ndim:]
+        Interpolated values at `xi`. See notes for behaviour when
+        ``xi.ndim == 1``.
+
+    See Also
+    --------
+    NearestNDInterpolator : Nearest neighbor interpolation on unstructured
+                            data in N dimensions
+    LinearNDInterpolator : Piecewise linear interpolant on unstructured data
+                           in N dimensions
+    RegularGridInterpolator : interpolation on a regular or rectilinear grid
+                              in arbitrary dimensions (`interpn` wraps this
+                              class).
+    RectBivariateSpline : Bivariate spline approximation over a rectangular mesh
+    scipy.ndimage.map_coordinates : interpolation on grids with equal spacing
+                                    (suitable for e.g., N-D image resampling)
+
+    Notes
+    -----
+
+    .. versionadded:: 0.14
+
+    In the case that ``xi.ndim == 1`` a new axis is inserted into
+    the 0 position of the returned array, values_x, so its shape is
+    instead ``(1,) + values.shape[ndim:]``.
+
+    If the input data is such that input dimensions have incommensurate
+    units and differ by many orders of magnitude, the interpolant may have
+    numerical artifacts. Consider rescaling the data before interpolation.
+
+    Examples
+    --------
+    Evaluate a simple example function on the points of a regular 3-D grid:
+
+    >>> import numpy as np
+    >>> from scipy.interpolate import interpn
+    >>> def value_func_3d(x, y, z):
+    ...     return 2 * x + 3 * y - z
+    >>> x = np.linspace(0, 4, 5)
+    >>> y = np.linspace(0, 5, 6)
+    >>> z = np.linspace(0, 6, 7)
+    >>> points = (x, y, z)
+    >>> values = value_func_3d(*np.meshgrid(*points, indexing='ij'))
+
+    Evaluate the interpolating function at a point
+
+    >>> point = np.array([2.21, 3.12, 1.15])
+    >>> print(interpn(points, values, point))
+    [12.63]
+
+    """
+    # sanity check 'method' kwarg
+    if method not in ["linear", "nearest", "cubic", "quintic", "pchip",
+                      "splinef2d", "slinear",
+                      "slinear_legacy", "cubic_legacy", "quintic_legacy"]:
+        raise ValueError("interpn only understands the methods 'linear', "
+                         "'nearest', 'slinear', 'cubic', 'quintic', 'pchip', "
+                         f"and 'splinef2d'. You provided {method}.")
+
+    if not hasattr(values, 'ndim'):
+        values = np.asarray(values)
+
+    ndim = values.ndim
+    if ndim > 2 and method == "splinef2d":
+        raise ValueError("The method splinef2d can only be used for "
+                         "2-dimensional input data")
+    if not bounds_error and fill_value is None and method == "splinef2d":
+        raise ValueError("The method splinef2d does not support extrapolation.")
+
+    # sanity check consistency of input dimensions
+    if len(points) > ndim:
+        raise ValueError("There are %d point arrays, but values has %d "
+                         "dimensions" % (len(points), ndim))
+    if len(points) != ndim and method == 'splinef2d':
+        raise ValueError("The method splinef2d can only be used for "
+                         "scalar data with one point per coordinate")
+
+    grid, descending_dimensions = _check_points(points)
+    _check_dimensionality(grid, values)
+
+    # sanity check requested xi
+    xi = _ndim_coords_from_arrays(xi, ndim=len(grid))
+    if xi.shape[-1] != len(grid):
+        raise ValueError("The requested sample points xi have dimension "
+                         "%d, but this RegularGridInterpolator has "
+                         "dimension %d" % (xi.shape[-1], len(grid)))
+
+    if bounds_error:
+        for i, p in enumerate(xi.T):
+            if not np.logical_and(np.all(grid[i][0] <= p),
+                                  np.all(p <= grid[i][-1])):
+                raise ValueError("One of the requested xi is out of bounds "
+                                 "in dimension %d" % i)
+
+    # perform interpolation
+    if method in RegularGridInterpolator._ALL_METHODS:
+        interp = RegularGridInterpolator(points, values, method=method,
+                                         bounds_error=bounds_error,
+                                         fill_value=fill_value)
+        return interp(xi)
+    elif method == "splinef2d":
+        xi_shape = xi.shape
+        xi = xi.reshape(-1, xi.shape[-1])
+
+        # RectBivariateSpline doesn't support fill_value; we need to wrap here
+        idx_valid = np.all((grid[0][0] <= xi[:, 0], xi[:, 0] <= grid[0][-1],
+                            grid[1][0] <= xi[:, 1], xi[:, 1] <= grid[1][-1]),
+                           axis=0)
+        result = np.empty_like(xi[:, 0])
+
+        # make a copy of values for RectBivariateSpline
+        interp = RectBivariateSpline(points[0], points[1], values[:])
+        result[idx_valid] = interp.ev(xi[idx_valid, 0], xi[idx_valid, 1])
+        result[np.logical_not(idx_valid)] = fill_value
+
+        return result.reshape(xi_shape[:-1])
+    else:
+        raise ValueError(f"unknown {method = }")

shared/package-files/33/335515c7106005c298d2bee9bfc0ef384ebf0896afc3439dddf8bc887f803c49/__init__.pyi

@@ -0,0 +1,3 @@
+from typing import Dict, Any
+
+LANG_INFO: Dict[str, Any] = ...

shared/package-files/33/3357196f3fa52433326a6626880e34964e00c5570aee50e9a0a0a7c6d86f6e4f/utf_16_be.py

@@ -0,0 +1,42 @@
+""" Python 'utf-16-be' Codec
+
+
+Written by Marc-Andre Lemburg (mal@lemburg.com).
+
+(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
+
+"""
+import codecs
+
+### Codec APIs
+
+encode = codecs.utf_16_be_encode
+
+def decode(input, errors='strict'):
+    return codecs.utf_16_be_decode(input, errors, True)
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input, final=False):
+        return codecs.utf_16_be_encode(input, self.errors)[0]
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    _buffer_decode = codecs.utf_16_be_decode
+
+class StreamWriter(codecs.StreamWriter):
+    encode = codecs.utf_16_be_encode
+
+class StreamReader(codecs.StreamReader):
+    decode = codecs.utf_16_be_decode
+
+### encodings module API
+
+def getregentry():
+    return codecs.CodecInfo(
+        name='utf-16-be',
+        encode=encode,
+        decode=decode,
+        incrementalencoder=IncrementalEncoder,
+        incrementaldecoder=IncrementalDecoder,
+        streamreader=StreamReader,
+        streamwriter=StreamWriter,
+    )

shared/package-files/33/3359968d2ef4a582c525abb9df836d82c95ca58ffc362638751991813ef74d5a/dataframe.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from collections import abc
+from typing import TYPE_CHECKING
+
+from pandas.core.interchange.column import PandasColumn
+from pandas.core.interchange.dataframe_protocol import DataFrame as DataFrameXchg
+from pandas.core.interchange.utils import maybe_rechunk
+
+if TYPE_CHECKING:
+    from collections.abc import (
+        Iterable,
+        Sequence,
+    )
+
+    from pandas import (
+        DataFrame,
+        Index,
+    )
+
+
+class PandasDataFrameXchg(DataFrameXchg):
+    """
+    A data frame class, with only the methods required by the interchange
+    protocol defined.
+    Instances of this (private) class are returned from
+    ``pd.DataFrame.__dataframe__`` as objects with the methods and
+    attributes defined on this class.
+    """
+
+    def __init__(self, df: DataFrame, allow_copy: bool = True) -> None:
+        """
+        Constructor - an instance of this (private) class is returned from
+        `pd.DataFrame.__dataframe__`.
+        """
+        self._df = df.rename(columns=str, copy=False)
+        self._allow_copy = allow_copy
+        for i, _col in enumerate(self._df.columns):
+            rechunked = maybe_rechunk(self._df.iloc[:, i], allow_copy=allow_copy)
+            if rechunked is not None:
+                self._df.isetitem(i, rechunked)
+
+    def __dataframe__(
+        self, nan_as_null: bool = False, allow_copy: bool = True
+    ) -> PandasDataFrameXchg:
+        # `nan_as_null` can be removed here once it's removed from
+        # Dataframe.__dataframe__
+        return PandasDataFrameXchg(self._df, allow_copy)
+
+    @property
+    def metadata(self) -> dict[str, Index]:
+        # `index` isn't a regular column, and the protocol doesn't support row
+        # labels - so we export it as Pandas-specific metadata here.
+        return {"pandas.index": self._df.index}
+
+    def num_columns(self) -> int:
+        return len(self._df.columns)
+
+    def num_rows(self) -> int:
+        return len(self._df)
+
+    def num_chunks(self) -> int:
+        return 1
+
+    def column_names(self) -> Index:
+        return self._df.columns
+
+    def get_column(self, i: int) -> PandasColumn:
+        return PandasColumn(self._df.iloc[:, i], allow_copy=self._allow_copy)
+
+    def get_column_by_name(self, name: str) -> PandasColumn:
+        return PandasColumn(self._df[name], allow_copy=self._allow_copy)
+
+    def get_columns(self) -> list[PandasColumn]:
+        return [
+            PandasColumn(self._df[name], allow_copy=self._allow_copy)
+            for name in self._df.columns
+        ]
+
+    def select_columns(self, indices: Sequence[int]) -> PandasDataFrameXchg:
+        if not isinstance(indices, abc.Sequence):
+            raise ValueError("`indices` is not a sequence")
+        if not isinstance(indices, list):
+            indices = list(indices)
+
+        return PandasDataFrameXchg(
+            self._df.iloc[:, indices], allow_copy=self._allow_copy
+        )
+
+    def select_columns_by_name(self, names: list[str]) -> PandasDataFrameXchg:  # type: ignore[override]
+        if not isinstance(names, abc.Sequence):
+            raise ValueError("`names` is not a sequence")
+        if not isinstance(names, list):
+            names = list(names)
+
+        return PandasDataFrameXchg(self._df.loc[:, names], allow_copy=self._allow_copy)
+
+    def get_chunks(self, n_chunks: int | None = None) -> Iterable[PandasDataFrameXchg]:
+        """
+        Return an iterator yielding the chunks.
+        """
+        if n_chunks and n_chunks > 1:
+            size = len(self._df)
+            step = size // n_chunks
+            if size % n_chunks != 0:
+                step += 1
+            for start in range(0, step * n_chunks, step):
+                yield PandasDataFrameXchg(
+                    self._df.iloc[start : start + step, :],
+                    allow_copy=self._allow_copy,
+                )
+        else:
+            yield self

shared/package-files/33/335fb9da0445995a7f6748e7c997d3503a9bc8c4db9a1693711b7e3fb1fd276f/missing.py

@@ -0,0 +1,269 @@
+# This file is part of Patsy
+# Copyright (C) 2013 Nathaniel Smith <njs@pobox.com>
+# See file LICENSE.txt for license information.
+
+# Missing data detection/handling
+
+# First, how do we represent missing data? (i.e., which values count as
+# "missing"?) In the long run, we want to use numpy's NA support... but that
+# doesn't exist yet. Until then, people use various sorts of ad-hoc
+# things. Some things that might be considered NA:
+#   NA (eventually)
+#   NaN  (in float or object arrays)
+#   None (in object arrays)
+#   np.ma.masked (in numpy.ma masked arrays)
+# Pandas compatibility considerations:
+#   For numeric arrays, None is unconditionally converted to NaN.
+#   For object arrays (including string arrays!), None and NaN are preserved,
+#     but pandas.isnull() returns True for both.
+# np.ma compatibility considerations:
+#   Preserving array subtypes is a huge pain, because it means that we can't
+#   just call 'asarray' and be done... we already jump through tons of hoops
+#   to write code that can handle both ndarray's and pandas objects, and
+#   just thinking about adding another item to this list makes me tired. So
+#   for now we don't support np.ma missing values. Use pandas!
+
+# Next, what should be done once we find missing data? R's options:
+#   -- throw away those rows (from all aligned matrices)
+#      -- with or without preserving information on which rows were discarded
+#   -- error out
+#   -- carry on
+# The 'carry on' option requires that we have some way to represent NA in our
+# output array. To avoid further solidifying the use of NaN for this purpose,
+# we'll leave this option out for now, until real NA support is
+# available. Also, we always preserve information on which rows were
+# discarded, using the pandas index functionality (currently this is only
+# returned to the original caller if they used return_type="dataframe",
+# though).
+
+import numpy as np
+from patsy import PatsyError
+from patsy.util import safe_isnan, safe_scalar_isnan, no_pickling, assert_no_pickling
+
+# These are made available in the patsy.* namespace
+__all__ = ["NAAction"]
+
+_valid_NA_types = ["None", "NaN"]
+_valid_NA_responses = ["raise", "drop"]
+
+
+def _desc_options(options):
+    return ", ".join([repr(opt) for opt in options])
+
+
+class NAAction(object):
+    """An :class:`NAAction` object defines a strategy for handling missing
+    data.
+
+    "NA" is short for "Not Available", and is used to refer to any value which
+    is somehow unmeasured or unavailable. In the long run, it is devoutly
+    hoped that numpy will gain first-class missing value support. Until then,
+    we work around this lack as best we're able.
+
+    There are two parts to this: First, we have to determine what counts as
+    missing data. For numerical data, the default is to treat NaN values
+    (e.g., ``numpy.nan``) as missing. For categorical data, the default is to
+    treat NaN values, and also the Python object None, as missing. (This is
+    consistent with how pandas does things, so if you're already using
+    None/NaN to mark missing data in your pandas DataFrames, you're good to
+    go.)
+
+    Second, we have to decide what to do with any missing data when we
+    encounter it. One option is to simply discard any rows which contain
+    missing data from our design matrices (``drop``). Another option is to
+    raise an error (``raise``). A third option would be to simply let the
+    missing values pass through into the returned design matrices. However,
+    this last option is not yet implemented, because of the lack of any
+    standard way to represent missing values in arbitrary numpy matrices;
+    we're hoping numpy will get this sorted out before we standardize on
+    anything ourselves.
+
+    You can control how patsy handles missing data through the ``NA_action=``
+    argument to functions like :func:`build_design_matrices` and
+    :func:`dmatrix`. If all you want to do is to choose between ``drop`` and
+    ``raise`` behaviour, you can pass one of those strings as the
+    ``NA_action=`` argument directly. If you want more fine-grained control
+    over how missing values are detected and handled, then you can create an
+    instance of this class, or your own object that implements the same
+    interface, and pass that as the ``NA_action=`` argument instead.
+    """
+
+    def __init__(self, on_NA="drop", NA_types=["None", "NaN"]):
+        """The :class:`NAAction` constructor takes the following arguments:
+
+        :arg on_NA: How to handle missing values. The default is ``"drop"``,
+          which removes all rows from all matrices which contain any missing
+          values. Also available is ``"raise"``, which raises an exception
+          when any missing values are encountered.
+        :arg NA_types: Which rules are used to identify missing values, as a
+          list of strings. Allowed values are:
+
+          * ``"None"``: treat the ``None`` object as missing in categorical
+            data.
+          * ``"NaN"``: treat floating point NaN values as missing in
+            categorical and numerical data.
+
+        .. versionadded:: 0.2.0
+        """
+        self.on_NA = on_NA
+        if self.on_NA not in _valid_NA_responses:
+            raise ValueError(
+                "invalid on_NA action %r "
+                "(should be one of %s)" % (on_NA, _desc_options(_valid_NA_responses))
+            )
+        if isinstance(NA_types, str):
+            raise ValueError("NA_types should be a list of strings")
+        self.NA_types = tuple(NA_types)
+        for NA_type in self.NA_types:
+            if NA_type not in _valid_NA_types:
+                raise ValueError(
+                    "invalid NA_type %r "
+                    "(should be one of %s)" % (NA_type, _desc_options(_valid_NA_types))
+                )
+
+    def is_categorical_NA(self, obj):
+        """Return True if `obj` is a categorical NA value.
+
+        Note that here `obj` is a single scalar value."""
+        if "NaN" in self.NA_types and safe_scalar_isnan(obj):
+            return True
+        if "None" in self.NA_types and obj is None:
+            return True
+        return False
+
+    def is_numerical_NA(self, arr):
+        """Returns a 1-d mask array indicating which rows in an array of
+        numerical values contain at least one NA value.
+
+        Note that here `arr` is a numpy array or pandas DataFrame."""
+        mask = np.zeros(arr.shape, dtype=bool)
+        if "NaN" in self.NA_types:
+            mask |= np.isnan(arr)
+        if mask.ndim > 1:
+            mask = np.any(mask, axis=1)
+        return mask
+
+    def handle_NA(self, values, is_NAs, origins):
+        """Takes a set of factor values that may have NAs, and handles them
+        appropriately.
+
+        :arg values: A list of `ndarray` objects representing the data.
+          These may be 1- or 2-dimensional, and may be of varying dtype. All
+          will have the same number of rows (or entries, for 1-d arrays).
+        :arg is_NAs: A list with the same number of entries as `values`,
+          containing boolean `ndarray` objects that indicate which rows
+          contain NAs in the corresponding entry in `values`.
+        :arg origins: A list with the same number of entries as
+          `values`, containing information on the origin of each
+          value. If we encounter a problem with some particular value, we use
+          the corresponding entry in `origins` as the origin argument when
+          raising a :class:`PatsyError`.
+        :returns: A list of new values (which may have a differing number of
+          rows.)
+        """
+        assert len(values) == len(is_NAs) == len(origins)
+        if len(values) == 0:
+            return values
+        if self.on_NA == "raise":
+            return self._handle_NA_raise(values, is_NAs, origins)
+        elif self.on_NA == "drop":
+            return self._handle_NA_drop(values, is_NAs, origins)
+        else:  # pragma: no cover
+            assert False
+
+    def _handle_NA_raise(self, values, is_NAs, origins):
+        for is_NA, origin in zip(is_NAs, origins):
+            if np.any(is_NA):
+                raise PatsyError("factor contains missing values", origin)
+        return values
+
+    def _handle_NA_drop(self, values, is_NAs, origins):
+        total_mask = np.zeros(is_NAs[0].shape[0], dtype=bool)
+        for is_NA in is_NAs:
+            total_mask |= is_NA
+        good_mask = ~total_mask
+        # "..." to handle 1- versus 2-dim indexing
+        return [v[good_mask] if v.ndim == 1 else v[good_mask, ...] for v in values]
+
+    __getstate__ = no_pickling
+
+
+def test_NAAction_basic():
+    import pytest
+
+    pytest.raises(ValueError, NAAction, on_NA="pord")
+    pytest.raises(ValueError, NAAction, NA_types=("NaN", "asdf"))
+    pytest.raises(ValueError, NAAction, NA_types="NaN")
+
+    assert_no_pickling(NAAction())
+
+
+def test_NAAction_NA_types_numerical():
+    for NA_types in [[], ["NaN"], ["None"], ["NaN", "None"]]:
+        action = NAAction(NA_types=NA_types)
+        for extra_shape in [(), (1,), (2,)]:
+            arr = np.ones((4,) + extra_shape, dtype=float)
+            nan_rows = [0, 2]
+            if arr.ndim > 1 and arr.shape[1] > 1:
+                arr[nan_rows, [0, 1]] = np.nan
+            else:
+                arr[nan_rows] = np.nan
+            exp_NA_mask = np.zeros(4, dtype=bool)
+            if "NaN" in NA_types:
+                exp_NA_mask[nan_rows] = True
+            got_NA_mask = action.is_numerical_NA(arr)
+            assert np.array_equal(got_NA_mask, exp_NA_mask)
+
+
+def test_NAAction_NA_types_categorical():
+    for NA_types in [[], ["NaN"], ["None"], ["NaN", "None"]]:
+        action = NAAction(NA_types=NA_types)
+        assert not action.is_categorical_NA("a")
+        assert not action.is_categorical_NA(1)
+        assert action.is_categorical_NA(None) == ("None" in NA_types)
+        assert action.is_categorical_NA(np.nan) == ("NaN" in NA_types)
+
+
+def test_NAAction_drop():
+    action = NAAction("drop")
+    in_values = [
+        np.asarray([-1, 2, -1, 4, 5]),
+        np.asarray([10.0, 20.0, 30.0, 40.0, 50.0]),
+        np.asarray([[1.0, np.nan], [3.0, 4.0], [10.0, 5.0], [6.0, 7.0], [8.0, np.nan]]),
+    ]
+    is_NAs = [
+        np.asarray([True, False, True, False, False]),
+        np.zeros(5, dtype=bool),
+        np.asarray([True, False, False, False, True]),
+    ]
+    out_values = action.handle_NA(in_values, is_NAs, [None] * 3)
+    assert len(out_values) == 3
+    assert np.array_equal(out_values[0], [2, 4])
+    assert np.array_equal(out_values[1], [20.0, 40.0])
+    assert np.array_equal(out_values[2], [[3.0, 4.0], [6.0, 7.0]])
+
+
+def test_NAAction_raise():
+    action = NAAction(on_NA="raise")
+
+    # no-NA just passes through:
+    in_arrs = [np.asarray([1.1, 1.2]), np.asarray([1, 2])]
+    is_NAs = [np.asarray([False, False])] * 2
+    got_arrs = action.handle_NA(in_arrs, is_NAs, [None, None])
+    assert np.array_equal(got_arrs[0], in_arrs[0])
+    assert np.array_equal(got_arrs[1], in_arrs[1])
+
+    from patsy.origin import Origin
+
+    o1 = Origin("asdf", 0, 1)
+    o2 = Origin("asdf", 2, 3)
+
+    # NA raises an error with a correct origin
+    in_idx = np.arange(2)
+    in_arrs = [np.asarray([1.1, 1.2]), np.asarray([1.0, np.nan])]
+    is_NAs = [np.asarray([False, False]), np.asarray([False, True])]
+    try:
+        action.handle_NA(in_arrs, is_NAs, [o1, o2])
+        assert False
+    except PatsyError as e:
+        assert e.origin is o2

shared/package-files/33/33604784129b509f04d81d901317d57fc35b00ae1916126d98a45e9416590e1e/registry.py

@@ -0,0 +1,414 @@
+from enum import Enum
+import importlib
+
+
+class BackendFilter(Enum):
+    """
+    Filter used with :meth:`~matplotlib.backends.registry.BackendRegistry.list_builtin`
+
+    .. versionadded:: 3.9
+    """
+    INTERACTIVE = 0
+    NON_INTERACTIVE = 1
+
+
+class BackendRegistry:
+    """
+    Registry of backends available within Matplotlib.
+
+    This is the single source of truth for available backends.
+
+    All use of ``BackendRegistry`` should be via the singleton instance
+    ``backend_registry`` which can be imported from ``matplotlib.backends``.
+
+    Each backend has a name, a module name containing the backend code, and an
+    optional GUI framework that must be running if the backend is interactive.
+    There are three sources of backends: built-in (source code is within the
+    Matplotlib repository), explicit ``module://some.backend`` syntax (backend is
+    obtained by loading the module), or via an entry point (self-registering
+    backend in an external package).
+
+    .. versionadded:: 3.9
+    """
+    # Mapping of built-in backend name to GUI framework, or "headless" for no
+    # GUI framework. Built-in backends are those which are included in the
+    # Matplotlib repo. A backend with name 'name' is located in the module
+    # f"matplotlib.backends.backend_{name.lower()}"
+    _BUILTIN_BACKEND_TO_GUI_FRAMEWORK = {
+        "gtk3agg": "gtk3",
+        "gtk3cairo": "gtk3",
+        "gtk4agg": "gtk4",
+        "gtk4cairo": "gtk4",
+        "macosx": "macosx",
+        "nbagg": "nbagg",
+        "notebook": "nbagg",
+        "qtagg": "qt",
+        "qtcairo": "qt",
+        "qt5agg": "qt5",
+        "qt5cairo": "qt5",
+        "tkagg": "tk",
+        "tkcairo": "tk",
+        "webagg": "webagg",
+        "wx": "wx",
+        "wxagg": "wx",
+        "wxcairo": "wx",
+        "agg": "headless",
+        "cairo": "headless",
+        "pdf": "headless",
+        "pgf": "headless",
+        "ps": "headless",
+        "svg": "headless",
+        "template": "headless",
+    }
+
+    # Reverse mapping of gui framework to preferred built-in backend.
+    _GUI_FRAMEWORK_TO_BACKEND = {
+        "gtk3": "gtk3agg",
+        "gtk4": "gtk4agg",
+        "headless": "agg",
+        "macosx": "macosx",
+        "qt": "qtagg",
+        "qt5": "qt5agg",
+        "qt6": "qtagg",
+        "tk": "tkagg",
+        "wx": "wxagg",
+    }
+
+    def __init__(self):
+        # Only load entry points when first needed.
+        self._loaded_entry_points = False
+
+        # Mapping of non-built-in backend to GUI framework, added dynamically from
+        # entry points and from matplotlib.use("module://some.backend") format.
+        # New entries have an "unknown" GUI framework that is determined when first
+        # needed by calling _get_gui_framework_by_loading.
+        self._backend_to_gui_framework = {}
+
+        # Mapping of backend name to module name, where different from
+        # f"matplotlib.backends.backend_{backend_name.lower()}". These are either
+        # hardcoded for backward compatibility, or loaded from entry points or
+        # "module://some.backend" syntax.
+        self._name_to_module = {
+            "notebook": "nbagg",
+        }
+
+    def _backend_module_name(self, backend):
+        if backend.startswith("module://"):
+            return backend[9:]
+
+        # Return name of module containing the specified backend.
+        # Does not check if the backend is valid, use is_valid_backend for that.
+        backend = backend.lower()
+
+        # Check if have specific name to module mapping.
+        backend = self._name_to_module.get(backend, backend)
+
+        return (backend[9:] if backend.startswith("module://")
+                else f"matplotlib.backends.backend_{backend}")
+
+    def _clear(self):
+        # Clear all dynamically-added data, used for testing only.
+        self.__init__()
+
+    def _ensure_entry_points_loaded(self):
+        # Load entry points, if they have not already been loaded.
+        if not self._loaded_entry_points:
+            entries = self._read_entry_points()
+            self._validate_and_store_entry_points(entries)
+            self._loaded_entry_points = True
+
+    def _get_gui_framework_by_loading(self, backend):
+        # Determine GUI framework for a backend by loading its module and reading the
+        # FigureCanvas.required_interactive_framework attribute.
+        # Returns "headless" if there is no GUI framework.
+        module = self.load_backend_module(backend)
+        canvas_class = module.FigureCanvas
+        return canvas_class.required_interactive_framework or "headless"
+
+    def _read_entry_points(self):
+        # Read entry points of modules that self-advertise as Matplotlib backends.
+        # Expects entry points like this one from matplotlib-inline (in pyproject.toml
+        # format):
+        #   [project.entry-points."matplotlib.backend"]
+        #   inline = "matplotlib_inline.backend_inline"
+        import importlib.metadata as im
+
+        entry_points = im.entry_points(group="matplotlib.backend")
+        entries = [(entry.name, entry.value) for entry in entry_points]
+
+        # For backward compatibility, if matplotlib-inline and/or ipympl are installed
+        # but too old to include entry points, create them. Do not import ipympl
+        # directly as this calls matplotlib.use() whilst in this function.
+        def backward_compatible_entry_points(
+                entries, module_name, threshold_version, names, target):
+            from matplotlib import _parse_to_version_info
+            try:
+                module_version = im.version(module_name)
+                if _parse_to_version_info(module_version) < threshold_version:
+                    for name in names:
+                        entries.append((name, target))
+            except im.PackageNotFoundError:
+                pass
+
+        names = [entry[0] for entry in entries]
+        if "inline" not in names:
+            backward_compatible_entry_points(
+                entries, "matplotlib_inline", (0, 1, 7), ["inline"],
+                "matplotlib_inline.backend_inline")
+        if "ipympl" not in names:
+            backward_compatible_entry_points(
+                entries, "ipympl", (0, 9, 4), ["ipympl", "widget"],
+                "ipympl.backend_nbagg")
+
+        return entries
+
+    def _validate_and_store_entry_points(self, entries):
+        # Validate and store entry points so that they can be used via matplotlib.use()
+        # in the normal manner. Entry point names cannot be of module:// format, cannot
+        # shadow a built-in backend name, and there cannot be multiple entry points
+        # with the same name but different modules. Multiple entry points with the same
+        # name and value are permitted (it can sometimes happen outside of our control,
+        # see https://github.com/matplotlib/matplotlib/issues/28367).
+        for name, module in set(entries):
+            name = name.lower()
+            if name.startswith("module://"):
+                raise RuntimeError(
+                    f"Entry point name '{name}' cannot start with 'module://'")
+            if name in self._BUILTIN_BACKEND_TO_GUI_FRAMEWORK:
+                raise RuntimeError(f"Entry point name '{name}' is a built-in backend")
+            if name in self._backend_to_gui_framework:
+                raise RuntimeError(f"Entry point name '{name}' duplicated")
+
+            self._name_to_module[name] = "module://" + module
+            # Do not yet know backend GUI framework, determine it only when necessary.
+            self._backend_to_gui_framework[name] = "unknown"
+
+    def backend_for_gui_framework(self, framework):
+        """
+        Return the name of the backend corresponding to the specified GUI framework.
+
+        Parameters
+        ----------
+        framework : str
+            GUI framework such as "qt".
+
+        Returns
+        -------
+        str or None
+            Backend name or None if GUI framework not recognised.
+        """
+        return self._GUI_FRAMEWORK_TO_BACKEND.get(framework.lower())
+
+    def is_valid_backend(self, backend):
+        """
+        Return True if the backend name is valid, False otherwise.
+
+        A backend name is valid if it is one of the built-in backends or has been
+        dynamically added via an entry point. Those beginning with ``module://`` are
+        always considered valid and are added to the current list of all backends
+        within this function.
+
+        Even if a name is valid, it may not be importable or usable. This can only be
+        determined by loading and using the backend module.
+
+        Parameters
+        ----------
+        backend : str
+            Name of backend.
+
+        Returns
+        -------
+        bool
+            True if backend is valid, False otherwise.
+        """
+        if not backend.startswith("module://"):
+            backend = backend.lower()
+
+        # For backward compatibility, convert ipympl and matplotlib-inline long
+        # module:// names to their shortened forms.
+        backwards_compat = {
+            "module://ipympl.backend_nbagg": "widget",
+            "module://matplotlib_inline.backend_inline": "inline",
+        }
+        backend = backwards_compat.get(backend, backend)
+
+        if (backend in self._BUILTIN_BACKEND_TO_GUI_FRAMEWORK or
+                backend in self._backend_to_gui_framework):
+            return True
+
+        if backend.startswith("module://"):
+            self._backend_to_gui_framework[backend] = "unknown"
+            return True
+
+        # Only load entry points if really need to and not already done so.
+        self._ensure_entry_points_loaded()
+        if backend in self._backend_to_gui_framework:
+            return True
+
+        return False
+
+    def list_all(self):
+        """
+        Return list of all known backends.
+
+        These include built-in backends and those obtained at runtime either from entry
+        points or explicit ``module://some.backend`` syntax.
+
+        Entry points will be loaded if they haven't been already.
+
+        Returns
+        -------
+        list of str
+            Backend names.
+        """
+        self._ensure_entry_points_loaded()
+        return [*self.list_builtin(), *self._backend_to_gui_framework]
+
+    def list_builtin(self, filter_=None):
+        """
+        Return list of backends that are built into Matplotlib.
+
+        Parameters
+        ----------
+        filter_ : `~.BackendFilter`, optional
+            Filter to apply to returned backends. For example, to return only
+            non-interactive backends use `.BackendFilter.NON_INTERACTIVE`.
+
+        Returns
+        -------
+        list of str
+            Backend names.
+        """
+        if filter_ == BackendFilter.INTERACTIVE:
+            return [k for k, v in self._BUILTIN_BACKEND_TO_GUI_FRAMEWORK.items()
+                    if v != "headless"]
+        elif filter_ == BackendFilter.NON_INTERACTIVE:
+            return [k for k, v in self._BUILTIN_BACKEND_TO_GUI_FRAMEWORK.items()
+                    if v == "headless"]
+
+        return [*self._BUILTIN_BACKEND_TO_GUI_FRAMEWORK]
+
+    def list_gui_frameworks(self):
+        """
+        Return list of GUI frameworks used by Matplotlib backends.
+
+        Returns
+        -------
+        list of str
+            GUI framework names.
+        """
+        return [k for k in self._GUI_FRAMEWORK_TO_BACKEND if k != "headless"]
+
+    def load_backend_module(self, backend):
+        """
+        Load and return the module containing the specified backend.
+
+        Parameters
+        ----------
+        backend : str
+            Name of backend to load.
+
+        Returns
+        -------
+        Module
+            Module containing backend.
+        """
+        module_name = self._backend_module_name(backend)
+        return importlib.import_module(module_name)
+
+    def resolve_backend(self, backend):
+        """
+        Return the backend and GUI framework for the specified backend name.
+
+        If the GUI framework is not yet known then it will be determined by loading the
+        backend module and checking the ``FigureCanvas.required_interactive_framework``
+        attribute.
+
+        This function only loads entry points if they have not already been loaded and
+        the backend is not built-in and not of ``module://some.backend`` format.
+
+        Parameters
+        ----------
+        backend : str or None
+            Name of backend, or None to use the default backend.
+
+        Returns
+        -------
+        backend : str
+            The backend name.
+        framework : str or None
+            The GUI framework, which will be None for a backend that is non-interactive.
+        """
+        if isinstance(backend, str):
+            if not backend.startswith("module://"):
+                backend = backend.lower()
+        else:  # Might be _auto_backend_sentinel or None
+            # Use whatever is already running...
+            from matplotlib import get_backend
+            backend = get_backend()
+
+        # Is backend already known (built-in or dynamically loaded)?
+        gui = (self._BUILTIN_BACKEND_TO_GUI_FRAMEWORK.get(backend) or
+               self._backend_to_gui_framework.get(backend))
+
+        # Is backend "module://something"?
+        if gui is None and isinstance(backend, str) and backend.startswith("module://"):
+            gui = "unknown"
+
+        # Is backend a possible entry point?
+        if gui is None and not self._loaded_entry_points:
+            self._ensure_entry_points_loaded()
+            gui = self._backend_to_gui_framework.get(backend)
+
+        # Backend known but not its gui framework.
+        if gui == "unknown":
+            gui = self._get_gui_framework_by_loading(backend)
+            self._backend_to_gui_framework[backend] = gui
+
+        if gui is None:
+            raise RuntimeError(f"'{backend}' is not a recognised backend name")
+
+        return backend, gui if gui != "headless" else None
+
+    def resolve_gui_or_backend(self, gui_or_backend):
+        """
+        Return the backend and GUI framework for the specified string that may be
+        either a GUI framework or a backend name, tested in that order.
+
+        This is for use with the IPython %matplotlib magic command which may be a GUI
+        framework such as ``%matplotlib qt`` or a backend name such as
+        ``%matplotlib qtagg``.
+
+        This function only loads entry points if they have not already been loaded and
+        the backend is not built-in and not of ``module://some.backend`` format.
+
+        Parameters
+        ----------
+        gui_or_backend : str or None
+            Name of GUI framework or backend, or None to use the default backend.
+
+        Returns
+        -------
+        backend : str
+            The backend name.
+        framework : str or None
+            The GUI framework, which will be None for a backend that is non-interactive.
+        """
+        if not gui_or_backend.startswith("module://"):
+            gui_or_backend = gui_or_backend.lower()
+
+        # First check if it is a gui loop name.
+        backend = self.backend_for_gui_framework(gui_or_backend)
+        if backend is not None:
+            return backend, gui_or_backend if gui_or_backend != "headless" else None
+
+        # Then check if it is a backend name.
+        try:
+            return self.resolve_backend(gui_or_backend)
+        except Exception:  # KeyError ?
+            raise RuntimeError(
+                f"'{gui_or_backend}' is not a recognised GUI loop or backend name")
+
+
+# Singleton
+backend_registry = BackendRegistry()

shared/package-files/33/33608e94a85d3ddb541c831a396b65188564e4d1b36a0d4e1047172f4bed4e8e/__init__.pyi

@@ -0,0 +1,27 @@
+from typing import Any, Container, Iterable, Optional, Text
+
+from bleach.linkifier import DEFAULT_CALLBACKS as DEFAULT_CALLBACKS, Linker as Linker, _Callback
+from bleach.sanitizer import (
+    ALLOWED_ATTRIBUTES as ALLOWED_ATTRIBUTES,
+    ALLOWED_PROTOCOLS as ALLOWED_PROTOCOLS,
+    ALLOWED_STYLES as ALLOWED_STYLES,
+    ALLOWED_TAGS as ALLOWED_TAGS,
+    Cleaner as Cleaner,
+)
+
+__releasedate__: Text
+__version__: Text
+VERSION: Any  # packaging.version.Version
+
+def clean(
+    text: Text,
+    tags: Container[Text] = ...,
+    attributes: Any = ...,
+    styles: Container[Text] = ...,
+    protocols: Container[Text] = ...,
+    strip: bool = ...,
+    strip_comments: bool = ...,
+) -> Text: ...
+def linkify(
+    text: Text, callbacks: Iterable[_Callback] = ..., skip_tags: Optional[Container[Text]] = ..., parse_email: bool = ...
+) -> Text: ...