Add files using upload-large-folder tool

shared/package-files/28/2808ec768e7053bc77b6b2471c20a81e1fdaebde861bd0348f7979a9713db535/upsample_linear1d_backward_cuda_dispatch.h

@@ -0,0 +1,28 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor upsample_linear1d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, c10::optional<double> scales=c10::nullopt);
+TORCH_API at::Tensor upsample_linear1d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, c10::optional<double> scales=c10::nullopt);
+TORCH_API at::Tensor & upsample_linear1d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, c10::optional<double> scales=c10::nullopt);
+TORCH_API at::Tensor & upsample_linear1d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, c10::optional<double> scales, at::Tensor & grad_input);
+TORCH_API at::Tensor & upsample_linear1d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, c10::optional<double> scales=c10::nullopt);
+TORCH_API at::Tensor & upsample_linear1d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, bool align_corners, c10::optional<double> scales, at::Tensor & grad_input);
+
+} // namespace cuda
+} // namespace at

shared/package-files/28/281fb0de8cc41105084cd2ed32dc7c3fd25e0eb8d0a3c1bbb98b159ea9dae1cf/_table_schema.py

@@ -0,0 +1,387 @@
+"""
+Table Schema builders
+
+https://specs.frictionlessdata.io/table-schema/
+"""
+from __future__ import annotations
+
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    cast,
+)
+import warnings
+
+from pandas._libs import lib
+from pandas._libs.json import ujson_loads
+from pandas._libs.tslibs import timezones
+from pandas._libs.tslibs.dtypes import freq_to_period_freqstr
+from pandas.util._exceptions import find_stack_level
+
+from pandas.core.dtypes.base import _registry as registry
+from pandas.core.dtypes.common import (
+    is_bool_dtype,
+    is_integer_dtype,
+    is_numeric_dtype,
+    is_string_dtype,
+)
+from pandas.core.dtypes.dtypes import (
+    CategoricalDtype,
+    DatetimeTZDtype,
+    ExtensionDtype,
+    PeriodDtype,
+)
+
+from pandas import DataFrame
+import pandas.core.common as com
+
+from pandas.tseries.frequencies import to_offset
+
+if TYPE_CHECKING:
+    from pandas._typing import (
+        DtypeObj,
+        JSONSerializable,
+    )
+
+    from pandas import Series
+    from pandas.core.indexes.multi import MultiIndex
+
+
+TABLE_SCHEMA_VERSION = "1.4.0"
+
+
+def as_json_table_type(x: DtypeObj) -> str:
+    """
+    Convert a NumPy / pandas type to its corresponding json_table.
+
+    Parameters
+    ----------
+    x : np.dtype or ExtensionDtype
+
+    Returns
+    -------
+    str
+        the Table Schema data types
+
+    Notes
+    -----
+    This table shows the relationship between NumPy / pandas dtypes,
+    and Table Schema dtypes.
+
+    ==============  =================
+    Pandas type     Table Schema type
+    ==============  =================
+    int64           integer
+    float64         number
+    bool            boolean
+    datetime64[ns]  datetime
+    timedelta64[ns] duration
+    object          str
+    categorical     any
+    =============== =================
+    """
+    if is_integer_dtype(x):
+        return "integer"
+    elif is_bool_dtype(x):
+        return "boolean"
+    elif is_numeric_dtype(x):
+        return "number"
+    elif lib.is_np_dtype(x, "M") or isinstance(x, (DatetimeTZDtype, PeriodDtype)):
+        return "datetime"
+    elif lib.is_np_dtype(x, "m"):
+        return "duration"
+    elif is_string_dtype(x):
+        return "string"
+    else:
+        return "any"
+
+
+def set_default_names(data):
+    """Sets index names to 'index' for regular, or 'level_x' for Multi"""
+    if com.all_not_none(*data.index.names):
+        nms = data.index.names
+        if len(nms) == 1 and data.index.name == "index":
+            warnings.warn(
+                "Index name of 'index' is not round-trippable.",
+                stacklevel=find_stack_level(),
+            )
+        elif len(nms) > 1 and any(x.startswith("level_") for x in nms):
+            warnings.warn(
+                "Index names beginning with 'level_' are not round-trippable.",
+                stacklevel=find_stack_level(),
+            )
+        return data
+
+    data = data.copy()
+    if data.index.nlevels > 1:
+        data.index.names = com.fill_missing_names(data.index.names)
+    else:
+        data.index.name = data.index.name or "index"
+    return data
+
+
+def convert_pandas_type_to_json_field(arr) -> dict[str, JSONSerializable]:
+    dtype = arr.dtype
+    name: JSONSerializable
+    if arr.name is None:
+        name = "values"
+    else:
+        name = arr.name
+    field: dict[str, JSONSerializable] = {
+        "name": name,
+        "type": as_json_table_type(dtype),
+    }
+
+    if isinstance(dtype, CategoricalDtype):
+        cats = dtype.categories
+        ordered = dtype.ordered
+
+        field["constraints"] = {"enum": list(cats)}
+        field["ordered"] = ordered
+    elif isinstance(dtype, PeriodDtype):
+        field["freq"] = dtype.freq.freqstr
+    elif isinstance(dtype, DatetimeTZDtype):
+        if timezones.is_utc(dtype.tz):
+            # timezone.utc has no "zone" attr
+            field["tz"] = "UTC"
+        else:
+            # error: "tzinfo" has no attribute "zone"
+            field["tz"] = dtype.tz.zone  # type: ignore[attr-defined]
+    elif isinstance(dtype, ExtensionDtype):
+        field["extDtype"] = dtype.name
+    return field
+
+
+def convert_json_field_to_pandas_type(field) -> str | CategoricalDtype:
+    """
+    Converts a JSON field descriptor into its corresponding NumPy / pandas type
+
+    Parameters
+    ----------
+    field
+        A JSON field descriptor
+
+    Returns
+    -------
+    dtype
+
+    Raises
+    ------
+    ValueError
+        If the type of the provided field is unknown or currently unsupported
+
+    Examples
+    --------
+    >>> convert_json_field_to_pandas_type({"name": "an_int", "type": "integer"})
+    'int64'
+
+    >>> convert_json_field_to_pandas_type(
+    ...     {
+    ...         "name": "a_categorical",
+    ...         "type": "any",
+    ...         "constraints": {"enum": ["a", "b", "c"]},
+    ...         "ordered": True,
+    ...     }
+    ... )
+    CategoricalDtype(categories=['a', 'b', 'c'], ordered=True, categories_dtype=object)
+
+    >>> convert_json_field_to_pandas_type({"name": "a_datetime", "type": "datetime"})
+    'datetime64[ns]'
+
+    >>> convert_json_field_to_pandas_type(
+    ...     {"name": "a_datetime_with_tz", "type": "datetime", "tz": "US/Central"}
+    ... )
+    'datetime64[ns, US/Central]'
+    """
+    typ = field["type"]
+    if typ == "string":
+        return field.get("extDtype", None)
+    elif typ == "integer":
+        return field.get("extDtype", "int64")
+    elif typ == "number":
+        return field.get("extDtype", "float64")
+    elif typ == "boolean":
+        return field.get("extDtype", "bool")
+    elif typ == "duration":
+        return "timedelta64"
+    elif typ == "datetime":
+        if field.get("tz"):
+            return f"datetime64[ns, {field['tz']}]"
+        elif field.get("freq"):
+            # GH#9586 rename frequency M to ME for offsets
+            offset = to_offset(field["freq"])
+            freq_n, freq_name = offset.n, offset.name
+            freq = freq_to_period_freqstr(freq_n, freq_name)
+            # GH#47747 using datetime over period to minimize the change surface
+            return f"period[{freq}]"
+        else:
+            return "datetime64[ns]"
+    elif typ == "any":
+        if "constraints" in field and "ordered" in field:
+            return CategoricalDtype(
+                categories=field["constraints"]["enum"], ordered=field["ordered"]
+            )
+        elif "extDtype" in field:
+            return registry.find(field["extDtype"])
+        else:
+            return "object"
+
+    raise ValueError(f"Unsupported or invalid field type: {typ}")
+
+
+def build_table_schema(
+    data: DataFrame | Series,
+    index: bool = True,
+    primary_key: bool | None = None,
+    version: bool = True,
+) -> dict[str, JSONSerializable]:
+    """
+    Create a Table schema from ``data``.
+
+    Parameters
+    ----------
+    data : Series, DataFrame
+    index : bool, default True
+        Whether to include ``data.index`` in the schema.
+    primary_key : bool or None, default True
+        Column names to designate as the primary key.
+        The default `None` will set `'primaryKey'` to the index
+        level or levels if the index is unique.
+    version : bool, default True
+        Whether to include a field `pandas_version` with the version
+        of pandas that last revised the table schema. This version
+        can be different from the installed pandas version.
+
+    Returns
+    -------
+    dict
+
+    Notes
+    -----
+    See `Table Schema
+    <https://pandas.pydata.org/docs/user_guide/io.html#table-schema>`__ for
+    conversion types.
+    Timedeltas as converted to ISO8601 duration format with
+    9 decimal places after the seconds field for nanosecond precision.
+
+    Categoricals are converted to the `any` dtype, and use the `enum` field
+    constraint to list the allowed values. The `ordered` attribute is included
+    in an `ordered` field.
+
+    Examples
+    --------
+    >>> from pandas.io.json._table_schema import build_table_schema
+    >>> df = pd.DataFrame(
+    ...     {'A': [1, 2, 3],
+    ...      'B': ['a', 'b', 'c'],
+    ...      'C': pd.date_range('2016-01-01', freq='d', periods=3),
+    ...     }, index=pd.Index(range(3), name='idx'))
+    >>> build_table_schema(df)
+    {'fields': \
+[{'name': 'idx', 'type': 'integer'}, \
+{'name': 'A', 'type': 'integer'}, \
+{'name': 'B', 'type': 'string'}, \
+{'name': 'C', 'type': 'datetime'}], \
+'primaryKey': ['idx'], \
+'pandas_version': '1.4.0'}
+    """
+    if index is True:
+        data = set_default_names(data)
+
+    schema: dict[str, Any] = {}
+    fields = []
+
+    if index:
+        if data.index.nlevels > 1:
+            data.index = cast("MultiIndex", data.index)
+            for level, name in zip(data.index.levels, data.index.names):
+                new_field = convert_pandas_type_to_json_field(level)
+                new_field["name"] = name
+                fields.append(new_field)
+        else:
+            fields.append(convert_pandas_type_to_json_field(data.index))
+
+    if data.ndim > 1:
+        for column, s in data.items():
+            fields.append(convert_pandas_type_to_json_field(s))
+    else:
+        fields.append(convert_pandas_type_to_json_field(data))
+
+    schema["fields"] = fields
+    if index and data.index.is_unique and primary_key is None:
+        if data.index.nlevels == 1:
+            schema["primaryKey"] = [data.index.name]
+        else:
+            schema["primaryKey"] = data.index.names
+    elif primary_key is not None:
+        schema["primaryKey"] = primary_key
+
+    if version:
+        schema["pandas_version"] = TABLE_SCHEMA_VERSION
+    return schema
+
+
+def parse_table_schema(json, precise_float: bool) -> DataFrame:
+    """
+    Builds a DataFrame from a given schema
+
+    Parameters
+    ----------
+    json :
+        A JSON table schema
+    precise_float : bool
+        Flag controlling precision when decoding string to double values, as
+        dictated by ``read_json``
+
+    Returns
+    -------
+    df : DataFrame
+
+    Raises
+    ------
+    NotImplementedError
+        If the JSON table schema contains either timezone or timedelta data
+
+    Notes
+    -----
+        Because :func:`DataFrame.to_json` uses the string 'index' to denote a
+        name-less :class:`Index`, this function sets the name of the returned
+        :class:`DataFrame` to ``None`` when said string is encountered with a
+        normal :class:`Index`. For a :class:`MultiIndex`, the same limitation
+        applies to any strings beginning with 'level_'. Therefore, an
+        :class:`Index` name of 'index'  and :class:`MultiIndex` names starting
+        with 'level_' are not supported.
+
+    See Also
+    --------
+    build_table_schema : Inverse function.
+    pandas.read_json
+    """
+    table = ujson_loads(json, precise_float=precise_float)
+    col_order = [field["name"] for field in table["schema"]["fields"]]
+    df = DataFrame(table["data"], columns=col_order)[col_order]
+
+    dtypes = {
+        field["name"]: convert_json_field_to_pandas_type(field)
+        for field in table["schema"]["fields"]
+    }
+
+    # No ISO constructor for Timedelta as of yet, so need to raise
+    if "timedelta64" in dtypes.values():
+        raise NotImplementedError(
+            'table="orient" can not yet read ISO-formatted Timedelta data'
+        )
+
+    df = df.astype(dtypes)
+
+    if "primaryKey" in table["schema"]:
+        df = df.set_index(table["schema"]["primaryKey"])
+        if len(df.index.names) == 1:
+            if df.index.name == "index":
+                df.index.name = None
+        else:
+            df.index.names = [
+                None if x.startswith("level_") else x for x in df.index.names
+            ]
+
+    return df

shared/package-files/28/284621cae64b99ea4346e679b9d0ab35ac5a02fd76b71985ac1cb8a2a5ccef6a/logdet.h

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

shared/package-files/28/2868c82c87d01c0551beda25dbdc12c0db675f9cca8c6dba37ace150f19e0b39/rolodex

@@ -0,0 +1,204 @@
+#!/bin/sh
+# the next line restarts using wish \
+exec wish8.6 "$0" ${1+"$@"}
+
+# rolodex --
+# This script was written as an entry in Tom LaStrange's rolodex
+# benchmark.  It creates something that has some of the look and
+# feel of a rolodex program, although it's lifeless and doesn't
+# actually do the rolodex application.
+
+package require Tk
+
+foreach i [winfo child .] {
+    catch {destroy $i}
+}
+
+set version 1.2
+
+#------------------------------------------
+# Phase 0: create the front end.
+#------------------------------------------
+
+frame .frame -relief flat
+pack .frame -side top -fill y -anchor center
+
+set names {{} Name: Address: {} {} {Home Phone:} {Work Phone:} Fax:}
+foreach i {1 2 3 4 5 6 7} {
+    label .frame.label$i -text [lindex $names $i] -anchor e
+    entry .frame.entry$i -width 35
+    grid .frame.label$i .frame.entry$i -sticky ew -pady 2 -padx 1
+}
+
+frame .buttons
+pack .buttons -side bottom -pady 2 -anchor center
+button .buttons.clear -text Clear
+button .buttons.add -text Add
+button .buttons.search -text Search
+button .buttons.delete -text "Delete ..."
+pack .buttons.clear .buttons.add .buttons.search .buttons.delete \
+	-side left -padx 2
+
+#------------------------------------------
+# Phase 1: Add menus, dialog boxes
+#------------------------------------------
+
+# DKF - note that this is an old-style menu bar; I just have not yet
+# got around to converting the context help code to work with the new
+# menu system and its <<MenuSelect>> virtual event.
+
+frame .menu -relief raised -borderwidth 1
+pack .menu -before .frame -side top -fill x
+
+menubutton .menu.file -text "File" -menu .menu.file.m -underline 0
+menu .menu.file.m
+.menu.file.m add command -label "Load ..." -command fileAction -underline 0
+.menu.file.m add command -label "Exit" -command {destroy .} -underline 0
+pack .menu.file -side left
+
+menubutton .menu.help -text "Help" -menu .menu.help.m -underline 0
+menu .menu.help.m
+pack .menu.help -side right
+
+proc deleteAction {} {
+    if {[tk_dialog .delete {Confirm Action} {Are you sure?} {} 0  Cancel]
+	    == 0} {
+	clearAction
+    }
+}
+.buttons.delete config -command deleteAction
+
+proc fileAction {} {
+    tk_dialog .fileSelection {File Selection} {This is a dummy file selection dialog box, which is used because there isn't a good file selection dialog built into Tk yet.} {} 0 OK
+    puts stderr {dummy file name}
+}
+
+#------------------------------------------
+# Phase 3: Print contents of card
+#------------------------------------------
+
+proc addAction {} {
+    global names
+    foreach i {1 2 3 4 5 6 7} {
+	puts stderr [format "%-12s %s" [lindex $names $i] [.frame.entry$i get]]
+    }
+}
+.buttons.add config -command addAction
+
+#------------------------------------------
+# Phase 4: Miscellaneous other actions
+#------------------------------------------
+
+proc clearAction {} {
+    foreach i {1 2 3 4 5 6 7} {
+	.frame.entry$i delete 0 end
+    }
+}
+.buttons.clear config -command clearAction
+
+proc fillCard {} {
+    clearAction
+    .frame.entry1 insert 0 "John Ousterhout"
+    .frame.entry2 insert 0 "CS Division, Department of EECS"
+    .frame.entry3 insert 0 "University of California"
+    .frame.entry4 insert 0 "Berkeley, CA 94720"
+    .frame.entry5 insert 0 "private"
+    .frame.entry6 insert 0 "510-642-0865"
+    .frame.entry7 insert 0 "510-642-5775"
+}
+.buttons.search config -command "addAction; fillCard"
+
+#----------------------------------------------------
+# Phase 5: Accelerators, mnemonics, command-line info
+#----------------------------------------------------
+
+.buttons.clear config -text "Clear    Ctrl+C"
+bind . <Control-c> clearAction
+.buttons.add config -text "Add    Ctrl+A"
+bind . <Control-a> addAction
+.buttons.search config -text "Search    Ctrl+S"
+bind . <Control-s> "addAction; fillCard"
+.buttons.delete config -text "Delete...    Ctrl+D"
+bind . <Control-d> deleteAction
+
+.menu.file.m entryconfig 1 -accel Ctrl+F
+bind . <Control-f> fileAction
+.menu.file.m entryconfig 2 -accel Ctrl+Q
+bind . <Control-q> {destroy .}
+
+focus .frame.entry1
+
+#----------------------------------------------------
+# Phase 6: help
+#----------------------------------------------------
+
+proc Help {topic {x 0} {y 0}} {
+    global helpTopics helpCmds
+    if {$topic == ""} return
+    while {[info exists helpCmds($topic)]} {
+	set topic [eval $helpCmds($topic)]
+    }
+    if [info exists helpTopics($topic)] {
+	set msg $helpTopics($topic)
+    } else {
+	set msg "Sorry, but no help is available for this topic"
+    }
+    tk_dialog .help {Rolodex Help} "Information on $topic:\n\n$msg" \
+	    {} 0 OK
+}
+
+proc getMenuTopic {w x y} {
+    return $w.[$w index @[expr {$y-[winfo rooty $w]}]]
+}
+
+event add <<Help>> <F1> <Help>
+bind .    <<Help>> {Help [winfo containing %X %Y] %X %Y}
+bind Menu <<Help>> {Help [winfo containing %X %Y] %X %Y}
+
+# Help text and commands follow:
+
+set helpTopics(.menu.file) {This is the "file" menu.  It can be used to invoke some overall operations on the rolodex applications, such as loading a file or exiting.}
+
+set helpCmds(.menu.file.m) {getMenuTopic $topic $x $y}
+set helpTopics(.menu.file.m.1) {The "Load" entry in the "File" menu posts a dialog box that you can use to select a rolodex file}
+set helpTopics(.menu.file.m.2) {The "Exit" entry in the "File" menu causes the rolodex application to terminate}
+set helpCmds(.menu.file.m.none) {set topic ".menu.file"}
+
+set helpTopics(.frame.entry1) {In this field of the rolodex entry you should type the person's name}
+set helpTopics(.frame.entry2) {In this field of the rolodex entry you should type the first line of the person's address}
+set helpTopics(.frame.entry3) {In this field of the rolodex entry you should type the second line of the person's address}
+set helpTopics(.frame.entry4) {In this field of the rolodex entry you should type the third line of the person's address}
+set helpTopics(.frame.entry5) {In this field of the rolodex entry you should type the person's home phone number, or "private" if the person doesn't want his or her number publicized}
+set helpTopics(.frame.entry6) {In this field of the rolodex entry you should type the person's work phone number}
+set helpTopics(.frame.entry7) {In this field of the rolodex entry you should type the phone number for the person's FAX machine}
+
+set helpCmds(.frame.label1) {set topic .frame.entry1}
+set helpCmds(.frame.label2) {set topic .frame.entry2}
+set helpCmds(.frame.label3) {set topic .frame.entry3}
+set helpCmds(.frame.label4) {set topic .frame.entry4}
+set helpCmds(.frame.label5) {set topic .frame.entry5}
+set helpCmds(.frame.label6) {set topic .frame.entry6}
+set helpCmds(.frame.label7) {set topic .frame.entry7}
+
+set helpTopics(context) {Unfortunately, this application doesn't support context-sensitive help in the usual way, because when this demo was written Tk didn't have a grab mechanism and this is needed for context-sensitive help.  Instead, you can achieve much the same effect by simply moving the mouse over the window you're curious about and pressing the Help or F1 keys.  You can do this anytime.}
+set helpTopics(help) {This application provides only very crude help.  Besides the entries in this menu, you can get help on individual windows by moving the mouse cursor over the window and pressing the Help or F1 keys.}
+set helpTopics(window) {This window is a dummy rolodex application created as part of Tom LaStrange's toolkit benchmark.  It doesn't really do anything useful except to demonstrate a few features of the Tk toolkit.}
+set helpTopics(keys) "The following accelerator keys are defined for this application (in addition to those already available for the entry windows):\n\nCtrl+A:\t\tAdd\nCtrl+C:\t\tClear\nCtrl+D:\t\tDelete\nCtrl+F:\t\tEnter file name\nCtrl+Q:\t\tExit application (quit)\nCtrl+S:\t\tSearch (dummy operation)"
+set helpTopics(version) "This is version $version."
+
+# Entries in "Help" menu
+
+.menu.help.m add command -label "On Context..." -command {Help context} \
+	-underline 3
+.menu.help.m add command -label "On Help..." -command {Help help} \
+	-underline 3
+.menu.help.m add command -label "On Window..." -command {Help window} \
+	-underline 3
+.menu.help.m add command -label "On Keys..." -command {Help keys} \
+	-underline 3
+.menu.help.m add command -label "On Version..." -command {Help version}  \
+	-underline 3
+
+# Local Variables:
+# mode: tcl
+# End:

shared/package-files/28/2889a273f20bca1c5abdb1b15676be02c71ffbea2489b6a564994ae386b97627/RegistrationDeclarations.h

@@ -0,0 +1,4 @@
+// This file contains all native_functions that can be registered to
+// and the schema string that they should be registered with
+
+${registration_declarations}

shared/package-files/28/28948c9b3b5746a4efa66901fa4cbe592548a80320fc6716a1ec13711c49d42c/_gauss_legendre.py

@@ -0,0 +1,62 @@
+from scipy._lib._array_api import array_namespace, np_compat
+
+from functools import cached_property
+
+from scipy.special import roots_legendre
+
+from ._base import FixedRule
+
+
+class GaussLegendreQuadrature(FixedRule):
+    """
+    Gauss-Legendre quadrature.
+
+    Parameters
+    ----------
+    npoints : int
+        Number of nodes for the higher-order rule.
+
+    xp : array_namespace, optional
+        The namespace for the node and weight arrays. Default is None, where NumPy is
+        used.
+
+    Examples
+    --------
+    Evaluate a 1D integral. Note in this example that ``f`` returns an array, so the
+    estimates will also be arrays.
+
+    >>> import numpy as np
+    >>> from scipy.integrate import cubature
+    >>> from scipy.integrate._rules import GaussLegendreQuadrature
+    >>> def f(x):
+    ...     return np.cos(x)
+    >>> rule = GaussLegendreQuadrature(21) # Use 21-point GaussLegendre
+    >>> a, b = np.array([0]), np.array([1])
+    >>> rule.estimate(f, a, b) # True value sin(1), approximately 0.84147
+     array([0.84147098])
+    >>> rule.estimate_error(f, a, b)
+     array([1.11022302e-16])
+    """
+
+    def __init__(self, npoints, xp=None):
+        if npoints < 2:
+            raise ValueError(
+                "At least 2 nodes required for Gauss-Legendre cubature"
+            )
+
+        self.npoints = npoints
+
+        if xp is None:
+            xp = np_compat
+
+        self.xp = array_namespace(xp.empty(0))
+
+    @cached_property
+    def nodes_and_weights(self):
+        # TODO: current converting to/from numpy
+        nodes, weights = roots_legendre(self.npoints)
+
+        return (
+            self.xp.asarray(nodes, dtype=self.xp.float64),
+            self.xp.asarray(weights, dtype=self.xp.float64)
+        )

shared/package-files/28/28b1c1421f5a5a02d859b7aac36922c906ae18d0e22a669d78c9a5b6274696b9/dateformat.pyi

@@ -0,0 +1,63 @@
+from datetime import datetime, date
+from typing import Any, Optional, Union
+
+from django.utils.timezone import FixedOffset
+
+re_formatchars: Any
+re_escaped: Any
+
+class Formatter:
+    def format(self, formatstr: str) -> str: ...
+
+class TimeFormat(Formatter):
+    data: Union[datetime, str] = ...
+    timezone: Optional[FixedOffset] = ...
+    def __init__(self, obj: Union[datetime, str]) -> None: ...
+    def a(self) -> str: ...
+    def A(self) -> str: ...
+    def B(self) -> None: ...
+    def e(self) -> str: ...
+    def f(self) -> Union[int, str]: ...
+    def g(self) -> int: ...
+    def G(self) -> int: ...
+    def h(self) -> str: ...
+    def H(self) -> str: ...
+    def i(self) -> str: ...
+    def O(self) -> str: ...
+    def P(self) -> str: ...
+    def s(self) -> str: ...
+    def T(self) -> str: ...
+    def u(self) -> str: ...
+    def Z(self) -> Union[int, str]: ...
+
+class DateFormat(TimeFormat):
+    data: Union[datetime, str]
+    timezone: Optional[FixedOffset]
+    year_days: Any = ...
+    def b(self): ...
+    def c(self) -> str: ...
+    def d(self) -> str: ...
+    def D(self): ...
+    def E(self): ...
+    def F(self): ...
+    def I(self) -> str: ...
+    def j(self) -> int: ...
+    def l(self): ...
+    def L(self) -> bool: ...
+    def m(self) -> str: ...
+    def M(self) -> str: ...
+    def n(self) -> int: ...
+    def N(self): ...
+    def o(self) -> int: ...
+    def r(self) -> str: ...
+    def S(self) -> str: ...
+    def t(self) -> str: ...
+    def U(self) -> int: ...
+    def w(self) -> int: ...
+    def W(self) -> int: ...
+    def y(self) -> str: ...
+    def Y(self) -> int: ...
+    def z(self) -> int: ...
+
+def format(value: Union[datetime, str, date], format_string: str) -> str: ...
+def time_format(value: Union[datetime, str], format_string: str) -> str: ...

shared/package-files/28/28b67a74effbbbc3a40a4843484feede592668c2034961f874e769ae9735b45b/pattern_utils.py

@@ -0,0 +1,200 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+toq = torch.ops.quantized
+
+from torch.fx import GraphModule
+from torch.fx.graph import Node
+
+from torch.ao.quantization.backend_config import get_native_backend_config
+from torch.ao.quantization.fx.quantize_handler import _get_pattern_to_quantize_handlers
+from torch.ao.quantization.utils import getattr_from_fqn
+from .ns_types import NSNodeTargetType
+from torch.ao.quantization import (
+    ObserverBase,
+    FakeQuantizeBase,
+)
+
+from typing import Dict, Tuple, Set, Callable, Any, Union, List
+
+
+def get_type_a_related_to_b(
+    base_name_to_sets_of_related_ops: Dict[str, Set[NSNodeTargetType]],
+) -> Set[Tuple[NSNodeTargetType, NSNodeTargetType]]:
+    # TODO(future PR): allow customizations
+    # TODO(future PR): reuse existing quantization mappings
+    # TODO(future PR): add the rest of modules and ops here
+    type_a_related_to_b: Set[Tuple[NSNodeTargetType, NSNodeTargetType]] = set()
+
+    for s in base_name_to_sets_of_related_ops.values():
+        s_list = list(s)
+        # add every bidirectional pair
+        for idx_0 in range(0, len(s_list)):
+            for idx_1 in range(idx_0, len(s_list)):
+                type_a_related_to_b.add((s_list[idx_0], s_list[idx_1]))
+                type_a_related_to_b.add((s_list[idx_1], s_list[idx_0]))
+
+    return type_a_related_to_b
+
+
+NSFusionElType = Union[
+    Callable,  # call_function or call_module type, example: F.linear or nn.Conv2d
+    str,  # call_method name, example: "dequantize"
+    Tuple[str, Any],  # call_method name and first argument, example: ("to", torch.float16)
+]
+NSFusionType = Union[
+    Tuple[NSFusionElType, NSFusionElType],
+    Tuple[NSFusionElType, NSFusionElType, NSFusionElType, NSFusionElType],
+]
+
+def get_reversed_fusions() -> List[Tuple[NSFusionType, int]]:
+    """
+    Set of potential fusions, in reverse order.  The order is reversed
+    to match how fusion patterns are defined in quantization code.
+
+    Fusion format:
+    ((fusion_op_0, fusion_op_1), base_op_idx)
+
+    Where base_op_idx is the idx of the op we should use to match other related
+    ops. Note: base_op_idx is specified in non-reverse order, i.e. a base_op_idx
+    of 0 represents the first op in regular (non-reverse) order, 1 represents the
+    second op, etc.
+    """
+    results: List[Tuple[NSFusionType, int]] = []
+
+    # Possible syntaxes:
+    # * single op: torch.nn.Conv2d
+    # * multiple ops: (torch.nn.ReLU, torch.nn.Conv2d)
+    # For fusions, we only care about patterns composed of multiple ops.
+    # TODO(future PR): allow customizations from default patterns.
+    all_quant_patterns = _get_pattern_to_quantize_handlers(get_native_backend_config())
+
+    default_base_op_idx = 0
+    for quant_pattern in all_quant_patterns.keys():
+        # TODO: this is a temporary hack to flatten the patterns from quantization so
+        # that it works with the ns matcher function, maybe we should use `_is_match`
+        # in torch.ao.quantization.fx.match_utils to match the patterns
+        if isinstance(quant_pattern, tuple) and len(quant_pattern) == 2 and \
+           isinstance(quant_pattern[1], tuple) and len(quant_pattern[1]) == 2:
+            # flatten the pattern with form (nn.ReLU, (nn.BatchNorm2d, nn.Conv2d))
+            quant_pattern = (quant_pattern[0], quant_pattern[1][0], quant_pattern[1][1])
+
+        # Only patterns of multiple ops are fusions, ignore
+        # patterns which contain a single ops (they get matched
+        # without caring about fusions).
+        if isinstance(quant_pattern, tuple):
+            results.append((quant_pattern, default_base_op_idx))  # type: ignore[arg-type]
+
+        # For each pattern, add additional patterns with observers and
+        # fake quants at the end.
+        # TODO(future PR): if needed, implement matching for a node
+        #   having multiple output observers.
+        for cls in (ObserverBase, FakeQuantizeBase):
+            if isinstance(quant_pattern, tuple):
+                new_pattern = (cls, *quant_pattern)
+            else:
+                new_pattern = (cls, quant_pattern)
+            results.append((new_pattern, default_base_op_idx))  # type: ignore[arg-type]
+
+
+    # After this point, results contains values such as
+    # [..., ((torch.nn.Relu, torch.nn.Conv2d), 0), ...]
+
+    # Patterns for matching fp16 emulation are not specified in the quantization
+    # fusion mappings.  For now, define them here.
+    fp16_em_base_op_idx = 1
+    patterns_to_add = [
+        # linear-relu fp16 emulation:
+        # fp16_to_fp32 -> linear -> relu -> fp32_to_fp16
+        ((("to", torch.float16), F.relu, F.linear, "dequantize"), fp16_em_base_op_idx,),
+        # Conv-BN fusion (this happens outside of quantization patterns,
+        # which is why it is defined separately here).
+        ((nn.BatchNorm1d, nn.Conv1d), default_base_op_idx),
+        ((nn.BatchNorm2d, nn.Conv2d), default_base_op_idx),
+        ((nn.BatchNorm3d, nn.Conv3d), default_base_op_idx),
+        ((nn.ReLU, nn.BatchNorm1d, nn.Conv1d), default_base_op_idx),
+        ((nn.ReLU, nn.BatchNorm2d, nn.Conv2d), default_base_op_idx),
+        ((nn.ReLU, nn.BatchNorm3d, nn.Conv3d), default_base_op_idx),
+    ]
+    for p in patterns_to_add:
+        results.append(p)  # type: ignore[arg-type]
+        results.append(((ObserverBase, *p[0]), p[1]))  # type: ignore[arg-type]
+        results.append(((FakeQuantizeBase, *p[0]), p[1]))  # type: ignore[arg-type]
+
+    return results
+
+
+def end_node_matches_reversed_fusion(
+    end_node: Node,
+    reversed_fusion: NSFusionType,
+    gm: GraphModule,
+    seen_nodes: Set[Node],
+) -> bool:
+    """
+    Returns true if a pattern ending with `end_node` matches
+    the fusion pattern.
+    """
+    cur_node = end_node
+    for fusion_idx in range(len(reversed_fusion)):
+        # each node can only belong to one matched pattern
+        if cur_node in seen_nodes:
+            return False
+
+        cur_fusion_el = reversed_fusion[fusion_idx]
+
+        if cur_node.op == 'call_function':
+            fusion_el_is_fun = (not isinstance(cur_fusion_el, str)) and \
+                (not isinstance(cur_fusion_el, type))
+            if fusion_el_is_fun:
+                if cur_node.target != cur_fusion_el:
+                    return False
+                if len(cur_node.args) > 0 and isinstance(cur_node.args[0], Node):
+                    cur_node = cur_node.args[0]
+                else:
+                    return False
+            else:
+                return False
+
+        elif cur_node.op == 'call_module':
+            fusion_el_is_mod = isinstance(cur_fusion_el, type)
+            if fusion_el_is_mod:
+                assert isinstance(cur_node.target, str)
+                target_mod = getattr_from_fqn(gm, cur_node.target)
+                if not isinstance(cur_fusion_el, type):
+                    return False
+                if not isinstance(target_mod, cur_fusion_el):
+                    return False
+                if len(cur_node.args) > 0 and isinstance(cur_node.args[0], Node):
+                    cur_node = cur_node.args[0]
+                else:
+                    return False
+            else:
+                return False
+
+        elif cur_node.op == 'call_method':
+            fusion_el_is_meth_with_second_arg = \
+                isinstance(cur_fusion_el, tuple) and len(cur_fusion_el) == 2
+            fusion_el_is_meth_without_args = isinstance(cur_fusion_el, str)
+            if fusion_el_is_meth_without_args or fusion_el_is_meth_with_second_arg:
+                if fusion_el_is_meth_without_args:
+                    if cur_node.target != cur_fusion_el:
+                        return False
+                else:
+                    assert isinstance(cur_fusion_el, tuple)
+                    if cur_node.target != cur_fusion_el[0]:
+                        return False
+                    elif len(cur_node.args) < 2:
+                        return False
+                    elif cur_node.args[1] != cur_fusion_el[1]:
+                        return False
+
+                if len(cur_node.args) > 0 and isinstance(cur_node.args[0], Node):
+                    cur_node = cur_node.args[0]
+                else:
+                    return False
+            else:
+                return False
+        else:
+            return False
+
+    return True

shared/package-files/28/28d386370beed69d9b6a2bd16e57502882be80a593a8ba8387c3998b1335031e/geqrf.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/geqrf_ops.h>
+
+namespace at {
+
+
+// aten::geqrf.a(Tensor self, *, Tensor(a!) a, Tensor(b!) tau) -> (Tensor(a!) a, Tensor(b!) tau)
+inline ::std::tuple<at::Tensor &,at::Tensor &> geqrf_out(at::Tensor & a, at::Tensor & tau, const at::Tensor & self) {
+    return at::_ops::geqrf_a::call(self, a, tau);
+}
+// aten::geqrf.a(Tensor self, *, Tensor(a!) a, Tensor(b!) tau) -> (Tensor(a!) a, Tensor(b!) tau)
+inline ::std::tuple<at::Tensor &,at::Tensor &> geqrf_outf(const at::Tensor & self, at::Tensor & a, at::Tensor & tau) {
+    return at::_ops::geqrf_a::call(self, a, tau);
+}
+
+// aten::geqrf(Tensor self) -> (Tensor a, Tensor tau)
+inline ::std::tuple<at::Tensor,at::Tensor> geqrf(const at::Tensor & self) {
+    return at::_ops::geqrf::call(self);
+}
+
+}

shared/package-files/28/28d7d9b92f072ab5cd552454a18b713166359c210b1989e0fd90efd9687db686/logical_not_ops.h

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

shared/package-files/28/28f219e4406c50b28204a450f09ac5fa14fa3330f06c8ba9023b389ad5ba417b/combinatorics.py

@@ -0,0 +1,126 @@
+import random
+
+import torch
+from torch.utils.data.datapipes.datapipe import IterDataPipe, MapDataPipe
+from typing import Iterator, List, Optional, TypeVar
+
+__all__ = ["ShufflerIterDataPipe", ]
+
+
+T_co = TypeVar('T_co', covariant=True)
+
+
+# @functional_datapipe('shuffle')
+class ShufflerIterDataPipe(IterDataPipe[T_co]):
+    r"""
+    Shuffle the input MapDataPipe via its indices (functional name: ``shuffle``).
+
+    When it is used with :class:`~torch.utils.data.DataLoader`, the methods to
+    set up random seed are different based on :attr:`num_workers`.
+
+    For single-process mode (:attr:`num_workers == 0`), the random seed is set before
+    the :class:`~torch.utils.data.DataLoader` in the main process. For multi-process
+    mode (:attr:`num_worker > 0`), ``worker_init_fn`` is used to set up a random seed
+    for each worker process.
+
+    Args:
+        datapipe: MapDataPipe being shuffled
+        indices: a list of indices of the MapDataPipe. If not provided, we assume it uses 0-based indexing
+
+    Example:
+        >>> # xdoctest: +SKIP
+        >>> from torchdata.datapipes.map import SequenceWrapper
+        >>> dp = SequenceWrapper(range(10))
+        >>> shuffle_dp = dp.shuffle().set_seed(0)
+        >>> list(shuffle_dp)
+        [7, 8, 1, 5, 3, 4, 2, 0, 9, 6]
+        >>> list(shuffle_dp)
+        [6, 1, 9, 5, 2, 4, 7, 3, 8, 0]
+        >>> # Reset seed for Shuffler
+        >>> shuffle_dp = shuffle_dp.set_seed(0)
+        >>> list(shuffle_dp)
+        [7, 8, 1, 5, 3, 4, 2, 0, 9, 6]
+
+    Note:
+        Even thought this ``shuffle`` operation takes a ``MapDataPipe`` as the input, it would return an
+        ``IterDataPipe`` rather than a ``MapDataPipe``, because ``MapDataPipe`` should be non-sensitive to
+        the order of data order for the sake of random reads, but ``IterDataPipe`` depends on the order
+        of data during data-processing.
+    """
+
+    datapipe: MapDataPipe[T_co]
+    _enabled: bool
+    _seed: Optional[int]
+    _rng: random.Random
+
+    def __init__(self,
+                 datapipe: MapDataPipe[T_co],
+                 *,
+                 indices: Optional[List] = None,
+                 ) -> None:
+        super().__init__()
+        self.datapipe = datapipe
+        self.indices = list(range(len(datapipe))) if indices is None else indices
+        self._enabled = True
+        self._seed = None
+        self._rng = random.Random()
+        self._shuffled_indices: List = self.indices
+
+    def set_shuffle(self, shuffle=True):
+        self._enabled = shuffle
+        return self
+
+    def set_seed(self, seed: int):
+        self._seed = seed
+        return self
+
+    def __iter__(self) -> Iterator[T_co]:
+        if not self._enabled:
+            for idx in self.indices:
+                yield self.datapipe[idx]
+        else:
+            while self._shuffled_indices:
+                idx = self._shuffled_indices.pop()
+                yield self.datapipe[idx]
+
+    def reset(self) -> None:
+        if self._enabled and self._seed is None:
+            self._seed = int(torch.empty((), dtype=torch.int64).random_().item())
+        self._rng.seed(self._seed)
+        self._seed = None
+        self._shuffled_indices = self._rng.sample(self.indices, len(self.indices))
+
+    def __len__(self) -> int:
+        return len(self.datapipe)
+
+    def __getstate__(self):
+        state = (
+            self.datapipe,
+            self.indices,
+            self._enabled,
+            self._seed,
+            self._rng.getstate(),
+            self._shuffled_indices,
+            self._valid_iterator_id,
+            self._number_of_samples_yielded,
+        )
+        if IterDataPipe.getstate_hook is not None:
+            return IterDataPipe.getstate_hook(state)
+        return state
+
+    def __setstate__(self, state):
+        (
+            self.datapipe,
+            self.indices,
+            self._enabled,
+            self._seed,
+            rng_state,
+            self._shuffled_indices,
+            self._valid_iterator_id,
+            self._number_of_samples_yielded,
+        ) = state
+        self._rng = random.Random()
+        self._rng.setstate(rng_state)
+
+
+MapDataPipe.register_datapipe_as_function("shuffle", ShufflerIterDataPipe)

shared/package-files/74/740228db814b6dd426a989aca58f20a3d2d66d795fbbe022b417249c26ea324e/inspect_pkg.py

@@ -0,0 +1,359 @@
+# Copyright (C) 2014 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+from __future__ import annotations
+
+import json
+import os
+import sys
+from collections import defaultdict
+from itertools import groupby
+from operator import itemgetter
+from os.path import abspath, basename, dirname, exists, join, normcase
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import TYPE_CHECKING
+
+from conda.api import Solver
+from conda.core.index import get_index
+from conda.core.prefix_data import PrefixData
+from conda.models.records import PrefixRecord
+
+from . import conda_interface
+from .conda_interface import (
+    specs_from_args,
+)
+from .os_utils.ldd import (
+    get_linkages,
+    get_package_obj_files,
+    get_untracked_obj_files,
+)
+from .os_utils.liefldd import codefile_class, machofile
+from .os_utils.macho import get_rpaths, human_filetype
+from .utils import (
+    comma_join,
+    ensure_list,
+    get_logger,
+    on_linux,
+    on_mac,
+    on_win,
+    package_has_file,
+)
+
+if TYPE_CHECKING:
+    from typing import Iterable, Literal
+
+log = get_logger(__name__)
+
+
+def which_package(
+    path: str | os.PathLike | Path,
+    prefix: str | os.PathLike | Path,
+) -> Iterable[PrefixRecord]:
+    """Detect which package(s) a path belongs to.
+
+    Given the path (of a (presumably) conda installed file) iterate over
+    the conda packages the file came from.  Usually the iteration yields
+    only one package.
+    """
+    try:
+        path = Path(path).relative_to(prefix)
+    except ValueError:
+        # ValueError: path is already relative to prefix
+        pass
+    # On Windows, be lenient and allow case-insensitive path comparisons.
+    # NOTE: On macOS, although case-insensitive filesystem is default, still
+    #       require case-sensitive matches (i.e., normcase on macOS is a no-op).
+    normcase_path = normcase(path)
+
+    for prec in PrefixData(str(prefix)).iter_records():
+        if normcase_path in (normcase(file) for file in prec["files"]):
+            yield prec
+
+
+def print_object_info(info, key):
+    output_string = ""
+    for header, group in groupby(sorted(info, key=itemgetter(key)), itemgetter(key)):
+        output_string += header + "\n"
+        for f_info in sorted(group, key=itemgetter("filename")):
+            for data in sorted(f_info):
+                if data == key:
+                    continue
+                if f_info[data] is None:
+                    continue
+                output_string += f"  {data}: {f_info[data]}\n"
+            if len([i for i in f_info if f_info[i] is not None and i != key]) > 1:
+                output_string += "\n"
+        output_string += "\n"
+    return output_string
+
+
+class _untracked_package:
+    def __str__(self):
+        return "<untracked>"
+
+
+untracked_package = _untracked_package()
+
+
+def check_install(
+    packages: Iterable[str],
+    subdir: str | None = None,
+    channel_urls: Iterable[str] = (),
+) -> None:
+    with TemporaryDirectory() as prefix:
+        Solver(
+            prefix,
+            channel_urls,
+            [subdir or conda_interface.subdir],
+            specs_from_args(packages),
+        ).solve_for_transaction(ignore_pinned=True).print_transaction_summary()
+
+
+def print_linkages(
+    depmap: dict[
+        PrefixRecord | Literal["not found" | "system" | "untracked"],
+        list[tuple[str, str, str]],
+    ],
+    show_files: bool = False,
+) -> str:
+    # print system, not found, and untracked last
+    sort_order = {
+        # PrefixRecord: (0, PrefixRecord.name),
+        "system": (1, "system"),
+        "not found": (2, "not found"),
+        "untracked": (3, "untracked"),
+        # str: (4, str),
+    }
+
+    output_string = ""
+    for prec, links in sorted(
+        depmap.items(),
+        key=(
+            lambda key: (0, key[0].name)
+            if isinstance(key[0], PrefixRecord)
+            else sort_order.get(key[0], (4, key[0]))
+        ),
+    ):
+        output_string += "%s:\n" % prec
+        if show_files:
+            for lib, path, binary in sorted(links):
+                output_string += f"    {lib} ({path}) from {binary}\n"
+        else:
+            for lib, path in sorted(set(map(itemgetter(0, 1), links))):
+                output_string += f"    {lib} ({path})\n"
+        output_string += "\n"
+    return output_string
+
+
+def replace_path(binary, path, prefix):
+    if on_linux:
+        return abspath(path)
+    elif on_mac:
+        if path == basename(binary):
+            return abspath(join(prefix, binary))
+        if "@rpath" in path:
+            rpaths = get_rpaths(join(prefix, binary))
+            if not rpaths:
+                return "NO LC_RPATH FOUND"
+            else:
+                for rpath in rpaths:
+                    path1 = path.replace("@rpath", rpath)
+                    path1 = path1.replace("@loader_path", join(prefix, dirname(binary)))
+                    if exists(abspath(join(prefix, path1))):
+                        path = path1
+                        break
+                else:
+                    return "not found"
+        path = path.replace("@loader_path", join(prefix, dirname(binary)))
+        if path.startswith("/"):
+            return abspath(path)
+        return "not found"
+
+
+def test_installable(channel: str = "defaults") -> bool:
+    success = True
+    for subdir in ["osx-64", "linux-32", "linux-64", "win-32", "win-64"]:
+        log.info("######## Testing subdir %s ########", subdir)
+        for prec in get_index(channel_urls=[channel], prepend=False, platform=subdir):
+            name = prec["name"]
+            if name in {"conda", "conda-build"}:
+                # conda can only be installed in the root environment
+                continue
+            elif name.endswith("@"):
+                # this is a 'virtual' feature record that conda adds to the index for the solver
+                # and should be ignored here
+                continue
+
+            version = prec["version"]
+            log.info("Testing %s=%s", name, version)
+
+            try:
+                check_install(
+                    [f"{name}={version}"],
+                    channel_urls=[channel],
+                    prepend=False,
+                    subdir=subdir,
+                )
+            except Exception as err:
+                success = False
+                log.error(
+                    "[%s/%s::%s=%s] %s",
+                    channel,
+                    subdir,
+                    name,
+                    version,
+                    repr(err),
+                )
+    return success
+
+
+def _underlined_text(text):
+    return str(text) + "\n" + "-" * len(str(text)) + "\n\n"
+
+
+def inspect_linkages(
+    packages: Iterable[str | _untracked_package],
+    prefix: str | os.PathLike | Path = sys.prefix,
+    untracked: bool = False,
+    all_packages: bool = False,
+    show_files: bool = False,
+    groupby: Literal["package" | "dependency"] = "package",
+    sysroot="",
+):
+    if not packages and not untracked and not all_packages:
+        sys.exit("At least one package or --untracked or --all must be provided")
+    elif on_win:
+        sys.exit("Error: conda inspect linkages is only implemented in Linux and OS X")
+
+    prefix = Path(prefix)
+    installed = {prec.name: prec for prec in PrefixData(str(prefix)).iter_records()}
+
+    if all_packages:
+        packages = sorted(installed.keys())
+    packages = ensure_list(packages)
+    if untracked:
+        packages.append(untracked_package)
+
+    pkgmap: dict[str | _untracked_package, dict[str, list]] = {}
+    for name in packages:
+        if name == untracked_package:
+            obj_files = get_untracked_obj_files(prefix)
+        elif name not in installed:
+            sys.exit(f"Package {name} is not installed in {prefix}")
+        else:
+            obj_files = get_package_obj_files(installed[name], prefix)
+
+        linkages = get_linkages(obj_files, prefix, sysroot)
+        pkgmap[name] = depmap = defaultdict(list)
+        for binary, paths in linkages.items():
+            for lib, path in paths:
+                path = (
+                    replace_path(binary, path, prefix)
+                    if path not in {"", "not found"}
+                    else path
+                )
+                try:
+                    relative = str(Path(path).relative_to(prefix))
+                except ValueError:
+                    # ValueError: path is not relative to prefix
+                    relative = None
+                if relative:
+                    precs = list(which_package(relative, prefix))
+                    if len(precs) > 1:
+                        get_logger(__name__).warn(
+                            "Warning: %s comes from multiple packages: %s",
+                            path,
+                            comma_join(map(str, precs)),
+                        )
+                    elif not precs:
+                        if exists(path):
+                            depmap["untracked"].append((lib, relative, binary))
+                        else:
+                            depmap["not found"].append((lib, relative, binary))
+                    for prec in precs:
+                        depmap[prec].append((lib, relative, binary))
+                elif path == "not found":
+                    depmap["not found"].append((lib, path, binary))
+                else:
+                    depmap["system"].append((lib, path, binary))
+
+    output_string = ""
+    if groupby == "package":
+        for pkg in packages:
+            output_string += _underlined_text(pkg)
+            output_string += print_linkages(pkgmap[pkg], show_files=show_files)
+
+    elif groupby == "dependency":
+        # {pkg: {dep: [files]}} -> {dep: {pkg: [files]}}
+        inverted_map = defaultdict(lambda: defaultdict(list))
+        for pkg in pkgmap:
+            for dep in pkgmap[pkg]:
+                if pkgmap[pkg][dep]:
+                    inverted_map[dep][pkg] = pkgmap[pkg][dep]
+
+        # print system and not found last
+        k = sorted(set(inverted_map.keys()) - {"system", "not found"})
+        for dep in k + ["system", "not found"]:
+            output_string += _underlined_text(dep)
+            output_string += print_linkages(inverted_map[dep], show_files=show_files)
+
+    else:
+        raise ValueError("Unrecognized groupby: %s" % groupby)
+    if hasattr(output_string, "decode"):
+        output_string = output_string.decode("utf-8")
+    return output_string
+
+
+def inspect_objects(
+    packages: Iterable[str],
+    prefix: str | os.PathLike | Path = sys.prefix,
+    groupby: str = "package",
+):
+    if not on_mac:
+        sys.exit("Error: conda inspect objects is only implemented in OS X")
+
+    prefix = Path(prefix)
+    installed = {prec.name: prec for prec in PrefixData(str(prefix)).iter_records()}
+
+    output_string = ""
+    for name in ensure_list(packages):
+        if name == untracked_package:
+            obj_files = get_untracked_obj_files(prefix)
+        elif name not in installed:
+            raise ValueError(f"Package {name} is not installed in {prefix}")
+        else:
+            obj_files = get_package_obj_files(installed[name], prefix)
+
+        output_string += _underlined_text(name)
+
+        info = []
+        for f in obj_files:
+            path = join(prefix, f)
+            codefile = codefile_class(path, skip_symlinks=True)
+            if codefile == machofile:
+                info.append(
+                    {
+                        "filetype": human_filetype(path, None),
+                        "rpath": ":".join(get_rpaths(path)),
+                        "filename": f,
+                    }
+                )
+
+        output_string += print_object_info(info, groupby)
+    if hasattr(output_string, "decode"):
+        output_string = output_string.decode("utf-8")
+    return output_string
+
+
+def get_hash_input(packages):
+    hash_inputs = {}
+    for pkg in ensure_list(packages):
+        pkgname = os.path.basename(pkg)
+        hash_inputs[pkgname] = {}
+        hash_input = package_has_file(pkg, "info/hash_input.json")
+        if hash_input:
+            hash_inputs[pkgname]["recipe"] = json.loads(hash_input)
+        else:
+            hash_inputs[pkgname] = "<no hash_input.json in file>"
+
+    return hash_inputs

shared/package-files/74/740d6bff1586f7434d0efb47a6bd7527135409cfc4ed0a08120a1498c2efadd7/test_page.py

@@ -0,0 +1,20 @@
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2010-2011 The IPython Development Team.
+#
+#  Distributed under the terms of the BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+import io
+
+# N.B. For the test suite, page.page is overridden (see IPython.testing.globalipapp)
+from IPython.core import page
+
+def test_detect_screen_size():
+    """Simple smoketest for page._detect_screen_size."""
+    try:
+        page._detect_screen_size(True, 25)
+    except (TypeError, io.UnsupportedOperation):
+        # This can happen in the test suite, because stdout may not have a
+        # fileno.
+        pass

shared/package-files/74/74215f00e53cb2cf1fcbb5fa28d3c206789cdb1c98ce3510b66b0397734ba4c4/_native_batch_norm_legit.h

@@ -0,0 +1,58 @@
+#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/_native_batch_norm_legit_ops.h>
+
+namespace at {
+
+
+// aten::_native_batch_norm_legit(Tensor input, Tensor? weight, Tensor? bias, Tensor(a!) running_mean, Tensor(b!) running_var, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor)
+inline ::std::tuple<at::Tensor,at::Tensor,at::Tensor> _native_batch_norm_legit(const at::Tensor & input, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, at::Tensor & running_mean, at::Tensor & running_var, bool training, double momentum, double eps) {
+    return at::_ops::_native_batch_norm_legit::call(input, weight, bias, running_mean, running_var, training, momentum, eps);
+}
+
+// aten::_native_batch_norm_legit.out(Tensor input, Tensor? weight, Tensor? bias, Tensor(a!) running_mean, Tensor(b!) running_var, bool training, float momentum, float eps, *, Tensor(d!) out, Tensor(e!) save_mean, Tensor(f!) save_invstd) -> (Tensor(d!), Tensor(e!), Tensor(f!))
+inline ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _native_batch_norm_legit_out(at::Tensor & out, at::Tensor & save_mean, at::Tensor & save_invstd, const at::Tensor & input, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, at::Tensor & running_mean, at::Tensor & running_var, bool training, double momentum, double eps) {
+    return at::_ops::_native_batch_norm_legit_out::call(input, weight, bias, running_mean, running_var, training, momentum, eps, out, save_mean, save_invstd);
+}
+// aten::_native_batch_norm_legit.out(Tensor input, Tensor? weight, Tensor? bias, Tensor(a!) running_mean, Tensor(b!) running_var, bool training, float momentum, float eps, *, Tensor(d!) out, Tensor(e!) save_mean, Tensor(f!) save_invstd) -> (Tensor(d!), Tensor(e!), Tensor(f!))
+inline ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _native_batch_norm_legit_outf(const at::Tensor & input, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, at::Tensor & running_mean, at::Tensor & running_var, bool training, double momentum, double eps, at::Tensor & out, at::Tensor & save_mean, at::Tensor & save_invstd) {
+    return at::_ops::_native_batch_norm_legit_out::call(input, weight, bias, running_mean, running_var, training, momentum, eps, out, save_mean, save_invstd);
+}
+
+// aten::_native_batch_norm_legit.no_stats(Tensor input, Tensor? weight, Tensor? bias, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor)
+inline ::std::tuple<at::Tensor,at::Tensor,at::Tensor> _native_batch_norm_legit(const at::Tensor & input, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, bool training, double momentum, double eps) {
+    return at::_ops::_native_batch_norm_legit_no_stats::call(input, weight, bias, training, momentum, eps);
+}
+
+// aten::_native_batch_norm_legit.no_stats_out(Tensor input, Tensor? weight, Tensor? bias, bool training, float momentum, float eps, *, Tensor(a!) out, Tensor(b!) save_mean, Tensor(c!) save_invstd) -> (Tensor(a!), Tensor(b!), Tensor(c!))
+inline ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _native_batch_norm_legit_out(at::Tensor & out, at::Tensor & save_mean, at::Tensor & save_invstd, const at::Tensor & input, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, bool training, double momentum, double eps) {
+    return at::_ops::_native_batch_norm_legit_no_stats_out::call(input, weight, bias, training, momentum, eps, out, save_mean, save_invstd);
+}
+// aten::_native_batch_norm_legit.no_stats_out(Tensor input, Tensor? weight, Tensor? bias, bool training, float momentum, float eps, *, Tensor(a!) out, Tensor(b!) save_mean, Tensor(c!) save_invstd) -> (Tensor(a!), Tensor(b!), Tensor(c!))
+inline ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _native_batch_norm_legit_outf(const at::Tensor & input, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, bool training, double momentum, double eps, at::Tensor & out, at::Tensor & save_mean, at::Tensor & save_invstd) {
+    return at::_ops::_native_batch_norm_legit_no_stats_out::call(input, weight, bias, training, momentum, eps, out, save_mean, save_invstd);
+}
+
+// aten::_native_batch_norm_legit_functional(Tensor input, Tensor? weight, Tensor? bias, Tensor running_mean, Tensor running_var, bool training, float momentum, float eps) -> (Tensor, Tensor, Tensor, Tensor running_mean_out, Tensor running_var_out)
+inline ::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor> _native_batch_norm_legit_functional(const at::Tensor & input, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, const at::Tensor & running_mean, const at::Tensor & running_var, bool training, double momentum, double eps) {
+    return at::_ops::_native_batch_norm_legit_functional::call(input, weight, bias, running_mean, running_var, training, momentum, eps);
+}
+
+}

shared/package-files/74/7435b58c6e505b4ad84566f3966050f0f4f6bfd65d5a0149d0844786f0494324/__init__.pyi

@@ -0,0 +1,24 @@
+from .general import (
+    ArrayAgg as ArrayAgg,
+    BitAnd as BitAnd,
+    BitOr as BitOr,
+    BoolAnd as BoolAnd,
+    BoolOr as BoolOr,
+    JSONBAgg as JSONBAgg,
+    StringAgg as StringAgg,
+)
+
+from .statistics import (
+    Corr as Corr,
+    CovarPop as CovarPop,
+    RegrAvgX as RegrAvgX,
+    RegrAvgY as RegrAvgY,
+    RegrCount as RegrCount,
+    RegrIntercept as RegrIntercept,
+    RegrR2 as RegrR2,
+    RegrSlope as RegrSlope,
+    RegrSXX as RegrSXX,
+    RegrSXY as RegrSXY,
+    RegrSYY as RegrSYY,
+    StatAggregate as StatAggregate,
+)

shared/package-files/74/7435f850d700fce2f0a7c1821c704b5717494b767a62c815be2fbe57cc610074/special_erfinv.h

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

shared/package-files/74/743857b19d6f384a0e30a0f691b06b04fe8e33a419c4596ae57c6ddba8740e08/reciprocal_cpu_dispatch.h

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

shared/package-files/74/743d6cd7703766653ad5d97023d063c0bba212eb748ef0d54b76af8b863afc20/test_numba.py

@@ -0,0 +1,129 @@
+import numpy as np
+import pytest
+
+from pandas.compat import is_platform_arm
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+)
+import pandas._testing as tm
+from pandas.util.version import Version
+
+pytestmark = [td.skip_if_no("numba"), pytest.mark.single_cpu, pytest.mark.skipif()]
+
+numba = pytest.importorskip("numba")
+pytestmark.append(
+    pytest.mark.skipif(
+        Version(numba.__version__) == Version("0.61") and is_platform_arm(),
+        reason=f"Segfaults on ARM platforms with numba {numba.__version__}",
+    )
+)
+
+
+@pytest.fixture(params=[0, 1])
+def apply_axis(request):
+    return request.param
+
+
+def test_numba_vs_python_noop(float_frame, apply_axis):
+    func = lambda x: x
+    result = float_frame.apply(func, engine="numba", axis=apply_axis)
+    expected = float_frame.apply(func, engine="python", axis=apply_axis)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_numba_vs_python_string_index():
+    # GH#56189
+    df = DataFrame(
+        1,
+        index=Index(["a", "b"], dtype=pd.StringDtype(na_value=np.nan)),
+        columns=Index(["x", "y"], dtype=pd.StringDtype(na_value=np.nan)),
+    )
+    func = lambda x: x
+    result = df.apply(func, engine="numba", axis=0)
+    expected = df.apply(func, engine="python", axis=0)
+    tm.assert_frame_equal(
+        result, expected, check_column_type=False, check_index_type=False
+    )
+
+
+def test_numba_vs_python_indexing():
+    frame = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": [7.0, 8.0, 9.0]},
+        index=Index(["A", "B", "C"]),
+    )
+    row_func = lambda x: x["c"]
+    result = frame.apply(row_func, engine="numba", axis=1)
+    expected = frame.apply(row_func, engine="python", axis=1)
+    tm.assert_series_equal(result, expected)
+
+    col_func = lambda x: x["A"]
+    result = frame.apply(col_func, engine="numba", axis=0)
+    expected = frame.apply(col_func, engine="python", axis=0)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "reduction",
+    [lambda x: x.mean(), lambda x: x.min(), lambda x: x.max(), lambda x: x.sum()],
+)
+def test_numba_vs_python_reductions(reduction, apply_axis):
+    df = DataFrame(np.ones((4, 4), dtype=np.float64))
+    result = df.apply(reduction, engine="numba", axis=apply_axis)
+    expected = df.apply(reduction, engine="python", axis=apply_axis)
+    tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("colnames", [[1, 2, 3], [1.0, 2.0, 3.0]])
+def test_numba_numeric_colnames(colnames):
+    # Check that numeric column names lower properly and can be indxed on
+    df = DataFrame(
+        np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.int64), columns=colnames
+    )
+    first_col = colnames[0]
+    f = lambda x: x[first_col]  # Get the first column
+    result = df.apply(f, engine="numba", axis=1)
+    expected = df.apply(f, engine="python", axis=1)
+    tm.assert_series_equal(result, expected)
+
+
+def test_numba_parallel_unsupported(float_frame):
+    f = lambda x: x
+    with pytest.raises(
+        NotImplementedError,
+        match="Parallel apply is not supported when raw=False and engine='numba'",
+    ):
+        float_frame.apply(f, engine="numba", engine_kwargs={"parallel": True})
+
+
+def test_numba_nonunique_unsupported(apply_axis):
+    f = lambda x: x
+    df = DataFrame({"a": [1, 2]}, index=Index(["a", "a"]))
+    with pytest.raises(
+        NotImplementedError,
+        match="The index/columns must be unique when raw=False and engine='numba'",
+    ):
+        df.apply(f, engine="numba", axis=apply_axis)
+
+
+def test_numba_unsupported_dtypes(apply_axis):
+    pytest.importorskip("pyarrow")
+    f = lambda x: x
+    df = DataFrame({"a": [1, 2], "b": ["a", "b"], "c": [4, 5]})
+    df["c"] = df["c"].astype("double[pyarrow]")
+
+    with pytest.raises(
+        ValueError,
+        match="Column b must have a numeric dtype. Found 'object|str' instead",
+    ):
+        df.apply(f, engine="numba", axis=apply_axis)
+
+    with pytest.raises(
+        ValueError,
+        match="Column c is backed by an extension array, "
+        "which is not supported by the numba engine.",
+    ):
+        df["c"].to_frame().apply(f, engine="numba", axis=apply_axis)

shared/package-files/74/7449d4c5166158cf346487d0dfd70bcf3251376c76576582fadddcb8560c5443/dependencies.py

@@ -0,0 +1,818 @@
+# pandas / Polars / etc. : if a user passes a dataframe from one of these
+# libraries, it means they must already have imported the given module.
+# So, we can just check sys.modules.
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, Any
+
+from narwhals._exceptions import issue_warning
+
+if TYPE_CHECKING:
+    from typing import TypeGuard
+
+    import cudf
+    import dask.dataframe as dd
+    import duckdb
+    import ibis
+    import modin.pandas as mpd
+    import pandas as pd
+    import polars as pl
+    import pyarrow as pa
+    import pyspark.sql as pyspark_sql
+    from pyspark.sql.connect.dataframe import DataFrame as PySparkConnectDataFrame
+    from typing_extensions import TypeIs
+
+    from narwhals._spark_like.dataframe import SQLFrameDataFrame
+    from narwhals.dataframe import DataFrame, LazyFrame
+    from narwhals.series import Series
+    from narwhals.typing import (
+        IntoDataFrameT,
+        IntoLazyFrameT,
+        IntoSeriesT,
+        PandasLikeDType,
+        _1DArray,
+        _1DArrayInt,
+        _2DArray,
+        _NDArray,
+        _NumpyScalar,
+        _ShapeT,
+    )
+
+
+# We silently allow these but - given that they claim
+# to be drop-in replacements for pandas - testing is
+# their responsibility.
+IMPORT_HOOKS = frozenset(["fireducks"])
+
+
+def get_polars() -> Any:
+    """Get Polars module (if already imported - else return None)."""
+    return sys.modules.get("polars", None)
+
+
+def get_pandas() -> Any:
+    """Get pandas module (if already imported - else return None)."""
+    return sys.modules.get("pandas", None)
+
+
+def get_modin() -> Any:  # pragma: no cover
+    """Get modin.pandas module (if already imported - else return None)."""
+    return sys.modules.get("modin.pandas", None)
+
+
+def get_cudf() -> Any:
+    """Get cudf module (if already imported - else return None)."""
+    return sys.modules.get("cudf", None)
+
+
+def get_cupy() -> Any:
+    """Get cupy module (if already imported - else return None)."""
+    return sys.modules.get("cupy", None)
+
+
+def get_pyarrow() -> Any:  # pragma: no cover
+    """Get pyarrow module (if already imported - else return None)."""
+    return sys.modules.get("pyarrow", None)
+
+
+def get_numpy() -> Any:
+    """Get numpy module (if already imported - else return None)."""
+    return sys.modules.get("numpy", None)
+
+
+def get_dask() -> Any:  # pragma: no cover
+    """Get dask (if already imported - else return None)."""
+    return sys.modules.get("dask", None)
+
+
+def get_dask_dataframe() -> Any:
+    """Get dask.dataframe module (if already imported - else return None)."""
+    return sys.modules.get("dask.dataframe", None)
+
+
+def get_duckdb() -> Any:
+    """Get duckdb module (if already imported - else return None)."""
+    return sys.modules.get("duckdb", None)
+
+
+def get_ibis() -> Any:
+    """Get ibis module (if already imported - else return None)."""
+    return sys.modules.get("ibis", None)
+
+
+def get_dask_expr() -> Any:  # pragma: no cover
+    """Get dask_expr module (if already imported - else return None)."""
+    if (dd := get_dask_dataframe()) is not None and hasattr(dd, "dask_expr"):
+        return dd.dask_expr
+    return sys.modules.get("dask_expr", None)
+
+
+def get_pyspark() -> Any:  # pragma: no cover
+    """Get pyspark module (if already imported - else return None)."""
+    return sys.modules.get("pyspark", None)
+
+
+def get_pyspark_sql() -> Any:
+    """Get pyspark.sql module (if already imported - else return None)."""
+    return sys.modules.get("pyspark.sql", None)
+
+
+def get_pyspark_connect() -> Any:
+    """Get pyspark.sql.connect module (if already imported - else return None)."""
+    return sys.modules.get("pyspark.sql.connect", None)
+
+
+def get_sqlframe() -> Any:
+    """Get sqlframe module (if already imported - else return None)."""
+    return sys.modules.get("sqlframe", None)
+
+
+def _warn_if_narwhals_df_or_lf(frame: Any, /) -> None:
+    if is_narwhals_dataframe(frame) or is_narwhals_lazyframe(frame):
+        from narwhals._utils import qualified_type_name
+
+        caller = sys._getframe(1).f_code.co_name
+        msg = (
+            f"You passed a `{qualified_type_name(frame)}` to `{caller}`.\n\n"
+            f"Hint: Instead of e.g. `{caller}(frame)`, "
+            f"did you mean `{caller}(frame.to_native())`?"
+        )
+        issue_warning(msg, UserWarning)
+
+
+def _warn_if_narwhals_series(ser: Any, /) -> None:
+    if is_narwhals_series(ser):
+        from narwhals._utils import qualified_type_name
+
+        caller = sys._getframe(1).f_code.co_name
+        msg = (
+            f"You passed a `{qualified_type_name(ser)}` to `{caller}`.\n\n"
+            f"Hint: Instead of e.g. `{caller}(ser)`, "
+            f"did you mean `{caller}(ser.to_native())`?"
+        )
+        issue_warning(msg, UserWarning)
+
+
+def _is_pandas_dataframe(df: Any) -> TypeIs[pd.DataFrame]:
+    """Check whether `df` is a pandas DataFrame without importing pandas."""
+    return ((pd := get_pandas()) is not None and isinstance(df, pd.DataFrame)) or any(
+        (mod := sys.modules.get(module_name, None)) is not None
+        and isinstance(df, mod.pandas.DataFrame)
+        for module_name in IMPORT_HOOKS
+    )
+
+
+def is_pandas_dataframe(df: Any) -> TypeIs[pd.DataFrame]:
+    """Check whether `df` is a pandas DataFrame without importing pandas.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_pandas_dataframe(df)
+
+
+def _is_pandas_series(ser: Any) -> TypeIs[pd.Series[Any]]:
+    """Check whether `ser` is a pandas Series without importing pandas."""
+    return ((pd := get_pandas()) is not None and isinstance(ser, pd.Series)) or any(
+        (mod := sys.modules.get(module_name, None)) is not None
+        and isinstance(ser, mod.pandas.Series)
+        for module_name in IMPORT_HOOKS
+    )
+
+
+def is_pandas_series(ser: Any) -> TypeIs[pd.Series[Any]]:
+    """Check whether `ser` is a pandas Series without importing pandas.
+
+    Warning:
+        This method cannot be called on Narwhals Series.
+    """
+    _warn_if_narwhals_series(ser)
+    return _is_pandas_series(ser)
+
+
+def is_pandas_index(index: Any) -> TypeIs[pd.Index[Any]]:
+    """Check whether `index` is a pandas Index without importing pandas."""
+    return ((pd := get_pandas()) is not None and isinstance(index, pd.Index)) or any(
+        (mod := sys.modules.get(module_name, None)) is not None
+        and isinstance(index, mod.pandas.Index)
+        for module_name in IMPORT_HOOKS
+    )
+
+
+def _is_modin_dataframe(df: Any) -> TypeIs[mpd.DataFrame]:
+    """Check whether `df` is a modin DataFrame without importing modin."""
+    return (mpd := get_modin()) is not None and isinstance(df, mpd.DataFrame)
+
+
+def is_modin_dataframe(df: Any) -> TypeIs[mpd.DataFrame]:
+    """Check whether `df` is a modin DataFrame without importing modin.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_modin_dataframe(df)
+
+
+def _is_modin_series(ser: Any) -> TypeIs[mpd.Series]:
+    """Check whether `ser` is a modin Series without importing modin."""
+    return (mpd := get_modin()) is not None and isinstance(ser, mpd.Series)
+
+
+def is_modin_series(ser: Any) -> TypeIs[mpd.Series]:
+    """Check whether `ser` is a modin Series without importing modin.
+
+    Warning:
+        This method cannot be called on Narwhals Series.
+    """
+    _warn_if_narwhals_series(ser)
+    return _is_modin_series(ser)
+
+
+def is_modin_index(index: Any) -> TypeIs[mpd.Index[Any]]:  # pragma: no cover
+    """Check whether `index` is a modin Index without importing modin."""
+    return (mpd := get_modin()) is not None and isinstance(index, mpd.Index)
+
+
+def _is_cudf_dataframe(df: Any) -> TypeIs[cudf.DataFrame]:
+    """Check whether `df` is a cudf DataFrame without importing cudf."""
+    return (cudf := get_cudf()) is not None and isinstance(df, cudf.DataFrame)
+
+
+def is_cudf_dataframe(df: Any) -> TypeIs[cudf.DataFrame]:
+    """Check whether `df` is a cudf DataFrame without importing cudf.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_cudf_dataframe(df)
+
+
+def _is_cudf_series(ser: Any) -> TypeIs[cudf.Series[Any]]:
+    """Check whether `ser` is a cudf Series without importing cudf."""
+    return (cudf := get_cudf()) is not None and isinstance(ser, cudf.Series)
+
+
+def is_cudf_series(ser: Any) -> TypeIs[cudf.Series[Any]]:
+    """Check whether `ser` is a cudf Series without importing cudf.
+
+    Warning:
+        This method cannot be called on Narwhals Series.
+    """
+    _warn_if_narwhals_series(ser)
+    return _is_cudf_series(ser)
+
+
+def is_cudf_index(index: Any) -> TypeIs[cudf.Index]:
+    """Check whether `index` is a cudf Index without importing cudf."""
+    return (cudf := get_cudf()) is not None and isinstance(
+        index, cudf.Index
+    )  # pragma: no cover
+
+
+def is_cupy_scalar(obj: Any) -> bool:
+    return (
+        (cupy := get_cupy()) is not None
+        and isinstance(obj, cupy.ndarray)
+        and obj.size == 1
+    )  # pragma: no cover
+
+
+def _is_dask_dataframe(df: Any) -> TypeIs[dd.DataFrame]:
+    """Check whether `df` is a Dask DataFrame without importing Dask."""
+    return (dd := get_dask_dataframe()) is not None and isinstance(df, dd.DataFrame)
+
+
+def is_dask_dataframe(df: Any) -> TypeIs[dd.DataFrame]:
+    """Check whether `df` is a Dask DataFrame without importing Dask.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_dask_dataframe(df)
+
+
+def _is_duckdb_relation(df: Any) -> TypeIs[duckdb.DuckDBPyRelation]:
+    """Check whether `df` is a DuckDB Relation without importing DuckDB."""
+    return (duckdb := get_duckdb()) is not None and isinstance(
+        df, duckdb.DuckDBPyRelation
+    )
+
+
+def is_duckdb_relation(df: Any) -> TypeIs[duckdb.DuckDBPyRelation]:
+    """Check whether `df` is a DuckDB Relation without importing DuckDB.
+
+    Warning:
+        This method cannot be called on Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_duckdb_relation(df)
+
+
+def _is_ibis_table(df: Any) -> TypeIs[ibis.Table]:
+    """Check whether `df` is a Ibis Table without importing Ibis."""
+    return (ibis := get_ibis()) is not None and isinstance(df, ibis.expr.types.Table)
+
+
+def is_ibis_table(df: Any) -> TypeIs[ibis.Table]:
+    """Check whether `df` is a Ibis Table without importing Ibis.
+
+    Warning:
+        This method cannot be called on Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_ibis_table(df)
+
+
+def _is_polars_dataframe(df: Any) -> TypeIs[pl.DataFrame]:
+    """Check whether `df` is a Polars DataFrame without importing Polars."""
+    return (pl := get_polars()) is not None and isinstance(df, pl.DataFrame)
+
+
+def is_polars_dataframe(df: Any) -> TypeIs[pl.DataFrame]:
+    """Check whether `df` is a Polars DataFrame without importing Polars.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_polars_dataframe(df)
+
+
+def _is_polars_lazyframe(df: Any) -> TypeIs[pl.LazyFrame]:
+    """Check whether `df` is a Polars LazyFrame without importing Polars."""
+    return (pl := get_polars()) is not None and isinstance(df, pl.LazyFrame)
+
+
+def is_polars_lazyframe(df: Any) -> TypeIs[pl.LazyFrame]:
+    """Check whether `df` is a Polars LazyFrame without importing Polars.
+
+    Warning:
+        This method cannot be called on Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_polars_lazyframe(df)
+
+
+def _is_polars_series(ser: Any) -> TypeIs[pl.Series]:
+    """Check whether `ser` is a Polars Series without importing Polars."""
+    return (pl := get_polars()) is not None and isinstance(ser, pl.Series)
+
+
+def is_polars_series(ser: Any) -> TypeIs[pl.Series]:
+    """Check whether `ser` is a Polars Series without importing Polars.
+
+    Warning:
+        This method cannot be called on Narwhals Series.
+    """
+    _warn_if_narwhals_series(ser)
+    return _is_polars_series(ser)
+
+
+def is_polars_schema(obj: Any) -> TypeIs[pl.Schema]:
+    return (
+        bool(pl := get_polars()) and hasattr(pl, "Schema") and isinstance(obj, pl.Schema)
+    )
+
+
+# NOTE: For `pl.Schema` only instantiated dtypes are expected
+def is_polars_data_type(obj: Any) -> TypeIs[pl.DataType]:
+    return bool(pl := get_polars()) and isinstance(obj, pl.DataType)
+
+
+def _is_pyarrow_chunked_array(ser: Any) -> TypeIs[pa.ChunkedArray[Any]]:
+    """Check whether `ser` is a PyArrow ChunkedArray without importing PyArrow."""
+    return (pa := get_pyarrow()) is not None and isinstance(ser, pa.ChunkedArray)
+
+
+def is_pyarrow_chunked_array(ser: Any) -> TypeIs[pa.ChunkedArray[Any]]:
+    """Check whether `ser` is a PyArrow ChunkedArray without importing PyArrow.
+
+    Warning:
+        This method cannot be called on Narwhals Series.
+    """
+    _warn_if_narwhals_series(ser)
+    return _is_pyarrow_chunked_array(ser)
+
+
+def _is_pyarrow_table(df: Any) -> TypeIs[pa.Table]:
+    """Check whether `df` is a PyArrow Table without importing PyArrow."""
+    return (pa := get_pyarrow()) is not None and isinstance(df, pa.Table)
+
+
+def is_pyarrow_table(df: Any) -> TypeIs[pa.Table]:
+    """Check whether `df` is a PyArrow Table without importing PyArrow.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_pyarrow_table(df)
+
+
+def is_pyarrow_scalar(obj: Any) -> TypeIs[pa.Scalar[Any]]:
+    return (pa := get_pyarrow()) is not None and isinstance(obj, pa.Scalar)
+
+
+def is_pyarrow_schema(obj: Any) -> TypeIs[pa.Schema]:
+    return bool(pa := get_pyarrow()) and isinstance(obj, pa.Schema)
+
+
+def is_pyarrow_data_type(obj: Any) -> TypeIs[pa.DataType]:
+    return bool(pa := get_pyarrow()) and isinstance(obj, pa.DataType)
+
+
+def _is_pyspark_dataframe(df: Any) -> TypeIs[pyspark_sql.DataFrame]:
+    """Check whether `df` is a PySpark DataFrame without importing PySpark."""
+    return bool(
+        (pyspark_sql := get_pyspark_sql()) is not None
+        and isinstance(df, pyspark_sql.DataFrame)
+    )
+
+
+def is_pyspark_dataframe(df: Any) -> TypeIs[pyspark_sql.DataFrame]:
+    """Check whether `df` is a PySpark DataFrame without importing PySpark.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_pyspark_dataframe(df)
+
+
+def _is_pyspark_connect_dataframe(df: Any) -> TypeIs[PySparkConnectDataFrame]:
+    """Check whether `df` is a PySpark Connect DataFrame without importing PySpark."""
+    if get_pyspark_connect() is not None:  # pragma: no cover
+        try:
+            from pyspark.sql.connect.dataframe import DataFrame
+        except ImportError:
+            return False
+        return isinstance(df, DataFrame)
+    return False
+
+
+def is_pyspark_connect_dataframe(df: Any) -> TypeIs[PySparkConnectDataFrame]:
+    """Check whether `df` is a PySpark Connect DataFrame without importing PySpark.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_pyspark_connect_dataframe(df)
+
+
+def _is_sqlframe_dataframe(df: Any) -> TypeIs[SQLFrameDataFrame]:
+    """Check whether `df` is a SQLFrame DataFrame without importing SQLFrame."""
+    if get_sqlframe() is not None:
+        from sqlframe.base.dataframe import BaseDataFrame
+
+        return isinstance(df, BaseDataFrame)
+    return False  # pragma: no cover
+
+
+def is_sqlframe_dataframe(df: Any) -> TypeIs[SQLFrameDataFrame]:
+    """Check whether `df` is a SQLFrame DataFrame without importing SQLFrame.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_sqlframe_dataframe(df)
+
+
+def is_numpy_array(arr: Any | _NDArray[_ShapeT]) -> TypeIs[_NDArray[_ShapeT]]:
+    """Check whether `arr` is a NumPy Array without importing NumPy."""
+    return (np := get_numpy()) is not None and isinstance(arr, np.ndarray)
+
+
+def is_numpy_array_1d(arr: Any) -> TypeIs[_1DArray]:
+    """Check whether `arr` is a 1D NumPy Array without importing NumPy."""
+    return is_numpy_array(arr) and arr.ndim == 1
+
+
+def is_numpy_array_1d_int(arr: Any) -> TypeIs[_1DArrayInt]:
+    return (
+        (np := get_numpy())
+        and is_numpy_array_1d(arr)
+        and np.issubdtype(arr.dtype, np.integer)
+    )
+
+
+def is_numpy_array_1d_bool(arr: Any) -> TypeIs[_1DArrayInt]:
+    return (
+        (np := get_numpy())
+        and is_numpy_array_1d(arr)
+        and np.issubdtype(arr.dtype, np.bool_)
+    )
+
+
+def is_numpy_array_2d(arr: Any) -> TypeIs[_2DArray]:
+    """Check whether `arr` is a 2D NumPy Array without importing NumPy."""
+    return is_numpy_array(arr) and arr.ndim == 2
+
+
+def is_numpy_scalar(scalar: Any) -> TypeGuard[_NumpyScalar]:
+    """Check whether `scalar` is a NumPy Scalar without importing NumPy."""
+    # NOTE: Needs to stay as `TypeGuard`
+    # - Used in `Series.__getitem__`, but not annotated
+    # - `TypeGuard` is *hiding* that the check introduces an intersection
+    return (np := get_numpy()) is not None and isinstance(scalar, np.generic)
+
+
+def _is_pandas_like_dataframe(df: Any) -> bool:
+    """Check whether `df` is a pandas-like DataFrame without doing any imports.
+
+    By "pandas-like", we mean: pandas, Modin, cuDF.
+    """
+    return _is_pandas_dataframe(df) or _is_modin_dataframe(df) or _is_cudf_dataframe(df)
+
+
+def is_pandas_like_dataframe(df: Any) -> bool:
+    """Check whether `df` is a pandas-like DataFrame without doing any imports.
+
+    By "pandas-like", we mean: pandas, Modin, cuDF.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return _is_pandas_like_dataframe(df)
+
+
+def _is_pandas_like_series(ser: Any) -> bool:
+    """Check whether `ser` is a pandas-like Series without doing any imports.
+
+    By "pandas-like", we mean: pandas, Modin, cuDF.
+    """
+    return _is_pandas_series(ser) or _is_modin_series(ser) or _is_cudf_series(ser)
+
+
+def is_pandas_like_series(ser: Any) -> bool:
+    """Check whether `ser` is a pandas-like Series without doing any imports.
+
+    By "pandas-like", we mean: pandas, Modin, cuDF.
+
+    Warning:
+        This method cannot be called on Narwhals Series.
+    """
+    _warn_if_narwhals_series(ser)
+    return _is_pandas_like_series(ser)
+
+
+def is_pandas_like_index(index: Any) -> bool:
+    """Check whether `index` is a pandas-like Index without doing any imports.
+
+    By "pandas-like", we mean: pandas, Modin, cuDF.
+    """
+    return (
+        is_pandas_index(index) or is_modin_index(index) or is_cudf_index(index)
+    )  # pragma: no cover
+
+
+def is_pandas_like_dtype(obj: Any) -> TypeIs[PandasLikeDType]:
+    return bool(pd := get_pandas()) and isinstance(
+        obj, (pd.api.extensions.ExtensionDtype, get_numpy().dtype)
+    )
+
+
+def is_cudf_dtype(
+    obj: Any,
+) -> TypeIs[pd.api.extensions.ExtensionDtype]:  # pragma: no cover
+    return (
+        bool(pd := get_pandas())
+        and isinstance(obj, (pd.api.extensions.ExtensionDtype))
+        and hasattr(obj, "to_arrow")
+    )
+
+
+def _is_native_series(obj: Any | IntoSeriesT) -> TypeIs[IntoSeriesT]:
+    from narwhals import plugins
+    from narwhals._utils import _hasattr_static
+
+    return (
+        _hasattr_static(obj, "__narwhals_series__")
+        or _is_polars_series(obj)
+        or _is_pyarrow_chunked_array(obj)
+        or _is_pandas_like_series(obj)
+        or plugins.is_native_series(obj)
+    )
+
+
+def _is_native_dataframe(obj: Any | IntoDataFrameT) -> TypeIs[IntoDataFrameT]:
+    from narwhals import plugins
+    from narwhals._utils import _hasattr_static
+
+    return (
+        _hasattr_static(obj, "__narwhals_dataframe__")
+        or _is_polars_dataframe(obj)
+        or _is_pyarrow_table(obj)
+        or _is_pandas_like_dataframe(obj)
+        or plugins.is_native_dataframe(obj)
+    )
+
+
+def _is_native_lazyframe(obj: Any | IntoLazyFrameT) -> TypeIs[IntoLazyFrameT]:
+    from narwhals import plugins
+    from narwhals._utils import _hasattr_static
+
+    return (
+        _hasattr_static(obj, "__narwhals_lazyframe__")
+        or _is_polars_lazyframe(obj)
+        or _is_dask_dataframe(obj)
+        or _is_duckdb_relation(obj)
+        or _is_ibis_table(obj)
+        or _is_pyspark_dataframe(obj)
+        or _is_pyspark_connect_dataframe(obj)
+        or _is_sqlframe_dataframe(obj)
+        or plugins.is_native_lazyframe(obj)
+    )
+
+
+def is_into_series(native_series: Any | IntoSeriesT) -> TypeIs[IntoSeriesT]:
+    """Check whether `native_series` can be converted to a Narwhals Series.
+
+    Arguments:
+        native_series: The object to check.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import polars as pl
+        >>> import numpy as np
+        >>> import narwhals as nw
+
+        >>> s_pd = pd.Series([1, 2, 3])
+        >>> s_pl = pl.Series([1, 2, 3])
+        >>> np_arr = np.array([1, 2, 3])
+
+        >>> nw.dependencies.is_into_series(s_pd)
+        True
+        >>> nw.dependencies.is_into_series(s_pl)
+        True
+        >>> nw.dependencies.is_into_series(np_arr)
+        False
+    """
+    from narwhals.series import Series
+
+    return isinstance(native_series, Series) or _is_native_series(native_series)
+
+
+def is_into_dataframe(native_dataframe: Any | IntoDataFrameT) -> TypeIs[IntoDataFrameT]:
+    """Check whether `native_dataframe` can be converted to a Narwhals DataFrame.
+
+    Arguments:
+        native_dataframe: The object to check.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import polars as pl
+        >>> import numpy as np
+        >>> from narwhals.dependencies import is_into_dataframe
+
+        >>> df_pd = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        >>> df_pl = pl.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        >>> np_arr = np.array([[1, 4], [2, 5], [3, 6]])
+
+        >>> is_into_dataframe(df_pd)
+        True
+        >>> is_into_dataframe(df_pl)
+        True
+        >>> is_into_dataframe(np_arr)
+        False
+    """
+    from narwhals.dataframe import DataFrame
+
+    return isinstance(native_dataframe, DataFrame) or _is_native_dataframe(
+        native_dataframe
+    )
+
+
+def is_into_lazyframe(native_lazyframe: Any | IntoLazyFrameT) -> TypeIs[IntoLazyFrameT]:
+    """Check whether `native_lazyframe` can be converted to a Narwhals LazyFrame.
+
+    Arguments:
+        native_lazyframe: The object to check.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import polars as pl
+        >>> import numpy as np
+        >>> from narwhals.dependencies import is_into_lazyframe
+
+        >>> df_pd = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        >>> lf_pl = pl.LazyFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        >>> np_arr = np.array([[1, 4], [2, 5], [3, 6]])
+
+        >>> is_into_lazyframe(df_pd)
+        False
+        >>> is_into_lazyframe(lf_pl)
+        True
+        >>> is_into_lazyframe(np_arr)
+        False
+    """
+    from narwhals.dataframe import LazyFrame
+
+    return isinstance(native_lazyframe, LazyFrame) or _is_native_lazyframe(
+        native_lazyframe
+    )
+
+
+def is_narwhals_dataframe(
+    df: DataFrame[IntoDataFrameT] | Any,
+) -> TypeIs[DataFrame[IntoDataFrameT]]:
+    """Check whether `df` is a Narwhals DataFrame.
+
+    This is useful if you expect a user to pass in a Narwhals
+    DataFrame directly, and you want to catch both `narwhals.DataFrame`
+    and `narwhals.stable.v1.DataFrame`.
+    """
+    from narwhals.dataframe import DataFrame
+
+    return isinstance(df, DataFrame)
+
+
+def is_narwhals_lazyframe(
+    lf: Any | LazyFrame[IntoLazyFrameT],
+) -> TypeIs[LazyFrame[IntoLazyFrameT]]:
+    """Check whether `lf` is a Narwhals LazyFrame.
+
+    This is useful if you expect a user to pass in a Narwhals
+    LazyFrame directly, and you want to catch both `narwhals.LazyFrame`
+    and `narwhals.stable.v1.LazyFrame`.
+    """
+    from narwhals.dataframe import LazyFrame
+
+    return isinstance(lf, LazyFrame)
+
+
+def is_narwhals_series(ser: Any | Series[IntoSeriesT]) -> TypeIs[Series[IntoSeriesT]]:
+    """Check whether `ser` is a Narwhals Series.
+
+    This is useful if you expect a user to pass in a Narwhals
+    Series directly, and you want to catch both `narwhals.Series`
+    and `narwhals.stable.v1.Series`.
+    """
+    from narwhals.series import Series
+
+    return isinstance(ser, Series)
+
+
+def is_narwhals_series_int(ser: Any | Series[IntoSeriesT]) -> TypeIs[Series[IntoSeriesT]]:
+    return is_narwhals_series(ser) and ser.dtype.is_integer()
+
+
+def is_narwhals_series_bool(
+    ser: Any | Series[IntoSeriesT],
+) -> TypeIs[Series[IntoSeriesT]]:
+    return is_narwhals_series(ser) and ser.dtype.is_boolean()
+
+
+__all__ = [
+    "get_cudf",
+    "get_dask",
+    "get_dask_dataframe",
+    "get_duckdb",
+    "get_ibis",
+    "get_modin",
+    "get_numpy",
+    "get_pandas",
+    "get_polars",
+    "get_pyarrow",
+    "get_pyspark",
+    "get_pyspark_connect",
+    "get_pyspark_sql",
+    "get_sqlframe",
+    "is_cudf_dataframe",
+    "is_cudf_index",
+    "is_cudf_series",
+    "is_dask_dataframe",
+    "is_duckdb_relation",
+    "is_ibis_table",
+    "is_into_dataframe",
+    "is_into_lazyframe",
+    "is_into_series",
+    "is_modin_dataframe",
+    "is_modin_index",
+    "is_modin_series",
+    "is_narwhals_dataframe",
+    "is_narwhals_lazyframe",
+    "is_narwhals_series",
+    "is_numpy_array",
+    "is_pandas_dataframe",
+    "is_pandas_index",
+    "is_pandas_like_dataframe",
+    "is_pandas_like_index",
+    "is_pandas_like_series",
+    "is_pandas_series",
+    "is_polars_dataframe",
+    "is_polars_lazyframe",
+    "is_polars_series",
+    "is_pyarrow_chunked_array",
+    "is_pyarrow_table",
+    "is_pyspark_connect_dataframe",
+    "is_pyspark_dataframe",
+    "is_sqlframe_dataframe",
+]

shared/package-files/74/744e964536e572ae3424a8572500ec3b0be114f26cb63ffc71e8222ed847d24b/__init__.py

@@ -0,0 +1,43 @@
+from pandas.core.arrays.arrow import ArrowExtensionArray
+from pandas.core.arrays.base import (
+    ExtensionArray,
+    ExtensionOpsMixin,
+    ExtensionScalarOpsMixin,
+)
+from pandas.core.arrays.boolean import BooleanArray
+from pandas.core.arrays.categorical import Categorical
+from pandas.core.arrays.datetimes import DatetimeArray
+from pandas.core.arrays.floating import FloatingArray
+from pandas.core.arrays.integer import IntegerArray
+from pandas.core.arrays.interval import IntervalArray
+from pandas.core.arrays.masked import BaseMaskedArray
+from pandas.core.arrays.numpy_ import NumpyExtensionArray
+from pandas.core.arrays.period import (
+    PeriodArray,
+    period_array,
+)
+from pandas.core.arrays.sparse import SparseArray
+from pandas.core.arrays.string_ import StringArray
+from pandas.core.arrays.string_arrow import ArrowStringArray
+from pandas.core.arrays.timedeltas import TimedeltaArray
+
+__all__ = [
+    "ArrowExtensionArray",
+    "ExtensionArray",
+    "ExtensionOpsMixin",
+    "ExtensionScalarOpsMixin",
+    "ArrowStringArray",
+    "BaseMaskedArray",
+    "BooleanArray",
+    "Categorical",
+    "DatetimeArray",
+    "FloatingArray",
+    "IntegerArray",
+    "IntervalArray",
+    "NumpyExtensionArray",
+    "PeriodArray",
+    "period_array",
+    "SparseArray",
+    "StringArray",
+    "TimedeltaArray",
+]

shared/package-files/74/7455918576862d910a3b1211c3ff1a24afea4eb8599047fc8943809a0d9aecf5/python_compiled_autograd.h

@@ -0,0 +1,7 @@
+#pragma once
+#include <torch/csrc/utils/python_stub.h>
+
+// see [Note: Compiled Autograd]
+namespace torch::dynamo::autograd {
+PyObject* torch_c_dynamo_compiled_autograd_init();
+} // namespace torch::dynamo::autograd

shared/package-files/74/745753959035fda80cbb13f5384474d9c2aa67e451f1d874112ffaf5774fdb4c/test_numconv.py

@@ -0,0 +1,38 @@
+import itertools
+import unittest
+from numba import njit
+from numba.core import types
+
+
+def template(fromty, toty):
+    def closure(self):
+        def cast(x):
+            y = x
+            return y
+
+        cfunc = njit(toty(fromty))(cast)
+        self.assertAlmostEqual(cfunc(1), 1)
+
+    return closure
+
+
+class TestNumberConversion(unittest.TestCase):
+    """
+    Test all int/float numeric conversion to ensure we have all the external
+    dependencies to perform these conversions.
+    """
+    # NOTE: more implicit tests are in test_numberctor
+
+    @classmethod
+    def automatic_populate(cls):
+        tys = types.integer_domain | types.real_domain
+        for fromty, toty in itertools.permutations(tys, r=2):
+            test_name = "test_{fromty}_to_{toty}".format(fromty=fromty,
+                                                         toty=toty)
+            setattr(cls, test_name, template(fromty, toty))
+
+
+TestNumberConversion.automatic_populate()
+
+if __name__ == '__main__':
+    unittest.main()

shared/package-files/74/74640986f3954e36f52d54f9a8f64b271a31df4b83326383076e88cfa4e355b7/_tv_tensor.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Mapping, Optional, Sequence, Tuple, Type, TypeVar, Union
+
+import torch
+from torch._C import DisableTorchFunctionSubclass
+from torch.types import _device, _dtype, _size
+
+from torchvision.tv_tensors._torch_function_helpers import _FORCE_TORCHFUNCTION_SUBCLASS, _must_return_subclass
+
+
+D = TypeVar("D", bound="TVTensor")
+
+
+class TVTensor(torch.Tensor):
+    """Base class for all TVTensors.
+
+    You probably don't want to use this class unless you're defining your own
+    custom TVTensors. See
+    :ref:`sphx_glr_auto_examples_transforms_plot_custom_tv_tensors.py` for details.
+    """
+
+    @staticmethod
+    def _to_tensor(
+        data: Any,
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[Union[torch.device, str, int]] = None,
+        requires_grad: Optional[bool] = None,
+    ) -> torch.Tensor:
+        if requires_grad is None:
+            requires_grad = data.requires_grad if isinstance(data, torch.Tensor) else False
+        return torch.as_tensor(data, dtype=dtype, device=device).requires_grad_(requires_grad)
+
+    @classmethod
+    def _wrap_output(
+        cls,
+        output: torch.Tensor,
+        args: Sequence[Any] = (),
+        kwargs: Optional[Mapping[str, Any]] = None,
+    ) -> torch.Tensor:
+        # Same as torch._tensor._convert
+        if isinstance(output, torch.Tensor) and not isinstance(output, cls):
+            output = output.as_subclass(cls)
+
+        if isinstance(output, (tuple, list)):
+            # Also handles things like namedtuples
+            output = type(output)(cls._wrap_output(part, args, kwargs) for part in output)
+        return output
+
+    @classmethod
+    def __torch_function__(
+        cls,
+        func: Callable[..., torch.Tensor],
+        types: Tuple[Type[torch.Tensor], ...],
+        args: Sequence[Any] = (),
+        kwargs: Optional[Mapping[str, Any]] = None,
+    ) -> torch.Tensor:
+        """For general information about how the __torch_function__ protocol works,
+        see https://pytorch.org/docs/stable/notes/extending.html#extending-torch
+
+        TL;DR: Every time a PyTorch operator is called, it goes through the inputs and looks for the
+        ``__torch_function__`` method. If one is found, it is invoked with the operator as ``func`` as well as the
+        ``args`` and ``kwargs`` of the original call.
+
+        Why do we override this? Because the base implementation in torch.Tensor would preserve the TVTensor type
+        of the output. In our case, we want to return pure tensors instead (with a few exceptions). Refer to the
+        "TVTensors FAQ" gallery example for a rationale of this behaviour (TL;DR: perf + no silver bullet).
+
+        Our implementation below is very similar to the base implementation in ``torch.Tensor`` - go check it out.
+        """
+        if not all(issubclass(cls, t) for t in types):
+            return NotImplemented
+
+        # Like in the base Tensor.__torch_function__ implementation, it's easier to always use
+        # DisableTorchFunctionSubclass and then manually re-wrap the output if necessary
+        with DisableTorchFunctionSubclass():
+            output = func(*args, **kwargs or dict())
+
+        must_return_subclass = _must_return_subclass()
+        if must_return_subclass or (func in _FORCE_TORCHFUNCTION_SUBCLASS and isinstance(args[0], cls)):
+            # If you're wondering why we need the `isinstance(args[0], cls)` check, remove it and see what fails
+            # in test_to_tv_tensor_reference().
+            # The __torch_function__ protocol will invoke the __torch_function__ method on *all* types involved in
+            # the computation by walking the MRO upwards. For example,
+            # `out = a_pure_tensor.to(an_image)` will invoke `Image.__torch_function__` with
+            # `args = (a_pure_tensor, an_image)` first. Without this guard, `out` would
+            # be wrapped into an `Image`.
+            return cls._wrap_output(output, args, kwargs)
+
+        if not must_return_subclass and isinstance(output, cls):
+            # DisableTorchFunctionSubclass is ignored by inplace ops like `.add_(...)`,
+            # so for those, the output is still a TVTensor. Thus, we need to manually unwrap.
+            return output.as_subclass(torch.Tensor)
+
+        return output
+
+    def _make_repr(self, **kwargs: Any) -> str:
+        # This is a poor man's implementation of the proposal in https://github.com/pytorch/pytorch/issues/76532.
+        # If that ever gets implemented, remove this in favor of the solution on the `torch.Tensor` class.
+        extra_repr = ", ".join(f"{key}={value}" for key, value in kwargs.items())
+        return f"{super().__repr__()[:-1]}, {extra_repr})"
+
+    # Add properties for common attributes like shape, dtype, device, ndim etc
+    # this way we return the result without passing into __torch_function__
+    @property
+    def shape(self) -> _size:  # type: ignore[override]
+        with DisableTorchFunctionSubclass():
+            return super().shape
+
+    @property
+    def ndim(self) -> int:  # type: ignore[override]
+        with DisableTorchFunctionSubclass():
+            return super().ndim
+
+    @property
+    def device(self, *args: Any, **kwargs: Any) -> _device:  # type: ignore[override]
+        with DisableTorchFunctionSubclass():
+            return super().device
+
+    @property
+    def dtype(self) -> _dtype:  # type: ignore[override]
+        with DisableTorchFunctionSubclass():
+            return super().dtype
+
+    def __deepcopy__(self: D, memo: Dict[int, Any]) -> D:
+        # We need to detach first, since a plain `Tensor.clone` will be part of the computation graph, which does
+        # *not* happen for `deepcopy(Tensor)`. A side-effect from detaching is that the `Tensor.requires_grad`
+        # attribute is cleared, so we need to refill it before we return.
+        # Note: We don't explicitly handle deep-copying of the metadata here. The only metadata we currently have is
+        # `BoundingBoxes.format` and `BoundingBoxes.canvas_size`, which are immutable and thus implicitly deep-copied by
+        # `BoundingBoxes.clone()`.
+        return self.detach().clone().requires_grad_(self.requires_grad)  # type: ignore[return-value]

shared/package-files/74/7468a8b3ed64f900467b0ed817338d653cd55b1cfe69801aaa571c976fe1e41a/_extended_precision.py

@@ -0,0 +1,27 @@
+"""A module with platform-specific extended precision
+`numpy.number` subclasses.
+
+The subclasses are defined here (instead of ``__init__.pyi``) such
+that they can be imported conditionally via the numpy's mypy plugin.
+"""
+
+import numpy as np
+from . import (
+    _80Bit,
+    _96Bit,
+    _128Bit,
+    _256Bit,
+)
+
+uint128 = np.unsignedinteger[_128Bit]
+uint256 = np.unsignedinteger[_256Bit]
+int128 = np.signedinteger[_128Bit]
+int256 = np.signedinteger[_256Bit]
+float80 = np.floating[_80Bit]
+float96 = np.floating[_96Bit]
+float128 = np.floating[_128Bit]
+float256 = np.floating[_256Bit]
+complex160 = np.complexfloating[_80Bit, _80Bit]
+complex192 = np.complexfloating[_96Bit, _96Bit]
+complex256 = np.complexfloating[_128Bit, _128Bit]
+complex512 = np.complexfloating[_256Bit, _256Bit]

shared/package-files/74/746b38d4187c578e5834bdffa3c2afbf111e6c49d1dd1778bd411f27b09633b8/sparse_compressed_tensor_ops.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API sparse_compressed_tensor_comp_plain_value_size {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::SymIntArrayRef, c10::optional<at::ScalarType>, c10::optional<at::Layout>, c10::optional<at::Device>, c10::optional<bool>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::sparse_compressed_tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "comp_plain_value_size")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "sparse_compressed_tensor.comp_plain_value_size(Tensor compressed_indices, Tensor plain_indices, Tensor values, SymInt[] size, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor")
+  static at::Tensor call(const at::Tensor & compressed_indices, const at::Tensor & plain_indices, const at::Tensor & values, c10::SymIntArrayRef size, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & compressed_indices, const at::Tensor & plain_indices, const at::Tensor & values, c10::SymIntArrayRef size, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory);
+};
+
+struct TORCH_API sparse_compressed_tensor_comp_plain_value {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, c10::optional<at::ScalarType>, c10::optional<at::Layout>, c10::optional<at::Device>, c10::optional<bool>);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::sparse_compressed_tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "comp_plain_value")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "sparse_compressed_tensor.comp_plain_value(Tensor compressed_indices, Tensor plain_indices, Tensor values, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=False) -> Tensor")
+  static at::Tensor call(const at::Tensor & compressed_indices, const at::Tensor & plain_indices, const at::Tensor & values, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & compressed_indices, const at::Tensor & plain_indices, const at::Tensor & values, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory);
+};
+
+}} // namespace at::_ops

shared/package-files/74/746f744513890193f4e0ff0a4f36c93849b9c3ee656c73df3f5b54e486c4ac9a/site.pyi

@@ -0,0 +1,15 @@
+import sys
+from typing import Iterable, List, Optional
+
+PREFIXES: List[str]
+ENABLE_USER_SITE: Optional[bool]
+USER_SITE: Optional[str]
+USER_BASE: Optional[str]
+
+if sys.version_info < (3,):
+    def main() -> None: ...
+
+def addsitedir(sitedir: str, known_paths: Optional[Iterable[str]] = ...) -> None: ...
+def getsitepackages(prefixes: Optional[Iterable[str]] = ...) -> List[str]: ...
+def getuserbase() -> str: ...
+def getusersitepackages() -> str: ...

shared/package-files/74/747f4d6e7edb335308724829e44f9f65dcf83ed53ba4f1172e79c746431eaf7a/pad_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor pad_symint(const at::Tensor & self, c10::SymIntArrayRef pad, c10::string_view mode="constant", c10::optional<double> value=c10::nullopt);
+} // namespace native
+} // namespace at

shared/package-files/74/7498883445447692d2af9f99fdaec1c68606bc0d7ea427c789aff1885d137d8a/ubsan.h

@@ -0,0 +1,97 @@
+// 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.
+
+// Contains utilities for making UBSan happy.
+
+#pragma once
+
+#include <cstring>
+#include <memory>
+#include <type_traits>
+
+#include "arrow/util/aligned_storage.h"
+#include "arrow/util/macros.h"
+
+namespace arrow {
+namespace util {
+
+namespace internal {
+
+constexpr uint8_t kNonNullFiller = 0;
+
+}  // namespace internal
+
+/// \brief Returns maybe_null if not null or a non-null pointer to an arbitrary memory
+/// that shouldn't be dereferenced.
+///
+/// Memset/Memcpy are undefined when a nullptr is passed as an argument use this utility
+/// method to wrap locations where this could happen.
+///
+/// Note: Flatbuffers has UBSan warnings if a zero length vector is passed.
+/// https://github.com/google/flatbuffers/pull/5355 is trying to resolve
+/// them.
+template <typename T>
+inline T* MakeNonNull(T* maybe_null = NULLPTR) {
+  if (ARROW_PREDICT_TRUE(maybe_null != NULLPTR)) {
+    return maybe_null;
+  }
+
+  return const_cast<T*>(reinterpret_cast<const T*>(&internal::kNonNullFiller));
+}
+
+template <typename T>
+inline std::enable_if_t<std::is_trivially_copyable_v<T>, T> SafeLoadAs(
+    const uint8_t* unaligned) {
+  using Type = std::remove_const_t<T>;
+  arrow::internal::AlignedStorage<Type> raw_data;
+  std::memcpy(raw_data.get(), unaligned, sizeof(T));
+  auto data = *raw_data.get();
+  raw_data.destroy();
+  return data;
+}
+
+template <typename T>
+inline std::enable_if_t<std::is_trivially_copyable_v<T>, T> SafeLoad(const T* unaligned) {
+  using Type = std::remove_const_t<T>;
+  arrow::internal::AlignedStorage<Type> raw_data;
+  std::memcpy(raw_data.get(), static_cast<const void*>(unaligned), sizeof(T));
+  auto data = *raw_data.get();
+  raw_data.destroy();
+  return data;
+}
+
+template <typename U, typename T>
+inline std::enable_if_t<std::is_trivially_copyable_v<T> &&
+                            std::is_trivially_copyable_v<U> && sizeof(T) == sizeof(U),
+                        U>
+SafeCopy(T value) {
+  using TypeU = std::remove_const_t<U>;
+  arrow::internal::AlignedStorage<TypeU> raw_data;
+  std::memcpy(raw_data.get(), static_cast<const void*>(&value), sizeof(T));
+  auto data = *raw_data.get();
+  raw_data.destroy();
+  return data;
+}
+
+template <typename T>
+inline std::enable_if_t<std::is_trivially_copyable_v<T>, void> SafeStore(void* unaligned,
+                                                                         T value) {
+  std::memcpy(unaligned, &value, sizeof(T));
+}
+
+}  // namespace util
+}  // namespace arrow

shared/package-files/74/7498de6addc14be4d89f546b505570b9f50c6ac6edccb7d8468cbf1d710d7854/utils.py

@@ -0,0 +1,136 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+import re
+from typing import FrozenSet, NewType, Tuple, Union, cast
+
+from .tags import Tag, parse_tag
+from .version import InvalidVersion, Version
+
+BuildTag = Union[Tuple[()], Tuple[int, str]]
+NormalizedName = NewType("NormalizedName", str)
+
+
+class InvalidWheelFilename(ValueError):
+    """
+    An invalid wheel filename was found, users should refer to PEP 427.
+    """
+
+
+class InvalidSdistFilename(ValueError):
+    """
+    An invalid sdist filename was found, users should refer to the packaging user guide.
+    """
+
+
+_canonicalize_regex = re.compile(r"[-_.]+")
+# PEP 427: The build number must start with a digit.
+_build_tag_regex = re.compile(r"(\d+)(.*)")
+
+
+def canonicalize_name(name: str) -> NormalizedName:
+    # This is taken from PEP 503.
+    value = _canonicalize_regex.sub("-", name).lower()
+    return cast(NormalizedName, value)
+
+
+def canonicalize_version(version: Union[Version, str]) -> str:
+    """
+    This is very similar to Version.__str__, but has one subtle difference
+    with the way it handles the release segment.
+    """
+    if isinstance(version, str):
+        try:
+            parsed = Version(version)
+        except InvalidVersion:
+            # Legacy versions cannot be normalized
+            return version
+    else:
+        parsed = version
+
+    parts = []
+
+    # Epoch
+    if parsed.epoch != 0:
+        parts.append(f"{parsed.epoch}!")
+
+    # Release segment
+    # NB: This strips trailing '.0's to normalize
+    parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in parsed.release)))
+
+    # Pre-release
+    if parsed.pre is not None:
+        parts.append("".join(str(x) for x in parsed.pre))
+
+    # Post-release
+    if parsed.post is not None:
+        parts.append(f".post{parsed.post}")
+
+    # Development release
+    if parsed.dev is not None:
+        parts.append(f".dev{parsed.dev}")
+
+    # Local version segment
+    if parsed.local is not None:
+        parts.append(f"+{parsed.local}")
+
+    return "".join(parts)
+
+
+def parse_wheel_filename(
+    filename: str,
+) -> Tuple[NormalizedName, Version, BuildTag, FrozenSet[Tag]]:
+    if not filename.endswith(".whl"):
+        raise InvalidWheelFilename(
+            f"Invalid wheel filename (extension must be '.whl'): {filename}"
+        )
+
+    filename = filename[:-4]
+    dashes = filename.count("-")
+    if dashes not in (4, 5):
+        raise InvalidWheelFilename(
+            f"Invalid wheel filename (wrong number of parts): {filename}"
+        )
+
+    parts = filename.split("-", dashes - 2)
+    name_part = parts[0]
+    # See PEP 427 for the rules on escaping the project name
+    if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None:
+        raise InvalidWheelFilename(f"Invalid project name: {filename}")
+    name = canonicalize_name(name_part)
+    version = Version(parts[1])
+    if dashes == 5:
+        build_part = parts[2]
+        build_match = _build_tag_regex.match(build_part)
+        if build_match is None:
+            raise InvalidWheelFilename(
+                f"Invalid build number: {build_part} in '{filename}'"
+            )
+        build = cast(BuildTag, (int(build_match.group(1)), build_match.group(2)))
+    else:
+        build = ()
+    tags = parse_tag(parts[-1])
+    return (name, version, build, tags)
+
+
+def parse_sdist_filename(filename: str) -> Tuple[NormalizedName, Version]:
+    if filename.endswith(".tar.gz"):
+        file_stem = filename[: -len(".tar.gz")]
+    elif filename.endswith(".zip"):
+        file_stem = filename[: -len(".zip")]
+    else:
+        raise InvalidSdistFilename(
+            f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):"
+            f" {filename}"
+        )
+
+    # We are requiring a PEP 440 version, which cannot contain dashes,
+    # so we split on the last dash.
+    name_part, sep, version_part = file_stem.rpartition("-")
+    if not sep:
+        raise InvalidSdistFilename(f"Invalid sdist filename: {filename}")
+
+    name = canonicalize_name(name_part)
+    version = Version(version_part)
+    return (name, version)

shared/package-files/74/749937a279c373f53a387e2e04d9a3a45d0a70b0081d981fe2dbcf0a8c856921/special_shifted_chebyshev_polynomial_v_meta.h

@@ -0,0 +1,27 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeMetaFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/TensorIterator.h>
+#include <ATen/TensorMeta.h>
+#include <tuple>
+#include <vector>
+
+namespace at {
+namespace meta {
+
+struct TORCH_API structured_special_shifted_chebyshev_polynomial_v : public TensorIteratorBase {
+    
+    
+    void meta(const at::Tensor & x, const at::Tensor & n);
+};
+
+} // namespace native
+} // namespace at

shared/package-files/74/74a59a0d9a6268c92e571a57aaa93109f4e759e489b30dc04b88a2b5d99b611e/base.py

@@ -0,0 +1,448 @@
+"""
+Progress bar implementation on top of prompt_toolkit.
+
+::
+
+    with ProgressBar(...) as pb:
+        for item in pb(data):
+            ...
+"""
+from __future__ import annotations
+
+import contextvars
+import datetime
+import functools
+import os
+import signal
+import threading
+import traceback
+from typing import (
+    Callable,
+    Generic,
+    Iterable,
+    Iterator,
+    Sequence,
+    Sized,
+    TextIO,
+    TypeVar,
+    cast,
+)
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.application.current import get_app_session
+from prompt_toolkit.filters import Condition, is_done, renderer_height_is_known
+from prompt_toolkit.formatted_text import (
+    AnyFormattedText,
+    StyleAndTextTuples,
+    to_formatted_text,
+)
+from prompt_toolkit.input import Input
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+from prompt_toolkit.layout import (
+    ConditionalContainer,
+    FormattedTextControl,
+    HSplit,
+    Layout,
+    VSplit,
+    Window,
+)
+from prompt_toolkit.layout.controls import UIContent, UIControl
+from prompt_toolkit.layout.dimension import AnyDimension, D
+from prompt_toolkit.output import ColorDepth, Output
+from prompt_toolkit.styles import BaseStyle
+from prompt_toolkit.utils import in_main_thread
+
+from .formatters import Formatter, create_default_formatters
+
+__all__ = ["ProgressBar"]
+
+E = KeyPressEvent
+
+_SIGWINCH = getattr(signal, "SIGWINCH", None)
+
+
+def create_key_bindings(cancel_callback: Callable[[], None] | None) -> KeyBindings:
+    """
+    Key bindings handled by the progress bar.
+    (The main thread is not supposed to handle any key bindings.)
+    """
+    kb = KeyBindings()
+
+    @kb.add("c-l")
+    def _clear(event: E) -> None:
+        event.app.renderer.clear()
+
+    if cancel_callback is not None:
+
+        @kb.add("c-c")
+        def _interrupt(event: E) -> None:
+            "Kill the 'body' of the progress bar, but only if we run from the main thread."
+            assert cancel_callback is not None
+            cancel_callback()
+
+    return kb
+
+
+_T = TypeVar("_T")
+
+
+class ProgressBar:
+    """
+    Progress bar context manager.
+
+    Usage ::
+
+        with ProgressBar(...) as pb:
+            for item in pb(data):
+                ...
+
+    :param title: Text to be displayed above the progress bars. This can be a
+        callable or formatted text as well.
+    :param formatters: List of :class:`.Formatter` instances.
+    :param bottom_toolbar: Text to be displayed in the bottom toolbar. This
+        can be a callable or formatted text.
+    :param style: :class:`prompt_toolkit.styles.BaseStyle` instance.
+    :param key_bindings: :class:`.KeyBindings` instance.
+    :param cancel_callback: Callback function that's called when control-c is
+        pressed by the user. This can be used for instance to start "proper"
+        cancellation if the wrapped code supports it.
+    :param file: The file object used for rendering, by default `sys.stderr` is used.
+
+    :param color_depth: `prompt_toolkit` `ColorDepth` instance.
+    :param output: :class:`~prompt_toolkit.output.Output` instance.
+    :param input: :class:`~prompt_toolkit.input.Input` instance.
+    """
+
+    def __init__(
+        self,
+        title: AnyFormattedText = None,
+        formatters: Sequence[Formatter] | None = None,
+        bottom_toolbar: AnyFormattedText = None,
+        style: BaseStyle | None = None,
+        key_bindings: KeyBindings | None = None,
+        cancel_callback: Callable[[], None] | None = None,
+        file: TextIO | None = None,
+        color_depth: ColorDepth | None = None,
+        output: Output | None = None,
+        input: Input | None = None,
+    ) -> None:
+        self.title = title
+        self.formatters = formatters or create_default_formatters()
+        self.bottom_toolbar = bottom_toolbar
+        self.counters: list[ProgressBarCounter[object]] = []
+        self.style = style
+        self.key_bindings = key_bindings
+        self.cancel_callback = cancel_callback
+
+        # If no `cancel_callback` was given, and we're creating the progress
+        # bar from the main thread. Cancel by sending a `KeyboardInterrupt` to
+        # the main thread.
+        if self.cancel_callback is None and in_main_thread():
+
+            def keyboard_interrupt_to_main_thread() -> None:
+                os.kill(os.getpid(), signal.SIGINT)
+
+            self.cancel_callback = keyboard_interrupt_to_main_thread
+
+        # Note that we use __stderr__ as default error output, because that
+        # works best with `patch_stdout`.
+        self.color_depth = color_depth
+        self.output = output or get_app_session().output
+        self.input = input or get_app_session().input
+
+        self._thread: threading.Thread | None = None
+
+        self._has_sigwinch = False
+        self._app_started = threading.Event()
+
+    def __enter__(self) -> ProgressBar:
+        # Create UI Application.
+        title_toolbar = ConditionalContainer(
+            Window(
+                FormattedTextControl(lambda: self.title),
+                height=1,
+                style="class:progressbar,title",
+            ),
+            filter=Condition(lambda: self.title is not None),
+        )
+
+        bottom_toolbar = ConditionalContainer(
+            Window(
+                FormattedTextControl(
+                    lambda: self.bottom_toolbar, style="class:bottom-toolbar.text"
+                ),
+                style="class:bottom-toolbar",
+                height=1,
+            ),
+            filter=~is_done
+            & renderer_height_is_known
+            & Condition(lambda: self.bottom_toolbar is not None),
+        )
+
+        def width_for_formatter(formatter: Formatter) -> AnyDimension:
+            # Needs to be passed as callable (partial) to the 'width'
+            # parameter, because we want to call it on every resize.
+            return formatter.get_width(progress_bar=self)
+
+        progress_controls = [
+            Window(
+                content=_ProgressControl(self, f, self.cancel_callback),
+                width=functools.partial(width_for_formatter, f),
+            )
+            for f in self.formatters
+        ]
+
+        self.app: Application[None] = Application(
+            min_redraw_interval=0.05,
+            layout=Layout(
+                HSplit(
+                    [
+                        title_toolbar,
+                        VSplit(
+                            progress_controls,
+                            height=lambda: D(
+                                preferred=len(self.counters), max=len(self.counters)
+                            ),
+                        ),
+                        Window(),
+                        bottom_toolbar,
+                    ]
+                )
+            ),
+            style=self.style,
+            key_bindings=self.key_bindings,
+            refresh_interval=0.3,
+            color_depth=self.color_depth,
+            output=self.output,
+            input=self.input,
+        )
+
+        # Run application in different thread.
+        def run() -> None:
+            try:
+                self.app.run(pre_run=self._app_started.set)
+            except BaseException as e:
+                traceback.print_exc()
+                print(e)
+
+        ctx: contextvars.Context = contextvars.copy_context()
+
+        self._thread = threading.Thread(target=ctx.run, args=(run,))
+        self._thread.start()
+
+        return self
+
+    def __exit__(self, *a: object) -> None:
+        # Wait for the app to be started. Make sure we don't quit earlier,
+        # otherwise `self.app.exit` won't terminate the app because
+        # `self.app.future` has not yet been set.
+        self._app_started.wait()
+
+        # Quit UI application.
+        if self.app.is_running and self.app.loop is not None:
+            self.app.loop.call_soon_threadsafe(self.app.exit)
+
+        if self._thread is not None:
+            self._thread.join()
+
+    def __call__(
+        self,
+        data: Iterable[_T] | None = None,
+        label: AnyFormattedText = "",
+        remove_when_done: bool = False,
+        total: int | None = None,
+    ) -> ProgressBarCounter[_T]:
+        """
+        Start a new counter.
+
+        :param label: Title text or description for this progress. (This can be
+            formatted text as well).
+        :param remove_when_done: When `True`, hide this progress bar.
+        :param total: Specify the maximum value if it can't be calculated by
+            calling ``len``.
+        """
+        counter = ProgressBarCounter(
+            self, data, label=label, remove_when_done=remove_when_done, total=total
+        )
+        self.counters.append(counter)
+        return counter
+
+    def invalidate(self) -> None:
+        self.app.invalidate()
+
+
+class _ProgressControl(UIControl):
+    """
+    User control for the progress bar.
+    """
+
+    def __init__(
+        self,
+        progress_bar: ProgressBar,
+        formatter: Formatter,
+        cancel_callback: Callable[[], None] | None,
+    ) -> None:
+        self.progress_bar = progress_bar
+        self.formatter = formatter
+        self._key_bindings = create_key_bindings(cancel_callback)
+
+    def create_content(self, width: int, height: int) -> UIContent:
+        items: list[StyleAndTextTuples] = []
+
+        for pr in self.progress_bar.counters:
+            try:
+                text = self.formatter.format(self.progress_bar, pr, width)
+            except BaseException:
+                traceback.print_exc()
+                text = "ERROR"
+
+            items.append(to_formatted_text(text))
+
+        def get_line(i: int) -> StyleAndTextTuples:
+            return items[i]
+
+        return UIContent(get_line=get_line, line_count=len(items), show_cursor=False)
+
+    def is_focusable(self) -> bool:
+        return True  # Make sure that the key bindings work.
+
+    def get_key_bindings(self) -> KeyBindings:
+        return self._key_bindings
+
+
+_CounterItem = TypeVar("_CounterItem", covariant=True)
+
+
+class ProgressBarCounter(Generic[_CounterItem]):
+    """
+    An individual counter (A progress bar can have multiple counters).
+    """
+
+    def __init__(
+        self,
+        progress_bar: ProgressBar,
+        data: Iterable[_CounterItem] | None = None,
+        label: AnyFormattedText = "",
+        remove_when_done: bool = False,
+        total: int | None = None,
+    ) -> None:
+        self.start_time = datetime.datetime.now()
+        self.stop_time: datetime.datetime | None = None
+        self.progress_bar = progress_bar
+        self.data = data
+        self.items_completed = 0
+        self.label = label
+        self.remove_when_done = remove_when_done
+        self._done = False
+        self.total: int | None
+
+        if total is None:
+            try:
+                self.total = len(cast(Sized, data))
+            except TypeError:
+                self.total = None  # We don't know the total length.
+        else:
+            self.total = total
+
+    def __iter__(self) -> Iterator[_CounterItem]:
+        if self.data is not None:
+            try:
+                for item in self.data:
+                    yield item
+                    self.item_completed()
+
+                # Only done if we iterate to the very end.
+                self.done = True
+            finally:
+                # Ensure counter has stopped even if we did not iterate to the
+                # end (e.g. break or exceptions).
+                self.stopped = True
+        else:
+            raise NotImplementedError("No data defined to iterate over.")
+
+    def item_completed(self) -> None:
+        """
+        Start handling the next item.
+
+        (Can be called manually in case we don't have a collection to loop through.)
+        """
+        self.items_completed += 1
+        self.progress_bar.invalidate()
+
+    @property
+    def done(self) -> bool:
+        """Whether a counter has been completed.
+
+        Done counter have been stopped (see stopped) and removed depending on
+        remove_when_done value.
+
+        Contrast this with stopped. A stopped counter may be terminated before
+        100% completion. A done counter has reached its 100% completion.
+        """
+        return self._done
+
+    @done.setter
+    def done(self, value: bool) -> None:
+        self._done = value
+        self.stopped = value
+
+        if value and self.remove_when_done:
+            self.progress_bar.counters.remove(self)
+
+    @property
+    def stopped(self) -> bool:
+        """Whether a counter has been stopped.
+
+        Stopped counters no longer have increasing time_elapsed. This distinction is
+        also used to prevent the Bar formatter with unknown totals from continuing to run.
+
+        A stopped counter (but not done) can be used to signal that a given counter has
+        encountered an error but allows other counters to continue
+        (e.g. download X of Y failed). Given how only done counters are removed
+        (see remove_when_done) this can help aggregate failures from a large number of
+        successes.
+
+        Contrast this with done. A done counter has reached its 100% completion.
+        A stopped counter may be terminated before 100% completion.
+        """
+        return self.stop_time is not None
+
+    @stopped.setter
+    def stopped(self, value: bool) -> None:
+        if value:
+            # This counter has not already been stopped.
+            if not self.stop_time:
+                self.stop_time = datetime.datetime.now()
+        else:
+            # Clearing any previously set stop_time.
+            self.stop_time = None
+
+    @property
+    def percentage(self) -> float:
+        if self.total is None:
+            return 0
+        else:
+            return self.items_completed * 100 / max(self.total, 1)
+
+    @property
+    def time_elapsed(self) -> datetime.timedelta:
+        """
+        Return how much time has been elapsed since the start.
+        """
+        if self.stop_time is None:
+            return datetime.datetime.now() - self.start_time
+        else:
+            return self.stop_time - self.start_time
+
+    @property
+    def time_left(self) -> datetime.timedelta | None:
+        """
+        Timedelta representing the time left.
+        """
+        if self.total is None or not self.percentage:
+            return None
+        elif self.done or self.stopped:
+            return datetime.timedelta(0)
+        else:
+            return self.time_elapsed * (100 - self.percentage) / self.percentage

shared/package-files/74/74b12fdedc6706b1d8c5a8ce60042103c080edac62b8fc351026da1cbe69df7f/test_adjlist.py

@@ -0,0 +1,268 @@
+"""
+    Unit tests for adjlist.
+"""
+import io
+import os
+import tempfile
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal, graphs_equal, nodes_equal
+
+
+class TestAdjlist:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.Graph(name="test")
+        e = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("a", "f")]
+        cls.G.add_edges_from(e)
+        cls.G.add_node("g")
+        cls.DG = nx.DiGraph(cls.G)
+        cls.XG = nx.MultiGraph()
+        cls.XG.add_weighted_edges_from([(1, 2, 5), (1, 2, 5), (1, 2, 1), (3, 3, 42)])
+        cls.XDG = nx.MultiDiGraph(cls.XG)
+
+    def test_read_multiline_adjlist_1(self):
+        # Unit test for https://networkx.lanl.gov/trac/ticket/252
+        s = b"""# comment line
+1 2
+# comment line
+2
+3
+"""
+        bytesIO = io.BytesIO(s)
+        G = nx.read_multiline_adjlist(bytesIO)
+        adj = {"1": {"3": {}, "2": {}}, "3": {"1": {}}, "2": {"1": {}}}
+        assert graphs_equal(G, nx.Graph(adj))
+
+    def test_unicode(self):
+        G = nx.Graph()
+        name1 = chr(2344) + chr(123) + chr(6543)
+        name2 = chr(5543) + chr(1543) + chr(324)
+        G.add_edge(name1, "Radiohead", **{name2: 3})
+        fd, fname = tempfile.mkstemp()
+        nx.write_multiline_adjlist(G, fname)
+        H = nx.read_multiline_adjlist(fname)
+        assert graphs_equal(G, H)
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_latin1_err(self):
+        G = nx.Graph()
+        name1 = chr(2344) + chr(123) + chr(6543)
+        name2 = chr(5543) + chr(1543) + chr(324)
+        G.add_edge(name1, "Radiohead", **{name2: 3})
+        fd, fname = tempfile.mkstemp()
+        pytest.raises(
+            UnicodeEncodeError, nx.write_multiline_adjlist, G, fname, encoding="latin-1"
+        )
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_latin1(self):
+        G = nx.Graph()
+        name1 = "Bj" + chr(246) + "rk"
+        name2 = chr(220) + "ber"
+        G.add_edge(name1, "Radiohead", **{name2: 3})
+        fd, fname = tempfile.mkstemp()
+        nx.write_multiline_adjlist(G, fname, encoding="latin-1")
+        H = nx.read_multiline_adjlist(fname, encoding="latin-1")
+        assert graphs_equal(G, H)
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_parse_adjlist(self):
+        lines = ["1 2 5", "2 3 4", "3 5", "4", "5"]
+        nx.parse_adjlist(lines, nodetype=int)  # smoke test
+        with pytest.raises(TypeError):
+            nx.parse_adjlist(lines, nodetype="int")
+        lines = ["1 2 5", "2 b", "c"]
+        with pytest.raises(TypeError):
+            nx.parse_adjlist(lines, nodetype=int)
+
+    def test_adjlist_graph(self):
+        G = self.G
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_adjlist(G, fname)
+        H = nx.read_adjlist(fname)
+        H2 = nx.read_adjlist(fname)
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_adjlist_digraph(self):
+        G = self.DG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_adjlist(G, fname)
+        H = nx.read_adjlist(fname, create_using=nx.DiGraph())
+        H2 = nx.read_adjlist(fname, create_using=nx.DiGraph())
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_adjlist_integers(self):
+        (fd, fname) = tempfile.mkstemp()
+        G = nx.convert_node_labels_to_integers(self.G)
+        nx.write_adjlist(G, fname)
+        H = nx.read_adjlist(fname, nodetype=int)
+        H2 = nx.read_adjlist(fname, nodetype=int)
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_adjlist_multigraph(self):
+        G = self.XG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_adjlist(G, fname)
+        H = nx.read_adjlist(fname, nodetype=int, create_using=nx.MultiGraph())
+        H2 = nx.read_adjlist(fname, nodetype=int, create_using=nx.MultiGraph())
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_adjlist_multidigraph(self):
+        G = self.XDG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_adjlist(G, fname)
+        H = nx.read_adjlist(fname, nodetype=int, create_using=nx.MultiDiGraph())
+        H2 = nx.read_adjlist(fname, nodetype=int, create_using=nx.MultiDiGraph())
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_adjlist_delimiter(self):
+        fh = io.BytesIO()
+        G = nx.path_graph(3)
+        nx.write_adjlist(G, fh, delimiter=":")
+        fh.seek(0)
+        H = nx.read_adjlist(fh, nodetype=int, delimiter=":")
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+
+
+class TestMultilineAdjlist:
+    @classmethod
+    def setup_class(cls):
+        cls.G = nx.Graph(name="test")
+        e = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("a", "f")]
+        cls.G.add_edges_from(e)
+        cls.G.add_node("g")
+        cls.DG = nx.DiGraph(cls.G)
+        cls.DG.remove_edge("b", "a")
+        cls.DG.remove_edge("b", "c")
+        cls.XG = nx.MultiGraph()
+        cls.XG.add_weighted_edges_from([(1, 2, 5), (1, 2, 5), (1, 2, 1), (3, 3, 42)])
+        cls.XDG = nx.MultiDiGraph(cls.XG)
+
+    def test_parse_multiline_adjlist(self):
+        lines = [
+            "1 2",
+            "b {'weight':3, 'name': 'Frodo'}",
+            "c {}",
+            "d 1",
+            "e {'weight':6, 'name': 'Saruman'}",
+        ]
+        nx.parse_multiline_adjlist(iter(lines))  # smoke test
+        with pytest.raises(TypeError):
+            nx.parse_multiline_adjlist(iter(lines), nodetype=int)
+        nx.parse_multiline_adjlist(iter(lines), edgetype=str)  # smoke test
+        with pytest.raises(TypeError):
+            nx.parse_multiline_adjlist(iter(lines), nodetype=int)
+        lines = ["1 a"]
+        with pytest.raises(TypeError):
+            nx.parse_multiline_adjlist(iter(lines))
+        lines = ["a 2"]
+        with pytest.raises(TypeError):
+            nx.parse_multiline_adjlist(iter(lines), nodetype=int)
+        lines = ["1 2"]
+        with pytest.raises(TypeError):
+            nx.parse_multiline_adjlist(iter(lines))
+        lines = ["1 2", "2 {}"]
+        with pytest.raises(TypeError):
+            nx.parse_multiline_adjlist(iter(lines))
+
+    def test_multiline_adjlist_graph(self):
+        G = self.G
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_multiline_adjlist(G, fname)
+        H = nx.read_multiline_adjlist(fname)
+        H2 = nx.read_multiline_adjlist(fname)
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_multiline_adjlist_digraph(self):
+        G = self.DG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_multiline_adjlist(G, fname)
+        H = nx.read_multiline_adjlist(fname, create_using=nx.DiGraph())
+        H2 = nx.read_multiline_adjlist(fname, create_using=nx.DiGraph())
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_multiline_adjlist_integers(self):
+        (fd, fname) = tempfile.mkstemp()
+        G = nx.convert_node_labels_to_integers(self.G)
+        nx.write_multiline_adjlist(G, fname)
+        H = nx.read_multiline_adjlist(fname, nodetype=int)
+        H2 = nx.read_multiline_adjlist(fname, nodetype=int)
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_multiline_adjlist_multigraph(self):
+        G = self.XG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_multiline_adjlist(G, fname)
+        H = nx.read_multiline_adjlist(fname, nodetype=int, create_using=nx.MultiGraph())
+        H2 = nx.read_multiline_adjlist(
+            fname, nodetype=int, create_using=nx.MultiGraph()
+        )
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_multiline_adjlist_multidigraph(self):
+        G = self.XDG
+        (fd, fname) = tempfile.mkstemp()
+        nx.write_multiline_adjlist(G, fname)
+        H = nx.read_multiline_adjlist(
+            fname, nodetype=int, create_using=nx.MultiDiGraph()
+        )
+        H2 = nx.read_multiline_adjlist(
+            fname, nodetype=int, create_using=nx.MultiDiGraph()
+        )
+        assert H is not H2  # they should be different graphs
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))
+        os.close(fd)
+        os.unlink(fname)
+
+    def test_multiline_adjlist_delimiter(self):
+        fh = io.BytesIO()
+        G = nx.path_graph(3)
+        nx.write_multiline_adjlist(G, fh, delimiter=":")
+        fh.seek(0)
+        H = nx.read_multiline_adjlist(fh, nodetype=int, delimiter=":")
+        assert nodes_equal(list(H), list(G))
+        assert edges_equal(list(H.edges()), list(G.edges()))

shared/package-files/74/74ba44a36438f5d10c9a8d777f8f5a7381f2d738b1883b155de85acc125f8b9e/nonascii.py

@@ -0,0 +1,4 @@
+# coding: iso-8859-5
+# (Unlikely to be the default encoding for most testers.)
+# ������������������� <- Cyrillic characters
+u = "����"

shared/package-files/74/74bf2c9f2530363853404d854367570148d36e8117847d8939e850a2f1df8b17/type_fwd.h

@@ -0,0 +1,28 @@
+// 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
+
+namespace parquet {
+
+class Decryptor;
+class Encryptor;
+
+class InternalFileDecryptor;
+class InternalFileEncryptor;
+
+}  // namespace parquet

shared/package-files/74/74dfbdd489c7257280129e4310ebc2f1baa5ee71feac829ef373bc0d40f3d15a/bartlett_window_native.h

@@ -0,0 +1,24 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor bartlett_window(int64_t window_length, c10::optional<at::ScalarType> dtype={}, c10::optional<at::Layout> layout={}, c10::optional<at::Device> device={}, c10::optional<bool> pin_memory={});
+TORCH_API at::Tensor & bartlett_window_out(int64_t window_length, at::Tensor & out);
+TORCH_API at::Tensor bartlett_window(int64_t window_length, bool periodic, c10::optional<at::ScalarType> dtype={}, c10::optional<at::Layout> layout={}, c10::optional<at::Device> device={}, c10::optional<bool> pin_memory={});
+TORCH_API at::Tensor & bartlett_window_periodic_out(int64_t window_length, bool periodic, at::Tensor & out);
+} // namespace native
+} // namespace at

shared/package-files/74/74f9be00518ea6c3d0a8651ec053f14fa9a337dbb1bcbde3a410f753bc970bc9/_ctc_loss_backward_cpu_dispatch.h

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

shared/package-files/7d/7d012c25bec6b3ff55abd574c47202074105c4d446cb1b9baf8c386459867316/__init__.py

@@ -0,0 +1,904 @@
+import os
+import re
+import abc
+import csv
+import sys
+from .. import zipp
+import email
+import pathlib
+import operator
+import textwrap
+import warnings
+import functools
+import itertools
+import posixpath
+import collections
+
+from . import _adapters, _meta, _py39compat
+from ._collections import FreezableDefaultDict, Pair
+from ._compat import (
+    NullFinder,
+    install,
+    pypy_partial,
+)
+from ._functools import method_cache, pass_none
+from ._itertools import always_iterable, unique_everseen
+from ._meta import PackageMetadata, SimplePath
+
+from contextlib import suppress
+from importlib import import_module
+from importlib.abc import MetaPathFinder
+from itertools import starmap
+from typing import List, Mapping, Optional
+
+
+__all__ = [
+    'Distribution',
+    'DistributionFinder',
+    'PackageMetadata',
+    'PackageNotFoundError',
+    'distribution',
+    'distributions',
+    'entry_points',
+    'files',
+    'metadata',
+    'packages_distributions',
+    'requires',
+    'version',
+]
+
+
+class PackageNotFoundError(ModuleNotFoundError):
+    """The package was not found."""
+
+    def __str__(self):
+        return f"No package metadata was found for {self.name}"
+
+    @property
+    def name(self):
+        (name,) = self.args
+        return name
+
+
+class Sectioned:
+    """
+    A simple entry point config parser for performance
+
+    >>> for item in Sectioned.read(Sectioned._sample):
+    ...     print(item)
+    Pair(name='sec1', value='# comments ignored')
+    Pair(name='sec1', value='a = 1')
+    Pair(name='sec1', value='b = 2')
+    Pair(name='sec2', value='a = 2')
+
+    >>> res = Sectioned.section_pairs(Sectioned._sample)
+    >>> item = next(res)
+    >>> item.name
+    'sec1'
+    >>> item.value
+    Pair(name='a', value='1')
+    >>> item = next(res)
+    >>> item.value
+    Pair(name='b', value='2')
+    >>> item = next(res)
+    >>> item.name
+    'sec2'
+    >>> item.value
+    Pair(name='a', value='2')
+    >>> list(res)
+    []
+    """
+
+    _sample = textwrap.dedent(
+        """
+        [sec1]
+        # comments ignored
+        a = 1
+        b = 2
+
+        [sec2]
+        a = 2
+        """
+    ).lstrip()
+
+    @classmethod
+    def section_pairs(cls, text):
+        return (
+            section._replace(value=Pair.parse(section.value))
+            for section in cls.read(text, filter_=cls.valid)
+            if section.name is not None
+        )
+
+    @staticmethod
+    def read(text, filter_=None):
+        lines = filter(filter_, map(str.strip, text.splitlines()))
+        name = None
+        for value in lines:
+            section_match = value.startswith('[') and value.endswith(']')
+            if section_match:
+                name = value.strip('[]')
+                continue
+            yield Pair(name, value)
+
+    @staticmethod
+    def valid(line):
+        return line and not line.startswith('#')
+
+
+class DeprecatedTuple:
+    """
+    Provide subscript item access for backward compatibility.
+
+    >>> recwarn = getfixture('recwarn')
+    >>> ep = EntryPoint(name='name', value='value', group='group')
+    >>> ep[:]
+    ('name', 'value', 'group')
+    >>> ep[0]
+    'name'
+    >>> len(recwarn)
+    1
+    """
+
+    # Do not remove prior to 2023-05-01 or Python 3.13
+    _warn = functools.partial(
+        warnings.warn,
+        "EntryPoint tuple interface is deprecated. Access members by name.",
+        DeprecationWarning,
+        stacklevel=pypy_partial(2),
+    )
+
+    def __getitem__(self, item):
+        self._warn()
+        return self._key()[item]
+
+
+class EntryPoint(DeprecatedTuple):
+    """An entry point as defined by Python packaging conventions.
+
+    See `the packaging docs on entry points
+    <https://packaging.python.org/specifications/entry-points/>`_
+    for more information.
+
+    >>> ep = EntryPoint(
+    ...     name=None, group=None, value='package.module:attr [extra1, extra2]')
+    >>> ep.module
+    'package.module'
+    >>> ep.attr
+    'attr'
+    >>> ep.extras
+    ['extra1', 'extra2']
+    """
+
+    pattern = re.compile(
+        r'(?P<module>[\w.]+)\s*'
+        r'(:\s*(?P<attr>[\w.]+)\s*)?'
+        r'((?P<extras>\[.*\])\s*)?$'
+    )
+    """
+    A regular expression describing the syntax for an entry point,
+    which might look like:
+
+        - module
+        - package.module
+        - package.module:attribute
+        - package.module:object.attribute
+        - package.module:attr [extra1, extra2]
+
+    Other combinations are possible as well.
+
+    The expression is lenient about whitespace around the ':',
+    following the attr, and following any extras.
+    """
+
+    name: str
+    value: str
+    group: str
+
+    dist: Optional['Distribution'] = None
+
+    def __init__(self, name, value, group):
+        vars(self).update(name=name, value=value, group=group)
+
+    def load(self):
+        """Load the entry point from its definition. If only a module
+        is indicated by the value, return that module. Otherwise,
+        return the named object.
+        """
+        match = self.pattern.match(self.value)
+        module = import_module(match.group('module'))
+        attrs = filter(None, (match.group('attr') or '').split('.'))
+        return functools.reduce(getattr, attrs, module)
+
+    @property
+    def module(self):
+        match = self.pattern.match(self.value)
+        return match.group('module')
+
+    @property
+    def attr(self):
+        match = self.pattern.match(self.value)
+        return match.group('attr')
+
+    @property
+    def extras(self):
+        match = self.pattern.match(self.value)
+        return re.findall(r'\w+', match.group('extras') or '')
+
+    def _for(self, dist):
+        vars(self).update(dist=dist)
+        return self
+
+    def matches(self, **params):
+        """
+        EntryPoint matches the given parameters.
+
+        >>> ep = EntryPoint(group='foo', name='bar', value='bing:bong [extra1, extra2]')
+        >>> ep.matches(group='foo')
+        True
+        >>> ep.matches(name='bar', value='bing:bong [extra1, extra2]')
+        True
+        >>> ep.matches(group='foo', name='other')
+        False
+        >>> ep.matches()
+        True
+        >>> ep.matches(extras=['extra1', 'extra2'])
+        True
+        >>> ep.matches(module='bing')
+        True
+        >>> ep.matches(attr='bong')
+        True
+        """
+        attrs = (getattr(self, param) for param in params)
+        return all(map(operator.eq, params.values(), attrs))
+
+    def _key(self):
+        return self.name, self.value, self.group
+
+    def __lt__(self, other):
+        return self._key() < other._key()
+
+    def __eq__(self, other):
+        return self._key() == other._key()
+
+    def __setattr__(self, name, value):
+        raise AttributeError("EntryPoint objects are immutable.")
+
+    def __repr__(self):
+        return (
+            f'EntryPoint(name={self.name!r}, value={self.value!r}, '
+            f'group={self.group!r})'
+        )
+
+    def __hash__(self):
+        return hash(self._key())
+
+
+class EntryPoints(tuple):
+    """
+    An immutable collection of selectable EntryPoint objects.
+    """
+
+    __slots__ = ()
+
+    def __getitem__(self, name):  # -> EntryPoint:
+        """
+        Get the EntryPoint in self matching name.
+        """
+        try:
+            return next(iter(self.select(name=name)))
+        except StopIteration:
+            raise KeyError(name)
+
+    def select(self, **params):
+        """
+        Select entry points from self that match the
+        given parameters (typically group and/or name).
+        """
+        return EntryPoints(ep for ep in self if _py39compat.ep_matches(ep, **params))
+
+    @property
+    def names(self):
+        """
+        Return the set of all names of all entry points.
+        """
+        return {ep.name for ep in self}
+
+    @property
+    def groups(self):
+        """
+        Return the set of all groups of all entry points.
+        """
+        return {ep.group for ep in self}
+
+    @classmethod
+    def _from_text_for(cls, text, dist):
+        return cls(ep._for(dist) for ep in cls._from_text(text))
+
+    @staticmethod
+    def _from_text(text):
+        return (
+            EntryPoint(name=item.value.name, value=item.value.value, group=item.name)
+            for item in Sectioned.section_pairs(text or '')
+        )
+
+
+class PackagePath(pathlib.PurePosixPath):
+    """A reference to a path in a package"""
+
+    def read_text(self, encoding='utf-8'):
+        with self.locate().open(encoding=encoding) as stream:
+            return stream.read()
+
+    def read_binary(self):
+        with self.locate().open('rb') as stream:
+            return stream.read()
+
+    def locate(self):
+        """Return a path-like object for this path"""
+        return self.dist.locate_file(self)
+
+
+class FileHash:
+    def __init__(self, spec):
+        self.mode, _, self.value = spec.partition('=')
+
+    def __repr__(self):
+        return f'<FileHash mode: {self.mode} value: {self.value}>'
+
+
+class Distribution(metaclass=abc.ABCMeta):
+    """A Python distribution package."""
+
+    @abc.abstractmethod
+    def read_text(self, filename):
+        """Attempt to load metadata file given by the name.
+
+        :param filename: The name of the file in the distribution info.
+        :return: The text if found, otherwise None.
+        """
+
+    @abc.abstractmethod
+    def locate_file(self, path):
+        """
+        Given a path to a file in this distribution, return a path
+        to it.
+        """
+
+    @classmethod
+    def from_name(cls, name: str):
+        """Return the Distribution for the given package name.
+
+        :param name: The name of the distribution package to search for.
+        :return: The Distribution instance (or subclass thereof) for the named
+            package, if found.
+        :raises PackageNotFoundError: When the named package's distribution
+            metadata cannot be found.
+        :raises ValueError: When an invalid value is supplied for name.
+        """
+        if not name:
+            raise ValueError("A distribution name is required.")
+        try:
+            return next(cls.discover(name=name))
+        except StopIteration:
+            raise PackageNotFoundError(name)
+
+    @classmethod
+    def discover(cls, **kwargs):
+        """Return an iterable of Distribution objects for all packages.
+
+        Pass a ``context`` or pass keyword arguments for constructing
+        a context.
+
+        :context: A ``DistributionFinder.Context`` object.
+        :return: Iterable of Distribution objects for all packages.
+        """
+        context = kwargs.pop('context', None)
+        if context and kwargs:
+            raise ValueError("cannot accept context and kwargs")
+        context = context or DistributionFinder.Context(**kwargs)
+        return itertools.chain.from_iterable(
+            resolver(context) for resolver in cls._discover_resolvers()
+        )
+
+    @staticmethod
+    def at(path):
+        """Return a Distribution for the indicated metadata path
+
+        :param path: a string or path-like object
+        :return: a concrete Distribution instance for the path
+        """
+        return PathDistribution(pathlib.Path(path))
+
+    @staticmethod
+    def _discover_resolvers():
+        """Search the meta_path for resolvers."""
+        declared = (
+            getattr(finder, 'find_distributions', None) for finder in sys.meta_path
+        )
+        return filter(None, declared)
+
+    @property
+    def metadata(self) -> _meta.PackageMetadata:
+        """Return the parsed metadata for this Distribution.
+
+        The returned object will have keys that name the various bits of
+        metadata.  See PEP 566 for details.
+        """
+        text = (
+            self.read_text('METADATA')
+            or self.read_text('PKG-INFO')
+            # This last clause is here to support old egg-info files.  Its
+            # effect is to just end up using the PathDistribution's self._path
+            # (which points to the egg-info file) attribute unchanged.
+            or self.read_text('')
+        )
+        return _adapters.Message(email.message_from_string(text))
+
+    @property
+    def name(self):
+        """Return the 'Name' metadata for the distribution package."""
+        return self.metadata['Name']
+
+    @property
+    def _normalized_name(self):
+        """Return a normalized version of the name."""
+        return Prepared.normalize(self.name)
+
+    @property
+    def version(self):
+        """Return the 'Version' metadata for the distribution package."""
+        return self.metadata['Version']
+
+    @property
+    def entry_points(self):
+        return EntryPoints._from_text_for(self.read_text('entry_points.txt'), self)
+
+    @property
+    def files(self):
+        """Files in this distribution.
+
+        :return: List of PackagePath for this distribution or None
+
+        Result is `None` if the metadata file that enumerates files
+        (i.e. RECORD for dist-info or SOURCES.txt for egg-info) is
+        missing.
+        Result may be empty if the metadata exists but is empty.
+        """
+
+        def make_file(name, hash=None, size_str=None):
+            result = PackagePath(name)
+            result.hash = FileHash(hash) if hash else None
+            result.size = int(size_str) if size_str else None
+            result.dist = self
+            return result
+
+        @pass_none
+        def make_files(lines):
+            return list(starmap(make_file, csv.reader(lines)))
+
+        return make_files(self._read_files_distinfo() or self._read_files_egginfo())
+
+    def _read_files_distinfo(self):
+        """
+        Read the lines of RECORD
+        """
+        text = self.read_text('RECORD')
+        return text and text.splitlines()
+
+    def _read_files_egginfo(self):
+        """
+        SOURCES.txt might contain literal commas, so wrap each line
+        in quotes.
+        """
+        text = self.read_text('SOURCES.txt')
+        return text and map('"{}"'.format, text.splitlines())
+
+    @property
+    def requires(self):
+        """Generated requirements specified for this Distribution"""
+        reqs = self._read_dist_info_reqs() or self._read_egg_info_reqs()
+        return reqs and list(reqs)
+
+    def _read_dist_info_reqs(self):
+        return self.metadata.get_all('Requires-Dist')
+
+    def _read_egg_info_reqs(self):
+        source = self.read_text('requires.txt')
+        return pass_none(self._deps_from_requires_text)(source)
+
+    @classmethod
+    def _deps_from_requires_text(cls, source):
+        return cls._convert_egg_info_reqs_to_simple_reqs(Sectioned.read(source))
+
+    @staticmethod
+    def _convert_egg_info_reqs_to_simple_reqs(sections):
+        """
+        Historically, setuptools would solicit and store 'extra'
+        requirements, including those with environment markers,
+        in separate sections. More modern tools expect each
+        dependency to be defined separately, with any relevant
+        extras and environment markers attached directly to that
+        requirement. This method converts the former to the
+        latter. See _test_deps_from_requires_text for an example.
+        """
+
+        def make_condition(name):
+            return name and f'extra == "{name}"'
+
+        def quoted_marker(section):
+            section = section or ''
+            extra, sep, markers = section.partition(':')
+            if extra and markers:
+                markers = f'({markers})'
+            conditions = list(filter(None, [markers, make_condition(extra)]))
+            return '; ' + ' and '.join(conditions) if conditions else ''
+
+        def url_req_space(req):
+            """
+            PEP 508 requires a space between the url_spec and the quoted_marker.
+            Ref python/importlib_metadata#357.
+            """
+            # '@' is uniquely indicative of a url_req.
+            return ' ' * ('@' in req)
+
+        for section in sections:
+            space = url_req_space(section.value)
+            yield section.value + space + quoted_marker(section.name)
+
+
+class DistributionFinder(MetaPathFinder):
+    """
+    A MetaPathFinder capable of discovering installed distributions.
+    """
+
+    class Context:
+        """
+        Keyword arguments presented by the caller to
+        ``distributions()`` or ``Distribution.discover()``
+        to narrow the scope of a search for distributions
+        in all DistributionFinders.
+
+        Each DistributionFinder may expect any parameters
+        and should attempt to honor the canonical
+        parameters defined below when appropriate.
+        """
+
+        name = None
+        """
+        Specific name for which a distribution finder should match.
+        A name of ``None`` matches all distributions.
+        """
+
+        def __init__(self, **kwargs):
+            vars(self).update(kwargs)
+
+        @property
+        def path(self):
+            """
+            The sequence of directory path that a distribution finder
+            should search.
+
+            Typically refers to Python installed package paths such as
+            "site-packages" directories and defaults to ``sys.path``.
+            """
+            return vars(self).get('path', sys.path)
+
+    @abc.abstractmethod
+    def find_distributions(self, context=Context()):
+        """
+        Find distributions.
+
+        Return an iterable of all Distribution instances capable of
+        loading the metadata for packages matching the ``context``,
+        a DistributionFinder.Context instance.
+        """
+
+
+class FastPath:
+    """
+    Micro-optimized class for searching a path for
+    children.
+
+    >>> FastPath('').children()
+    ['...']
+    """
+
+    @functools.lru_cache()  # type: ignore
+    def __new__(cls, root):
+        return super().__new__(cls)
+
+    def __init__(self, root):
+        self.root = root
+
+    def joinpath(self, child):
+        return pathlib.Path(self.root, child)
+
+    def children(self):
+        with suppress(Exception):
+            return os.listdir(self.root or '.')
+        with suppress(Exception):
+            return self.zip_children()
+        return []
+
+    def zip_children(self):
+        zip_path = zipp.Path(self.root)
+        names = zip_path.root.namelist()
+        self.joinpath = zip_path.joinpath
+
+        return dict.fromkeys(child.split(posixpath.sep, 1)[0] for child in names)
+
+    def search(self, name):
+        return self.lookup(self.mtime).search(name)
+
+    @property
+    def mtime(self):
+        with suppress(OSError):
+            return os.stat(self.root).st_mtime
+        self.lookup.cache_clear()
+
+    @method_cache
+    def lookup(self, mtime):
+        return Lookup(self)
+
+
+class Lookup:
+    def __init__(self, path: FastPath):
+        base = os.path.basename(path.root).lower()
+        base_is_egg = base.endswith(".egg")
+        self.infos = FreezableDefaultDict(list)
+        self.eggs = FreezableDefaultDict(list)
+
+        for child in path.children():
+            low = child.lower()
+            if low.endswith((".dist-info", ".egg-info")):
+                # rpartition is faster than splitext and suitable for this purpose.
+                name = low.rpartition(".")[0].partition("-")[0]
+                normalized = Prepared.normalize(name)
+                self.infos[normalized].append(path.joinpath(child))
+            elif base_is_egg and low == "egg-info":
+                name = base.rpartition(".")[0].partition("-")[0]
+                legacy_normalized = Prepared.legacy_normalize(name)
+                self.eggs[legacy_normalized].append(path.joinpath(child))
+
+        self.infos.freeze()
+        self.eggs.freeze()
+
+    def search(self, prepared):
+        infos = (
+            self.infos[prepared.normalized]
+            if prepared
+            else itertools.chain.from_iterable(self.infos.values())
+        )
+        eggs = (
+            self.eggs[prepared.legacy_normalized]
+            if prepared
+            else itertools.chain.from_iterable(self.eggs.values())
+        )
+        return itertools.chain(infos, eggs)
+
+
+class Prepared:
+    """
+    A prepared search for metadata on a possibly-named package.
+    """
+
+    normalized = None
+    legacy_normalized = None
+
+    def __init__(self, name):
+        self.name = name
+        if name is None:
+            return
+        self.normalized = self.normalize(name)
+        self.legacy_normalized = self.legacy_normalize(name)
+
+    @staticmethod
+    def normalize(name):
+        """
+        PEP 503 normalization plus dashes as underscores.
+        """
+        return re.sub(r"[-_.]+", "-", name).lower().replace('-', '_')
+
+    @staticmethod
+    def legacy_normalize(name):
+        """
+        Normalize the package name as found in the convention in
+        older packaging tools versions and specs.
+        """
+        return name.lower().replace('-', '_')
+
+    def __bool__(self):
+        return bool(self.name)
+
+
+@install
+class MetadataPathFinder(NullFinder, DistributionFinder):
+    """A degenerate finder for distribution packages on the file system.
+
+    This finder supplies only a find_distributions() method for versions
+    of Python that do not have a PathFinder find_distributions().
+    """
+
+    def find_distributions(self, context=DistributionFinder.Context()):
+        """
+        Find distributions.
+
+        Return an iterable of all Distribution instances capable of
+        loading the metadata for packages matching ``context.name``
+        (or all names if ``None`` indicated) along the paths in the list
+        of directories ``context.path``.
+        """
+        found = self._search_paths(context.name, context.path)
+        return map(PathDistribution, found)
+
+    @classmethod
+    def _search_paths(cls, name, paths):
+        """Find metadata directories in paths heuristically."""
+        prepared = Prepared(name)
+        return itertools.chain.from_iterable(
+            path.search(prepared) for path in map(FastPath, paths)
+        )
+
+    def invalidate_caches(cls):
+        FastPath.__new__.cache_clear()
+
+
+class PathDistribution(Distribution):
+    def __init__(self, path: SimplePath):
+        """Construct a distribution.
+
+        :param path: SimplePath indicating the metadata directory.
+        """
+        self._path = path
+
+    def read_text(self, filename):
+        with suppress(
+            FileNotFoundError,
+            IsADirectoryError,
+            KeyError,
+            NotADirectoryError,
+            PermissionError,
+        ):
+            return self._path.joinpath(filename).read_text(encoding='utf-8')
+
+    read_text.__doc__ = Distribution.read_text.__doc__
+
+    def locate_file(self, path):
+        return self._path.parent / path
+
+    @property
+    def _normalized_name(self):
+        """
+        Performance optimization: where possible, resolve the
+        normalized name from the file system path.
+        """
+        stem = os.path.basename(str(self._path))
+        return (
+            pass_none(Prepared.normalize)(self._name_from_stem(stem))
+            or super()._normalized_name
+        )
+
+    @staticmethod
+    def _name_from_stem(stem):
+        """
+        >>> PathDistribution._name_from_stem('foo-3.0.egg-info')
+        'foo'
+        >>> PathDistribution._name_from_stem('CherryPy-3.0.dist-info')
+        'CherryPy'
+        >>> PathDistribution._name_from_stem('face.egg-info')
+        'face'
+        >>> PathDistribution._name_from_stem('foo.bar')
+        """
+        filename, ext = os.path.splitext(stem)
+        if ext not in ('.dist-info', '.egg-info'):
+            return
+        name, sep, rest = filename.partition('-')
+        return name
+
+
+def distribution(distribution_name):
+    """Get the ``Distribution`` instance for the named package.
+
+    :param distribution_name: The name of the distribution package as a string.
+    :return: A ``Distribution`` instance (or subclass thereof).
+    """
+    return Distribution.from_name(distribution_name)
+
+
+def distributions(**kwargs):
+    """Get all ``Distribution`` instances in the current environment.
+
+    :return: An iterable of ``Distribution`` instances.
+    """
+    return Distribution.discover(**kwargs)
+
+
+def metadata(distribution_name) -> _meta.PackageMetadata:
+    """Get the metadata for the named package.
+
+    :param distribution_name: The name of the distribution package to query.
+    :return: A PackageMetadata containing the parsed metadata.
+    """
+    return Distribution.from_name(distribution_name).metadata
+
+
+def version(distribution_name):
+    """Get the version string for the named package.
+
+    :param distribution_name: The name of the distribution package to query.
+    :return: The version string for the package as defined in the package's
+        "Version" metadata key.
+    """
+    return distribution(distribution_name).version
+
+
+_unique = functools.partial(
+    unique_everseen,
+    key=_py39compat.normalized_name,
+)
+"""
+Wrapper for ``distributions`` to return unique distributions by name.
+"""
+
+
+def entry_points(**params) -> EntryPoints:
+    """Return EntryPoint objects for all installed packages.
+
+    Pass selection parameters (group or name) to filter the
+    result to entry points matching those properties (see
+    EntryPoints.select()).
+
+    :return: EntryPoints for all installed packages.
+    """
+    eps = itertools.chain.from_iterable(
+        dist.entry_points for dist in _unique(distributions())
+    )
+    return EntryPoints(eps).select(**params)
+
+
+def files(distribution_name):
+    """Return a list of files for the named package.
+
+    :param distribution_name: The name of the distribution package to query.
+    :return: List of files composing the distribution.
+    """
+    return distribution(distribution_name).files
+
+
+def requires(distribution_name):
+    """
+    Return a list of requirements for the named package.
+
+    :return: An iterator of requirements, suitable for
+        packaging.requirement.Requirement.
+    """
+    return distribution(distribution_name).requires
+
+
+def packages_distributions() -> Mapping[str, List[str]]:
+    """
+    Return a mapping of top-level packages to their
+    distributions.
+
+    >>> import collections.abc
+    >>> pkgs = packages_distributions()
+    >>> all(isinstance(dist, collections.abc.Sequence) for dist in pkgs.values())
+    True
+    """
+    pkg_to_dist = collections.defaultdict(list)
+    for dist in distributions():
+        for pkg in _top_level_declared(dist) or _top_level_inferred(dist):
+            pkg_to_dist[pkg].append(dist.metadata['Name'])
+    return dict(pkg_to_dist)
+
+
+def _top_level_declared(dist):
+    return (dist.read_text('top_level.txt') or '').split()
+
+
+def _top_level_inferred(dist):
+    return {
+        f.parts[0] if len(f.parts) > 1 else f.with_suffix('').name
+        for f in always_iterable(dist.files)
+        if f.suffix == ".py"
+    }