Remove 5000 files superseded by the deduplicated export

shared/package-files/9b/9b2824a306502b0a6f1290bd19fd1fcd2869bb52c21a5c33a1bc9480da5752dd/blob

@@ -1,413 +0,0 @@
-from __future__ import annotations
-
-import abc
-from functools import lru_cache
-from typing import TYPE_CHECKING, Any, ClassVar, Final, Protocol, TypeVar, cast, overload
-
-import polars as pl
-
-from narwhals._duration import Interval
-from narwhals._utils import (
-    Implementation,
-    Version,
-    _DeferredIterable,
-    _StoresCompliant,
-    _StoresNative,
-    deep_getattr,
-    isinstance_or_issubclass,
-)
-from narwhals.exceptions import (
-    ColumnNotFoundError,
-    ComputeError,
-    DuplicateError,
-    InvalidOperationError,
-    NarwhalsError,
-    ShapeError,
-)
-
-if TYPE_CHECKING:
-    from collections.abc import Callable, Iterable, Iterator, Mapping
-
-    from typing_extensions import TypeIs
-
-    from narwhals._compliant.typing import Accessor
-    from narwhals._polars.dataframe import Method
-    from narwhals._polars.expr import PolarsExpr
-    from narwhals._polars.series import PolarsSeries
-    from narwhals.dtypes import DType
-    from narwhals.typing import IntoDType
-
-    T = TypeVar("T")
-    NativeT = TypeVar(
-        "NativeT", bound="pl.DataFrame | pl.LazyFrame | pl.Series | pl.Expr"
-    )
-
-NativeT_co = TypeVar("NativeT_co", "pl.Series", "pl.Expr", covariant=True)
-CompliantT_co = TypeVar("CompliantT_co", "PolarsSeries", "PolarsExpr", covariant=True)
-CompliantT = TypeVar("CompliantT", "PolarsSeries", "PolarsExpr")
-
-BACKEND_VERSION = Implementation.POLARS._backend_version()
-"""Static backend version for `polars`."""
-
-SERIES_ACCEPTS_PD_INDEX: Final[bool] = BACKEND_VERSION >= (0, 20, 7)
-"""`pl.Series(values: pd.Index)` fixed in https://github.com/pola-rs/polars/pull/14087"""
-
-RESPECT_JOIN_NULL_SEMI_ANTI: Final[bool] = BACKEND_VERSION >= (0, 20, 22)
-"""Polars < 0.20.22 treats `null == null` as a match in semi/anti joins.
-
-Dropping rows with null keys on the right removes these spurious matches,
-which is always valid since narwhals treats nulls as non-matching.
-
-Fixed in https://github.com/pola-rs/polars/pull/15696
-"""
-
-SERIES_RESPECTS_DTYPE: Final[bool] = BACKEND_VERSION >= (0, 20, 26)
-"""`pl.Series(dtype=...)` fixed in https://github.com/pola-rs/polars/pull/15962
-
-Includes `SERIES_ACCEPTS_PD_INDEX`.
-"""
-
-HAS_INT_128: Final[bool] = BACKEND_VERSION >= (1, 18, 0)
-"""https://github.com/pola-rs/polars/pull/20232"""
-
-FROM_DICTS_ACCEPTS_MAPPINGS: Final[bool] = BACKEND_VERSION >= (1, 30, 0)
-"""`pl.from_dicts(data: Iterable[Mapping[str, Any]])` since https://github.com/pola-rs/polars/pull/22638"""
-
-HAS_UINT_128: Final[bool] = BACKEND_VERSION >= (1, 34, 0)
-"""https://github.com/pola-rs/polars/pull/24346"""
-
-HAS_FLOAT_16: Final[bool] = BACKEND_VERSION >= (1, 36, 0)
-"""https://github.com/pola-rs/polars/pull/25185"""
-
-BINARY_ADD_UPCASTS_DECIMAL_TO_FLOAT: Final[bool] = BACKEND_VERSION >= (1, 34, 0)
-"""Polars >= 1.34 upcasts `Decimal + float` to `Float64` (matching `int`/`Float32` promotion).
-
-https://github.com/pola-rs/polars/pull/24594
-"""
-
-
-@overload
-def extract_native(obj: _StoresNative[NativeT]) -> NativeT: ...
-@overload
-def extract_native(obj: T) -> T: ...
-def extract_native(obj: _StoresNative[NativeT] | T) -> NativeT | T:
-    return obj.native if _is_compliant_polars(obj) else cast("T", obj)
-
-
-def _is_compliant_polars(
-    obj: _StoresNative[NativeT] | Any,
-) -> TypeIs[_StoresNative[NativeT]]:
-    from narwhals._polars.dataframe import PolarsDataFrame, PolarsLazyFrame
-    from narwhals._polars.expr import PolarsExpr
-    from narwhals._polars.series import PolarsSeries
-
-    return isinstance(obj, (PolarsDataFrame, PolarsLazyFrame, PolarsSeries, PolarsExpr))
-
-
-def extract_args_kwargs(
-    args: Iterable[Any], kwds: Mapping[str, Any], /
-) -> tuple[Iterator[Any], dict[str, Any]]:
-    it_args = (extract_native(arg) for arg in args)
-    return it_args, {k: extract_native(v) for k, v in kwds.items()}
-
-
-@lru_cache(maxsize=128)
-def native_to_narwhals_dtype(  # noqa: C901, PLR0912
-    dtype: pl.DataType, version: Version
-) -> DType:
-    dtypes = version.dtypes
-    if dtype == pl.Float64:
-        return dtypes.Float64()
-    if dtype == pl.Float32:
-        return dtypes.Float32()
-    if HAS_FLOAT_16 and dtype == pl.Float16:
-        return dtypes.Float16()
-    if HAS_INT_128 and dtype == pl.Int128:
-        return dtypes.Int128()
-    if dtype == pl.Int64:
-        return dtypes.Int64()
-    if dtype == pl.Int32:
-        return dtypes.Int32()
-    if dtype == pl.Int16:
-        return dtypes.Int16()
-    if dtype == pl.Int8:
-        return dtypes.Int8()
-    if HAS_UINT_128 and dtype == pl.UInt128:
-        return dtypes.UInt128()
-    if dtype == pl.UInt64:
-        return dtypes.UInt64()
-    if dtype == pl.UInt32:
-        return dtypes.UInt32()
-    if dtype == pl.UInt16:
-        return dtypes.UInt16()
-    if dtype == pl.UInt8:
-        return dtypes.UInt8()
-    if dtype == pl.String:
-        return dtypes.String()
-    if dtype == pl.Boolean:
-        return dtypes.Boolean()
-    if dtype == pl.Object:
-        return dtypes.Object()
-    if isinstance(dtype, pl.Categorical):
-        return dtypes.Categorical()
-    if isinstance(dtype, pl.Enum):
-        if version is Version.V1:
-            return dtypes.Enum()  # type: ignore[call-arg]
-        categories = _DeferredIterable(dtype.categories.to_list)
-        return dtypes.Enum(categories)
-    if dtype == pl.Date:
-        return dtypes.Date()
-    if isinstance(dtype, pl.Datetime):
-        return dtypes.Datetime(dtype.time_unit, dtype.time_zone)
-    if isinstance(dtype, pl.Duration):
-        return dtypes.Duration(dtype.time_unit)
-    if isinstance(dtype, pl.Struct):
-        fields = [
-            dtypes.Field(name, native_to_narwhals_dtype(tp, version))
-            for name, tp in dtype
-        ]
-        return dtypes.Struct(fields)
-    if isinstance(dtype, pl.List):
-        return dtypes.List(native_to_narwhals_dtype(dtype.inner, version))
-    if isinstance(dtype, pl.Array):
-        outer_shape = dtype.width if BACKEND_VERSION < (0, 20, 30) else dtype.size  # type: ignore[attr-defined]
-        return dtypes.Array(native_to_narwhals_dtype(dtype.inner, version), outer_shape)
-    if isinstance(dtype, pl.Decimal):
-        return dtypes.Decimal(dtype.precision, dtype.scale)
-    if dtype == pl.Time:
-        return dtypes.Time()
-    if dtype == pl.Binary:
-        return dtypes.Binary()
-    return dtypes.Unknown()
-
-
-dtypes = Version.MAIN.dtypes
-
-
-def _version_dependent_dtypes() -> dict[type[DType], pl.DataType]:
-    if not HAS_INT_128:  # pragma: no cover
-        return {}
-    nw_to_pl: dict[type[DType], pl.DataType] = {dtypes.Int128: pl.Int128()}
-    nw_to_pl = nw_to_pl | {dtypes.UInt128: pl.UInt128()} if HAS_UINT_128 else nw_to_pl
-    return nw_to_pl | {dtypes.Float16: pl.Float16()} if HAS_FLOAT_16 else nw_to_pl
-
-
-NW_TO_PL_DTYPES: Mapping[type[DType], pl.DataType] = {
-    dtypes.Float64: pl.Float64(),
-    dtypes.Float32: pl.Float32(),
-    dtypes.Binary: pl.Binary(),
-    dtypes.String: pl.String(),
-    dtypes.Boolean: pl.Boolean(),
-    dtypes.Categorical: pl.Categorical(),
-    dtypes.Date: pl.Date(),
-    dtypes.Time: pl.Time(),
-    dtypes.Int8: pl.Int8(),
-    dtypes.Int16: pl.Int16(),
-    dtypes.Int32: pl.Int32(),
-    dtypes.Int64: pl.Int64(),
-    dtypes.UInt8: pl.UInt8(),
-    dtypes.UInt16: pl.UInt16(),
-    dtypes.UInt32: pl.UInt32(),
-    dtypes.UInt64: pl.UInt64(),
-    dtypes.Object: pl.Object(),
-    dtypes.Unknown: pl.Unknown(),
-    **_version_dependent_dtypes(),
-}
-
-
-def narwhals_to_native_dtype(  # noqa: C901
-    dtype: IntoDType, version: Version
-) -> pl.DataType:
-    dtypes = version.dtypes
-    base_type = dtype.base_type()
-    if pl_type := NW_TO_PL_DTYPES.get(base_type):
-        return pl_type
-    if isinstance_or_issubclass(dtype, dtypes.Enum):
-        if version is Version.V1:
-            msg = "Converting to Enum is not supported in narwhals.stable.v1"
-            raise NotImplementedError(msg)
-        if isinstance(dtype, dtypes.Enum):
-            return pl.Enum(dtype.categories)
-        msg = "Can not cast / initialize Enum without categories present"
-        raise ValueError(msg)
-    if isinstance_or_issubclass(dtype, dtypes.Datetime):
-        return pl.Datetime(dtype.time_unit, dtype.time_zone)  # type: ignore[arg-type]
-    if isinstance_or_issubclass(dtype, dtypes.Duration):
-        return pl.Duration(dtype.time_unit)  # type: ignore[arg-type]
-    if isinstance_or_issubclass(dtype, dtypes.List):
-        return pl.List(narwhals_to_native_dtype(dtype.inner, version))
-    if isinstance_or_issubclass(dtype, dtypes.Struct):
-        fields = [
-            pl.Field(field.name, narwhals_to_native_dtype(field.dtype, version))
-            for field in dtype.fields
-        ]
-        return pl.Struct(fields)
-    if isinstance_or_issubclass(dtype, dtypes.Array):  # pragma: no cover
-        size = dtype.size
-        kwargs = {"width": size} if BACKEND_VERSION < (0, 20, 30) else {"shape": size}
-        return pl.Array(narwhals_to_native_dtype(dtype.inner, version), **kwargs)
-    if isinstance_or_issubclass(dtype, dtypes.Decimal):
-        return pl.Decimal(dtype.precision, dtype.scale)
-    return pl.Unknown()  # pragma: no cover
-
-
-def _is_polars_exception(exception: Exception) -> bool:
-    if BACKEND_VERSION >= (1,):
-        # Old versions of Polars didn't have PolarsError.
-        return isinstance(exception, pl.exceptions.PolarsError)
-    # Last attempt, for old Polars versions.
-    return "polars.exceptions" in str(type(exception))  # pragma: no cover
-
-
-def _is_cudf_exception(exception: Exception) -> bool:
-    # These exceptions are raised when running polars on GPUs via cuDF
-    return str(exception).startswith("CUDF failure")
-
-
-def catch_polars_exception(exception: Exception) -> NarwhalsError | Exception:
-    if isinstance(exception, pl.exceptions.ColumnNotFoundError):
-        return ColumnNotFoundError(str(exception))
-    if isinstance(exception, pl.exceptions.ShapeError):
-        return ShapeError(str(exception))
-    if isinstance(exception, pl.exceptions.InvalidOperationError):
-        return InvalidOperationError(str(exception))
-    if isinstance(exception, pl.exceptions.DuplicateError):
-        return DuplicateError(str(exception))
-    if isinstance(exception, pl.exceptions.ComputeError):
-        return ComputeError(str(exception))
-    if _is_polars_exception(exception) or _is_cudf_exception(exception):
-        return NarwhalsError(str(exception))  # pragma: no cover
-    # Just return exception as-is.
-    return exception
-
-
-class PolarsAnyNamespace(
-    _StoresCompliant[CompliantT_co],
-    _StoresNative[NativeT_co],
-    Protocol[CompliantT_co, NativeT_co],
-):
-    _accessor: ClassVar[Accessor]
-
-    def __getattr__(self, attr: str) -> Callable[..., CompliantT_co]:
-        def func(*args: Any, **kwargs: Any) -> CompliantT_co:
-            pos, kwds = extract_args_kwargs(args, kwargs)
-            method = deep_getattr(self.native, self._accessor, attr)
-            return self.compliant._with_native(method(*pos, **kwds))
-
-        return func
-
-
-class PolarsDateTimeNamespace(PolarsAnyNamespace[CompliantT, NativeT_co]):
-    _accessor: ClassVar[Accessor] = "dt"
-
-    def truncate(self, every: str) -> CompliantT:
-        # Ensure consistent error message is raised.
-        Interval.parse(every)
-        return self.__getattr__("truncate")(every)
-
-    def offset_by(self, by: str) -> CompliantT:
-        # Ensure consistent error message is raised.
-        Interval.parse_no_constraints(by)
-        return self.__getattr__("offset_by")(by)
-
-    to_string: Method[CompliantT]
-    replace_time_zone: Method[CompliantT]
-    convert_time_zone: Method[CompliantT]
-    timestamp: Method[CompliantT]
-    date: Method[CompliantT]
-    year: Method[CompliantT]
-    month: Method[CompliantT]
-    day: Method[CompliantT]
-    hour: Method[CompliantT]
-    minute: Method[CompliantT]
-    second: Method[CompliantT]
-    millisecond: Method[CompliantT]
-    microsecond: Method[CompliantT]
-    nanosecond: Method[CompliantT]
-    ordinal_day: Method[CompliantT]
-    weekday: Method[CompliantT]
-    total_minutes: Method[CompliantT]
-    total_seconds: Method[CompliantT]
-    total_milliseconds: Method[CompliantT]
-    total_microseconds: Method[CompliantT]
-    total_nanoseconds: Method[CompliantT]
-
-
-class PolarsStringNamespace(PolarsAnyNamespace[CompliantT, NativeT_co]):
-    _accessor: ClassVar[Accessor] = "str"
-
-    # NOTE: Use `abstractmethod` if we have defs to implement, but also `Method` usage
-    @abc.abstractmethod
-    def to_titlecase(self) -> CompliantT: ...
-
-    @abc.abstractmethod
-    def zfill(self, width: int) -> CompliantT: ...
-
-    @abc.abstractmethod
-    def slice(self, offset: int, length: int | None) -> CompliantT: ...
-
-    len_chars: Method[CompliantT]
-    replace: Method[CompliantT]
-    replace_all: Method[CompliantT]
-    strip_chars: Method[CompliantT]
-    strip_chars_start: Method[CompliantT]
-    strip_chars_end: Method[CompliantT]
-    starts_with: Method[CompliantT]
-    ends_with: Method[CompliantT]
-    contains: Method[CompliantT]
-    split: Method[CompliantT]
-    to_date: Method[CompliantT]
-    to_datetime: Method[CompliantT]
-    to_time: Method[CompliantT]
-    to_lowercase: Method[CompliantT]
-    to_uppercase: Method[CompliantT]
-    pad_start: Method[CompliantT]
-    pad_end: Method[CompliantT]
-
-
-def native_get_categories(native: pl.Series) -> pl.Series:
-    # NOTE: Polars deprecated `cat.get_categories` in v1.44 and removed it
-    # in v2.0, so we use the workaround they suggest.
-    # See https://github.com/narwhals-dev/narwhals/issues/3895.
-    #
-    # For `Enum`, the declared categories are already unique, ordered, and
-    # null-free, so we can return `dtype.categories` directly.
-    dtype = native.dtype
-    if isinstance(dtype, pl.Enum):
-        return dtype.categories
-    return native.unique(maintain_order=True).drop_nulls().cast(pl.String)
-
-
-class PolarsCatNamespace(PolarsAnyNamespace[CompliantT, NativeT_co]):
-    _accessor: ClassVar[Accessor] = "cat"
-
-    @abc.abstractmethod
-    def get_categories(self) -> CompliantT: ...
-
-
-class PolarsListNamespace(PolarsAnyNamespace[CompliantT, NativeT_co]):
-    _accessor: ClassVar[Accessor] = "list"
-
-    @abc.abstractmethod
-    def len(self) -> CompliantT: ...
-
-    get: Method[CompliantT]
-
-    unique: Method[CompliantT]
-
-    max: Method[CompliantT]
-
-    mean: Method[CompliantT]
-
-    median: Method[CompliantT]
-
-    min: Method[CompliantT]
-
-    sort: Method[CompliantT]
-
-    sum: Method[CompliantT]
-
-
-class PolarsStructNamespace(PolarsAnyNamespace[CompliantT, NativeT_co]):
-    _accessor: ClassVar[Accessor] = "struct"
-    field: Method[CompliantT]

shared/package-files/9b/9b29fc93ae95aef6672fa47a556e880cf4df3baf15c636c9f14a7922e4a314be/blob

@@ -1,88 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#pragma once
-
-#include <cstdint>
-
-#include "arrow/util/bit_util.h"
-#include "arrow/util/bitmap_reader.h"
-
-namespace arrow {
-namespace internal {
-
-// A function that visits each bit in a bitmap and calls a visitor function with a
-// boolean representation of that bit. This is intended to be analogous to
-// GenerateBits.
-template <class Visitor>
-void VisitBits(const uint8_t* bitmap, int64_t start_offset, int64_t length,
-               Visitor&& visit) {
-  BitmapReader reader(bitmap, start_offset, length);
-  for (int64_t index = 0; index < length; ++index) {
-    visit(reader.IsSet());
-    reader.Next();
-  }
-}
-
-// Like VisitBits(), but unrolls its main loop for better performance.
-template <class Visitor>
-void VisitBitsUnrolled(const uint8_t* bitmap, int64_t start_offset, int64_t length,
-                       Visitor&& visit) {
-  if (length == 0) {
-    return;
-  }
-
-  // Start by visiting any bits preceding the first full byte.
-  int64_t num_bits_before_full_bytes =
-      bit_util::RoundUpToMultipleOf8(start_offset) - start_offset;
-  // Truncate num_bits_before_full_bytes if it is greater than length.
-  if (num_bits_before_full_bytes > length) {
-    num_bits_before_full_bytes = length;
-  }
-  // Use the non loop-unrolled VisitBits since we don't want to add branches
-  VisitBits<Visitor>(bitmap, start_offset, num_bits_before_full_bytes, visit);
-
-  // Shift the start pointer to the first full byte and compute the
-  // number of full bytes to be read.
-  const uint8_t* first_full_byte = bitmap + bit_util::CeilDiv(start_offset, 8);
-  const int64_t num_full_bytes = (length - num_bits_before_full_bytes) / 8;
-
-  // Iterate over each full byte of the input bitmap and call the visitor in
-  // a loop-unrolled manner.
-  for (int64_t byte_index = 0; byte_index < num_full_bytes; ++byte_index) {
-    // Get the current bit-packed byte value from the bitmap.
-    const uint8_t byte = *(first_full_byte + byte_index);
-
-    // Execute the visitor function on each bit of the current byte.
-    visit(bit_util::GetBitFromByte(byte, 0));
-    visit(bit_util::GetBitFromByte(byte, 1));
-    visit(bit_util::GetBitFromByte(byte, 2));
-    visit(bit_util::GetBitFromByte(byte, 3));
-    visit(bit_util::GetBitFromByte(byte, 4));
-    visit(bit_util::GetBitFromByte(byte, 5));
-    visit(bit_util::GetBitFromByte(byte, 6));
-    visit(bit_util::GetBitFromByte(byte, 7));
-  }
-
-  // Write any leftover bits in the last byte.
-  const int64_t num_bits_after_full_bytes = (length - num_bits_before_full_bytes) % 8;
-  VisitBits<Visitor>(first_full_byte + num_full_bytes, 0, num_bits_after_full_bytes,
-                     visit);
-}
-
-}  // namespace internal
-}  // namespace arrow

shared/package-files/9b/9b2c1a62c96e69385c72c6f7d5499d217c1773c48436f016e83412ea582aace6/blob

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <memory>
-
-#include <c10/core/Device.h>
-#include <c10/util/strong_type.h>
-#include <torch/csrc/Export.h>
-
-struct CUevent_st;
-
-namespace torch {
-namespace profiler {
-namespace impl {
-
-// ----------------------------------------------------------------------------
-// -- Annotation --------------------------------------------------------------
-// ----------------------------------------------------------------------------
-using ProfilerEventStub = std::shared_ptr<CUevent_st>;
-using ProfilerVoidEventStub = std::shared_ptr<void>;
-
-struct TORCH_API ProfilerStubs {
-  virtual void record(
-      c10::DeviceIndex* device,
-      ProfilerVoidEventStub* event,
-      int64_t* cpu_ns) const = 0;
-  virtual float elapsed(
-      const ProfilerVoidEventStub* event,
-      const ProfilerVoidEventStub* event2) const = 0;
-  virtual void mark(const char* name) const = 0;
-  virtual void rangePush(const char* name) const = 0;
-  virtual void rangePop() const = 0;
-  virtual bool enabled() const {
-    return false;
-  }
-  virtual void onEachDevice(std::function<void(int)> op) const = 0;
-  virtual void synchronize() const = 0;
-  virtual ~ProfilerStubs();
-};
-
-TORCH_API void registerCUDAMethods(ProfilerStubs* stubs);
-TORCH_API const ProfilerStubs* cudaStubs();
-TORCH_API void registerITTMethods(ProfilerStubs* stubs);
-TORCH_API const ProfilerStubs* ittStubs();
-TORCH_API void registerPrivateUse1Methods(ProfilerStubs* stubs);
-TORCH_API const ProfilerStubs* privateuse1Stubs();
-
-using vulkan_id_t = strong::type<
-    int64_t,
-    struct _VulkanID,
-    strong::regular,
-    strong::convertible_to<int64_t>,
-    strong::hashable>;
-
-} // namespace impl
-} // namespace profiler
-} // namespace torch

shared/package-files/9b/9b2e55e0f1d3df31cb2b442f6a712a427eb98c9e7f9cd572eae97fd301d14f5f/blob

@@ -1,140 +0,0 @@
-""" Functions related to graph covers."""
-
-from functools import partial
-from itertools import chain
-
-import networkx as nx
-from networkx.utils import arbitrary_element, not_implemented_for
-
-__all__ = ["min_edge_cover", "is_edge_cover"]
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-def min_edge_cover(G, matching_algorithm=None):
-    """Returns the min cardinality edge cover of the graph as a set of edges.
-
-    A smallest edge cover can be found in polynomial time by finding
-    a maximum matching and extending it greedily so that all nodes
-    are covered. This function follows that process. A maximum matching
-    algorithm can be specified for the first step of the algorithm.
-    The resulting set may return a set with one 2-tuple for each edge,
-    (the usual case) or with both 2-tuples `(u, v)` and `(v, u)` for
-    each edge. The latter is only done when a bipartite matching algorithm
-    is specified as `matching_algorithm`.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        An undirected graph.
-
-    matching_algorithm : function
-        A function that returns a maximum cardinality matching for `G`.
-        The function must take one input, the graph `G`, and return
-        either a set of edges (with only one direction for the pair of nodes)
-        or a dictionary mapping each node to its mate. If not specified,
-        :func:`~networkx.algorithms.matching.max_weight_matching` is used.
-        Common bipartite matching functions include
-        :func:`~networkx.algorithms.bipartite.matching.hopcroft_karp_matching`
-        or
-        :func:`~networkx.algorithms.bipartite.matching.eppstein_matching`.
-
-    Returns
-    -------
-    min_cover : set
-
-        A set of the edges in a minimum edge cover in the form of tuples.
-        It contains only one of the equivalent 2-tuples `(u, v)` and `(v, u)`
-        for each edge. If a bipartite method is used to compute the matching,
-        the returned set contains both the 2-tuples `(u, v)` and `(v, u)`
-        for each edge of a minimum edge cover.
-
-    Examples
-    --------
-    >>> G = nx.Graph([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3)])
-    >>> sorted(nx.min_edge_cover(G))
-    [(2, 1), (3, 0)]
-
-    Notes
-    -----
-    An edge cover of a graph is a set of edges such that every node of
-    the graph is incident to at least one edge of the set.
-    The minimum edge cover is an edge covering of smallest cardinality.
-
-    Due to its implementation, the worst-case running time of this algorithm
-    is bounded by the worst-case running time of the function
-    ``matching_algorithm``.
-
-    Minimum edge cover for `G` can also be found using the `min_edge_covering`
-    function in :mod:`networkx.algorithms.bipartite.covering` which is
-    simply this function with a default matching algorithm of
-    :func:`~networkx.algorithms.bipartite.matching.hopcraft_karp_matching`
-    """
-    if len(G) == 0:
-        return set()
-    if nx.number_of_isolates(G) > 0:
-        # ``min_cover`` does not exist as there is an isolated node
-        raise nx.NetworkXException(
-            "Graph has a node with no edge incident on it, " "so no edge cover exists."
-        )
-    if matching_algorithm is None:
-        matching_algorithm = partial(nx.max_weight_matching, maxcardinality=True)
-    maximum_matching = matching_algorithm(G)
-    # ``min_cover`` is superset of ``maximum_matching``
-    try:
-        # bipartite matching algs return dict so convert if needed
-        min_cover = set(maximum_matching.items())
-        bipartite_cover = True
-    except AttributeError:
-        min_cover = maximum_matching
-        bipartite_cover = False
-    # iterate for uncovered nodes
-    uncovered_nodes = set(G) - {v for u, v in min_cover} - {u for u, v in min_cover}
-    for v in uncovered_nodes:
-        # Since `v` is uncovered, each edge incident to `v` will join it
-        # with a covered node (otherwise, if there were an edge joining
-        # uncovered nodes `u` and `v`, the maximum matching algorithm
-        # would have found it), so we can choose an arbitrary edge
-        # incident to `v`. (This applies only in a simple graph, not a
-        # multigraph.)
-        u = arbitrary_element(G[v])
-        min_cover.add((u, v))
-        if bipartite_cover:
-            min_cover.add((v, u))
-    return min_cover
-
-
-@not_implemented_for("directed")
-def is_edge_cover(G, cover):
-    """Decides whether a set of edges is a valid edge cover of the graph.
-
-    Given a set of edges, whether it is an edge covering can
-    be decided if we just check whether all nodes of the graph
-    has an edge from the set, incident on it.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        An undirected bipartite graph.
-
-    cover : set
-        Set of edges to be checked.
-
-    Returns
-    -------
-    bool
-        Whether the set of edges is a valid edge cover of the graph.
-
-    Examples
-    --------
-    >>> G = nx.Graph([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3)])
-    >>> cover = {(2, 1), (3, 0)}
-    >>> nx.is_edge_cover(G, cover)
-    True
-
-    Notes
-    -----
-    An edge cover of a graph is a set of edges such that every node of
-    the graph is incident to at least one edge of the set.
-    """
-    return set(G) <= set(chain.from_iterable(cover))

shared/package-files/9b/9b2f91be34024fbcf645f6ef92460e5f944ca6a16268b79478ab904b2934d357/blob

@@ -1,52 +0,0 @@
-# created by tools/loadICU.tcl -- do not edit
-namespace eval ::tcl::clock {
-    ::msgcat::mcset el DAYS_OF_WEEK_ABBREV [list \
-        "\u039a\u03c5\u03c1"\
-        "\u0394\u03b5\u03c5"\
-        "\u03a4\u03c1\u03b9"\
-        "\u03a4\u03b5\u03c4"\
-        "\u03a0\u03b5\u03bc"\
-        "\u03a0\u03b1\u03c1"\
-        "\u03a3\u03b1\u03b2"]
-    ::msgcat::mcset el DAYS_OF_WEEK_FULL [list \
-        "\u039a\u03c5\u03c1\u03b9\u03b1\u03ba\u03ae"\
-        "\u0394\u03b5\u03c5\u03c4\u03ad\u03c1\u03b1"\
-        "\u03a4\u03c1\u03af\u03c4\u03b7"\
-        "\u03a4\u03b5\u03c4\u03ac\u03c1\u03c4\u03b7"\
-        "\u03a0\u03ad\u03bc\u03c0\u03c4\u03b7"\
-        "\u03a0\u03b1\u03c1\u03b1\u03c3\u03ba\u03b5\u03c5\u03ae"\
-        "\u03a3\u03ac\u03b2\u03b2\u03b1\u03c4\u03bf"]
-    ::msgcat::mcset el MONTHS_ABBREV [list \
-        "\u0399\u03b1\u03bd"\
-        "\u03a6\u03b5\u03b2"\
-        "\u039c\u03b1\u03c1"\
-        "\u0391\u03c0\u03c1"\
-        "\u039c\u03b1\u03ca"\
-        "\u0399\u03bf\u03c5\u03bd"\
-        "\u0399\u03bf\u03c5\u03bb"\
-        "\u0391\u03c5\u03b3"\
-        "\u03a3\u03b5\u03c0"\
-        "\u039f\u03ba\u03c4"\
-        "\u039d\u03bf\u03b5"\
-        "\u0394\u03b5\u03ba"\
-        ""]
-    ::msgcat::mcset el MONTHS_FULL [list \
-        "\u0399\u03b1\u03bd\u03bf\u03c5\u03ac\u03c1\u03b9\u03bf\u03c2"\
-        "\u03a6\u03b5\u03b2\u03c1\u03bf\u03c5\u03ac\u03c1\u03b9\u03bf\u03c2"\
-        "\u039c\u03ac\u03c1\u03c4\u03b9\u03bf\u03c2"\
-        "\u0391\u03c0\u03c1\u03af\u03bb\u03b9\u03bf\u03c2"\
-        "\u039c\u03ac\u03ca\u03bf\u03c2"\
-        "\u0399\u03bf\u03cd\u03bd\u03b9\u03bf\u03c2"\
-        "\u0399\u03bf\u03cd\u03bb\u03b9\u03bf\u03c2"\
-        "\u0391\u03cd\u03b3\u03bf\u03c5\u03c3\u03c4\u03bf\u03c2"\
-        "\u03a3\u03b5\u03c0\u03c4\u03ad\u03bc\u03b2\u03c1\u03b9\u03bf\u03c2"\
-        "\u039f\u03ba\u03c4\u03ce\u03b2\u03c1\u03b9\u03bf\u03c2"\
-        "\u039d\u03bf\u03ad\u03bc\u03b2\u03c1\u03b9\u03bf\u03c2"\
-        "\u0394\u03b5\u03ba\u03ad\u03bc\u03b2\u03c1\u03b9\u03bf\u03c2"\
-        ""]
-    ::msgcat::mcset el AM "\u03c0\u03bc"
-    ::msgcat::mcset el PM "\u03bc\u03bc"
-    ::msgcat::mcset el DATE_FORMAT "%e/%m/%Y"
-    ::msgcat::mcset el TIME_FORMAT_12 "%l:%M:%S %P"
-    ::msgcat::mcset el DATE_TIME_FORMAT "%e/%m/%Y %l:%M:%S %P %z"
-}

shared/package-files/9b/9b2ff15cb3d217ce7ef0b06547f16743aef6d5363072c505bff85d03e769596e/blob

@@ -1,360 +0,0 @@
-Metadata-Version: 2.1
-Name: pyOpenSSL
-Version: 24.0.0
-Summary: Python wrapper module around the OpenSSL library
-Home-page: https://pyopenssl.org/
-Author: The pyOpenSSL developers
-Author-email: cryptography-dev@python.org
-License: Apache License, Version 2.0
-Project-URL: Source, https://github.com/pyca/pyopenssl
-Classifier: Development Status :: 6 - Mature
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: MacOS :: MacOS X
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: POSIX
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Topic :: Security :: Cryptography
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: System :: Networking
-Requires-Python: >=3.7
-License-File: LICENSE
-Requires-Dist: cryptography <43,>=41.0.5
-Provides-Extra: docs
-Requires-Dist: sphinx !=5.2.0,!=5.2.0.post0,!=7.2.5 ; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
-Provides-Extra: test
-Requires-Dist: flaky ; extra == 'test'
-Requires-Dist: pretend ; extra == 'test'
-Requires-Dist: pytest >=3.0.1 ; extra == 'test'
-
-========================================================
-pyOpenSSL -- A Python wrapper around the OpenSSL library
-========================================================
-
-.. image:: https://readthedocs.org/projects/pyopenssl/badge/?version=stable
-   :target: https://pyopenssl.org/en/stable/
-   :alt: Stable Docs
-
-.. image:: https://github.com/pyca/pyopenssl/workflows/CI/badge.svg?branch=main
-   :target: https://github.com/pyca/pyopenssl/actions?query=workflow%3ACI+branch%3Amain
-
-.. image:: https://codecov.io/github/pyca/pyopenssl/branch/main/graph/badge.svg
-   :target: https://codecov.io/github/pyca/pyopenssl
-   :alt: Test coverage
-
-**Note:** The Python Cryptographic Authority **strongly suggests** the use of `pyca/cryptography`_
-where possible. If you are using pyOpenSSL for anything other than making a TLS connection
-**you should move to cryptography and drop your pyOpenSSL dependency**.
-
-High-level wrapper around a subset of the OpenSSL library. Includes
-
-* ``SSL.Connection`` objects, wrapping the methods of Python's portable sockets
-* Callbacks written in Python
-* Extensive error-handling mechanism, mirroring OpenSSL's error codes
-
-... and much more.
-
-You can find more information in the documentation_.
-Development takes place on GitHub_.
-
-
-Discussion
-==========
-
-If you run into bugs, you can file them in our `issue tracker`_.
-
-We maintain a cryptography-dev_ mailing list for both user and development discussions.
-
-You can also join ``#pyca`` on ``irc.libera.chat`` to ask questions or get involved.
-
-
-.. _documentation: https://pyopenssl.org/
-.. _`issue tracker`: https://github.com/pyca/pyopenssl/issues
-.. _cryptography-dev: https://mail.python.org/mailman/listinfo/cryptography-dev
-.. _GitHub: https://github.com/pyca/pyopenssl
-.. _`pyca/cryptography`: https://github.com/pyca/cryptography
-
-
-Release Information
-===================
-
-24.0.0 (2024-01-22)
--------------------
-
-Backward-incompatible changes:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Deprecations:
-^^^^^^^^^^^^^
-
-Changes:
-^^^^^^^^
-
-- Added ``OpenSSL.SSL.Connection.get_selected_srtp_profile`` to determine which SRTP profile was negotiated.
-  `#1279 <https://github.com/pyca/pyopenssl/pull/1279>`_.
-
-23.3.0 (2023-10-25)
--------------------
-
-Backward-incompatible changes:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-- Dropped support for Python 3.6.
-- The minimum ``cryptography`` version is now 41.0.5.
-- Removed ``OpenSSL.crypto.loads_pkcs7`` and ``OpenSSL.crypto.loads_pkcs12`` which had been deprecated for 3 years.
-- Added ``OpenSSL.SSL.OP_LEGACY_SERVER_CONNECT`` to allow legacy insecure renegotiation between OpenSSL and unpatched servers.
-  `#1234 <https://github.com/pyca/pyopenssl/pull/1234>`_.
-
-Deprecations:
-^^^^^^^^^^^^^
-
-- Deprecated ``OpenSSL.crypto.PKCS12`` (which was intended to have been deprecated at the same time as ``OpenSSL.crypto.load_pkcs12``).
-- Deprecated ``OpenSSL.crypto.NetscapeSPKI``.
-- Deprecated ``OpenSSL.crypto.CRL``
-- Deprecated ``OpenSSL.crypto.Revoked``
-- Deprecated ``OpenSSL.crypto.load_crl`` and ``OpenSSL.crypto.dump_crl``
-- Deprecated ``OpenSSL.crypto.sign`` and ``OpenSSL.crypto.verify``
-- Deprecated ``OpenSSL.crypto.X509Extension``
-
-Changes:
-^^^^^^^^
-
-- Changed ``OpenSSL.crypto.X509Store.add_crl`` to also accept
-  ``cryptography``'s ``x509.CertificateRevocationList`` arguments in addition
-  to the now deprecated ``OpenSSL.crypto.CRL`` arguments.
-- Fixed ``test_set_default_verify_paths`` test so that it is skipped if no
-  network connection is available.
-
-23.2.0 (2023-05-30)
--------------------
-
-Backward-incompatible changes:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-- Removed ``X509StoreFlags.NOTIFY_POLICY``.
-  `#1213 <https://github.com/pyca/pyopenssl/pull/1213>`_.
-
-Deprecations:
-^^^^^^^^^^^^^
-
-Changes:
-^^^^^^^^
-
-- ``cryptography`` maximum version has been increased to 41.0.x.
-- Invalid versions are now rejected in ``OpenSSL.crypto.X509Req.set_version``.
-- Added ``X509VerificationCodes`` to ``OpenSSL.SSL``.
-  `#1202 <https://github.com/pyca/pyopenssl/pull/1202>`_.
-
-23.1.1 (2023-03-28)
--------------------
-
-Backward-incompatible changes:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Deprecations:
-^^^^^^^^^^^^^
-
-Changes:
-^^^^^^^^
-
-- Worked around an issue in OpenSSL 3.1.0 which caused `X509Extension.get_short_name` to raise an exception when no short name was known to OpenSSL.
-  `#1204 <https://github.com/pyca/pyopenssl/pull/1204>`_.
-
-23.1.0 (2023-03-24)
--------------------
-
-Backward-incompatible changes:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Deprecations:
-^^^^^^^^^^^^^
-
-Changes:
-^^^^^^^^
-
-- ``cryptography`` maximum version has been increased to 40.0.x.
-- Add ``OpenSSL.SSL.Connection.DTLSv1_get_timeout`` and ``OpenSSL.SSL.Connection.DTLSv1_handle_timeout``
-  to support DTLS timeouts `#1180 <https://github.com/pyca/pyopenssl/pull/1180>`_.
-
-23.0.0 (2023-01-01)
--------------------
-
-Backward-incompatible changes:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Deprecations:
-^^^^^^^^^^^^^
-
-Changes:
-^^^^^^^^
-
-- Add ``OpenSSL.SSL.X509StoreFlags.PARTIAL_CHAIN`` constant to allow for users
-  to perform certificate verification on partial certificate chains.
-  `#1166 <https://github.com/pyca/pyopenssl/pull/1166>`_
-- ``cryptography`` maximum version has been increased to 39.0.x.
-
-22.1.0 (2022-09-25)
--------------------
-
-Backward-incompatible changes:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-- Remove support for SSLv2 and SSLv3.
-- The minimum ``cryptography`` version is now 38.0.x (and we now pin releases
-  against ``cryptography`` major versions to prevent future breakage)
-- The ``OpenSSL.crypto.X509StoreContextError`` exception has been refactored,
-  changing its internal attributes.
-  `#1133 <https://github.com/pyca/pyopenssl/pull/1133>`_
-
-Deprecations:
-^^^^^^^^^^^^^
-
-- ``OpenSSL.SSL.SSLeay_version`` is deprecated in favor of
-  ``OpenSSL.SSL.OpenSSL_version``. The constants ``OpenSSL.SSL.SSLEAY_*`` are
-  deprecated in favor of ``OpenSSL.SSL.OPENSSL_*``.
-
-Changes:
-^^^^^^^^
-
-- Add ``OpenSSL.SSL.Connection.set_verify`` and ``OpenSSL.SSL.Connection.get_verify_mode``
-  to override the context object's verification flags.
-  `#1073 <https://github.com/pyca/pyopenssl/pull/1073>`_
-- Add ``OpenSSL.SSL.Connection.use_certificate`` and ``OpenSSL.SSL.Connection.use_privatekey``
-  to set a certificate per connection (and not just per context) `#1121 <https://github.com/pyca/pyopenssl/pull/1121>`_.
-
-22.0.0 (2022-01-29)
--------------------
-
-Backward-incompatible changes:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-- Drop support for Python 2.7.
-  `#1047 <https://github.com/pyca/pyopenssl/pull/1047>`_
-- The minimum ``cryptography`` version is now 35.0.
-
-Deprecations:
-^^^^^^^^^^^^^
-
-Changes:
-^^^^^^^^
-
-- Expose wrappers for some `DTLS
-  <https://en.wikipedia.org/wiki/Datagram_Transport_Layer_Security>`_
-  primitives. `#1026 <https://github.com/pyca/pyopenssl/pull/1026>`_
-
-21.0.0 (2021-09-28)
--------------------
-
-Backward-incompatible changes:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-- The minimum ``cryptography`` version is now 3.3.
-- Drop support for Python 3.5
-
-Deprecations:
-^^^^^^^^^^^^^
-
-Changes:
-^^^^^^^^
-
-- Raise an error when an invalid ALPN value is set.
-  `#993 <https://github.com/pyca/pyopenssl/pull/993>`_
-- Added ``OpenSSL.SSL.Context.set_min_proto_version`` and ``OpenSSL.SSL.Context.set_max_proto_version``
-  to set the minimum and maximum supported TLS version `#985 <https://github.com/pyca/pyopenssl/pull/985>`_.
-- Updated ``to_cryptography`` and ``from_cryptography`` methods to support an upcoming release of ``cryptography`` without raising deprecation warnings.
-  `#1030 <https://github.com/pyca/pyopenssl/pull/1030>`_
-
-20.0.1 (2020-12-15)
--------------------
-
-Backward-incompatible changes:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Deprecations:
-^^^^^^^^^^^^^
-
-Changes:
-^^^^^^^^
-
-- Fixed compatibility with OpenSSL 1.1.0.
-
-20.0.0 (2020-11-27)
--------------------
-
-
-Backward-incompatible changes:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-- The minimum ``cryptography`` version is now 3.2.
-- Remove deprecated ``OpenSSL.tsafe`` module.
-- Removed deprecated ``OpenSSL.SSL.Context.set_npn_advertise_callback``, ``OpenSSL.SSL.Context.set_npn_select_callback``, and ``OpenSSL.SSL.Connection.get_next_proto_negotiated``.
-- Drop support for Python 3.4
-- Drop support for OpenSSL 1.0.1 and 1.0.2
-
-Deprecations:
-^^^^^^^^^^^^^
-
-- Deprecated ``OpenSSL.crypto.loads_pkcs7`` and ``OpenSSL.crypto.loads_pkcs12``.
-
-Changes:
-^^^^^^^^
-
-- Added a new optional ``chain`` parameter to ``OpenSSL.crypto.X509StoreContext()``
-  where additional untrusted certificates can be specified to help chain building.
-  `#948 <https://github.com/pyca/pyopenssl/pull/948>`_
-- Added ``OpenSSL.crypto.X509Store.load_locations`` to set trusted
-  certificate file bundles and/or directories for verification.
-  `#943 <https://github.com/pyca/pyopenssl/pull/943>`_
-- Added ``Context.set_keylog_callback`` to log key material.
-  `#910 <https://github.com/pyca/pyopenssl/pull/910>`_
-- Added ``OpenSSL.SSL.Connection.get_verified_chain`` to retrieve the
-  verified certificate chain of the peer.
-  `#894 <https://github.com/pyca/pyopenssl/pull/894>`_.
-- Make verification callback optional in ``Context.set_verify``.
-  If omitted, OpenSSL's default verification is used.
-  `#933 <https://github.com/pyca/pyopenssl/pull/933>`_
-- Fixed a bug that could truncate or cause a zero-length key error due to a
-  null byte in private key passphrase in ``OpenSSL.crypto.load_privatekey``
-  and ``OpenSSL.crypto.dump_privatekey``.
-  `#947 <https://github.com/pyca/pyopenssl/pull/947>`_
-
-19.1.0 (2019-11-18)
--------------------
-
-
-Backward-incompatible changes:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-- Removed deprecated ``ContextType``, ``ConnectionType``, ``PKeyType``, ``X509NameType``, ``X509ReqType``, ``X509Type``, ``X509StoreType``, ``CRLType``, ``PKCS7Type``, ``PKCS12Type``, and ``NetscapeSPKIType`` aliases.
-  Use the classes without the ``Type`` suffix instead.
-  `#814 <https://github.com/pyca/pyopenssl/pull/814>`_
-- The minimum ``cryptography`` version is now 2.8 due to issues on macOS with a transitive dependency.
-  `#875 <https://github.com/pyca/pyopenssl/pull/875>`_
-
-Deprecations:
-^^^^^^^^^^^^^
-
-- Deprecated ``OpenSSL.SSL.Context.set_npn_advertise_callback``, ``OpenSSL.SSL.Context.set_npn_select_callback``, and ``OpenSSL.SSL.Connection.get_next_proto_negotiated``.
-  ALPN should be used instead.
-  `#820 <https://github.com/pyca/pyopenssl/pull/820>`_
-
-
-Changes:
-^^^^^^^^
-
-- Support ``bytearray`` in ``SSL.Connection.send()`` by using cffi's from_buffer.
-  `#852 <https://github.com/pyca/pyopenssl/pull/852>`_
-- The ``OpenSSL.SSL.Context.set_alpn_select_callback`` can return a new ``NO_OVERLAPPING_PROTOCOLS`` sentinel value
-  to allow a TLS handshake to complete without an application protocol.
-
-`Full changelog <https://pyopenssl.org/en/stable/changelog.html>`_.
-

shared/package-files/9b/9b34108030dba74e01d372b226ba2cb0ba7c62aef6449ce3a7edc0adf8db307f/blob

@@ -1,188 +0,0 @@
-try:
-    from ctypes import c_float, c_int, c_double
-except ImportError:
-    pass
-
-import pyglet.gl as pgl
-from sympy.core import S
-
-
-def get_model_matrix(array_type=c_float, glGetMethod=pgl.glGetFloatv):
-    """
-    Returns the current modelview matrix.
-    """
-    m = (array_type*16)()
-    glGetMethod(pgl.GL_MODELVIEW_MATRIX, m)
-    return m
-
-
-def get_projection_matrix(array_type=c_float, glGetMethod=pgl.glGetFloatv):
-    """
-    Returns the current modelview matrix.
-    """
-    m = (array_type*16)()
-    glGetMethod(pgl.GL_PROJECTION_MATRIX, m)
-    return m
-
-
-def get_viewport():
-    """
-    Returns the current viewport.
-    """
-    m = (c_int*4)()
-    pgl.glGetIntegerv(pgl.GL_VIEWPORT, m)
-    return m
-
-
-def get_direction_vectors():
-    m = get_model_matrix()
-    return ((m[0], m[4], m[8]),
-            (m[1], m[5], m[9]),
-            (m[2], m[6], m[10]))
-
-
-def get_view_direction_vectors():
-    m = get_model_matrix()
-    return ((m[0], m[1], m[2]),
-            (m[4], m[5], m[6]),
-            (m[8], m[9], m[10]))
-
-
-def get_basis_vectors():
-    return ((1, 0, 0), (0, 1, 0), (0, 0, 1))
-
-
-def screen_to_model(x, y, z):
-    m = get_model_matrix(c_double, pgl.glGetDoublev)
-    p = get_projection_matrix(c_double, pgl.glGetDoublev)
-    w = get_viewport()
-    mx, my, mz = c_double(), c_double(), c_double()
-    pgl.gluUnProject(x, y, z, m, p, w, mx, my, mz)
-    return float(mx.value), float(my.value), float(mz.value)
-
-
-def model_to_screen(x, y, z):
-    m = get_model_matrix(c_double, pgl.glGetDoublev)
-    p = get_projection_matrix(c_double, pgl.glGetDoublev)
-    w = get_viewport()
-    mx, my, mz = c_double(), c_double(), c_double()
-    pgl.gluProject(x, y, z, m, p, w, mx, my, mz)
-    return float(mx.value), float(my.value), float(mz.value)
-
-
-def vec_subs(a, b):
-    return tuple(a[i] - b[i] for i in range(len(a)))
-
-
-def billboard_matrix():
-    """
-    Removes rotational components of
-    current matrix so that primitives
-    are always drawn facing the viewer.
-
-    |1|0|0|x|
-    |0|1|0|x|
-    |0|0|1|x| (x means left unchanged)
-    |x|x|x|x|
-    """
-    m = get_model_matrix()
-    # XXX: for i in range(11): m[i] = i ?
-    m[0] = 1
-    m[1] = 0
-    m[2] = 0
-    m[4] = 0
-    m[5] = 1
-    m[6] = 0
-    m[8] = 0
-    m[9] = 0
-    m[10] = 1
-    pgl.glLoadMatrixf(m)
-
-
-def create_bounds():
-    return [[S.Infinity, S.NegativeInfinity, 0],
-            [S.Infinity, S.NegativeInfinity, 0],
-            [S.Infinity, S.NegativeInfinity, 0]]
-
-
-def update_bounds(b, v):
-    if v is None:
-        return
-    for axis in range(3):
-        b[axis][0] = min([b[axis][0], v[axis]])
-        b[axis][1] = max([b[axis][1], v[axis]])
-
-
-def interpolate(a_min, a_max, a_ratio):
-    return a_min + a_ratio * (a_max - a_min)
-
-
-def rinterpolate(a_min, a_max, a_value):
-    a_range = a_max - a_min
-    if a_max == a_min:
-        a_range = 1.0
-    return (a_value - a_min) / float(a_range)
-
-
-def interpolate_color(color1, color2, ratio):
-    return tuple(interpolate(color1[i], color2[i], ratio) for i in range(3))
-
-
-def scale_value(v, v_min, v_len):
-    return (v - v_min) / v_len
-
-
-def scale_value_list(flist):
-    v_min, v_max = min(flist), max(flist)
-    v_len = v_max - v_min
-    return [scale_value(f, v_min, v_len) for f in flist]
-
-
-def strided_range(r_min, r_max, stride, max_steps=50):
-    o_min, o_max = r_min, r_max
-    if abs(r_min - r_max) < 0.001:
-        return []
-    try:
-        range(int(r_min - r_max))
-    except (TypeError, OverflowError):
-        return []
-    if r_min > r_max:
-        raise ValueError("r_min cannot be greater than r_max")
-    r_min_s = (r_min % stride)
-    r_max_s = stride - (r_max % stride)
-    if abs(r_max_s - stride) < 0.001:
-        r_max_s = 0.0
-    r_min -= r_min_s
-    r_max += r_max_s
-    r_steps = int((r_max - r_min)/stride)
-    if max_steps and r_steps > max_steps:
-        return strided_range(o_min, o_max, stride*2)
-    return [r_min] + [r_min + e*stride for e in range(1, r_steps + 1)] + [r_max]
-
-
-def parse_option_string(s):
-    if not isinstance(s, str):
-        return None
-    options = {}
-    for token in s.split(';'):
-        pieces = token.split('=')
-        if len(pieces) == 1:
-            option, value = pieces[0], ""
-        elif len(pieces) == 2:
-            option, value = pieces
-        else:
-            raise ValueError("Plot option string '%s' is malformed." % (s))
-        options[option.strip()] = value.strip()
-    return options
-
-
-def dot_product(v1, v2):
-    return sum(v1[i]*v2[i] for i in range(3))
-
-
-def vec_sub(v1, v2):
-    return tuple(v1[i] - v2[i] for i in range(3))
-
-
-def vec_mag(v):
-    return sum(v[i]**2 for i in range(3))**(0.5)

shared/package-files/9b/9b3bb70cade8184ee8eca3239aa7e6762ad6be906e15e8ea42ed5629b8abdafa/blob

@@ -1,200 +0,0 @@
-/* Translated from Cython into C++ by SciPy developers in 2024.
- * Original header with Copyright information appears below.
- */
-
-/* Implementation of sin/cos/sinh/cosh integrals for complex arguments
- *
- * Sources
- * [1] Fredrik Johansson and others. mpmath: a Python library for
- *     arbitrary-precision floating-point arithmetic (version 0.19),
- *     December 2013. http://mpmath.org/.
- * [2] NIST, "Digital Library of Mathematical Functions",
- *     https://dlmf.nist.gov/
- */
-
-#pragma once
-
-#include "config.h"
-#include "error.h"
-
-#include "expint.h"
-#include "cephes/const.h"
-#include "cephes/sici.h"
-#include "cephes/shichi.h"
-
-namespace xsf {
-namespace detail {
-    
-    XSF_HOST_DEVICE inline void sici_power_series(int sgn, std::complex<double> z,
-						       std::complex<double> *s, std::complex<double> *c) {
-	/* DLMF 6.6.5 and 6.6.6. If sgn = -1 computes si/ci, and if sgn = 1
-	 * computes shi/chi.
-	 */        
-	std::complex<double> fac = z;
-	*s = fac;
-	*c = 0;
-	std::complex<double> term1, term2;
-	for (int n = 1; n < 100; n++) {
-	    fac *= static_cast<double>(sgn)*z/(2.0*n);
-	    term2 = fac/(2.0*n);
-	    *c += term2;
-	    fac *= z/(2.0*n + 1.0);
-	    term1 = fac/(2.0*n + 1.0);
-	    *s += term1;
-	    constexpr double tol = std::numeric_limits<double>::epsilon();
-	    if (std::abs(term1) < tol*std::abs(*s) && std::abs(term2) < tol*std::abs(*c)) {
-		break;
-	    }
-	}
-    }
-
-}
-
-    
-XSF_HOST_DEVICE inline int sici(std::complex<double> z,
-				    std::complex<double> *si, std::complex<double> *ci) {
-    /* Compute sin/cos integrals at complex arguments. The algorithm
-     * largely follows that of [1].
-     */
-
-    constexpr double EULER = xsf::cephes::detail::SCIPY_EULER;
-
-    if (z == std::numeric_limits<double>::infinity()) {
-        *si = M_PI_2;
-        *ci = 0;
-        return 0;
-    }
-    if (z == -std::numeric_limits<double>::infinity()) {
-	*si = -M_PI_2;
-        *ci = {0.0, M_PI};
-        return 0;
-    }
-
-    if (std::abs(z) < 0.8) {
-        // Use the series to avoid cancellation in si
-	detail::sici_power_series(-1, z, si, ci);
-
-        if (z == 0.0) {
-            set_error("sici", SF_ERROR_DOMAIN, NULL);
-            *ci = {-std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()};
-        } else {
-            *ci += EULER + std::log(z);
-	}
-        return 0;
-    }
-    
-    // DLMF 6.5.5/6.5.6 plus DLMF 6.4.4/6.4.6/6.4.7
-    std::complex<double> jz = std::complex<double>(0.0, 1.0) * z;
-    std::complex<double> term1 = expi(jz);
-    std::complex<double> term2 = expi(-jz);
-    *si = std::complex<double>(0.0, -0.5)*(term1 - term2);
-    *ci = 0.5*(term1 + term2);
-    if (z.real() == 0) {
-        if (z.imag() > 0) {
-            *ci += std::complex<double>(0.0, M_PI_2);
-	} else if (z.imag() < 0) {
-            *ci -= std::complex<double>(0.0, M_PI_2);
-	}
-    } else if (z.real() > 0) {
-        *si -= M_PI_2;
-    } else {
-        *si += M_PI_2;
-        if (z.imag() >= 0) {
-            *ci += std::complex<double>(0.0, M_PI);
-        } else {
-            *ci -= std::complex<double>(0.0, M_PI);
-	}
-    }
-    return 0;
-}
-
-XSF_HOST_DEVICE inline int sici(std::complex<float> z,
-				    std::complex<float> *si_f, std::complex<float> *ci_f) {
-    std::complex<double> si;
-    std::complex<double> ci;
-    int res = sici(z, &si, &ci);
-    *si_f = si;
-    *ci_f = ci;
-    return res;
-}
-
-XSF_HOST_DEVICE inline int shichi(std::complex<double> z,
-				       std::complex<double> *shi, std::complex<double> *chi) {
-    /* Compute sinh/cosh integrals at complex arguments. The algorithm
-     * largely follows that of [1].
-     */
-    constexpr double EULER = xsf::cephes::detail::SCIPY_EULER;
-    if (z == std::numeric_limits<double>::infinity()) {
-        *shi = std::numeric_limits<double>::infinity();
-        *chi = std::numeric_limits<double>::infinity();
-        return 0;
-    }
-    if (z == -std::numeric_limits<double>::infinity()) {
-        *shi = -std::numeric_limits<double>::infinity();
-        *chi = std::numeric_limits<double>::infinity();
-        return 0;
-    }
-    if (std::abs(z) < 0.8) {
-        // Use the series to avoid cancellation in shi
-	detail::sici_power_series(1, z, shi, chi);
-        if (z == 0.0) {
-            set_error("shichi", SF_ERROR_DOMAIN, NULL);
-            *chi = {-std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()};
-        } else {
-            *chi += EULER + std::log(z);
-	}
-	return 0;
-    }
-
-    std::complex<double> term1 = expi(z);
-    std::complex<double> term2 = expi(-z);
-    *shi = 0.5*(term1 - term2);
-    *chi = 0.5*(term1 + term2);
-    if (z.imag() > 0) {
-        *shi -= std::complex<double>(0.0, 0.5*M_PI);
-        *chi += std::complex<double>(0.0, 0.5*M_PI);
-    } else if (z.imag() < 0) {
-        *shi += std::complex<double>(0.0, 0.5*M_PI);
-        *chi -= std::complex<double>(0.0, 0.5*M_PI);
-    } else if (z.real() < 0) {
-        *chi += std::complex<double>(0.0, M_PI);
-    }
-    return 0;
-}
-
-XSF_HOST_DEVICE inline int shichi(std::complex<float> z,
-				    std::complex<float> *shi_f, std::complex<float> *chi_f) {
-    std::complex<double> shi;
-    std::complex<double> chi;
-    int res = shichi(z, &shi, &chi);
-    *shi_f = shi;
-    *chi_f = chi;
-    return res;
-}
-
-XSF_HOST_DEVICE inline int sici(double x, double *si, double *ci) {
-    return cephes::sici(x, si, ci);
-}
-
-XSF_HOST_DEVICE inline int shichi(double x, double *shi, double *chi) {
-    return cephes::shichi(x, shi, chi);
-}
-
-XSF_HOST_DEVICE inline int sici(float x, float *si_f, float *ci_f) {
-    double si;
-    double ci;
-    int res = cephes::sici(x, &si, &ci);
-    *si_f = si;
-    *ci_f = ci;
-    return res;
-}
-
-XSF_HOST_DEVICE inline int shichi(float x, float *shi_f, float *chi_f) {
-    double shi;
-    double chi;
-    int res = cephes::shichi(x, &shi, &chi);
-    *shi_f = shi;
-    *chi_f = chi;
-    return res;
-}
-}

shared/package-files/9b/9b3e92596047cab99a939229b56d656a7862d617eacf9291d7fa6f6c95f80e36/blob

@@ -1,570 +0,0 @@
-from collections import defaultdict
-
-import numpy as np
-
-import statsmodels.base.model as base
-import statsmodels.base.wrapper as wrap
-from statsmodels.formula.formulatools import advance_eval_env
-from statsmodels.genmod import families
-from statsmodels.genmod.families import links, varfuncs
-from statsmodels.genmod.generalized_linear_model import GLM
-import statsmodels.regression.linear_model as lm
-from statsmodels.tools._decorators import cache_readonly
-
-
-class QIFCovariance:
-    """
-    A covariance model for quadratic inference function regression.
-
-    The mat method returns a basis matrix B such that the inverse
-    of the working covariance lies in the linear span of the
-    basis matrices.
-
-    Subclasses should set the number of basis matrices `num_terms`,
-    so that `mat(d, j)` for j=0, ..., num_terms-1 gives the basis
-    of dimension d.
-    """
-
-    def mat(self, dim, term):
-        """
-        Returns the term'th basis matrix, which is a dim x dim
-        matrix.
-
-        Parameters
-        ----------
-        dim : int
-            The dimension of the basis matrix.
-        term : int
-            The index of the basis matrix to return, ranging from 0
-            to `num_terms` - 1.
-
-        Returns
-        -------
-        ndarray or None
-            The dim x dim basis matrix for `term`, or None if `term`
-            is greater than or equal to `num_terms`.
-        """
-        raise NotImplementedError
-
-
-class QIFIndependence(QIFCovariance):
-    """
-    Independent working covariance for QIF regression.  This covariance
-    model gives identical results to GEE with the independence working
-    covariance.  When using QIFIndependence as the working covariance,
-    the QIF value will be zero, and cannot be used for chi^2 testing, or
-    for model selection using AIC, BIC, etc.
-    """
-
-    def __init__(self):
-        self.num_terms = 1
-
-    def mat(self, dim, term):
-        if term == 0:
-            return np.eye(dim)
-        else:
-            return None
-
-
-class QIFExchangeable(QIFCovariance):
-    """
-    Exchangeable working covariance for QIF regression.
-    """
-
-    def __init__(self):
-        self.num_terms = 2
-
-    def mat(self, dim, term):
-        if term == 0:
-            return np.eye(dim)
-        elif term == 1:
-            return np.ones((dim, dim))
-        else:
-            return None
-
-
-class QIFAutoregressive(QIFCovariance):
-    """
-    Autoregressive working covariance for QIF regression.
-    """
-
-    def __init__(self):
-        self.num_terms = 3
-
-    def mat(self, dim, term):
-
-        if dim < 3:
-            msg = ("Groups must have size at least 3 for "
-                   "autoregressive covariance.")
-            raise ValueError(msg)
-
-        if term == 0:
-            return np.eye(dim)
-        elif term == 1:
-            mat = np.zeros((dim, dim))
-            mat.flat[1::(dim+1)] = 1
-            mat += mat.T
-            return mat
-        elif term == 2:
-            mat = np.zeros((dim, dim))
-            mat[0, 0] = 1
-            mat[dim-1, dim-1] = 1
-            return mat
-        else:
-            return None
-
-
-class QIF(base.Model):
-    """
-    Fit a regression model using quadratic inference functions (QIF).
-
-    QIF is an alternative to GEE that can be more efficient, and that
-    offers different approaches for model selection and inference.
-
-    Parameters
-    ----------
-    endog : array_like
-        The dependent variables of the regression.
-    exog : array_like
-        The independent variables of the regression.
-    groups : array_like
-        Labels indicating which group each observation belongs to.
-        Observations in different groups should be independent.
-    family : genmod family, optional
-        An instance of a GLM family. The default is Gaussian.
-    cov_struct : QIFCovariance instance, optional
-        An instance of a QIFCovariance. The default is
-        QIFIndependence.
-    missing : str, optional
-        Available options are 'none', 'drop', and 'raise'. If 'none', no nan
-        checking is done. If 'drop', any observations with nans are dropped.
-        If 'raise', an error is raised.
-
-    References
-    ----------
-    A. Qu, B. Lindsay, B. Li (2000).  Improving Generalized Estimating
-    Equations using Quadratic Inference Functions, Biometrika 87:4.
-    www.jstor.org/stable/2673612
-    """
-
-    def __init__(self, endog, exog, groups, family=None,
-                 cov_struct=None, missing="none", **kwargs):
-
-        # Handle the family argument
-        if family is None:
-            family = families.Gaussian()
-        elif not issubclass(family.__class__, families.Family):
-            raise ValueError("QIF: `family` must be a genmod "
-                             "family instance")
-        self.family = family
-
-        self._fit_history = defaultdict(list)
-
-        # Handle the cov_struct argument
-        if cov_struct is None:
-            cov_struct = QIFIndependence()
-        elif not isinstance(cov_struct, QIFCovariance):
-            raise ValueError(
-                "QIF: `cov_struct` must be a QIFCovariance instance")
-        self.cov_struct = cov_struct
-
-        groups = np.asarray(groups)
-
-        super().__init__(endog, exog, groups=groups,
-                         missing=missing, **kwargs)
-
-        self.group_names = list(set(groups))
-        self.nobs = len(self.endog)
-
-        groups_ix = defaultdict(list)
-        for i, g in enumerate(groups):
-            groups_ix[g].append(i)
-        self.groups_ix = [groups_ix[na] for na in self.group_names]
-
-        self._check_args(groups)
-
-    def _check_args(self, groups):
-
-        if len(groups) != len(self.endog):
-            msg = "QIF: groups and endog should have the same length"
-            raise ValueError(msg)
-
-        if len(self.endog) != self.exog.shape[0]:
-            msg = ("QIF: the length of endog should be equal to the "
-                   "number of rows of exog.")
-            raise ValueError(msg)
-
-    def objective(self, params):
-        """
-        Calculate the QIF objective function and its gradient.
-
-        Parameters
-        ----------
-        params : array_like
-            The model parameters at which the objective function and
-            its gradient are evaluated.
-
-        Returns
-        -------
-        qif : float
-            The value of the QIF objective function.
-        grad : ndarray
-            The gradient vector of the QIF objective function.
-        cmat : ndarray
-            The estimated covariance matrix of the estimating
-            equations.
-        gn : ndarray
-            The moment vector, i.e., the average of the estimating
-            equations over the groups.
-        gn_deriv : ndarray
-            The gradients of each estimating equation with
-            respect to the parameter.
-        """
-
-        endog = self.endog
-        exog = self.exog
-        lpr = np.dot(exog, params)
-        mean = self.family.link.inverse(lpr)
-        va = self.family.variance(mean)
-
-        # Mean derivative
-        idl = self.family.link.inverse_deriv(lpr)
-        idl2 = self.family.link.inverse_deriv2(lpr)
-        vd = self.family.variance.deriv(mean)
-
-        m = self.cov_struct.num_terms
-        p = exog.shape[1]
-
-        d = p * m
-        gn = np.zeros(d)
-        gi = np.zeros(d)
-        gi_deriv = np.zeros((d, p))
-        gn_deriv = np.zeros((d, p))
-        cn_deriv = [0] * p
-        cmat = np.zeros((d, d))
-
-        fastvar = self.family.variance is varfuncs.constant
-        fastlink = isinstance(
-            self.family.link,
-            # TODO: Remove links.identity after deprecation final
-            (links.Identity, links.identity)
-        )
-
-        for ix in self.groups_ix:
-            sd = np.sqrt(va[ix])
-            resid = endog[ix] - mean[ix]
-            sresid = resid / sd
-            deriv = exog[ix, :] * idl[ix, None]
-
-            jj = 0
-            for j in range(m):
-                # The derivative of each term in (5) of Qu et al.
-                # There are four terms involving beta in a product.
-                # Iterated application of the product rule gives
-                # the gradient as a sum of four terms.
-                c = self.cov_struct.mat(len(ix), j)
-                crs1 = np.dot(c, sresid) / sd
-                gi[jj:jj+p] = np.dot(deriv.T, crs1)
-                crs2 = np.dot(c, -deriv / sd[:, None]) / sd[:, None]
-                gi_deriv[jj:jj+p, :] = np.dot(deriv.T, crs2)
-                if not (fastlink and fastvar):
-                    for k in range(p):
-                        m1 = np.dot(exog[ix, :].T,
-                                    idl2[ix] * exog[ix, k] * crs1)
-                        if not fastvar:
-                            vx = -0.5 * vd[ix] * deriv[:, k] / va[ix]**1.5
-                            m2 = np.dot(deriv.T, vx * np.dot(c, sresid))
-                            m3 = np.dot(deriv.T, np.dot(c, vx * resid) / sd)
-                        else:
-                            m2, m3 = 0, 0
-                        gi_deriv[jj:jj+p, k] += m1 + m2 + m3
-                jj += p
-
-            for j in range(p):
-                u = np.outer(gi, gi_deriv[:, j])
-                cn_deriv[j] += u + u.T
-
-            gn += gi
-            gn_deriv += gi_deriv
-
-            cmat += np.outer(gi, gi)
-
-        ngrp = len(self.groups_ix)
-        gn /= ngrp
-        gn_deriv /= ngrp
-        cmat /= ngrp**2
-
-        qif = np.dot(gn, np.linalg.solve(cmat, gn))
-
-        gcg = np.zeros(p)
-        for j in range(p):
-            cn_deriv[j] /= len(self.groups_ix)**2
-            u = np.linalg.solve(cmat, cn_deriv[j]).T
-            u = np.linalg.solve(cmat, u)
-            gcg[j] = np.dot(gn, np.dot(u, gn))
-
-        grad = 2 * np.dot(gn_deriv.T, np.linalg.solve(cmat, gn)) - gcg
-
-        return qif, grad, cmat, gn, gn_deriv
-
-    def estimate_scale(self, params):
-        """
-        Estimate the dispersion/scale.
-
-        The scale parameter for binomial and Poisson families is
-        fixed at 1, otherwise it is estimated from the data.
-
-        Parameters
-        ----------
-        params : array_like
-            The regression coefficients at which the scale is
-            estimated.
-
-        Returns
-        -------
-        float
-            The estimated scale parameter.
-        """
-
-        if isinstance(self.family, (families.Binomial, families.Poisson)):
-            return 1.
-
-        if hasattr(self, "ddof_scale"):
-            ddof_scale = self.ddof_scale
-        else:
-            ddof_scale = self.exog[1]
-
-        lpr = np.dot(self.exog, params)
-        mean = self.family.link.inverse(lpr)
-        resid = self.endog - mean
-        scale = np.sum(resid**2) / (self.nobs - ddof_scale)
-
-        return scale
-
-    @classmethod
-    def from_formula(cls, formula, groups, data, subset=None,
-                     *args, **kwargs):
-        """
-        Create a QIF model instance from a formula and dataframe.
-
-        Parameters
-        ----------
-        formula : str or generic Formula object
-            The formula specifying the model
-        groups : array_like or str
-            Array of grouping labels.  If a string, this is the name
-            of a variable in `data` that contains the grouping labels.
-        data : array_like
-            The data for the model.
-        subset : array_like, optional
-            An array_like object of booleans, integers, or index
-            values that indicate the subset of the data to use when
-            fitting the model.
-
-        Returns
-        -------
-        model : QIF model instance
-        """
-
-        if isinstance(groups, str):
-            groups = data[groups]
-        advance_eval_env(kwargs)
-        model = super().from_formula(
-            formula, data, *args,  subset=subset, groups=groups, **kwargs
-        )
-
-        return model
-
-    def fit(self, maxiter=100, start_params=None, tol=1e-6, gtol=1e-4,
-            ddof_scale=None):
-        """
-        Fit a GLM to correlated data using QIF.
-
-        Parameters
-        ----------
-        maxiter : int, optional
-            Maximum number of iterations.
-        start_params : array_like, optional
-            Starting values
-        tol : float, optional
-            Convergence threshold for difference of successive
-            estimates.
-        gtol : float, optional
-            Convergence threshold for gradient.
-        ddof_scale : int, optional
-            Degrees of freedom for the scale parameter
-
-        Returns
-        -------
-        QIFResults object
-        """
-
-        if ddof_scale is None:
-            self.ddof_scale = self.exog.shape[1]
-        else:
-            self.ddof_scale = ddof_scale
-
-        if start_params is None:
-            model = GLM(self.endog, self.exog, family=self.family)
-            result = model.fit()
-            params = result.params
-        else:
-            params = start_params
-
-        for _ in range(maxiter):
-
-            qif, grad, cmat, _, gn_deriv = self.objective(params)
-
-            gnorm = np.sqrt(np.sum(grad * grad))
-            self._fit_history["qif"].append(qif)
-            self._fit_history["gradnorm"].append(gnorm)
-
-            if gnorm < gtol:
-                break
-
-            cjac = 2 * np.dot(gn_deriv.T, np.linalg.solve(cmat, gn_deriv))
-            step = np.linalg.solve(cjac, grad)
-
-            snorm = np.sqrt(np.sum(step * step))
-            self._fit_history["stepnorm"].append(snorm)
-            if snorm < tol:
-                break
-            params -= step
-
-        vcov = np.dot(gn_deriv.T, np.linalg.solve(cmat, gn_deriv))
-        vcov = np.linalg.inv(vcov)
-        scale = self.estimate_scale(params)
-
-        rslt = QIFResults(self, params, vcov / scale, scale)
-        rslt.fit_history = self._fit_history
-        self._fit_history = defaultdict(list)
-
-        return QIFResultsWrapper(rslt)
-
-
-class QIFResults(base.LikelihoodModelResults):
-    """
-    Results class for QIF Regression
-
-    Attributes
-    ----------
-    qif : float
-        The value of the QIF objective function at the estimated
-        parameters.
-    """
-    def __init__(self, model, params, cov_params, scale,
-                 use_t=False, **kwds):
-
-        super().__init__(
-            model, params, normalized_cov_params=cov_params,
-            scale=scale)
-
-        self.qif, _, _, _, _ = self.model.objective(params)
-
-    @cache_readonly
-    def aic(self):
-        """
-        An AIC-like statistic for models fit using QIF.
-        """
-        if isinstance(self.model.cov_struct, QIFIndependence):
-            msg = "AIC not available with QIFIndependence covariance"
-            raise ValueError(msg)
-        df = self.model.exog.shape[1]
-        return self.qif + 2*df
-
-    @cache_readonly
-    def bic(self):
-        """
-        A BIC-like statistic for models fit using QIF.
-        """
-        if isinstance(self.model.cov_struct, QIFIndependence):
-            msg = "BIC not available with QIFIndependence covariance"
-            raise ValueError(msg)
-        df = self.model.exog.shape[1]
-        return self.qif + np.log(self.model.nobs)*df
-
-    @cache_readonly
-    def fittedvalues(self):
-        """
-        Returns the fitted values from the model.
-        """
-        return self.model.family.link.inverse(
-                np.dot(self.model.exog, self.params))
-
-    def summary(self, yname=None, xname=None, title=None, alpha=.05):
-        """
-        Summarize the QIF regression results
-
-        Parameters
-        ----------
-        yname : str, optional
-            Default is `y`
-        xname : list of str, optional
-            Names for the exogenous variables, default is `var_#` where `#`
-            is the 0-based index of the regressor. Must match the number of
-            parameters in the model
-        title : str, optional
-            Title for the top table. If not None, then this replaces
-            the default title
-        alpha : float, optional
-            significance level for the confidence intervals
-
-        Returns
-        -------
-        smry : Summary instance
-            this holds the summary tables and text, which can be
-            printed or converted to various output formats.
-
-        See Also
-        --------
-        statsmodels.iolib.summary.Summary : class to hold summary results
-        """
-
-        top_left = [("Dep. Variable:", None),
-                    ("Method:", ["QIF"]),
-                    ("Family:", [self.model.family.__class__.__name__]),
-                    ("Covariance structure:",
-                     [self.model.cov_struct.__class__.__name__]),
-                    ("Date:", None),
-                    ("Time:", None),
-                    ]
-
-        NY = [len(y) for y in self.model.groups_ix]
-
-        top_right = [("No. Observations:", [sum(NY)]),
-                     ("No. clusters:", [len(NY)]),
-                     ("Min. cluster size:", [min(NY)]),
-                     ("Max. cluster size:", [max(NY)]),
-                     ("Mean cluster size:", [f"{np.mean(NY):.1f}"]),
-                     ("Scale:", [f"{self.scale:.3f}"]),
-                     ]
-
-        if title is None:
-            title = self.model.__class__.__name__ + " " +\
-                "Regression Results"
-
-        # Override the exog variable names if xname is provided as an
-        # argument.
-        if xname is None:
-            xname = self.model.exog_names
-
-        if yname is None:
-            yname = self.model.endog_names
-
-        # Create summary table instance
-        from statsmodels.iolib.summary import Summary
-        smry = Summary()
-        smry.add_table_2cols(self, gleft=top_left, gright=top_right,
-                             yname=yname, xname=xname,
-                             title=title)
-        smry.add_table_params(self, yname=yname, xname=xname,
-                              alpha=alpha, use_t=False)
-
-        return smry
-
-
-class QIFResultsWrapper(lm.RegressionResultsWrapper):
-    pass
-
-
-wrap.populate_wrapper(QIFResultsWrapper, QIFResults)

shared/package-files/9b/9b45a809e914c434a5fedb1bcfe7f9bd9ee4471fd5d828bcafa59cd50b502507/blob

@@ -1,884 +0,0 @@
-#pragma once
-
-#include <ATen/Context.h>
-#include <c10/core/DeviceType.h>
-#include <torch/csrc/autograd/autograd.h>
-#include <torch/csrc/autograd/edge.h>
-#include <torch/csrc/autograd/function.h>
-#include <torch/csrc/autograd/generated/variable_factories.h>
-#include <torch/csrc/autograd/variable.h>
-#include <torch/csrc/jit/api/compilation_unit.h>
-#include <torch/csrc/jit/api/module.h>
-#include <torch/csrc/jit/frontend/error_report.h>
-#include <torch/csrc/jit/ir/ir.h>
-#include <torch/csrc/jit/mobile/register_ops_common_utils.h>
-#include <torch/csrc/jit/runtime/custom_operator.h>
-#include <torch/csrc/jit/runtime/graph_executor.h>
-#include <torch/csrc/jit/runtime/jit_exception.h>
-#include <torch/csrc/jit/runtime/logging.h>
-#include <torch/csrc/jit/runtime/operator.h>
-#include <torch/csrc/jit/runtime/print_handler.h>
-#include <torch/csrc/jit/runtime/profiling_record.h>
-#include <torch/csrc/jit/runtime/vararg_functions.h>
-#include <torch/csrc/jit/serialization/pickle.h>
-
-#include <ATen/ExpandUtils.h>
-#include <ATen/Parallel.h>
-#include <ATen/WrapDimUtils.h>
-#include <ATen/core/Dict.h>
-#include <ATen/core/Generator.h>
-#include <ATen/core/ivalue.h>
-#include <c10/core/Device.h>
-#include <c10/core/thread_pool.h>
-#include <c10/util/SmallVector.h>
-#include <c10/util/irange.h>
-#include <c10/util/string_utils.h>
-
-namespace torch::jit {
-constexpr inline c10::AliasAnalysisKind aliasAnalysisFromSchema() {
-  return c10::AliasAnalysisKind::FROM_SCHEMA;
-}
-
-constexpr inline c10::AliasAnalysisKind aliasAnalysisConservative() {
-  return c10::AliasAnalysisKind::CONSERVATIVE;
-}
-
-constexpr inline c10::AliasAnalysisKind aliasAnalysisSpecialCase() {
-  return c10::AliasAnalysisKind::INTERNAL_SPECIAL_CASE;
-}
-
-template <class T>
-c10::List<T> make_result_list(const TypePtr& elemType) {
-  return c10::List<T>();
-}
-
-template <>
-c10::impl::GenericList make_result_list<IValue>(const TypePtr& elemType);
-
-// As described in https://docs.python.org/3/library/functions.html#round
-// When a number is exactly halfway between two integers, python builtin round
-// function will round to even number. We use round(x/2)*2 to handle the
-// special halfway case. For positive 'x', round(x/2)*2 =
-// round((x_e + x_r)/2)*2 = x_e + round(x_r/2)*2, where x_e is an even integer,
-// x_r is either 0.5 of 1.5, round(x_r/2)*2 results a 0 or 2, so the final
-// result will always be a even number. Due to symmetricity, it also applies to
-// negative cases.
-inline double round_to_even(double a) {
-  return a - std::floor(a) == 0.5 ? (std::round(a * 0.5) * 2.0) : std::round(a);
-}
-
-// using the rules from python_arg_parser FunctionParameter::check
-// tensor cannot have grad set, tensor must be 0 dim,
-// and if the dest is an int the source must be integral type
-void checkImplicitTensorToNum(const at::Tensor& t, bool toInt);
-
-static C10_UNUSED int64_t floordiv(int64_t a, int64_t b) {
-  if (b == 0) {
-    throw std::runtime_error("division by 0");
-  }
-  if ((a > 0) == (b > 0)) {
-    // simple case, both have same sign
-    return a / b;
-  } else {
-    // in python division rounds down, it doesn't not truncate like in c++
-    auto r = lldiv(a, b);
-    return (r.rem) ? r.quot - 1 : r.quot;
-  }
-}
-TORCH_API void checkDoubleInRange(double a);
-static C10_UNUSED int64_t floor(double a) {
-  checkDoubleInRange(a);
-  return std::floor(a);
-}
-static C10_UNUSED int64_t ceil(double a) {
-  checkDoubleInRange(a);
-  return std::ceil(a);
-}
-
-static C10_UNUSED int64_t gcd(int64_t a, int64_t b) {
-  while (b != 0) {
-    int64_t r = a % b;
-    a = b;
-    b = r;
-  }
-  // in python gcd returns non-negative values
-  return std::abs(a);
-}
-
-int64_t partProduct(int n, int m);
-
-void loop(int n, int64_t& p, int64_t& r);
-
-int nminussumofbits(int v);
-
-int64_t factorial(int n);
-static const double degToRad = std::acos(-1.0) / 180.0;
-static const double radToDeg = 180.0 / std::acos(-1.0);
-double degrees(double x);
-double radians(double x);
-
-// Convert an python index (which may be negative) into an index usable for a
-// C++ container
-
-// Equivalent to list.at(idx)
-template <typename T>
-decltype(auto) getItem(const c10::List<T>& list, int64_t idx) {
-  const int64_t list_size = list.size();
-  const int64_t normalized_idx = normalizeIndex(idx, list_size);
-  if (normalized_idx < 0 || normalized_idx >= list_size) {
-    throw std::out_of_range("list index out of range");
-  }
-  return list.get(normalized_idx);
-}
-
-template <typename T>
-void setItem(const c10::List<T>& list, int64_t idx, T&& value) {
-  const int64_t list_size = list.size();
-  const int64_t normalized_idx = normalizeIndex(idx, list_size);
-  if (normalized_idx < 0 || normalized_idx >= list_size) {
-    throw std::out_of_range("list index out of range");
-  }
-  list.set(normalized_idx, std::forward<T>(value));
-}
-
-void listAppend(Stack& stack);
-
-void listReverse(Stack& stack);
-
-template <typename T>
-void minList(Stack& stack) {
-  c10::List<T> a = pop(stack).to<c10::List<T>>();
-  c10::List<T> b = pop(stack).to<c10::List<T>>();
-
-  size_t min_size = std::min(a.size(), b.size());
-  for (const auto i : c10::irange(min_size)) {
-    if (a[i] == b[i]) {
-      continue;
-    }
-
-    push(stack, a[i] < b[i] ? a : b);
-    return;
-  }
-
-  push(stack, b.size() < a.size() ? b : a);
-}
-
-template <typename T>
-void maxList(Stack& stack) {
-  c10::List<T> a = pop(stack).to<c10::List<T>>();
-  c10::List<T> b = pop(stack).to<c10::List<T>>();
-
-  size_t min_size = std::min(a.size(), b.size());
-  for (const auto i : c10::irange(min_size)) {
-    if (a[i] == b[i]) {
-      continue;
-    }
-
-    push(stack, a[i] > b[i] ? a : b);
-    return;
-  }
-
-  push(stack, b.size() > a.size() ? b : a);
-}
-
-void listPopImpl(Stack& stack, const char* empty_message);
-
-void listPop(Stack& stack);
-
-void listClear(Stack& stack);
-
-void listDelete(Stack& stack);
-
-void listInsert(Stack& stack);
-
-template <typename T>
-void listRemove(Stack& stack) {
-  T elem = pop(stack).to<T>();
-  c10::List<T> list = pop(stack).to<c10::List<T>>();
-
-  auto pos = std::find(list.begin(), list.end(), elem);
-
-  if (pos != list.end()) {
-    list.erase(pos);
-  } else {
-    AT_ERROR("list.remove(x): x not in list");
-  }
-}
-
-template <typename T>
-void listMin(Stack& stack) {
-  c10::List<T> list = pop(stack).to<c10::List<T>>();
-  size_t list_size = list.size();
-  if (list_size == 0) {
-    throw std::runtime_error("min() arg is an empty sequence");
-  }
-
-  T min_elem = list[0];
-  for (const auto i : c10::irange(1, list_size)) {
-    T elem = list[i];
-    min_elem = elem < min_elem ? elem : min_elem;
-  }
-
-  stack.push_back(min_elem);
-}
-
-template <typename T>
-void listMax(Stack& stack) {
-  c10::List<T> list = pop(stack).to<c10::List<T>>();
-  size_t list_size = list.size();
-  if (list_size == 0) {
-    throw std::runtime_error("max() arg is an empty sequence");
-  }
-
-  T max_elem = list[0];
-  for (const auto i : c10::irange(1, list_size)) {
-    T elem = list[i];
-    max_elem = elem > max_elem ? elem : max_elem;
-  }
-
-  stack.push_back(max_elem);
-}
-
-template <>
-void listRemove<at::Tensor>(Stack& stack);
-
-template <typename T>
-void listIndex(Stack& stack) {
-  T elem = pop(stack).to<T>();
-  c10::List<T> list = pop(stack).to<c10::List<T>>();
-
-  auto pos = std::find(list.begin(), list.end(), elem);
-
-  if (pos != list.end()) {
-    push(stack, static_cast<int64_t>(std::distance(list.begin(), pos)));
-  } else {
-    AT_ERROR("'", elem, "' is not in list");
-  }
-}
-
-template <>
-void listIndex<at::Tensor>(Stack& stack);
-
-template <typename T>
-void listCount(Stack& stack) {
-  T elem = pop(stack).to<T>();
-  c10::List<T> list = pop(stack).to<c10::List<T>>();
-
-  const int64_t count = std::count(list.begin(), list.end(), elem);
-  push(stack, count);
-}
-
-template <>
-void listCount<at::Tensor>(Stack& stack);
-
-void listExtend(Stack& stack);
-
-void listCopy(Stack& stack);
-
-void listSelect(Stack& stack);
-
-void listLen(Stack& stack);
-
-template <typename T>
-void listEq(Stack& stack) {
-  c10::List<T> b = pop(stack).to<c10::List<T>>();
-  c10::List<T> a = pop(stack).to<c10::List<T>>();
-  push(stack, a == b);
-}
-
-template <typename T>
-void listNe(Stack& stack) {
-  c10::List<T> b = pop(stack).to<c10::List<T>>();
-  c10::List<T> a = pop(stack).to<c10::List<T>>();
-  push(stack, a != b);
-}
-
-inline bool tensor_list_equal(
-    const c10::List<at::Tensor>& a,
-    const c10::List<at::Tensor>& b) {
-  if (a.size() != b.size()) {
-    return false;
-  }
-
-  for (const auto i : c10::irange(a.size())) {
-    const at::Tensor& a_element = a[i];
-    const at::Tensor& b_element = b[i];
-    // This preserves Python's semantics, which uses eq() to compare two
-    // elements, then passes the result to bool().
-    // see: https://docs.python.org/3.4/reference/datamodel.html#object.__ge__
-    const auto cmp_result = a_element.eq(b_element);
-    if (!at::native::is_nonzero(cmp_result)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-// Specialization for at::Tensor, since it doesn't define operator==
-template <>
-void listEq<at::Tensor>(Stack& stack);
-
-// Specialization for at::Tensor, since it doesn't define operator==
-template <>
-void listNe<at::Tensor>(Stack& stack);
-
-void listList(Stack& stack);
-
-template <typename T>
-void listContains(Stack& stack) {
-  auto key = pop(stack).to<T>();
-  auto list = pop(stack).to<c10::List<T>>();
-  // NOLINTNEXTLINE(performance-implicit-conversion-in-loop)
-  for (const T& item : list) {
-    if (item == key) {
-      push(stack, true);
-      return;
-    }
-  }
-  push(stack, false);
-}
-
-void listAdd(Stack& stack);
-
-void listInplaceAdd(Stack& stack);
-
-void listMulIntLeftInPlace(Stack& stack);
-
-void listMulIntLeft(Stack& stack);
-
-void listMulIntRight(Stack& stack);
-
-void listSlice(Stack& stack);
-
-template <typename T>
-void listSort(Stack& stack) {
-  bool reverse = pop(stack).toBool();
-  c10::List<T> list = pop(stack).to<c10::List<T>>();
-  std::sort(list.begin(), list.end(), [reverse](const T& a, const T& b) {
-    // FBCode errors without this check - "strict weak ordering"
-    // TODO: remove when possible, since it just slows down
-    // sorting and doesn't do anything useful
-    if (a == b) {
-      return false;
-    }
-    return (a < b) != reverse;
-  });
-}
-
-// Specialization for at::Tensor
-template <>
-void listSort<at::Tensor>(Stack& stack);
-
-template <typename T>
-void listCopyAndSort(Stack& stack) {
-  c10::List<T> list = pop(stack).to<c10::List<T>>();
-  auto list_copied = list.copy();
-  std::sort(list_copied.begin(), list_copied.end(), [](const T& a, const T& b) {
-    // "strict weak ordering" issue - see other sort
-    if (a == b) {
-      return false;
-    }
-    return a < b;
-  });
-  push(stack, list_copied);
-}
-
-// Specialization for at::Tensor
-template <>
-void listCopyAndSort<at::Tensor>(Stack& stack);
-
-void listSetItem(Stack& stack);
-
-struct OperatorGeneratorArgs {
-  const char* schema_str;
-  bool isOperationCreator;
-  union {
-    void (*operation)(Stack&);
-    OperationCreator operationCreator;
-  };
-  AliasAnalysisKind aliasAnalysis;
-
-  explicit constexpr OperatorGeneratorArgs(
-      torch::detail::SelectiveStr<true> schema_str,
-      void (*op)(Stack&),
-      AliasAnalysisKind aa)
-      : schema_str(schema_str),
-        isOperationCreator(false),
-        operation(op),
-        aliasAnalysis(aa) {}
-
-  explicit constexpr OperatorGeneratorArgs(
-      torch::detail::SelectiveStr<true> schema_str,
-      OperationCreator opCreator,
-      AliasAnalysisKind aa)
-      : schema_str(schema_str),
-        isOperationCreator(true),
-        operationCreator(opCreator),
-        aliasAnalysis(aa) {}
-
-  template <typename... Args>
-  explicit constexpr OperatorGeneratorArgs(
-      torch::detail::SelectiveStr<false>,
-      Args...)
-      : schema_str(nullptr),
-        isOperationCreator(false),
-        operation(nullptr),
-        aliasAnalysis(AliasAnalysisKind::INTERNAL_SPECIAL_CASE) {}
-};
-
-#define DEFINE_GENERIC_BINARY_OP(                                             \
-    aten_op, op, int_float_result, complex_result)                            \
-  OperatorGeneratorArgs(                                                      \
-      TORCH_SELECTIVE_SCHEMA(#aten_op                                         \
-                             ".int_int(int a, int b) -> " #int_float_result), \
-      [](Stack& stack) {                                                      \
-        int64_t a, b;                                                         \
-        pop(stack, a, b);                                                     \
-        push(stack, op);                                                      \
-      },                                                                      \
-      aliasAnalysisFromSchema()),                                             \
-      OperatorGeneratorArgs(                                                  \
-          TORCH_SELECTIVE_SCHEMA(                                             \
-              #aten_op                                                        \
-              ".float_float(float a, float b) -> " #int_float_result),        \
-          [](Stack& stack) {                                                  \
-            double a, b;                                                      \
-            pop(stack, a, b);                                                 \
-            push(stack, op);                                                  \
-          },                                                                  \
-          aliasAnalysisFromSchema()),                                         \
-      OperatorGeneratorArgs(                                                  \
-          TORCH_SELECTIVE_SCHEMA(                                             \
-              #aten_op                                                        \
-              ".complex_complex(complex a, complex b) -> " #complex_result),  \
-          [](Stack& stack) {                                                  \
-            c10::complex<double> a, b;                                        \
-            pop(stack, a, b);                                                 \
-            push(stack, op);                                                  \
-          },                                                                  \
-          aliasAnalysisFromSchema())
-
-// define implementations for primitive number ops
-#define DEFINE_GENERIC_OP(aten_op, int_op, float_op, int_result, float_result) \
-  OperatorGeneratorArgs(                                                       \
-      TORCH_SELECTIVE_SCHEMA(#aten_op ".int(int a, int b) -> " #int_result),   \
-      [](Stack& stack) {                                                       \
-        int64_t a, b;                                                          \
-        pop(stack, a, b);                                                      \
-        push(stack, int_op);                                                   \
-      },                                                                       \
-      aliasAnalysisFromSchema()),                                              \
-      OperatorGeneratorArgs(                                                   \
-          TORCH_SELECTIVE_SCHEMA(                                              \
-              #aten_op ".float(float a, float b) -> " #float_result),          \
-          [](Stack& stack) {                                                   \
-            double a, b;                                                       \
-            pop(stack, a, b);                                                  \
-            push(stack, float_op);                                             \
-          },                                                                   \
-          aliasAnalysisFromSchema())
-
-#define DEFINE_INT_FLOAT_OP(aten_op, op, result)                            \
-  OperatorGeneratorArgs(                                                    \
-      TORCH_SELECTIVE_SCHEMA(#aten_op                                       \
-                             ".int_float(int a, float b) -> " #result),     \
-      [](Stack& stack) {                                                    \
-        int64_t a;                                                          \
-        double b;                                                           \
-        pop(stack, a, b);                                                   \
-        push(stack, op);                                                    \
-      },                                                                    \
-      aliasAnalysisFromSchema()),                                           \
-      OperatorGeneratorArgs(                                                \
-          TORCH_SELECTIVE_SCHEMA(#aten_op                                   \
-                                 ".float_int(float a, int b) -> " #result), \
-          [](Stack& stack) {                                                \
-            double a;                                                       \
-            int64_t b;                                                      \
-            pop(stack, a, b);                                               \
-            push(stack, op);                                                \
-          },                                                                \
-          aliasAnalysisFromSchema())
-
-#define DEFINE_INT_OP(aten_op, op)                                  \
-  OperatorGeneratorArgs(                                            \
-      TORCH_SELECTIVE_SCHEMA(#aten_op ".int(int a, int b) -> int"), \
-      [](Stack& stack) {                                            \
-        int64_t a, b;                                               \
-        pop(stack, a, b);                                           \
-        push(stack, op); /* NOLINT(hicpp-signed-bitwise) */         \
-      },                                                            \
-      aliasAnalysisFromSchema())
-
-#define DEFINE_STR_CMP_OP(aten_op, op)                               \
-  OperatorGeneratorArgs(                                             \
-      TORCH_SELECTIVE_SCHEMA(#aten_op ".str(str a, str b) -> bool"), \
-      [](Stack& stack) {                                             \
-        auto b = pop(stack).toStringRef();                           \
-        auto a = pop(stack).toStringRef();                           \
-        push(stack, op);                                             \
-      },                                                             \
-      aliasAnalysisFromSchema())
-
-// define a primitive op over Scalar operands.
-// it's necessary to register this overload following
-// int/float variations to avoid trapping Scalar args
-// in unintended implicit conversions
-#define DEFINE_SCALAR_BINARY_OP_AVOID_COLLISION_GENERIC(          \
-    aten_op, int_op, float_op, result, string_val)                \
-  OperatorGeneratorArgs(                                          \
-      TORCH_SELECTIVE_SCHEMA(#aten_op string_val                  \
-                             "(Scalar a, Scalar b) -> " #result), \
-      [](Stack& stack) {                                          \
-        IValue x, y;                                              \
-        pop(stack, x, y);                                         \
-        if (x.isDouble()) {                                       \
-          if (y.isDouble()) {                                     \
-            double a = x.toDouble();                              \
-            double b = y.toDouble();                              \
-            push(stack, float_op);                                \
-          } else {                                                \
-            double a = x.toDouble();                              \
-            int64_t b = y.toInt();                                \
-            push(stack, float_op);                                \
-          }                                                       \
-        } else {                                                  \
-          if (y.isDouble()) {                                     \
-            int64_t a = x.toInt();                                \
-            double b = y.toDouble();                              \
-            push(stack, float_op);                                \
-          } else {                                                \
-            int64_t a = x.toInt();                                \
-            int64_t b = y.toInt();                                \
-            push(stack, int_op);                                  \
-          }                                                       \
-        }                                                         \
-      },                                                          \
-      aliasAnalysisFromSchema())
-
-#define DEFINE_SCALAR_BINARY_OP(aten_op, int_op, float_op, result) \
-  DEFINE_SCALAR_BINARY_OP_AVOID_COLLISION_GENERIC(                 \
-      aten_op, int_op, float_op, result, "")
-
-#define DEFINE_SCALAR_BINARY_OP_AVOID_COLLISION(   \
-    aten_op, int_op, float_op, result)             \
-  DEFINE_SCALAR_BINARY_OP_AVOID_COLLISION_GENERIC( \
-      aten_op, int_op, float_op, result, ".Scalar_Scalar")
-
-#define DEFINE_BINARY_OP(aten_op, op)             \
-  DEFINE_GENERIC_OP(aten_op, op, op, int, float), \
-      DEFINE_INT_FLOAT_OP(aten_op, op, float),    \
-      DEFINE_SCALAR_BINARY_OP(aten_op, op, op, Scalar)
-
-#define DEFINE_BINARY_FLOAT_OP(aten_op, op)         \
-  DEFINE_GENERIC_OP(aten_op, op, op, float, float), \
-      DEFINE_INT_FLOAT_OP(aten_op, op, float),      \
-      DEFINE_SCALAR_BINARY_OP(aten_op, op, op, float)
-
-#define DEFINE_COMPARISON_OP(aten_op, op)             \
-  DEFINE_GENERIC_OP(aten_op, op, op, bool, bool),     \
-      DEFINE_INT_FLOAT_OP(aten_op, op, bool),         \
-      DEFINE_SCALAR_BINARY_OP(aten_op, op, op, bool), \
-      DEFINE_STR_CMP_OP(aten_op, op)
-
-#define DEFINE_UNARY_INT_OP(aten_op, op, result)                  \
-  OperatorGeneratorArgs(                                          \
-      TORCH_SELECTIVE_SCHEMA(#aten_op ".int(int a) -> " #result), \
-      [](Stack& stack) {                                          \
-        int64_t a;                                                \
-        pop(stack, a);                                            \
-        push(stack, op);                                          \
-      },                                                          \
-      aliasAnalysisFromSchema())
-
-#define DEFINE_UNARY_FLOAT_OP(aten_op, op, result)                    \
-  OperatorGeneratorArgs(                                              \
-      TORCH_SELECTIVE_SCHEMA(#aten_op ".float(float a) -> " #result), \
-      [](Stack& stack) {                                              \
-        double a;                                                     \
-        pop(stack, a);                                                \
-        push(stack, op);                                              \
-      },                                                              \
-      aliasAnalysisFromSchema())
-
-#define DEFINE_UNARY_OP(aten_op, op, int_result, float_result)            \
-  DEFINE_UNARY_INT_OP(aten_op, op, int_result),                           \
-      DEFINE_UNARY_FLOAT_OP(aten_op, op, float_result),                   \
-      OperatorGeneratorArgs(                                              \
-          TORCH_SELECTIVE_SCHEMA(#aten_op ".Scalar(Scalar a) -> Scalar"), \
-          [](Stack& stack) {                                              \
-            IValue x;                                                     \
-            pop(stack, x);                                                \
-            if (x.isDouble()) {                                           \
-              double a = x.toDouble();                                    \
-              push(stack, static_cast<float_result>(op));                 \
-            } else {                                                      \
-              int64_t a = x.toInt();                                      \
-              push(stack, static_cast<int_result>(op));                   \
-            }                                                             \
-          },                                                              \
-          aliasAnalysisFromSchema())
-#define DEFINE_BOOL_OP(aten_op, op)                                     \
-  OperatorGeneratorArgs(                                                \
-      TORCH_SELECTIVE_SCHEMA(#aten_op ".bool(bool a, bool b) -> bool"), \
-      [](Stack& stack) {                                                \
-        bool a, b;                                                      \
-        pop(stack, a, b);                                               \
-        push(stack, op);                                                \
-      },                                                                \
-      aliasAnalysisFromSchema())
-#define DEFINE_STRING_OP(op_name, string_op, result)                    \
-  OperatorGeneratorArgs(                                                \
-      TORCH_SELECTIVE_SCHEMA(#op_name ".str(str a, str b) ->" #result), \
-      [](Stack& stack) {                                                \
-        auto b = pop(stack).toStringRef();                              \
-        auto a = pop(stack).toStringRef();                              \
-        push(stack, string_op);                                         \
-      },                                                                \
-      aliasAnalysisFromSchema())
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-#define DEFINE_UNARY_COMPLEX_OP(aten_op, op, result)                      \
-  OperatorGeneratorArgs(                                                  \
-      TORCH_SELECTIVE_SCHEMA(#aten_op ".complex(complex a) -> " #result), \
-      [](Stack& stack) {                                                  \
-        c10::complex<double> a;                                           \
-        pop(stack, a);                                                    \
-        push(stack, op);                                                  \
-      },                                                                  \
-      aliasAnalysisFromSchema())
-
-// Some complex unary ops (like abs, angle) return real valued output, but most
-// other unary ops return complex valued output. So, this macro is used in the
-// former case where we can explicitly pass complex_result_cast argument, which
-// is set to c10::complex<float> in the macro `DEFINE_UNARY_OP_WITH_COMPLEX`
-// defined below.
-#define DEFINE_UNARY_OP_WITH_COMPLEX_CAST(                                \
-    aten_op,                                                              \
-    op,                                                                   \
-    int_result,                                                           \
-    float_result,                                                         \
-    complex_result,                                                       \
-    complex_result_cast)                                                  \
-  DEFINE_UNARY_INT_OP(aten_op, op, int_result),                           \
-      DEFINE_UNARY_FLOAT_OP(aten_op, op, float_result),                   \
-      DEFINE_UNARY_COMPLEX_OP(aten_op, op, complex_result),               \
-      OperatorGeneratorArgs(                                              \
-          TORCH_SELECTIVE_SCHEMA(#aten_op ".Scalar(Scalar a) -> Scalar"), \
-          [](Stack& stack) {                                              \
-            IValue x;                                                     \
-            pop(stack, x);                                                \
-            if (x.isDouble()) {                                           \
-              double a = x.toDouble();                                    \
-              push(stack, static_cast<float_result>(op));                 \
-            } else if (x.isComplexDouble()) {                             \
-              c10::complex<double> a = x.toComplexDouble();               \
-              push(stack, static_cast<complex_result_cast>(op));          \
-            } else {                                                      \
-              int64_t a = x.toInt();                                      \
-              push(stack, static_cast<int_result>(op));                   \
-            }                                                             \
-          },                                                              \
-          aliasAnalysisFromSchema())
-
-#define DEFINE_UNARY_OP_WITH_COMPLEX(aten_op, op, int_result, float_result) \
-  DEFINE_UNARY_OP_WITH_COMPLEX_CAST(                                        \
-      aten_op, op, int_result, float_result, complex, c10::complex<double>)
-
-#define DEFINE_GENERIC_OP_WITH_COMPLEX(                                       \
-    aten_op,                                                                  \
-    int_op,                                                                   \
-    float_op,                                                                 \
-    complex_op,                                                               \
-    int_result,                                                               \
-    float_result,                                                             \
-    complex_result)                                                           \
-  OperatorGeneratorArgs(                                                      \
-      TORCH_SELECTIVE_SCHEMA(#aten_op ".int(int a, int b) -> " #int_result),  \
-      [](Stack& stack) {                                                      \
-        int64_t a, b;                                                         \
-        pop(stack, a, b);                                                     \
-        push(stack, int_op);                                                  \
-      },                                                                      \
-      aliasAnalysisFromSchema()),                                             \
-      OperatorGeneratorArgs(                                                  \
-          TORCH_SELECTIVE_SCHEMA(                                             \
-              #aten_op ".complex(complex a, complex b) -> " #complex_result), \
-          [](Stack& stack) {                                                  \
-            c10::complex<double> a, b;                                        \
-            pop(stack, a, b);                                                 \
-            push(stack, complex_op);                                          \
-          },                                                                  \
-          aliasAnalysisFromSchema()),                                         \
-      OperatorGeneratorArgs(                                                  \
-          TORCH_SELECTIVE_SCHEMA(                                             \
-              #aten_op ".float(float a, float b) -> " #float_result),         \
-          [](Stack& stack) {                                                  \
-            double a, b;                                                      \
-            pop(stack, a, b);                                                 \
-            push(stack, float_op);                                            \
-          },                                                                  \
-          aliasAnalysisFromSchema())
-
-#define DEFINE_INT_COMPLEX_OP(aten_op, op, result)                          \
-  OperatorGeneratorArgs(                                                    \
-      TORCH_SELECTIVE_SCHEMA(#aten_op                                       \
-                             ".int_complex(int a, complex b) -> " #result), \
-      [](Stack& stack) {                                                    \
-        int64_t a;                                                          \
-        c10::complex<double> b;                                             \
-        pop(stack, a, b);                                                   \
-        push(stack, op);                                                    \
-      },                                                                    \
-      aliasAnalysisFromSchema()),                                           \
-      OperatorGeneratorArgs(                                                \
-          TORCH_SELECTIVE_SCHEMA(                                           \
-              #aten_op ".complex_int(complex a, int b) -> " #result),       \
-          [](Stack& stack) {                                                \
-            c10::complex<double> a;                                         \
-            int64_t b;                                                      \
-            pop(stack, a, b);                                               \
-            push(stack, op);                                                \
-          },                                                                \
-          aliasAnalysisFromSchema())
-
-#define DEFINE_FLOAT_COMPLEX_OP(aten_op, op, result)                      \
-  OperatorGeneratorArgs(                                                  \
-      TORCH_SELECTIVE_SCHEMA(                                             \
-          #aten_op ".float_complex(float a, complex b) -> " #result),     \
-      [](Stack& stack) {                                                  \
-        double a;                                                         \
-        c10::complex<double> b;                                           \
-        pop(stack, a, b);                                                 \
-        push(stack, op);                                                  \
-      },                                                                  \
-      aliasAnalysisFromSchema()),                                         \
-      OperatorGeneratorArgs(                                              \
-          TORCH_SELECTIVE_SCHEMA(                                         \
-              #aten_op ".complex_float(complex a, float b) -> " #result), \
-          [](Stack& stack) {                                              \
-            c10::complex<double> a;                                       \
-            double b;                                                     \
-            pop(stack, a, b);                                             \
-            push(stack, op);                                              \
-          },                                                              \
-          aliasAnalysisFromSchema())
-
-#define DEFINE_SCALAR_BINARY_OP_WITH_COMPLEX_AVOID_COLLISION_GENERIC( \
-    aten_op, int_op, float_op, complex_op, result, string_val)        \
-  OperatorGeneratorArgs(                                              \
-      TORCH_SELECTIVE_SCHEMA(#aten_op string_val                      \
-                             "(Scalar a, Scalar b) -> " #result),     \
-      [](Stack& stack) {                                              \
-        IValue x, y;                                                  \
-        pop(stack, x, y);                                             \
-        if (x.isComplexDouble()) {                                    \
-          c10::complex<double> a = x.toComplexDouble();               \
-          if (y.isComplexDouble()) {                                  \
-            c10::complex<double> b = y.toComplexDouble();             \
-            push(stack, complex_op);                                  \
-          } else if (y.isDouble()) {                                  \
-            double b = y.toDouble();                                  \
-            push(stack, complex_op);                                  \
-          } else {                                                    \
-            int64_t b = y.toInt();                                    \
-            push(stack, complex_op);                                  \
-          }                                                           \
-        } else if (x.isDouble()) {                                    \
-          double a = x.toDouble();                                    \
-          if (y.isComplexDouble()) {                                  \
-            c10::complex<double> b = y.toComplexDouble();             \
-            push(stack, complex_op);                                  \
-          } else if (y.isDouble()) {                                  \
-            double b = y.toDouble();                                  \
-            push(stack, float_op);                                    \
-          } else {                                                    \
-            int64_t b = y.toInt();                                    \
-            push(stack, float_op);                                    \
-          }                                                           \
-        } else {                                                      \
-          int64_t a = x.toInt();                                      \
-          if (y.isComplexDouble()) {                                  \
-            c10::complex<double> b = y.toComplexDouble();             \
-            push(stack, complex_op);                                  \
-          } else if (y.isDouble()) {                                  \
-            double b = y.toDouble();                                  \
-            push(stack, float_op);                                    \
-          } else {                                                    \
-            int64_t b = y.toInt();                                    \
-            push(stack, int_op);                                      \
-          }                                                           \
-        }                                                             \
-      },                                                              \
-      aliasAnalysisFromSchema())
-
-#define DEFINE_SCALAR_BINARY_OP_WITH_COMPLEX_WITHOUT_INT_COMPLEX_PAIR(     \
-    aten_op, int_op, float_op, complex_op, result)                         \
-  OperatorGeneratorArgs(                                                   \
-      TORCH_SELECTIVE_SCHEMA(#aten_op "(Scalar a, Scalar b) -> " #result), \
-      [](Stack& stack) {                                                   \
-        IValue x, y;                                                       \
-        pop(stack, x, y);                                                  \
-        if (x.isComplexDouble()) {                                         \
-          c10::complex<double> a = x.toComplexDouble();                    \
-          if (y.isComplexDouble()) {                                       \
-            c10::complex<double> b = y.toComplexDouble();                  \
-            push(stack, complex_op);                                       \
-          } else if (y.isDouble()) {                                       \
-            double b = y.toDouble();                                       \
-            push(stack, complex_op);                                       \
-          }                                                                \
-        } else if (x.isDouble()) {                                         \
-          double a = x.toDouble();                                         \
-          if (y.isComplexDouble()) {                                       \
-            c10::complex<double> b = y.toComplexDouble();                  \
-            push(stack, complex_op);                                       \
-          } else if (y.isDouble()) {                                       \
-            double b = y.toDouble();                                       \
-            push(stack, float_op);                                         \
-          } else {                                                         \
-            int64_t b = y.toInt();                                         \
-            push(stack, float_op);                                         \
-          }                                                                \
-        } else {                                                           \
-          int64_t a = x.toInt();                                           \
-          if (y.isDouble()) {                                              \
-            double b = y.toDouble();                                       \
-            push(stack, float_op);                                         \
-          } else if (y.isInt()) {                                          \
-            int64_t b = y.toInt();                                         \
-            push(stack, int_op);                                           \
-          }                                                                \
-        }                                                                  \
-      },                                                                   \
-      aliasAnalysisFromSchema())
-
-#define DEFINE_SCALAR_BINARY_OP_WITH_COMPLEX(                   \
-    aten_op, int_op, float_op, complex_op, result)              \
-  DEFINE_SCALAR_BINARY_OP_WITH_COMPLEX_AVOID_COLLISION_GENERIC( \
-      aten_op, int_op, float_op, complex_op, result, "")
-
-#define DEFINE_BINARY_OP_WITH_COMPLEX(aten_op, op)                          \
-  DEFINE_GENERIC_OP_WITH_COMPLEX(aten_op, op, op, op, int, float, complex), \
-      DEFINE_INT_COMPLEX_OP(aten_op, op, complex),                          \
-      DEFINE_FLOAT_COMPLEX_OP(aten_op, op, complex),                        \
-      DEFINE_INT_FLOAT_OP(aten_op, op, float),                              \
-      DEFINE_SCALAR_BINARY_OP_WITH_COMPLEX(aten_op, op, op, op, Scalar)
-
-#define DEFINE_COMPARISON_OP_WITH_COMPLEX(aten_op, op)                   \
-  DEFINE_GENERIC_OP_WITH_COMPLEX(aten_op, op, op, op, bool, bool, bool), \
-      DEFINE_INT_FLOAT_OP(aten_op, op, bool),                            \
-      DEFINE_FLOAT_COMPLEX_OP(aten_op, op, bool),                        \
-      DEFINE_SCALAR_BINARY_OP_WITH_COMPLEX_WITHOUT_INT_COMPLEX_PAIR(     \
-          aten_op, op, op, op, bool),                                    \
-      DEFINE_STR_CMP_OP(aten_op, op)
-
-TORCH_API at::Generator make_generator_for_device(
-    c10::Device device,
-    c10::optional<int64_t> seed = c10::nullopt);
-
-} // namespace torch::jit

shared/package-files/9b/9b484599c4f3bd9f2c65b6e759e10dc332b2b9fa44f735b0651f96088e247695/blob

@@ -1,113 +0,0 @@
-"""Tests for homomorphisms."""
-
-from sympy.core.singleton import S
-from sympy.polys.domains.rationalfield import QQ
-from sympy.abc import x, y
-from sympy.polys.agca import homomorphism
-from sympy.testing.pytest import raises
-
-
-def test_printing():
-    R = QQ.old_poly_ring(x)
-
-    assert str(homomorphism(R.free_module(1), R.free_module(1), [0])) == \
-        'Matrix([[0]]) : QQ[x]**1 -> QQ[x]**1'
-    assert str(homomorphism(R.free_module(2), R.free_module(2), [0, 0])) == \
-        'Matrix([                       \n[0, 0], : QQ[x]**2 -> QQ[x]**2\n[0, 0]])                       '
-    assert str(homomorphism(R.free_module(1), R.free_module(1) / [[x]], [0])) == \
-        'Matrix([[0]]) : QQ[x]**1 -> QQ[x]**1/<[x]>'
-    assert str(R.free_module(0).identity_hom()) == 'Matrix(0, 0, []) : QQ[x]**0 -> QQ[x]**0'
-
-def test_operations():
-    F = QQ.old_poly_ring(x).free_module(2)
-    G = QQ.old_poly_ring(x).free_module(3)
-    f = F.identity_hom()
-    g = homomorphism(F, F, [0, [1, x]])
-    h = homomorphism(F, F, [[1, 0], 0])
-    i = homomorphism(F, G, [[1, 0, 0], [0, 1, 0]])
-
-    assert f == f
-    assert f != g
-    assert f != i
-    assert (f != F.identity_hom()) is False
-    assert 2*f == f*2 == homomorphism(F, F, [[2, 0], [0, 2]])
-    assert f/2 == homomorphism(F, F, [[S.Half, 0], [0, S.Half]])
-    assert f + g == homomorphism(F, F, [[1, 0], [1, x + 1]])
-    assert f - g == homomorphism(F, F, [[1, 0], [-1, 1 - x]])
-    assert f*g == g == g*f
-    assert h*g == homomorphism(F, F, [0, [1, 0]])
-    assert g*h == homomorphism(F, F, [0, 0])
-    assert i*f == i
-    assert f([1, 2]) == [1, 2]
-    assert g([1, 2]) == [2, 2*x]
-
-    assert i.restrict_domain(F.submodule([x, x]))([x, x]) == i([x, x])
-    h1 = h.quotient_domain(F.submodule([0, 1]))
-    assert h1([1, 0]) == h([1, 0])
-    assert h1.restrict_domain(h1.domain.submodule([x, 0]))([x, 0]) == h([x, 0])
-
-    raises(TypeError, lambda: f/g)
-    raises(TypeError, lambda: f + 1)
-    raises(TypeError, lambda: f + i)
-    raises(TypeError, lambda: f - 1)
-    raises(TypeError, lambda: f*i)
-
-
-def test_creation():
-    F = QQ.old_poly_ring(x).free_module(3)
-    G = QQ.old_poly_ring(x).free_module(2)
-    SM = F.submodule([1, 1, 1])
-    Q = F / SM
-    SQ = Q.submodule([1, 0, 0])
-
-    matrix = [[1, 0], [0, 1], [-1, -1]]
-    h = homomorphism(F, G, matrix)
-    h2 = homomorphism(Q, G, matrix)
-    assert h.quotient_domain(SM) == h2
-    raises(ValueError, lambda: h.quotient_domain(F.submodule([1, 0, 0])))
-    assert h2.restrict_domain(SQ) == homomorphism(SQ, G, matrix)
-    raises(ValueError, lambda: h.restrict_domain(G))
-    raises(ValueError, lambda: h.restrict_codomain(G.submodule([1, 0])))
-    raises(ValueError, lambda: h.quotient_codomain(F))
-
-    im = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
-    for M in [F, SM, Q, SQ]:
-        assert M.identity_hom() == homomorphism(M, M, im)
-    assert SM.inclusion_hom() == homomorphism(SM, F, im)
-    assert SQ.inclusion_hom() == homomorphism(SQ, Q, im)
-    assert Q.quotient_hom() == homomorphism(F, Q, im)
-    assert SQ.quotient_hom() == homomorphism(SQ.base, SQ, im)
-
-    class conv:
-        def convert(x, y=None):
-            return x
-
-    class dummy:
-        container = conv()
-
-        def submodule(*args):
-            return None
-    raises(TypeError, lambda: homomorphism(dummy(), G, matrix))
-    raises(TypeError, lambda: homomorphism(F, dummy(), matrix))
-    raises(
-        ValueError, lambda: homomorphism(QQ.old_poly_ring(x, y).free_module(3), G, matrix))
-    raises(ValueError, lambda: homomorphism(F, G, [0, 0]))
-
-
-def test_properties():
-    R = QQ.old_poly_ring(x, y)
-    F = R.free_module(2)
-    h = homomorphism(F, F, [[x, 0], [y, 0]])
-    assert h.kernel() == F.submodule([-y, x])
-    assert h.image() == F.submodule([x, 0], [y, 0])
-    assert not h.is_injective()
-    assert not h.is_surjective()
-    assert h.restrict_codomain(h.image()).is_surjective()
-    assert h.restrict_domain(F.submodule([1, 0])).is_injective()
-    assert h.quotient_domain(
-        h.kernel()).restrict_codomain(h.image()).is_isomorphism()
-
-    R2 = QQ.old_poly_ring(x, y, order=(("lex", x), ("ilex", y))) / [x**2 + 1]
-    F = R2.free_module(2)
-    h = homomorphism(F, F, [[x, 0], [y, y + 1]])
-    assert h.is_isomorphism()

shared/package-files/9b/9b4b2ab4ef7b3c4bfcfff6eca7136078b7c168c81adab9d952790797eea37249/blob

@@ -1,63 +0,0 @@
-from typing import Any, Dict, Optional, TypeVar, Union
-
-from django.db.models.expressions import Combinable, CombinedExpression, Func, Value, _OutputField
-from django.db.models.lookups import Lookup
-
-from django.db.models import Field
-
-_Expression = Union[str, Combinable, "SearchQueryCombinable"]
-
-class SearchVectorExact(Lookup): ...
-class SearchVectorField(Field): ...
-class SearchQueryField(Field): ...
-
-class SearchVectorCombinable:
-    ADD: str = ...
-
-class SearchVector(SearchVectorCombinable, Func):
-    config: Optional[Any] = ...
-    def __init__(self, *expressions: _Expression, **extra: Any): ...
-
-class CombinedSearchVector(SearchVectorCombinable, CombinedExpression):
-    def __init__(
-        self, lhs, connector, rhs, config: Optional[_Expression] = ..., output_field: Optional[_OutputField] = ...
-    ): ...
-
-_T = TypeVar("_T", bound="SearchQueryCombinable")
-
-class SearchQueryCombinable:
-    BITAND: str = ...
-    BITOR: str = ...
-    def __or__(self: _T, other: SearchQueryCombinable) -> _T: ...
-    def __ror__(self: _T, other: SearchQueryCombinable) -> _T: ...
-    def __and__(self: _T, other: SearchQueryCombinable) -> _T: ...
-    def __rand__(self: _T, other: SearchQueryCombinable) -> _T: ...
-
-class SearchQuery(SearchQueryCombinable, Value):  # type: ignore
-    SEARCH_TYPES: Dict[str, str] = ...
-    def __init__(
-        self,
-        value: str,
-        output_field: Optional[_OutputField] = ...,
-        *,
-        config: Optional[_Expression] = ...,
-        invert: bool = ...,
-        search_type: str = ...
-    ): ...
-    def __invert__(self: _T) -> _T: ...
-
-class CombinedSearchQuery(SearchQueryCombinable, CombinedExpression):  # type: ignore
-    def __init__(
-        self, lhs, connector, rhs, config: Optional[_Expression] = ..., output_field: Optional[_OutputField] = ...
-    ) -> None: ...
-
-class SearchRank(Func):
-    def __init__(
-        self, vector: Union[SearchVector, _Expression], query: Union[SearchQuery, _Expression], **extra: Any
-    ) -> None: ...
-
-class TrigramBase(Func):
-    def __init__(self, expression: _Expression, string, **extra: Any) -> None: ...
-
-class TrigramSimilarity(TrigramBase): ...
-class TrigramDistance(TrigramBase): ...

shared/package-files/9b/9b4d6e6e077c5be4e16cbf790138fb75158aea70027ab99005cd0cac43cf42bf/blob

@@ -1,68 +0,0 @@
-# Authors: The scikit-learn developers
-# SPDX-License-Identifier: BSD-3-Clause
-
-
-def _check_feature_names(X, feature_names=None):
-    """Check feature names.
-
-    Parameters
-    ----------
-    X : array-like of shape (n_samples, n_features)
-        Input data.
-
-    feature_names : None or array-like of shape (n_names,), dtype=str
-        Feature names to check or `None`.
-
-    Returns
-    -------
-    feature_names : list of str
-        Feature names validated. If `feature_names` is `None`, then a list of
-        feature names is provided, i.e. the column names of a pandas dataframe
-        or a generic list of feature names (e.g. `["x0", "x1", ...]`) for a
-        NumPy array.
-    """
-    if feature_names is None:
-        if hasattr(X, "columns") and hasattr(X.columns, "tolist"):
-            # get the column names for a pandas dataframe
-            feature_names = X.columns.tolist()
-        else:
-            # define a list of numbered indices for a numpy array
-            feature_names = [f"x{i}" for i in range(X.shape[1])]
-    elif hasattr(feature_names, "tolist"):
-        # convert numpy array or pandas index to a list
-        feature_names = feature_names.tolist()
-    if len(set(feature_names)) != len(feature_names):
-        raise ValueError("feature_names should not contain duplicates.")
-
-    return feature_names
-
-
-def _get_feature_index(fx, feature_names=None):
-    """Get feature index.
-
-    Parameters
-    ----------
-    fx : int or str
-        Feature index or name.
-
-    feature_names : list of str, default=None
-        All feature names from which to search the indices.
-
-    Returns
-    -------
-    idx : int
-        Feature index.
-    """
-    if isinstance(fx, str):
-        if feature_names is None:
-            raise ValueError(
-                f"Cannot plot partial dependence for feature {fx!r} since "
-                "the list of feature names was not provided, neither as "
-                "column names of a pandas data-frame nor via the feature_names "
-                "parameter."
-            )
-        try:
-            return feature_names.index(fx)
-        except ValueError as e:
-            raise ValueError(f"Feature {fx!r} not in feature_names") from e
-    return fx

shared/package-files/9b/9b4fa9e614c6536132eee050ac1ecb48f813bd2d02f05afe480f5dd81017e8c9/blob

@@ -1,687 +0,0 @@
-import itertools
-
-from sympy.concrete.summations import Sum
-from sympy.core.add import Add
-from sympy.core.expr import Expr
-from sympy.core.function import expand as _expand
-from sympy.core.mul import Mul
-from sympy.core.relational import Eq
-from sympy.core.singleton import S
-from sympy.core.symbol import Symbol
-from sympy.integrals.integrals import Integral
-from sympy.logic.boolalg import Not
-from sympy.core.parameters import global_parameters
-from sympy.core.sorting import default_sort_key
-from sympy.core.sympify import _sympify
-from sympy.core.relational import Relational
-from sympy.logic.boolalg import Boolean
-from sympy.stats import variance, covariance
-from sympy.stats.rv import (RandomSymbol, pspace, dependent,
-                            given, sampling_E, RandomIndexedSymbol, is_random,
-                            PSpace, sampling_P, random_symbols)
-
-__all__ = ['Probability', 'Expectation', 'Variance', 'Covariance']
-
-
-@is_random.register(Expr)
-def _(x):
-    atoms = x.free_symbols
-    if len(atoms) == 1 and next(iter(atoms)) == x:
-        return False
-    return any(is_random(i) for i in atoms)
-
-@is_random.register(RandomSymbol)  # type: ignore
-def _(x):
-    return True
-
-
-class Probability(Expr):
-    """
-    Symbolic expression for the probability.
-
-    Examples
-    ========
-
-    >>> from sympy.stats import Probability, Normal
-    >>> from sympy import Integral
-    >>> X = Normal("X", 0, 1)
-    >>> prob = Probability(X > 1)
-    >>> prob
-    Probability(X > 1)
-
-    Integral representation:
-
-    >>> prob.rewrite(Integral)
-    Integral(sqrt(2)*exp(-_z**2/2)/(2*sqrt(pi)), (_z, 1, oo))
-
-    Evaluation of the integral:
-
-    >>> prob.evaluate_integral()
-    sqrt(2)*(-sqrt(2)*sqrt(pi)*erf(sqrt(2)/2) + sqrt(2)*sqrt(pi))/(4*sqrt(pi))
-    """
-    def __new__(cls, prob, condition=None, **kwargs):
-        prob = _sympify(prob)
-        if condition is None:
-            obj = Expr.__new__(cls, prob)
-        else:
-            condition = _sympify(condition)
-            obj = Expr.__new__(cls, prob, condition)
-        obj._condition = condition
-        return obj
-
-    def doit(self, **hints):
-        condition = self.args[0]
-        given_condition = self._condition
-        numsamples = hints.get('numsamples', False)
-        for_rewrite = not hints.get('for_rewrite', False)
-
-        if isinstance(condition, Not):
-            return S.One - self.func(condition.args[0], given_condition,
-                                    evaluate=for_rewrite).doit(**hints)
-
-        if condition.has(RandomIndexedSymbol):
-            return pspace(condition).probability(condition, given_condition,
-                                             evaluate=for_rewrite)
-
-        if isinstance(given_condition, RandomSymbol):
-            condrv = random_symbols(condition)
-            if len(condrv) == 1 and condrv[0] == given_condition:
-                from sympy.stats.frv_types import BernoulliDistribution
-                return BernoulliDistribution(self.func(condition).doit(**hints), 0, 1)
-            if any(dependent(rv, given_condition) for rv in condrv):
-                return Probability(condition, given_condition)
-            else:
-                return Probability(condition).doit()
-
-        if given_condition is not None and \
-                not isinstance(given_condition, (Relational, Boolean)):
-            raise ValueError("%s is not a relational or combination of relationals"
-                    % (given_condition))
-
-        if given_condition == False or condition is S.false:
-            return S.Zero
-        if not isinstance(condition, (Relational, Boolean)):
-            raise ValueError("%s is not a relational or combination of relationals"
-                    % (condition))
-        if condition is S.true:
-            return S.One
-
-        if numsamples:
-            return sampling_P(condition, given_condition, numsamples=numsamples)
-        if given_condition is not None:  # If there is a condition
-            # Recompute on new conditional expr
-            return Probability(given(condition, given_condition)).doit()
-
-        # Otherwise pass work off to the ProbabilitySpace
-        if pspace(condition) == PSpace():
-            return Probability(condition, given_condition)
-
-        result = pspace(condition).probability(condition)
-        if hasattr(result, 'doit') and for_rewrite:
-            return result.doit()
-        else:
-            return result
-
-    def _eval_rewrite_as_Integral(self, arg, condition=None, **kwargs):
-        return self.func(arg, condition=condition).doit(for_rewrite=True)
-
-    _eval_rewrite_as_Sum = _eval_rewrite_as_Integral
-
-    def evaluate_integral(self):
-        return self.rewrite(Integral).doit()
-
-
-class Expectation(Expr):
-    """
-    Symbolic expression for the expectation.
-
-    Examples
-    ========
-
-    >>> from sympy.stats import Expectation, Normal, Probability, Poisson
-    >>> from sympy import symbols, Integral, Sum
-    >>> mu = symbols("mu")
-    >>> sigma = symbols("sigma", positive=True)
-    >>> X = Normal("X", mu, sigma)
-    >>> Expectation(X)
-    Expectation(X)
-    >>> Expectation(X).evaluate_integral().simplify()
-    mu
-
-    To get the integral expression of the expectation:
-
-    >>> Expectation(X).rewrite(Integral)
-    Integral(sqrt(2)*X*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo))
-
-    The same integral expression, in more abstract terms:
-
-    >>> Expectation(X).rewrite(Probability)
-    Integral(x*Probability(Eq(X, x)), (x, -oo, oo))
-
-    To get the Summation expression of the expectation for discrete random variables:
-
-    >>> lamda = symbols('lamda', positive=True)
-    >>> Z = Poisson('Z', lamda)
-    >>> Expectation(Z).rewrite(Sum)
-    Sum(Z*lamda**Z*exp(-lamda)/factorial(Z), (Z, 0, oo))
-
-    This class is aware of some properties of the expectation:
-
-    >>> from sympy.abc import a
-    >>> Expectation(a*X)
-    Expectation(a*X)
-    >>> Y = Normal("Y", 1, 2)
-    >>> Expectation(X + Y)
-    Expectation(X + Y)
-
-    To expand the ``Expectation`` into its expression, use ``expand()``:
-
-    >>> Expectation(X + Y).expand()
-    Expectation(X) + Expectation(Y)
-    >>> Expectation(a*X + Y).expand()
-    a*Expectation(X) + Expectation(Y)
-    >>> Expectation(a*X + Y)
-    Expectation(a*X + Y)
-    >>> Expectation((X + Y)*(X - Y)).expand()
-    Expectation(X**2) - Expectation(Y**2)
-
-    To evaluate the ``Expectation``, use ``doit()``:
-
-    >>> Expectation(X + Y).doit()
-    mu + 1
-    >>> Expectation(X + Expectation(Y + Expectation(2*X))).doit()
-    3*mu + 1
-
-    To prevent evaluating nested ``Expectation``, use ``doit(deep=False)``
-
-    >>> Expectation(X + Expectation(Y)).doit(deep=False)
-    mu + Expectation(Expectation(Y))
-    >>> Expectation(X + Expectation(Y + Expectation(2*X))).doit(deep=False)
-    mu + Expectation(Expectation(Y + Expectation(2*X)))
-
-    """
-
-    def __new__(cls, expr, condition=None, **kwargs):
-        expr = _sympify(expr)
-        if expr.is_Matrix:
-            from sympy.stats.symbolic_multivariate_probability import ExpectationMatrix
-            return ExpectationMatrix(expr, condition)
-        if condition is None:
-            if not is_random(expr):
-                return expr
-            obj = Expr.__new__(cls, expr)
-        else:
-            condition = _sympify(condition)
-            obj = Expr.__new__(cls, expr, condition)
-        obj._condition = condition
-        return obj
-
-    def expand(self, **hints):
-        expr = self.args[0]
-        condition = self._condition
-
-        if not is_random(expr):
-            return expr
-
-        if isinstance(expr, Add):
-            return Add.fromiter(Expectation(a, condition=condition).expand()
-                    for a in expr.args)
-
-        expand_expr = _expand(expr)
-        if isinstance(expand_expr, Add):
-            return Add.fromiter(Expectation(a, condition=condition).expand()
-                    for a in expand_expr.args)
-
-        elif isinstance(expr, Mul):
-            rv = []
-            nonrv = []
-            for a in expr.args:
-                if is_random(a):
-                    rv.append(a)
-                else:
-                    nonrv.append(a)
-            return Mul.fromiter(nonrv)*Expectation(Mul.fromiter(rv), condition=condition)
-
-        return self
-
-    def doit(self, **hints):
-        deep = hints.get('deep', True)
-        condition = self._condition
-        expr = self.args[0]
-        numsamples = hints.get('numsamples', False)
-        for_rewrite = not hints.get('for_rewrite', False)
-
-        if deep:
-            expr = expr.doit(**hints)
-
-        if not is_random(expr) or isinstance(expr, Expectation):  # expr isn't random?
-            return expr
-        if numsamples:  # Computing by monte carlo sampling?
-            evalf = hints.get('evalf', True)
-            return sampling_E(expr, condition, numsamples=numsamples, evalf=evalf)
-
-        if expr.has(RandomIndexedSymbol):
-            return pspace(expr).compute_expectation(expr, condition)
-
-        # Create new expr and recompute E
-        if condition is not None:  # If there is a condition
-            return self.func(given(expr, condition)).doit(**hints)
-
-        # A few known statements for efficiency
-
-        if expr.is_Add:  # We know that E is Linear
-            return Add(*[self.func(arg, condition).doit(**hints)
-                    if not isinstance(arg, Expectation) else self.func(arg, condition)
-                         for arg in expr.args])
-        if expr.is_Mul:
-            if expr.atoms(Expectation):
-                return expr
-
-        if pspace(expr) == PSpace():
-            return self.func(expr)
-        # Otherwise case is simple, pass work off to the ProbabilitySpace
-        result = pspace(expr).compute_expectation(expr, evaluate=for_rewrite)
-        if hasattr(result, 'doit') and for_rewrite:
-            return result.doit(**hints)
-        else:
-            return result
-
-
-    def _eval_rewrite_as_Probability(self, arg, condition=None, **kwargs):
-        rvs = arg.atoms(RandomSymbol)
-        if len(rvs) > 1:
-            raise NotImplementedError()
-        if len(rvs) == 0:
-            return arg
-
-        rv = rvs.pop()
-        if rv.pspace is None:
-            raise ValueError("Probability space not known")
-
-        symbol = rv.symbol
-        if symbol.name[0].isupper():
-            symbol = Symbol(symbol.name.lower())
-        else :
-            symbol = Symbol(symbol.name + "_1")
-
-        if rv.pspace.is_Continuous:
-            return Integral(arg.replace(rv, symbol)*Probability(Eq(rv, symbol), condition), (symbol, rv.pspace.domain.set.inf, rv.pspace.domain.set.sup))
-        else:
-            if rv.pspace.is_Finite:
-                raise NotImplementedError
-            else:
-                return Sum(arg.replace(rv, symbol)*Probability(Eq(rv, symbol), condition), (symbol, rv.pspace.domain.set.inf, rv.pspace.set.sup))
-
-    def _eval_rewrite_as_Integral(self, arg, condition=None, **kwargs):
-        return self.func(arg, condition=condition).doit(deep=False, for_rewrite=True)
-
-    _eval_rewrite_as_Sum = _eval_rewrite_as_Integral # For discrete this will be Sum
-
-    def evaluate_integral(self):
-        return self.rewrite(Integral).doit()
-
-    evaluate_sum = evaluate_integral
-
-class Variance(Expr):
-    """
-    Symbolic expression for the variance.
-
-    Examples
-    ========
-
-    >>> from sympy import symbols, Integral
-    >>> from sympy.stats import Normal, Expectation, Variance, Probability
-    >>> mu = symbols("mu", positive=True)
-    >>> sigma = symbols("sigma", positive=True)
-    >>> X = Normal("X", mu, sigma)
-    >>> Variance(X)
-    Variance(X)
-    >>> Variance(X).evaluate_integral()
-    sigma**2
-
-    Integral representation of the underlying calculations:
-
-    >>> Variance(X).rewrite(Integral)
-    Integral(sqrt(2)*(X - Integral(sqrt(2)*X*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo)))**2*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo))
-
-    Integral representation, without expanding the PDF:
-
-    >>> Variance(X).rewrite(Probability)
-    -Integral(x*Probability(Eq(X, x)), (x, -oo, oo))**2 + Integral(x**2*Probability(Eq(X, x)), (x, -oo, oo))
-
-    Rewrite the variance in terms of the expectation
-
-    >>> Variance(X).rewrite(Expectation)
-    -Expectation(X)**2 + Expectation(X**2)
-
-    Some transformations based on the properties of the variance may happen:
-
-    >>> from sympy.abc import a
-    >>> Y = Normal("Y", 0, 1)
-    >>> Variance(a*X)
-    Variance(a*X)
-
-    To expand the variance in its expression, use ``expand()``:
-
-    >>> Variance(a*X).expand()
-    a**2*Variance(X)
-    >>> Variance(X + Y)
-    Variance(X + Y)
-    >>> Variance(X + Y).expand()
-    2*Covariance(X, Y) + Variance(X) + Variance(Y)
-
-    """
-    def __new__(cls, arg, condition=None, **kwargs):
-        arg = _sympify(arg)
-
-        if arg.is_Matrix:
-            from sympy.stats.symbolic_multivariate_probability import VarianceMatrix
-            return VarianceMatrix(arg, condition)
-        if condition is None:
-            obj = Expr.__new__(cls, arg)
-        else:
-            condition = _sympify(condition)
-            obj = Expr.__new__(cls, arg, condition)
-        obj._condition = condition
-        return obj
-
-    def expand(self, **hints):
-        arg = self.args[0]
-        condition = self._condition
-
-        if not is_random(arg):
-            return S.Zero
-
-        if isinstance(arg, RandomSymbol):
-            return self
-        elif isinstance(arg, Add):
-            rv = []
-            for a in arg.args:
-                if is_random(a):
-                    rv.append(a)
-            variances = Add(*(Variance(xv, condition).expand() for xv in rv))
-            map_to_covar = lambda x: 2*Covariance(*x, condition=condition).expand()
-            covariances = Add(*map(map_to_covar, itertools.combinations(rv, 2)))
-            return variances + covariances
-        elif isinstance(arg, Mul):
-            nonrv = []
-            rv = []
-            for a in arg.args:
-                if is_random(a):
-                    rv.append(a)
-                else:
-                    nonrv.append(a**2)
-            if len(rv) == 0:
-                return S.Zero
-            return Mul.fromiter(nonrv)*Variance(Mul.fromiter(rv), condition)
-
-        # this expression contains a RandomSymbol somehow:
-        return self
-
-    def _eval_rewrite_as_Expectation(self, arg, condition=None, **kwargs):
-            e1 = Expectation(arg**2, condition)
-            e2 = Expectation(arg, condition)**2
-            return e1 - e2
-
-    def _eval_rewrite_as_Probability(self, arg, condition=None, **kwargs):
-        return self.rewrite(Expectation).rewrite(Probability)
-
-    def _eval_rewrite_as_Integral(self, arg, condition=None, **kwargs):
-        return variance(self.args[0], self._condition, evaluate=False)
-
-    _eval_rewrite_as_Sum = _eval_rewrite_as_Integral
-
-    def evaluate_integral(self):
-        return self.rewrite(Integral).doit()
-
-
-class Covariance(Expr):
-    """
-    Symbolic expression for the covariance.
-
-    Examples
-    ========
-
-    >>> from sympy.stats import Covariance
-    >>> from sympy.stats import Normal
-    >>> X = Normal("X", 3, 2)
-    >>> Y = Normal("Y", 0, 1)
-    >>> Z = Normal("Z", 0, 1)
-    >>> W = Normal("W", 0, 1)
-    >>> cexpr = Covariance(X, Y)
-    >>> cexpr
-    Covariance(X, Y)
-
-    Evaluate the covariance, `X` and `Y` are independent,
-    therefore zero is the result:
-
-    >>> cexpr.evaluate_integral()
-    0
-
-    Rewrite the covariance expression in terms of expectations:
-
-    >>> from sympy.stats import Expectation
-    >>> cexpr.rewrite(Expectation)
-    Expectation(X*Y) - Expectation(X)*Expectation(Y)
-
-    In order to expand the argument, use ``expand()``:
-
-    >>> from sympy.abc import a, b, c, d
-    >>> Covariance(a*X + b*Y, c*Z + d*W)
-    Covariance(a*X + b*Y, c*Z + d*W)
-    >>> Covariance(a*X + b*Y, c*Z + d*W).expand()
-    a*c*Covariance(X, Z) + a*d*Covariance(W, X) + b*c*Covariance(Y, Z) + b*d*Covariance(W, Y)
-
-    This class is aware of some properties of the covariance:
-
-    >>> Covariance(X, X).expand()
-    Variance(X)
-    >>> Covariance(a*X, b*Y).expand()
-    a*b*Covariance(X, Y)
-    """
-
-    def __new__(cls, arg1, arg2, condition=None, **kwargs):
-        arg1 = _sympify(arg1)
-        arg2 = _sympify(arg2)
-
-        if arg1.is_Matrix or arg2.is_Matrix:
-            from sympy.stats.symbolic_multivariate_probability import CrossCovarianceMatrix
-            return CrossCovarianceMatrix(arg1, arg2, condition)
-
-        if kwargs.pop('evaluate', global_parameters.evaluate):
-            arg1, arg2 = sorted([arg1, arg2], key=default_sort_key)
-
-        if condition is None:
-            obj = Expr.__new__(cls, arg1, arg2)
-        else:
-            condition = _sympify(condition)
-            obj = Expr.__new__(cls, arg1, arg2, condition)
-        obj._condition = condition
-        return obj
-
-    def expand(self, **hints):
-        arg1 = self.args[0]
-        arg2 = self.args[1]
-        condition = self._condition
-
-        if arg1 == arg2:
-            return Variance(arg1, condition).expand()
-
-        if not is_random(arg1):
-            return S.Zero
-        if not is_random(arg2):
-            return S.Zero
-
-        arg1, arg2 = sorted([arg1, arg2], key=default_sort_key)
-
-        if isinstance(arg1, RandomSymbol) and isinstance(arg2, RandomSymbol):
-            return Covariance(arg1, arg2, condition)
-
-        coeff_rv_list1 = self._expand_single_argument(arg1.expand())
-        coeff_rv_list2 = self._expand_single_argument(arg2.expand())
-
-        addends = [a*b*Covariance(*sorted([r1, r2], key=default_sort_key), condition=condition)
-                   for (a, r1) in coeff_rv_list1 for (b, r2) in coeff_rv_list2]
-        return Add.fromiter(addends)
-
-    @classmethod
-    def _expand_single_argument(cls, expr):
-        # return (coefficient, random_symbol) pairs:
-        if isinstance(expr, RandomSymbol):
-            return [(S.One, expr)]
-        elif isinstance(expr, Add):
-            outval = []
-            for a in expr.args:
-                if isinstance(a, Mul):
-                    outval.append(cls._get_mul_nonrv_rv_tuple(a))
-                elif is_random(a):
-                    outval.append((S.One, a))
-
-            return outval
-        elif isinstance(expr, Mul):
-            return [cls._get_mul_nonrv_rv_tuple(expr)]
-        elif is_random(expr):
-            return [(S.One, expr)]
-
-    @classmethod
-    def _get_mul_nonrv_rv_tuple(cls, m):
-        rv = []
-        nonrv = []
-        for a in m.args:
-            if is_random(a):
-                rv.append(a)
-            else:
-                nonrv.append(a)
-        return (Mul.fromiter(nonrv), Mul.fromiter(rv))
-
-    def _eval_rewrite_as_Expectation(self, arg1, arg2, condition=None, **kwargs):
-        e1 = Expectation(arg1*arg2, condition)
-        e2 = Expectation(arg1, condition)*Expectation(arg2, condition)
-        return e1 - e2
-
-    def _eval_rewrite_as_Probability(self, arg1, arg2, condition=None, **kwargs):
-        return self.rewrite(Expectation).rewrite(Probability)
-
-    def _eval_rewrite_as_Integral(self, arg1, arg2, condition=None, **kwargs):
-        return covariance(self.args[0], self.args[1], self._condition, evaluate=False)
-
-    _eval_rewrite_as_Sum = _eval_rewrite_as_Integral
-
-    def evaluate_integral(self):
-        return self.rewrite(Integral).doit()
-
-
-class Moment(Expr):
-    """
-    Symbolic class for Moment
-
-    Examples
-    ========
-
-    >>> from sympy import Symbol, Integral
-    >>> from sympy.stats import Normal, Expectation, Probability, Moment
-    >>> mu = Symbol('mu', real=True)
-    >>> sigma = Symbol('sigma', positive=True)
-    >>> X = Normal('X', mu, sigma)
-    >>> M = Moment(X, 3, 1)
-
-    To evaluate the result of Moment use `doit`:
-
-    >>> M.doit()
-    mu**3 - 3*mu**2 + 3*mu*sigma**2 + 3*mu - 3*sigma**2 - 1
-
-    Rewrite the Moment expression in terms of Expectation:
-
-    >>> M.rewrite(Expectation)
-    Expectation((X - 1)**3)
-
-    Rewrite the Moment expression in terms of Probability:
-
-    >>> M.rewrite(Probability)
-    Integral((x - 1)**3*Probability(Eq(X, x)), (x, -oo, oo))
-
-    Rewrite the Moment expression in terms of Integral:
-
-    >>> M.rewrite(Integral)
-    Integral(sqrt(2)*(X - 1)**3*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo))
-
-    """
-    def __new__(cls, X, n, c=0, condition=None, **kwargs):
-        X = _sympify(X)
-        n = _sympify(n)
-        c = _sympify(c)
-        if condition is not None:
-            condition = _sympify(condition)
-            return super().__new__(cls, X, n, c, condition)
-        else:
-            return super().__new__(cls, X, n, c)
-
-    def doit(self, **hints):
-        return self.rewrite(Expectation).doit(**hints)
-
-    def _eval_rewrite_as_Expectation(self, X, n, c=0, condition=None, **kwargs):
-        return Expectation((X - c)**n, condition)
-
-    def _eval_rewrite_as_Probability(self, X, n, c=0, condition=None, **kwargs):
-        return self.rewrite(Expectation).rewrite(Probability)
-
-    def _eval_rewrite_as_Integral(self, X, n, c=0, condition=None, **kwargs):
-        return self.rewrite(Expectation).rewrite(Integral)
-
-
-class CentralMoment(Expr):
-    """
-    Symbolic class Central Moment
-
-    Examples
-    ========
-
-    >>> from sympy import Symbol, Integral
-    >>> from sympy.stats import Normal, Expectation, Probability, CentralMoment
-    >>> mu = Symbol('mu', real=True)
-    >>> sigma = Symbol('sigma', positive=True)
-    >>> X = Normal('X', mu, sigma)
-    >>> CM = CentralMoment(X, 4)
-
-    To evaluate the result of CentralMoment use `doit`:
-
-    >>> CM.doit().simplify()
-    3*sigma**4
-
-    Rewrite the CentralMoment expression in terms of Expectation:
-
-    >>> CM.rewrite(Expectation)
-    Expectation((X - Expectation(X))**4)
-
-    Rewrite the CentralMoment expression in terms of Probability:
-
-    >>> CM.rewrite(Probability)
-    Integral((x - Integral(x*Probability(True), (x, -oo, oo)))**4*Probability(Eq(X, x)), (x, -oo, oo))
-
-    Rewrite the CentralMoment expression in terms of Integral:
-
-    >>> CM.rewrite(Integral)
-    Integral(sqrt(2)*(X - Integral(sqrt(2)*X*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo)))**4*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo))
-
-    """
-    def __new__(cls, X, n, condition=None, **kwargs):
-        X = _sympify(X)
-        n = _sympify(n)
-        if condition is not None:
-            condition = _sympify(condition)
-            return super().__new__(cls, X, n, condition)
-        else:
-            return super().__new__(cls, X, n)
-
-    def doit(self, **hints):
-        return self.rewrite(Expectation).doit(**hints)
-
-    def _eval_rewrite_as_Expectation(self, X, n, condition=None, **kwargs):
-        mu = Expectation(X, condition, **kwargs)
-        return Moment(X, n, mu, condition, **kwargs).rewrite(Expectation)
-
-    def _eval_rewrite_as_Probability(self, X, n, condition=None, **kwargs):
-        return self.rewrite(Expectation).rewrite(Probability)
-
-    def _eval_rewrite_as_Integral(self, X, n, condition=None, **kwargs):
-        return self.rewrite(Expectation).rewrite(Integral)

shared/package-files/9b/9b542cdd392345b80afdab68e0f7056548da6fee5a1315a7bf918d1b54bd957b/blob

@@ -1,11 +0,0 @@
-from .optimizer import Optimizer, ParamsT
-
-class Adadelta(Optimizer):
-    def __init__(
-        self,
-        params: ParamsT,
-        lr: float = ...,
-        rho: float = ...,
-        eps: float = ...,
-        weight_decay: float = ...,
-    ) -> None: ...

shared/package-files/9b/9b5b3703806bbd17835f93e58836a5639dd884f7ef875b3ec7879f6b57e521a1/blob

@@ -1,95 +0,0 @@
-"""A variety of linear models."""
-
-# Authors: The scikit-learn developers
-# SPDX-License-Identifier: BSD-3-Clause
-
-# See http://scikit-learn.sourceforge.net/modules/sgd.html and
-# http://scikit-learn.sourceforge.net/modules/linear_model.html for
-# complete documentation.
-
-from ._base import LinearRegression
-from ._bayes import ARDRegression, BayesianRidge
-from ._coordinate_descent import (
-    ElasticNet,
-    ElasticNetCV,
-    Lasso,
-    LassoCV,
-    MultiTaskElasticNet,
-    MultiTaskElasticNetCV,
-    MultiTaskLasso,
-    MultiTaskLassoCV,
-    enet_path,
-    lasso_path,
-)
-from ._glm import GammaRegressor, PoissonRegressor, TweedieRegressor
-from ._huber import HuberRegressor
-from ._least_angle import (
-    Lars,
-    LarsCV,
-    LassoLars,
-    LassoLarsCV,
-    LassoLarsIC,
-    lars_path,
-    lars_path_gram,
-)
-from ._logistic import LogisticRegression, LogisticRegressionCV
-from ._omp import (
-    OrthogonalMatchingPursuit,
-    OrthogonalMatchingPursuitCV,
-    orthogonal_mp,
-    orthogonal_mp_gram,
-)
-from ._passive_aggressive import PassiveAggressiveClassifier, PassiveAggressiveRegressor
-from ._perceptron import Perceptron
-from ._quantile import QuantileRegressor
-from ._ransac import RANSACRegressor
-from ._ridge import Ridge, RidgeClassifier, RidgeClassifierCV, RidgeCV, ridge_regression
-from ._stochastic_gradient import SGDClassifier, SGDOneClassSVM, SGDRegressor
-from ._theil_sen import TheilSenRegressor
-
-__all__ = [
-    "ARDRegression",
-    "BayesianRidge",
-    "ElasticNet",
-    "ElasticNetCV",
-    "GammaRegressor",
-    "HuberRegressor",
-    "Lars",
-    "LarsCV",
-    "Lasso",
-    "LassoCV",
-    "LassoLars",
-    "LassoLarsCV",
-    "LassoLarsIC",
-    "LinearRegression",
-    "LogisticRegression",
-    "LogisticRegressionCV",
-    "MultiTaskElasticNet",
-    "MultiTaskElasticNetCV",
-    "MultiTaskLasso",
-    "MultiTaskLassoCV",
-    "OrthogonalMatchingPursuit",
-    "OrthogonalMatchingPursuitCV",
-    "PassiveAggressiveClassifier",
-    "PassiveAggressiveRegressor",
-    "Perceptron",
-    "PoissonRegressor",
-    "QuantileRegressor",
-    "RANSACRegressor",
-    "Ridge",
-    "RidgeCV",
-    "RidgeClassifier",
-    "RidgeClassifierCV",
-    "SGDClassifier",
-    "SGDOneClassSVM",
-    "SGDRegressor",
-    "TheilSenRegressor",
-    "TweedieRegressor",
-    "enet_path",
-    "lars_path",
-    "lars_path_gram",
-    "lasso_path",
-    "orthogonal_mp",
-    "orthogonal_mp_gram",
-    "ridge_regression",
-]

shared/package-files/9b/9b62149e65ae88c6dd4da6bc3fd68cac9355d5be78045d9faf3270495fdc5451/blob

@@ -1,160 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from narwhals._compliant.any_namespace import StringNamespace
-from narwhals._pandas_like.utils import (
-    PandasLikeSeriesNamespace,
-    align_and_extract_native,
-    get_dtype_backend,
-    is_dtype_pyarrow,
-)
-from narwhals._utils import str_slice_stop
-
-if TYPE_CHECKING:
-    from narwhals._pandas_like.series import PandasLikeSeries
-
-
-class PandasLikeSeriesStringNamespace(
-    PandasLikeSeriesNamespace, StringNamespace["PandasLikeSeries"]
-):
-    def _with_native_bool(self, result: Any) -> PandasLikeSeries:
-        # See https://narwhals-dev.github.io/narwhals/concepts/boolean/.
-        if (
-            result.dtype == object
-            and get_dtype_backend(self.native.dtype, self.implementation) is None
-        ):
-            not_na = result.notna()
-            all_valid = not_na.all()
-            if not all_valid and self.implementation._backend_version() < (3,):
-                result.where(not_na, False, inplace=True)
-                result = result.astype(bool, copy=False)
-            elif not all_valid:
-                result = result.where(not_na, False).astype(bool)
-            else:  # pragma: no cover
-                pass
-        return self.with_native(result)
-
-    def len_chars(self) -> PandasLikeSeries:
-        result = self.native.str.len()
-        if result.dtype == object:
-            # pandas returns `object` instead of a number for an all-null `object` column.
-            result = self.implementation.to_native_namespace().to_numeric(result)
-        return self.with_native(result)
-
-    def replace(
-        self, value: PandasLikeSeries, pattern: str, *, literal: bool, n: int
-    ) -> PandasLikeSeries:
-        if n == 0:
-            return self.compliant
-        _, value_native = align_and_extract_native(self.compliant, value)
-        if not isinstance(value_native, str):
-            msg = f"{self.compliant._implementation} backed `.str.replace` only supports str replacement values"
-            raise TypeError(msg)
-        series = self.native.str.replace(
-            pat=pattern, repl=value_native, n=n, regex=not literal
-        )
-        return self.with_native(series)
-
-    def replace_all(
-        self, value: PandasLikeSeries, pattern: str, *, literal: bool
-    ) -> PandasLikeSeries:
-        return self.replace(value, pattern, literal=literal, n=-1)
-
-    def strip_chars(self, characters: str | None) -> PandasLikeSeries:
-        return self.with_native(self.native.str.strip(characters))
-
-    def strip_chars_start(self, characters: str) -> PandasLikeSeries:
-        return self.with_native(self.native.str.lstrip(characters))
-
-    def strip_chars_end(self, characters: str) -> PandasLikeSeries:
-        return self.with_native(self.native.str.rstrip(characters))
-
-    def starts_with(self, prefix: PandasLikeSeries) -> PandasLikeSeries:
-        _, prefix_native = align_and_extract_native(self.compliant, prefix)
-        if not isinstance(prefix_native, str):
-            msg = f"`.str.starts_with` only supports prefix values for {self.compliant._implementation} backend"
-            raise TypeError(msg)
-        return self._with_native_bool(self.native.str.startswith(prefix_native))
-
-    def ends_with(self, suffix: PandasLikeSeries) -> PandasLikeSeries:
-        _, suffix_native = align_and_extract_native(self.compliant, suffix)
-        if not isinstance(suffix_native, str):
-            msg = f"`.str.ends_with` only supports suffix values for {self.compliant._implementation} backend"
-            raise TypeError(msg)
-        return self._with_native_bool(self.native.str.endswith(suffix_native))
-
-    def contains(self, pattern: PandasLikeSeries, *, literal: bool) -> PandasLikeSeries:
-        _, pattern_native = align_and_extract_native(self.compliant, pattern)
-        if not isinstance(pattern_native, str):
-            msg = f"`.str.contains` only supports str pattern values for {self.compliant._implementation} backend"
-            raise TypeError(msg)
-        return self._with_native_bool(
-            self.native.str.contains(pat=pattern_native, regex=not literal)
-        )
-
-    def slice(self, offset: int, length: int | None) -> PandasLikeSeries:
-        stop = str_slice_stop(offset, length)
-        return self.with_native(self.native.str.slice(start=offset, stop=stop))
-
-    def split(self, by: str) -> PandasLikeSeries:
-        implementation = self.implementation
-        if not implementation.is_cudf() and not is_dtype_pyarrow(self.native.dtype):
-            msg = (
-                "This operation requires a pyarrow-backed series. "
-                "Please refer to https://narwhals-dev.github.io/narwhals/api-reference/narwhals/#narwhals.maybe_convert_dtypes "
-                "and ensure you are using dtype_backend='pyarrow'. "
-                "Additionally, make sure you have pandas version 1.5+ and pyarrow installed. "
-            )
-            raise TypeError(msg)
-        return self.with_native(self.native.str.split(pat=by))
-
-    def to_datetime(self, format: str | None) -> PandasLikeSeries:
-        # If we know inputs are timezone-aware, we can pass `utc=True` for better performance.
-        if format and any(x in format for x in ("%z", "Z")):
-            return self.with_native(self._to_datetime(format, utc=True))
-        result = self.with_native(self._to_datetime(format, utc=False))
-        if (tz := getattr(result.dtype, "time_zone", None)) and tz != "UTC":
-            return result.dt.convert_time_zone("UTC")
-        return result
-
-    def _to_datetime(self, format: str | None, *, utc: bool) -> Any:
-        result = self.implementation.to_native_namespace().to_datetime(
-            self.native, format=format, utc=utc
-        )
-        return (
-            result.convert_dtypes(dtype_backend="pyarrow")
-            if is_dtype_pyarrow(self.native.dtype)
-            else result
-        )
-
-    def to_date(self, format: str | None) -> PandasLikeSeries:
-        return self.to_datetime(format=format).dt.date()
-
-    def to_time(self, format: str | None) -> PandasLikeSeries:
-        time_dtype = self.version.dtypes.Time()
-        return self.with_native(self._to_datetime(format, utc=False)).cast(time_dtype)
-
-    def to_uppercase(self) -> PandasLikeSeries:
-        return self.with_native(self.native.str.upper())
-
-    def to_lowercase(self) -> PandasLikeSeries:
-        return self.with_native(self.native.str.lower())
-
-    def to_titlecase(self) -> PandasLikeSeries:
-        return self.with_native(self.native.str.title())
-
-    def zfill(self, width: int) -> PandasLikeSeries:
-        if width == 0:
-            return self.compliant
-        return self.with_native(self.native.str.zfill(width))
-
-    def pad_start(self, length: int, fill_char: str) -> PandasLikeSeries:
-        return self.with_native(
-            self.native.str.pad(width=length, fillchar=fill_char, side="left")
-        )
-
-    def pad_end(self, length: int, fill_char: str) -> PandasLikeSeries:
-        return self.with_native(
-            self.native.str.pad(width=length, fillchar=fill_char, side="right")
-        )

shared/package-files/9b/9b633e2d6aa5d803d19bb099de8163f7b49408a1bfaea3fe3e7d519e15dda808/blob

@@ -1,50 +0,0 @@
-#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 ldexp_Tensor {
-  using schema = at::Tensor (const at::Tensor &, const at::Tensor &);
-  using ptr_schema = schema*;
-  // See Note [static constexpr char* members for windows NVCC]
-  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::ldexp")
-  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
-  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "ldexp.Tensor(Tensor self, Tensor other) -> Tensor")
-  static at::Tensor call(const at::Tensor & self, const at::Tensor & other);
-  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other);
-};
-
-struct TORCH_API ldexp_ {
-  using schema = at::Tensor & (at::Tensor &, const at::Tensor &);
-  using ptr_schema = schema*;
-  // See Note [static constexpr char* members for windows NVCC]
-  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::ldexp_")
-  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
-  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "ldexp_(Tensor(a!) self, Tensor other) -> Tensor(a!)")
-  static at::Tensor & call(at::Tensor & self, const at::Tensor & other);
-  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & other);
-};
-
-struct TORCH_API ldexp_out {
-  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &);
-  using ptr_schema = schema*;
-  // See Note [static constexpr char* members for windows NVCC]
-  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::ldexp")
-  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
-  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "ldexp.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)")
-  static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
-  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
-};
-
-}} // namespace at::_ops

shared/package-files/9b/9b65eeebf6d708da9966136f37d3d3eef925cdce7587f22da457eeee1f8ba83e/blob

@@ -1,557 +0,0 @@
-from __future__ import annotations
-
-import ctypes
-import re
-from typing import Any
-
-import numpy as np
-
-from pandas._config import using_string_dtype
-
-from pandas.compat._optional import import_optional_dependency
-from pandas.errors import SettingWithCopyError
-
-import pandas as pd
-from pandas.core.interchange.dataframe_protocol import (
-    Buffer,
-    Column,
-    ColumnNullType,
-    DataFrame as DataFrameXchg,
-    DtypeKind,
-)
-from pandas.core.interchange.utils import (
-    ArrowCTypes,
-    Endianness,
-)
-
-_NP_DTYPES: dict[DtypeKind, dict[int, Any]] = {
-    DtypeKind.INT: {8: np.int8, 16: np.int16, 32: np.int32, 64: np.int64},
-    DtypeKind.UINT: {8: np.uint8, 16: np.uint16, 32: np.uint32, 64: np.uint64},
-    DtypeKind.FLOAT: {32: np.float32, 64: np.float64},
-    DtypeKind.BOOL: {1: bool, 8: bool},
-}
-
-
-def from_dataframe(df, allow_copy: bool = True) -> pd.DataFrame:
-    """
-    Build a ``pd.DataFrame`` from any DataFrame supporting the interchange protocol.
-
-    .. note::
-
-       For new development, we highly recommend using the Arrow C Data Interface
-       alongside the Arrow PyCapsule Interface instead of the interchange protocol.
-       From pandas 2.3 onwards, `from_dataframe` uses the PyCapsule Interface,
-       only falling back to the interchange protocol if that fails.
-
-    .. warning::
-
-        Due to severe implementation issues, we recommend only considering using the
-        interchange protocol in the following cases:
-
-        - converting to pandas: for pandas >= 2.0.3
-        - converting from pandas: for pandas >= 3.0.0
-
-    Parameters
-    ----------
-    df : DataFrameXchg
-        Object supporting the interchange protocol, i.e. `__dataframe__` method.
-    allow_copy : bool, default: True
-        Whether to allow copying the memory to perform the conversion
-        (if false then zero-copy approach is requested).
-
-    Returns
-    -------
-    pd.DataFrame
-
-    Examples
-    --------
-    >>> df_not_necessarily_pandas = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
-    >>> interchange_object = df_not_necessarily_pandas.__dataframe__()
-    >>> interchange_object.column_names()
-    Index(['A', 'B'], dtype='object')
-    >>> df_pandas = (pd.api.interchange.from_dataframe
-    ...              (interchange_object.select_columns_by_name(['A'])))
-    >>> df_pandas
-         A
-    0    1
-    1    2
-
-    These methods (``column_names``, ``select_columns_by_name``) should work
-    for any dataframe library which implements the interchange protocol.
-    """
-    if isinstance(df, pd.DataFrame):
-        return df
-
-    if hasattr(df, "__arrow_c_stream__"):
-        try:
-            pa = import_optional_dependency("pyarrow", min_version="14.0.0")
-        except ImportError:
-            # fallback to _from_dataframe
-            pass
-        else:
-            try:
-                return pa.table(df).to_pandas(zero_copy_only=not allow_copy)
-            except pa.ArrowInvalid as e:
-                raise RuntimeError(e) from e
-
-    if not hasattr(df, "__dataframe__"):
-        raise ValueError("`df` does not support __dataframe__")
-
-    return _from_dataframe(
-        df.__dataframe__(allow_copy=allow_copy), allow_copy=allow_copy
-    )
-
-
-def _from_dataframe(df: DataFrameXchg, allow_copy: bool = True):
-    """
-    Build a ``pd.DataFrame`` from the DataFrame interchange object.
-
-    Parameters
-    ----------
-    df : DataFrameXchg
-        Object supporting the interchange protocol, i.e. `__dataframe__` method.
-    allow_copy : bool, default: True
-        Whether to allow copying the memory to perform the conversion
-        (if false then zero-copy approach is requested).
-
-    Returns
-    -------
-    pd.DataFrame
-    """
-    pandas_dfs = []
-    for chunk in df.get_chunks():
-        pandas_df = protocol_df_chunk_to_pandas(chunk)
-        pandas_dfs.append(pandas_df)
-
-    if not allow_copy and len(pandas_dfs) > 1:
-        raise RuntimeError(
-            "To join chunks a copy is required which is forbidden by allow_copy=False"
-        )
-    if not pandas_dfs:
-        pandas_df = protocol_df_chunk_to_pandas(df)
-    elif len(pandas_dfs) == 1:
-        pandas_df = pandas_dfs[0]
-    else:
-        pandas_df = pd.concat(pandas_dfs, axis=0, ignore_index=True, copy=False)
-
-    index_obj = df.metadata.get("pandas.index", None)
-    if index_obj is not None:
-        pandas_df.index = index_obj
-
-    return pandas_df
-
-
-def protocol_df_chunk_to_pandas(df: DataFrameXchg) -> pd.DataFrame:
-    """
-    Convert interchange protocol chunk to ``pd.DataFrame``.
-
-    Parameters
-    ----------
-    df : DataFrameXchg
-
-    Returns
-    -------
-    pd.DataFrame
-    """
-    columns: dict[str, Any] = {}
-    buffers = []  # hold on to buffers, keeps memory alive
-    for name in df.column_names():
-        if not isinstance(name, str):
-            raise ValueError(f"Column {name} is not a string")
-        if name in columns:
-            raise ValueError(f"Column {name} is not unique")
-        col = df.get_column_by_name(name)
-        dtype = col.dtype[0]
-        if dtype in (
-            DtypeKind.INT,
-            DtypeKind.UINT,
-            DtypeKind.FLOAT,
-            DtypeKind.BOOL,
-        ):
-            columns[name], buf = primitive_column_to_ndarray(col)
-        elif dtype == DtypeKind.CATEGORICAL:
-            columns[name], buf = categorical_column_to_series(col)
-        elif dtype == DtypeKind.STRING:
-            columns[name], buf = string_column_to_ndarray(col)
-        elif dtype == DtypeKind.DATETIME:
-            columns[name], buf = datetime_column_to_ndarray(col)
-        else:
-            raise NotImplementedError(f"Data type {dtype} not handled yet")
-
-        buffers.append(buf)
-
-    pandas_df = pd.DataFrame(columns)
-    pandas_df.attrs["_INTERCHANGE_PROTOCOL_BUFFERS"] = buffers
-    return pandas_df
-
-
-def primitive_column_to_ndarray(col: Column) -> tuple[np.ndarray, Any]:
-    """
-    Convert a column holding one of the primitive dtypes to a NumPy array.
-
-    A primitive type is one of: int, uint, float, bool.
-
-    Parameters
-    ----------
-    col : Column
-
-    Returns
-    -------
-    tuple
-        Tuple of np.ndarray holding the data and the memory owner object
-        that keeps the memory alive.
-    """
-    buffers = col.get_buffers()
-
-    data_buff, data_dtype = buffers["data"]
-    data = buffer_to_ndarray(
-        data_buff, data_dtype, offset=col.offset, length=col.size()
-    )
-
-    data = set_nulls(data, col, buffers["validity"])
-    return data, buffers
-
-
-def categorical_column_to_series(col: Column) -> tuple[pd.Series, Any]:
-    """
-    Convert a column holding categorical data to a pandas Series.
-
-    Parameters
-    ----------
-    col : Column
-
-    Returns
-    -------
-    tuple
-        Tuple of pd.Series holding the data and the memory owner object
-        that keeps the memory alive.
-    """
-    categorical = col.describe_categorical
-
-    if not categorical["is_dictionary"]:
-        raise NotImplementedError("Non-dictionary categoricals not supported yet")
-
-    cat_column = categorical["categories"]
-    if hasattr(cat_column, "_col"):
-        # Item "Column" of "Optional[Column]" has no attribute "_col"
-        # Item "None" of "Optional[Column]" has no attribute "_col"
-        categories = np.array(cat_column._col)  # type: ignore[union-attr]
-    else:
-        raise NotImplementedError(
-            "Interchanging categorical columns isn't supported yet, and our "
-            "fallback of using the `col._col` attribute (a ndarray) failed."
-        )
-    buffers = col.get_buffers()
-
-    codes_buff, codes_dtype = buffers["data"]
-    codes = buffer_to_ndarray(
-        codes_buff, codes_dtype, offset=col.offset, length=col.size()
-    )
-
-    # Doing module in order to not get ``IndexError`` for
-    # out-of-bounds sentinel values in `codes`
-    if len(categories) > 0:
-        values = categories[codes % len(categories)]
-    else:
-        values = codes
-
-    cat = pd.Categorical(
-        values, categories=categories, ordered=categorical["is_ordered"]
-    )
-    data = pd.Series(cat)
-
-    data = set_nulls(data, col, buffers["validity"])
-    return data, buffers
-
-
-def string_column_to_ndarray(col: Column) -> tuple[np.ndarray, Any]:
-    """
-    Convert a column holding string data to a NumPy array.
-
-    Parameters
-    ----------
-    col : Column
-
-    Returns
-    -------
-    tuple
-        Tuple of np.ndarray holding the data and the memory owner object
-        that keeps the memory alive.
-    """
-    null_kind, sentinel_val = col.describe_null
-
-    if null_kind not in (
-        ColumnNullType.NON_NULLABLE,
-        ColumnNullType.USE_BITMASK,
-        ColumnNullType.USE_BYTEMASK,
-    ):
-        raise NotImplementedError(
-            f"{null_kind} null kind is not yet supported for string columns."
-        )
-
-    buffers = col.get_buffers()
-
-    assert buffers["offsets"], "String buffers must contain offsets"
-    # Retrieve the data buffer containing the UTF-8 code units
-    data_buff, _ = buffers["data"]
-    # We're going to reinterpret the buffer as uint8, so make sure we can do it safely
-    assert col.dtype[2] in (
-        ArrowCTypes.STRING,
-        ArrowCTypes.LARGE_STRING,
-    )  # format_str == utf-8
-    # Convert the buffers to NumPy arrays. In order to go from STRING to
-    # an equivalent ndarray, we claim that the buffer is uint8 (i.e., a byte array)
-    data_dtype = (
-        DtypeKind.UINT,
-        8,
-        ArrowCTypes.UINT8,
-        Endianness.NATIVE,
-    )
-    # Specify zero offset as we don't want to chunk the string data
-    data = buffer_to_ndarray(data_buff, data_dtype, offset=0, length=data_buff.bufsize)
-
-    # Retrieve the offsets buffer containing the index offsets demarcating
-    # the beginning and the ending of each string
-    offset_buff, offset_dtype = buffers["offsets"]
-    # Offsets buffer contains start-stop positions of strings in the data buffer,
-    # meaning that it has more elements than in the data buffer, do `col.size() + 1`
-    # here to pass a proper offsets buffer size
-    offsets = buffer_to_ndarray(
-        offset_buff, offset_dtype, offset=col.offset, length=col.size() + 1
-    )
-
-    null_pos = None
-    if null_kind in (ColumnNullType.USE_BITMASK, ColumnNullType.USE_BYTEMASK):
-        validity = buffers["validity"]
-        if validity is not None:
-            valid_buff, valid_dtype = validity
-            null_pos = buffer_to_ndarray(
-                valid_buff, valid_dtype, offset=col.offset, length=col.size()
-            )
-            if sentinel_val == 0:
-                null_pos = ~null_pos
-
-    # Assemble the strings from the code units
-    str_list: list[None | float | str] = [None] * col.size()
-    for i in range(col.size()):
-        # Check for missing values
-        if null_pos is not None and null_pos[i]:
-            str_list[i] = np.nan
-            continue
-
-        # Extract a range of code units
-        units = data[offsets[i] : offsets[i + 1]]
-
-        # Convert the list of code units to bytes
-        str_bytes = bytes(units)
-
-        # Create the string
-        string = str_bytes.decode(encoding="utf-8")
-
-        # Add to our list of strings
-        str_list[i] = string
-
-    if using_string_dtype():
-        res = pd.Series(str_list, dtype="str")
-    else:
-        res = np.asarray(str_list, dtype="object")  # type: ignore[assignment]
-
-    return res, buffers  # type: ignore[return-value]
-
-
-def parse_datetime_format_str(format_str, data) -> pd.Series | np.ndarray:
-    """Parse datetime `format_str` to interpret the `data`."""
-    # timestamp 'ts{unit}:tz'
-    timestamp_meta = re.match(r"ts([smun]):(.*)", format_str)
-    if timestamp_meta:
-        unit, tz = timestamp_meta.group(1), timestamp_meta.group(2)
-        if unit != "s":
-            # the format string describes only a first letter of the unit, so
-            # add one extra letter to convert the unit to numpy-style:
-            # 'm' -> 'ms', 'u' -> 'us', 'n' -> 'ns'
-            unit += "s"
-        data = data.astype(f"datetime64[{unit}]")
-        if tz != "":
-            data = pd.Series(data).dt.tz_localize("UTC").dt.tz_convert(tz)
-        return data
-
-    # date 'td{Days/Ms}'
-    date_meta = re.match(r"td([Dm])", format_str)
-    if date_meta:
-        unit = date_meta.group(1)
-        if unit == "D":
-            # NumPy doesn't support DAY unit, so converting days to seconds
-            # (converting to uint64 to avoid overflow)
-            data = (data.astype(np.uint64) * (24 * 60 * 60)).astype("datetime64[s]")
-        elif unit == "m":
-            data = data.astype("datetime64[ms]")
-        else:
-            raise NotImplementedError(f"Date unit is not supported: {unit}")
-        return data
-
-    raise NotImplementedError(f"DateTime kind is not supported: {format_str}")
-
-
-def datetime_column_to_ndarray(col: Column) -> tuple[np.ndarray | pd.Series, Any]:
-    """
-    Convert a column holding DateTime data to a NumPy array.
-
-    Parameters
-    ----------
-    col : Column
-
-    Returns
-    -------
-    tuple
-        Tuple of np.ndarray holding the data and the memory owner object
-        that keeps the memory alive.
-    """
-    buffers = col.get_buffers()
-
-    _, col_bit_width, format_str, _ = col.dtype
-    dbuf, _ = buffers["data"]
-    # Consider dtype being `uint` to get number of units passed since the 01.01.1970
-
-    data = buffer_to_ndarray(
-        dbuf,
-        (
-            DtypeKind.INT,
-            col_bit_width,
-            getattr(ArrowCTypes, f"INT{col_bit_width}"),
-            Endianness.NATIVE,
-        ),
-        offset=col.offset,
-        length=col.size(),
-    )
-
-    data = parse_datetime_format_str(format_str, data)  # type: ignore[assignment]
-    data = set_nulls(data, col, buffers["validity"])
-    return data, buffers
-
-
-def buffer_to_ndarray(
-    buffer: Buffer,
-    dtype: tuple[DtypeKind, int, str, str],
-    *,
-    length: int,
-    offset: int = 0,
-) -> np.ndarray:
-    """
-    Build a NumPy array from the passed buffer.
-
-    Parameters
-    ----------
-    buffer : Buffer
-        Buffer to build a NumPy array from.
-    dtype : tuple
-        Data type of the buffer conforming protocol dtypes format.
-    offset : int, default: 0
-        Number of elements to offset from the start of the buffer.
-    length : int, optional
-        If the buffer is a bit-mask, specifies a number of bits to read
-        from the buffer. Has no effect otherwise.
-
-    Returns
-    -------
-    np.ndarray
-
-    Notes
-    -----
-    The returned array doesn't own the memory. The caller of this function is
-    responsible for keeping the memory owner object alive as long as
-    the returned NumPy array is being used.
-    """
-    kind, bit_width, _, _ = dtype
-
-    column_dtype = _NP_DTYPES.get(kind, {}).get(bit_width, None)
-    if column_dtype is None:
-        raise NotImplementedError(f"Conversion for {dtype} is not yet supported.")
-
-    # TODO: No DLPack yet, so need to construct a new ndarray from the data pointer
-    # and size in the buffer plus the dtype on the column. Use DLPack as NumPy supports
-    # it since https://github.com/numpy/numpy/pull/19083
-    ctypes_type = np.ctypeslib.as_ctypes_type(column_dtype)
-
-    if bit_width == 1:
-        assert length is not None, "`length` must be specified for a bit-mask buffer."
-        pa = import_optional_dependency("pyarrow")
-        arr = pa.BooleanArray.from_buffers(
-            pa.bool_(),
-            length,
-            [None, pa.foreign_buffer(buffer.ptr, length)],
-            offset=offset,
-        )
-        return np.asarray(arr)
-    else:
-        data_pointer = ctypes.cast(
-            buffer.ptr + (offset * bit_width // 8), ctypes.POINTER(ctypes_type)
-        )
-        if length > 0:
-            return np.ctypeslib.as_array(data_pointer, shape=(length,))
-        return np.array([], dtype=ctypes_type)
-
-
-def set_nulls(
-    data: np.ndarray | pd.Series,
-    col: Column,
-    validity: tuple[Buffer, tuple[DtypeKind, int, str, str]] | None,
-    allow_modify_inplace: bool = True,
-):
-    """
-    Set null values for the data according to the column null kind.
-
-    Parameters
-    ----------
-    data : np.ndarray or pd.Series
-        Data to set nulls in.
-    col : Column
-        Column object that describes the `data`.
-    validity : tuple(Buffer, dtype) or None
-        The return value of ``col.buffers()``. We do not access the ``col.buffers()``
-        here to not take the ownership of the memory of buffer objects.
-    allow_modify_inplace : bool, default: True
-        Whether to modify the `data` inplace when zero-copy is possible (True) or always
-        modify a copy of the `data` (False).
-
-    Returns
-    -------
-    np.ndarray or pd.Series
-        Data with the nulls being set.
-    """
-    if validity is None:
-        return data
-    null_kind, sentinel_val = col.describe_null
-    null_pos = None
-
-    if null_kind == ColumnNullType.USE_SENTINEL:
-        null_pos = pd.Series(data) == sentinel_val
-    elif null_kind in (ColumnNullType.USE_BITMASK, ColumnNullType.USE_BYTEMASK):
-        assert validity, "Expected to have a validity buffer for the mask"
-        valid_buff, valid_dtype = validity
-        null_pos = buffer_to_ndarray(
-            valid_buff, valid_dtype, offset=col.offset, length=col.size()
-        )
-        if sentinel_val == 0:
-            null_pos = ~null_pos
-    elif null_kind in (ColumnNullType.NON_NULLABLE, ColumnNullType.USE_NAN):
-        pass
-    else:
-        raise NotImplementedError(f"Null kind {null_kind} is not yet supported.")
-
-    if null_pos is not None and np.any(null_pos):
-        if not allow_modify_inplace:
-            data = data.copy()
-        try:
-            data[null_pos] = None
-        except TypeError:
-            # TypeError happens if the `data` dtype appears to be non-nullable
-            # in numpy notation (bool, int, uint). If this happens,
-            # cast the `data` to nullable float dtype.
-            data = data.astype(float)
-            data[null_pos] = None
-        except SettingWithCopyError:
-            # `SettingWithCopyError` may happen for datetime-like with missing values.
-            data = data.copy()
-            data[null_pos] = None
-
-    return data

shared/package-files/9b/9b66f7e1cf75ec85b9a3e43fe936081e5b0af6549494d8b2ac84d3507ff3c1ec/blob

@@ -1,353 +0,0 @@
-"""This is invoked in a subprocess to call the build backend hooks.
-
-It expects:
-- Command line args: hook_name, control_dir
-- Environment variables:
-      PEP517_BUILD_BACKEND=entry.point:spec
-      PEP517_BACKEND_PATH=paths (separated with os.pathsep)
-- control_dir/input.json:
-  - {"kwargs": {...}}
-
-Results:
-- control_dir/output.json
-  - {"return_val": ...}
-"""
-import json
-import os
-import os.path
-import re
-import shutil
-import sys
-import traceback
-from glob import glob
-from importlib import import_module
-from os.path import join as pjoin
-
-# This file is run as a script, and `import wrappers` is not zip-safe, so we
-# include write_json() and read_json() from wrappers.py.
-
-
-def write_json(obj, path, **kwargs):
-    with open(path, 'w', encoding='utf-8') as f:
-        json.dump(obj, f, **kwargs)
-
-
-def read_json(path):
-    with open(path, encoding='utf-8') as f:
-        return json.load(f)
-
-
-class BackendUnavailable(Exception):
-    """Raised if we cannot import the backend"""
-    def __init__(self, traceback):
-        self.traceback = traceback
-
-
-class BackendInvalid(Exception):
-    """Raised if the backend is invalid"""
-    def __init__(self, message):
-        self.message = message
-
-
-class HookMissing(Exception):
-    """Raised if a hook is missing and we are not executing the fallback"""
-    def __init__(self, hook_name=None):
-        super().__init__(hook_name)
-        self.hook_name = hook_name
-
-
-def contained_in(filename, directory):
-    """Test if a file is located within the given directory."""
-    filename = os.path.normcase(os.path.abspath(filename))
-    directory = os.path.normcase(os.path.abspath(directory))
-    return os.path.commonprefix([filename, directory]) == directory
-
-
-def _build_backend():
-    """Find and load the build backend"""
-    # Add in-tree backend directories to the front of sys.path.
-    backend_path = os.environ.get('PEP517_BACKEND_PATH')
-    if backend_path:
-        extra_pathitems = backend_path.split(os.pathsep)
-        sys.path[:0] = extra_pathitems
-
-    ep = os.environ['PEP517_BUILD_BACKEND']
-    mod_path, _, obj_path = ep.partition(':')
-    try:
-        obj = import_module(mod_path)
-    except ImportError:
-        raise BackendUnavailable(traceback.format_exc())
-
-    if backend_path:
-        if not any(
-            contained_in(obj.__file__, path)
-            for path in extra_pathitems
-        ):
-            raise BackendInvalid("Backend was not loaded from backend-path")
-
-    if obj_path:
-        for path_part in obj_path.split('.'):
-            obj = getattr(obj, path_part)
-    return obj
-
-
-def _supported_features():
-    """Return the list of options features supported by the backend.
-
-    Returns a list of strings.
-    The only possible value is 'build_editable'.
-    """
-    backend = _build_backend()
-    features = []
-    if hasattr(backend, "build_editable"):
-        features.append("build_editable")
-    return features
-
-
-def get_requires_for_build_wheel(config_settings):
-    """Invoke the optional get_requires_for_build_wheel hook
-
-    Returns [] if the hook is not defined.
-    """
-    backend = _build_backend()
-    try:
-        hook = backend.get_requires_for_build_wheel
-    except AttributeError:
-        return []
-    else:
-        return hook(config_settings)
-
-
-def get_requires_for_build_editable(config_settings):
-    """Invoke the optional get_requires_for_build_editable hook
-
-    Returns [] if the hook is not defined.
-    """
-    backend = _build_backend()
-    try:
-        hook = backend.get_requires_for_build_editable
-    except AttributeError:
-        return []
-    else:
-        return hook(config_settings)
-
-
-def prepare_metadata_for_build_wheel(
-        metadata_directory, config_settings, _allow_fallback):
-    """Invoke optional prepare_metadata_for_build_wheel
-
-    Implements a fallback by building a wheel if the hook isn't defined,
-    unless _allow_fallback is False in which case HookMissing is raised.
-    """
-    backend = _build_backend()
-    try:
-        hook = backend.prepare_metadata_for_build_wheel
-    except AttributeError:
-        if not _allow_fallback:
-            raise HookMissing()
-    else:
-        return hook(metadata_directory, config_settings)
-    # fallback to build_wheel outside the try block to avoid exception chaining
-    # which can be confusing to users and is not relevant
-    whl_basename = backend.build_wheel(metadata_directory, config_settings)
-    return _get_wheel_metadata_from_wheel(whl_basename, metadata_directory,
-                                          config_settings)
-
-
-def prepare_metadata_for_build_editable(
-        metadata_directory, config_settings, _allow_fallback):
-    """Invoke optional prepare_metadata_for_build_editable
-
-    Implements a fallback by building an editable wheel if the hook isn't
-    defined, unless _allow_fallback is False in which case HookMissing is
-    raised.
-    """
-    backend = _build_backend()
-    try:
-        hook = backend.prepare_metadata_for_build_editable
-    except AttributeError:
-        if not _allow_fallback:
-            raise HookMissing()
-        try:
-            build_hook = backend.build_editable
-        except AttributeError:
-            raise HookMissing(hook_name='build_editable')
-        else:
-            whl_basename = build_hook(metadata_directory, config_settings)
-            return _get_wheel_metadata_from_wheel(whl_basename,
-                                                  metadata_directory,
-                                                  config_settings)
-    else:
-        return hook(metadata_directory, config_settings)
-
-
-WHEEL_BUILT_MARKER = 'PEP517_ALREADY_BUILT_WHEEL'
-
-
-def _dist_info_files(whl_zip):
-    """Identify the .dist-info folder inside a wheel ZipFile."""
-    res = []
-    for path in whl_zip.namelist():
-        m = re.match(r'[^/\\]+-[^/\\]+\.dist-info/', path)
-        if m:
-            res.append(path)
-    if res:
-        return res
-    raise Exception("No .dist-info folder found in wheel")
-
-
-def _get_wheel_metadata_from_wheel(
-        whl_basename, metadata_directory, config_settings):
-    """Extract the metadata from a wheel.
-
-    Fallback for when the build backend does not
-    define the 'get_wheel_metadata' hook.
-    """
-    from zipfile import ZipFile
-    with open(os.path.join(metadata_directory, WHEEL_BUILT_MARKER), 'wb'):
-        pass  # Touch marker file
-
-    whl_file = os.path.join(metadata_directory, whl_basename)
-    with ZipFile(whl_file) as zipf:
-        dist_info = _dist_info_files(zipf)
-        zipf.extractall(path=metadata_directory, members=dist_info)
-    return dist_info[0].split('/')[0]
-
-
-def _find_already_built_wheel(metadata_directory):
-    """Check for a wheel already built during the get_wheel_metadata hook.
-    """
-    if not metadata_directory:
-        return None
-    metadata_parent = os.path.dirname(metadata_directory)
-    if not os.path.isfile(pjoin(metadata_parent, WHEEL_BUILT_MARKER)):
-        return None
-
-    whl_files = glob(os.path.join(metadata_parent, '*.whl'))
-    if not whl_files:
-        print('Found wheel built marker, but no .whl files')
-        return None
-    if len(whl_files) > 1:
-        print('Found multiple .whl files; unspecified behaviour. '
-              'Will call build_wheel.')
-        return None
-
-    # Exactly one .whl file
-    return whl_files[0]
-
-
-def build_wheel(wheel_directory, config_settings, metadata_directory=None):
-    """Invoke the mandatory build_wheel hook.
-
-    If a wheel was already built in the
-    prepare_metadata_for_build_wheel fallback, this
-    will copy it rather than rebuilding the wheel.
-    """
-    prebuilt_whl = _find_already_built_wheel(metadata_directory)
-    if prebuilt_whl:
-        shutil.copy2(prebuilt_whl, wheel_directory)
-        return os.path.basename(prebuilt_whl)
-
-    return _build_backend().build_wheel(wheel_directory, config_settings,
-                                        metadata_directory)
-
-
-def build_editable(wheel_directory, config_settings, metadata_directory=None):
-    """Invoke the optional build_editable hook.
-
-    If a wheel was already built in the
-    prepare_metadata_for_build_editable fallback, this
-    will copy it rather than rebuilding the wheel.
-    """
-    backend = _build_backend()
-    try:
-        hook = backend.build_editable
-    except AttributeError:
-        raise HookMissing()
-    else:
-        prebuilt_whl = _find_already_built_wheel(metadata_directory)
-        if prebuilt_whl:
-            shutil.copy2(prebuilt_whl, wheel_directory)
-            return os.path.basename(prebuilt_whl)
-
-        return hook(wheel_directory, config_settings, metadata_directory)
-
-
-def get_requires_for_build_sdist(config_settings):
-    """Invoke the optional get_requires_for_build_wheel hook
-
-    Returns [] if the hook is not defined.
-    """
-    backend = _build_backend()
-    try:
-        hook = backend.get_requires_for_build_sdist
-    except AttributeError:
-        return []
-    else:
-        return hook(config_settings)
-
-
-class _DummyException(Exception):
-    """Nothing should ever raise this exception"""
-
-
-class GotUnsupportedOperation(Exception):
-    """For internal use when backend raises UnsupportedOperation"""
-    def __init__(self, traceback):
-        self.traceback = traceback
-
-
-def build_sdist(sdist_directory, config_settings):
-    """Invoke the mandatory build_sdist hook."""
-    backend = _build_backend()
-    try:
-        return backend.build_sdist(sdist_directory, config_settings)
-    except getattr(backend, 'UnsupportedOperation', _DummyException):
-        raise GotUnsupportedOperation(traceback.format_exc())
-
-
-HOOK_NAMES = {
-    'get_requires_for_build_wheel',
-    'prepare_metadata_for_build_wheel',
-    'build_wheel',
-    'get_requires_for_build_editable',
-    'prepare_metadata_for_build_editable',
-    'build_editable',
-    'get_requires_for_build_sdist',
-    'build_sdist',
-    '_supported_features',
-}
-
-
-def main():
-    if len(sys.argv) < 3:
-        sys.exit("Needs args: hook_name, control_dir")
-    hook_name = sys.argv[1]
-    control_dir = sys.argv[2]
-    if hook_name not in HOOK_NAMES:
-        sys.exit("Unknown hook: %s" % hook_name)
-    hook = globals()[hook_name]
-
-    hook_input = read_json(pjoin(control_dir, 'input.json'))
-
-    json_out = {'unsupported': False, 'return_val': None}
-    try:
-        json_out['return_val'] = hook(**hook_input['kwargs'])
-    except BackendUnavailable as e:
-        json_out['no_backend'] = True
-        json_out['traceback'] = e.traceback
-    except BackendInvalid as e:
-        json_out['backend_invalid'] = True
-        json_out['backend_error'] = e.message
-    except GotUnsupportedOperation as e:
-        json_out['unsupported'] = True
-        json_out['traceback'] = e.traceback
-    except HookMissing as e:
-        json_out['hook_missing'] = True
-        json_out['missing_hook_name'] = e.hook_name or hook_name
-
-    write_json(json_out, pjoin(control_dir, 'output.json'), indent=2)
-
-
-if __name__ == '__main__':
-    main()

shared/package-files/9b/9b6742f1d21425a930997735c01c838096af851948a118f4923bade4c777e9e7/blob

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

shared/package-files/9b/9b6cdb3f80bbf7a16f415b15566b175028b3f0fae3d8efa94f9e6b6c70363700/blob

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <Python.h>
-
-// @generated from ../tools/autograd/templates/python_functions.h
-
-// Python bindings for automatically generated autograd functions
-
-namespace torch { namespace autograd { namespace generated {
-
-void initialize_autogenerated_functions_0(PyObject* module);
-void initialize_autogenerated_functions_1(PyObject* module);
-void initialize_autogenerated_functions_2(PyObject* module);
-void initialize_autogenerated_functions_3(PyObject* module);
-void initialize_autogenerated_functions_4(PyObject* module);
-
-inline void initialize_autogenerated_functions(PyObject* module) {
-  initialize_autogenerated_functions_0(module);
-  initialize_autogenerated_functions_1(module);
-  initialize_autogenerated_functions_2(module);
-  initialize_autogenerated_functions_3(module);
-  initialize_autogenerated_functions_4(module);
-}
-
-}}} // namespace torch::autograd::generated

shared/package-files/9b/9b6d58df002d41cfa38ba55e6fa93f33983a034672148e1e81c853767c21fa94/blob

@@ -1,11 +0,0 @@
-"""For when pip wants to check the date or time.
-"""
-
-import datetime
-
-
-def today_is_later_than(year: int, month: int, day: int) -> bool:
-    today = datetime.date.today()
-    given = datetime.date(year, month, day)
-
-    return today > given

shared/package-files/9b/9b6e400eb85440ec64ab66b4ac111546585740c9ca61fd156400d7153cbad9f4/blob

@@ -1,335 +0,0 @@
-# history.tcl --
-#
-# Implementation of the history command.
-#
-# Copyright (c) 1997 Sun Microsystems, Inc.
-#
-# See the file "license.terms" for information on usage and redistribution of
-# this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-
-# The tcl::history array holds the history list and some additional
-# bookkeeping variables.
-#
-# nextid	the index used for the next history list item.
-# keep		the max size of the history list
-# oldest	the index of the oldest item in the history.
-
-namespace eval ::tcl {
-    variable history
-    if {![info exists history]} {
-	array set history {
-	    nextid	0
-	    keep	20
-	    oldest	-20
-	}
-    }
-
-    namespace ensemble create -command ::tcl::history -map {
-	add	::tcl::HistAdd
-	change	::tcl::HistChange
-	clear	::tcl::HistClear
-	event	::tcl::HistEvent
-	info	::tcl::HistInfo
-	keep	::tcl::HistKeep
-	nextid	::tcl::HistNextID
-	redo	::tcl::HistRedo
-    }
-}
-
-# history --
-#
-#	This is the main history command.  See the man page for its interface.
-#	This does some argument checking and calls the helper ensemble in the
-#	tcl namespace.
-
-proc ::history {args} {
-    # If no command given, we're doing 'history info'. Can't be done with an
-    # ensemble unknown handler, as those don't fire when no subcommand is
-    # given at all.
-
-    if {![llength $args]} {
-	set args info
-    }
-
-    # Tricky stuff needed to make stack and errors come out right!
-    tailcall apply {arglist {tailcall history {*}$arglist} ::tcl} $args
-}
-
-# (unnamed) --
-#
-#	Callback when [::history] is destroyed. Destroys the implementation.
-#
-# Parameters:
-#	oldName    what the command was called.
-#	newName    what the command is now called (an empty string).
-#	op	   the operation (= delete).
-#
-# Results:
-#	none
-#
-# Side Effects:
-#	The implementation of the [::history] command ceases to exist.
-
-trace add command ::history delete [list apply {{oldName newName op} {
-    variable history
-    unset -nocomplain history
-    foreach c [info procs ::tcl::Hist*] {
-	rename $c {}
-    }
-    rename ::tcl::history {}
-} ::tcl}]
-
-# tcl::HistAdd --
-#
-#	Add an item to the history, and optionally eval it at the global scope
-#
-# Parameters:
-#	event		the command to add
-#	exec		(optional) a substring of "exec" causes the command to
-#			be evaled.
-# Results:
-# 	If executing, then the results of the command are returned
-#
-# Side Effects:
-#	Adds to the history list
-
-proc ::tcl::HistAdd {event {exec {}}} {
-    variable history
-
-    if {
-	[prefix longest {exec {}} $exec] eq ""
-	&& [llength [info level 0]] == 3
-    } then {
-	return -code error "bad argument \"$exec\": should be \"exec\""
-    }
-
-    # Do not add empty commands to the history
-    if {[string trim $event] eq ""} {
-	return ""
-    }
-
-    # Maintain the history
-    set history([incr history(nextid)]) $event
-    unset -nocomplain history([incr history(oldest)])
-
-    # Only execute if 'exec' (or non-empty prefix of it) given
-    if {$exec eq ""} {
-	return ""
-    }
-    tailcall eval $event
-}
-
-# tcl::HistKeep --
-#
-#	Set or query the limit on the length of the history list
-#
-# Parameters:
-#	limit	(optional) the length of the history list
-#
-# Results:
-#	If no limit is specified, the current limit is returned
-#
-# Side Effects:
-#	Updates history(keep) if a limit is specified
-
-proc ::tcl::HistKeep {{count {}}} {
-    variable history
-    if {[llength [info level 0]] == 1} {
-	return $history(keep)
-    }
-    if {![string is integer -strict $count] || ($count < 0)} {
-	return -code error "illegal keep count \"$count\""
-    }
-    set oldold $history(oldest)
-    set history(oldest) [expr {$history(nextid) - $count}]
-    for {} {$oldold <= $history(oldest)} {incr oldold} {
-	unset -nocomplain history($oldold)
-    }
-    set history(keep) $count
-}
-
-# tcl::HistClear --
-#
-#	Erase the history list
-#
-# Parameters:
-#	none
-#
-# Results:
-#	none
-#
-# Side Effects:
-#	Resets the history array, except for the keep limit
-
-proc ::tcl::HistClear {} {
-    variable history
-    set keep $history(keep)
-    unset history
-    array set history [list \
-	nextid	0	\
-	keep	$keep	\
-	oldest	-$keep	\
-    ]
-}
-
-# tcl::HistInfo --
-#
-#	Return a pretty-printed version of the history list
-#
-# Parameters:
-#	num	(optional) the length of the history list to return
-#
-# Results:
-#	A formatted history list
-
-proc ::tcl::HistInfo {{count {}}} {
-    variable history
-    if {[llength [info level 0]] == 1} {
-	set count [expr {$history(keep) + 1}]
-    } elseif {![string is integer -strict $count]} {
-	return -code error "bad integer \"$count\""
-    }
-    set result {}
-    set newline ""
-    for {set i [expr {$history(nextid) - $count + 1}]} \
-	    {$i <= $history(nextid)} {incr i} {
-	if {![info exists history($i)]} {
-	    continue
-	}
-        set cmd [string map [list \n \n\t] [string trimright $history($i) \ \n]]
-	append result $newline[format "%6d  %s" $i $cmd]
-	set newline \n
-    }
-    return $result
-}
-
-# tcl::HistRedo --
-#
-#	Fetch the previous or specified event, execute it, and then replace
-#	the current history item with that event.
-#
-# Parameters:
-#	event	(optional) index of history item to redo.  Defaults to -1,
-#		which means the previous event.
-#
-# Results:
-#	Those of the command being redone.
-#
-# Side Effects:
-#	Replaces the current history list item with the one being redone.
-
-proc ::tcl::HistRedo {{event -1}} {
-    variable history
-
-    set i [HistIndex $event]
-    if {$i == $history(nextid)} {
-	return -code error "cannot redo the current event"
-    }
-    set cmd $history($i)
-    HistChange $cmd 0
-    tailcall eval $cmd
-}
-
-# tcl::HistIndex --
-#
-#	Map from an event specifier to an index in the history list.
-#
-# Parameters:
-#	event	index of history item to redo.
-#		If this is a positive number, it is used directly.
-#		If it is a negative number, then it counts back to a previous
-#		event, where -1 is the most recent event.
-#		A string can be matched, either by being the prefix of a
-#		command or by matching a command with string match.
-#
-# Results:
-#	The index into history, or an error if the index didn't match.
-
-proc ::tcl::HistIndex {event} {
-    variable history
-    if {![string is integer -strict $event]} {
-	for {set i [expr {$history(nextid)-1}]} {[info exists history($i)]} \
-		{incr i -1} {
-	    if {[string match $event* $history($i)]} {
-		return $i
-	    }
-	    if {[string match $event $history($i)]} {
-		return $i
-	    }
-	}
-	return -code error "no event matches \"$event\""
-    } elseif {$event <= 0} {
-	set i [expr {$history(nextid) + $event}]
-    } else {
-	set i $event
-    }
-    if {$i <= $history(oldest)} {
-	return -code error "event \"$event\" is too far in the past"
-    }
-    if {$i > $history(nextid)} {
-	return -code error "event \"$event\" hasn't occured yet"
-    }
-    return $i
-}
-
-# tcl::HistEvent --
-#
-#	Map from an event specifier to the value in the history list.
-#
-# Parameters:
-#	event	index of history item to redo.  See index for a description of
-#		possible event patterns.
-#
-# Results:
-#	The value from the history list.
-
-proc ::tcl::HistEvent {{event -1}} {
-    variable history
-    set i [HistIndex $event]
-    if {![info exists history($i)]} {
-	return ""
-    }
-    return [string trimright $history($i) \ \n]
-}
-
-# tcl::HistChange --
-#
-#	Replace a value in the history list.
-#
-# Parameters:
-#	newValue  The new value to put into the history list.
-#	event	  (optional) index of history item to redo.  See index for a
-#		  description of possible event patterns.  This defaults to 0,
-#		  which specifies the current event.
-#
-# Side Effects:
-#	Changes the history list.
-
-proc ::tcl::HistChange {newValue {event 0}} {
-    variable history
-    set i [HistIndex $event]
-    set history($i) $newValue
-}
-
-# tcl::HistNextID --
-#
-#	Returns the number of the next history event.
-#
-# Parameters:
-#	None.
-#
-# Side Effects:
-#	None.
-
-proc ::tcl::HistNextID {} {
-    variable history
-    return [expr {$history(nextid) + 1}]
-}
-
-return
-
-# Local Variables:
-# mode: tcl
-# fill-column: 78
-# End:

shared/package-files/9b/9b6fd8df3c9d5193733e9bbcf27f303cd5aa6b17da01330a128ff30205ccab26/blob

@@ -1,166 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-import inspect
-from types import FunctionType
-from typing import Any
-from typing import final
-from typing import Generic
-from typing import TypeVar
-import warnings
-
-
-class PytestWarning(UserWarning):
-    """Base class for all warnings emitted by pytest."""
-
-    __module__ = "pytest"
-
-
-@final
-class PytestAssertRewriteWarning(PytestWarning):
-    """Warning emitted by the pytest assert rewrite module."""
-
-    __module__ = "pytest"
-
-
-@final
-class PytestCacheWarning(PytestWarning):
-    """Warning emitted by the cache plugin in various situations."""
-
-    __module__ = "pytest"
-
-
-@final
-class PytestConfigWarning(PytestWarning):
-    """Warning emitted for configuration issues."""
-
-    __module__ = "pytest"
-
-
-@final
-class PytestCollectionWarning(PytestWarning):
-    """Warning emitted when pytest is not able to collect a file or symbol in a module."""
-
-    __module__ = "pytest"
-
-
-class PytestDeprecationWarning(PytestWarning, DeprecationWarning):
-    """Warning class for features that will be removed in a future version."""
-
-    __module__ = "pytest"
-
-
-class PytestRemovedIn9Warning(PytestDeprecationWarning):
-    """Warning class for features that will be removed in pytest 9."""
-
-    __module__ = "pytest"
-
-
-class PytestReturnNotNoneWarning(PytestWarning):
-    """Warning emitted when a test function is returning value other than None."""
-
-    __module__ = "pytest"
-
-
-@final
-class PytestExperimentalApiWarning(PytestWarning, FutureWarning):
-    """Warning category used to denote experiments in pytest.
-
-    Use sparingly as the API might change or even be removed completely in a
-    future version.
-    """
-
-    __module__ = "pytest"
-
-    @classmethod
-    def simple(cls, apiname: str) -> PytestExperimentalApiWarning:
-        return cls(f"{apiname} is an experimental api that may change over time")
-
-
-@final
-class PytestUnhandledCoroutineWarning(PytestReturnNotNoneWarning):
-    """Warning emitted for an unhandled coroutine.
-
-    A coroutine was encountered when collecting test functions, but was not
-    handled by any async-aware plugin.
-    Coroutine test functions are not natively supported.
-    """
-
-    __module__ = "pytest"
-
-
-@final
-class PytestUnknownMarkWarning(PytestWarning):
-    """Warning emitted on use of unknown markers.
-
-    See :ref:`mark` for details.
-    """
-
-    __module__ = "pytest"
-
-
-@final
-class PytestUnraisableExceptionWarning(PytestWarning):
-    """An unraisable exception was reported.
-
-    Unraisable exceptions are exceptions raised in :meth:`__del__ <object.__del__>`
-    implementations and similar situations when the exception cannot be raised
-    as normal.
-    """
-
-    __module__ = "pytest"
-
-
-@final
-class PytestUnhandledThreadExceptionWarning(PytestWarning):
-    """An unhandled exception occurred in a :class:`~threading.Thread`.
-
-    Such exceptions don't propagate normally.
-    """
-
-    __module__ = "pytest"
-
-
-_W = TypeVar("_W", bound=PytestWarning)
-
-
-@final
-@dataclasses.dataclass
-class UnformattedWarning(Generic[_W]):
-    """A warning meant to be formatted during runtime.
-
-    This is used to hold warnings that need to format their message at runtime,
-    as opposed to a direct message.
-    """
-
-    category: type[_W]
-    template: str
-
-    def format(self, **kwargs: Any) -> _W:
-        """Return an instance of the warning category, formatted with given kwargs."""
-        return self.category(self.template.format(**kwargs))
-
-
-def warn_explicit_for(method: FunctionType, message: PytestWarning) -> None:
-    """
-    Issue the warning :param:`message` for the definition of the given :param:`method`
-
-    this helps to log warnings for functions defined prior to finding an issue with them
-    (like hook wrappers being marked in a legacy mechanism)
-    """
-    lineno = method.__code__.co_firstlineno
-    filename = inspect.getfile(method)
-    module = method.__module__
-    mod_globals = method.__globals__
-    try:
-        warnings.warn_explicit(
-            message,
-            type(message),
-            filename=filename,
-            module=module,
-            registry=mod_globals.setdefault("__warningregistry__", {}),
-            lineno=lineno,
-        )
-    except Warning as w:
-        # If warnings are errors (e.g. -Werror), location information gets lost, so we add it to the message.
-        raise type(w)(f"{w}\n at {filename}:{lineno}") from None

shared/package-files/9b/9b717166deba6db15d053b26793d1c34c4a756495065bafecb0657dd9461794f/blob

@@ -1,57 +0,0 @@
-from .module import Module
-from .. import functional as F
-
-from torch import Tensor
-
-__all__ = ['ChannelShuffle']
-
-class ChannelShuffle(Module):
-    r"""Divides and rearranges the channels in a tensor.
-
-    This operation divides the channels in a tensor of shape :math:`(*, C , H, W)`
-    into g groups and rearranges them as :math:`(*, \frac{C}{g}, g, H, W)`,
-    while keeping the original tensor shape.
-
-    Args:
-        groups (int): number of groups to divide channels in.
-
-    Examples::
-
-        >>> # xdoctest: +IGNORE_WANT("FIXME: incorrect want")
-        >>> channel_shuffle = nn.ChannelShuffle(2)
-        >>> input = torch.randn(1, 4, 2, 2)
-        >>> print(input)
-        [[[[1, 2],
-           [3, 4]],
-          [[5, 6],
-           [7, 8]],
-          [[9, 10],
-           [11, 12]],
-          [[13, 14],
-           [15, 16]],
-         ]]
-        >>> output = channel_shuffle(input)
-        >>> print(output)
-        [[[[1, 2],
-           [3, 4]],
-          [[9, 10],
-           [11, 12]],
-          [[5, 6],
-           [7, 8]],
-          [[13, 14],
-           [15, 16]],
-         ]]
-    """
-
-    __constants__ = ['groups']
-    groups: int
-
-    def __init__(self, groups: int) -> None:
-        super().__init__()
-        self.groups = groups
-
-    def forward(self, input: Tensor) -> Tensor:
-        return F.channel_shuffle(input, self.groups)
-
-    def extra_repr(self) -> str:
-        return f'groups={self.groups}'

shared/package-files/9b/9b7207dba4c2ccb0e94bc72dbf324a2c0f31e35e2eaf98e55f7b1d4f8b01e26f/blob

@@ -1,50 +0,0 @@
-from collections.abc import Generator
-from contextlib import contextmanager
-import pathlib
-import tempfile
-
-import pytest
-
-from pandas.io.pytables import HDFStore
-
-tables = pytest.importorskip("tables")
-# set these parameters so we don't have file sharing
-tables.parameters.MAX_NUMEXPR_THREADS = 1
-tables.parameters.MAX_BLOSC_THREADS = 1
-tables.parameters.MAX_THREADS = 1
-
-
-def safe_close(store):
-    try:
-        if store is not None:
-            store.close()
-    except OSError:
-        pass
-
-
-# contextmanager to ensure the file cleanup
-@contextmanager
-def ensure_clean_store(
-    path, mode="a", complevel=None, complib=None, fletcher32=False
-) -> Generator[HDFStore, None, None]:
-    with tempfile.TemporaryDirectory() as tmpdirname:
-        tmp_path = pathlib.Path(tmpdirname, path)
-        with HDFStore(
-            tmp_path,
-            mode=mode,
-            complevel=complevel,
-            complib=complib,
-            fletcher32=fletcher32,
-        ) as store:
-            yield store
-
-
-def _maybe_remove(store, key):
-    """
-    For tests using tables, try removing the table to be sure there is
-    no content from previous tests using the same table name.
-    """
-    try:
-        store.remove(key)
-    except (ValueError, KeyError):
-        pass

shared/package-files/9b/9b72799855182eb383e06337a6fb5c8a9e01872fcdf9c1e1adcb01a3915657a7/blob

@@ -1,27 +0,0 @@
-#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_upsample_trilinear3d : public at::impl::MetaBase {
-    
-    
-    void meta(const at::Tensor & self, at::ArrayRef<int64_t> output_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w);
-};
-
-} // namespace native
-} // namespace at

shared/package-files/9b/9b73f686d2ddb70d184f449d22d666b0a1ea63797ad578875be8245c4efa817e/blob

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9b73f686d2ddb70d184f449d22d666b0a1ea63797ad578875be8245c4efa817e
-size 831312

shared/package-files/9b/9b754b17f8c1e4f6d11f3ae7c0f25b6bfcfb78c73ce79016075e681189215e73/blob

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

shared/package-files/9b/9b75f170af5486c48214aefebeb394eb3b67f9e69e5ca2ee4bc74ff3c418eb3c/blob

@@ -1,480 +0,0 @@
-from functools import lru_cache
-from typing import Optional, List
-
-from charset_normalizer.constant import UNICODE_SECONDARY_RANGE_KEYWORD
-from charset_normalizer.utils import is_punctuation, is_symbol, unicode_range, is_accentuated, is_latin, \
-    remove_accent, is_separator, is_cjk, is_case_variable, is_hangul, is_katakana, is_hiragana, is_ascii, is_thai
-
-
-class MessDetectorPlugin:
-    """
-    Base abstract class used for mess detection plugins.
-    All detectors MUST extend and implement given methods.
-    """
-
-    def eligible(self, character: str) -> bool:
-        """
-        Determine if given character should be fed in.
-        """
-        raise NotImplementedError  # pragma: nocover
-
-    def feed(self, character: str) -> None:
-        """
-        The main routine to be executed upon character.
-        Insert the logic in witch the text would be considered chaotic.
-        """
-        raise NotImplementedError  # pragma: nocover
-
-    def reset(self) -> None:
-        """
-        Permit to reset the plugin to the initial state.
-        """
-        raise NotImplementedError  # pragma: nocover
-
-    @property
-    def ratio(self) -> float:
-        """
-        Compute the chaos ratio based on what your feed() has seen.
-        Must NOT be lower than 0.; No restriction gt 0.
-        """
-        raise NotImplementedError  # pragma: nocover
-
-
-class TooManySymbolOrPunctuationPlugin(MessDetectorPlugin):
-
-    def __init__(self):
-        self._punctuation_count = 0  # type: int
-        self._symbol_count = 0  # type: int
-        self._character_count = 0  # type: int
-
-        self._last_printable_char = None  # type: Optional[str]
-        self._frenzy_symbol_in_word = False  # type: bool
-
-    def eligible(self, character: str) -> bool:
-        return character.isprintable()
-
-    def feed(self, character: str) -> None:
-        self._character_count += 1
-
-        if character != self._last_printable_char and character not in ["<", ">", "=", ":", "/", "&", ";", "{", "}", "[", "]", ",", "|", '"']:
-            if is_punctuation(character):
-                self._punctuation_count += 1
-            elif character.isdigit() is False and is_symbol(character):
-                self._symbol_count += 2
-
-        self._last_printable_char = character
-
-    def reset(self) -> None:
-        self._punctuation_count = 0
-        self._character_count = 0
-        self._symbol_count = 0
-
-    @property
-    def ratio(self) -> float:
-        if self._character_count == 0:
-            return 0.
-
-        ratio_of_punctuation = (self._punctuation_count + self._symbol_count) / self._character_count  # type: float
-
-        return ratio_of_punctuation if ratio_of_punctuation >= 0.3 else 0.
-
-
-class TooManyAccentuatedPlugin(MessDetectorPlugin):
-
-    def __init__(self):
-        self._character_count = 0  # type: int
-        self._accentuated_count = 0  # type: int
-
-    def eligible(self, character: str) -> bool:
-        return character.isalpha()
-
-    def feed(self, character: str) -> None:
-        self._character_count += 1
-
-        if is_accentuated(character):
-            self._accentuated_count += 1
-
-    def reset(self) -> None:
-        self._character_count = 0
-        self._accentuated_count = 0
-
-    @property
-    def ratio(self) -> float:
-        if self._character_count == 0:
-            return 0.
-        ratio_of_accentuation = self._accentuated_count / self._character_count  # type: float
-        return ratio_of_accentuation if ratio_of_accentuation >= 0.35 else 0.
-
-
-class UnprintablePlugin(MessDetectorPlugin):
-
-    def __init__(self):
-        self._unprintable_count = 0  # type: int
-        self._character_count = 0  # type: int
-
-    def eligible(self, character: str) -> bool:
-        return True
-
-    def feed(self, character: str) -> None:
-        if character not in {'\n', '\t', '\r', '\v'} and character.isprintable() is False:
-            self._unprintable_count += 1
-        self._character_count += 1
-
-    def reset(self) -> None:
-        self._unprintable_count = 0
-
-    @property
-    def ratio(self) -> float:
-        if self._character_count == 0:
-            return 0.
-
-        return (self._unprintable_count * 8) / self._character_count
-
-
-class SuspiciousDuplicateAccentPlugin(MessDetectorPlugin):
-
-    def __init__(self):
-        self._successive_count = 0  # type: int
-        self._character_count = 0  # type: int
-
-        self._last_latin_character = None  # type: Optional[str]
-
-    def eligible(self, character: str) -> bool:
-        return character.isalpha() and is_latin(character)
-
-    def feed(self, character: str) -> None:
-        self._character_count += 1
-        if self._last_latin_character is not None:
-            if is_accentuated(character) and is_accentuated(self._last_latin_character):
-                if character.isupper() and self._last_latin_character.isupper():
-                    self._successive_count += 1
-                # Worse if its the same char duplicated with different accent.
-                if remove_accent(character) == remove_accent(self._last_latin_character):
-                    self._successive_count += 1
-        self._last_latin_character = character
-
-    def reset(self) -> None:
-        self._successive_count = 0
-        self._character_count = 0
-        self._last_latin_character = None
-
-    @property
-    def ratio(self) -> float:
-        if self._character_count == 0:
-            return 0.
-
-        return (self._successive_count * 2) / self._character_count
-
-
-class SuspiciousRange(MessDetectorPlugin):
-
-    def __init__(self):
-        self._suspicious_successive_range_count = 0  # type: int
-        self._character_count = 0  # type: int
-        self._last_printable_seen = None  # type: Optional[str]
-
-    def eligible(self, character: str) -> bool:
-        return character.isprintable()
-
-    def feed(self, character: str) -> None:
-        self._character_count += 1
-
-        if character.isspace() or is_punctuation(character):
-            self._last_printable_seen = None
-            return
-
-        if self._last_printable_seen is None:
-            self._last_printable_seen = character
-            return
-
-        unicode_range_a = unicode_range(self._last_printable_seen)  # type: Optional[str]
-        unicode_range_b = unicode_range(character)  # type: Optional[str]
-
-        if is_suspiciously_successive_range(unicode_range_a, unicode_range_b):
-            self._suspicious_successive_range_count += 1
-
-        self._last_printable_seen = character
-
-    def reset(self) -> None:
-        self._character_count = 0
-        self._suspicious_successive_range_count = 0
-        self._last_printable_seen = None
-
-    @property
-    def ratio(self) -> float:
-        if self._character_count == 0:
-            return 0.
-
-        ratio_of_suspicious_range_usage = (self._suspicious_successive_range_count * 2) / self._character_count  # type: float
-
-        if ratio_of_suspicious_range_usage < 0.1:
-            return 0.
-
-        return ratio_of_suspicious_range_usage
-
-
-class SuperWeirdWordPlugin(MessDetectorPlugin):
-
-    def __init__(self):
-        self._word_count = 0  # type: int
-        self._bad_word_count = 0  # type: int
-        self._is_current_word_bad = False  # type: bool
-        self._foreign_long_watch = False  # type: bool
-
-        self._character_count = 0  # type: int
-        self._bad_character_count = 0  # type: int
-
-        self._buffer = ""  # type: str
-        self._buffer_accent_count = 0  # type: int
-
-    def eligible(self, character: str) -> bool:
-        return True
-
-    def feed(self, character: str) -> None:
-        if character.isalpha():
-            self._buffer = "".join([self._buffer, character])
-            if is_accentuated(character):
-                self._buffer_accent_count += 1
-            if self._foreign_long_watch is False and is_latin(character) is False and is_cjk(character) is False and is_hangul(character) is False and is_katakana(character) is False and is_hiragana(character) is False and is_thai(character) is False:
-                self._foreign_long_watch = True
-            return
-        if not self._buffer:
-            return
-        if (character.isspace() or is_punctuation(character) or is_separator(character)) and self._buffer:
-            self._word_count += 1
-            buffer_length = len(self._buffer)  # type: int
-
-            self._character_count += buffer_length
-
-            if buffer_length >= 4 and self._buffer_accent_count / buffer_length >= 0.3:
-                self._is_current_word_bad = True
-            if buffer_length >= 24 and self._foreign_long_watch:
-                self._is_current_word_bad = True
-
-            if self._is_current_word_bad:
-                self._bad_word_count += 1
-                self._bad_character_count += len(self._buffer)
-                self._is_current_word_bad = False
-
-            self._foreign_long_watch = False
-            self._buffer = ""
-            self._buffer_accent_count = 0
-        elif character not in {"<", ">", "-", "="} and character.isdigit() is False and is_symbol(character):
-            self._is_current_word_bad = True
-            self._buffer += character
-
-    def reset(self) -> None:
-        self._buffer = ""
-        self._is_current_word_bad = False
-        self._foreign_long_watch = False
-        self._bad_word_count = 0
-        self._word_count = 0
-        self._character_count = 0
-        self._bad_character_count = 0
-
-    @property
-    def ratio(self) -> float:
-        if self._word_count <= 10:
-            return 0.
-
-        return self._bad_character_count / self._character_count
-
-
-class CjkInvalidStopPlugin(MessDetectorPlugin):
-    """
-    GB(Chinese) based encoding often render the stop incorrectly when the content does not fit and can be easily detected.
-    Searching for the overuse of '丅' and '丄'.
-    """
-
-    def __init__(self):
-        self._wrong_stop_count = 0  # type: int
-        self._cjk_character_count = 0  # type: int
-
-    def eligible(self, character: str) -> bool:
-        return True
-
-    def feed(self, character: str) -> None:
-        if character in ["丅", "丄"]:
-            self._wrong_stop_count += 1
-            return
-        if is_cjk(character):
-            self._cjk_character_count += 1
-
-    def reset(self) -> None:
-        self._wrong_stop_count = 0
-        self._cjk_character_count = 0
-
-    @property
-    def ratio(self) -> float:
-        if self._cjk_character_count < 16:
-            return 0.
-        return self._wrong_stop_count / self._cjk_character_count
-
-
-class ArchaicUpperLowerPlugin(MessDetectorPlugin):
-
-    def __init__(self):
-        self._buf = False  # type: bool
-
-        self._character_count_since_last_sep = 0  # type: int
-
-        self._successive_upper_lower_count = 0  # type: int
-        self._successive_upper_lower_count_final = 0  # type: int
-
-        self._character_count = 0  # type: int
-
-        self._last_alpha_seen = None  # type: Optional[str]
-        self._current_ascii_only = True  # type: bool
-
-    def eligible(self, character: str) -> bool:
-        return True
-
-    def feed(self, character: str) -> None:
-        is_concerned = character.isalpha() and is_case_variable(character)
-        chunk_sep = is_concerned is False
-
-        if chunk_sep and self._character_count_since_last_sep > 0:
-            if self._character_count_since_last_sep <= 64 and character.isdigit() is False and self._current_ascii_only is False:
-                self._successive_upper_lower_count_final += self._successive_upper_lower_count
-
-            self._successive_upper_lower_count = 0
-            self._character_count_since_last_sep = 0
-            self._last_alpha_seen = None
-            self._buf = False
-            self._character_count += 1
-            self._current_ascii_only = True
-
-            return
-
-        if self._current_ascii_only is True and is_ascii(character) is False:
-            self._current_ascii_only = False
-
-        if self._last_alpha_seen is not None:
-            if (character.isupper() and self._last_alpha_seen.islower()) or (character.islower() and self._last_alpha_seen.isupper()):
-                if self._buf is True:
-                    self._successive_upper_lower_count += 2
-                    self._buf = False
-                else:
-                    self._buf = True
-            else:
-                self._buf = False
-
-        self._character_count += 1
-        self._character_count_since_last_sep += 1
-        self._last_alpha_seen = character
-
-    def reset(self) -> None:
-        self._character_count = 0
-        self._character_count_since_last_sep = 0
-        self._successive_upper_lower_count = 0
-        self._successive_upper_lower_count_final = 0
-        self._last_alpha_seen = None
-        self._buf = False
-        self._current_ascii_only = True
-
-    @property
-    def ratio(self) -> float:
-        if self._character_count == 0:
-            return 0.
-
-        return self._successive_upper_lower_count_final / self._character_count
-
-
-def is_suspiciously_successive_range(unicode_range_a: Optional[str], unicode_range_b: Optional[str]) -> bool:
-    """
-    Determine if two Unicode range seen next to each other can be considered as suspicious.
-    """
-    if unicode_range_a is None or unicode_range_b is None:
-        return True
-
-    if unicode_range_a == unicode_range_b:
-        return False
-
-    if "Latin" in unicode_range_a and "Latin" in unicode_range_b:
-        return False
-
-    if "Emoticons" in unicode_range_a or "Emoticons" in unicode_range_b:
-        return False
-
-    keywords_range_a, keywords_range_b = unicode_range_a.split(" "), unicode_range_b.split(" ")
-
-    for el in keywords_range_a:
-        if el in UNICODE_SECONDARY_RANGE_KEYWORD:
-            continue
-        if el in keywords_range_b:
-            return False
-
-    # Japanese Exception
-    if unicode_range_a in ['Katakana', 'Hiragana'] and unicode_range_b in ['Katakana', 'Hiragana']:
-        return False
-
-    if unicode_range_a in ['Katakana', 'Hiragana'] or unicode_range_b in ['Katakana', 'Hiragana']:
-        if "CJK" in unicode_range_a or "CJK" in unicode_range_b:
-            return False
-
-    if "Hangul" in unicode_range_a or "Hangul" in unicode_range_b:
-        if "CJK" in unicode_range_a or "CJK" in unicode_range_b:
-            return False
-        if unicode_range_a == "Basic Latin" or unicode_range_b == "Basic Latin":
-            return False
-
-    # Chinese/Japanese use dedicated range for punctuation and/or separators.
-    if ('CJK' in unicode_range_a or 'CJK' in unicode_range_b) or (unicode_range_a in ['Katakana', 'Hiragana'] and unicode_range_b in ['Katakana', 'Hiragana']):
-        if 'Punctuation' in unicode_range_a or 'Punctuation' in unicode_range_b:
-            return False
-        if 'Forms' in unicode_range_a or 'Forms' in unicode_range_b:
-            return False
-
-    return True
-
-
-@lru_cache(maxsize=2048)
-def mess_ratio(decoded_sequence: str, maximum_threshold: float = 0.2, debug: bool = False) -> float:
-    """
-    Compute a mess ratio given a decoded bytes sequence. The maximum threshold does stop the computation earlier.
-    """
-    detectors = []  # type: List[MessDetectorPlugin]
-
-    for md_class in MessDetectorPlugin.__subclasses__():
-        detectors.append(
-            md_class()
-        )
-
-    length = len(decoded_sequence)  # type: int
-
-    mean_mess_ratio = 0.  # type: float
-
-    if length < 512:
-        intermediary_mean_mess_ratio_calc = 32  # type: int
-    elif length <= 1024:
-        intermediary_mean_mess_ratio_calc = 64
-    else:
-        intermediary_mean_mess_ratio_calc = 128
-
-    for character, index in zip(decoded_sequence, range(0, length)):
-        for detector in detectors:
-            if detector.eligible(character):
-                detector.feed(character)
-
-        if (index > 0 and index % intermediary_mean_mess_ratio_calc == 0) or index == length-1:
-            mean_mess_ratio = sum(
-                [
-                    dt.ratio for dt in detectors
-                ]
-            )
-
-            if mean_mess_ratio >= maximum_threshold:
-                break
-
-    if debug:
-        for dt in detectors:  # pragma: nocover
-            print(
-                dt.__class__,
-                dt.ratio
-            )
-
-    return round(
-        mean_mess_ratio,
-        3
-    )
-

shared/package-files/9b/9b79065dfee170914ab9ff6306eddbabe921f4c432484396c6011b04497447c4/blob

@@ -1,1202 +0,0 @@
-import collections
-import dataclasses
-import enum
-import itertools as it
-import logging
-from typing import (
-    Any,
-    cast,
-    DefaultDict,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Union,
-)
-
-from typing_extensions import Literal
-
-import torch
-from torch._C import FunctionSchema
-from torch._C._autograd import _ProfilerResult
-from torch._C._profiler import (
-    _EventType,
-    _ExtraFields_Allocation,
-    _ExtraFields_TorchOp,
-    _ProfilerEvent,
-    _TensorMetadata,
-    RecordScope,
-)
-from torch._utils import _element_size
-from torch.profiler import _utils
-
-KeyAndID = Tuple["Key", int]
-TensorAndID = Tuple["TensorKey", int]
-
-log = logging.getLogger(__name__)
-
-
-class Category(enum.Enum):
-    INPUT = enum.auto()
-    TEMPORARY = enum.auto()
-    ACTIVATION = enum.auto()
-    GRADIENT = enum.auto()
-    AUTOGRAD_DETAIL = enum.auto()
-    PARAMETER = enum.auto()
-    OPTIMIZER_STATE = enum.auto()
-
-
-_CATEGORY_TO_COLORS = {
-    Category.PARAMETER: "darkgreen",
-    Category.OPTIMIZER_STATE: "goldenrod",
-    Category.INPUT: "black",
-    Category.TEMPORARY: "mediumpurple",
-    Category.ACTIVATION: "red",
-    Category.GRADIENT: "mediumblue",
-    Category.AUTOGRAD_DETAIL: "royalblue",
-    None: "grey",
-}
-
-_CATEGORY_TO_INDEX = {c: i for i, c in enumerate(_CATEGORY_TO_COLORS)}
-
-
-class Action(enum.Enum):
-    PREEXISTING = enum.auto()
-    CREATE = enum.auto()
-    INCREMENT_VERSION = enum.auto()
-    DESTROY = enum.auto()
-
-
-_ACTION_TO_INDEX = {i: i.value for i in Action}
-
-
-@dataclasses.dataclass(eq=True, unsafe_hash=False, frozen=True)
-class Key:
-    device: torch.device
-
-
-@dataclasses.dataclass
-class _Storage:
-    """Bundle storage pointer and id.
-
-    All profiling logic should use `allocation_id`, however it is useful to
-    print storage pointers for debugging and unit tests sometimes look up
-    values using the storage data pointer of a live Tensor."""
-
-    ptr: int
-    allocation_id: int
-
-    def __repr__(self) -> str:
-        return f"{hex(self.ptr):>18} ({self.allocation_id})"
-
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, _Storage) and self.allocation_id == other.allocation_id
-
-    def __hash__(self) -> int:
-        return hash(self.allocation_id)
-
-
-@dataclasses.dataclass(eq=True, unsafe_hash=True, frozen=True)
-class TensorKey(Key):
-    """Hashable identifier for a storage which has been asigned an ID.
-
-    A detailed description of Tensor IDs and why they are needed is given in
-    `torch/csrc/profiler/collection.h` when `TensorID` is declared. To
-    summarize, multiple Storage buffers can map to the same logical Tensor.
-    This dataclass is used to refer to a concrete in-memory StorageImpl of
-    a Tensor.
-    """
-
-    id: int
-    storage: _Storage
-
-    def __repr__(self) -> str:
-        return f"id={self.id}: {repr(self.storage):<24} ({self.device})"
-
-    def __lt__(self, other: "TensorKey") -> bool:
-        return self._as_sortable < other._as_sortable
-
-    @staticmethod
-    def _make(
-        tensor_id: Optional[int],
-        storage_ptr: Optional[int],
-        allocation_id: Optional[int],
-        device: torch.device,
-    ) -> Optional["TensorKey"]:
-        if (
-            tensor_id is not None
-            and storage_ptr is not None
-            and allocation_id is not None
-        ):
-            return TensorKey(device, tensor_id, _Storage(storage_ptr, allocation_id))
-        return None
-
-    @classmethod
-    def from_allocation(cls, alloc: _ExtraFields_Allocation) -> Optional["TensorKey"]:
-        return cls._make(alloc.id, alloc.ptr, alloc.allocation_id, alloc.device)
-
-    @classmethod
-    def from_tensor(cls, t: Optional[_TensorMetadata]) -> Optional["TensorKey"]:
-        if t is not None:
-            return cls._make(t.id, t.storage_data_ptr, t.allocation_id, t.device)
-        return None
-
-    @property
-    def _as_sortable(self) -> Tuple[int, int, str, int]:
-        return self.id, self.storage.allocation_id, self.device.type, self.device.index
-
-
-def _extract_parameters_and_gradients(
-    node: _ProfilerEvent,
-) -> Iterator[Tuple[Optional[TensorKey], Optional[TensorKey]]]:
-    children = node.children
-
-    # AccumulateGrad is used in the Autograd engine to handle gradient updates.
-    # There are two possible cases:
-    # 1) This is a newly created gradient Tensor. In that case there is nothing
-    #    to accumulate, so autograd simply detaches the Tensor.
-    #
-    # 2) There is a preexisting gradient Tensor and we need to add the newly
-    #    computed update. This is done with an in-place add (aten::add_) op.
-    #    (The underscore suffix denotes "in-place".)
-    if (
-        node.typed[0] == _EventType.TorchOp
-        and node.typed[1].scope == RecordScope.BACKWARD_FUNCTION
-        # TODO(robieta): Move away from load bearing names
-        and node.name == "torch::autograd::AccumulateGrad"
-        and children
-        and children[0].typed[0] == _EventType.TorchOp
-        and children[0].name in ("aten::detach", "aten::add_")
-        and children[0].typed[1].inputs
-        and isinstance(children[0].typed[1].inputs[0], _TensorMetadata)
-    ):
-        yield None, TensorKey.from_tensor(children[0].typed[1].inputs[0])
-
-    # We directly instrument `torch.nn.Module` and `torch.optim.Optimizer`
-    # NOTE: The values captured by the python tracer are cached; they can be
-    #       used to build up labels but do not imply that a Tensor was live at
-    #       a particular time.
-    elif node.typed[0] == _EventType.PyCall:
-        typed_fields = node.typed[1]
-        assert typed_fields.module is None or typed_fields.optimizer is None
-        if typed_fields.module is not None:
-            for _, p, p_grad in typed_fields.module.parameters:
-                yield TensorKey.from_tensor(p), TensorKey.from_tensor(p_grad)
-
-        if typed_fields.optimizer is not None:
-            for p, p_grad, _ in typed_fields.optimizer.parameters:
-                yield TensorKey.from_tensor(p), TensorKey.from_tensor(p_grad)
-
-
-def extract_parameters(node: _ProfilerEvent) -> Iterator[TensorKey]:
-    for p, p_grad in _extract_parameters_and_gradients(node):
-        if p is not None:
-            yield p
-
-
-def extract_gradients(
-    node: _ProfilerEvent,
-) -> Iterator[Tuple[Optional[TensorKey], TensorKey]]:
-    for p, p_grad in _extract_parameters_and_gradients(node):
-        if p_grad is not None:
-            yield p, p_grad
-
-
-def get_scopes(event: Optional[_ProfilerEvent]) -> Tuple[RecordScope, ...]:
-    scopes = []
-    while event:
-        if event.typed[0] == _EventType.TorchOp:
-            scopes.append(event.typed[1].scope)
-        event = event.parent
-    return tuple(scopes)
-
-
-class SchemaMatcher:
-    """Lookup operator schema based on profiled name.
-
-    When profiling we record the operator's name but not the schema. However
-    some analysis requires that information. Fortunately we can look up
-    registered schema from the recorded name. We do not, however, record the
-    overload and so we must compare the profiled arguments with all overloads
-    to determine viable matches.
-
-    Note: Once https://github.com/pytorch/pytorch/issues/78871 is completed
-    this code will be obsolete.
-    """
-
-    @classmethod
-    def inputs_are_mutable(cls, t: _ExtraFields_TorchOp) -> Tuple[Optional[bool], ...]:
-        """Determine which inputs may have mutated based on function schema.
-
-        Note that we don't need to resolve down to a single schema to perform
-        this analysis. An input is mutable if it is mutable in any overload. In
-        practice, however, it is overwhelmingly common to match a single
-        overload. If we cannot find any valid schema then we must be
-        conservative and assume all inputs are mutable.
-        """
-        mutable: Optional[List[bool]] = None
-        for schema in cls.match_schemas(t):
-            mutable = mutable or [False for _ in schema.arguments]
-            for i, arg in enumerate(schema.arguments):
-                mutable[i] |= getattr(arg.alias_info, "is_write", False)
-
-        return tuple(mutable or (None for _ in t.inputs))
-
-    @classmethod
-    def match_schemas(cls, t: _ExtraFields_TorchOp) -> Tuple[FunctionSchema, ...]:
-        signature = tuple(
-            # Tensor
-            TensorKey.from_tensor(i) if isinstance(i, _TensorMetadata)
-            #
-            # TensorList
-            else [TensorKey.from_tensor(j) for j in i] if isinstance(i, list)
-            #
-            # Scalar and uncaptured inputs.
-            else i
-            for i in t.inputs
-        )
-
-        def matches(schema) -> bool:
-            return len(schema.arguments) == len(signature) and all(
-                cls._types_match(observed, schema_arg.type)
-                for observed, schema_arg in zip(signature, schema.arguments)
-            )
-
-        return tuple(s for s in cls.lookup_schemas(t.name) or () if matches(s))
-
-    @classmethod
-    def _types_match(cls, observed, schema_type) -> bool:
-        if isinstance(schema_type, torch._C.OptionalType):
-            schema_type = schema_type.getElementType()
-            return observed is None or cls._types_match(observed, schema_type)
-
-        if isinstance(schema_type, torch._C.AnyType):
-            return True
-
-        if schema_type.isSubtypeOf(torch._C.ListType.ofTensors()):
-            return isinstance(observed, list) and all(
-                isinstance(i, TensorKey) for i in observed
-            )
-
-        type_map: Tuple[Tuple[Any, Union[type, Tuple[type, ...]]], ...] = (
-            (torch._C.TensorType, TensorKey),
-            (torch._C.NoneType, type(None)),
-            (torch._C.BoolType, bool),
-            (torch._C.IntType, int),
-            (torch._C.FloatType, float),
-            (torch._C.ComplexType, complex),
-            (torch._C.NumberType, (bool, int, float, complex)),
-        )
-
-        for jit_type, py_types in type_map:
-            if isinstance(schema_type, jit_type):
-                return isinstance(observed, py_types)
-
-        # Profiler only records a subset of possible argument types. If we
-        # reach this point then the schema must call for a type that profiler
-        # does not record. Thus, the schema can only be a match if `observed`
-        # is also None.
-        return observed is None
-
-    @staticmethod
-    def lookup_schemas(name: str) -> Optional[Tuple[FunctionSchema, ...]]:
-        # TODO(robieta):
-        #   _jit_get_schemas_for_operator is quite expensive. (~100us / call)
-        #   Consider adding `functools.lru_cache` if that becomes an issue.
-
-        try:
-            # Schema lookup will throw if `name` is malformed. (For example,
-            # schemas must be namespaced and schema lookup will fail if name
-            # does not include "::".) We simply catch the exception and return
-            # `None` to denote that `name` cannot be an operator name.
-            #
-            # Note that record_function annotations also go through this path,
-            # so it is expected that some names will not correspond to PyTorch
-            # operators.
-            if "::" not in name:
-                return None
-            return tuple(torch._C._jit_get_schemas_for_operator(name))
-        except RuntimeError:
-            return None
-
-
-class OpTree:
-    def __init__(self, result: _ProfilerResult) -> None:
-        self._root_nodes = result.experimental_event_tree()
-        self._sorted_nodes = tuple(sorted(self.dfs(), key=lambda x: x.start_time_ns))
-
-    def dfs(self, *args, **kwargs) -> Iterator[_ProfilerEvent]:
-        yield from _utils.traverse_dfs(self._root_nodes, *args, **kwargs)
-
-    @property
-    def sorted_nodes(self) -> Tuple[_ProfilerEvent, ...]:
-        return self._sorted_nodes
-
-
-class SizeMap:
-    def __init__(self, op_tree: OpTree) -> None:
-        self._values: Dict[TensorKey, int] = {}
-
-        for node in op_tree.sorted_nodes:
-            if node.typed[0] == _EventType.TorchOp:
-                for t in self._flat_tensor_inputs(node.typed[1]):
-                    self._update_values(t)
-
-            elif node.typed[0] == _EventType.PyCall:
-                typed_fields = node.typed[1]
-                assert typed_fields.module is None or typed_fields.optimizer is None
-                if typed_fields.module is not None:
-                    for _, p, p_grad in typed_fields.module.parameters:
-                        self._update_values(p)
-                        self._update_values(p_grad)
-
-                if typed_fields.optimizer is not None:
-                    for p, p_grad, state in typed_fields.optimizer.parameters:
-                        self._update_values(p)
-                        self._update_values(p_grad)
-                        for _, t in state:
-                            self._update_values(t)
-
-        allocations: Dict[TensorKey, int] = {}
-        for node in op_tree.sorted_nodes:
-            if node.typed[0] == _EventType.Allocation:
-                alloc_fields = node.typed[1]
-                key = TensorKey.from_allocation(alloc_fields)
-                if key:
-                    new_size = abs(alloc_fields.alloc_size)
-                    prior_size = allocations.setdefault(key, new_size)
-
-                    # It is possible to resize Storage in PyTorch, however we
-                    # key on data pointer so most resizes will be treated as a
-                    # change in storage. The one corner case that cannot be
-                    # handled is `realloc` which successfully resizes the
-                    # storage. At time of writing this is not done anywhere in
-                    # the core PyTorch codebase.
-                    if prior_size != new_size:
-                        delta = f"{prior_size} vs. {new_size}"
-                        log.warning("Mismatch between allocation and free: %s", delta)
-
-        self._values.update(allocations)
-
-    def _update_values(self, t: Optional[_TensorMetadata]) -> None:
-        key = TensorKey.from_tensor(t)
-        if key is not None and t is not None and t.layout == torch.strided:
-            # Scalars are represented as zero dim Tensors
-            n = max(i[0] * i[1] for i in zip(t.sizes or [1], t.strides or [1]))
-
-            num_bytes = n * _element_size(t.dtype)
-            assert num_bytes >= 0, f"{num_bytes}"
-            self._values[key] = max(self._values.get(key, 0), num_bytes)
-
-    @staticmethod
-    def _flat_tensor_inputs(op: _ExtraFields_TorchOp) -> Iterator[_TensorMetadata]:
-        for i in op.inputs:
-            if isinstance(i, _TensorMetadata):
-                yield i
-            elif isinstance(i, list):
-                yield from i
-
-    def __getitem__(self, key: TensorKey):
-        return self._values[key]
-
-
-@dataclasses.dataclass()
-class DataFlowEdge:
-    input_version: Optional[int] = None
-    mutated: Optional[bool] = False
-
-    @property
-    def is_allocation(self) -> bool:
-        return self.input_version is None
-
-    @property
-    def is_deletion(self) -> bool:
-        return self.mutated is None
-
-
-class DataFlowNode:
-    def __init__(self, event: _ProfilerEvent, graph: "DataFlowGraph") -> None:
-        self._event = event
-        self._graph = graph
-        self._edges: Dict[TensorKey, DataFlowEdge] = self._determine_edges()
-
-        for key, edge in self._edges.items():
-            if edge.mutated and not edge.is_allocation:
-                self._graph.bump(key)
-
-        # Make sure the version bumping behavior matches what we expect.
-        versions = {k: (v, self._graph.lookup(k)) for k, v in self.outputs.items()}
-        assert all(i == j for i, j in versions.values()), f"{versions}, {self._edges}"
-
-    def _determine_edges(self) -> Dict[TensorKey, DataFlowEdge]:
-        subtree = tuple(_utils.traverse_dfs([self._event]))
-
-        # Start by populating edges from op inputs and outputs.
-        mutable_by_key: Dict[Optional[TensorKey], Set[Optional[bool]]] = {}
-        for op in (i.typed[1] for i in subtree if i.typed[0] == _EventType.TorchOp):
-            for op_input, mutable in zip(
-                op.inputs, SchemaMatcher.inputs_are_mutable(op)
-            ):
-                # Tensor
-                if isinstance(op_input, _TensorMetadata):
-                    key = TensorKey.from_tensor(op_input)
-                    mutable_by_key.setdefault(key, set()).add(mutable)
-
-                # TensorList
-                elif isinstance(op_input, list):
-                    for op_input_i in op_input:
-                        key = TensorKey.from_tensor(op_input_i)
-                        mutable_by_key.setdefault(key, set()).add(mutable)
-
-        edges: DefaultDict[Optional[TensorKey], DataFlowEdge]
-        edges = collections.defaultdict(DataFlowEdge)
-        for key, mutable_set in mutable_by_key.items():
-            if key is not None:
-                edges[key].input_version = self._graph.lookup(key) if key else -1
-
-                # We consider an op to be mutated if we encounter a schema where it
-                # is a mutable argument OR if it is ambiguous. (We never explicitly
-                # see it in any schema.)
-                mutated = (True in mutable_set) or (tuple(mutable_set) == (None,))
-                edges[key].mutated = mutated
-
-        # Then handle deletions. Note that deleting a Tensor implicitly adds
-        # it as an input edge.
-        for i in subtree:
-            if i.typed[0] == _EventType.Allocation and i.typed[1].alloc_size < 0:
-                key = TensorKey.from_allocation(i.typed[1])
-                edge = edges[key]
-                assert key is None or edge.mutated is not None, f"Double delete: {key}"
-                edge.mutated = None
-                edge.input_version = self._graph.lookup(key) if key else -1
-
-        # And finally handle allocations. This step must be last, because the
-        # previous two steps optimistically add input edges.
-        for i in subtree:
-            if i.typed[0] == _EventType.Allocation and i.typed[1].alloc_size > 0:
-                edges[TensorKey.from_allocation(i.typed[1])].input_version = None
-
-        # We don't need to sort the inputs, but it makes debugging and unit tests nicer.
-        return dict(sorted((k, v) for k, v in edges.items() if k is not None))
-
-    @property
-    def inputs(self) -> Dict[TensorKey, Tuple[bool, int]]:
-        return {
-            # MyPy can't see through `is_allocation` to know that
-            # `v.input_version` is not None.
-            k: (bool(v.mutated), cast(int, v.input_version))
-            for k, v in self._edges.items()
-            if not v.is_allocation
-        }
-
-    @property
-    def outputs(self) -> Dict[TensorKey, int]:
-        return {
-            k: 0 if v.input_version is None else v.input_version + 1
-            for k, v in self._edges.items()
-            if (v.is_allocation and not v.is_deletion) or v.mutated
-        }
-
-    @property
-    def intermediates(self) -> Tuple[TensorKey, ...]:
-        return tuple(
-            k for k, v in self._edges.items() if v.is_allocation and v.is_deletion
-        )
-
-    @property
-    def start_time(self) -> int:
-        return self._event.start_time_ns
-
-
-class DataFlowGraph:
-    def __init__(self, op_tree: OpTree) -> None:
-        self._op_tree = op_tree
-        self._leaf_events = self._extract_leaf_events(op_tree)
-        self._active_version: Dict[TensorKey, Optional[int]] = {}
-        self._flow_nodes = [DataFlowNode(e, self) for e in self.leaf_events]
-        self._flow_nodes.sort(key=lambda x: x.start_time)
-        self.validate()
-
-    @property
-    def flow_nodes(self) -> Tuple[DataFlowNode, ...]:
-        return tuple(self._flow_nodes)
-
-    def validate(self):
-        # Check that each (Tensor, version) pair has a unique creation node
-        outputs: Set[Tuple[TensorKey, int]] = set()
-        for node in self.flow_nodes:
-            node_outputs = set(node.outputs.items())
-            duplicates = outputs & node_outputs
-            assert not duplicates, f"{node._event.name} {node._edges} {duplicates}"
-            outputs |= node_outputs
-
-        # And check that `self._nodes` forms a valid topologically sorted DAG.
-        tensor_versions: Dict[TensorKey, int] = {}
-        for node in self.flow_nodes:
-            for key, (_, version) in node.inputs.items():
-                expected = tensor_versions.get(key, 0)
-                assert expected == version, (expected, version)
-
-            for key, version in node.outputs.items():
-                prior_version = tensor_versions.get(key, version)
-                assert version >= prior_version, (version, prior_version)
-                tensor_versions[key] = version
-
-    @property
-    def leaf_events(self) -> Tuple[_ProfilerEvent, ...]:
-        return self._leaf_events
-
-    @staticmethod
-    def _extract_leaf_events(op_tree: OpTree) -> Tuple[_ProfilerEvent, ...]:
-        """Partially traverse the op tree and extract top level ops.
-
-        Consider the following code:
-        ```
-        with record_function("My annotation"):
-            x.zero_()
-            y.zero_()
-        ```
-
-        The op tree (assuming no Autograd) will look like:
-          <Python context>
-            TorchOp: "My annotation"
-              TorchOp: zero_
-                TorchOp: fill_
-              TorchOp: zero_
-                TorchOp: fill_
-
-        The recursive structure of operator calls makes data flow unwieldy.
-        In order to simplify analysis we would like to select the highest level
-        ops to represent in the graph. In this case those are the `zero_` ops;
-        the fact that `fill_` is called is an implementation detail. We also
-        do not want to group everything under "My annotation" as this could
-        create overly coarse bundles and lose critical semantics.
-
-        To address this issue we walk over the graph and select the topmost
-        torch ops ** which match at least one operator schema **. These form
-        the leaves of the first pass through the op tree. (As well as any
-        allocations or frees which do are not part of a kernel.) These events
-        form the logical nodes in our data flow graph.
-        """
-
-        leaf_events: List[_ProfilerEvent] = []
-
-        def leaf_op(e: _ProfilerEvent) -> bool:
-            return e.typed[0] == _EventType.TorchOp and (
-                e.typed[1].scope == RecordScope.BACKWARD_FUNCTION
-                or bool(SchemaMatcher.match_schemas(e.typed[1]))
-            )
-
-        def children_fn(e: _ProfilerEvent):
-            if leaf_op(e) or e.tag == _EventType.Allocation:
-                leaf_events.append(e)
-                return []
-
-            return e.children
-
-        for _ in op_tree.dfs(children_fn=children_fn):
-            pass
-
-        return tuple(sorted(leaf_events, key=lambda x: x.start_time_ns))
-
-    def lookup(self, key: TensorKey) -> int:
-        version = self._active_version.setdefault(key, 0)
-        assert version is not None
-        return version
-
-    def bump(self, key: TensorKey) -> None:
-        prior_version = self._active_version.get(key, None)
-        assert prior_version is not None
-        self._active_version[key] = prior_version + 1
-
-    def delete(self, key: TensorKey) -> None:
-        assert self._active_version.setdefault(key, 0) is not None
-        self._active_version[key] = None
-
-
-@dataclasses.dataclass
-class CategoryElement:
-    by_id: Optional[Category] = None
-    by_key: Dict[TensorKey, Category] = dataclasses.field(default_factory=dict)
-    by_version: Dict[TensorAndID, Category] = dataclasses.field(default_factory=dict)
-
-    # Used by unit tests to check internals. (And consequently by
-    # MemoryProfile.lookup) This should not be used in any other capacity.
-    _by_id_keyset: Set[TensorKey] = dataclasses.field(default_factory=set)
-
-
-@dataclasses.dataclass
-class CategoryDict:
-    _values: DefaultDict[int, CategoryElement] = dataclasses.field(
-        default_factory=lambda: collections.defaultdict(CategoryElement)
-    )
-
-    def set_by_id(self, key: TensorKey, category: Category) -> None:
-        self._values[key.id].by_id = category
-        self._values[key.id]._by_id_keyset.add(key)
-
-    def set_by_key(self, key: TensorKey, category: Category) -> None:
-        self._values[key.id].by_key[key] = category
-
-    def set_by_version(self, key: TensorKey, version: int, category: Category) -> None:
-        self._values[key.id].by_version[(key, version)] = category
-
-    def setdefault_by_version(
-        self, key: TensorKey, version: int, category: Category
-    ) -> None:
-        self._values[key.id].by_version.setdefault((key, version), category)
-
-    def get(self, key: Key, version: int) -> Optional[Category]:
-        if isinstance(key, Key) and not isinstance(key, TensorKey):
-            return None
-        element = self._values[key.id]
-        return (
-            element.by_id
-            or element.by_key.get(key, None)
-            or element.by_version.get((key, version), None)
-        )
-
-
-class MemoryProfile:
-    def __init__(self, result: _ProfilerResult) -> None:
-        self._op_tree = OpTree(result)
-        self._data_flow_graph = DataFlowGraph(self._op_tree)
-        self._size_map = SizeMap(self._op_tree)
-        self._categories = CategoryDict()
-
-        self._set_gradients_and_temporaries()
-        self._set_parameters_using_python_tracer()
-        self._set_inputs()
-        self._set_parameters_using_data_flow()
-        self._set_activations()
-        self._set_optimizer_state()
-        self._set_autograd_detail()
-
-    @property
-    def timeline(self) -> Tuple[Tuple[int, Action, KeyAndID, int], ...]:
-        output: List[Tuple[int, Action, KeyAndID, int]] = []
-        allocation_times: Dict[Tuple[TensorKey, bool], int] = {}
-        live_unknown: Dict[Tuple[int, torch.device], Literal[True]] = {}
-        for event in self._op_tree.dfs():
-            if event.typed[0] == _EventType.Allocation:
-                alloc_fields = event.typed[1]
-                alloc_size = alloc_fields.alloc_size
-                is_allocation = alloc_size > 0
-                t = event.start_time_ns
-
-                tkey = TensorKey.from_allocation(alloc_fields)
-                if tkey is not None:
-                    allocation_times[(tkey, is_allocation)] = t
-
-                else:
-                    key = Key(alloc_fields.device)
-                    ptr_and_device = (alloc_fields.ptr, key.device)
-                    if is_allocation:
-                        if ptr_and_device in live_unknown:
-                            output.append(
-                                (t, Action.INCREMENT_VERSION, (key, 0), alloc_size)
-                            )
-                        else:
-                            live_unknown[ptr_and_device] = True
-                            output.append((t, Action.CREATE, (key, 0), alloc_size))
-                    else:
-                        output.append((t, Action.DESTROY, (key, 0), -alloc_size))
-                        if not live_unknown.pop(ptr_and_device, False):
-                            output.append(
-                                (-1, Action.PREEXISTING, (key, 0), -alloc_size)
-                            )
-
-        snapshot = self._category_snapshot()
-        last_version = dict(sorted(snapshot.keys()))
-
-        events: List[Tuple[int, Action, TensorAndID]] = [
-            (-1, Action.PREEXISTING, (key, version))
-            for key, version in snapshot.keys()
-            if (key, True) not in allocation_times and version == 0
-        ]
-
-        for node in self._data_flow_graph.flow_nodes:
-            for key, edge in node._edges.items():
-                if edge.is_allocation:
-                    t = allocation_times[(key, True)]
-                    events.append((t, Action.CREATE, (key, 0)))
-
-                elif edge.mutated:
-                    t = node._event.start_time_ns
-                    version = edge.input_version
-                    assert version is not None
-                    events.append((t, Action.INCREMENT_VERSION, (key, version)))
-
-                if edge.is_deletion:
-                    t = allocation_times[(key, False)]
-                    events.append((t, Action.DESTROY, (key, last_version[key])))
-
-        output.extend(
-            (time, action, (key, version), self._size_map[key])
-            for time, action, (key, version) in events
-        )
-
-        output.sort(key=lambda x: (x[0], x[1].value))
-        return tuple(output)
-
-    def _is_gradient(self, *args, **kwargs) -> bool:
-        return self._categories.get(*args, **kwargs) == Category.GRADIENT
-
-    def _category_snapshot(self) -> Dict[TensorAndID, Optional[Category]]:
-        all_tensor_versions: Set[TensorAndID] = set()
-
-        for node in self._data_flow_graph.flow_nodes:
-            all_tensor_versions.update(((k, v) for k, (_, v) in node.inputs.items()))
-            all_tensor_versions.update((key, 0) for key in node.intermediates)
-            all_tensor_versions.update(node.outputs.items())
-
-        for i in self._categories._values.values():
-            all_tensor_versions.update((key, 0) for key in i._by_id_keyset)
-
-        return {
-            (key, version): self._categories.get(key, version)
-            for key, version in sorted(all_tensor_versions)
-        }
-
-    def _any_version_depends_on_gradient(self) -> Set[int]:
-        """Extract IDs of Tensors which depend or will depend on a gradient.
-
-        Note that this weakened definition of "depends" requires us to loop
-        over the data flow graph multiple times because it allows dependency
-        information to flow backward through edges and removes the guarantee
-        that nodes are topologically sorted. (Or indeed, even that a valid
-        topological order exists.) Put another way, we have converted an
-        acyclic data flow graph into a cyclic graph and we are attempting to
-        partition cycles involving a gradient from the rest of the graph.
-        """
-        depends_on_gradient: Set[int] = set()
-        while True:
-            start_size = len(depends_on_gradient)
-            for node in self._data_flow_graph.flow_nodes:
-                ids = tuple(
-                    key.id
-                    for key, (_, version) in node.inputs.items()
-                    if self._categories.get(key, version)
-                    in (Category.GRADIENT, Category.PARAMETER)
-                    or key.id in depends_on_gradient
-                )
-
-                if ids:
-                    depends_on_gradient.update(ids)
-                    depends_on_gradient.update(key.id for key in node.outputs)
-
-            # We are guaranteed to exit because there is a finite set of
-            # TensorAndID pairs. In practice we do not expect to loop more than
-            # three times: once to identify the core parameter update loop,
-            # once to fold the first step into that loop, and a third time
-            # where no new elements are added.
-            if len(depends_on_gradient) == start_size:
-                return depends_on_gradient
-
-    def _set_gradients_and_temporaries(self) -> None:
-        """Mark Tensors which are unambiguous and simple to reason about."""
-
-        # Gradients are straightforward to detect. We directly check the
-        # `.grad` property in the Python tracer, and we can detect any new
-        # gradient Tensors from `AccumulateGrad` ops.
-        for event in self._op_tree.dfs():
-            for _, p_grad in extract_gradients(event):
-                self._categories.set_by_id(p_grad, Category.GRADIENT)
-
-        # Similarly, temporary Tensors are easy to identify and are useful to
-        # flag since they can make memory use "spikier" than one would
-        # otherwise expect.
-        for node in self._data_flow_graph.flow_nodes:
-            for i in node.intermediates:
-                self._categories.set_by_key(i, Category.TEMPORARY)
-
-    def _set_parameters_using_python_tracer(self) -> None:
-        for event in self._op_tree.dfs():
-            for p in extract_parameters(event):
-                if p is not None:
-                    self._categories.set_by_id(p, Category.PARAMETER)
-
-    def _set_inputs(self) -> None:
-        """Mark inputs based on which Tensors are updated using gradients.
-
-        The process for differentiating between inputs and activations is more
-        involved. Most Tensors in a training loop depend on at least one
-        gradient: parameters depend on them through updates, and activations
-        and optimizer state depend on them transitively through parameters.
-        Critically, we do not need to know which Tensors are parameters to
-        apply this method; we can simply walk the data flow graph to build the
-        set of all values which depend on a gradient and then obtain the set
-        of inputs from the conjugate set.
-
-        There is, however, one hiccup. The first time we see a parameter is
-        generally on the forward pass of the first step. We know from
-        inspection of the data flow graph that v1 of that Tensor depends on
-        a gradient (provided we profile an optimizer step), but not v0. To
-        address this problem we weaken the definition of "depends on a
-        gradient" to "any version of this Tensor depends on a gradient",
-        which in turn strengthens the criteria for the input set enough to
-        filter the activations in the forward pass of the first step."""
-
-        # All of this analysis is predicated on using at least one training
-        # step (or parameters from the python tracer) to partition the graph.
-        # Absent that we cannot determine which Tensors are inputs and which
-        # ones are part of the model.
-        depends_on_gradient = self._any_version_depends_on_gradient()
-
-        # We only want to annotate Tensors which actually contribute to the
-        # model calculation.
-        produces_gradient: Set[TensorAndID] = set()
-        for node in reversed(self._data_flow_graph.flow_nodes):
-            tensors = {(key, version) for key, (_, version) in node.inputs.items()}
-            tensors |= node.outputs.items()
-            if any(
-                self._categories.get(*i) in (Category.GRADIENT, Category.PARAMETER)
-                or i in produces_gradient
-                for i in tensors
-            ):
-                produces_gradient |= tensors
-
-        # Don't include Tensors created in the backward pass, as these are
-        # generally Autograd implementation details rather than proper inputs.
-        input_candidates = produces_gradient.copy()
-        for node in self._data_flow_graph.flow_nodes:
-            if RecordScope.BACKWARD_FUNCTION in get_scopes(node._event):
-                input_candidates -= set(node.outputs.items())
-
-        for key, version in input_candidates:
-            if key.id not in depends_on_gradient:
-                self._categories.setdefault_by_version(key, version, Category.INPUT)
-
-    def _set_parameters_using_data_flow(self) -> None:
-        """Deduce which Tensors are parameters.
-
-        Consider the following code for the step of SGD with momentum
-        (nesterov=False), where `d_p` is the gradient of `param` and `buf` is
-        the momentum buffer.
-        ```
-          buf.mul_(momentum).add_(d_p, alpha=1 - dampening)
-          d_p = buf
-          param.add_(d_p, alpha=-lr)
-        ```
-        Both `param` and `buf` take a gradient and perform an in-place update.
-
-        The python tracer will inspect calls to `nn.Module.forward` and
-        `optim.Optimizer.step` to extract parameter and optimizer state
-        respectively (including parameters), so this is generally a non-issue.
-
-        However as a fallback we can also exploit several properties of
-        parameters to distinguish them from other model state.
-
-        First, they are directly used in the forward pass. (At this point we
-        haven't established which parts of the graph correspond to the forward
-        pass but we can deduce enough to suffice.) Some mutable state such as
-        batch norm moving averages also contribute to the forward pass, but
-        optimizer state does not.
-
-        Second, a parameter is by definition used to compute at least one
-        gradient and depends on at least one gradient.
-        """
-        snapshot = self._category_snapshot()
-
-        # Determine which Tensors might be parameters based on forward pass
-        # data flow. Note this these are only candidates; we filter nodes that
-        # we know are part of the backward pass but that doesn't guarantee that
-        # they are part of the forward pass.
-        candidate_parameters: Set[TensorAndID] = set()
-        candidate_fwd_tensors: Set[TensorAndID] = {
-            i for i, category in snapshot.items() if category == Category.INPUT
-        }
-
-        for node in self._data_flow_graph.flow_nodes:
-            inputs = {(key, value) for key, (_, value) in node.inputs.items()}
-            if (
-                # Don't check nodes in the backward pass.
-                RecordScope.BACKWARD_FUNCTION not in get_scopes(node._event)
-                and not any(self._is_gradient(*i) for i in inputs)
-                and not any(self._is_gradient(*i) for i in node.outputs.items())
-                #
-                # and only check nodes which depend on an input.
-                and candidate_fwd_tensors.intersection(inputs)
-            ):
-                candidate_fwd_tensors |= node.outputs.items()
-                candidate_parameters |= inputs.difference(candidate_fwd_tensors)
-
-        # Require that each parameter eventually contributes to the value of a gradient
-        used_for_gradient: Set[TensorAndID] = set()
-        for node in reversed(self._data_flow_graph.flow_nodes):
-            if any(
-                self._is_gradient(*i) or i in used_for_gradient
-                for i in node.outputs.items()
-            ):
-                for key, (_, version) in node.inputs.items():
-                    used_for_gradient.add((key, version))
-        candidate_parameters.intersection_update(used_for_gradient)
-
-        # and depends on a gradient.
-        parameter_keys = {key.id for key, _ in candidate_parameters}
-        parameter_keys &= self._any_version_depends_on_gradient()
-
-        for key, _ in snapshot.keys():
-            if key.id in parameter_keys:
-                self._categories.set_by_id(key, Category.PARAMETER)
-
-    def _set_activations(self) -> None:
-        """Flood the graph to identify activations."""
-
-        required = {Category.INPUT, Category.ACTIVATION}
-        also_allowed = {Category.PARAMETER, Category.TEMPORARY}
-        for node in self._data_flow_graph.flow_nodes:
-            inputs = {(key, value) for key, (_, value) in node.inputs.items()}
-            input_categories = {self._categories.get(*i) for i in inputs}
-
-            if (
-                (input_categories & required)
-                and not (input_categories - (required | also_allowed))
-                #
-                # Stop filling when we reach the backward pass.
-                and RecordScope.BACKWARD_FUNCTION not in get_scopes(node._event)
-            ):
-                for i in node.outputs.items():
-                    self._categories.setdefault_by_version(*i, Category.ACTIVATION)
-
-    def _set_optimizer_state(self) -> None:
-        for event in self._op_tree.dfs():
-            if event.typed[0] == _EventType.PyCall and event.typed[1].optimizer:
-                parameters = event.typed[1].optimizer.parameters
-                for _, t in it.chain(*[state for _, _, state in parameters]):
-                    key = TensorKey.from_tensor(t)
-                    if key is not None:
-                        self._categories.set_by_id(key, Category.OPTIMIZER_STATE)
-
-    def _set_autograd_detail(self):
-        prior = {None, Category.AUTOGRAD_DETAIL}
-        for node in self._data_flow_graph.flow_nodes:
-            if RecordScope.BACKWARD_FUNCTION in get_scopes(node._event):
-                for key, version in node.outputs.items():
-                    if version == 0 or self._categories.get(key, version - 1) in prior:
-                        self._categories.setdefault_by_version(
-                            key, version, Category.AUTOGRAD_DETAIL
-                        )
-
-
-class MemoryProfileTimeline:
-    def __init__(self, memory_profile):
-        """The minimum representation of the memory profile timeline
-        includes the memory timeline and categories. The timeline
-        consists of [timestamp, action, (TensorKey, version), numbytes]
-        elements, to denote any actions (pre-existing, create, destroy,
-        or increment_version) that occurred to a specific Tensor for a
-        chunk of memory. The categories help map each (TensorKey,
-        version) pair into a category."""
-        self.timeline = memory_profile.timeline
-        self.categories = memory_profile._categories
-
-    def _coalesce_timeline(self, device_str):
-        """Convert the memory timeline and categories into a memory plot
-        consisting of timestamps and their respective sizes by category
-        for a given device.
-
-        Input: device
-        Output: [timestamps, sizes by category]
-        """
-        device = torch.device(device_str)
-        times: List[int] = []
-        sizes: List[List[int]] = []
-
-        def update(key, version, delta):
-            category = (
-                self.categories.get(key, version)
-                if isinstance(key, TensorKey)
-                else None
-            )
-            index = _CATEGORY_TO_INDEX[category] + 1
-            sizes[-1][index] += int(delta)
-
-        t_min = -1
-        for t, action, (key, version), numbytes in self.timeline:
-            if key.device != device:
-                continue
-
-            # Convert timestamps from ns to us, to match trace events.
-            if t != -1:
-                t = int(t / 1000)
-
-            # Save the smallest timestamp to populate pre-existing allocs.
-            if t_min == -1 or (t < t_min and t > 0):
-                t_min = t
-
-            # Handle timestep
-            if len(times) == 0:
-                times.append(t)
-                sizes.append([0] + [0 for _ in _CATEGORY_TO_INDEX])
-
-            elif t != times[-1]:
-                times.append(t)
-                sizes.append(sizes[-1].copy())
-
-            # Handle memory and categories
-            if action in (Action.PREEXISTING, Action.CREATE):
-                update(key, version, numbytes)
-
-            elif action == Action.INCREMENT_VERSION:
-                update(key, version, -numbytes)
-                update(key, version + 1, numbytes)
-
-            elif action == Action.DESTROY:
-                update(key, version, -numbytes)
-
-            else:
-                raise ValueError(f"Unknown action: {action}")
-
-        times = [t_min if t < 0 else t for t in times]
-        return times, sizes
-
-    def export_memory_timeline(self, path, device_str) -> None:
-        """Saves the memory timeline as [times, sizes by category]
-        as a JSON formatted file to the given path for the given
-        device."""
-        times, sizes = self._coalesce_timeline(device_str)
-        # TODO: Write a faster serialize (orjson not available in CI)
-        import json
-
-        with open(path, "w") as f:
-            json.dump([times, sizes], f)
-
-    def export_memory_timeline_raw(self, path, device_str) -> None:
-        """Saves the memory timeline as raw memory event tuples in the
-        form of (timestamp, action, numbytes, category)
-        as a JSON formatted file to the given path for the given
-        device."""
-        device = torch.device(device_str)
-        raw_events: List[Tuple[int, int, int, int]] = []
-
-        def get_category_index(key, version):
-            category = (
-                self.categories.get(key, version)
-                if isinstance(key, TensorKey)
-                else None
-            )
-            return _CATEGORY_TO_INDEX[category]
-
-        for t, action, (key, version), numbytes in self.timeline:
-            if key.device != device:
-                continue
-
-            if action in (Action.PREEXISTING, Action.CREATE):
-                raw_events.append(
-                    (
-                        t,
-                        _ACTION_TO_INDEX[action],
-                        numbytes,
-                        get_category_index(key, version),
-                    )
-                )
-
-            elif action == Action.INCREMENT_VERSION:
-                raw_events.append(
-                    (
-                        t,
-                        _ACTION_TO_INDEX[action],
-                        -numbytes,
-                        get_category_index(key, version),
-                    )
-                )
-                raw_events.append(
-                    (
-                        t,
-                        _ACTION_TO_INDEX[action],
-                        numbytes,
-                        get_category_index(key, version + 1),
-                    )
-                )
-
-            elif action == Action.DESTROY:
-                raw_events.append(
-                    (
-                        t,
-                        _ACTION_TO_INDEX[action],
-                        -numbytes,
-                        get_category_index(key, version),
-                    )
-                )
-
-            else:
-                raise ValueError(f"Unknown action: {action}")
-
-        import json
-
-        with open(path, "w") as f:
-            json.dump(raw_events, f)
-
-    def export_memory_timeline_html(
-        self, path, device_str, figsize=(20, 12), title=None
-    ) -> None:
-        """Exports the memory timeline as an HTML file which contains
-        the memory timeline plot embedded as a PNG file."""
-        # Check if user has matplotlib installed, return gracefully if not.
-        import importlib.util
-
-        matplotlib_spec = importlib.util.find_spec("matplotlib")
-        if matplotlib_spec is None:
-            print(
-                "export_memory_timeline_html failed because matplotlib was not found."
-            )
-            return
-
-        from base64 import b64encode
-        from os import remove
-        from tempfile import NamedTemporaryFile
-
-        import matplotlib.pyplot as plt
-        import numpy as np
-
-        mt = self._coalesce_timeline(device_str)
-        times, sizes = np.array(mt[0]), np.array(mt[1])
-        # For this timeline, start at 0 to match Chrome traces.
-        t_min = min(times)
-        times -= t_min
-        stacked = np.cumsum(sizes, axis=1) / 1024**3
-        device = torch.device(device_str)
-        max_memory_allocated = torch.cuda.max_memory_allocated(device)
-        max_memory_reserved = torch.cuda.max_memory_reserved(device)
-
-        # Plot memory timeline as stacked data
-        fig = plt.figure(figsize=figsize, dpi=80)
-        axes = fig.gca()
-        for category, color in _CATEGORY_TO_COLORS.items():
-            i = _CATEGORY_TO_INDEX[category]
-            axes.fill_between(
-                times / 1e3, stacked[:, i], stacked[:, i + 1], color=color, alpha=0.7
-            )
-        fig.legend(["Unknown" if i is None else i.name for i in _CATEGORY_TO_COLORS])
-        # Usually training steps are in magnitude of ms.
-        axes.set_xlabel("Time (ms)")
-        axes.set_ylabel("Memory (GB)")
-        title = "\n\n".join(
-            ([title] if title else [])
-            + [
-                f"Max memory allocated: {max_memory_allocated/(1024**3):.2f} GiB \n"
-                f"Max memory reserved: {max_memory_reserved/(1024**3):.2f} GiB"
-            ]
-        )
-        axes.set_title(title)
-
-        # Embed the memory timeline image into the HTML file
-        tmpfile = NamedTemporaryFile("wb", suffix=".png", delete=False)
-        tmpfile.close()
-        fig.savefig(tmpfile.name, format="png")
-
-        with open(tmpfile.name, "rb") as tmp:
-            encoded = b64encode(tmp.read()).decode("utf-8")
-            html = f"""<html>
-<head><meta charset="utf-8" /><title>GPU Memory Timeline HTML</title></head>
-<body>
-  <img src='data:image/png;base64,{encoded}'>
-</body>
-</html>"""
-
-            with open(path, "w") as f:
-                f.write(html)
-        remove(tmpfile.name)

shared/package-files/9b/9b7c8bd1d4c05d73ca75e619a0bf9958598fd50abe57a63d5f11bb10c43ba2f1/blob

@@ -1,329 +0,0 @@
-from torch.fx.passes.utils.fuser_utils import fuse_by_partitions
-import collections
-import itertools
-import logging
-
-from copy import copy
-from typing import Dict, Iterable, List, Optional, Sequence, Set
-
-from torch.fx.graph_module import GraphModule
-from torch.fx.node import Node, _get_qualified_name
-from torch.fx.passes.operator_support import OperatorSupportBase
-
-
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.WARNING)
-
-class Partition:
-    def __init__(self, id: Optional[int] = None, nodes: Optional[Iterable[Node]] = None):
-        self.id = id
-        self.nodes: Set[Node] = set(nodes) if nodes is not None else set()
-
-    def __repr__(self) -> str:
-        return str(self.nodes)
-
-    def add_node(self, node: Node):
-        self.nodes.add(node)
-
-    def remove_node(self, node: Node):
-        self.nodes.remove(node)
-
-    def size(self):
-        return len(self.nodes)
-
-class _DependencyViewer:
-    def __init__(self, graph_module: GraphModule):
-        self.upstreams = collections.defaultdict(set)
-        self.downstreams = collections.defaultdict(set)
-
-        for node in graph_module.graph.nodes:
-            for input_node in node.all_input_nodes:
-                # add input_node and input_node's upstream dependency
-                self.upstreams[node].add(input_node)
-                self.upstreams[node].update(self.upstreams[input_node])
-
-        for node in reversed(graph_module.graph.nodes):
-            for output_node in node.users:
-                # add output_node and output_node's downstream dependency
-                self.downstreams[node].add(output_node)
-                self.downstreams[node].update(self.downstreams[output_node])
-
-    def downstreams_of(self, node: Node) -> Set[Node]:
-        return self.downstreams[node]
-
-    def upstreams_of(self, node: Node) -> Set[Node]:
-        return self.upstreams[node]
-
-class CapabilityBasedPartitioner:
-
-    def __init__(self,
-                 graph_module: GraphModule,
-                 operator_support: OperatorSupportBase,
-                 allows_single_node_partition: bool = False,
-                 non_compute_ops: Optional[Sequence[str]] = None,
-                 allowed_single_node_partition_ops: Optional[Sequence[str]] = None,
-                 ) -> None:
-        self.graph_module = graph_module
-        self.operator_support = operator_support
-        self.allows_single_node_partition = allows_single_node_partition
-        self.non_compute_ops = non_compute_ops if non_compute_ops is not None else []
-        self.allowed_single_node_partition_ops = (
-            allowed_single_node_partition_ops
-            if allowed_single_node_partition_ops is not None
-            else []
-        )
-        self.dependency_viewer = _DependencyViewer(graph_module)
-
-    def __is_node_supported(self, node: Node) -> bool:
-        return (
-            self.operator_support.is_node_supported(dict(self.graph_module.named_modules()), node)
-        )
-
-    def propose_partitions(self) -> List[Partition]:
-        # partition_map is a mapping from partition id to a set of partition id's.
-        # The value set contains all the partition ids that can be reached by doing a
-        # DFS starting from the partition id in the key.
-        partition_map : Dict[int, Set] = collections.defaultdict(set)
-
-        # assumptions: nodes in candidate list is sorted in topological order
-        assignment: Dict[Node, int] = {}   # mapping from node to partition_id
-        partitions_by_id: Dict[int, Partition] = {}  # mapping from partition_id to partition
-        new_partition_id = itertools.count()
-
-        # try to merge partition other_id into partition self_id
-        # merge only happens if the end graph doesn't contain cyclic dependency
-        # returns `True` when merge happens, `False` otherwise.
-        def maybe_merge_partition(self_id: int, other_id: int):
-            # merged_nodes is the union of nodes in two partition to-be-merged
-            merged_nodes = copy(partitions_by_id[self_id].nodes)
-            merged_nodes.update(partitions_by_id[other_id].nodes)
-
-            def dfs_iter_find_cycle(all_user_nodes: List[Node]):
-                for user_node in all_user_nodes:
-                    visited_partition_ids = set()
-
-                    for path_node in self.dependency_viewer.downstreams_of(user_node):
-                        # If any of the nodes in the dfs path of this node are in the merged_nodes
-                        # list then there is a cycle in the graph.
-                        if path_node in merged_nodes:
-                            return True
-
-                        # If any of the nodes in the dfs path of this node are in the assignment
-                        # map then we have to make sure that the partitions that these nodes belong
-                        # to do not form a cycle with the current partitions being merged. This means
-                        # iterating through all the nodes in all the parititons that are traversed in
-                        # the dfs path and checking if they are in the merged_nodes list.
-                        if path_node in assignment:
-                            partition_id = assignment[path_node]
-                            # If the partition id has already been visited then we know that it doesn't
-                            # form a cycle with the current partitions being merged.
-                            if partition_id in visited_partition_ids:
-                                continue
-                            p_map = partition_map[partition_id]
-                            if self_id in p_map or other_id in p_map:
-                                return True
-
-                            visited_partition_ids.add(partition_id)
-
-                return False
-
-            # check if merge would create cyclic dependency.
-            all_user_nodes = []
-            for node in merged_nodes:
-                for user_node in node.users:
-                    if user_node not in merged_nodes:
-                        all_user_nodes.append(user_node)
-
-            if dfs_iter_find_cycle(all_user_nodes):
-                # return false indicating cyclic dependency found and
-                # merge is aborted
-                return False
-
-            # no cyclic dependency found, move forward with the merge
-            # updating partition nodes
-            partitions_by_id[self_id].nodes = merged_nodes
-            # updating assignment map
-            for node in partitions_by_id[other_id].nodes:
-                assignment[node] = self_id
-            # delete other partition
-            del partitions_by_id[other_id]
-
-            partition_map[self_id] = partition_map[self_id].union(partition_map[other_id])
-            del partition_map[other_id]
-
-            return True
-
-        def merge_single_node(node: Node, id: Optional[int]):
-            def _update_partition_map(node: Node, id: int):
-                # Iterate through all the downstream nodes of this node and update the partition map
-                # to indicate that there is a path from the partition id of this node to the target
-                # partition id.
-                downstream_nodes = self.dependency_viewer.downstreams_of(node)
-                for curr_node in downstream_nodes:
-                    target_id = assignment.get(curr_node, None)
-                    if target_id is not None:
-                        partition_map[id].add(target_id)
-
-                # Iterate through all the upstream nodes of this node and update the partition map
-                # to indicate that there is a path from the partition id of the upstream node to the
-                # current node's partition id.
-                upstream_nodes = self.dependency_viewer.upstreams_of(node)
-                for curr_node in upstream_nodes:
-                    source_id = assignment.get(curr_node, None)
-                    if source_id is not None:
-                        partition_map[source_id].add(id)
-
-            if node in assignment:
-                partitions_by_id[assignment[node]].remove_node(node)
-
-            if id is None:
-                assignment.pop(node)
-            elif id not in partitions_by_id:
-                assignment[node] = id
-                partitions_by_id[id] = Partition(id=id, nodes=[node])
-                _update_partition_map(node, id)
-            else:
-                assignment[node] = id
-                partitions_by_id[id].add_node(node)
-                _update_partition_map(node, id)
-
-        logger.debug("Proposing partitions...")
-
-        for node in reversed(self.graph_module.graph.nodes):
-            # use Dict as an ordered set to ensure deterministic partitioning result, don't care value
-            merge_candidates: Dict[int, None] = {}
-
-            # Note a limited horizontal fusion is enabled:
-            #   when `node` is not supported, the code below attempts to fuse consumer of `node`.
-            #
-            # I don't see a need to add a knob to disable horizontal fusion yet, we can short-cut
-            # the fusion by adding an `else` block here to skip horizontal fusion.
-            if self.__is_node_supported(node) and node not in assignment:
-                partition_id = next(new_partition_id)
-                merge_single_node(node, partition_id)
-                merge_candidates[partition_id] = None
-
-            # merge all possible partitions
-            for node in assignment:
-                merge_candidates[assignment[node]] = None
-
-            merge_candidates_list = list(merge_candidates.keys())
-            if len(merge_candidates_list) > 1:
-                self_id = merge_candidates_list[0]
-                for other_id in merge_candidates_list[1:]:
-                    # note: merge partition `other_id` into partition `self_id` if
-                    # it doesn't create cyclic dependency in the graph, otherwise,
-                    # this is a no-op
-                    maybe_merge_partition(self_id, other_id)
-
-        # post processing to re-assign "getitem" nodes into upstream partition
-        logger.debug("Reassigning getitem nodes to its producer node's partition...")
-        nodes_reassignment: Dict[Node, int] = {}
-        for node in self.graph_module.graph.nodes:
-            is_tuple_output = True
-            for user in node.users:
-                if user.op != "call_function" or \
-                   _get_qualified_name(user.target) != "_operator.getitem":     # type: ignore[arg-type]
-                    is_tuple_output = False
-                    break
-
-            # node has tuple outputs, re-assign all following getitem node into node's partition
-            if is_tuple_output:
-                id = assignment.get(node, None)     # type: ignore[arg-type]
-                for user in node.users:
-                    if assignment.get(user, None) != id:    # type: ignore[arg-type]
-                        nodes_reassignment[user] = id  # type: ignore[assignment]
-        for node, id in nodes_reassignment.items():
-            merge_single_node(node, id)
-
-        # filter out single node partitions
-        if not self.allows_single_node_partition:
-            logger.debug("Filtering out single node partitions...")
-            default_non_compute_ops = {"torch.ops.aten.view", "_operator.getitem"}
-            non_compute_ops = default_non_compute_ops.union(set(self.non_compute_ops))
-            partitions_to_remove: List[int] = []
-            for id, partition in partitions_by_id.items():
-                compute_node_count = 0
-                for node in partition.nodes:
-                    if node.op == "call_function":
-                        assert callable(node.target)
-                        if _get_qualified_name(node.target) not in non_compute_ops:
-                            compute_node_count += 1
-                        if _get_qualified_name(node.target) in self.allowed_single_node_partition_ops:
-                            compute_node_count += 1
-                if compute_node_count <= 1:
-                    partitions_to_remove.append(id)
-            for id in partitions_to_remove:
-                del partitions_by_id[id]
-
-        logger.debug("Partitions proposed:")
-        for id, partition in partitions_by_id.items():
-            logger.debug("partition #%s: %s", id, [node.name for node in partition.nodes])
-
-        return list(partitions_by_id.values())
-
-    def fuse_partitions(self, partitions: List[Partition]) -> GraphModule:
-        logger.debug("Fusing partitions...")
-        # fuse_by_partitions expects partitions in List[List[Node]]: [ [node0, node1], [node2, node3] ]
-        return fuse_by_partitions(self.graph_module, [list(partition.nodes) for partition in partitions])
-
-    # remove non-compute-ops that sits at the boundary of a partition.
-    def remove_bookend_non_compute_ops(self, partitions: List[Partition]):
-        non_compute_ops = set(self.non_compute_ops)
-
-        def is_non_compute_node(node: Node):
-            return node.op == "call_function" and \
-                _get_qualified_name(node.target) in non_compute_ops  # type: ignore[arg-type]
-
-        # cache transparent nodes
-        transparent_input_nodes: Dict[Node, bool] = {}
-        transparent_output_nodes: Dict[Node, bool] = {}
-
-        def is_transparent_input_node(node: Node, partition: Set[Node], removed_nodes: Set[Node]):
-            if node.op == "placeholder" or (node not in partition) or (node in removed_nodes):
-                return True
-            if node in transparent_input_nodes:
-                return transparent_input_nodes[node]
-            if is_non_compute_node(node):
-                for input_n in node.all_input_nodes:
-                    if not is_transparent_input_node(input_n, partition, removed_nodes):
-                        transparent_input_nodes[node] = False
-                        return False
-                transparent_input_nodes[node] = True
-                return True
-            transparent_input_nodes[node] = False
-            return False
-
-        def is_transparent_output_node(node: Node, partition: Set[Node], removed_nodes: Set[Node]):
-            if node.op == "placeholder" or (node not in partition) or (node in removed_nodes):
-                return True
-            if node in transparent_output_nodes:
-                return transparent_output_nodes[node]
-            if is_non_compute_node(node):
-                for output_n in node.users:
-                    if not is_transparent_output_node(output_n, partition, removed_nodes):
-                        transparent_output_nodes[node] = False
-                        return False
-                transparent_output_nodes[node] = True
-                return True
-            transparent_output_nodes[node] = False
-            return False
-
-        for partition in partitions:
-            # Note it's ok to use `set` here, since we are only query if a node
-            # has been removed. We are NEVER going to iterate on nodes inside
-            # the set.
-            remove_node: Set[Node] = set()
-            for node in partition.nodes:
-                if is_non_compute_node(node) and \
-                    (is_transparent_input_node(node, partition.nodes, remove_node) or
-                     is_transparent_output_node(node, partition.nodes, remove_node)):
-                    remove_node.add(node)
-
-            if len(remove_node) != 0:
-                partition.nodes = partition.nodes - remove_node
-
-    def partition_and_fuse(self) -> GraphModule:
-        partitions = self.propose_partitions()
-        fused_gm = self.fuse_partitions(partitions)
-        return fused_gm

shared/package-files/9b/9b7d4f55a4e2fdb02c430068fdffabc732addce238da3f1df2690249c3353274/blob

@@ -1,17 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2019-09/schema",
-    "$id": "https://json-schema.org/draft/2019-09/meta/content",
-    "$vocabulary": {
-        "https://json-schema.org/draft/2019-09/vocab/content": true
-    },
-    "$recursiveAnchor": true,
-
-    "title": "Content vocabulary meta-schema",
-
-    "type": ["object", "boolean"],
-    "properties": {
-        "contentMediaType": { "type": "string" },
-        "contentEncoding": { "type": "string" },
-        "contentSchema": { "$recursiveRef": "#" }
-    }
-}

shared/package-files/9b/9b7d69d168dc15419c91b2621e70a949a2101aabfe2eae6788862475ddf760ca/blob

@@ -1,234 +0,0 @@
-"""
-Array methods which are called by both the C-code for the method
-and the Python code for the NumPy-namespace function
-
-"""
-import warnings
-from contextlib import nullcontext
-
-from numpy.core import multiarray as mu
-from numpy.core import umath as um
-from numpy.core.multiarray import asanyarray
-from numpy.core import numerictypes as nt
-from numpy.core import _exceptions
-from numpy.core._ufunc_config import _no_nep50_warning
-from numpy._globals import _NoValue
-from numpy.compat import pickle, os_fspath
-
-# save those O(100) nanoseconds!
-umr_maximum = um.maximum.reduce
-umr_minimum = um.minimum.reduce
-umr_sum = um.add.reduce
-umr_prod = um.multiply.reduce
-umr_any = um.logical_or.reduce
-umr_all = um.logical_and.reduce
-
-# Complex types to -> (2,)float view for fast-path computation in _var()
-_complex_to_float = {
-    nt.dtype(nt.csingle) : nt.dtype(nt.single),
-    nt.dtype(nt.cdouble) : nt.dtype(nt.double),
-}
-# Special case for windows: ensure double takes precedence
-if nt.dtype(nt.longdouble) != nt.dtype(nt.double):
-    _complex_to_float.update({
-        nt.dtype(nt.clongdouble) : nt.dtype(nt.longdouble),
-    })
-
-# avoid keyword arguments to speed up parsing, saves about 15%-20% for very
-# small reductions
-def _amax(a, axis=None, out=None, keepdims=False,
-          initial=_NoValue, where=True):
-    return umr_maximum(a, axis, None, out, keepdims, initial, where)
-
-def _amin(a, axis=None, out=None, keepdims=False,
-          initial=_NoValue, where=True):
-    return umr_minimum(a, axis, None, out, keepdims, initial, where)
-
-def _sum(a, axis=None, dtype=None, out=None, keepdims=False,
-         initial=_NoValue, where=True):
-    return umr_sum(a, axis, dtype, out, keepdims, initial, where)
-
-def _prod(a, axis=None, dtype=None, out=None, keepdims=False,
-          initial=_NoValue, where=True):
-    return umr_prod(a, axis, dtype, out, keepdims, initial, where)
-
-def _any(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True):
-    # Parsing keyword arguments is currently fairly slow, so avoid it for now
-    if where is True:
-        return umr_any(a, axis, dtype, out, keepdims)
-    return umr_any(a, axis, dtype, out, keepdims, where=where)
-
-def _all(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True):
-    # Parsing keyword arguments is currently fairly slow, so avoid it for now
-    if where is True:
-        return umr_all(a, axis, dtype, out, keepdims)
-    return umr_all(a, axis, dtype, out, keepdims, where=where)
-
-def _count_reduce_items(arr, axis, keepdims=False, where=True):
-    # fast-path for the default case
-    if where is True:
-        # no boolean mask given, calculate items according to axis
-        if axis is None:
-            axis = tuple(range(arr.ndim))
-        elif not isinstance(axis, tuple):
-            axis = (axis,)
-        items = 1
-        for ax in axis:
-            items *= arr.shape[mu.normalize_axis_index(ax, arr.ndim)]
-        items = nt.intp(items)
-    else:
-        # TODO: Optimize case when `where` is broadcast along a non-reduction
-        # axis and full sum is more excessive than needed.
-
-        # guarded to protect circular imports
-        from numpy.lib.stride_tricks import broadcast_to
-        # count True values in (potentially broadcasted) boolean mask
-        items = umr_sum(broadcast_to(where, arr.shape), axis, nt.intp, None,
-                        keepdims)
-    return items
-
-def _clip(a, min=None, max=None, out=None, **kwargs):
-    if min is None and max is None:
-        raise ValueError("One of max or min must be given")
-
-    if min is None:
-        return um.minimum(a, max, out=out, **kwargs)
-    elif max is None:
-        return um.maximum(a, min, out=out, **kwargs)
-    else:
-        return um.clip(a, min, max, out=out, **kwargs)
-
-def _mean(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True):
-    arr = asanyarray(a)
-
-    is_float16_result = False
-
-    rcount = _count_reduce_items(arr, axis, keepdims=keepdims, where=where)
-    if rcount == 0 if where is True else umr_any(rcount == 0, axis=None):
-        warnings.warn("Mean of empty slice.", RuntimeWarning, stacklevel=2)
-
-    # Cast bool, unsigned int, and int to float64 by default
-    if dtype is None:
-        if issubclass(arr.dtype.type, (nt.integer, nt.bool_)):
-            dtype = mu.dtype('f8')
-        elif issubclass(arr.dtype.type, nt.float16):
-            dtype = mu.dtype('f4')
-            is_float16_result = True
-
-    ret = umr_sum(arr, axis, dtype, out, keepdims, where=where)
-    if isinstance(ret, mu.ndarray):
-        with _no_nep50_warning():
-            ret = um.true_divide(
-                    ret, rcount, out=ret, casting='unsafe', subok=False)
-        if is_float16_result and out is None:
-            ret = arr.dtype.type(ret)
-    elif hasattr(ret, 'dtype'):
-        if is_float16_result:
-            ret = arr.dtype.type(ret / rcount)
-        else:
-            ret = ret.dtype.type(ret / rcount)
-    else:
-        ret = ret / rcount
-
-    return ret
-
-def _var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *,
-         where=True):
-    arr = asanyarray(a)
-
-    rcount = _count_reduce_items(arr, axis, keepdims=keepdims, where=where)
-    # Make this warning show up on top.
-    if ddof >= rcount if where is True else umr_any(ddof >= rcount, axis=None):
-        warnings.warn("Degrees of freedom <= 0 for slice", RuntimeWarning,
-                      stacklevel=2)
-
-    # Cast bool, unsigned int, and int to float64 by default
-    if dtype is None and issubclass(arr.dtype.type, (nt.integer, nt.bool_)):
-        dtype = mu.dtype('f8')
-
-    # Compute the mean.
-    # Note that if dtype is not of inexact type then arraymean will
-    # not be either.
-    arrmean = umr_sum(arr, axis, dtype, keepdims=True, where=where)
-    # The shape of rcount has to match arrmean to not change the shape of out
-    # in broadcasting. Otherwise, it cannot be stored back to arrmean.
-    if rcount.ndim == 0:
-        # fast-path for default case when where is True
-        div = rcount
-    else:
-        # matching rcount to arrmean when where is specified as array
-        div = rcount.reshape(arrmean.shape)
-    if isinstance(arrmean, mu.ndarray):
-        with _no_nep50_warning():
-            arrmean = um.true_divide(arrmean, div, out=arrmean,
-                                     casting='unsafe', subok=False)
-    elif hasattr(arrmean, "dtype"):
-        arrmean = arrmean.dtype.type(arrmean / rcount)
-    else:
-        arrmean = arrmean / rcount
-
-    # Compute sum of squared deviations from mean
-    # Note that x may not be inexact and that we need it to be an array,
-    # not a scalar.
-    x = asanyarray(arr - arrmean)
-
-    if issubclass(arr.dtype.type, (nt.floating, nt.integer)):
-        x = um.multiply(x, x, out=x)
-    # Fast-paths for built-in complex types
-    elif x.dtype in _complex_to_float:
-        xv = x.view(dtype=(_complex_to_float[x.dtype], (2,)))
-        um.multiply(xv, xv, out=xv)
-        x = um.add(xv[..., 0], xv[..., 1], out=x.real).real
-    # Most general case; includes handling object arrays containing imaginary
-    # numbers and complex types with non-native byteorder
-    else:
-        x = um.multiply(x, um.conjugate(x), out=x).real
-
-    ret = umr_sum(x, axis, dtype, out, keepdims=keepdims, where=where)
-
-    # Compute degrees of freedom and make sure it is not negative.
-    rcount = um.maximum(rcount - ddof, 0)
-
-    # divide by degrees of freedom
-    if isinstance(ret, mu.ndarray):
-        with _no_nep50_warning():
-            ret = um.true_divide(
-                    ret, rcount, out=ret, casting='unsafe', subok=False)
-    elif hasattr(ret, 'dtype'):
-        ret = ret.dtype.type(ret / rcount)
-    else:
-        ret = ret / rcount
-
-    return ret
-
-def _std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *,
-         where=True):
-    ret = _var(a, axis=axis, dtype=dtype, out=out, ddof=ddof,
-               keepdims=keepdims, where=where)
-
-    if isinstance(ret, mu.ndarray):
-        ret = um.sqrt(ret, out=ret)
-    elif hasattr(ret, 'dtype'):
-        ret = ret.dtype.type(um.sqrt(ret))
-    else:
-        ret = um.sqrt(ret)
-
-    return ret
-
-def _ptp(a, axis=None, out=None, keepdims=False):
-    return um.subtract(
-        umr_maximum(a, axis, None, out, keepdims),
-        umr_minimum(a, axis, None, None, keepdims),
-        out
-    )
-
-def _dump(self, file, protocol=2):
-    if hasattr(file, 'write'):
-        ctx = nullcontext(file)
-    else:
-        ctx = open(os_fspath(file), "wb")
-    with ctx as f:
-        pickle.dump(self, f, protocol=protocol)
-
-def _dumps(self, protocol=2):
-    return pickle.dumps(self, protocol=protocol)

shared/package-files/9b/9b7e40ee33b9e3130d800e30e44767d62fd21db5d6065a504d12cc47c1a06d91/blob

@@ -1,109 +0,0 @@
-"""Numerical Methods for Holonomic Functions"""
-
-from sympy.core.sympify import sympify
-from sympy.holonomic.holonomic import DMFsubs
-
-from mpmath import mp
-
-
-def _evalf(func, points, derivatives=False, method='RK4'):
-    """
-    Numerical methods for numerical integration along a given set of
-    points in the complex plane.
-    """
-
-    ann = func.annihilator
-    a = ann.order
-    R = ann.parent.base
-    K = R.get_field()
-
-    if method == 'Euler':
-        meth = _euler
-    else:
-        meth = _rk4
-
-    dmf = []
-    for j in ann.listofpoly:
-        dmf.append(K.new(j.rep))
-
-    red = [-dmf[i] / dmf[a] for i in range(a)]
-
-    y0 = func.y0
-    if len(y0) < a:
-        raise TypeError("Not Enough Initial Conditions")
-    x0 = func.x0
-    sol = [meth(red, x0, points[0], y0, a)]
-
-    for i, j in enumerate(points[1:]):
-        sol.append(meth(red, points[i], j, sol[-1], a))
-
-    if not derivatives:
-        return [sympify(i[0]) for i in sol]
-    else:
-        return sympify(sol)
-
-
-def _euler(red, x0, x1, y0, a):
-    """
-    Euler's method for numerical integration.
-    From x0 to x1 with initial values given at x0 as vector y0.
-    """
-
-    A = sympify(x0)._to_mpmath(mp.prec)
-    B = sympify(x1)._to_mpmath(mp.prec)
-    y_0 = [sympify(i)._to_mpmath(mp.prec) for i in y0]
-    h = B - A
-    f_0 = y_0[1:]
-    f_0_n = 0
-
-    for i in range(a):
-        f_0_n += sympify(DMFsubs(red[i], A, mpm=True))._to_mpmath(mp.prec) * y_0[i]
-    f_0.append(f_0_n)
-
-    sol = []
-    for i in range(a):
-        sol.append(y_0[i] + h * f_0[i])
-
-    return sol
-
-
-def _rk4(red, x0, x1, y0, a):
-    """
-    Runge-Kutta 4th order numerical method.
-    """
-
-    A = sympify(x0)._to_mpmath(mp.prec)
-    B = sympify(x1)._to_mpmath(mp.prec)
-    y_0 = [sympify(i)._to_mpmath(mp.prec) for i in y0]
-    h = B - A
-
-    f_0_n = 0
-    f_1_n = 0
-    f_2_n = 0
-    f_3_n = 0
-
-    f_0 = y_0[1:]
-    for i in range(a):
-        f_0_n += sympify(DMFsubs(red[i], A, mpm=True))._to_mpmath(mp.prec) * y_0[i]
-    f_0.append(f_0_n)
-
-    f_1 = [y_0[i] + f_0[i]*h/2 for i in range(1, a)]
-    for i in range(a):
-        f_1_n += sympify(DMFsubs(red[i], A + h/2, mpm=True))._to_mpmath(mp.prec) * (y_0[i] + f_0[i]*h/2)
-    f_1.append(f_1_n)
-
-    f_2 = [y_0[i] + f_1[i]*h/2 for i in range(1, a)]
-    for i in range(a):
-        f_2_n += sympify(DMFsubs(red[i], A + h/2, mpm=True))._to_mpmath(mp.prec) * (y_0[i] + f_1[i]*h/2)
-    f_2.append(f_2_n)
-
-    f_3 = [y_0[i] + f_2[i]*h for i in range(1, a)]
-    for i in range(a):
-        f_3_n += sympify(DMFsubs(red[i], A + h, mpm=True))._to_mpmath(mp.prec) * (y_0[i] + f_2[i]*h)
-    f_3.append(f_3_n)
-
-    sol = []
-    for i in range(a):
-        sol.append(y_0[i] + h * (f_0[i]+2*f_1[i]+2*f_2[i]+f_3[i])/6)
-
-    return sol

shared/package-files/9b/9b8648ab7c6ea7dec4c0aab3db5e6fd033f3925eb80c627c7248893b35a43c78/blob

@@ -1,17 +0,0 @@
-from typing import Dict, Tuple
-
-from django.db.backends.base.base import BaseDatabaseWrapper
-
-def psycopg2_version() -> Tuple[int, ...]: ...
-
-PSYCOPG2_VERSION: Tuple[int, ...] = ...
-
-class DatabaseWrapper(BaseDatabaseWrapper):
-    operators: Dict[str, str] = ...
-    pattern_esc: str = ...
-    pattern_ops: Dict[str, str] = ...
-
-    # PostgreSQL backend-specific attributes.
-    _named_cursor_idx: int = ...
-    @property
-    def pg_version(self) -> str: ...

shared/package-files/9b/9b86cb0749eb28f07811ecd87954712f8bacda87a621d2d31e209acfbab4be1a/blob

@@ -1,27 +0,0 @@
-#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_fractional_max_pool2d_backward : public at::impl::MetaBase {
-    
-    
-    void meta(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef output_size, const at::Tensor & indices);
-};
-
-} // namespace native
-} // namespace at

shared/package-files/9b/9b8b84fe0598495357e29ad58df7c0c4bd126e2514fec2e861a167606009660b/blob

@@ -1,39 +0,0 @@
-#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/_cdist_forward_ops.h>
-
-namespace at {
-
-
-// aten::_cdist_forward(Tensor x1, Tensor x2, float p, int? compute_mode) -> Tensor
-inline at::Tensor _cdist_forward(const at::Tensor & x1, const at::Tensor & x2, double p, c10::optional<int64_t> compute_mode) {
-    return at::_ops::_cdist_forward::call(x1, x2, p, compute_mode);
-}
-
-// aten::_cdist_forward.out(Tensor x1, Tensor x2, float p, int? compute_mode, *, Tensor(a!) out) -> Tensor(a!)
-inline at::Tensor & _cdist_forward_out(at::Tensor & out, const at::Tensor & x1, const at::Tensor & x2, double p, c10::optional<int64_t> compute_mode) {
-    return at::_ops::_cdist_forward_out::call(x1, x2, p, compute_mode, out);
-}
-// aten::_cdist_forward.out(Tensor x1, Tensor x2, float p, int? compute_mode, *, Tensor(a!) out) -> Tensor(a!)
-inline at::Tensor & _cdist_forward_outf(const at::Tensor & x1, const at::Tensor & x2, double p, c10::optional<int64_t> compute_mode, at::Tensor & out) {
-    return at::_ops::_cdist_forward_out::call(x1, x2, p, compute_mode, out);
-}
-
-}

shared/package-files/9b/9b8c6edddc57710cdff7af9638a24f14d9b0d0611517b243e7294c45c79f760d/blob

@@ -1,288 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from narwhals._compliant.any_namespace import DateTimeNamespace
-from narwhals._constants import (
-    MS_PER_SECOND,
-    NS_PER_SECOND,
-    SECONDS_PER_DAY,
-    US_PER_SECOND,
-)
-from narwhals._duration import Interval
-from narwhals._pandas_like.utils import (
-    ALIAS_DICT,
-    UNITS_DICT,
-    PandasLikeSeriesNamespace,
-    calculate_timestamp_date,
-    calculate_timestamp_datetime,
-    get_dtype_backend,
-    int_dtype_mapper,
-    is_dtype_pyarrow,
-)
-
-if TYPE_CHECKING:
-    from datetime import timedelta
-
-    import pandas as pd
-
-    from narwhals._pandas_like.series import PandasLikeSeries
-    from narwhals.typing import TimeUnit
-
-
-class PandasLikeSeriesDateTimeNamespace(
-    PandasLikeSeriesNamespace, DateTimeNamespace["PandasLikeSeries"]
-):
-    def date(self) -> PandasLikeSeries:
-        result = self.with_native(self.native.dt.date)
-        if str(result.dtype).lower() == "object":
-            msg = (
-                "Accessing `date` on the default pandas backend "
-                "will return a Series of type `object`."
-                "\nThis differs from polars API and will prevent `.dt` chaining. "
-                "Please switch to the `pyarrow` backend:"
-                '\ndf.convert_dtypes(dtype_backend="pyarrow")'
-            )
-            raise NotImplementedError(msg)
-        return result
-
-    def year(self) -> PandasLikeSeries:
-        return self.with_native(self.native.dt.year)
-
-    def month(self) -> PandasLikeSeries:
-        return self.with_native(self.native.dt.month)
-
-    def day(self) -> PandasLikeSeries:
-        return self.with_native(self.native.dt.day)
-
-    def hour(self) -> PandasLikeSeries:
-        return self.with_native(self.native.dt.hour)
-
-    def minute(self) -> PandasLikeSeries:
-        return self.with_native(self.native.dt.minute)
-
-    def second(self) -> PandasLikeSeries:
-        return self.with_native(self.native.dt.second)
-
-    def millisecond(self) -> PandasLikeSeries:
-        return self.microsecond() // 1000
-
-    def microsecond(self) -> PandasLikeSeries:
-        if self.backend_version < (3, 0, 0) and self._is_pyarrow():
-            # crazy workaround for https://github.com/pandas-dev/pandas/issues/59154
-            import pyarrow.compute as pc  # ignore-banned-import()
-
-            from narwhals._arrow.utils import lit
-
-            arr_ns = self.native.array
-            arr = arr_ns.__arrow_array__()
-            result_arr = pc.add(
-                pc.multiply(pc.millisecond(arr), lit(1_000)), pc.microsecond(arr)
-            )
-            result = type(self.native)(type(arr_ns)(result_arr), name=self.native.name)
-            return self.with_native(result)
-
-        return self.with_native(self.native.dt.microsecond)
-
-    def nanosecond(self) -> PandasLikeSeries:
-        return self.microsecond() * 1_000 + self.native.dt.nanosecond
-
-    def ordinal_day(self) -> PandasLikeSeries:
-        return self.with_native(self.native.dt.day_of_year)
-
-    def weekday(self) -> PandasLikeSeries:
-        # Pandas is 0-6 while Polars is 1-7
-        impl = self.compliant._implementation
-        native = self.native
-        result = (
-            native.dt.day_of_week
-            if impl.is_pandas() and impl._backend_version() >= (1, 5)
-            else native.dt.weekday
-        )
-        return self.with_native(result) + 1
-
-    def _is_pyarrow(self) -> bool:
-        return is_dtype_pyarrow(self.native.dtype)
-
-    def _get_total_seconds(self) -> Any:
-        if hasattr(self.native.dt, "total_seconds"):
-            return self.native.dt.total_seconds()
-        return (  # pragma: no cover
-            self.native.dt.days * SECONDS_PER_DAY
-            + self.native.dt.seconds
-            + (self.native.dt.microseconds / US_PER_SECOND)
-            + (self.native.dt.nanoseconds / NS_PER_SECOND)
-        )
-
-    def total_minutes(self) -> PandasLikeSeries:
-        s = self._get_total_seconds()
-        # this calculates the sign of each series element
-        s_sign = 2 * (s > 0).astype(int_dtype_mapper(s.dtype)) - 1
-        s_abs = s.abs() // 60
-        if ~s.isna().any():
-            s_abs = s_abs.astype(int_dtype_mapper(s.dtype))
-        return self.with_native(s_abs * s_sign)
-
-    def total_seconds(self) -> PandasLikeSeries:
-        s = self._get_total_seconds()
-        # this calculates the sign of each series element
-        s_sign = 2 * (s > 0).astype(int_dtype_mapper(s.dtype)) - 1
-        s_abs = s.abs() // 1
-        if ~s.isna().any():
-            s_abs = s_abs.astype(int_dtype_mapper(s.dtype))
-        return self.with_native(s_abs * s_sign)
-
-    def total_milliseconds(self) -> PandasLikeSeries:
-        s = self._get_total_seconds() * MS_PER_SECOND
-        # this calculates the sign of each series element
-        s_sign = 2 * (s > 0).astype(int_dtype_mapper(s.dtype)) - 1
-        s_abs = s.abs() // 1
-        if ~s.isna().any():
-            s_abs = s_abs.astype(int_dtype_mapper(s.dtype))
-        return self.with_native(s_abs * s_sign)
-
-    def total_microseconds(self) -> PandasLikeSeries:
-        s = self._get_total_seconds() * US_PER_SECOND
-        # this calculates the sign of each series element
-        s_sign = 2 * (s > 0).astype(int_dtype_mapper(s.dtype)) - 1
-        s_abs = s.abs() // 1
-        if ~s.isna().any():
-            s_abs = s_abs.astype(int_dtype_mapper(s.dtype))
-        return self.with_native(s_abs * s_sign)
-
-    def total_nanoseconds(self) -> PandasLikeSeries:
-        s = self._get_total_seconds() * NS_PER_SECOND
-        # this calculates the sign of each series element
-        s_sign = 2 * (s > 0).astype(int_dtype_mapper(s.dtype)) - 1
-        s_abs = s.abs() // 1
-        if ~s.isna().any():
-            s_abs = s_abs.astype(int_dtype_mapper(s.dtype))
-        return self.with_native(s_abs * s_sign)
-
-    def to_string(self, format: str) -> PandasLikeSeries:
-        # Polars' parser treats `'%.f'` as pandas does `'.%f'`
-        # PyArrow interprets `'%S'` as "seconds, plus fractional seconds"
-        # and doesn't support `%f`
-        if not self._is_pyarrow():
-            format = format.replace("%S%.f", "%S.%f")
-        else:
-            format = format.replace("%S.%f", "%S").replace("%S%.f", "%S")
-        return self.with_native(self.native.dt.strftime(format))
-
-    def replace_time_zone(self, time_zone: str | None) -> PandasLikeSeries:
-        de_zone = self.native.dt.tz_localize(None)
-        result = de_zone.dt.tz_localize(time_zone) if time_zone is not None else de_zone
-        return self.with_native(result)
-
-    def convert_time_zone(self, time_zone: str) -> PandasLikeSeries:
-        if self.compliant.dtype.time_zone is None:  # type: ignore[attr-defined]
-            result = self.native.dt.tz_localize("UTC").dt.tz_convert(time_zone)
-        else:
-            result = self.native.dt.tz_convert(time_zone)
-        return self.with_native(result)
-
-    def timestamp(self, time_unit: TimeUnit) -> PandasLikeSeries:
-        s = self.native
-        dtype = self.compliant.dtype
-        mask_na = s.isna()
-        dtypes = self.version.dtypes
-        if dtype == dtypes.Date:
-            # Date is only supported in pandas dtypes if pyarrow-backed
-            s_cast = s.astype("Int32[pyarrow]")
-            result = calculate_timestamp_date(s_cast, time_unit)
-        elif isinstance(dtype, dtypes.Datetime):
-            fn = (
-                s.view
-                if (self.implementation.is_pandas() and self.backend_version < (2,))
-                else s.astype
-            )
-            s_cast = fn("Int64[pyarrow]") if self._is_pyarrow() else fn("int64")
-            result = calculate_timestamp_datetime(s_cast, dtype.time_unit, time_unit)
-        else:
-            msg = "Input should be either of Date or Datetime type"
-            raise TypeError(msg)
-        result[mask_na] = None
-        return self.with_native(result)
-
-    def truncate(self, every: str) -> PandasLikeSeries:
-        interval = Interval.parse(every)
-        multiple, unit = interval.multiple, interval.unit
-        native = self.native
-        if self.implementation.is_cudf():
-            if multiple != 1:
-                msg = f"Only multiple `1` is supported for cuDF, got: {multiple}."
-                raise NotImplementedError(msg)
-            return self.with_native(self.native.dt.floor(ALIAS_DICT.get(unit, unit)))
-        dtype_backend = get_dtype_backend(native.dtype, self.compliant._implementation)
-        if unit in {"mo", "q", "y"}:
-            if self.implementation.is_cudf():
-                msg = f"Truncating to {unit} is not supported yet for cuDF."
-                raise NotImplementedError(msg)
-            if dtype_backend == "pyarrow":
-                import pyarrow.compute as pc  # ignore-banned-import
-
-                ca = native.array._pa_array
-                result_arr = pc.floor_temporal(ca, multiple, UNITS_DICT[unit])
-            else:
-                if unit == "q":
-                    multiple *= 3
-                    np_unit = "M"
-                elif unit == "mo":
-                    np_unit = "M"
-                else:
-                    np_unit = "Y"
-                arr = native.values  # noqa: PD011
-                arr_dtype = arr.dtype
-                result_arr = arr.astype(f"datetime64[{multiple}{np_unit}]").astype(
-                    arr_dtype
-                )
-            result_native = type(native)(
-                result_arr, dtype=native.dtype, index=native.index, name=native.name
-            )
-            return self.with_native(result_native)
-        return self.with_native(
-            self.native.dt.floor(f"{multiple}{ALIAS_DICT.get(unit, unit)}")
-        )
-
-    def offset_by(self, by: str) -> PandasLikeSeries:
-        native = self.native
-        pdx = self.compliant.__native_namespace__()
-        if self._is_pyarrow():
-            import pyarrow as pa  # ignore-banned-import
-
-            compliant = self.compliant
-            ca = pa.chunked_array([compliant.to_arrow()])
-            result = (
-                compliant._version.namespace.from_backend("pyarrow")
-                .compliant.from_native(ca)
-                .dt.offset_by(by)
-                .native
-            )
-            result_pd = native.__class__(
-                result, dtype=native.dtype, index=native.index, name=native.name
-            )
-        else:
-            interval = Interval.parse_no_constraints(by)
-            multiple, unit = interval.multiple, interval.unit
-            if unit == "q":
-                multiple *= 3
-                unit = "mo"
-            offset: pd.DateOffset | timedelta
-            if unit == "y":
-                offset = pdx.DateOffset(years=multiple)
-            elif unit == "mo":
-                offset = pdx.DateOffset(months=multiple)
-            elif unit == "ns":
-                offset = pdx.Timedelta(multiple, unit=UNITS_DICT[unit])
-            else:
-                offset = interval.to_timedelta()
-            dtype = self.compliant.dtype
-            datetime_dtype = self.version.dtypes.Datetime
-            if unit == "d" and isinstance(dtype, datetime_dtype) and dtype.time_zone:
-                native_without_timezone = native.dt.tz_localize(None)
-                result_pd = native_without_timezone + offset
-                result_pd = result_pd.dt.tz_localize(dtype.time_zone)
-            else:
-                result_pd = native + offset
-
-        return self.with_native(result_pd)

shared/package-files/9b/9b9249bfb2c4ed5ba4a7c879d2bf74b027db392003d9b3152154145313597834/blob

@@ -1,2808 +0,0 @@
-#ifndef TZ_H
-#define TZ_H
-
-// The MIT License (MIT)
-//
-// Copyright (c) 2015, 2016, 2017 Howard Hinnant
-// Copyright (c) 2017 Jiangang Zhuang
-// Copyright (c) 2017 Aaron Bishop
-// Copyright (c) 2017 Tomasz Kamiński
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-//
-// Our apologies.  When the previous paragraph was written, lowercase had not yet
-// been invented (that would involve another several millennia of evolution).
-// We did not mean to shout.
-
-// Get more recent database at http://www.iana.org/time-zones
-
-// The notion of "current timezone" is something the operating system is expected to "just
-// know". How it knows this is system specific. It's often a value set by the user at OS
-// installation time and recorded by the OS somewhere. On Linux and Mac systems the current
-// timezone name is obtained by looking at the name or contents of a particular file on
-// disk. On Windows the current timezone name comes from the registry. In either method,
-// there is no guarantee that the "native" current timezone name obtained will match any
-// of the "Standard" names in this library's "database". On Linux, the names usually do
-// seem to match so mapping functions to map from native to "Standard" are typically not
-// required. On Windows, the names are never "Standard" so mapping is always required.
-// Technically any OS may use the mapping process but currently only Windows does use it.
-
-#ifndef USE_OS_TZDB
-#  define USE_OS_TZDB 0
-#endif
-
-#ifndef HAS_REMOTE_API
-#  if USE_OS_TZDB == 0
-#    if defined _WIN32 || defined __ANDROID__
-#      define HAS_REMOTE_API 0
-#    else
-#      define HAS_REMOTE_API 1
-#    endif
-#  else  // HAS_REMOTE_API makes no sense when using the OS timezone database
-#    define HAS_REMOTE_API 0
-#  endif
-#endif
-
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wconstant-logical-operand"
-#endif
-
-static_assert(!(USE_OS_TZDB && HAS_REMOTE_API),
-              "USE_OS_TZDB and HAS_REMOTE_API can not be used together");
-
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-
-#ifndef AUTO_DOWNLOAD
-#  define AUTO_DOWNLOAD HAS_REMOTE_API
-#endif
-
-static_assert(HAS_REMOTE_API == 0 ? AUTO_DOWNLOAD == 0 : true,
-              "AUTO_DOWNLOAD can not be turned on without HAS_REMOTE_API");
-
-#ifndef USE_SHELL_API
-#  define USE_SHELL_API 1
-#endif
-
-#if USE_OS_TZDB
-#  ifdef _WIN32
-#    error "USE_OS_TZDB can not be used on Windows"
-#  endif
-#endif
-
-#ifndef HAS_DEDUCTION_GUIDES
-#  if __cplusplus >= 201703
-#    define HAS_DEDUCTION_GUIDES 1
-#  else
-#    define HAS_DEDUCTION_GUIDES 0
-#  endif
-#endif  // HAS_DEDUCTION_GUIDES
-
-#include "date.h"
-
-#if defined(_MSC_VER) && (_MSC_VER < 1900)
-#include "tz_private.h"
-#endif
-
-#include <algorithm>
-#include <atomic>
-#include <cassert>
-#include <chrono>
-#include <istream>
-#include <locale>
-#include <memory>
-#include <mutex>
-#include <ostream>
-#include <sstream>
-#include <stdexcept>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#ifdef _WIN32
-#  ifdef DATE_BUILD_DLL
-#    define DATE_API __declspec(dllexport)
-#  elif defined(DATE_USE_DLL)
-#    define DATE_API __declspec(dllimport)
-#  else
-#    define DATE_API
-#  endif
-#else
-#  ifdef DATE_BUILD_DLL
-#    define DATE_API __attribute__ ((visibility ("default")))
-#  else
-#    define DATE_API
-#  endif
-#endif
-
-namespace arrow_vendored::date
-{
-
-enum class choose {earliest, latest};
-
-#if defined(BUILD_TZ_LIB)
-# if defined(ANDROID) || defined(__ANDROID__)
-struct tzdb;
-static std::unique_ptr<tzdb> init_tzdb();
-# endif // defined(ANDROID) || defined(__ANDROID__)
-#endif // defined(BUILD_TZ_LIB)
-
-namespace detail
-{
-    struct undocumented;
-
-    template<typename T>
-    struct nodeduct
-    {
-       using type = T;
-    };
-
-    template<typename T>
-    using nodeduct_t = typename nodeduct<T>::type;
-}
-
-struct sys_info
-{
-    sys_seconds          begin;
-    sys_seconds          end;
-    std::chrono::seconds offset;
-    std::chrono::minutes save;
-    std::string          abbrev;
-};
-
-template<class CharT, class Traits>
-std::basic_ostream<CharT, Traits>&
-operator<<(std::basic_ostream<CharT, Traits>& os, const sys_info& r)
-{
-    os << r.begin << '\n';
-    os << r.end << '\n';
-    os << make_time(r.offset) << "\n";
-    os << make_time(r.save) << "\n";
-    os << r.abbrev << '\n';
-    return os;
-}
-
-struct local_info
-{
-    enum {unique, nonexistent, ambiguous} result;
-    sys_info first;
-    sys_info second;
-};
-
-template<class CharT, class Traits>
-std::basic_ostream<CharT, Traits>&
-operator<<(std::basic_ostream<CharT, Traits>& os, const local_info& r)
-{
-    if (r.result == local_info::nonexistent)
-        os << "nonexistent between\n";
-    else if (r.result == local_info::ambiguous)
-        os << "ambiguous between\n";
-    os << r.first;
-    if (r.result != local_info::unique)
-    {
-        os << "and\n";
-        os << r.second;
-    }
-    return os;
-}
-
-class nonexistent_local_time
-    : public std::runtime_error
-{
-public:
-    template <class Duration>
-        nonexistent_local_time(local_time<Duration> tp, const local_info& i);
-
-private:
-    template <class Duration>
-    static
-    std::string
-    make_msg(local_time<Duration> tp, const local_info& i);
-};
-
-template <class Duration>
-inline
-nonexistent_local_time::nonexistent_local_time(local_time<Duration> tp,
-                                               const local_info& i)
-    : std::runtime_error(make_msg(tp, i))
-{
-}
-
-template <class Duration>
-std::string
-nonexistent_local_time::make_msg(local_time<Duration> tp, const local_info& i)
-{
-    assert(i.result == local_info::nonexistent);
-    std::ostringstream os;
-    os << tp << " is in a gap between\n"
-       << local_seconds{i.first.end.time_since_epoch()} + i.first.offset << ' '
-       << i.first.abbrev << " and\n"
-       << local_seconds{i.second.begin.time_since_epoch()} + i.second.offset << ' '
-       << i.second.abbrev
-       << " which are both equivalent to\n";
-    date::operator<<(os, i.first.end) << " UTC";
-    return os.str();
-}
-
-class ambiguous_local_time
-    : public std::runtime_error
-{
-public:
-    template <class Duration>
-        ambiguous_local_time(local_time<Duration> tp, const local_info& i);
-
-private:
-    template <class Duration>
-    static
-    std::string
-    make_msg(local_time<Duration> tp, const local_info& i);
-};
-
-template <class Duration>
-inline
-ambiguous_local_time::ambiguous_local_time(local_time<Duration> tp, const local_info& i)
-    : std::runtime_error(make_msg(tp, i))
-{
-}
-
-template <class Duration>
-std::string
-ambiguous_local_time::make_msg(local_time<Duration> tp, const local_info& i)
-{
-    assert(i.result == local_info::ambiguous);
-    std::ostringstream os;
-    os << tp << " is ambiguous.  It could be\n"
-       << tp << ' ' << i.first.abbrev << " == "
-       << tp - i.first.offset << " UTC or\n"
-       << tp << ' ' << i.second.abbrev  << " == "
-       << tp - i.second.offset  << " UTC";
-    return os.str();
-}
-
-class time_zone;
-
-#if HAS_STRING_VIEW
-DATE_API const time_zone* locate_zone(std::string_view tz_name);
-#else
-DATE_API const time_zone* locate_zone(const std::string& tz_name);
-#endif
-
-DATE_API const time_zone* current_zone();
-
-template <class T>
-struct zoned_traits
-{
-};
-
-template <>
-struct zoned_traits<const time_zone*>
-{
-    static
-    const time_zone*
-    default_zone()
-    {
-        return date::locate_zone("Etc/UTC");
-    }
-
-#if HAS_STRING_VIEW
-
-    static
-    const time_zone*
-    locate_zone(std::string_view name)
-    {
-        return date::locate_zone(name);
-    }
-
-#else  // !HAS_STRING_VIEW
-
-    static
-    const time_zone*
-    locate_zone(const std::string& name)
-    {
-        return date::locate_zone(name);
-    }
-
-    static
-    const time_zone*
-    locate_zone(const char* name)
-    {
-        return date::locate_zone(name);
-    }
-
-#endif  // !HAS_STRING_VIEW
-};
-
-template <class Duration, class TimeZonePtr>
-class zoned_time;
-
-template <class Duration1, class Duration2, class TimeZonePtr>
-bool
-operator==(const zoned_time<Duration1, TimeZonePtr>& x,
-           const zoned_time<Duration2, TimeZonePtr>& y);
-
-template <class Duration, class TimeZonePtr = const time_zone*>
-class zoned_time
-{
-public:
-    using duration = typename std::common_type<Duration, std::chrono::seconds>::type;
-
-private:
-    TimeZonePtr        zone_;
-    sys_time<duration> tp_;
-
-public:
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class T = TimeZonePtr,
-              class = decltype(zoned_traits<T>::default_zone())>
-#endif
-        zoned_time();
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class T = TimeZonePtr,
-              class = decltype(zoned_traits<T>::default_zone())>
-#endif
-        zoned_time(const sys_time<Duration>& st);
-    explicit zoned_time(TimeZonePtr z);
-
-#if HAS_STRING_VIEW
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_constructible
-                  <
-                      zoned_time,
-                      decltype(zoned_traits<T>::locate_zone(std::string_view()))
-                  >::value
-              >::type>
-        explicit zoned_time(std::string_view name);
-#else
-#  if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_constructible
-                  <
-                      zoned_time,
-                      decltype(zoned_traits<T>::locate_zone(std::string()))
-                  >::value
-              >::type>
-#  endif
-        explicit zoned_time(const std::string& name);
-#endif
-
-    template <class Duration2,
-              class = typename std::enable_if
-                      <
-                          std::is_convertible<sys_time<Duration2>,
-                                              sys_time<Duration>>::value
-                      >::type>
-        zoned_time(const zoned_time<Duration2, TimeZonePtr>& zt) NOEXCEPT;
-
-    zoned_time(TimeZonePtr z, const sys_time<Duration>& st);
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_convertible
-                  <
-                      decltype(std::declval<T&>()->to_sys(local_time<Duration>{})),
-                      sys_time<duration>
-                  >::value
-              >::type>
-#endif
-        zoned_time(TimeZonePtr z, const local_time<Duration>& tp);
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_convertible
-                  <
-                      decltype(std::declval<T&>()->to_sys(local_time<Duration>{},
-                                                          choose::earliest)),
-                      sys_time<duration>
-                  >::value
-              >::type>
-#endif
-        zoned_time(TimeZonePtr z, const local_time<Duration>& tp, choose c);
-
-    template <class Duration2, class TimeZonePtr2,
-              class = typename std::enable_if
-                      <
-                          std::is_convertible<sys_time<Duration2>,
-                                              sys_time<Duration>>::value
-                      >::type>
-        zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& zt);
-
-    template <class Duration2, class TimeZonePtr2,
-              class = typename std::enable_if
-                      <
-                          std::is_convertible<sys_time<Duration2>,
-                                              sys_time<Duration>>::value
-                      >::type>
-        zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& zt, choose);
-
-#if HAS_STRING_VIEW
-
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_constructible
-                  <
-                      zoned_time,
-                      decltype(zoned_traits<T>::locate_zone(std::string_view())),
-                      sys_time<Duration>
-                  >::value
-              >::type>
-        zoned_time(std::string_view name, detail::nodeduct_t<const sys_time<Duration>&> st);
-
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_constructible
-                  <
-                      zoned_time,
-                      decltype(zoned_traits<T>::locate_zone(std::string_view())),
-                      local_time<Duration>
-                  >::value
-              >::type>
-        zoned_time(std::string_view name, detail::nodeduct_t<const local_time<Duration>&> tp);
-
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_constructible
-                  <
-                      zoned_time,
-                      decltype(zoned_traits<T>::locate_zone(std::string_view())),
-                      local_time<Duration>,
-                      choose
-                  >::value
-              >::type>
-        zoned_time(std::string_view name, detail::nodeduct_t<const local_time<Duration>&> tp, choose c);
-
-    template <class Duration2, class TimeZonePtr2, class T = TimeZonePtr,
-              class = typename std::enable_if
-                      <
-                          std::is_convertible<sys_time<Duration2>,
-                                              sys_time<Duration>>::value &&
-                          std::is_constructible
-                          <
-                              zoned_time,
-                              decltype(zoned_traits<T>::locate_zone(std::string_view())),
-                              zoned_time
-                          >::value
-                      >::type>
-        zoned_time(std::string_view name, const zoned_time<Duration2, TimeZonePtr2>& zt);
-
-    template <class Duration2, class TimeZonePtr2, class T = TimeZonePtr,
-              class = typename std::enable_if
-                      <
-                          std::is_convertible<sys_time<Duration2>,
-                                              sys_time<Duration>>::value &&
-                          std::is_constructible
-                          <
-                              zoned_time,
-                              decltype(zoned_traits<T>::locate_zone(std::string_view())),
-                              zoned_time,
-                              choose
-                          >::value
-                      >::type>
-        zoned_time(std::string_view name, const zoned_time<Duration2, TimeZonePtr2>& zt, choose);
-
-#else  // !HAS_STRING_VIEW
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_constructible
-                  <
-                      zoned_time,
-                      decltype(zoned_traits<T>::locate_zone(std::string())),
-                      sys_time<Duration>
-                  >::value
-              >::type>
-#endif
-        zoned_time(const std::string& name, const sys_time<Duration>& st);
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_constructible
-                  <
-                      zoned_time,
-                      decltype(zoned_traits<T>::locate_zone(std::string())),
-                      sys_time<Duration>
-                  >::value
-              >::type>
-#endif
-        zoned_time(const char* name, const sys_time<Duration>& st);
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_constructible
-                  <
-                      zoned_time,
-                      decltype(zoned_traits<T>::locate_zone(std::string())),
-                      local_time<Duration>
-                  >::value
-              >::type>
-#endif
-        zoned_time(const std::string& name, const local_time<Duration>& tp);
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_constructible
-                  <
-                      zoned_time,
-                      decltype(zoned_traits<T>::locate_zone(std::string())),
-                      local_time<Duration>
-                  >::value
-              >::type>
-#endif
-        zoned_time(const char* name, const local_time<Duration>& tp);
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_constructible
-                  <
-                      zoned_time,
-                      decltype(zoned_traits<T>::locate_zone(std::string())),
-                      local_time<Duration>,
-                      choose
-                  >::value
-              >::type>
-#endif
-        zoned_time(const std::string& name, const local_time<Duration>& tp, choose c);
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class T = TimeZonePtr,
-              class = typename std::enable_if
-              <
-                  std::is_constructible
-                  <
-                      zoned_time,
-                      decltype(zoned_traits<T>::locate_zone(std::string())),
-                      local_time<Duration>,
-                      choose
-                  >::value
-              >::type>
-#endif
-        zoned_time(const char* name, const local_time<Duration>& tp, choose c);
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class Duration2, class TimeZonePtr2, class T = TimeZonePtr,
-              class = typename std::enable_if
-                      <
-                          std::is_convertible<sys_time<Duration2>,
-                                              sys_time<Duration>>::value &&
-                          std::is_constructible
-                          <
-                              zoned_time,
-                              decltype(zoned_traits<T>::locate_zone(std::string())),
-                              zoned_time
-                          >::value
-                      >::type>
-#else
-    template <class Duration2, class TimeZonePtr2>
-#endif
-        zoned_time(const std::string& name, const zoned_time<Duration2, TimeZonePtr2>& zt);
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class Duration2, class TimeZonePtr2, class T = TimeZonePtr,
-              class = typename std::enable_if
-                      <
-                          std::is_convertible<sys_time<Duration2>,
-                                              sys_time<Duration>>::value &&
-                          std::is_constructible
-                          <
-                              zoned_time,
-                              decltype(zoned_traits<T>::locate_zone(std::string())),
-                              zoned_time
-                          >::value
-                      >::type>
-#else
-    template <class Duration2, class TimeZonePtr2>
-#endif
-        zoned_time(const char* name, const zoned_time<Duration2, TimeZonePtr2>& zt);
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class Duration2, class TimeZonePtr2, class T = TimeZonePtr,
-              class = typename std::enable_if
-                      <
-                          std::is_convertible<sys_time<Duration2>,
-                                              sys_time<Duration>>::value &&
-                          std::is_constructible
-                          <
-                              zoned_time,
-                              decltype(zoned_traits<T>::locate_zone(std::string())),
-                              zoned_time,
-                              choose
-                          >::value
-                      >::type>
-#else
-    template <class Duration2, class TimeZonePtr2>
-#endif
-        zoned_time(const std::string& name, const zoned_time<Duration2, TimeZonePtr2>& zt,
-                   choose);
-
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-    template <class Duration2, class TimeZonePtr2, class T = TimeZonePtr,
-              class = typename std::enable_if
-                      <
-                          std::is_convertible<sys_time<Duration2>,
-                                              sys_time<Duration>>::value &&
-                          std::is_constructible
-                          <
-                              zoned_time,
-                              decltype(zoned_traits<T>::locate_zone(std::string())),
-                              zoned_time,
-                              choose
-                          >::value
-                      >::type>
-#else
-    template <class Duration2, class TimeZonePtr2>
-#endif
-        zoned_time(const char* name, const zoned_time<Duration2, TimeZonePtr2>& zt,
-                   choose);
-
-#endif  // !HAS_STRING_VIEW
-
-    zoned_time& operator=(const sys_time<Duration>& st);
-    zoned_time& operator=(const local_time<Duration>& ut);
-
-    explicit operator sys_time<duration>() const;
-    explicit operator local_time<duration>() const;
-
-    TimeZonePtr          get_time_zone() const;
-    local_time<duration> get_local_time() const;
-    sys_time<duration>   get_sys_time() const;
-    sys_info             get_info() const;
-
-    template <class Duration1, class Duration2, class TimeZonePtr1>
-    friend
-    bool
-    operator==(const zoned_time<Duration1, TimeZonePtr1>& x,
-               const zoned_time<Duration2, TimeZonePtr1>& y);
-
-    template <class CharT, class Traits, class Duration1, class TimeZonePtr1>
-    friend
-    std::basic_ostream<CharT, Traits>&
-    operator<<(std::basic_ostream<CharT, Traits>& os,
-               const zoned_time<Duration1, TimeZonePtr1>& t);
-
-private:
-    template <class D, class T> friend class zoned_time;
-
-    template <class TimeZonePtr2>
-    static
-    TimeZonePtr2&&
-    check(TimeZonePtr2&& p);
-};
-
-using zoned_seconds = zoned_time<std::chrono::seconds>;
-
-#if HAS_DEDUCTION_GUIDES
-
-namespace detail
-{
-   template<typename TimeZonePtrOrName>
-   using time_zone_representation =
-       std::conditional_t
-       <
-           std::is_convertible<TimeZonePtrOrName, std::string_view>::value,
-           time_zone const*,
-           std::remove_cv_t<std::remove_reference_t<TimeZonePtrOrName>>
-       >;
-}
-
-zoned_time()
-    -> zoned_time<std::chrono::seconds>;
-
-template <class Duration>
-zoned_time(sys_time<Duration>)
-    -> zoned_time<std::common_type_t<Duration, std::chrono::seconds>>;
-
-template <class TimeZonePtrOrName>
-zoned_time(TimeZonePtrOrName&&)
-    -> zoned_time<std::chrono::seconds, detail::time_zone_representation<TimeZonePtrOrName>>;
-
-template <class TimeZonePtrOrName, class Duration>
-zoned_time(TimeZonePtrOrName&&, sys_time<Duration>)
-    -> zoned_time<std::common_type_t<Duration, std::chrono::seconds>, detail::time_zone_representation<TimeZonePtrOrName>>;
-
-template <class TimeZonePtrOrName, class Duration>
-zoned_time(TimeZonePtrOrName&&, local_time<Duration>, choose = choose::earliest)
-    -> zoned_time<std::common_type_t<Duration, std::chrono::seconds>, detail::time_zone_representation<TimeZonePtrOrName>>;
-
-template <class Duration, class TimeZonePtrOrName, class TimeZonePtr2>
-zoned_time(TimeZonePtrOrName&&, zoned_time<Duration, TimeZonePtr2>, choose = choose::earliest)
-    -> zoned_time<std::common_type_t<Duration, std::chrono::seconds>, detail::time_zone_representation<TimeZonePtrOrName>>;
-
-#endif  // HAS_DEDUCTION_GUIDES
-
-template <class Duration1, class Duration2, class TimeZonePtr>
-inline
-bool
-operator==(const zoned_time<Duration1, TimeZonePtr>& x,
-           const zoned_time<Duration2, TimeZonePtr>& y)
-{
-    return x.zone_ == y.zone_ && x.tp_ == y.tp_;
-}
-
-template <class Duration1, class Duration2, class TimeZonePtr>
-inline
-bool
-operator!=(const zoned_time<Duration1, TimeZonePtr>& x,
-           const zoned_time<Duration2, TimeZonePtr>& y)
-{
-    return !(x == y);
-}
-
-#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
-
-namespace detail
-{
-#  if USE_OS_TZDB
-    struct transition;
-    struct expanded_ttinfo;
-#  else  // !USE_OS_TZDB
-    struct zonelet;
-    class Rule;
-#  endif  // !USE_OS_TZDB
-}
-
-#endif  // !defined(_MSC_VER) || (_MSC_VER >= 1900)
-
-class time_zone
-{
-private:
-    std::string                          name_;
-#if USE_OS_TZDB
-    std::vector<detail::transition>      transitions_;
-    std::vector<detail::expanded_ttinfo> ttinfos_;
-#else  // !USE_OS_TZDB
-    std::vector<detail::zonelet>         zonelets_;
-#endif  // !USE_OS_TZDB
-    std::unique_ptr<std::once_flag>      adjusted_;
-
-public:
-#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
-    time_zone(time_zone&&) = default;
-    time_zone& operator=(time_zone&&) = default;
-#else   // defined(_MSC_VER) && (_MSC_VER < 1900)
-    time_zone(time_zone&& src);
-    time_zone& operator=(time_zone&& src);
-#endif  // defined(_MSC_VER) && (_MSC_VER < 1900)
-
-    DATE_API explicit time_zone(const std::string& s, detail::undocumented);
-
-    const std::string& name() const NOEXCEPT;
-
-    template <class Duration> sys_info   get_info(sys_time<Duration> st) const;
-    template <class Duration> local_info get_info(local_time<Duration> tp) const;
-
-    template <class Duration>
-        sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-        to_sys(local_time<Duration> tp) const;
-
-    template <class Duration>
-        sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-        to_sys(local_time<Duration> tp, choose z) const;
-
-    template <class Duration>
-        local_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-        to_local(sys_time<Duration> tp) const;
-
-    friend bool operator==(const time_zone& x, const time_zone& y) NOEXCEPT;
-    friend bool operator< (const time_zone& x, const time_zone& y) NOEXCEPT;
-    friend DATE_API std::ostream& operator<<(std::ostream& os, const time_zone& z);
-
-#if !USE_OS_TZDB
-    DATE_API void add(const std::string& s);
-#else
-# if defined(BUILD_TZ_LIB)
-#  if defined(ANDROID) || defined(__ANDROID__)
-    friend std::unique_ptr<tzdb> init_tzdb();
-#  endif // defined(ANDROID) || defined(__ANDROID__)
-# endif // defined(BUILD_TZ_LIB)
-#endif  // !USE_OS_TZDB
-
-private:
-    DATE_API sys_info   get_info_impl(sys_seconds tp) const;
-    DATE_API local_info get_info_impl(local_seconds tp) const;
-
-    template <class Duration>
-        sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-        to_sys_impl(local_time<Duration> tp, choose z, std::false_type) const;
-    template <class Duration>
-        sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-        to_sys_impl(local_time<Duration> tp, choose, std::true_type) const;
-
-#if USE_OS_TZDB
-    DATE_API void init() const;
-    DATE_API void init_impl();
-    DATE_API sys_info
-        load_sys_info(std::vector<detail::transition>::const_iterator i) const;
-
-    template <class TimeType>
-    DATE_API void
-    load_data(std::istream& inf, std::int32_t tzh_leapcnt, std::int32_t tzh_timecnt,
-                                 std::int32_t tzh_typecnt, std::int32_t tzh_charcnt);
-# if defined(ANDROID) || defined(__ANDROID__)
-    void parse_from_android_tzdata(std::ifstream& inf, const std::size_t off);
-# endif // defined(ANDROID) || defined(__ANDROID__)
-#else  // !USE_OS_TZDB
-    DATE_API sys_info   get_info_impl(sys_seconds tp, int tz_int) const;
-    DATE_API void adjust_infos(const std::vector<detail::Rule>& rules);
-    DATE_API void parse_info(std::istream& in);
-#endif  // !USE_OS_TZDB
-};
-
-#if defined(_MSC_VER) && (_MSC_VER < 1900)
-
-inline
-time_zone::time_zone(time_zone&& src)
-    : name_(std::move(src.name_))
-    , zonelets_(std::move(src.zonelets_))
-    , adjusted_(std::move(src.adjusted_))
-    {}
-
-inline
-time_zone&
-time_zone::operator=(time_zone&& src)
-{
-    name_ = std::move(src.name_);
-    zonelets_ = std::move(src.zonelets_);
-    adjusted_ = std::move(src.adjusted_);
-    return *this;
-}
-
-#endif  // defined(_MSC_VER) && (_MSC_VER < 1900)
-
-inline
-const std::string&
-time_zone::name() const NOEXCEPT
-{
-    return name_;
-}
-
-template <class Duration>
-inline
-sys_info
-time_zone::get_info(sys_time<Duration> st) const
-{
-    return get_info_impl(date::floor<std::chrono::seconds>(st));
-}
-
-template <class Duration>
-inline
-local_info
-time_zone::get_info(local_time<Duration> tp) const
-{
-    return get_info_impl(date::floor<std::chrono::seconds>(tp));
-}
-
-template <class Duration>
-inline
-sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-time_zone::to_sys(local_time<Duration> tp) const
-{
-    return to_sys_impl(tp, choose{}, std::true_type{});
-}
-
-template <class Duration>
-inline
-sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-time_zone::to_sys(local_time<Duration> tp, choose z) const
-{
-    return to_sys_impl(tp, z, std::false_type{});
-}
-
-template <class Duration>
-inline
-local_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-time_zone::to_local(sys_time<Duration> tp) const
-{
-    using LT = local_time<typename std::common_type<Duration, std::chrono::seconds>::type>;
-    auto i = get_info(tp);
-    return LT{(tp + i.offset).time_since_epoch()};
-}
-
-inline bool operator==(const time_zone& x, const time_zone& y) NOEXCEPT {return x.name_ == y.name_;}
-inline bool operator< (const time_zone& x, const time_zone& y) NOEXCEPT {return x.name_ < y.name_;}
-
-inline bool operator!=(const time_zone& x, const time_zone& y) NOEXCEPT {return !(x == y);}
-inline bool operator> (const time_zone& x, const time_zone& y) NOEXCEPT {return   y < x;}
-inline bool operator<=(const time_zone& x, const time_zone& y) NOEXCEPT {return !(y < x);}
-inline bool operator>=(const time_zone& x, const time_zone& y) NOEXCEPT {return !(x < y);}
-
-template <class Duration>
-sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-time_zone::to_sys_impl(local_time<Duration> tp, choose z, std::false_type) const
-{
-    auto i = get_info(tp);
-    if (i.result == local_info::nonexistent)
-    {
-        return i.first.end;
-    }
-    else if (i.result == local_info::ambiguous)
-    {
-        if (z == choose::latest)
-            return sys_time<Duration>{tp.time_since_epoch()} - i.second.offset;
-    }
-    return sys_time<Duration>{tp.time_since_epoch()} - i.first.offset;
-}
-
-template <class Duration>
-sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-time_zone::to_sys_impl(local_time<Duration> tp, choose, std::true_type) const
-{
-    auto i = get_info(tp);
-    if (i.result == local_info::nonexistent)
-        throw nonexistent_local_time(tp, i);
-    else if (i.result == local_info::ambiguous)
-        throw ambiguous_local_time(tp, i);
-    return sys_time<Duration>{tp.time_since_epoch()} - i.first.offset;
-}
-
-#if !USE_OS_TZDB
-
-class time_zone_link
-{
-private:
-    std::string name_;
-    std::string target_;
-public:
-    DATE_API explicit time_zone_link(const std::string& s);
-
-    const std::string& name() const {return name_;}
-    const std::string& target() const {return target_;}
-
-    friend bool operator==(const time_zone_link& x, const time_zone_link& y) {return x.name_ == y.name_;}
-    friend bool operator< (const time_zone_link& x, const time_zone_link& y) {return x.name_ < y.name_;}
-
-    friend DATE_API std::ostream& operator<<(std::ostream& os, const time_zone_link& x);
-};
-
-using link = time_zone_link;
-
-inline bool operator!=(const time_zone_link& x, const time_zone_link& y) {return !(x == y);}
-inline bool operator> (const time_zone_link& x, const time_zone_link& y) {return   y < x;}
-inline bool operator<=(const time_zone_link& x, const time_zone_link& y) {return !(y < x);}
-inline bool operator>=(const time_zone_link& x, const time_zone_link& y) {return !(x < y);}
-
-#endif  // !USE_OS_TZDB
-
-class leap_second
-{
-private:
-    sys_seconds date_;
-
-public:
-#if USE_OS_TZDB
-    DATE_API explicit leap_second(const sys_seconds& s, detail::undocumented);
-#else
-    DATE_API explicit leap_second(const std::string& s, detail::undocumented);
-#endif
-
-    sys_seconds date() const {return date_;}
-
-    friend bool operator==(const leap_second& x, const leap_second& y) {return x.date_ == y.date_;}
-    friend bool operator< (const leap_second& x, const leap_second& y) {return x.date_ < y.date_;}
-
-    template <class Duration>
-    friend
-    bool
-    operator==(const leap_second& x, const sys_time<Duration>& y)
-    {
-        return x.date_ == y;
-    }
-
-    template <class Duration>
-    friend
-    bool
-    operator< (const leap_second& x, const sys_time<Duration>& y)
-    {
-        return x.date_ < y;
-    }
-
-    template <class Duration>
-    friend
-    bool
-    operator< (const sys_time<Duration>& x, const leap_second& y)
-    {
-        return x < y.date_;
-    }
-
-    friend DATE_API std::ostream& operator<<(std::ostream& os, const leap_second& x);
-};
-
-inline bool operator!=(const leap_second& x, const leap_second& y) {return !(x == y);}
-inline bool operator> (const leap_second& x, const leap_second& y) {return   y < x;}
-inline bool operator<=(const leap_second& x, const leap_second& y) {return !(y < x);}
-inline bool operator>=(const leap_second& x, const leap_second& y) {return !(x < y);}
-
-template <class Duration>
-inline
-bool
-operator==(const sys_time<Duration>& x, const leap_second& y)
-{
-    return y == x;
-}
-
-template <class Duration>
-inline
-bool
-operator!=(const leap_second& x, const sys_time<Duration>& y)
-{
-    return !(x == y);
-}
-
-template <class Duration>
-inline
-bool
-operator!=(const sys_time<Duration>& x, const leap_second& y)
-{
-    return !(x == y);
-}
-
-template <class Duration>
-inline
-bool
-operator> (const leap_second& x, const sys_time<Duration>& y)
-{
-    return y < x;
-}
-
-template <class Duration>
-inline
-bool
-operator> (const sys_time<Duration>& x, const leap_second& y)
-{
-    return y < x;
-}
-
-template <class Duration>
-inline
-bool
-operator<=(const leap_second& x, const sys_time<Duration>& y)
-{
-    return !(y < x);
-}
-
-template <class Duration>
-inline
-bool
-operator<=(const sys_time<Duration>& x, const leap_second& y)
-{
-    return !(y < x);
-}
-
-template <class Duration>
-inline
-bool
-operator>=(const leap_second& x, const sys_time<Duration>& y)
-{
-    return !(x < y);
-}
-
-template <class Duration>
-inline
-bool
-operator>=(const sys_time<Duration>& x, const leap_second& y)
-{
-    return !(x < y);
-}
-
-using leap = leap_second;
-
-#ifdef _WIN32
-
-namespace detail
-{
-
-// The time zone mapping is modelled after this data file:
-// http://unicode.org/repos/cldr/trunk/common/supplemental/windowsZones.xml
-// and the field names match the element names from the mapZone element
-// of windowsZones.xml.
-// The website displays this file here:
-// http://www.unicode.org/cldr/charts/latest/supplemental/zone_tzid.html
-// The html view is sorted before being displayed but is otherwise the same
-// There is a mapping between the os centric view (in this case windows)
-// the html displays uses and the generic view the xml file.
-// That mapping is this:
-// display column "windows" -> xml field "other".
-// display column "region"  -> xml field "territory".
-// display column "tzid"    -> xml field "type".
-// This structure uses the generic terminology because it could be
-// used to to support other os/native name conversions, not just windows,
-// and using the same generic names helps retain the connection to the
-// origin of the data that we are using.
-struct timezone_mapping
-{
-    timezone_mapping(const char* other, const char* territory, const char* type)
-        : other(other), territory(territory), type(type)
-    {
-    }
-    timezone_mapping() = default;
-    std::string other;
-    std::string territory;
-    std::string type;
-};
-
-}  // detail
-
-#endif  // _WIN32
-
-struct tzdb
-{
-    std::string                 version = "unknown";
-    std::vector<time_zone>      zones;
-#if !USE_OS_TZDB
-    std::vector<time_zone_link> links;
-#endif
-    std::vector<leap_second>    leap_seconds;
-#if !USE_OS_TZDB
-    std::vector<detail::Rule>   rules;
-#endif
-#ifdef _WIN32
-    std::vector<detail::timezone_mapping> mappings;
-#endif
-    tzdb* next = nullptr;
-
-    tzdb() = default;
-#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
-    tzdb(tzdb&&) = default;
-    tzdb& operator=(tzdb&&) = default;
-#else  // defined(_MSC_VER) && (_MSC_VER < 1900)
-    tzdb(tzdb&& src)
-        : version(std::move(src.version))
-        , zones(std::move(src.zones))
-        , links(std::move(src.links))
-        , leap_seconds(std::move(src.leap_seconds))
-        , rules(std::move(src.rules))
-        , mappings(std::move(src.mappings))
-    {}
-
-    tzdb& operator=(tzdb&& src)
-    {
-        version = std::move(src.version);
-        zones = std::move(src.zones);
-        links = std::move(src.links);
-        leap_seconds = std::move(src.leap_seconds);
-        rules = std::move(src.rules);
-        mappings = std::move(src.mappings);
-        return *this;
-    }
-#endif  // defined(_MSC_VER) && (_MSC_VER < 1900)
-
-#if HAS_STRING_VIEW
-    DATE_API const time_zone* locate_zone(std::string_view tz_name) const;
-#else
-    DATE_API const time_zone* locate_zone(const std::string& tz_name) const;
-#endif
-    DATE_API const time_zone* current_zone() const;
-};
-
-using TZ_DB = tzdb;
-
-DATE_API std::ostream&
-operator<<(std::ostream& os, const tzdb& db);
-
-DATE_API const tzdb& get_tzdb();
-
-class tzdb_list
-{
-    std::atomic<tzdb*> head_{nullptr};
-
-public:
-    DATE_API ~tzdb_list();
-    tzdb_list() = default;
-    DATE_API tzdb_list(tzdb_list&& x) NOEXCEPT;
-
-    const tzdb& front() const NOEXCEPT {return *head_;}
-          tzdb& front()       NOEXCEPT {return *head_;}
-
-    class const_iterator;
-
-    const_iterator begin() const NOEXCEPT;
-    const_iterator end() const NOEXCEPT;
-
-    const_iterator cbegin() const NOEXCEPT;
-    const_iterator cend() const NOEXCEPT;
-
-    DATE_API const_iterator erase_after(const_iterator p) NOEXCEPT;
-
-    struct undocumented_helper;
-private:
-    void push_front(tzdb* tzdb) NOEXCEPT;
-};
-
-class tzdb_list::const_iterator
-{
-    tzdb* p_ = nullptr;
-
-    explicit const_iterator(tzdb* p) NOEXCEPT : p_{p} {}
-public:
-    const_iterator() = default;
-
-    using iterator_category = std::forward_iterator_tag;
-    using value_type        = tzdb;
-    using reference         = const value_type&;
-    using pointer           = const value_type*;
-    using difference_type   = std::ptrdiff_t;
-
-    reference operator*() const NOEXCEPT {return *p_;}
-    pointer  operator->() const NOEXCEPT {return p_;}
-
-    const_iterator& operator++() NOEXCEPT {p_ = p_->next; return *this;}
-    const_iterator  operator++(int) NOEXCEPT {auto t = *this; ++(*this); return t;}
-
-    friend
-    bool
-    operator==(const const_iterator& x, const const_iterator& y) NOEXCEPT
-        {return x.p_ == y.p_;}
-
-    friend
-    bool
-    operator!=(const const_iterator& x, const const_iterator& y) NOEXCEPT
-        {return !(x == y);}
-
-    friend class tzdb_list;
-};
-
-inline
-tzdb_list::const_iterator
-tzdb_list::begin() const NOEXCEPT
-{
-    return const_iterator{head_};
-}
-
-inline
-tzdb_list::const_iterator
-tzdb_list::end() const NOEXCEPT
-{
-    return const_iterator{nullptr};
-}
-
-inline
-tzdb_list::const_iterator
-tzdb_list::cbegin() const NOEXCEPT
-{
-    return begin();
-}
-
-inline
-tzdb_list::const_iterator
-tzdb_list::cend() const NOEXCEPT
-{
-    return end();
-}
-
-DATE_API tzdb_list& get_tzdb_list();
-
-#if !USE_OS_TZDB
-
-DATE_API const tzdb& reload_tzdb();
-DATE_API void        set_install(const std::string& install);
-
-#endif  // !USE_OS_TZDB
-
-#if HAS_REMOTE_API
-
-DATE_API std::string remote_version();
-// if provided error_buffer size should be at least CURL_ERROR_SIZE
-DATE_API bool        remote_download(const std::string& version, char* error_buffer = nullptr);
-DATE_API bool        remote_install(const std::string& version);
-
-#endif
-
-// zoned_time
-
-namespace detail
-{
-
-template <class T>
-inline
-T*
-to_raw_pointer(T* p) NOEXCEPT
-{
-    return p;
-}
-
-template <class Pointer>
-inline
-auto
-to_raw_pointer(Pointer p) NOEXCEPT
-    -> decltype(detail::to_raw_pointer(p.operator->()))
-{
-    return detail::to_raw_pointer(p.operator->());
-}
-
-}  // namespace detail
-
-template <class Duration, class TimeZonePtr>
-template <class TimeZonePtr2>
-inline
-TimeZonePtr2&&
-zoned_time<Duration, TimeZonePtr>::check(TimeZonePtr2&& p)
-{
-    if (detail::to_raw_pointer(p) == nullptr)
-        throw std::runtime_error(
-            "zoned_time constructed with a time zone pointer == nullptr");
-    return std::forward<TimeZonePtr2>(p);
-}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class T, class>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time()
-    : zone_(check(zoned_traits<TimeZonePtr>::default_zone()))
-    {}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class T, class>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const sys_time<Duration>& st)
-    : zone_(check(zoned_traits<TimeZonePtr>::default_zone()))
-    , tp_(st)
-    {}
-
-template <class Duration, class TimeZonePtr>
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(TimeZonePtr z)
-    : zone_(check(std::move(z)))
-    {}
-
-#if HAS_STRING_VIEW
-
-template <class Duration, class TimeZonePtr>
-template <class T, class>
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(std::string_view name)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name))
-    {}
-
-#else  // !HAS_STRING_VIEW
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class T, class>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const std::string& name)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name))
-    {}
-
-#endif  // !HAS_STRING_VIEW
-
-template <class Duration, class TimeZonePtr>
-template <class Duration2, class>
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const zoned_time<Duration2, TimeZonePtr>& zt) NOEXCEPT
-    : zone_(zt.zone_)
-    , tp_(zt.tp_)
-    {}
-
-template <class Duration, class TimeZonePtr>
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(TimeZonePtr z, const sys_time<Duration>& st)
-    : zone_(check(std::move(z)))
-    , tp_(st)
-    {}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class T, class>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(TimeZonePtr z, const local_time<Duration>& t)
-    : zone_(check(std::move(z)))
-    , tp_(zone_->to_sys(t))
-    {}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class T, class>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(TimeZonePtr z, const local_time<Duration>& t,
-                                              choose c)
-    : zone_(check(std::move(z)))
-    , tp_(zone_->to_sys(t, c))
-    {}
-
-template <class Duration, class TimeZonePtr>
-template <class Duration2, class TimeZonePtr2, class>
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(TimeZonePtr z,
-                                              const zoned_time<Duration2, TimeZonePtr2>& zt)
-    : zone_(check(std::move(z)))
-    , tp_(zt.tp_)
-    {}
-
-template <class Duration, class TimeZonePtr>
-template <class Duration2, class TimeZonePtr2, class>
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(TimeZonePtr z,
-                                      const zoned_time<Duration2, TimeZonePtr2>& zt, choose)
-    : zoned_time(std::move(z), zt)
-    {}
-
-#if HAS_STRING_VIEW
-
-template <class Duration, class TimeZonePtr>
-template <class T, class>
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(std::string_view name,
-                                              detail::nodeduct_t<const sys_time<Duration>&> st)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), st)
-    {}
-
-template <class Duration, class TimeZonePtr>
-template <class T, class>
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(std::string_view name,
-                                              detail::nodeduct_t<const local_time<Duration>&> t)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), t)
-    {}
-
-template <class Duration, class TimeZonePtr>
-template <class T, class>
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(std::string_view name,
-                                              detail::nodeduct_t<const local_time<Duration>&> t, choose c)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), t, c)
-    {}
-
-template <class Duration, class TimeZonePtr>
-template <class Duration2, class TimeZonePtr2, class, class>
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(std::string_view name,
-                                              const zoned_time<Duration2, TimeZonePtr2>& zt)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), zt)
-    {}
-
-template <class Duration, class TimeZonePtr>
-template <class Duration2, class TimeZonePtr2, class, class>
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(std::string_view name,
-                                              const zoned_time<Duration2, TimeZonePtr2>& zt,
-                                              choose c)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), zt, c)
-    {}
-
-#else  // !HAS_STRING_VIEW
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class T, class>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const std::string& name,
-                                              const sys_time<Duration>& st)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), st)
-    {}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class T, class>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const char* name,
-                                              const sys_time<Duration>& st)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), st)
-    {}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class T, class>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const std::string& name,
-                                              const local_time<Duration>& t)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), t)
-    {}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class T, class>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const char* name,
-                                              const local_time<Duration>& t)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), t)
-    {}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class T, class>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const std::string& name,
-                                              const local_time<Duration>& t, choose c)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), t, c)
-    {}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class T, class>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const char* name,
-                                              const local_time<Duration>& t, choose c)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), t, c)
-    {}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class Duration2, class TimeZonePtr2, class, class>
-#else
-template <class Duration2, class TimeZonePtr2>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const std::string& name,
-                                              const zoned_time<Duration2, TimeZonePtr2>& zt)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), zt)
-    {}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class Duration2, class TimeZonePtr2, class, class>
-#else
-template <class Duration2, class TimeZonePtr2>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const char* name,
-                                              const zoned_time<Duration2, TimeZonePtr2>& zt)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), zt)
-    {}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class Duration2, class TimeZonePtr2, class, class>
-#else
-template <class Duration2, class TimeZonePtr2>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const std::string& name,
-                                              const zoned_time<Duration2, TimeZonePtr2>& zt,
-                                              choose c)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), zt, c)
-    {}
-
-template <class Duration, class TimeZonePtr>
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-template <class Duration2, class TimeZonePtr2, class, class>
-#else
-template <class Duration2, class TimeZonePtr2>
-#endif
-inline
-zoned_time<Duration, TimeZonePtr>::zoned_time(const char* name,
-                                              const zoned_time<Duration2, TimeZonePtr2>& zt,
-                                              choose c)
-    : zoned_time(zoned_traits<TimeZonePtr>::locate_zone(name), zt, c)
-    {}
-
-#endif  // HAS_STRING_VIEW
-
-template <class Duration, class TimeZonePtr>
-inline
-zoned_time<Duration, TimeZonePtr>&
-zoned_time<Duration, TimeZonePtr>::operator=(const sys_time<Duration>& st)
-{
-    tp_ = st;
-    return *this;
-}
-
-template <class Duration, class TimeZonePtr>
-inline
-zoned_time<Duration, TimeZonePtr>&
-zoned_time<Duration, TimeZonePtr>::operator=(const local_time<Duration>& ut)
-{
-    tp_ = zone_->to_sys(ut);
-    return *this;
-}
-
-template <class Duration, class TimeZonePtr>
-inline
-zoned_time<Duration, TimeZonePtr>::operator local_time<typename zoned_time<Duration, TimeZonePtr>::duration>() const
-{
-    return get_local_time();
-}
-
-template <class Duration, class TimeZonePtr>
-inline
-zoned_time<Duration, TimeZonePtr>::operator sys_time<typename zoned_time<Duration, TimeZonePtr>::duration>() const
-{
-    return get_sys_time();
-}
-
-template <class Duration, class TimeZonePtr>
-inline
-TimeZonePtr
-zoned_time<Duration, TimeZonePtr>::get_time_zone() const
-{
-    return zone_;
-}
-
-template <class Duration, class TimeZonePtr>
-inline
-local_time<typename zoned_time<Duration, TimeZonePtr>::duration>
-zoned_time<Duration, TimeZonePtr>::get_local_time() const
-{
-    return zone_->to_local(tp_);
-}
-
-template <class Duration, class TimeZonePtr>
-inline
-sys_time<typename zoned_time<Duration, TimeZonePtr>::duration>
-zoned_time<Duration, TimeZonePtr>::get_sys_time() const
-{
-    return tp_;
-}
-
-template <class Duration, class TimeZonePtr>
-inline
-sys_info
-zoned_time<Duration, TimeZonePtr>::get_info() const
-{
-    return zone_->get_info(tp_);
-}
-
-// make_zoned_time
-
-inline
-zoned_time<std::chrono::seconds>
-make_zoned()
-{
-    return zoned_time<std::chrono::seconds>();
-}
-
-template <class Duration>
-inline
-zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-make_zoned(const sys_time<Duration>& tp)
-{
-    return zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type>(tp);
-}
-
-template <class TimeZonePtr
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-#if !defined(__INTEL_COMPILER) || (__INTEL_COMPILER > 1600)
-          , class = typename std::enable_if
-          <
-            std::is_class
-            <
-                typename std::decay
-                <
-                    decltype(*detail::to_raw_pointer(std::declval<TimeZonePtr&>()))
-                >::type
-            >{}
-          >::type
-#endif
-#endif
-         >
-inline
-zoned_time<std::chrono::seconds, TimeZonePtr>
-make_zoned(TimeZonePtr z)
-{
-    return zoned_time<std::chrono::seconds, TimeZonePtr>(std::move(z));
-}
-
-inline
-zoned_seconds
-make_zoned(const std::string& name)
-{
-    return zoned_seconds(name);
-}
-
-template <class Duration, class TimeZonePtr
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-#if !defined(__INTEL_COMPILER) || (__INTEL_COMPILER > 1600)
-          , class = typename std::enable_if
-          <
-            std::is_class<typename std::decay<decltype(*std::declval<TimeZonePtr&>())>::type>{}
-          >::type
-#endif
-#endif
-         >
-inline
-zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type, TimeZonePtr>
-make_zoned(TimeZonePtr zone, const local_time<Duration>& tp)
-{
-    return zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type,
-                      TimeZonePtr>(std::move(zone), tp);
-}
-
-template <class Duration, class TimeZonePtr
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-#if !defined(__INTEL_COMPILER) || (__INTEL_COMPILER > 1600)
-          , class = typename std::enable_if
-          <
-            std::is_class<typename std::decay<decltype(*std::declval<TimeZonePtr&>())>::type>{}
-          >::type
-#endif
-#endif
-         >
-inline
-zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type, TimeZonePtr>
-make_zoned(TimeZonePtr zone, const local_time<Duration>& tp, choose c)
-{
-    return zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type,
-                      TimeZonePtr>(std::move(zone), tp, c);
-}
-
-template <class Duration>
-inline
-zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-make_zoned(const std::string& name, const local_time<Duration>& tp)
-{
-    return zoned_time<typename std::common_type<Duration,
-                      std::chrono::seconds>::type>(name, tp);
-}
-
-template <class Duration>
-inline
-zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-make_zoned(const std::string& name, const local_time<Duration>& tp, choose c)
-{
-    return zoned_time<typename std::common_type<Duration,
-                      std::chrono::seconds>::type>(name, tp, c);
-}
-
-template <class Duration, class TimeZonePtr>
-inline
-zoned_time<Duration, TimeZonePtr>
-make_zoned(TimeZonePtr zone, const zoned_time<Duration, TimeZonePtr>& zt)
-{
-    return zoned_time<Duration, TimeZonePtr>(std::move(zone), zt);
-}
-
-template <class Duration, class TimeZonePtr>
-inline
-zoned_time<Duration, TimeZonePtr>
-make_zoned(const std::string& name, const zoned_time<Duration, TimeZonePtr>& zt)
-{
-    return zoned_time<Duration, TimeZonePtr>(name, zt);
-}
-
-template <class Duration, class TimeZonePtr>
-inline
-zoned_time<Duration, TimeZonePtr>
-make_zoned(TimeZonePtr zone, const zoned_time<Duration, TimeZonePtr>& zt, choose c)
-{
-    return zoned_time<Duration, TimeZonePtr>(std::move(zone), zt, c);
-}
-
-template <class Duration, class TimeZonePtr>
-inline
-zoned_time<Duration, TimeZonePtr>
-make_zoned(const std::string& name, const zoned_time<Duration, TimeZonePtr>& zt, choose c)
-{
-    return zoned_time<Duration, TimeZonePtr>(name, zt, c);
-}
-
-template <class Duration, class TimeZonePtr
-#if !defined(_MSC_VER) || (_MSC_VER > 1916)
-#if !defined(__INTEL_COMPILER) || (__INTEL_COMPILER > 1600)
-          , class = typename std::enable_if
-          <
-            std::is_class<typename std::decay<decltype(*std::declval<TimeZonePtr&>())>::type>{}
-          >::type
-#endif
-#endif
-         >
-inline
-zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type, TimeZonePtr>
-make_zoned(TimeZonePtr zone, const sys_time<Duration>& st)
-{
-    return zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type,
-                      TimeZonePtr>(std::move(zone), st);
-}
-
-template <class Duration>
-inline
-zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-make_zoned(const std::string& name, const sys_time<Duration>& st)
-{
-    return zoned_time<typename std::common_type<Duration,
-                      std::chrono::seconds>::type>(name, st);
-}
-
-template <class CharT, class Traits, class Duration, class TimeZonePtr>
-std::basic_ostream<CharT, Traits>&
-to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
-          const zoned_time<Duration, TimeZonePtr>& tp)
-{
-    using duration = typename zoned_time<Duration, TimeZonePtr>::duration;
-    using LT = local_time<duration>;
-    auto const st = tp.get_sys_time();
-    auto const info = tp.get_time_zone()->get_info(st);
-    return to_stream(os, fmt, LT{(st+info.offset).time_since_epoch()},
-                     &info.abbrev, &info.offset);
-}
-
-template <class CharT, class Traits, class Duration, class TimeZonePtr>
-inline
-std::basic_ostream<CharT, Traits>&
-operator<<(std::basic_ostream<CharT, Traits>& os, const zoned_time<Duration, TimeZonePtr>& t)
-{
-    const CharT fmt[] = {'%', 'F', ' ', '%', 'T', ' ', '%', 'Z', CharT{}};
-    return to_stream(os, fmt, t);
-}
-
-class utc_clock
-{
-public:
-    using duration                  = std::chrono::system_clock::duration;
-    using rep                       = duration::rep;
-    using period                    = duration::period;
-    using time_point                = std::chrono::time_point<utc_clock>;
-    static CONSTDATA bool is_steady = false;
-
-    static time_point now();
-
-    template<typename Duration>
-    static
-    std::chrono::time_point<std::chrono::system_clock, typename std::common_type<Duration, std::chrono::seconds>::type>
-    to_sys(const std::chrono::time_point<utc_clock, Duration>&);
-
-    template<typename Duration>
-    static
-    std::chrono::time_point<utc_clock, typename std::common_type<Duration, std::chrono::seconds>::type>
-    from_sys(const std::chrono::time_point<std::chrono::system_clock, Duration>&);
-
-    template<typename Duration>
-    static
-    std::chrono::time_point<local_t, typename std::common_type<Duration, std::chrono::seconds>::type>
-    to_local(const std::chrono::time_point<utc_clock, Duration>&);
-
-    template<typename Duration>
-    static
-    std::chrono::time_point<utc_clock, typename std::common_type<Duration, std::chrono::seconds>::type>
-    from_local(const std::chrono::time_point<local_t, Duration>&);
-};
-
-template <class Duration>
-    using utc_time = std::chrono::time_point<utc_clock, Duration>;
-
-using utc_seconds = utc_time<std::chrono::seconds>;
-
-template <class Duration>
-utc_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-utc_clock::from_sys(const sys_time<Duration>& st)
-{
-    using std::chrono::seconds;
-    using CD = typename std::common_type<Duration, seconds>::type;
-    auto const& leaps = get_tzdb().leap_seconds;
-    auto const lt = std::upper_bound(leaps.begin(), leaps.end(), st);
-    return utc_time<CD>{st.time_since_epoch() + seconds{lt-leaps.begin()}};
-}
-
-// Return pair<is_leap_second, seconds{number_of_leap_seconds_since_1970}>
-// first is true if ut is during a leap second insertion, otherwise false.
-// If ut is during a leap second insertion, that leap second is included in the count
-template <class Duration>
-std::pair<bool, std::chrono::seconds>
-is_leap_second(date::utc_time<Duration> const& ut)
-{
-    using std::chrono::seconds;
-    using duration = typename std::common_type<Duration, seconds>::type;
-    auto const& leaps = get_tzdb().leap_seconds;
-    auto tp = sys_time<duration>{ut.time_since_epoch()};
-    auto const lt = std::upper_bound(leaps.begin(), leaps.end(), tp);
-    auto ds = seconds{lt-leaps.begin()};
-    tp -= ds;
-    auto ls = false;
-    if (lt > leaps.begin())
-    {
-        if (tp < lt[-1])
-        {
-            if (tp >= lt[-1].date() - seconds{1})
-                ls = true;
-            else
-                --ds;
-        }
-    }
-    return {ls, ds};
-}
-
-struct leap_second_info
-{
-    bool is_leap_second;
-    std::chrono::seconds elapsed;
-};
-
-template <class Duration>
-leap_second_info
-get_leap_second_info(date::utc_time<Duration> const& ut)
-{
-    auto p = is_leap_second(ut);
-    return {p.first, p.second};
-}
-
-template <class Duration>
-sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-utc_clock::to_sys(const utc_time<Duration>& ut)
-{
-    using std::chrono::seconds;
-    using CD = typename std::common_type<Duration, seconds>::type;
-    auto ls = is_leap_second(ut);
-    auto tp = sys_time<CD>{ut.time_since_epoch() - ls.second};
-    if (ls.first)
-        tp = floor<seconds>(tp) + seconds{1} - CD{1};
-    return tp;
-}
-
-inline
-utc_clock::time_point
-utc_clock::now()
-{
-    return from_sys(std::chrono::system_clock::now());
-}
-
-template <class Duration>
-utc_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-utc_clock::from_local(const local_time<Duration>& st)
-{
-    return from_sys(sys_time<Duration>{st.time_since_epoch()});
-}
-
-template <class Duration>
-local_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-utc_clock::to_local(const utc_time<Duration>& ut)
-{
-    using CD = typename std::common_type<Duration, std::chrono::seconds>::type;
-    return local_time<CD>{to_sys(ut).time_since_epoch()};
-}
-
-template <class CharT, class Traits, class Duration>
-std::basic_ostream<CharT, Traits>&
-to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
-          const utc_time<Duration>& t)
-{
-    using std::chrono::seconds;
-    using CT = typename std::common_type<Duration, seconds>::type;
-    const std::string abbrev("UTC");
-    CONSTDATA seconds offset{0};
-    auto ls = is_leap_second(t);
-    auto tp = sys_time<CT>{t.time_since_epoch() - ls.second};
-    auto const sd = floor<days>(tp);
-    year_month_day ymd = sd;
-    auto time = make_time(tp - sys_seconds{sd});
-    time.seconds(detail::undocumented{}) += seconds{ls.first};
-    fields<CT> fds{ymd, time};
-    return to_stream(os, fmt, fds, &abbrev, &offset);
-}
-
-template <class CharT, class Traits, class Duration>
-std::basic_ostream<CharT, Traits>&
-operator<<(std::basic_ostream<CharT, Traits>& os, const utc_time<Duration>& t)
-{
-    const CharT fmt[] = {'%', 'F', ' ', '%', 'T', CharT{}};
-    return to_stream(os, fmt, t);
-}
-
-template <class Duration, class CharT, class Traits, class Alloc = std::allocator<CharT>>
-std::basic_istream<CharT, Traits>&
-from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
-            utc_time<Duration>& tp, std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
-            std::chrono::minutes* offset = nullptr)
-{
-    using std::chrono::seconds;
-    using std::chrono::minutes;
-    using CT = typename std::common_type<Duration, seconds>::type;
-    minutes offset_local{};
-    auto offptr = offset ? offset : &offset_local;
-    fields<CT> fds{};
-    fds.has_tod = true;
-    from_stream(is, fmt, fds, abbrev, offptr);
-    if (!fds.ymd.ok())
-        is.setstate(std::ios::failbit);
-    if (!is.fail())
-    {
-        bool is_60_sec = fds.tod.seconds() == seconds{60};
-        if (is_60_sec)
-            fds.tod.seconds(detail::undocumented{}) -= seconds{1};
-        auto tmp = utc_clock::from_sys(sys_days(fds.ymd) - *offptr + fds.tod.to_duration());
-        if (is_60_sec)
-            tmp += seconds{1};
-        if (is_60_sec != is_leap_second(tmp).first || !fds.tod.in_conventional_range())
-        {
-            is.setstate(std::ios::failbit);
-            return is;
-        }
-        tp = std::chrono::time_point_cast<Duration>(tmp);
-    }
-    return is;
-}
-
-// tai_clock
-
-class tai_clock
-{
-public:
-    using duration                  = std::chrono::system_clock::duration;
-    using rep                       = duration::rep;
-    using period                    = duration::period;
-    using time_point                = std::chrono::time_point<tai_clock>;
-    static const bool is_steady     = false;
-
-    static time_point now();
-
-    template<typename Duration>
-    static
-    std::chrono::time_point<utc_clock, typename std::common_type<Duration, std::chrono::seconds>::type>
-    to_utc(const std::chrono::time_point<tai_clock, Duration>&) NOEXCEPT;
-
-    template<typename Duration>
-    static
-    std::chrono::time_point<tai_clock, typename std::common_type<Duration, std::chrono::seconds>::type>
-    from_utc(const std::chrono::time_point<utc_clock, Duration>&) NOEXCEPT;
-
-    template<typename Duration>
-    static
-    std::chrono::time_point<local_t, typename std::common_type<Duration, date::days>::type>
-    to_local(const std::chrono::time_point<tai_clock, Duration>&) NOEXCEPT;
-
-    template<typename Duration>
-    static
-    std::chrono::time_point<tai_clock, typename std::common_type<Duration, date::days>::type>
-    from_local(const std::chrono::time_point<local_t, Duration>&) NOEXCEPT;
-};
-
-template <class Duration>
-    using tai_time = std::chrono::time_point<tai_clock, Duration>;
-
-using tai_seconds = tai_time<std::chrono::seconds>;
-
-template <class Duration>
-inline
-utc_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-tai_clock::to_utc(const tai_time<Duration>& t) NOEXCEPT
-{
-    using std::chrono::seconds;
-    using CD = typename std::common_type<Duration, seconds>::type;
-    return utc_time<CD>{t.time_since_epoch()} -
-            (sys_days(year{1970}/January/1) - sys_days(year{1958}/January/1) + seconds{10});
-}
-
-template <class Duration>
-inline
-tai_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-tai_clock::from_utc(const utc_time<Duration>& t) NOEXCEPT
-{
-    using std::chrono::seconds;
-    using CD = typename std::common_type<Duration, seconds>::type;
-    return tai_time<CD>{t.time_since_epoch()} +
-            (sys_days(year{1970}/January/1) - sys_days(year{1958}/January/1) + seconds{10});
-}
-
-inline
-tai_clock::time_point
-tai_clock::now()
-{
-    return from_utc(utc_clock::now());
-}
-
-template <class Duration>
-inline
-local_time<typename std::common_type<Duration, date::days>::type>
-tai_clock::to_local(const tai_time<Duration>& t) NOEXCEPT
-{
-    using CD = typename std::common_type<Duration, date::days>::type;
-    return local_time<CD>{t.time_since_epoch()} -
-           (local_days(year{1970}/January/1) - local_days(year{1958}/January/1));
-}
-
-template <class Duration>
-inline
-tai_time<typename std::common_type<Duration, date::days>::type>
-tai_clock::from_local(const local_time<Duration>& t) NOEXCEPT
-{
-    using CD = typename std::common_type<Duration, date::days>::type;
-    return tai_time<CD>{t.time_since_epoch()} +
-            (local_days(year{1970}/January/1) - local_days(year{1958}/January/1));
-}
-
-template <class CharT, class Traits, class Duration>
-std::basic_ostream<CharT, Traits>&
-to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
-          const tai_time<Duration>& t)
-{
-    const std::string abbrev("TAI");
-    CONSTDATA std::chrono::seconds offset{0};
-    return to_stream(os, fmt, tai_clock::to_local(t), &abbrev, &offset);
-}
-
-template <class CharT, class Traits, class Duration>
-std::basic_ostream<CharT, Traits>&
-operator<<(std::basic_ostream<CharT, Traits>& os, const tai_time<Duration>& t)
-{
-    const CharT fmt[] = {'%', 'F', ' ', '%', 'T', CharT{}};
-    return to_stream(os, fmt, t);
-}
-
-template <class Duration, class CharT, class Traits, class Alloc = std::allocator<CharT>>
-std::basic_istream<CharT, Traits>&
-from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
-            tai_time<Duration>& tp,
-            std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
-            std::chrono::minutes* offset = nullptr)
-{
-    local_time<Duration> lp;
-    from_stream(is, fmt, lp, abbrev, offset);
-    if (!is.fail())
-        tp = tai_clock::from_local(lp);
-    return is;
-}
-
-// gps_clock
-
-class gps_clock
-{
-public:
-    using duration                  = std::chrono::system_clock::duration;
-    using rep                       = duration::rep;
-    using period                    = duration::period;
-    using time_point                = std::chrono::time_point<gps_clock>;
-    static const bool is_steady     = false;
-
-    static time_point now();
-
-    template<typename Duration>
-    static
-    std::chrono::time_point<utc_clock, typename std::common_type<Duration, std::chrono::seconds>::type>
-    to_utc(const std::chrono::time_point<gps_clock, Duration>&) NOEXCEPT;
-
-    template<typename Duration>
-    static
-    std::chrono::time_point<gps_clock, typename std::common_type<Duration, std::chrono::seconds>::type>
-    from_utc(const std::chrono::time_point<utc_clock, Duration>&) NOEXCEPT;
-
-    template<typename Duration>
-    static
-    std::chrono::time_point<local_t, typename std::common_type<Duration, date::days>::type>
-    to_local(const std::chrono::time_point<gps_clock, Duration>&) NOEXCEPT;
-
-    template<typename Duration>
-    static
-    std::chrono::time_point<gps_clock, typename std::common_type<Duration, date::days>::type>
-    from_local(const std::chrono::time_point<local_t, Duration>&) NOEXCEPT;
-};
-
-template <class Duration>
-    using gps_time = std::chrono::time_point<gps_clock, Duration>;
-
-using gps_seconds = gps_time<std::chrono::seconds>;
-
-template <class Duration>
-inline
-utc_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-gps_clock::to_utc(const gps_time<Duration>& t) NOEXCEPT
-{
-    using std::chrono::seconds;
-    using CD = typename std::common_type<Duration, seconds>::type;
-    return utc_time<CD>{t.time_since_epoch()} +
-            (sys_days(year{1980}/January/Sunday[1]) - sys_days(year{1970}/January/1) +
-             seconds{9});
-}
-
-template <class Duration>
-inline
-gps_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-gps_clock::from_utc(const utc_time<Duration>& t) NOEXCEPT
-{
-    using std::chrono::seconds;
-    using CD = typename std::common_type<Duration, seconds>::type;
-    return gps_time<CD>{t.time_since_epoch()} -
-            (sys_days(year{1980}/January/Sunday[1]) - sys_days(year{1970}/January/1) +
-             seconds{9});
-}
-
-inline
-gps_clock::time_point
-gps_clock::now()
-{
-    return from_utc(utc_clock::now());
-}
-
-template <class Duration>
-inline
-local_time<typename std::common_type<Duration, date::days>::type>
-gps_clock::to_local(const gps_time<Duration>& t) NOEXCEPT
-{
-    using CD = typename std::common_type<Duration, date::days>::type;
-    return local_time<CD>{t.time_since_epoch()} +
-            (local_days(year{1980}/January/Sunday[1]) - local_days(year{1970}/January/1));
-}
-
-template <class Duration>
-inline
-gps_time<typename std::common_type<Duration, date::days>::type>
-gps_clock::from_local(const local_time<Duration>& t) NOEXCEPT
-{
-    using CD = typename std::common_type<Duration, date::days>::type;
-    return gps_time<CD>{t.time_since_epoch()} -
-            (local_days(year{1980}/January/Sunday[1]) - local_days(year{1970}/January/1));
-}
-
-
-template <class CharT, class Traits, class Duration>
-std::basic_ostream<CharT, Traits>&
-to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
-          const gps_time<Duration>& t)
-{
-    const std::string abbrev("GPS");
-    CONSTDATA std::chrono::seconds offset{0};
-    return to_stream(os, fmt, gps_clock::to_local(t), &abbrev, &offset);
-}
-
-template <class CharT, class Traits, class Duration>
-std::basic_ostream<CharT, Traits>&
-operator<<(std::basic_ostream<CharT, Traits>& os, const gps_time<Duration>& t)
-{
-    const CharT fmt[] = {'%', 'F', ' ', '%', 'T', CharT{}};
-    return to_stream(os, fmt, t);
-}
-
-template <class Duration, class CharT, class Traits, class Alloc = std::allocator<CharT>>
-std::basic_istream<CharT, Traits>&
-from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
-            gps_time<Duration>& tp,
-            std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
-            std::chrono::minutes* offset = nullptr)
-{
-    local_time<Duration> lp;
-    from_stream(is, fmt, lp, abbrev, offset);
-    if (!is.fail())
-        tp = gps_clock::from_local(lp);
-    return is;
-}
-
-// clock_time_conversion
-
-template <class DstClock, class SrcClock>
-struct clock_time_conversion
-{};
-
-template <>
-struct clock_time_conversion<std::chrono::system_clock, std::chrono::system_clock>
-{
-    template <class Duration>
-    CONSTCD14
-    sys_time<Duration>
-    operator()(const sys_time<Duration>& st) const
-    {
-        return st;
-    }
-};
-
-template <>
-struct clock_time_conversion<utc_clock, utc_clock>
-{
-    template <class Duration>
-    CONSTCD14
-    utc_time<Duration>
-    operator()(const utc_time<Duration>& ut) const
-    {
-        return ut;
-    }
-};
-
-template<>
-struct clock_time_conversion<local_t, local_t>
-{
-    template <class Duration>
-    CONSTCD14
-    local_time<Duration>
-    operator()(const local_time<Duration>& lt) const
-    {
-        return lt;
-    }
-};
-
-template <>
-struct clock_time_conversion<utc_clock, std::chrono::system_clock>
-{
-    template <class Duration>
-    utc_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-    operator()(const sys_time<Duration>& st) const
-    {
-        return utc_clock::from_sys(st);
-    }
-};
-
-template <>
-struct clock_time_conversion<std::chrono::system_clock, utc_clock>
-{
-    template <class Duration>
-    sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-    operator()(const utc_time<Duration>& ut) const
-    {
-        return utc_clock::to_sys(ut);
-    }
-};
-
-template<>
-struct clock_time_conversion<local_t, std::chrono::system_clock>
-{
-    template <class Duration>
-    CONSTCD14
-    local_time<Duration>
-    operator()(const sys_time<Duration>& st) const
-    {
-       return local_time<Duration>{st.time_since_epoch()};
-    }
-};
-
-template<>
-struct clock_time_conversion<std::chrono::system_clock, local_t>
-{
-    template <class Duration>
-    CONSTCD14
-    sys_time<Duration>
-    operator()(const local_time<Duration>& lt) const
-    {
-        return sys_time<Duration>{lt.time_since_epoch()};
-    }
-};
-
-template<>
-struct clock_time_conversion<utc_clock, local_t>
-{
-    template <class Duration>
-    utc_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-    operator()(const local_time<Duration>& lt) const
-    {
-       return utc_clock::from_local(lt);
-    }
-};
-
-template<>
-struct clock_time_conversion<local_t, utc_clock>
-{
-    template <class Duration>
-    local_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-    operator()(const utc_time<Duration>& ut) const
-    {
-       return utc_clock::to_local(ut);
-    }
-};
-
-template<typename Clock>
-struct clock_time_conversion<Clock, Clock>
-{
-    template <class Duration>
-    CONSTCD14
-    std::chrono::time_point<Clock, Duration>
-    operator()(const std::chrono::time_point<Clock, Duration>& tp) const
-    {
-        return tp;
-    }
-};
-
-namespace ctc_detail
-{
-
-template <class Clock, class Duration>
-    using time_point = std::chrono::time_point<Clock, Duration>;
-
-using std::declval;
-using std::chrono::system_clock;
-
-//Check if TimePoint is time for given clock,
-//if not emits hard error
-template <class Clock, class TimePoint>
-struct return_clock_time
-{
-    using clock_time_point = time_point<Clock, typename TimePoint::duration>;
-    using type             = TimePoint;
-
-    static_assert(std::is_same<TimePoint, clock_time_point>::value,
-                  "time point with appropariate clock shall be returned");
-};
-
-// Check if Clock has to_sys method accepting TimePoint with given duration const& and
-// returning sys_time. If so has nested type member equal to return type to_sys.
-template <class Clock, class Duration, class = void>
-struct return_to_sys
-{};
-
-template <class Clock, class Duration>
-struct return_to_sys
-       <
-           Clock, Duration,
-           decltype(Clock::to_sys(declval<time_point<Clock, Duration> const&>()), void())
-       >
-    : return_clock_time
-      <
-          system_clock,
-          decltype(Clock::to_sys(declval<time_point<Clock, Duration> const&>()))
-      >
-{};
-
-// Similiar to above
-template <class Clock, class Duration, class = void>
-struct return_from_sys
-{};
-
-template <class Clock, class Duration>
-struct return_from_sys
-       <
-           Clock, Duration,
-           decltype(Clock::from_sys(declval<time_point<system_clock, Duration> const&>()),
-                    void())
-       >
-    : return_clock_time
-      <
-          Clock,
-          decltype(Clock::from_sys(declval<time_point<system_clock, Duration> const&>()))
-      >
-{};
-
-// Similiar to above
-template <class Clock, class Duration, class = void>
-struct return_to_utc
-{};
-
-template <class Clock, class Duration>
-struct return_to_utc
-       <
-           Clock, Duration,
-           decltype(Clock::to_utc(declval<time_point<Clock, Duration> const&>()), void())
-       >
-    : return_clock_time
-      <
-          utc_clock,
-          decltype(Clock::to_utc(declval<time_point<Clock, Duration> const&>()))>
-{};
-
-// Similiar to above
-template <class Clock, class Duration, class = void>
-struct return_from_utc
-{};
-
-template <class Clock, class Duration>
-struct return_from_utc
-       <
-           Clock, Duration,
-           decltype(Clock::from_utc(declval<time_point<utc_clock, Duration> const&>()),
-                    void())
-       >
-    : return_clock_time
-      <
-          Clock,
-          decltype(Clock::from_utc(declval<time_point<utc_clock, Duration> const&>()))
-      >
-{};
-
-// Similiar to above
-template<typename Clock, typename Duration, typename = void>
-struct return_to_local
-{};
-
-template<typename Clock, typename Duration>
-struct return_to_local
-       <
-          Clock, Duration,
-          decltype(Clock::to_local(declval<time_point<Clock, Duration> const&>()),
-                   void())
-       >
-     : return_clock_time
-       <
-           local_t,
-           decltype(Clock::to_local(declval<time_point<Clock, Duration> const&>()))
-       >
-{};
-
-// Similiar to above
-template<typename Clock, typename Duration, typename = void>
-struct return_from_local
-{};
-
-template<typename Clock, typename Duration>
-struct return_from_local
-       <
-           Clock, Duration,
-           decltype(Clock::from_local(declval<time_point<local_t, Duration> const&>()),
-                    void())
-       >
-     : return_clock_time
-       <
-           Clock,
-           decltype(Clock::from_local(declval<time_point<local_t, Duration> const&>()))
-       >
-{};
-
-}  // namespace ctc_detail
-
-template <class SrcClock>
-struct clock_time_conversion<std::chrono::system_clock, SrcClock>
-{
-    template <class Duration>
-    CONSTCD14
-    typename ctc_detail::return_to_sys<SrcClock, Duration>::type
-    operator()(const std::chrono::time_point<SrcClock, Duration>& tp) const
-    {
-        return SrcClock::to_sys(tp);
-    }
-};
-
-template <class DstClock>
-struct clock_time_conversion<DstClock, std::chrono::system_clock>
-{
-    template <class Duration>
-    CONSTCD14
-    typename ctc_detail::return_from_sys<DstClock, Duration>::type
-    operator()(const sys_time<Duration>& st) const
-    {
-        return DstClock::from_sys(st);
-    }
-};
-
-template <class SrcClock>
-struct clock_time_conversion<utc_clock, SrcClock>
-{
-    template <class Duration>
-    CONSTCD14
-    typename ctc_detail::return_to_utc<SrcClock, Duration>::type
-    operator()(const std::chrono::time_point<SrcClock, Duration>& tp) const
-    {
-        return SrcClock::to_utc(tp);
-    }
-};
-
-template <class DstClock>
-struct clock_time_conversion<DstClock, utc_clock>
-{
-    template <class Duration>
-    CONSTCD14
-    typename ctc_detail::return_from_utc<DstClock, Duration>::type
-    operator()(const utc_time<Duration>& ut) const
-    {
-        return DstClock::from_utc(ut);
-    }
-};
-
-template<typename SrcClock>
-struct clock_time_conversion<local_t, SrcClock>
-{
-    template <class Duration>
-    CONSTCD14
-    typename ctc_detail::return_to_local<SrcClock, Duration>::type
-    operator()(const std::chrono::time_point<SrcClock, Duration>& tp) const
-    {
-        return SrcClock::to_local(tp);
-    }
-};
-
-template<typename DstClock>
-struct clock_time_conversion<DstClock, local_t>
-{
-    template <class Duration>
-    CONSTCD14
-    typename ctc_detail::return_from_local<DstClock, Duration>::type
-    operator()(const local_time<Duration>& lt) const
-    {
-        return DstClock::from_local(lt);
-    }
-};
-
-namespace clock_cast_detail
-{
-
-template <class Clock, class Duration>
-    using time_point = std::chrono::time_point<Clock, Duration>;
-using std::chrono::system_clock;
-
-template <class DstClock, class SrcClock, class Duration>
-CONSTCD14
-auto
-conv_clock(const time_point<SrcClock, Duration>& t)
-    -> decltype(std::declval<clock_time_conversion<DstClock, SrcClock>>()(t))
-{
-    return clock_time_conversion<DstClock, SrcClock>{}(t);
-}
-
-//direct trait conversion, 1st candidate
-template <class DstClock, class SrcClock, class Duration>
-CONSTCD14
-auto
-cc_impl(const time_point<SrcClock, Duration>& t, const time_point<SrcClock, Duration>*)
-    -> decltype(conv_clock<DstClock>(t))
-{
-    return conv_clock<DstClock>(t);
-}
-
-//conversion through sys, 2nd candidate
-template <class DstClock, class SrcClock, class Duration>
-CONSTCD14
-auto
-cc_impl(const time_point<SrcClock, Duration>& t, const void*)
-    -> decltype(conv_clock<DstClock>(conv_clock<system_clock>(t)))
-{
-    return conv_clock<DstClock>(conv_clock<system_clock>(t));
-}
-
-//conversion through utc, 2nd candidate
-template <class DstClock, class SrcClock, class Duration>
-CONSTCD14
-auto
-cc_impl(const time_point<SrcClock, Duration>& t, const void*)
-    -> decltype(0,  // MSVC_WORKAROUND
-                conv_clock<DstClock>(conv_clock<utc_clock>(t)))
-{
-    return conv_clock<DstClock>(conv_clock<utc_clock>(t));
-}
-
-//conversion through sys and utc, 3rd candidate
-template <class DstClock, class SrcClock, class Duration>
-CONSTCD14
-auto
-cc_impl(const time_point<SrcClock, Duration>& t, ...)
-    -> decltype(conv_clock<DstClock>(conv_clock<utc_clock>(conv_clock<system_clock>(t))))
-{
-    return conv_clock<DstClock>(conv_clock<utc_clock>(conv_clock<system_clock>(t)));
-}
-
-//conversion through utc and sys, 3rd candidate
-template <class DstClock, class SrcClock, class Duration>
-CONSTCD14
-auto
-cc_impl(const time_point<SrcClock, Duration>& t, ...)
-    -> decltype(0,  // MSVC_WORKAROUND
-                conv_clock<DstClock>(conv_clock<system_clock>(conv_clock<utc_clock>(t))))
-{
-    return conv_clock<DstClock>(conv_clock<system_clock>(conv_clock<utc_clock>(t)));
-}
-
-}  // namespace clock_cast_detail
-
-template <class DstClock, class SrcClock, class Duration>
-CONSTCD14
-auto
-clock_cast(const std::chrono::time_point<SrcClock, Duration>& tp)
-    -> decltype(clock_cast_detail::cc_impl<DstClock>(tp, &tp))
-{
-    return clock_cast_detail::cc_impl<DstClock>(tp, &tp);
-}
-
-// Deprecated API
-
-template <class Duration>
-inline
-sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-to_sys_time(const utc_time<Duration>& t)
-{
-    return utc_clock::to_sys(t);
-}
-
-template <class Duration>
-inline
-sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-to_sys_time(const tai_time<Duration>& t)
-{
-    return utc_clock::to_sys(tai_clock::to_utc(t));
-}
-
-template <class Duration>
-inline
-sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-to_sys_time(const gps_time<Duration>& t)
-{
-    return utc_clock::to_sys(gps_clock::to_utc(t));
-}
-
-
-template <class Duration>
-inline
-utc_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-to_utc_time(const sys_time<Duration>& t)
-{
-    return utc_clock::from_sys(t);
-}
-
-template <class Duration>
-inline
-utc_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-to_utc_time(const tai_time<Duration>& t)
-{
-    return tai_clock::to_utc(t);
-}
-
-template <class Duration>
-inline
-utc_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-to_utc_time(const gps_time<Duration>& t)
-{
-    return gps_clock::to_utc(t);
-}
-
-
-template <class Duration>
-inline
-tai_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-to_tai_time(const sys_time<Duration>& t)
-{
-    return tai_clock::from_utc(utc_clock::from_sys(t));
-}
-
-template <class Duration>
-inline
-tai_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-to_tai_time(const utc_time<Duration>& t)
-{
-    return tai_clock::from_utc(t);
-}
-
-template <class Duration>
-inline
-tai_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-to_tai_time(const gps_time<Duration>& t)
-{
-    return tai_clock::from_utc(gps_clock::to_utc(t));
-}
-
-
-template <class Duration>
-inline
-gps_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-to_gps_time(const sys_time<Duration>& t)
-{
-    return gps_clock::from_utc(utc_clock::from_sys(t));
-}
-
-template <class Duration>
-inline
-gps_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-to_gps_time(const utc_time<Duration>& t)
-{
-    return gps_clock::from_utc(t);
-}
-
-template <class Duration>
-inline
-gps_time<typename std::common_type<Duration, std::chrono::seconds>::type>
-to_gps_time(const tai_time<Duration>& t)
-{
-    return gps_clock::from_utc(tai_clock::to_utc(t));
-}
-
-}  // namespace arrow_vendored::date
-
-#endif  // TZ_H

shared/package-files/9b/9b99fa34cb2c454490337a62a9d91f5828c1a4f1ac22d94d94fffea34a2d612e/blob

@@ -1,563 +0,0 @@
-"""create and manipulate C data types in Python"""
-
-import os as _os, sys as _sys
-import types as _types
-
-__version__ = "1.1.0"
-
-from _ctypes import Union, Structure, Array
-from _ctypes import _Pointer
-from _ctypes import CFuncPtr as _CFuncPtr
-from _ctypes import __version__ as _ctypes_version
-from _ctypes import RTLD_LOCAL, RTLD_GLOBAL
-from _ctypes import ArgumentError
-
-from struct import calcsize as _calcsize
-
-if __version__ != _ctypes_version:
-    raise Exception("Version number mismatch", __version__, _ctypes_version)
-
-if _os.name == "nt":
-    from _ctypes import FormatError
-
-DEFAULT_MODE = RTLD_LOCAL
-if _os.name == "posix" and _sys.platform == "darwin":
-    # On OS X 10.3, we use RTLD_GLOBAL as default mode
-    # because RTLD_LOCAL does not work at least on some
-    # libraries.  OS X 10.3 is Darwin 7, so we check for
-    # that.
-
-    if int(_os.uname().release.split('.')[0]) < 8:
-        DEFAULT_MODE = RTLD_GLOBAL
-
-from _ctypes import FUNCFLAG_CDECL as _FUNCFLAG_CDECL, \
-     FUNCFLAG_PYTHONAPI as _FUNCFLAG_PYTHONAPI, \
-     FUNCFLAG_USE_ERRNO as _FUNCFLAG_USE_ERRNO, \
-     FUNCFLAG_USE_LASTERROR as _FUNCFLAG_USE_LASTERROR
-
-# WINOLEAPI -> HRESULT
-# WINOLEAPI_(type)
-#
-# STDMETHODCALLTYPE
-#
-# STDMETHOD(name)
-# STDMETHOD_(type, name)
-#
-# STDAPICALLTYPE
-
-def create_string_buffer(init, size=None):
-    """create_string_buffer(aBytes) -> character array
-    create_string_buffer(anInteger) -> character array
-    create_string_buffer(aBytes, anInteger) -> character array
-    """
-    if isinstance(init, bytes):
-        if size is None:
-            size = len(init)+1
-        _sys.audit("ctypes.create_string_buffer", init, size)
-        buftype = c_char * size
-        buf = buftype()
-        buf.value = init
-        return buf
-    elif isinstance(init, int):
-        _sys.audit("ctypes.create_string_buffer", None, init)
-        buftype = c_char * init
-        buf = buftype()
-        return buf
-    raise TypeError(init)
-
-def c_buffer(init, size=None):
-##    "deprecated, use create_string_buffer instead"
-##    import warnings
-##    warnings.warn("c_buffer is deprecated, use create_string_buffer instead",
-##                  DeprecationWarning, stacklevel=2)
-    return create_string_buffer(init, size)
-
-_c_functype_cache = {}
-def CFUNCTYPE(restype, *argtypes, **kw):
-    """CFUNCTYPE(restype, *argtypes,
-                 use_errno=False, use_last_error=False) -> function prototype.
-
-    restype: the result type
-    argtypes: a sequence specifying the argument types
-
-    The function prototype can be called in different ways to create a
-    callable object:
-
-    prototype(integer address) -> foreign function
-    prototype(callable) -> create and return a C callable function from callable
-    prototype(integer index, method name[, paramflags]) -> foreign function calling a COM method
-    prototype((ordinal number, dll object)[, paramflags]) -> foreign function exported by ordinal
-    prototype((function name, dll object)[, paramflags]) -> foreign function exported by name
-    """
-    flags = _FUNCFLAG_CDECL
-    if kw.pop("use_errno", False):
-        flags |= _FUNCFLAG_USE_ERRNO
-    if kw.pop("use_last_error", False):
-        flags |= _FUNCFLAG_USE_LASTERROR
-    if kw:
-        raise ValueError("unexpected keyword argument(s) %s" % kw.keys())
-    try:
-        return _c_functype_cache[(restype, argtypes, flags)]
-    except KeyError:
-        class CFunctionType(_CFuncPtr):
-            _argtypes_ = argtypes
-            _restype_ = restype
-            _flags_ = flags
-        _c_functype_cache[(restype, argtypes, flags)] = CFunctionType
-        return CFunctionType
-
-if _os.name == "nt":
-    from _ctypes import LoadLibrary as _dlopen
-    from _ctypes import FUNCFLAG_STDCALL as _FUNCFLAG_STDCALL
-
-    _win_functype_cache = {}
-    def WINFUNCTYPE(restype, *argtypes, **kw):
-        # docstring set later (very similar to CFUNCTYPE.__doc__)
-        flags = _FUNCFLAG_STDCALL
-        if kw.pop("use_errno", False):
-            flags |= _FUNCFLAG_USE_ERRNO
-        if kw.pop("use_last_error", False):
-            flags |= _FUNCFLAG_USE_LASTERROR
-        if kw:
-            raise ValueError("unexpected keyword argument(s) %s" % kw.keys())
-        try:
-            return _win_functype_cache[(restype, argtypes, flags)]
-        except KeyError:
-            class WinFunctionType(_CFuncPtr):
-                _argtypes_ = argtypes
-                _restype_ = restype
-                _flags_ = flags
-            _win_functype_cache[(restype, argtypes, flags)] = WinFunctionType
-            return WinFunctionType
-    if WINFUNCTYPE.__doc__:
-        WINFUNCTYPE.__doc__ = CFUNCTYPE.__doc__.replace("CFUNCTYPE", "WINFUNCTYPE")
-
-elif _os.name == "posix":
-    from _ctypes import dlopen as _dlopen
-
-from _ctypes import sizeof, byref, addressof, alignment, resize
-from _ctypes import get_errno, set_errno
-from _ctypes import _SimpleCData
-
-def _check_size(typ, typecode=None):
-    # Check if sizeof(ctypes_type) against struct.calcsize.  This
-    # should protect somewhat against a misconfigured libffi.
-    from struct import calcsize
-    if typecode is None:
-        # Most _type_ codes are the same as used in struct
-        typecode = typ._type_
-    actual, required = sizeof(typ), calcsize(typecode)
-    if actual != required:
-        raise SystemError("sizeof(%s) wrong: %d instead of %d" % \
-                          (typ, actual, required))
-
-class py_object(_SimpleCData):
-    _type_ = "O"
-    def __repr__(self):
-        try:
-            return super().__repr__()
-        except ValueError:
-            return "%s(<NULL>)" % type(self).__name__
-_check_size(py_object, "P")
-
-class c_short(_SimpleCData):
-    _type_ = "h"
-_check_size(c_short)
-
-class c_ushort(_SimpleCData):
-    _type_ = "H"
-_check_size(c_ushort)
-
-class c_long(_SimpleCData):
-    _type_ = "l"
-_check_size(c_long)
-
-class c_ulong(_SimpleCData):
-    _type_ = "L"
-_check_size(c_ulong)
-
-if _calcsize("i") == _calcsize("l"):
-    # if int and long have the same size, make c_int an alias for c_long
-    c_int = c_long
-    c_uint = c_ulong
-else:
-    class c_int(_SimpleCData):
-        _type_ = "i"
-    _check_size(c_int)
-
-    class c_uint(_SimpleCData):
-        _type_ = "I"
-    _check_size(c_uint)
-
-class c_float(_SimpleCData):
-    _type_ = "f"
-_check_size(c_float)
-
-class c_double(_SimpleCData):
-    _type_ = "d"
-_check_size(c_double)
-
-class c_longdouble(_SimpleCData):
-    _type_ = "g"
-if sizeof(c_longdouble) == sizeof(c_double):
-    c_longdouble = c_double
-
-if _calcsize("l") == _calcsize("q"):
-    # if long and long long have the same size, make c_longlong an alias for c_long
-    c_longlong = c_long
-    c_ulonglong = c_ulong
-else:
-    class c_longlong(_SimpleCData):
-        _type_ = "q"
-    _check_size(c_longlong)
-
-    class c_ulonglong(_SimpleCData):
-        _type_ = "Q"
-    ##    def from_param(cls, val):
-    ##        return ('d', float(val), val)
-    ##    from_param = classmethod(from_param)
-    _check_size(c_ulonglong)
-
-class c_ubyte(_SimpleCData):
-    _type_ = "B"
-c_ubyte.__ctype_le__ = c_ubyte.__ctype_be__ = c_ubyte
-# backward compatibility:
-##c_uchar = c_ubyte
-_check_size(c_ubyte)
-
-class c_byte(_SimpleCData):
-    _type_ = "b"
-c_byte.__ctype_le__ = c_byte.__ctype_be__ = c_byte
-_check_size(c_byte)
-
-class c_char(_SimpleCData):
-    _type_ = "c"
-c_char.__ctype_le__ = c_char.__ctype_be__ = c_char
-_check_size(c_char)
-
-class c_char_p(_SimpleCData):
-    _type_ = "z"
-    def __repr__(self):
-        return "%s(%s)" % (self.__class__.__name__, c_void_p.from_buffer(self).value)
-_check_size(c_char_p, "P")
-
-class c_void_p(_SimpleCData):
-    _type_ = "P"
-c_voidp = c_void_p # backwards compatibility (to a bug)
-_check_size(c_void_p)
-
-class c_bool(_SimpleCData):
-    _type_ = "?"
-
-from _ctypes import POINTER, pointer, _pointer_type_cache
-
-class c_wchar_p(_SimpleCData):
-    _type_ = "Z"
-    def __repr__(self):
-        return "%s(%s)" % (self.__class__.__name__, c_void_p.from_buffer(self).value)
-
-class c_wchar(_SimpleCData):
-    _type_ = "u"
-
-def _reset_cache():
-    _pointer_type_cache.clear()
-    _c_functype_cache.clear()
-    if _os.name == "nt":
-        _win_functype_cache.clear()
-    # _SimpleCData.c_wchar_p_from_param
-    POINTER(c_wchar).from_param = c_wchar_p.from_param
-    # _SimpleCData.c_char_p_from_param
-    POINTER(c_char).from_param = c_char_p.from_param
-    _pointer_type_cache[None] = c_void_p
-
-def create_unicode_buffer(init, size=None):
-    """create_unicode_buffer(aString) -> character array
-    create_unicode_buffer(anInteger) -> character array
-    create_unicode_buffer(aString, anInteger) -> character array
-    """
-    if isinstance(init, str):
-        if size is None:
-            if sizeof(c_wchar) == 2:
-                # UTF-16 requires a surrogate pair (2 wchar_t) for non-BMP
-                # characters (outside [U+0000; U+FFFF] range). +1 for trailing
-                # NUL character.
-                size = sum(2 if ord(c) > 0xFFFF else 1 for c in init) + 1
-            else:
-                # 32-bit wchar_t (1 wchar_t per Unicode character). +1 for
-                # trailing NUL character.
-                size = len(init) + 1
-        _sys.audit("ctypes.create_unicode_buffer", init, size)
-        buftype = c_wchar * size
-        buf = buftype()
-        buf.value = init
-        return buf
-    elif isinstance(init, int):
-        _sys.audit("ctypes.create_unicode_buffer", None, init)
-        buftype = c_wchar * init
-        buf = buftype()
-        return buf
-    raise TypeError(init)
-
-
-# XXX Deprecated
-def SetPointerType(pointer, cls):
-    if _pointer_type_cache.get(cls, None) is not None:
-        raise RuntimeError("This type already exists in the cache")
-    if id(pointer) not in _pointer_type_cache:
-        raise RuntimeError("What's this???")
-    pointer.set_type(cls)
-    _pointer_type_cache[cls] = pointer
-    del _pointer_type_cache[id(pointer)]
-
-# XXX Deprecated
-def ARRAY(typ, len):
-    return typ * len
-
-################################################################
-
-
-class CDLL(object):
-    """An instance of this class represents a loaded dll/shared
-    library, exporting functions using the standard C calling
-    convention (named 'cdecl' on Windows).
-
-    The exported functions can be accessed as attributes, or by
-    indexing with the function name.  Examples:
-
-    <obj>.qsort -> callable object
-    <obj>['qsort'] -> callable object
-
-    Calling the functions releases the Python GIL during the call and
-    reacquires it afterwards.
-    """
-    _func_flags_ = _FUNCFLAG_CDECL
-    _func_restype_ = c_int
-    # default values for repr
-    _name = '<uninitialized>'
-    _handle = 0
-    _FuncPtr = None
-
-    def __init__(self, name, mode=DEFAULT_MODE, handle=None,
-                 use_errno=False,
-                 use_last_error=False,
-                 winmode=None):
-        self._name = name
-        flags = self._func_flags_
-        if use_errno:
-            flags |= _FUNCFLAG_USE_ERRNO
-        if use_last_error:
-            flags |= _FUNCFLAG_USE_LASTERROR
-        if _sys.platform.startswith("aix"):
-            """When the name contains ".a(" and ends with ")",
-               e.g., "libFOO.a(libFOO.so)" - this is taken to be an
-               archive(member) syntax for dlopen(), and the mode is adjusted.
-               Otherwise, name is presented to dlopen() as a file argument.
-            """
-            if name and name.endswith(")") and ".a(" in name:
-                mode |= ( _os.RTLD_MEMBER | _os.RTLD_NOW )
-        if _os.name == "nt":
-            if winmode is not None:
-                mode = winmode
-            else:
-                import nt
-                mode = nt._LOAD_LIBRARY_SEARCH_DEFAULT_DIRS
-                if '/' in name or '\\' in name:
-                    self._name = nt._getfullpathname(self._name)
-                    mode |= nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR
-
-        class _FuncPtr(_CFuncPtr):
-            _flags_ = flags
-            _restype_ = self._func_restype_
-        self._FuncPtr = _FuncPtr
-
-        if handle is None:
-            self._handle = _dlopen(self._name, mode)
-        else:
-            self._handle = handle
-
-    def __repr__(self):
-        return "<%s '%s', handle %x at %#x>" % \
-               (self.__class__.__name__, self._name,
-                (self._handle & (_sys.maxsize*2 + 1)),
-                id(self) & (_sys.maxsize*2 + 1))
-
-    def __getattr__(self, name):
-        if name.startswith('__') and name.endswith('__'):
-            raise AttributeError(name)
-        func = self.__getitem__(name)
-        setattr(self, name, func)
-        return func
-
-    def __getitem__(self, name_or_ordinal):
-        func = self._FuncPtr((name_or_ordinal, self))
-        if not isinstance(name_or_ordinal, int):
-            func.__name__ = name_or_ordinal
-        return func
-
-class PyDLL(CDLL):
-    """This class represents the Python library itself.  It allows
-    accessing Python API functions.  The GIL is not released, and
-    Python exceptions are handled correctly.
-    """
-    _func_flags_ = _FUNCFLAG_CDECL | _FUNCFLAG_PYTHONAPI
-
-if _os.name == "nt":
-
-    class WinDLL(CDLL):
-        """This class represents a dll exporting functions using the
-        Windows stdcall calling convention.
-        """
-        _func_flags_ = _FUNCFLAG_STDCALL
-
-    # XXX Hm, what about HRESULT as normal parameter?
-    # Mustn't it derive from c_long then?
-    from _ctypes import _check_HRESULT, _SimpleCData
-    class HRESULT(_SimpleCData):
-        _type_ = "l"
-        # _check_retval_ is called with the function's result when it
-        # is used as restype.  It checks for the FAILED bit, and
-        # raises an OSError if it is set.
-        #
-        # The _check_retval_ method is implemented in C, so that the
-        # method definition itself is not included in the traceback
-        # when it raises an error - that is what we want (and Python
-        # doesn't have a way to raise an exception in the caller's
-        # frame).
-        _check_retval_ = _check_HRESULT
-
-    class OleDLL(CDLL):
-        """This class represents a dll exporting functions using the
-        Windows stdcall calling convention, and returning HRESULT.
-        HRESULT error values are automatically raised as OSError
-        exceptions.
-        """
-        _func_flags_ = _FUNCFLAG_STDCALL
-        _func_restype_ = HRESULT
-
-class LibraryLoader(object):
-    def __init__(self, dlltype):
-        self._dlltype = dlltype
-
-    def __getattr__(self, name):
-        if name[0] == '_':
-            raise AttributeError(name)
-        dll = self._dlltype(name)
-        setattr(self, name, dll)
-        return dll
-
-    def __getitem__(self, name):
-        return getattr(self, name)
-
-    def LoadLibrary(self, name):
-        return self._dlltype(name)
-
-    __class_getitem__ = classmethod(_types.GenericAlias)
-
-cdll = LibraryLoader(CDLL)
-pydll = LibraryLoader(PyDLL)
-
-if _os.name == "nt":
-    pythonapi = PyDLL("python dll", None, _sys.dllhandle)
-elif _sys.platform == "cygwin":
-    pythonapi = PyDLL("libpython%d.%d.dll" % _sys.version_info[:2])
-else:
-    pythonapi = PyDLL(None)
-
-
-if _os.name == "nt":
-    windll = LibraryLoader(WinDLL)
-    oledll = LibraryLoader(OleDLL)
-
-    GetLastError = windll.kernel32.GetLastError
-    from _ctypes import get_last_error, set_last_error
-
-    def WinError(code=None, descr=None):
-        if code is None:
-            code = GetLastError()
-        if descr is None:
-            descr = FormatError(code).strip()
-        return OSError(None, descr, None, code)
-
-if sizeof(c_uint) == sizeof(c_void_p):
-    c_size_t = c_uint
-    c_ssize_t = c_int
-elif sizeof(c_ulong) == sizeof(c_void_p):
-    c_size_t = c_ulong
-    c_ssize_t = c_long
-elif sizeof(c_ulonglong) == sizeof(c_void_p):
-    c_size_t = c_ulonglong
-    c_ssize_t = c_longlong
-
-# functions
-
-from _ctypes import _memmove_addr, _memset_addr, _string_at_addr, _cast_addr
-
-## void *memmove(void *, const void *, size_t);
-memmove = CFUNCTYPE(c_void_p, c_void_p, c_void_p, c_size_t)(_memmove_addr)
-
-## void *memset(void *, int, size_t)
-memset = CFUNCTYPE(c_void_p, c_void_p, c_int, c_size_t)(_memset_addr)
-
-def PYFUNCTYPE(restype, *argtypes):
-    class CFunctionType(_CFuncPtr):
-        _argtypes_ = argtypes
-        _restype_ = restype
-        _flags_ = _FUNCFLAG_CDECL | _FUNCFLAG_PYTHONAPI
-    return CFunctionType
-
-_cast = PYFUNCTYPE(py_object, c_void_p, py_object, py_object)(_cast_addr)
-def cast(obj, typ):
-    return _cast(obj, obj, typ)
-
-_string_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_string_at_addr)
-def string_at(ptr, size=-1):
-    """string_at(addr[, size]) -> string
-
-    Return the string at addr."""
-    return _string_at(ptr, size)
-
-try:
-    from _ctypes import _wstring_at_addr
-except ImportError:
-    pass
-else:
-    _wstring_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_wstring_at_addr)
-    def wstring_at(ptr, size=-1):
-        """wstring_at(addr[, size]) -> string
-
-        Return the string at addr."""
-        return _wstring_at(ptr, size)
-
-
-if _os.name == "nt": # COM stuff
-    def DllGetClassObject(rclsid, riid, ppv):
-        try:
-            ccom = __import__("comtypes.server.inprocserver", globals(), locals(), ['*'])
-        except ImportError:
-            return -2147221231 # CLASS_E_CLASSNOTAVAILABLE
-        else:
-            return ccom.DllGetClassObject(rclsid, riid, ppv)
-
-    def DllCanUnloadNow():
-        try:
-            ccom = __import__("comtypes.server.inprocserver", globals(), locals(), ['*'])
-        except ImportError:
-            return 0 # S_OK
-        return ccom.DllCanUnloadNow()
-
-from ctypes._endian import BigEndianStructure, LittleEndianStructure
-
-# Fill in specifically-sized types
-c_int8 = c_byte
-c_uint8 = c_ubyte
-for kind in [c_short, c_int, c_long, c_longlong]:
-    if sizeof(kind) == 2: c_int16 = kind
-    elif sizeof(kind) == 4: c_int32 = kind
-    elif sizeof(kind) == 8: c_int64 = kind
-for kind in [c_ushort, c_uint, c_ulong, c_ulonglong]:
-    if sizeof(kind) == 2: c_uint16 = kind
-    elif sizeof(kind) == 4: c_uint32 = kind
-    elif sizeof(kind) == 8: c_uint64 = kind
-del(kind)
-
-_reset_cache()

shared/package-files/9b/9ba27558c729a3ded33a153652e663250379593d748ad9c473f4942553ddd247/blob

@@ -1,106 +0,0 @@
-import numpy as np
-
-from pandas.compat import WARNING_CHECK_DISABLED
-
-from pandas import (
-    DataFrame,
-    option_context,
-)
-import pandas._testing as tm
-from pandas.tests.copy_view.util import get_array
-
-
-def test_clip_inplace_reference(using_copy_on_write, warn_copy_on_write):
-    df = DataFrame({"a": [1.5, 2, 3]})
-    df_copy = df.copy()
-    arr_a = get_array(df, "a")
-    view = df[:]
-    if warn_copy_on_write:
-        with tm.assert_cow_warning():
-            df.clip(lower=2, inplace=True)
-    else:
-        df.clip(lower=2, inplace=True)
-
-    if using_copy_on_write:
-        assert not np.shares_memory(get_array(df, "a"), arr_a)
-        assert df._mgr._has_no_reference(0)
-        assert view._mgr._has_no_reference(0)
-        tm.assert_frame_equal(df_copy, view)
-    else:
-        assert np.shares_memory(get_array(df, "a"), arr_a)
-
-
-def test_clip_inplace_reference_no_op(using_copy_on_write):
-    df = DataFrame({"a": [1.5, 2, 3]})
-    df_copy = df.copy()
-    arr_a = get_array(df, "a")
-    view = df[:]
-    df.clip(lower=0, inplace=True)
-
-    assert np.shares_memory(get_array(df, "a"), arr_a)
-
-    if using_copy_on_write:
-        assert not df._mgr._has_no_reference(0)
-        assert not view._mgr._has_no_reference(0)
-        tm.assert_frame_equal(df_copy, view)
-
-
-def test_clip_inplace(using_copy_on_write):
-    df = DataFrame({"a": [1.5, 2, 3]})
-    arr_a = get_array(df, "a")
-    df.clip(lower=2, inplace=True)
-
-    assert np.shares_memory(get_array(df, "a"), arr_a)
-
-    if using_copy_on_write:
-        assert df._mgr._has_no_reference(0)
-
-
-def test_clip(using_copy_on_write):
-    df = DataFrame({"a": [1.5, 2, 3]})
-    df_orig = df.copy()
-    df2 = df.clip(lower=2)
-
-    assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
-
-    if using_copy_on_write:
-        assert df._mgr._has_no_reference(0)
-    tm.assert_frame_equal(df_orig, df)
-
-
-def test_clip_no_op(using_copy_on_write):
-    df = DataFrame({"a": [1.5, 2, 3]})
-    df2 = df.clip(lower=0)
-
-    if using_copy_on_write:
-        assert not df._mgr._has_no_reference(0)
-        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
-    else:
-        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
-
-
-def test_clip_chained_inplace(using_copy_on_write):
-    df = DataFrame({"a": [1, 4, 2], "b": 1})
-    df_orig = df.copy()
-    if using_copy_on_write:
-        with tm.raises_chained_assignment_error():
-            df["a"].clip(1, 2, inplace=True)
-        tm.assert_frame_equal(df, df_orig)
-
-        with tm.raises_chained_assignment_error():
-            df[["a"]].clip(1, 2, inplace=True)
-        tm.assert_frame_equal(df, df_orig)
-    else:
-        with tm.assert_produces_warning(
-            FutureWarning if not WARNING_CHECK_DISABLED else None,
-            match="inplace method",
-        ):
-            df["a"].clip(1, 2, inplace=True)
-
-        with tm.assert_produces_warning(None):
-            with option_context("mode.chained_assignment", None):
-                df[["a"]].clip(1, 2, inplace=True)
-
-        with tm.assert_produces_warning(None):
-            with option_context("mode.chained_assignment", None):
-                df[df["a"] > 1].clip(1, 2, inplace=True)

shared/package-files/9b/9ba2eb28230878d7ae89c7ee30c146dfe29efbba328d3b03d5045b29d4d15589/blob

@@ -1,365 +0,0 @@
-from sympy.core.numbers import (E, Rational, pi)
-from sympy.functions.elementary.exponential import exp
-from sympy.functions.elementary.miscellaneous import sqrt
-from sympy.core import S, symbols, I
-from sympy.discrete.convolutions import (
-    convolution, convolution_fft, convolution_ntt, convolution_fwht,
-    convolution_subset, covering_product, intersecting_product)
-from sympy.testing.pytest import raises
-from sympy.abc import x, y
-
-def test_convolution():
-    # fft
-    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5)]
-    b = [9, 5, 5, 4, 3, 2]
-    c = [3, 5, 3, 7, 8]
-    d = [1422, 6572, 3213, 5552]
-
-    assert convolution(a, b) == convolution_fft(a, b)
-    assert convolution(a, b, dps=9) == convolution_fft(a, b, dps=9)
-    assert convolution(a, d, dps=7) == convolution_fft(d, a, dps=7)
-    assert convolution(a, d[1:], dps=3) == convolution_fft(d[1:], a, dps=3)
-
-    # prime moduli of the form (m*2**k + 1), sequence length
-    # should be a divisor of 2**k
-    p = 7*17*2**23 + 1
-    q = 19*2**10 + 1
-
-    # ntt
-    assert convolution(d, b, prime=q) == convolution_ntt(b, d, prime=q)
-    assert convolution(c, b, prime=p) == convolution_ntt(b, c, prime=p)
-    assert convolution(d, c, prime=p) == convolution_ntt(c, d, prime=p)
-    raises(TypeError, lambda: convolution(b, d, dps=5, prime=q))
-    raises(TypeError, lambda: convolution(b, d, dps=6, prime=q))
-
-    # fwht
-    assert convolution(a, b, dyadic=True) == convolution_fwht(a, b)
-    assert convolution(a, b, dyadic=False) == convolution(a, b)
-    raises(TypeError, lambda: convolution(b, d, dps=2, dyadic=True))
-    raises(TypeError, lambda: convolution(b, d, prime=p, dyadic=True))
-    raises(TypeError, lambda: convolution(a, b, dps=2, dyadic=True))
-    raises(TypeError, lambda: convolution(b, c, prime=p, dyadic=True))
-
-    # subset
-    assert convolution(a, b, subset=True) == convolution_subset(a, b) == \
-            convolution(a, b, subset=True, dyadic=False) == \
-                convolution(a, b, subset=True)
-    assert convolution(a, b, subset=False) == convolution(a, b)
-    raises(TypeError, lambda: convolution(a, b, subset=True, dyadic=True))
-    raises(TypeError, lambda: convolution(c, d, subset=True, dps=6))
-    raises(TypeError, lambda: convolution(a, c, subset=True, prime=q))
-
-
-def test_cyclic_convolution():
-    # fft
-    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5)]
-    b = [9, 5, 5, 4, 3, 2]
-
-    assert convolution([1, 2, 3], [4, 5, 6], cycle=0) == \
-            convolution([1, 2, 3], [4, 5, 6], cycle=5) == \
-                convolution([1, 2, 3], [4, 5, 6])
-
-    assert convolution([1, 2, 3], [4, 5, 6], cycle=3) == [31, 31, 28]
-
-    a = [Rational(1, 3), Rational(7, 3), Rational(5, 9), Rational(2, 7), Rational(5, 8)]
-    b = [Rational(3, 5), Rational(4, 7), Rational(7, 8), Rational(8, 9)]
-
-    assert convolution(a, b, cycle=0) == \
-            convolution(a, b, cycle=len(a) + len(b) - 1)
-
-    assert convolution(a, b, cycle=4) == [Rational(87277, 26460), Rational(30521, 11340),
-                            Rational(11125, 4032), Rational(3653, 1080)]
-
-    assert convolution(a, b, cycle=6) == [Rational(20177, 20160), Rational(676, 315), Rational(47, 24),
-                            Rational(3053, 1080), Rational(16397, 5292), Rational(2497, 2268)]
-
-    assert convolution(a, b, cycle=9) == \
-                convolution(a, b, cycle=0) + [S.Zero]
-
-    # ntt
-    a = [2313, 5323532, S(3232), 42142, 42242421]
-    b = [S(33456), 56757, 45754, 432423]
-
-    assert convolution(a, b, prime=19*2**10 + 1, cycle=0) == \
-            convolution(a, b, prime=19*2**10 + 1, cycle=8) == \
-                convolution(a, b, prime=19*2**10 + 1)
-
-    assert convolution(a, b, prime=19*2**10 + 1, cycle=5) == [96, 17146, 2664,
-                                                                    15534, 3517]
-
-    assert convolution(a, b, prime=19*2**10 + 1, cycle=7) == [4643, 3458, 1260,
-                                                        15534, 3517, 16314, 13688]
-
-    assert convolution(a, b, prime=19*2**10 + 1, cycle=9) == \
-            convolution(a, b, prime=19*2**10 + 1) + [0]
-
-    # fwht
-    u, v, w, x, y = symbols('u v w x y')
-    p, q, r, s, t = symbols('p q r s t')
-    c = [u, v, w, x, y]
-    d = [p, q, r, s, t]
-
-    assert convolution(a, b, dyadic=True, cycle=3) == \
-                        [2499522285783, 19861417974796, 4702176579021]
-
-    assert convolution(a, b, dyadic=True, cycle=5) == [2718149225143,
-            2114320852171, 20571217906407, 246166418903, 1413262436976]
-
-    assert convolution(c, d, dyadic=True, cycle=4) == \
-            [p*u + p*y + q*v + r*w + s*x + t*u + t*y,
-             p*v + q*u + q*y + r*x + s*w + t*v,
-             p*w + q*x + r*u + r*y + s*v + t*w,
-             p*x + q*w + r*v + s*u + s*y + t*x]
-
-    assert convolution(c, d, dyadic=True, cycle=6) == \
-            [p*u + q*v + r*w + r*y + s*x + t*w + t*y,
-             p*v + q*u + r*x + s*w + s*y + t*x,
-             p*w + q*x + r*u + s*v,
-             p*x + q*w + r*v + s*u,
-             p*y + t*u,
-             q*y + t*v]
-
-    # subset
-    assert convolution(a, b, subset=True, cycle=7) == [18266671799811,
-                    178235365533, 213958794, 246166418903, 1413262436976,
-                    2397553088697, 1932759730434]
-
-    assert convolution(a[1:], b, subset=True, cycle=4) == \
-            [178104086592, 302255835516, 244982785880, 3717819845434]
-
-    assert convolution(a, b[:-1], subset=True, cycle=6) == [1932837114162,
-            178235365533, 213958794, 245166224504, 1413262436976, 2397553088697]
-
-    assert convolution(c, d, subset=True, cycle=3) == \
-            [p*u + p*x + q*w + r*v + r*y + s*u + t*w,
-             p*v + p*y + q*u + s*y + t*u + t*x,
-             p*w + q*y + r*u + t*v]
-
-    assert convolution(c, d, subset=True, cycle=5) == \
-            [p*u + q*y + t*v,
-             p*v + q*u + r*y + t*w,
-             p*w + r*u + s*y + t*x,
-             p*x + q*w + r*v + s*u,
-             p*y + t*u]
-
-    raises(ValueError, lambda: convolution([1, 2, 3], [4, 5, 6], cycle=-1))
-
-
-def test_convolution_fft():
-    assert all(convolution_fft([], x, dps=y) == [] for x in ([], [1]) for y in (None, 3))
-    assert convolution_fft([1, 2, 3], [4, 5, 6]) == [4, 13, 28, 27, 18]
-    assert convolution_fft([1], [5, 6, 7]) == [5, 6, 7]
-    assert convolution_fft([1, 3], [5, 6, 7]) == [5, 21, 25, 21]
-
-    assert convolution_fft([1 + 2*I], [2 + 3*I]) == [-4 + 7*I]
-    assert convolution_fft([1 + 2*I, 3 + 4*I, 5 + 3*I/5], [Rational(2, 5) + 4*I/7]) == \
-            [Rational(-26, 35) + I*48/35, Rational(-38, 35) + I*116/35, Rational(58, 35) + I*542/175]
-
-    assert convolution_fft([Rational(3, 4), Rational(5, 6)], [Rational(7, 8), Rational(1, 3), Rational(2, 5)]) == \
-                                    [Rational(21, 32), Rational(47, 48), Rational(26, 45), Rational(1, 3)]
-
-    assert convolution_fft([Rational(1, 9), Rational(2, 3), Rational(3, 5)], [Rational(2, 5), Rational(3, 7), Rational(4, 9)]) == \
-                                [Rational(2, 45), Rational(11, 35), Rational(8152, 14175), Rational(523, 945), Rational(4, 15)]
-
-    assert convolution_fft([pi, E, sqrt(2)], [sqrt(3), 1/pi, 1/E]) == \
-                    [sqrt(3)*pi, 1 + sqrt(3)*E, E/pi + pi*exp(-1) + sqrt(6),
-                                            sqrt(2)/pi + 1, sqrt(2)*exp(-1)]
-
-    assert convolution_fft([2321, 33123], [5321, 6321, 71323]) == \
-                        [12350041, 190918524, 374911166, 2362431729]
-
-    assert convolution_fft([312313, 31278232], [32139631, 319631]) == \
-                        [10037624576503, 1005370659728895, 9997492572392]
-
-    raises(TypeError, lambda: convolution_fft(x, y))
-    raises(ValueError, lambda: convolution_fft([x, y], [y, x]))
-
-
-def test_convolution_ntt():
-    # prime moduli of the form (m*2**k + 1), sequence length
-    # should be a divisor of 2**k
-    p = 7*17*2**23 + 1
-    q = 19*2**10 + 1
-    r = 2*500000003 + 1 # only for sequences of length 1 or 2
-    # s = 2*3*5*7 # composite modulus
-
-    assert all(convolution_ntt([], x, prime=y) == [] for x in ([], [1]) for y in (p, q, r))
-    assert convolution_ntt([2], [3], r) == [6]
-    assert convolution_ntt([2, 3], [4], r) == [8, 12]
-
-    assert convolution_ntt([32121, 42144, 4214, 4241], [32132, 3232, 87242], p) == [33867619,
-                                    459741727, 79180879, 831885249, 381344700, 369993322]
-    assert convolution_ntt([121913, 3171831, 31888131, 12], [17882, 21292, 29921, 312], q) == \
-                                                [8158, 3065, 3682, 7090, 1239, 2232, 3744]
-
-    assert convolution_ntt([12, 19, 21, 98, 67], [2, 6, 7, 8, 9], p) == \
-                    convolution_ntt([12, 19, 21, 98, 67], [2, 6, 7, 8, 9], q)
-    assert convolution_ntt([12, 19, 21, 98, 67], [21, 76, 17, 78, 69], p) == \
-                    convolution_ntt([12, 19, 21, 98, 67], [21, 76, 17, 78, 69], q)
-
-    raises(ValueError, lambda: convolution_ntt([2, 3], [4, 5], r))
-    raises(ValueError, lambda: convolution_ntt([x, y], [y, x], q))
-    raises(TypeError, lambda: convolution_ntt(x, y, p))
-
-
-def test_convolution_fwht():
-    assert convolution_fwht([], []) == []
-    assert convolution_fwht([], [1]) == []
-    assert convolution_fwht([1, 2, 3], [4, 5, 6]) == [32, 13, 18, 27]
-
-    assert convolution_fwht([Rational(5, 7), Rational(6, 8), Rational(7, 3)], [2, 4, Rational(6, 7)]) == \
-                                    [Rational(45, 7), Rational(61, 14), Rational(776, 147), Rational(419, 42)]
-
-    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5), 4 + 5*I]
-    b = [94, 51, 53, 45, 31, 27, 13]
-    c = [3 + 4*I, 5 + 7*I, 3, Rational(7, 6), 8]
-
-    assert convolution_fwht(a, b) == [53*sqrt(3) + 366 + 155*I,
-                                    45*sqrt(3) + Rational(5848, 15) + 135*I,
-                                    94*sqrt(3) + Rational(1257, 5) + 65*I,
-                                    51*sqrt(3) + Rational(3974, 15),
-                                    13*sqrt(3) + 452 + 470*I,
-                                    Rational(4513, 15) + 255*I,
-                                    31*sqrt(3) + Rational(1314, 5) + 265*I,
-                                    27*sqrt(3) + Rational(3676, 15) + 225*I]
-
-    assert convolution_fwht(b, c) == [Rational(1993, 2) + 733*I, Rational(6215, 6) + 862*I,
-        Rational(1659, 2) + 527*I, Rational(1988, 3) + 551*I, 1019 + 313*I, Rational(3955, 6) + 325*I,
-        Rational(1175, 2) + 52*I, Rational(3253, 6) + 91*I]
-
-    assert convolution_fwht(a[3:], c) == [Rational(-54, 5) + I*293/5, -1 + I*204/5,
-            Rational(133, 15) + I*35/6, Rational(409, 30) + 15*I, Rational(56, 5), 32 + 40*I, 0, 0]
-
-    u, v, w, x, y, z = symbols('u v w x y z')
-
-    assert convolution_fwht([u, v], [x, y]) == [u*x + v*y, u*y + v*x]
-
-    assert convolution_fwht([u, v, w], [x, y]) == \
-        [u*x + v*y, u*y + v*x, w*x, w*y]
-
-    assert convolution_fwht([u, v, w], [x, y, z]) == \
-        [u*x + v*y + w*z, u*y + v*x, u*z + w*x, v*z + w*y]
-
-    raises(TypeError, lambda: convolution_fwht(x, y))
-    raises(TypeError, lambda: convolution_fwht(x*y, u + v))
-
-
-def test_convolution_subset():
-    assert convolution_subset([], []) == []
-    assert convolution_subset([], [Rational(1, 3)]) == []
-    assert convolution_subset([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
-
-    a = [1, Rational(5, 3), sqrt(3), 4 + 5*I]
-    b = [64, 71, 55, 47, 33, 29, 15]
-    c = [3 + I*2/3, 5 + 7*I, 7, Rational(7, 5), 9]
-
-    assert convolution_subset(a, b) == [64, Rational(533, 3), 55 + 64*sqrt(3),
-                                        71*sqrt(3) + Rational(1184, 3) + 320*I, 33, 84,
-                                        15 + 33*sqrt(3), 29*sqrt(3) + 157 + 165*I]
-
-    assert convolution_subset(b, c) == [192 + I*128/3, 533 + I*1486/3,
-                                        613 + I*110/3, Rational(5013, 5) + I*1249/3,
-                                        675 + 22*I, 891 + I*751/3,
-                                        771 + 10*I, Rational(3736, 5) + 105*I]
-
-    assert convolution_subset(a, c) == convolution_subset(c, a)
-    assert convolution_subset(a[:2], b) == \
-            [64, Rational(533, 3), 55, Rational(416, 3), 33, 84, 15, 25]
-
-    assert convolution_subset(a[:2], c) == \
-            [3 + I*2/3, 10 + I*73/9, 7, Rational(196, 15), 9, 15, 0, 0]
-
-    u, v, w, x, y, z = symbols('u v w x y z')
-
-    assert convolution_subset([u, v, w], [x, y]) == [u*x, u*y + v*x, w*x, w*y]
-    assert convolution_subset([u, v, w, x], [y, z]) == \
-                            [u*y, u*z + v*y, w*y, w*z + x*y]
-
-    assert convolution_subset([u, v], [x, y, z]) == \
-                    convolution_subset([x, y, z], [u, v])
-
-    raises(TypeError, lambda: convolution_subset(x, z))
-    raises(TypeError, lambda: convolution_subset(Rational(7, 3), u))
-
-
-def test_covering_product():
-    assert covering_product([], []) == []
-    assert covering_product([], [Rational(1, 3)]) == []
-    assert covering_product([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
-
-    a = [1, Rational(5, 8), sqrt(7), 4 + 9*I]
-    b = [66, 81, 95, 49, 37, 89, 17]
-    c = [3 + I*2/3, 51 + 72*I, 7, Rational(7, 15), 91]
-
-    assert covering_product(a, b) == [66, Rational(1383, 8), 95 + 161*sqrt(7),
-                                        130*sqrt(7) + 1303 + 2619*I, 37,
-                                        Rational(671, 4), 17 + 54*sqrt(7),
-                                        89*sqrt(7) + Rational(4661, 8) + 1287*I]
-
-    assert covering_product(b, c) == [198 + 44*I, 7740 + 10638*I,
-                                        1412 + I*190/3, Rational(42684, 5) + I*31202/3,
-                                        9484 + I*74/3, 22163 + I*27394/3,
-                                        10621 + I*34/3, Rational(90236, 15) + 1224*I]
-
-    assert covering_product(a, c) == covering_product(c, a)
-    assert covering_product(b, c[:-1]) == [198 + 44*I, 7740 + 10638*I,
-                                         1412 + I*190/3, Rational(42684, 5) + I*31202/3,
-                                         111 + I*74/3, 6693 + I*27394/3,
-                                         429 + I*34/3, Rational(23351, 15) + 1224*I]
-
-    assert covering_product(a, c[:-1]) == [3 + I*2/3,
-                            Rational(339, 4) + I*1409/12, 7 + 10*sqrt(7) + 2*sqrt(7)*I/3,
-                            -403 + 772*sqrt(7)/15 + 72*sqrt(7)*I + I*12658/15]
-
-    u, v, w, x, y, z = symbols('u v w x y z')
-
-    assert covering_product([u, v, w], [x, y]) == \
-                            [u*x, u*y + v*x + v*y, w*x, w*y]
-
-    assert covering_product([u, v, w, x], [y, z]) == \
-                            [u*y, u*z + v*y + v*z, w*y, w*z + x*y + x*z]
-
-    assert covering_product([u, v], [x, y, z]) == \
-                    covering_product([x, y, z], [u, v])
-
-    raises(TypeError, lambda: covering_product(x, z))
-    raises(TypeError, lambda: covering_product(Rational(7, 3), u))
-
-
-def test_intersecting_product():
-    assert intersecting_product([], []) == []
-    assert intersecting_product([], [Rational(1, 3)]) == []
-    assert intersecting_product([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
-
-    a = [1, sqrt(5), Rational(3, 8) + 5*I, 4 + 7*I]
-    b = [67, 51, 65, 48, 36, 79, 27]
-    c = [3 + I*2/5, 5 + 9*I, 7, Rational(7, 19), 13]
-
-    assert intersecting_product(a, b) == [195*sqrt(5) + Rational(6979, 8) + 1886*I,
-                                178*sqrt(5) + 520 + 910*I, Rational(841, 2) + 1344*I,
-                                192 + 336*I, 0, 0, 0, 0]
-
-    assert intersecting_product(b, c) == [Rational(128553, 19) + I*9521/5,
-                Rational(17820, 19) + 1602*I, Rational(19264, 19), Rational(336, 19), 1846, 0, 0, 0]
-
-    assert intersecting_product(a, c) == intersecting_product(c, a)
-    assert intersecting_product(b[1:], c[:-1]) == [Rational(64788, 19) + I*8622/5,
-                    Rational(12804, 19) + 1152*I, Rational(11508, 19), Rational(252, 19), 0, 0, 0, 0]
-
-    assert intersecting_product(a, c[:-2]) == \
-                    [Rational(-99, 5) + 10*sqrt(5) + 2*sqrt(5)*I/5 + I*3021/40,
-                    -43 + 5*sqrt(5) + 9*sqrt(5)*I + 71*I, Rational(245, 8) + 84*I, 0]
-
-    u, v, w, x, y, z = symbols('u v w x y z')
-
-    assert intersecting_product([u, v, w], [x, y]) == \
-                            [u*x + u*y + v*x + w*x + w*y, v*y, 0, 0]
-
-    assert intersecting_product([u, v, w, x], [y, z]) == \
-                        [u*y + u*z + v*y + w*y + w*z + x*y, v*z + x*z, 0, 0]
-
-    assert intersecting_product([u, v], [x, y, z]) == \
-                    intersecting_product([x, y, z], [u, v])
-
-    raises(TypeError, lambda: intersecting_product(x, z))
-    raises(TypeError, lambda: intersecting_product(u, Rational(8, 3)))

shared/package-files/9b/9ba66c370c751a1b0492d42beb73715c74245f607b36d8b4d755d8b0f836c5fa/blob

@@ -1,112 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#pragma once
-
-#include <cstdint>
-#include <memory>
-
-#include "arrow/buffer.h"
-#include "arrow/memory_pool.h"
-#include "arrow/result.h"
-#include "arrow/util/bit_util.h"
-#include "arrow/util/visibility.h"
-
-namespace arrow {
-namespace internal {
-
-// A std::generate() like function to write sequential bits into a bitmap area.
-// Bits preceding the bitmap area are preserved, bits following the bitmap
-// area may be clobbered.
-
-template <class Generator>
-void GenerateBits(uint8_t* bitmap, int64_t start_offset, int64_t length, Generator&& g) {
-  if (length == 0) {
-    return;
-  }
-  uint8_t* cur = bitmap + start_offset / 8;
-  uint8_t bit_mask = bit_util::kBitmask[start_offset % 8];
-  uint8_t current_byte = *cur & bit_util::kPrecedingBitmask[start_offset % 8];
-
-  for (int64_t index = 0; index < length; ++index) {
-    const bool bit = g();
-    current_byte = bit ? (current_byte | bit_mask) : current_byte;
-    bit_mask = static_cast<uint8_t>(bit_mask << 1);
-    if (bit_mask == 0) {
-      bit_mask = 1;
-      *cur++ = current_byte;
-      current_byte = 0;
-    }
-  }
-  if (bit_mask != 1) {
-    *cur++ = current_byte;
-  }
-}
-
-// Like GenerateBits(), but unrolls its main loop for higher performance.
-
-template <class Generator>
-void GenerateBitsUnrolled(uint8_t* bitmap, int64_t start_offset, int64_t length,
-                          Generator&& g) {
-  static_assert(std::is_same<decltype(std::declval<Generator>()()), bool>::value,
-                "Functor passed to GenerateBitsUnrolled must return bool");
-
-  if (length == 0) {
-    return;
-  }
-  uint8_t current_byte;
-  uint8_t* cur = bitmap + start_offset / 8;
-  const uint64_t start_bit_offset = start_offset % 8;
-  uint8_t bit_mask = bit_util::kBitmask[start_bit_offset];
-  int64_t remaining = length;
-
-  if (bit_mask != 0x01) {
-    current_byte = *cur & bit_util::kPrecedingBitmask[start_bit_offset];
-    while (bit_mask != 0 && remaining > 0) {
-      current_byte |= g() * bit_mask;
-      bit_mask = static_cast<uint8_t>(bit_mask << 1);
-      --remaining;
-    }
-    *cur++ = current_byte;
-  }
-
-  int64_t remaining_bytes = remaining / 8;
-  uint8_t out_results[8];
-  while (remaining_bytes-- > 0) {
-    for (int i = 0; i < 8; ++i) {
-      out_results[i] = g();
-    }
-    *cur++ = static_cast<uint8_t>(out_results[0] | out_results[1] << 1 |
-                                  out_results[2] << 2 | out_results[3] << 3 |
-                                  out_results[4] << 4 | out_results[5] << 5 |
-                                  out_results[6] << 6 | out_results[7] << 7);
-  }
-
-  int64_t remaining_bits = remaining % 8;
-  if (remaining_bits) {
-    current_byte = 0;
-    bit_mask = 0x01;
-    while (remaining_bits-- > 0) {
-      current_byte |= g() * bit_mask;
-      bit_mask = static_cast<uint8_t>(bit_mask << 1);
-    }
-    *cur++ = current_byte;
-  }
-}
-
-}  // namespace internal
-}  // namespace arrow

shared/package-files/9b/9ba7b5b1a97124d16a01ca9921b766b8f2bf995761f7f4d5a4776df91868353d/blob

@@ -1,13 +0,0 @@
-*** Mon, 25 Jul 2016 11:30:46 ***
-TEST FOR GRANGER-CAUSALITY:
-H0: "Dp" do not Granger-cause "R"
-
-Test statistic l = 0.7474
-pval-F( l; 4, 176) = 0.5610 
-
-TEST FOR INSTANTANEOUS CAUSALITY:
-H0: No instantaneous causality between "Dp" and "R"
-
-Test statistic: c = 0.4071
-pval-Chi( c; 1) = 0.5235 
-