diff --git a/.gitattributes b/.gitattributes
index eb4ccc665c72307de2e3b8474a0decd1af5e872f..790279177569241059827f4523457df016df7a28 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1738,3 +1738,5 @@ vllm/lib/python3.10/site-packages/cupy/_core/_kernel.cpython-310-x86_64-linux-gn
vllm/lib/python3.10/site-packages/cupy/_core/_routines_math.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
vllm/lib/python3.10/site-packages/cupy/_core/_memory_range.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
vllm/lib/python3.10/site-packages/cupy/_core/_dtype.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+videollama2/lib/python3.10/site-packages/contourpy/_contourpy.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+vllm/lib/python3.10/site-packages/cupy/cuda/jitify.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
diff --git a/parrot/lib/python3.10/site-packages/multidict-6.1.0.dist-info/LICENSE b/parrot/lib/python3.10/site-packages/multidict-6.1.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..8727172ae058e56805bd8ed0f988b6788711dcfd
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/multidict-6.1.0.dist-info/LICENSE
@@ -0,0 +1,13 @@
+ Copyright 2016 Andrew Svetlov and aio-libs contributors
+
+ Licensed 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.
diff --git a/parrot/lib/python3.10/site-packages/narwhals/__pycache__/group_by.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/__pycache__/group_by.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dc594105044af700c0ad0193146bb7248d9e11a9
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/__pycache__/group_by.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/__pycache__/translate.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/__pycache__/translate.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cce82a4ac16a3f4bfeff79a9044d9eea88d9a22d
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/__pycache__/translate.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/__pycache__/typing.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/__pycache__/typing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a0744cb673d279f64b28a88df63c8ad8e7ac70c3
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/__pycache__/typing.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/dataframe.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/dataframe.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e6ae7b2b074506702859a3e9ef41c05c4094ea67
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/_arrow/__pycache__/dataframe.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_duckdb/__init__.py b/parrot/lib/python3.10/site-packages/narwhals/_duckdb/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/__init__.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5119c0e2df88cc2b98c388bfd345a263e702d764
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/__init__.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/series.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/series.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1116af001f8cc7c2ba8a94558b59acc40b703e24
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/_duckdb/__pycache__/series.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_duckdb/series.py b/parrot/lib/python3.10/site-packages/narwhals/_duckdb/series.py
new file mode 100644
index 0000000000000000000000000000000000000000..f19a6f76fd1fb3fbfdbe7bba2b3afbb9c20801fa
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/narwhals/_duckdb/series.py
@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any
+
+from narwhals._duckdb.dataframe import map_duckdb_dtype_to_narwhals_dtype
+
+
+class DuckDBInterchangeSeries:
+ def __init__(self, df: Any) -> None:
+ self._native_series = df
+
+ def __narwhals_series__(self) -> Any:
+ return self
+
+ def __getattr__(self, attr: str) -> Any:
+ if attr == "dtype":
+ return map_duckdb_dtype_to_narwhals_dtype(self._native_series.types[0])
+ msg = ( # pragma: no cover
+ f"Attribute {attr} is not supported for metadata-only dataframes.\n\n"
+ "If you would like to see this kind of object better supported in "
+ "Narwhals, please open a feature request "
+ "at https://github.com/narwhals-dev/narwhals/issues."
+ )
+ raise NotImplementedError(msg) # pragma: no cover
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_ibis/__pycache__/__init__.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/_ibis/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4b786eaa02b69e770ee6c41b2aefe29ea3245013
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/_ibis/__pycache__/__init__.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_ibis/__pycache__/series.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/_ibis/__pycache__/series.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e5f526ebddb42ce105ee0638f0fa7832db05ba68
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/_ibis/__pycache__/series.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_ibis/series.py b/parrot/lib/python3.10/site-packages/narwhals/_ibis/series.py
new file mode 100644
index 0000000000000000000000000000000000000000..73e3b6d47107fdb172c074d1cfcdbbec2d00fd15
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/narwhals/_ibis/series.py
@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any
+
+from narwhals._ibis.dataframe import map_ibis_dtype_to_narwhals_dtype
+
+
+class IbisInterchangeSeries:
+ def __init__(self, df: Any) -> None:
+ self._native_series = df
+
+ def __narwhals_series__(self) -> Any:
+ return self
+
+ def __getattr__(self, attr: str) -> Any:
+ if attr == "dtype":
+ return map_ibis_dtype_to_narwhals_dtype(self._native_series.type())
+ msg = (
+ f"Attribute {attr} is not supported for metadata-only dataframes.\n\n"
+ "If you would like to see this kind of object better supported in "
+ "Narwhals, please open a feature request "
+ "at https://github.com/narwhals-dev/narwhals/issues."
+ )
+ raise NotImplementedError(msg)
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_interchange/__init__.py b/parrot/lib/python3.10/site-packages/narwhals/_interchange/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_interchange/__pycache__/dataframe.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/_interchange/__pycache__/dataframe.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a88b4ec3b4c5f0ef44ecca11f527de8921398956
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/_interchange/__pycache__/dataframe.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_interchange/__pycache__/series.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/_interchange/__pycache__/series.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d359ba0ea598631e47b918803518f82a20b6efe7
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/_interchange/__pycache__/series.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_interchange/dataframe.py b/parrot/lib/python3.10/site-packages/narwhals/_interchange/dataframe.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e9775258742abd841d336f1c9d09b1a6ac51185
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/narwhals/_interchange/dataframe.py
@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import enum
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import NoReturn
+
+from narwhals import dtypes
+
+if TYPE_CHECKING:
+ from narwhals._interchange.series import InterchangeSeries
+
+
+class DtypeKind(enum.IntEnum):
+ # https://data-apis.org/dataframe-protocol/latest/API.html
+ INT = 0
+ UINT = 1
+ FLOAT = 2
+ BOOL = 20
+ STRING = 21 # UTF-8
+ DATETIME = 22
+ CATEGORICAL = 23
+
+
+def map_interchange_dtype_to_narwhals_dtype(
+ interchange_dtype: tuple[DtypeKind, int, Any, Any],
+) -> dtypes.DType:
+ if interchange_dtype[0] == DtypeKind.INT:
+ if interchange_dtype[1] == 64:
+ return dtypes.Int64()
+ if interchange_dtype[1] == 32:
+ return dtypes.Int32()
+ if interchange_dtype[1] == 16:
+ return dtypes.Int16()
+ if interchange_dtype[1] == 8:
+ return dtypes.Int8()
+ msg = "Invalid bit width for INT" # pragma: no cover
+ raise AssertionError(msg)
+ if interchange_dtype[0] == DtypeKind.UINT:
+ if interchange_dtype[1] == 64:
+ return dtypes.UInt64()
+ if interchange_dtype[1] == 32:
+ return dtypes.UInt32()
+ if interchange_dtype[1] == 16:
+ return dtypes.UInt16()
+ if interchange_dtype[1] == 8:
+ return dtypes.UInt8()
+ msg = "Invalid bit width for UINT" # pragma: no cover
+ raise AssertionError(msg)
+ if interchange_dtype[0] == DtypeKind.FLOAT:
+ if interchange_dtype[1] == 64:
+ return dtypes.Float64()
+ if interchange_dtype[1] == 32:
+ return dtypes.Float32()
+ msg = "Invalid bit width for FLOAT" # pragma: no cover
+ raise AssertionError(msg)
+ if interchange_dtype[0] == DtypeKind.BOOL:
+ return dtypes.Boolean()
+ if interchange_dtype[0] == DtypeKind.STRING:
+ return dtypes.String()
+ if interchange_dtype[0] == DtypeKind.DATETIME:
+ return dtypes.Datetime()
+ if interchange_dtype[0] == DtypeKind.CATEGORICAL: # pragma: no cover
+ # upstream issue: https://github.com/ibis-project/ibis/issues/9570
+ return dtypes.Categorical()
+ msg = f"Invalid dtype, got: {interchange_dtype}" # pragma: no cover
+ raise AssertionError(msg)
+
+
+class InterchangeFrame:
+ def __init__(self, df: Any) -> None:
+ self._native_frame = df
+ self._interchange_frame = df.__dataframe__()
+
+ def __narwhals_dataframe__(self) -> Any:
+ return self
+
+ def __getitem__(self, item: str) -> InterchangeSeries:
+ from narwhals._interchange.series import InterchangeSeries
+
+ return InterchangeSeries(self._interchange_frame.get_column_by_name(item))
+
+ @property
+ def schema(self) -> dict[str, dtypes.DType]:
+ return {
+ column_name: map_interchange_dtype_to_narwhals_dtype(
+ self._interchange_frame.get_column_by_name(column_name).dtype
+ )
+ for column_name in self._interchange_frame.column_names()
+ }
+
+ def __getattr__(self, attr: str) -> NoReturn:
+ msg = (
+ f"Attribute {attr} is not supported for metadata-only dataframes.\n\n"
+ "Hint: you probably called `nw.from_native` on an object which isn't fully "
+ "supported by Narwhals, yet implements `__dataframe__`. If you would like to "
+ "see this kind of object supported in Narwhals, please open a feature request "
+ "at https://github.com/narwhals-dev/narwhals/issues."
+ )
+ raise NotImplementedError(msg)
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/__pycache__/namespace.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/__pycache__/namespace.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b2f2f350771ac61b674d4d19311dee02a2efb703
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/__pycache__/namespace.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/__pycache__/selectors.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/__pycache__/selectors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cb27f9d7bc9fa1f6ba9c0c5aa344d742dca7058f
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/__pycache__/selectors.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/__pycache__/series.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/__pycache__/series.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2fd8e7c2a6efb161a2e1f76b17a0c81be982689c
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/__pycache__/series.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/__pycache__/typing.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/__pycache__/typing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e95fd4b09a90969c97112582a67904abdc98f633
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/__pycache__/typing.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/dataframe.py b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/dataframe.py
new file mode 100644
index 0000000000000000000000000000000000000000..446c68a133f9cba294fed4151e594e565b356064
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/dataframe.py
@@ -0,0 +1,730 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Iterable
+from typing import Iterator
+from typing import Literal
+from typing import Sequence
+from typing import overload
+
+from narwhals._expression_parsing import evaluate_into_exprs
+from narwhals._pandas_like.expr import PandasLikeExpr
+from narwhals._pandas_like.utils import broadcast_series
+from narwhals._pandas_like.utils import convert_str_slice_to_int_slice
+from narwhals._pandas_like.utils import create_native_series
+from narwhals._pandas_like.utils import horizontal_concat
+from narwhals._pandas_like.utils import translate_dtype
+from narwhals._pandas_like.utils import validate_dataframe_comparand
+from narwhals.dependencies import get_cudf
+from narwhals.dependencies import get_modin
+from narwhals.dependencies import get_pandas
+from narwhals.dependencies import is_numpy_array
+from narwhals.utils import Implementation
+from narwhals.utils import flatten
+from narwhals.utils import generate_unique_token
+from narwhals.utils import is_sequence_but_not_str
+from narwhals.utils import parse_columns_to_drop
+
+if TYPE_CHECKING:
+ import numpy as np
+ import pandas as pd
+ from typing_extensions import Self
+
+ from narwhals._pandas_like.group_by import PandasLikeGroupBy
+ from narwhals._pandas_like.namespace import PandasLikeNamespace
+ from narwhals._pandas_like.series import PandasLikeSeries
+ from narwhals._pandas_like.typing import IntoPandasLikeExpr
+ from narwhals.dtypes import DType
+
+
+class PandasLikeDataFrame:
+ # --- not in the spec ---
+ def __init__(
+ self,
+ native_dataframe: Any,
+ *,
+ implementation: Implementation,
+ backend_version: tuple[int, ...],
+ ) -> None:
+ self._validate_columns(native_dataframe.columns)
+ self._native_frame = native_dataframe
+ self._implementation = implementation
+ self._backend_version = backend_version
+
+ def __narwhals_dataframe__(self) -> Self:
+ return self
+
+ def __narwhals_lazyframe__(self) -> Self:
+ return self
+
+ def __narwhals_namespace__(self) -> PandasLikeNamespace:
+ from narwhals._pandas_like.namespace import PandasLikeNamespace
+
+ return PandasLikeNamespace(self._implementation, self._backend_version)
+
+ def __native_namespace__(self) -> Any:
+ if self._implementation is Implementation.PANDAS:
+ return get_pandas()
+ if self._implementation is Implementation.MODIN: # pragma: no cover
+ return get_modin()
+ if self._implementation is Implementation.CUDF: # pragma: no cover
+ return get_cudf()
+ msg = f"Expected pandas/modin/cudf, got: {type(self._implementation)}" # pragma: no cover
+ raise AssertionError(msg)
+
+ def __len__(self) -> int:
+ return len(self._native_frame)
+
+ def _validate_columns(self, columns: pd.Index) -> None:
+ try:
+ len_unique_columns = len(columns.drop_duplicates())
+ except Exception: # noqa: BLE001 # pragma: no cover
+ msg = f"Expected hashable (e.g. str or int) column names, got: {columns}"
+ raise ValueError(msg) from None
+
+ if len(columns) != len_unique_columns:
+ msg = f"Expected unique column names, got: {columns}"
+ raise ValueError(msg)
+
+ def _from_native_frame(self, df: Any) -> Self:
+ return self.__class__(
+ df,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def get_column(self, name: str) -> PandasLikeSeries:
+ from narwhals._pandas_like.series import PandasLikeSeries
+
+ return PandasLikeSeries(
+ self._native_frame.loc[:, name],
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def __array__(self, dtype: Any = None, copy: bool | None = None) -> np.ndarray:
+ return self.to_numpy(dtype=dtype, copy=copy)
+
+ @overload
+ def __getitem__(self, item: tuple[Sequence[int], str | int]) -> PandasLikeSeries: ... # type: ignore[overload-overlap]
+
+ @overload
+ def __getitem__(self, item: Sequence[int]) -> PandasLikeDataFrame: ...
+
+ @overload
+ def __getitem__(self, item: str) -> PandasLikeSeries: ... # type: ignore[overload-overlap]
+
+ @overload
+ def __getitem__(self, item: Sequence[str]) -> PandasLikeDataFrame: ...
+
+ @overload
+ def __getitem__(self, item: slice) -> PandasLikeDataFrame: ...
+
+ @overload
+ def __getitem__(self, item: tuple[slice, slice]) -> Self: ...
+
+ @overload
+ def __getitem__(
+ self, item: tuple[Sequence[int], Sequence[int] | slice]
+ ) -> PandasLikeDataFrame: ...
+
+ @overload
+ def __getitem__(self, item: tuple[slice, Sequence[int]]) -> PandasLikeDataFrame: ...
+
+ def __getitem__(
+ self,
+ item: str
+ | int
+ | slice
+ | Sequence[int]
+ | Sequence[str]
+ | tuple[Sequence[int], str | int]
+ | tuple[slice | Sequence[int], Sequence[int] | slice]
+ | tuple[slice, slice],
+ ) -> PandasLikeSeries | PandasLikeDataFrame:
+ if isinstance(item, tuple):
+ item = tuple(list(i) if is_sequence_but_not_str(i) else i for i in item)
+
+ if isinstance(item, str):
+ from narwhals._pandas_like.series import PandasLikeSeries
+
+ return PandasLikeSeries(
+ self._native_frame.loc[:, item],
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ elif (
+ isinstance(item, tuple)
+ and len(item) == 2
+ and is_sequence_but_not_str(item[1])
+ ):
+ if len(item[1]) == 0:
+ # Return empty dataframe
+ return self._from_native_frame(self._native_frame.__class__())
+ if all(isinstance(x, int) for x in item[1]):
+ return self._from_native_frame(self._native_frame.iloc[item])
+ if all(isinstance(x, str) for x in item[1]):
+ indexer = (
+ item[0],
+ self._native_frame.columns.get_indexer(item[1]),
+ )
+ return self._from_native_frame(self._native_frame.iloc[indexer])
+ msg = (
+ f"Expected sequence str or int, got: {type(item[1])}" # pragma: no cover
+ )
+ raise TypeError(msg) # pragma: no cover
+
+ elif isinstance(item, tuple) and len(item) == 2 and isinstance(item[1], slice):
+ columns = self._native_frame.columns
+ if isinstance(item[1].start, str) or isinstance(item[1].stop, str):
+ start, stop, step = convert_str_slice_to_int_slice(item[1], columns)
+ return self._from_native_frame(
+ self._native_frame.iloc[item[0], slice(start, stop, step)]
+ )
+ if isinstance(item[1].start, int) or isinstance(item[1].stop, int):
+ return self._from_native_frame(
+ self._native_frame.iloc[
+ item[0], slice(item[1].start, item[1].stop, item[1].step)
+ ]
+ )
+ msg = f"Expected slice of integers or strings, got: {type(item[1])}" # pragma: no cover
+ raise TypeError(msg) # pragma: no cover
+
+ elif isinstance(item, tuple) and len(item) == 2:
+ from narwhals._pandas_like.series import PandasLikeSeries
+
+ if isinstance(item[1], str):
+ item = (item[0], self._native_frame.columns.get_loc(item[1])) # type: ignore[assignment]
+ native_series = self._native_frame.iloc[item]
+ elif isinstance(item[1], int):
+ native_series = self._native_frame.iloc[item]
+ else: # pragma: no cover
+ msg = f"Expected str or int, got: {type(item[1])}"
+ raise TypeError(msg)
+
+ return PandasLikeSeries(
+ native_series,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ elif is_sequence_but_not_str(item) or (is_numpy_array(item) and item.ndim == 1):
+ if all(isinstance(x, str) for x in item) and len(item) > 0:
+ return self._from_native_frame(self._native_frame.loc[:, item])
+ return self._from_native_frame(self._native_frame.iloc[item])
+
+ elif isinstance(item, slice):
+ if isinstance(item.start, str) or isinstance(item.stop, str):
+ start, stop, step = convert_str_slice_to_int_slice(
+ item, self._native_frame.columns
+ )
+ return self._from_native_frame(
+ self._native_frame.iloc[:, slice(start, stop, step)]
+ )
+ return self._from_native_frame(self._native_frame.iloc[item])
+
+ else: # pragma: no cover
+ msg = f"Expected str or slice, got: {type(item)}"
+ raise TypeError(msg)
+
+ # --- properties ---
+ @property
+ def columns(self) -> list[str]:
+ return self._native_frame.columns.tolist() # type: ignore[no-any-return]
+
+ def rows(
+ self, *, named: bool = False
+ ) -> list[tuple[Any, ...]] | list[dict[str, Any]]:
+ if not named:
+ return list(self._native_frame.itertuples(index=False, name=None))
+
+ return self._native_frame.to_dict(orient="records") # type: ignore[no-any-return]
+
+ def iter_rows(
+ self,
+ *,
+ named: bool = False,
+ buffer_size: int = 512,
+ ) -> Iterator[list[tuple[Any, ...]]] | Iterator[list[dict[str, Any]]]:
+ """
+ NOTE:
+ The param ``buffer_size`` is only here for compatibility with the polars API
+ and has no effect on the output.
+ """
+ if not named:
+ yield from self._native_frame.itertuples(index=False, name=None)
+ else:
+ col_names = self._native_frame.columns
+ yield from (
+ dict(zip(col_names, row))
+ for row in self._native_frame.itertuples(index=False)
+ ) # type: ignore[misc]
+
+ @property
+ def schema(self) -> dict[str, DType]:
+ return {
+ col: translate_dtype(self._native_frame.loc[:, col])
+ for col in self._native_frame.columns
+ }
+
+ def collect_schema(self) -> dict[str, DType]:
+ return self.schema
+
+ # --- reshape ---
+ def select(
+ self,
+ *exprs: IntoPandasLikeExpr,
+ **named_exprs: IntoPandasLikeExpr,
+ ) -> Self:
+ if exprs and all(isinstance(x, str) for x in exprs) and not named_exprs:
+ # This is a simple slice => fastpath!
+ return self._from_native_frame(self._native_frame.loc[:, list(exprs)])
+ new_series = evaluate_into_exprs(self, *exprs, **named_exprs)
+ if not new_series:
+ # return empty dataframe, like Polars does
+ return self._from_native_frame(self._native_frame.__class__())
+ new_series = broadcast_series(new_series)
+ df = horizontal_concat(
+ new_series,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+ return self._from_native_frame(df)
+
+ def drop_nulls(self, subset: str | list[str] | None) -> Self:
+ if subset is None:
+ return self._from_native_frame(self._native_frame.dropna(axis=0))
+ subset = [subset] if isinstance(subset, str) else subset
+ plx = self.__narwhals_namespace__()
+ return self.filter(~plx.any_horizontal(plx.col(*subset).is_null()))
+
+ def with_row_index(self, name: str) -> Self:
+ row_index = create_native_series(
+ range(len(self._native_frame)),
+ index=self._native_frame.index,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ ).alias(name)
+ return self._from_native_frame(
+ horizontal_concat(
+ [row_index._native_series, self._native_frame],
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+ )
+
+ def row(self, row: int) -> tuple[Any, ...]:
+ return tuple(x for x in self._native_frame.iloc[row])
+
+ def filter(
+ self,
+ *predicates: IntoPandasLikeExpr,
+ ) -> Self:
+ plx = self.__narwhals_namespace__()
+ if (
+ len(predicates) == 1
+ and isinstance(predicates[0], list)
+ and all(isinstance(x, bool) for x in predicates[0])
+ ):
+ _mask = predicates[0]
+ else:
+ expr = plx.all_horizontal(*predicates)
+ # Safety: all_horizontal's expression only returns a single column.
+ mask = expr._call(self)[0]
+ _mask = validate_dataframe_comparand(self._native_frame.index, mask)
+ return self._from_native_frame(self._native_frame.loc[_mask])
+
+ def with_columns(
+ self,
+ *exprs: IntoPandasLikeExpr,
+ **named_exprs: IntoPandasLikeExpr,
+ ) -> Self:
+ index = self._native_frame.index
+ new_columns = evaluate_into_exprs(self, *exprs, **named_exprs)
+
+ if not new_columns and len(self) == 0:
+ return self
+
+ # If the inputs are all Expressions which return full columns
+ # (as opposed to scalars), we can use a fast path (concat, instead of assign).
+ # We can't use the fastpath if any input is not an expression (e.g.
+ # if it's a Series) because then we might be changing its flags.
+ # See `test_memmap` for an example of where this is necessary.
+ fast_path = (
+ all(len(s) > 1 for s in new_columns)
+ and all(isinstance(x, PandasLikeExpr) for x in exprs)
+ and all(isinstance(x, PandasLikeExpr) for (_, x) in named_exprs.items())
+ )
+
+ if fast_path:
+ new_column_name_to_new_column_map = {s.name: s for s in new_columns}
+ to_concat = []
+ # Make sure to preserve column order
+ for name in self._native_frame.columns:
+ if name in new_column_name_to_new_column_map:
+ to_concat.append(
+ validate_dataframe_comparand(
+ index, new_column_name_to_new_column_map.pop(name)
+ )
+ )
+ else:
+ to_concat.append(self._native_frame.loc[:, name])
+ to_concat.extend(
+ validate_dataframe_comparand(index, new_column_name_to_new_column_map[s])
+ for s in new_column_name_to_new_column_map
+ )
+
+ df = horizontal_concat(
+ to_concat,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+ else:
+ df = self._native_frame.copy(deep=False)
+ for s in new_columns:
+ df[s.name] = validate_dataframe_comparand(index, s)
+ return self._from_native_frame(df)
+
+ def rename(self, mapping: dict[str, str]) -> Self:
+ return self._from_native_frame(self._native_frame.rename(columns=mapping))
+
+ def drop(self: Self, columns: list[str], strict: bool) -> Self: # noqa: FBT001
+ to_drop = parse_columns_to_drop(
+ compliant_frame=self, columns=columns, strict=strict
+ )
+ return self._from_native_frame(self._native_frame.drop(columns=to_drop))
+
+ # --- transform ---
+ def sort(
+ self,
+ by: str | Iterable[str],
+ *more_by: str,
+ descending: bool | Sequence[bool] = False,
+ ) -> Self:
+ flat_keys = flatten([*flatten([by]), *more_by])
+ df = self._native_frame
+ if isinstance(descending, bool):
+ ascending: bool | list[bool] = not descending
+ else:
+ ascending = [not d for d in descending]
+ return self._from_native_frame(df.sort_values(flat_keys, ascending=ascending))
+
+ # --- convert ---
+ def collect(self) -> PandasLikeDataFrame:
+ return PandasLikeDataFrame(
+ self._native_frame,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ # --- actions ---
+ def group_by(self, *keys: str) -> PandasLikeGroupBy:
+ from narwhals._pandas_like.group_by import PandasLikeGroupBy
+
+ return PandasLikeGroupBy(
+ self,
+ list(keys),
+ )
+
+ def join(
+ self,
+ other: Self,
+ *,
+ how: Literal["left", "inner", "outer", "cross", "anti", "semi"] = "inner",
+ left_on: str | list[str] | None,
+ right_on: str | list[str] | None,
+ suffix: str,
+ ) -> Self:
+ if isinstance(left_on, str):
+ left_on = [left_on]
+ if isinstance(right_on, str):
+ right_on = [right_on]
+ if how == "cross":
+ if (
+ self._implementation is Implementation.MODIN
+ or self._implementation is Implementation.CUDF
+ ) or (
+ self._implementation is Implementation.PANDAS
+ and self._backend_version < (1, 4)
+ ):
+ key_token = generate_unique_token(
+ n_bytes=8, columns=[*self.columns, *other.columns]
+ )
+
+ return self._from_native_frame(
+ self._native_frame.assign(**{key_token: 0})
+ .merge(
+ other._native_frame.assign(**{key_token: 0}),
+ how="inner",
+ left_on=key_token,
+ right_on=key_token,
+ suffixes=("", suffix),
+ )
+ .drop(columns=key_token),
+ )
+ else:
+ return self._from_native_frame(
+ self._native_frame.merge(
+ other._native_frame,
+ how="cross",
+ suffixes=("", suffix),
+ ),
+ )
+
+ if how == "anti":
+ indicator_token = generate_unique_token(
+ n_bytes=8, columns=[*self.columns, *other.columns]
+ )
+
+ other_native = (
+ other._native_frame.loc[:, right_on]
+ .rename( # rename to avoid creating extra columns in join
+ columns=dict(zip(right_on, left_on)) # type: ignore[arg-type]
+ )
+ .drop_duplicates()
+ )
+ return self._from_native_frame(
+ self._native_frame.merge(
+ other_native,
+ how="outer",
+ indicator=indicator_token,
+ left_on=left_on,
+ right_on=left_on,
+ )
+ .loc[lambda t: t[indicator_token] == "left_only"]
+ .drop(columns=indicator_token)
+ )
+
+ if how == "semi":
+ other_native = (
+ other._native_frame.loc[:, right_on]
+ .rename( # rename to avoid creating extra columns in join
+ columns=dict(zip(right_on, left_on)) # type: ignore[arg-type]
+ )
+ .drop_duplicates() # avoids potential rows duplication from inner join
+ )
+ return self._from_native_frame(
+ self._native_frame.merge(
+ other_native,
+ how="inner",
+ left_on=left_on,
+ right_on=left_on,
+ )
+ )
+
+ if how == "left":
+ other_native = other._native_frame
+ result_native = self._native_frame.merge(
+ other_native,
+ how="left",
+ left_on=left_on,
+ right_on=right_on,
+ suffixes=("", suffix),
+ )
+ extra = []
+ for left_key, right_key in zip(left_on, right_on): # type: ignore[arg-type]
+ if right_key != left_key and right_key not in self.columns:
+ extra.append(right_key)
+ elif right_key != left_key:
+ extra.append(f"{right_key}{suffix}")
+ return self._from_native_frame(result_native.drop(columns=extra))
+
+ return self._from_native_frame(
+ self._native_frame.merge(
+ other._native_frame,
+ left_on=left_on,
+ right_on=right_on,
+ how=how,
+ suffixes=("", suffix),
+ ),
+ )
+
+ def join_asof(
+ self,
+ other: Self,
+ *,
+ left_on: str | None = None,
+ right_on: str | None = None,
+ on: str | None = None,
+ by_left: str | list[str] | None = None,
+ by_right: str | list[str] | None = None,
+ by: str | list[str] | None = None,
+ strategy: Literal["backward", "forward", "nearest"] = "backward",
+ ) -> Self:
+ plx = self.__native_namespace__()
+ return self._from_native_frame(
+ plx.merge_asof(
+ self._native_frame,
+ other._native_frame,
+ left_on=left_on,
+ right_on=right_on,
+ on=on,
+ left_by=by_left,
+ right_by=by_right,
+ by=by,
+ direction=strategy,
+ suffixes=("", "_right"),
+ ),
+ )
+
+ # --- partial reduction ---
+
+ def head(self, n: int) -> Self:
+ return self._from_native_frame(self._native_frame.head(n))
+
+ def tail(self, n: int) -> Self:
+ return self._from_native_frame(self._native_frame.tail(n))
+
+ def unique(
+ self: Self,
+ subset: str | list[str] | None,
+ *,
+ keep: Literal["any", "first", "last", "none"] = "any",
+ maintain_order: bool = False,
+ ) -> Self:
+ """
+ NOTE:
+ The param `maintain_order` is only here for compatibility with the polars API
+ and has no effect on the output.
+ """
+ mapped_keep = {"none": False, "any": "first"}.get(keep, keep)
+ subset = flatten(subset) if subset else None
+ return self._from_native_frame(
+ self._native_frame.drop_duplicates(subset=subset, keep=mapped_keep)
+ )
+
+ # --- lazy-only ---
+ def lazy(self) -> Self:
+ return self
+
+ @property
+ def shape(self) -> tuple[int, int]:
+ return self._native_frame.shape # type: ignore[no-any-return]
+
+ def to_dict(self, *, as_series: bool = False) -> dict[str, Any]:
+ from narwhals._pandas_like.series import PandasLikeSeries
+
+ if as_series:
+ # TODO(Unassigned): should this return narwhals series?
+ return {
+ col: PandasLikeSeries(
+ self._native_frame.loc[:, col],
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+ for col in self.columns
+ }
+ return self._native_frame.to_dict(orient="list") # type: ignore[no-any-return]
+
+ def to_numpy(self, dtype: Any = None, copy: bool | None = None) -> Any:
+ from narwhals._pandas_like.series import PANDAS_TO_NUMPY_DTYPE_MISSING
+
+ if copy is None:
+ # pandas default differs from Polars, but cuDF default is True
+ copy = self._implementation is Implementation.CUDF
+
+ if dtype is not None:
+ return self._native_frame.to_numpy(dtype=dtype, copy=copy)
+
+ # pandas return `object` dtype for nullable dtypes if dtype=None,
+ # so we cast each Series to numpy and let numpy find a common dtype.
+ # If there aren't any dtypes where `to_numpy()` is "broken" (i.e. it
+ # returns Object) then we just call `to_numpy()` on the DataFrame.
+ for col_dtype in self._native_frame.dtypes:
+ if str(col_dtype) in PANDAS_TO_NUMPY_DTYPE_MISSING:
+ import numpy as np # ignore-banned-import
+
+ return np.hstack(
+ [self[col].to_numpy(copy=copy)[:, None] for col in self.columns]
+ )
+ return self._native_frame.to_numpy(copy=copy)
+
+ def to_pandas(self) -> Any:
+ if self._implementation is Implementation.PANDAS:
+ return self._native_frame
+ if self._implementation is Implementation.MODIN: # pragma: no cover
+ return self._native_frame._to_pandas()
+ return self._native_frame.to_pandas() # pragma: no cover
+
+ def write_parquet(self, file: Any) -> Any:
+ self._native_frame.to_parquet(file)
+
+ def write_csv(self, file: Any = None) -> Any:
+ return self._native_frame.to_csv(file, index=False)
+
+ # --- descriptive ---
+ def is_duplicated(self: Self) -> PandasLikeSeries:
+ from narwhals._pandas_like.series import PandasLikeSeries
+
+ return PandasLikeSeries(
+ self._native_frame.duplicated(keep=False),
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def is_empty(self: Self) -> bool:
+ return self._native_frame.empty # type: ignore[no-any-return]
+
+ def is_unique(self: Self) -> PandasLikeSeries:
+ from narwhals._pandas_like.series import PandasLikeSeries
+
+ return PandasLikeSeries(
+ ~self._native_frame.duplicated(keep=False),
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def null_count(self: Self) -> PandasLikeDataFrame:
+ return PandasLikeDataFrame(
+ self._native_frame.isna().sum(axis=0).to_frame().transpose(),
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def item(self: Self, row: int | None = None, column: int | str | None = None) -> Any:
+ if row is None and column is None:
+ if self.shape != (1, 1):
+ msg = (
+ "can only call `.item()` if the dataframe is of shape (1, 1),"
+ " or if explicit row/col values are provided;"
+ f" frame has shape {self.shape!r}"
+ )
+ raise ValueError(msg)
+ return self._native_frame.iloc[0, 0]
+
+ elif row is None or column is None:
+ msg = "cannot call `.item()` with only one of `row` or `column`"
+ raise ValueError(msg)
+
+ _col = self.columns.index(column) if isinstance(column, str) else column
+ return self._native_frame.iloc[row, _col]
+
+ def clone(self: Self) -> Self:
+ return self._from_native_frame(self._native_frame.copy())
+
+ def gather_every(self: Self, n: int, offset: int = 0) -> Self:
+ return self._from_native_frame(self._native_frame.iloc[offset::n])
+
+ def to_arrow(self: Self) -> Any:
+ if self._implementation is Implementation.CUDF: # pragma: no cover
+ return self._native_frame.to_arrow(preserve_index=False)
+
+ import pyarrow as pa # ignore-banned-import()
+
+ return pa.Table.from_pandas(self._native_frame)
+
+ def sample(
+ self: Self,
+ n: int | None = None,
+ *,
+ fraction: float | None = None,
+ with_replacement: bool = False,
+ seed: int | None = None,
+ ) -> Self:
+ return self._from_native_frame(
+ self._native_frame.sample(
+ n=n, frac=fraction, replace=with_replacement, random_state=seed
+ )
+ )
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/namespace.py b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/namespace.py
new file mode 100644
index 0000000000000000000000000000000000000000..37c889549e278e13a34431284ba785677941f20b
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/namespace.py
@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+from functools import reduce
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Callable
+from typing import Iterable
+from typing import cast
+
+from narwhals import dtypes
+from narwhals._expression_parsing import parse_into_exprs
+from narwhals._pandas_like.dataframe import PandasLikeDataFrame
+from narwhals._pandas_like.expr import PandasLikeExpr
+from narwhals._pandas_like.selectors import PandasSelectorNamespace
+from narwhals._pandas_like.series import PandasLikeSeries
+from narwhals._pandas_like.utils import create_native_series
+from narwhals._pandas_like.utils import horizontal_concat
+from narwhals._pandas_like.utils import vertical_concat
+
+if TYPE_CHECKING:
+ from narwhals._pandas_like.typing import IntoPandasLikeExpr
+ from narwhals.utils import Implementation
+
+
+class PandasLikeNamespace:
+ Int64 = dtypes.Int64
+ Int32 = dtypes.Int32
+ Int16 = dtypes.Int16
+ Int8 = dtypes.Int8
+ UInt64 = dtypes.UInt64
+ UInt32 = dtypes.UInt32
+ UInt16 = dtypes.UInt16
+ UInt8 = dtypes.UInt8
+ Float64 = dtypes.Float64
+ Float32 = dtypes.Float32
+ Boolean = dtypes.Boolean
+ Object = dtypes.Object
+ Unknown = dtypes.Unknown
+ Categorical = dtypes.Categorical
+ Enum = dtypes.Enum
+ String = dtypes.String
+ Datetime = dtypes.Datetime
+ Duration = dtypes.Duration
+ Date = dtypes.Date
+
+ @property
+ def selectors(self) -> PandasSelectorNamespace:
+ return PandasSelectorNamespace(
+ implementation=self._implementation, backend_version=self._backend_version
+ )
+
+ # --- not in spec ---
+ def __init__(
+ self, implementation: Implementation, backend_version: tuple[int, ...]
+ ) -> None:
+ self._implementation = implementation
+ self._backend_version = backend_version
+
+ def _create_expr_from_callable(
+ self,
+ func: Callable[[PandasLikeDataFrame], list[PandasLikeSeries]],
+ *,
+ depth: int,
+ function_name: str,
+ root_names: list[str] | None,
+ output_names: list[str] | None,
+ ) -> PandasLikeExpr:
+ return PandasLikeExpr(
+ func,
+ depth=depth,
+ function_name=function_name,
+ root_names=root_names,
+ output_names=output_names,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def _create_series_from_scalar(
+ self, value: Any, series: PandasLikeSeries
+ ) -> PandasLikeSeries:
+ return PandasLikeSeries._from_iterable(
+ [value],
+ name=series._native_series.name,
+ index=series._native_series.index[0:1],
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def _create_expr_from_series(self, series: PandasLikeSeries) -> PandasLikeExpr:
+ return PandasLikeExpr(
+ lambda _df: [series],
+ depth=0,
+ function_name="series",
+ root_names=None,
+ output_names=None,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def _create_compliant_series(self, value: Any) -> PandasLikeSeries:
+ return create_native_series(
+ value,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ # --- selection ---
+ def col(self, *column_names: str) -> PandasLikeExpr:
+ return PandasLikeExpr.from_column_names(
+ *column_names,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def all(self) -> PandasLikeExpr:
+ return PandasLikeExpr(
+ lambda df: [
+ PandasLikeSeries(
+ df._native_frame.loc[:, column_name],
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+ for column_name in df.columns
+ ],
+ depth=0,
+ function_name="all",
+ root_names=None,
+ output_names=None,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def lit(self, value: Any, dtype: dtypes.DType | None) -> PandasLikeExpr:
+ def _lit_pandas_series(df: PandasLikeDataFrame) -> PandasLikeSeries:
+ pandas_series = PandasLikeSeries._from_iterable(
+ data=[value],
+ name="lit",
+ index=df._native_frame.index[0:1],
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+ if dtype:
+ return pandas_series.cast(dtype)
+ return pandas_series
+
+ return PandasLikeExpr(
+ lambda df: [_lit_pandas_series(df)],
+ depth=0,
+ function_name="lit",
+ root_names=None,
+ output_names=["lit"],
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ # --- reduction ---
+ def sum(self, *column_names: str) -> PandasLikeExpr:
+ return PandasLikeExpr.from_column_names(
+ *column_names,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ ).sum()
+
+ def mean(self, *column_names: str) -> PandasLikeExpr:
+ return PandasLikeExpr.from_column_names(
+ *column_names,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ ).mean()
+
+ def max(self, *column_names: str) -> PandasLikeExpr:
+ return PandasLikeExpr.from_column_names(
+ *column_names,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ ).max()
+
+ def min(self, *column_names: str) -> PandasLikeExpr:
+ return PandasLikeExpr.from_column_names(
+ *column_names,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ ).min()
+
+ def len(self) -> PandasLikeExpr:
+ return PandasLikeExpr(
+ lambda df: [
+ PandasLikeSeries._from_iterable(
+ [len(df._native_frame)],
+ name="len",
+ index=[0],
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+ ],
+ depth=0,
+ function_name="len",
+ root_names=None,
+ output_names=["len"],
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ # --- horizontal ---
+ def sum_horizontal(self, *exprs: IntoPandasLikeExpr) -> PandasLikeExpr:
+ return reduce(
+ lambda x, y: x + y,
+ [expr.fill_null(0) for expr in parse_into_exprs(*exprs, namespace=self)],
+ )
+
+ def all_horizontal(self, *exprs: IntoPandasLikeExpr) -> PandasLikeExpr:
+ return reduce(lambda x, y: x & y, parse_into_exprs(*exprs, namespace=self))
+
+ def any_horizontal(self, *exprs: IntoPandasLikeExpr) -> PandasLikeExpr:
+ return reduce(lambda x, y: x | y, parse_into_exprs(*exprs, namespace=self))
+
+ def mean_horizontal(self, *exprs: IntoPandasLikeExpr) -> PandasLikeExpr:
+ pandas_like_exprs = parse_into_exprs(*exprs, namespace=self)
+ total = reduce(lambda x, y: x + y, (e.fill_null(0.0) for e in pandas_like_exprs))
+ n_non_zero = reduce(
+ lambda x, y: x + y, ((1 - e.is_null()) for e in pandas_like_exprs)
+ )
+ return total / n_non_zero
+
+ def concat(
+ self,
+ items: Iterable[PandasLikeDataFrame],
+ *,
+ how: str = "vertical",
+ ) -> PandasLikeDataFrame:
+ dfs: list[Any] = [item._native_frame for item in items]
+ if how == "horizontal":
+ return PandasLikeDataFrame(
+ horizontal_concat(
+ dfs,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ ),
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+ if how == "vertical":
+ return PandasLikeDataFrame(
+ vertical_concat(
+ dfs,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ ),
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+ raise NotImplementedError
+
+ def when(
+ self,
+ *predicates: IntoPandasLikeExpr,
+ ) -> PandasWhen:
+ plx = self.__class__(self._implementation, self._backend_version)
+ if predicates:
+ condition = plx.all_horizontal(*predicates)
+ else:
+ msg = "at least one predicate needs to be provided"
+ raise TypeError(msg)
+
+ return PandasWhen(condition, self._implementation, self._backend_version)
+
+
+class PandasWhen:
+ def __init__(
+ self,
+ condition: PandasLikeExpr,
+ implementation: Implementation,
+ backend_version: tuple[int, ...],
+ then_value: Any = None,
+ otherwise_value: Any = None,
+ ) -> None:
+ self._implementation = implementation
+ self._backend_version = backend_version
+ self._condition = condition
+ self._then_value = then_value
+ self._otherwise_value = otherwise_value
+
+ def __call__(self, df: PandasLikeDataFrame) -> list[PandasLikeSeries]:
+ from narwhals._expression_parsing import parse_into_expr
+ from narwhals._pandas_like.namespace import PandasLikeNamespace
+ from narwhals._pandas_like.utils import validate_column_comparand
+
+ plx = PandasLikeNamespace(
+ implementation=self._implementation, backend_version=self._backend_version
+ )
+
+ condition = parse_into_expr(self._condition, namespace=plx)._call(df)[0] # type: ignore[arg-type]
+ try:
+ value_series = parse_into_expr(self._then_value, namespace=plx)._call(df)[0] # type: ignore[arg-type]
+ except TypeError:
+ # `self._otherwise_value` is a scalar and can't be converted to an expression
+ value_series = condition.__class__._from_iterable( # type: ignore[call-arg]
+ [self._then_value] * len(condition),
+ name="literal",
+ index=condition._native_series.index,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+ value_series = cast(PandasLikeSeries, value_series)
+
+ value_series_native = value_series._native_series
+ condition_native = validate_column_comparand(value_series_native.index, condition)
+
+ if self._otherwise_value is None:
+ return [
+ value_series._from_native_series(
+ value_series_native.where(condition_native)
+ )
+ ]
+ try:
+ otherwise_series = parse_into_expr(
+ self._otherwise_value, namespace=plx
+ )._call(df)[0] # type: ignore[arg-type]
+ except TypeError:
+ # `self._otherwise_value` is a scalar and can't be converted to an expression
+ return [
+ value_series._from_native_series(
+ value_series_native.where(condition_native, self._otherwise_value)
+ )
+ ]
+ else:
+ return [value_series.zip_with(condition, otherwise_series)]
+
+ def then(self, value: PandasLikeExpr | PandasLikeSeries | Any) -> PandasThen:
+ self._then_value = value
+
+ return PandasThen(
+ self,
+ depth=0,
+ function_name="whenthen",
+ root_names=None,
+ output_names=None,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+
+class PandasThen(PandasLikeExpr):
+ def __init__(
+ self,
+ call: PandasWhen,
+ *,
+ depth: int,
+ function_name: str,
+ root_names: list[str] | None,
+ output_names: list[str] | None,
+ implementation: Implementation,
+ backend_version: tuple[int, ...],
+ ) -> None:
+ self._implementation = implementation
+ self._backend_version = backend_version
+
+ self._call = call
+ self._depth = depth
+ self._function_name = function_name
+ self._root_names = root_names
+ self._output_names = output_names
+
+ def otherwise(self, value: PandasLikeExpr | PandasLikeSeries | Any) -> PandasLikeExpr:
+ # type ignore because we are setting the `_call` attribute to a
+ # callable object of type `PandasWhen`, base class has the attribute as
+ # only a `Callable`
+ self._call._otherwise_value = value # type: ignore[attr-defined]
+ self._function_name = "whenotherwise"
+ return self
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/series.py b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/series.py
new file mode 100644
index 0000000000000000000000000000000000000000..873683dd559cf6feb64c9c1032ee6a46bc170d2a
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/series.py
@@ -0,0 +1,917 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Iterable
+from typing import Iterator
+from typing import Literal
+from typing import Sequence
+from typing import overload
+
+from narwhals._pandas_like.utils import int_dtype_mapper
+from narwhals._pandas_like.utils import narwhals_to_native_dtype
+from narwhals._pandas_like.utils import native_series_from_iterable
+from narwhals._pandas_like.utils import set_axis
+from narwhals._pandas_like.utils import to_datetime
+from narwhals._pandas_like.utils import translate_dtype
+from narwhals._pandas_like.utils import validate_column_comparand
+from narwhals.dependencies import get_cudf
+from narwhals.dependencies import get_modin
+from narwhals.dependencies import get_pandas
+from narwhals.utils import Implementation
+
+if TYPE_CHECKING:
+ from typing_extensions import Self
+
+ from narwhals._pandas_like.dataframe import PandasLikeDataFrame
+ from narwhals.dtypes import DType
+
+PANDAS_TO_NUMPY_DTYPE_NO_MISSING = {
+ "Int64": "int64",
+ "int64[pyarrow]": "int64",
+ "Int32": "int32",
+ "int32[pyarrow]": "int32",
+ "Int16": "int16",
+ "int16[pyarrow]": "int16",
+ "Int8": "int8",
+ "int8[pyarrow]": "int8",
+ "UInt64": "uint64",
+ "uint64[pyarrow]": "uint64",
+ "UInt32": "uint32",
+ "uint32[pyarrow]": "uint32",
+ "UInt16": "uint16",
+ "uint16[pyarrow]": "uint16",
+ "UInt8": "uint8",
+ "uint8[pyarrow]": "uint8",
+ "Float64": "float64",
+ "float64[pyarrow]": "float64",
+ "Float32": "float32",
+ "float32[pyarrow]": "float32",
+}
+PANDAS_TO_NUMPY_DTYPE_MISSING = {
+ "Int64": "float64",
+ "int64[pyarrow]": "float64",
+ "Int32": "float64",
+ "int32[pyarrow]": "float64",
+ "Int16": "float64",
+ "int16[pyarrow]": "float64",
+ "Int8": "float64",
+ "int8[pyarrow]": "float64",
+ "UInt64": "float64",
+ "uint64[pyarrow]": "float64",
+ "UInt32": "float64",
+ "uint32[pyarrow]": "float64",
+ "UInt16": "float64",
+ "uint16[pyarrow]": "float64",
+ "UInt8": "float64",
+ "uint8[pyarrow]": "float64",
+ "Float64": "float64",
+ "float64[pyarrow]": "float64",
+ "Float32": "float32",
+ "float32[pyarrow]": "float32",
+}
+
+
+class PandasLikeSeries:
+ def __init__(
+ self,
+ native_series: Any,
+ *,
+ implementation: Implementation,
+ backend_version: tuple[int, ...],
+ ) -> None:
+ self._name = native_series.name
+ self._native_series = native_series
+ self._implementation = implementation
+ self._backend_version = backend_version
+
+ # In pandas, copy-on-write becomes the default in version 3.
+ # So, before that, we need to explicitly avoid unnecessary
+ # copies by using `copy=False` sometimes.
+ if self._implementation is Implementation.PANDAS and self._backend_version < (
+ 3,
+ 0,
+ 0,
+ ):
+ self._use_copy_false = True
+ else:
+ self._use_copy_false = False
+
+ def __native_namespace__(self) -> Any:
+ if self._implementation is Implementation.PANDAS:
+ return get_pandas()
+ if self._implementation is Implementation.MODIN: # pragma: no cover
+ return get_modin()
+ if self._implementation is Implementation.CUDF: # pragma: no cover
+ return get_cudf()
+ msg = f"Expected pandas/modin/cudf, got: {type(self._implementation)}" # pragma: no cover
+ raise AssertionError(msg)
+
+ def __narwhals_series__(self) -> Self:
+ return self
+
+ @overload
+ def __getitem__(self, idx: int) -> Any: ...
+
+ @overload
+ def __getitem__(self, idx: slice | Sequence[int]) -> Self: ...
+
+ def __getitem__(self, idx: int | slice | Sequence[int]) -> Any | Self:
+ if isinstance(idx, int):
+ return self._native_series.iloc[idx]
+ return self._from_native_series(self._native_series.iloc[idx])
+
+ def _rename(self, series: Any, name: str) -> Any:
+ if self._use_copy_false:
+ return series.rename(name, copy=False)
+ return series.rename(name) # pragma: no cover
+
+ def _from_native_series(self, series: Any) -> Self:
+ return self.__class__(
+ series,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ @classmethod
+ def _from_iterable(
+ cls: type[Self],
+ data: Iterable[Any],
+ name: str,
+ index: Any,
+ *,
+ implementation: Implementation,
+ backend_version: tuple[int, ...],
+ ) -> Self:
+ return cls(
+ native_series_from_iterable(
+ data,
+ name=name,
+ index=index,
+ implementation=implementation,
+ ),
+ implementation=implementation,
+ backend_version=backend_version,
+ )
+
+ def __len__(self) -> int:
+ return self.shape[0]
+
+ @property
+ def name(self) -> str:
+ return self._name # type: ignore[no-any-return]
+
+ @property
+ def shape(self) -> tuple[int]:
+ return self._native_series.shape # type: ignore[no-any-return]
+
+ @property
+ def dtype(self: Self) -> DType:
+ return translate_dtype(self._native_series)
+
+ def scatter(self, indices: int | Sequence[int], values: Any) -> Self:
+ if isinstance(values, self.__class__):
+ # .copy() is necessary in some pre-2.2 versions of pandas to avoid
+ # `values` also getting modified (!)
+ values = validate_column_comparand(self._native_series.index, values).copy()
+ values = set_axis(
+ values,
+ self._native_series.index[indices],
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+ s = self._native_series
+ s.iloc[indices] = values
+ s.name = self.name
+ return self._from_native_series(s)
+
+ def cast(
+ self,
+ dtype: Any,
+ ) -> Self:
+ ser = self._native_series
+ dtype = narwhals_to_native_dtype(dtype, ser.dtype, self._implementation)
+ return self._from_native_series(ser.astype(dtype))
+
+ def item(self: Self, index: int | None = None) -> Any:
+ # cuDF doesn't have Series.item().
+ if index is None:
+ if len(self) != 1:
+ msg = (
+ "can only call '.item()' if the Series is of length 1,"
+ f" or an explicit index is provided (Series is of length {len(self)})"
+ )
+ raise ValueError(msg)
+ return self._native_series.iloc[0]
+ return self._native_series.iloc[index]
+
+ def to_frame(self) -> PandasLikeDataFrame:
+ from narwhals._pandas_like.dataframe import PandasLikeDataFrame
+
+ return PandasLikeDataFrame(
+ self._native_series.to_frame(),
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def to_list(self) -> Any:
+ return self._native_series.to_list()
+
+ def is_between(
+ self, lower_bound: Any, upper_bound: Any, closed: str = "both"
+ ) -> PandasLikeSeries:
+ ser = self._native_series
+ if closed == "left":
+ res = ser.ge(lower_bound) & ser.lt(upper_bound)
+ elif closed == "right":
+ res = ser.gt(lower_bound) & ser.le(upper_bound)
+ elif closed == "none":
+ res = ser.gt(lower_bound) & ser.lt(upper_bound)
+ elif closed == "both":
+ res = ser.ge(lower_bound) & ser.le(upper_bound)
+ else: # pragma: no cover
+ raise AssertionError
+ return self._from_native_series(res)
+
+ def is_in(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ res = ser.isin(other)
+ return self._from_native_series(res)
+
+ def arg_true(self) -> PandasLikeSeries:
+ ser = self._native_series
+ result = ser.__class__(range(len(ser)), name=ser.name, index=ser.index).loc[ser]
+ return self._from_native_series(result)
+
+ # Binary comparisons
+
+ def filter(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ if not (isinstance(other, list) and all(isinstance(x, bool) for x in other)):
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.loc[other], ser.name))
+
+ def __eq__(self, other: object) -> PandasLikeSeries: # type: ignore[override]
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__eq__(other), ser.name))
+
+ def __ne__(self, other: object) -> PandasLikeSeries: # type: ignore[override]
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__ne__(other), ser.name))
+
+ def __ge__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__ge__(other), ser.name))
+
+ def __gt__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__gt__(other), ser.name))
+
+ def __le__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__le__(other), ser.name))
+
+ def __lt__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__lt__(other), ser.name))
+
+ def __and__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__and__(other), ser.name))
+
+ def __rand__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__rand__(other), ser.name))
+
+ def __or__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__or__(other), ser.name))
+
+ def __ror__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__ror__(other), ser.name))
+
+ def __add__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__add__(other), ser.name))
+
+ def __radd__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__radd__(other), ser.name))
+
+ def __sub__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__sub__(other), ser.name))
+
+ def __rsub__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__rsub__(other), ser.name))
+
+ def __mul__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__mul__(other), ser.name))
+
+ def __rmul__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__rmul__(other), ser.name))
+
+ def __truediv__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__truediv__(other), ser.name))
+
+ def __rtruediv__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__rtruediv__(other), ser.name))
+
+ def __floordiv__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__floordiv__(other), ser.name))
+
+ def __rfloordiv__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__rfloordiv__(other), ser.name))
+
+ def __pow__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__pow__(other), ser.name))
+
+ def __rpow__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__rpow__(other), ser.name))
+
+ def __mod__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__mod__(other), ser.name))
+
+ def __rmod__(self, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ other = validate_column_comparand(self._native_series.index, other)
+ return self._from_native_series(self._rename(ser.__rmod__(other), ser.name))
+
+ # Unary
+
+ def __invert__(self: PandasLikeSeries) -> PandasLikeSeries:
+ ser = self._native_series
+ return self._from_native_series(~ser)
+
+ # Reductions
+
+ def any(self) -> Any:
+ ser = self._native_series
+ return ser.any()
+
+ def all(self) -> Any:
+ ser = self._native_series
+ return ser.all()
+
+ def min(self) -> Any:
+ ser = self._native_series
+ return ser.min()
+
+ def max(self) -> Any:
+ ser = self._native_series
+ return ser.max()
+
+ def sum(self) -> Any:
+ ser = self._native_series
+ return ser.sum()
+
+ def count(self) -> Any:
+ ser = self._native_series
+ return ser.count()
+
+ def mean(self) -> Any:
+ ser = self._native_series
+ return ser.mean()
+
+ def std(
+ self,
+ *,
+ ddof: int = 1,
+ ) -> Any:
+ ser = self._native_series
+ return ser.std(ddof=ddof)
+
+ def len(self) -> Any:
+ return len(self._native_series)
+
+ # Transformations
+
+ def is_null(self) -> PandasLikeSeries:
+ ser = self._native_series
+ return self._from_native_series(ser.isna())
+
+ def fill_null(self, value: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ return self._from_native_series(ser.fillna(value))
+
+ def drop_nulls(self) -> PandasLikeSeries:
+ ser = self._native_series
+ return self._from_native_series(ser.dropna())
+
+ def n_unique(self) -> int:
+ ser = self._native_series
+ return ser.nunique(dropna=False) # type: ignore[no-any-return]
+
+ def sample(
+ self: Self,
+ n: int | None = None,
+ *,
+ fraction: float | None = None,
+ with_replacement: bool = False,
+ seed: int | None = None,
+ ) -> Self:
+ ser = self._native_series
+ return self._from_native_series(
+ ser.sample(n=n, frac=fraction, replace=with_replacement, random_state=seed)
+ )
+
+ def abs(self) -> PandasLikeSeries:
+ return self._from_native_series(self._native_series.abs())
+
+ def cum_sum(self) -> PandasLikeSeries:
+ return self._from_native_series(self._native_series.cumsum())
+
+ def unique(self) -> PandasLikeSeries:
+ return self._from_native_series(
+ self._native_series.__class__(
+ self._native_series.unique(), name=self._native_series.name
+ )
+ )
+
+ def diff(self) -> PandasLikeSeries:
+ return self._from_native_series(self._native_series.diff())
+
+ def shift(self, n: int) -> PandasLikeSeries:
+ return self._from_native_series(self._native_series.shift(n))
+
+ def sort(
+ self, *, descending: bool = False, nulls_last: bool = False
+ ) -> PandasLikeSeries:
+ ser = self._native_series
+ na_position = "last" if nulls_last else "first"
+ return self._from_native_series(
+ ser.sort_values(ascending=not descending, na_position=na_position).rename(
+ self.name
+ )
+ )
+
+ def alias(self, name: str) -> Self:
+ ser = self._native_series
+ return self._from_native_series(self._rename(ser, name))
+
+ def __array__(self, dtype: Any = None, copy: bool | None = None) -> Any:
+ # pandas used to always return object dtype for nullable dtypes.
+ # So, we intercept __array__ and pass to `to_numpy` ourselves to make
+ # sure an appropriate numpy dtype is returned.
+ return self.to_numpy(dtype=dtype, copy=copy)
+
+ def to_numpy(self, dtype: Any = None, copy: bool | None = None) -> Any:
+ # the default is meant to be None, but pandas doesn't allow it?
+ # https://numpy.org/doc/stable/reference/generated/numpy.ndarray.__array__.html
+ copy = copy or self._implementation is Implementation.CUDF
+
+ has_missing = self._native_series.isna().any()
+ if (
+ has_missing
+ and str(self._native_series.dtype) in PANDAS_TO_NUMPY_DTYPE_MISSING
+ ):
+ if self._implementation is Implementation.PANDAS and self._backend_version < (
+ 1,
+ ): # pragma: no cover
+ kwargs = {}
+ else:
+ kwargs = {"na_value": float("nan")}
+ return self._native_series.to_numpy(
+ dtype=dtype
+ or PANDAS_TO_NUMPY_DTYPE_MISSING[str(self._native_series.dtype)],
+ copy=copy,
+ **kwargs,
+ )
+ if (
+ not has_missing
+ and str(self._native_series.dtype) in PANDAS_TO_NUMPY_DTYPE_NO_MISSING
+ ):
+ return self._native_series.to_numpy(
+ dtype=dtype
+ or PANDAS_TO_NUMPY_DTYPE_NO_MISSING[str(self._native_series.dtype)],
+ copy=copy,
+ )
+ return self._native_series.to_numpy(dtype=dtype, copy=copy)
+
+ def to_pandas(self) -> Any:
+ if self._implementation is Implementation.PANDAS:
+ return self._native_series
+ elif self._implementation is Implementation.CUDF: # pragma: no cover
+ return self._native_series.to_pandas()
+ elif self._implementation is Implementation.MODIN: # pragma: no cover
+ return self._native_series._to_pandas()
+ msg = f"Unknown implementation: {self._implementation}" # pragma: no cover
+ raise AssertionError(msg)
+
+ # --- descriptive ---
+ def is_duplicated(self: Self) -> Self:
+ res = self._native_series.duplicated(keep=False)
+ res = self._rename(res, self.name)
+ return self._from_native_series(res)
+
+ def is_empty(self: Self) -> bool:
+ return self._native_series.empty # type: ignore[no-any-return]
+
+ def is_unique(self: Self) -> Self:
+ res = ~self._native_series.duplicated(keep=False)
+ res = self._rename(res, self.name)
+ return self._from_native_series(res)
+
+ def null_count(self: Self) -> int:
+ return self._native_series.isna().sum() # type: ignore[no-any-return]
+
+ def is_first_distinct(self: Self) -> Self:
+ res = ~self._native_series.duplicated(keep="first")
+ res = self._rename(res, self.name)
+ return self._from_native_series(res)
+
+ def is_last_distinct(self: Self) -> Self:
+ res = ~self._native_series.duplicated(keep="last")
+ res = self._rename(res, self.name)
+ return self._from_native_series(res)
+
+ def is_sorted(self: Self, *, descending: bool = False) -> bool:
+ if not isinstance(descending, bool):
+ msg = f"argument 'descending' should be boolean, found {type(descending)}"
+ raise TypeError(msg)
+
+ if descending:
+ return self._native_series.is_monotonic_decreasing # type: ignore[no-any-return]
+ else:
+ return self._native_series.is_monotonic_increasing # type: ignore[no-any-return]
+
+ def value_counts(
+ self: Self,
+ *,
+ sort: bool = False,
+ parallel: bool = False,
+ name: str | None = None,
+ normalize: bool = False,
+ ) -> PandasLikeDataFrame:
+ """Parallel is unused, exists for compatibility"""
+ from narwhals._pandas_like.dataframe import PandasLikeDataFrame
+
+ index_name_ = "index" if self._name is None else self._name
+ value_name_ = name or ("proportion" if normalize else "count")
+
+ val_count = self._native_series.value_counts(
+ dropna=False,
+ sort=False,
+ normalize=normalize,
+ ).reset_index()
+
+ val_count.columns = [index_name_, value_name_]
+
+ if sort:
+ val_count = val_count.sort_values(value_name_, ascending=False)
+
+ return PandasLikeDataFrame(
+ val_count,
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def quantile(
+ self: Self,
+ quantile: float,
+ interpolation: Literal["nearest", "higher", "lower", "midpoint", "linear"],
+ ) -> Any:
+ return self._native_series.quantile(q=quantile, interpolation=interpolation)
+
+ def zip_with(self: Self, mask: Any, other: Any) -> PandasLikeSeries:
+ ser = self._native_series
+ mask = validate_column_comparand(ser.index, mask)
+ other = validate_column_comparand(ser.index, other)
+ res = ser.where(mask, other)
+ return self._from_native_series(res)
+
+ def head(self: Self, n: int) -> Self:
+ return self._from_native_series(self._native_series.head(n))
+
+ def tail(self: Self, n: int) -> Self:
+ return self._from_native_series(self._native_series.tail(n))
+
+ def round(self: Self, decimals: int) -> Self:
+ return self._from_native_series(self._native_series.round(decimals=decimals))
+
+ def to_dummies(
+ self: Self, *, separator: str = "_", drop_first: bool = False
+ ) -> PandasLikeDataFrame:
+ from narwhals._pandas_like.dataframe import PandasLikeDataFrame
+
+ plx = self.__native_namespace__()
+ series = self._native_series
+ name = str(self._name) if self._name else ""
+ return PandasLikeDataFrame(
+ plx.get_dummies(
+ series,
+ prefix=name,
+ prefix_sep=separator,
+ drop_first=drop_first,
+ ).astype(int),
+ implementation=self._implementation,
+ backend_version=self._backend_version,
+ )
+
+ def gather_every(self: Self, n: int, offset: int = 0) -> Self:
+ return self._from_native_series(self._native_series.iloc[offset::n])
+
+ def clip(
+ self: Self, lower_bound: Any | None = None, upper_bound: Any | None = None
+ ) -> Self:
+ return self._from_native_series(
+ self._native_series.clip(lower_bound, upper_bound)
+ )
+
+ def to_arrow(self: Self) -> Any:
+ if self._implementation is Implementation.CUDF: # pragma: no cover
+ return self._native_series.to_arrow()
+
+ import pyarrow as pa # ignore-banned-import()
+
+ return pa.Array.from_pandas(self._native_series)
+
+ def mode(self: Self) -> Self:
+ native_series = self._native_series
+ result = native_series.mode()
+ result.name = native_series.name
+ return self._from_native_series(result)
+
+ def __iter__(self: Self) -> Iterator[Any]:
+ yield from self._native_series.__iter__()
+
+ @property
+ def str(self) -> PandasLikeSeriesStringNamespace:
+ return PandasLikeSeriesStringNamespace(self)
+
+ @property
+ def dt(self) -> PandasLikeSeriesDateTimeNamespace:
+ return PandasLikeSeriesDateTimeNamespace(self)
+
+ @property
+ def cat(self) -> PandasLikeSeriesCatNamespace:
+ return PandasLikeSeriesCatNamespace(self)
+
+
+class PandasLikeSeriesCatNamespace:
+ def __init__(self, series: PandasLikeSeries) -> None:
+ self._pandas_series = series
+
+ def get_categories(self) -> PandasLikeSeries:
+ s = self._pandas_series._native_series
+ return self._pandas_series._from_native_series(
+ s.__class__(s.cat.categories, name=s.name)
+ )
+
+
+class PandasLikeSeriesStringNamespace:
+ def __init__(self, series: PandasLikeSeries) -> None:
+ self._pandas_series = series
+
+ def len_chars(self) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.str.len()
+ )
+
+ def replace(
+ self, pattern: str, value: str, *, literal: bool = False, n: int = 1
+ ) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.str.replace(
+ pat=pattern, repl=value, n=n, regex=not literal
+ ),
+ )
+
+ def replace_all(
+ self, pattern: str, value: str, *, literal: bool = False
+ ) -> PandasLikeSeries:
+ return self.replace(pattern, value, literal=literal, n=-1)
+
+ def strip_chars(self, characters: str | None) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.str.strip(characters),
+ )
+
+ def starts_with(self, prefix: str) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.str.startswith(prefix),
+ )
+
+ def ends_with(self, suffix: str) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.str.endswith(suffix),
+ )
+
+ def contains(self, pattern: str, *, literal: bool = False) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.str.contains(
+ pat=pattern, regex=not literal
+ )
+ )
+
+ def slice(self, offset: int, length: int | None = None) -> PandasLikeSeries:
+ stop = offset + length if length else None
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.str.slice(start=offset, stop=stop),
+ )
+
+ def to_datetime(self, format: str | None = None) -> PandasLikeSeries: # noqa: A002
+ return self._pandas_series._from_native_series(
+ to_datetime(self._pandas_series._implementation)(
+ self._pandas_series._native_series, format=format
+ )
+ )
+
+ def to_uppercase(self) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.str.upper(),
+ )
+
+ def to_lowercase(self) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.str.lower(),
+ )
+
+
+class PandasLikeSeriesDateTimeNamespace:
+ def __init__(self, series: PandasLikeSeries) -> None:
+ self._pandas_series = series
+
+ def date(self) -> PandasLikeSeries:
+ result = self._pandas_series._from_native_series(
+ self._pandas_series._native_series.dt.date,
+ )
+ if str(result.dtype).lower() == "object":
+ msg = (
+ "Accessing `date` on the default pandas backend "
+ "will return a Series of type `object`."
+ "\nThis differs from polars API and will prevent `.dt` chaining. "
+ "Please switch to the `pyarrow` backend:"
+ '\ndf.convert_dtypes(dtype_backend="pyarrow")'
+ )
+ raise NotImplementedError(msg)
+ return result
+
+ def year(self) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.dt.year,
+ )
+
+ def month(self) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.dt.month,
+ )
+
+ def day(self) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.dt.day,
+ )
+
+ def hour(self) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.dt.hour,
+ )
+
+ def minute(self) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.dt.minute,
+ )
+
+ def second(self) -> PandasLikeSeries:
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.dt.second,
+ )
+
+ def millisecond(self) -> PandasLikeSeries:
+ return self.microsecond() // 1000
+
+ def microsecond(self) -> PandasLikeSeries:
+ if self._pandas_series._backend_version < (3, 0, 0) and "pyarrow" in str(
+ self._pandas_series._native_series.dtype
+ ):
+ # crazy workaround for https://github.com/pandas-dev/pandas/issues/59154
+ import pyarrow.compute as pc # ignore-banned-import()
+
+ native_series = self._pandas_series._native_series
+ arr = native_series.array.__arrow_array__()
+ result_arr = pc.add(
+ pc.multiply(pc.millisecond(arr), 1000), pc.microsecond(arr)
+ )
+ result = native_series.__class__(
+ native_series.array.__class__(result_arr), name=native_series.name
+ )
+ return self._pandas_series._from_native_series(result)
+
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.dt.microsecond
+ )
+
+ def nanosecond(self) -> PandasLikeSeries:
+ return ( # type: ignore[no-any-return]
+ self.microsecond() * 1_000 + self._pandas_series._native_series.dt.nanosecond
+ )
+
+ def ordinal_day(self) -> PandasLikeSeries:
+ ser = self._pandas_series._native_series
+ year_start = ser.dt.year
+ result = (
+ ser.to_numpy().astype("datetime64[D]")
+ - (year_start.to_numpy() - 1970).astype("datetime64[Y]")
+ ).astype("int32") + 1
+ dtype = "Int64[pyarrow]" if "pyarrow" in str(ser.dtype) else "int32"
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.__class__(
+ result, dtype=dtype, name=year_start.name
+ )
+ )
+
+ def total_minutes(self) -> PandasLikeSeries:
+ s = self._pandas_series._native_series.dt.total_seconds()
+ s_sign = (
+ 2 * (s > 0).astype(int_dtype_mapper(s.dtype)) - 1
+ ) # this calculates the sign of each series element
+ s_abs = s.abs() // 60
+ if ~s.isna().any():
+ s_abs = s_abs.astype(int_dtype_mapper(s.dtype))
+ return self._pandas_series._from_native_series(s_abs * s_sign)
+
+ def total_seconds(self) -> PandasLikeSeries:
+ s = self._pandas_series._native_series.dt.total_seconds()
+ s_sign = (
+ 2 * (s > 0).astype(int_dtype_mapper(s.dtype)) - 1
+ ) # this calculates the sign of each series element
+ s_abs = s.abs() // 1
+ if ~s.isna().any():
+ s_abs = s_abs.astype(int_dtype_mapper(s.dtype))
+ return self._pandas_series._from_native_series(s_abs * s_sign)
+
+ def total_milliseconds(self) -> PandasLikeSeries:
+ s = self._pandas_series._native_series.dt.total_seconds() * 1e3
+ s_sign = (
+ 2 * (s > 0).astype(int_dtype_mapper(s.dtype)) - 1
+ ) # this calculates the sign of each series element
+ s_abs = s.abs() // 1
+ if ~s.isna().any():
+ s_abs = s_abs.astype(int_dtype_mapper(s.dtype))
+ return self._pandas_series._from_native_series(s_abs * s_sign)
+
+ def total_microseconds(self) -> PandasLikeSeries:
+ s = self._pandas_series._native_series.dt.total_seconds() * 1e6
+ s_sign = (
+ 2 * (s > 0).astype(int_dtype_mapper(s.dtype)) - 1
+ ) # this calculates the sign of each series element
+ s_abs = s.abs() // 1
+ if ~s.isna().any():
+ s_abs = s_abs.astype(int_dtype_mapper(s.dtype))
+ return self._pandas_series._from_native_series(s_abs * s_sign)
+
+ def total_nanoseconds(self) -> PandasLikeSeries:
+ s = self._pandas_series._native_series.dt.total_seconds() * 1e9
+ s_sign = (
+ 2 * (s > 0).astype(int_dtype_mapper(s.dtype)) - 1
+ ) # this calculates the sign of each series element
+ s_abs = s.abs() // 1
+ if ~s.isna().any():
+ s_abs = s_abs.astype(int_dtype_mapper(s.dtype))
+ return self._pandas_series._from_native_series(s_abs * s_sign)
+
+ def to_string(self, format: str) -> PandasLikeSeries: # noqa: A002
+ # Polars' parser treats `'%.f'` as pandas does `'.%f'`
+ # PyArrow interprets `'%S'` as "seconds, plus fractional seconds"
+ # and doesn't support `%f`
+ if "pyarrow" not in str(self._pandas_series._native_series.dtype):
+ format = format.replace("%S%.f", "%S.%f")
+ else:
+ format = format.replace("%S.%f", "%S").replace("%S%.f", "%S")
+ return self._pandas_series._from_native_series(
+ self._pandas_series._native_series.dt.strftime(format)
+ )
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/typing.py b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/typing.py
new file mode 100644
index 0000000000000000000000000000000000000000..3fe6dcd57c5dfd546336e614e98b7fa5344c7171
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/narwhals/_pandas_like/typing.py
@@ -0,0 +1,17 @@
+from __future__ import annotations # pragma: no cover
+
+from typing import TYPE_CHECKING # pragma: no cover
+from typing import Union # pragma: no cover
+
+if TYPE_CHECKING:
+ import sys
+
+ if sys.version_info >= (3, 10):
+ from typing import TypeAlias
+ else:
+ from typing_extensions import TypeAlias
+
+ from narwhals._pandas_like.expr import PandasLikeExpr
+ from narwhals._pandas_like.series import PandasLikeSeries
+
+ IntoPandasLikeExpr: TypeAlias = Union[PandasLikeExpr, str, PandasLikeSeries]
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_polars/__pycache__/series.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/_polars/__pycache__/series.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..55b0c59bdecf812efce09a0fa331e46a1c8ac76e
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/_polars/__pycache__/series.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/narwhals/_polars/dataframe.py b/parrot/lib/python3.10/site-packages/narwhals/_polars/dataframe.py
new file mode 100644
index 0000000000000000000000000000000000000000..77d8a016beea034ea18e2c683d1663514ada05a9
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/narwhals/_polars/dataframe.py
@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Any
+
+from narwhals._polars.namespace import PolarsNamespace
+from narwhals._polars.utils import convert_str_slice_to_int_slice
+from narwhals._polars.utils import extract_args_kwargs
+from narwhals._polars.utils import translate_dtype
+from narwhals.dependencies import get_polars
+from narwhals.utils import Implementation
+from narwhals.utils import is_sequence_but_not_str
+from narwhals.utils import parse_columns_to_drop
+
+if TYPE_CHECKING:
+ import numpy as np
+ from typing_extensions import Self
+
+
+class PolarsDataFrame:
+ def __init__(self, df: Any, *, backend_version: tuple[int, ...]) -> None:
+ self._native_frame = df
+ self._implementation = Implementation.POLARS
+ self._backend_version = backend_version
+
+ def __repr__(self) -> str: # pragma: no cover
+ return "PolarsDataFrame"
+
+ def __narwhals_dataframe__(self) -> Self:
+ return self
+
+ def __narwhals_namespace__(self) -> PolarsNamespace:
+ return PolarsNamespace(backend_version=self._backend_version)
+
+ def __native_namespace__(self) -> Any:
+ return get_polars()
+
+ def _from_native_frame(self, df: Any) -> Self:
+ return self.__class__(df, backend_version=self._backend_version)
+
+ def _from_native_object(self, obj: Any) -> Any:
+ pl = get_polars()
+ if isinstance(obj, pl.Series):
+ from narwhals._polars.series import PolarsSeries
+
+ return PolarsSeries(obj, backend_version=self._backend_version)
+ if isinstance(obj, pl.DataFrame):
+ return self._from_native_frame(obj)
+ # scalar
+ return obj
+
+ def __getattr__(self, attr: str) -> Any:
+ if attr == "collect": # pragma: no cover
+ raise AttributeError
+
+ def func(*args: Any, **kwargs: Any) -> Any:
+ args, kwargs = extract_args_kwargs(args, kwargs) # type: ignore[assignment]
+ return self._from_native_object(
+ getattr(self._native_frame, attr)(*args, **kwargs)
+ )
+
+ return func
+
+ def __array__(self, dtype: Any | None = None, copy: bool | None = None) -> np.ndarray:
+ if self._backend_version < (0, 20, 28) and copy is not None: # pragma: no cover
+ msg = "`copy` in `__array__` is only supported for Polars>=0.20.28"
+ raise NotImplementedError(msg)
+ if self._backend_version < (0, 20, 28): # pragma: no cover
+ return self._native_frame.__array__(dtype)
+ return self._native_frame.__array__(dtype)
+
+ @property
+ def schema(self) -> dict[str, Any]:
+ schema = self._native_frame.schema
+ return {name: translate_dtype(dtype) for name, dtype in schema.items()}
+
+ def collect_schema(self) -> dict[str, Any]:
+ if self._backend_version < (1,): # pragma: no cover
+ schema = self._native_frame.schema
+ else:
+ schema = dict(self._native_frame.collect_schema())
+ return {name: translate_dtype(dtype) for name, dtype in schema.items()}
+
+ @property
+ def shape(self) -> tuple[int, int]:
+ return self._native_frame.shape # type: ignore[no-any-return]
+
+ def __getitem__(self, item: Any) -> Any:
+ if self._backend_version > (0, 20, 30):
+ return self._from_native_object(self._native_frame.__getitem__(item))
+ else: # pragma: no cover
+ # TODO(marco): we can delete this branch after Polars==0.20.30 becomes the minimum
+ # Polars version we support
+ if isinstance(item, tuple):
+ item = tuple(list(i) if is_sequence_but_not_str(i) else i for i in item)
+
+ columns = self.columns
+ if isinstance(item, tuple) and len(item) == 2 and isinstance(item[1], slice):
+ if isinstance(item[1].start, str) or isinstance(item[1].stop, str):
+ start, stop, step = convert_str_slice_to_int_slice(item[1], columns)
+ return self._from_native_frame(
+ self._native_frame.select(columns[start:stop:step]).__getitem__(
+ item[0]
+ )
+ )
+ if isinstance(item[1].start, int) or isinstance(item[1].stop, int):
+ return self._from_native_frame(
+ self._native_frame.select(
+ columns[item[1].start : item[1].stop : item[1].step]
+ ).__getitem__(item[0])
+ )
+ msg = f"Expected slice of integers or strings, got: {type(item[1])}" # pragma: no cover
+ raise TypeError(msg) # pragma: no cover
+ pl = get_polars()
+ if (
+ isinstance(item, tuple)
+ and (len(item) == 2)
+ and is_sequence_but_not_str(item[1])
+ and (len(item[1]) == 0)
+ ):
+ result = self._native_frame.select(item[1])
+ elif isinstance(item, slice) and (
+ isinstance(item.start, str) or isinstance(item.stop, str)
+ ):
+ start, stop, step = convert_str_slice_to_int_slice(item, columns)
+ return self._from_native_frame(
+ self._native_frame.select(columns[start:stop:step])
+ )
+ elif is_sequence_but_not_str(item) and (len(item) == 0):
+ result = self._native_frame.slice(0, 0)
+ else:
+ result = self._native_frame.__getitem__(item)
+ if isinstance(result, pl.Series):
+ from narwhals._polars.series import PolarsSeries
+
+ return PolarsSeries(result, backend_version=self._backend_version)
+ return self._from_native_object(result)
+
+ def get_column(self, name: str) -> Any:
+ from narwhals._polars.series import PolarsSeries
+
+ return PolarsSeries(
+ self._native_frame.get_column(name), backend_version=self._backend_version
+ )
+
+ def is_empty(self) -> bool:
+ return len(self._native_frame) == 0
+
+ @property
+ def columns(self) -> list[str]:
+ return self._native_frame.columns # type: ignore[no-any-return]
+
+ def lazy(self) -> PolarsLazyFrame:
+ return PolarsLazyFrame(
+ self._native_frame.lazy(), backend_version=self._backend_version
+ )
+
+ def to_dict(self, *, as_series: bool) -> Any:
+ df = self._native_frame
+
+ if as_series:
+ from narwhals._polars.series import PolarsSeries
+
+ return {
+ name: PolarsSeries(col, backend_version=self._backend_version)
+ for name, col in df.to_dict(as_series=True).items()
+ }
+ else:
+ return df.to_dict(as_series=False)
+
+ def group_by(self, *by: str) -> Any:
+ from narwhals._polars.group_by import PolarsGroupBy
+
+ return PolarsGroupBy(self, list(by))
+
+ def with_row_index(self, name: str) -> Any:
+ if self._backend_version < (0, 20, 4): # pragma: no cover
+ return self._from_native_frame(self._native_frame.with_row_count(name))
+ return self._from_native_frame(self._native_frame.with_row_index(name))
+
+ def drop(self: Self, columns: list[str], strict: bool) -> Self: # noqa: FBT001
+ if self._backend_version < (1, 0, 0): # pragma: no cover
+ to_drop = parse_columns_to_drop(
+ compliant_frame=self, columns=columns, strict=strict
+ )
+ return self._from_native_frame(self._native_frame.drop(to_drop))
+ return self._from_native_frame(self._native_frame.drop(columns, strict=strict))
+
+
+class PolarsLazyFrame:
+ def __init__(self, df: Any, *, backend_version: tuple[int, ...]) -> None:
+ self._native_frame = df
+ self._backend_version = backend_version
+
+ def __repr__(self) -> str: # pragma: no cover
+ return "PolarsLazyFrame"
+
+ def __narwhals_lazyframe__(self) -> Self:
+ return self
+
+ def __narwhals_namespace__(self) -> PolarsNamespace:
+ return PolarsNamespace(backend_version=self._backend_version)
+
+ def __native_namespace__(self) -> Any: # pragma: no cover
+ return get_polars()
+
+ def _from_native_frame(self, df: Any) -> Self:
+ return self.__class__(df, backend_version=self._backend_version)
+
+ def __getattr__(self, attr: str) -> Any:
+ def func(*args: Any, **kwargs: Any) -> Any:
+ args, kwargs = extract_args_kwargs(args, kwargs) # type: ignore[assignment]
+ return self._from_native_frame(
+ getattr(self._native_frame, attr)(*args, **kwargs)
+ )
+
+ return func
+
+ @property
+ def columns(self) -> list[str]:
+ return self._native_frame.columns # type: ignore[no-any-return]
+
+ @property
+ def schema(self) -> dict[str, Any]:
+ schema = self._native_frame.schema
+ return {name: translate_dtype(dtype) for name, dtype in schema.items()}
+
+ def collect_schema(self) -> dict[str, Any]:
+ if self._backend_version < (1,): # pragma: no cover
+ schema = self._native_frame.schema
+ else:
+ schema = dict(self._native_frame.collect_schema())
+ return {name: translate_dtype(dtype) for name, dtype in schema.items()}
+
+ def collect(self) -> PolarsDataFrame:
+ return PolarsDataFrame(
+ self._native_frame.collect(), backend_version=self._backend_version
+ )
+
+ def group_by(self, *by: str) -> Any:
+ from narwhals._polars.group_by import PolarsLazyGroupBy
+
+ return PolarsLazyGroupBy(self, list(by))
+
+ def with_row_index(self, name: str) -> Any:
+ if self._backend_version < (0, 20, 4): # pragma: no cover
+ return self._from_native_frame(self._native_frame.with_row_count(name))
+ return self._from_native_frame(self._native_frame.with_row_index(name))
+
+ def drop(self: Self, columns: list[str], strict: bool) -> Self: # noqa: FBT001
+ if self._backend_version < (1, 0, 0): # pragma: no cover
+ return self._from_native_frame(self._native_frame.drop(columns))
+ return self._from_native_frame(self._native_frame.drop(columns, strict=strict))
diff --git a/parrot/lib/python3.10/site-packages/narwhals/stable/__init__.py b/parrot/lib/python3.10/site-packages/narwhals/stable/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..572034fe731008e7972de90224be5f187959f44d
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/narwhals/stable/__init__.py
@@ -0,0 +1,3 @@
+from narwhals.stable import v1
+
+__all__ = ["v1"]
diff --git a/parrot/lib/python3.10/site-packages/narwhals/stable/__pycache__/v1.cpython-310.pyc b/parrot/lib/python3.10/site-packages/narwhals/stable/__pycache__/v1.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7501fbcc31f08f7fe5263e17c69e040d6c7b61f3
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/narwhals/stable/__pycache__/v1.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/scipy/sparse/tests/data/csc_py2.npz b/parrot/lib/python3.10/site-packages/scipy/sparse/tests/data/csc_py2.npz
new file mode 100644
index 0000000000000000000000000000000000000000..d4459ff2786fabe4bcf4653d880cbf0afd4bfdcf
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/sparse/tests/data/csc_py2.npz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bac27f1a3eb1fdd102dae39b7dd61ce83e82f096388e344e14285071984d01fa
+size 846
diff --git a/parrot/lib/python3.10/site-packages/scipy/sparse/tests/data/csc_py3.npz b/parrot/lib/python3.10/site-packages/scipy/sparse/tests/data/csc_py3.npz
new file mode 100644
index 0000000000000000000000000000000000000000..e40a38584bc4647621601075d946ce46a8e065dc
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/scipy/sparse/tests/data/csc_py3.npz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b1b84315c7077417e720512d086a5a6217c2875b818d27704ae9b7237c69dfe
+size 851
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/__init__.py b/videollama2/lib/python3.10/site-packages/contourpy/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..33c1f014b867cc069d532839b405c3f7696c5a22
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/contourpy/__init__.py
@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from contourpy._contourpy import (
+ ContourGenerator,
+ FillType,
+ LineType,
+ Mpl2005ContourGenerator,
+ Mpl2014ContourGenerator,
+ SerialContourGenerator,
+ ThreadedContourGenerator,
+ ZInterp,
+ max_threads,
+)
+from contourpy._version import __version__
+from contourpy.chunk import calc_chunk_sizes
+from contourpy.convert import (
+ convert_filled,
+ convert_lines,
+ convert_multi_filled,
+ convert_multi_lines,
+)
+from contourpy.dechunk import (
+ dechunk_filled,
+ dechunk_lines,
+ dechunk_multi_filled,
+ dechunk_multi_lines,
+)
+from contourpy.enum_util import as_fill_type, as_line_type, as_z_interp
+
+if TYPE_CHECKING:
+ from typing import Any
+
+ from numpy.typing import ArrayLike
+
+ from ._contourpy import CoordinateArray, MaskArray
+
+__all__ = [
+ "__version__",
+ "contour_generator",
+ "convert_filled",
+ "convert_lines",
+ "convert_multi_filled",
+ "convert_multi_lines",
+ "dechunk_filled",
+ "dechunk_lines",
+ "dechunk_multi_filled",
+ "dechunk_multi_lines",
+ "max_threads",
+ "FillType",
+ "LineType",
+ "ContourGenerator",
+ "Mpl2005ContourGenerator",
+ "Mpl2014ContourGenerator",
+ "SerialContourGenerator",
+ "ThreadedContourGenerator",
+ "ZInterp",
+]
+
+
+# Simple mapping of algorithm name to class name.
+_class_lookup: dict[str, type[ContourGenerator]] = {
+ "mpl2005": Mpl2005ContourGenerator,
+ "mpl2014": Mpl2014ContourGenerator,
+ "serial": SerialContourGenerator,
+ "threaded": ThreadedContourGenerator,
+}
+
+
+def _remove_z_mask(
+ z: ArrayLike | np.ma.MaskedArray[Any, Any] | None,
+) -> tuple[CoordinateArray, MaskArray | None]:
+ # Preserve mask if present.
+ z_array = np.ma.asarray(z, dtype=np.float64) # type: ignore[no-untyped-call]
+ z_masked = np.ma.masked_invalid(z_array, copy=False) # type: ignore[no-untyped-call]
+
+ if np.ma.is_masked(z_masked): # type: ignore[no-untyped-call]
+ mask = np.ma.getmask(z_masked) # type: ignore[no-untyped-call]
+ else:
+ mask = None
+
+ return np.ma.getdata(z_masked), mask # type: ignore[no-untyped-call]
+
+
+def contour_generator(
+ x: ArrayLike | None = None,
+ y: ArrayLike | None = None,
+ z: ArrayLike | np.ma.MaskedArray[Any, Any] | None = None,
+ *,
+ name: str = "serial",
+ corner_mask: bool | None = None,
+ line_type: LineType | str | None = None,
+ fill_type: FillType | str | None = None,
+ chunk_size: int | tuple[int, int] | None = None,
+ chunk_count: int | tuple[int, int] | None = None,
+ total_chunk_count: int | None = None,
+ quad_as_tri: bool = False,
+ z_interp: ZInterp | str | None = ZInterp.Linear,
+ thread_count: int = 0,
+) -> ContourGenerator:
+ """Create and return a :class:`~.ContourGenerator` object.
+
+ The class and properties of the returned :class:`~.ContourGenerator` are determined by the
+ function arguments, with sensible defaults.
+
+ Args:
+ x (array-like of shape (ny, nx) or (nx,), optional): The x-coordinates of the ``z`` values.
+ May be 2D with the same shape as ``z.shape``, or 1D with length ``nx = z.shape[1]``.
+ If not specified are assumed to be ``np.arange(nx)``. Must be ordered monotonically.
+ y (array-like of shape (ny, nx) or (ny,), optional): The y-coordinates of the ``z`` values.
+ May be 2D with the same shape as ``z.shape``, or 1D with length ``ny = z.shape[0]``.
+ If not specified are assumed to be ``np.arange(ny)``. Must be ordered monotonically.
+ z (array-like of shape (ny, nx), may be a masked array): The 2D gridded values to calculate
+ the contours of. May be a masked array, and any invalid values (``np.inf`` or
+ ``np.nan``) will also be masked out.
+ name (str): Algorithm name, one of ``"serial"``, ``"threaded"``, ``"mpl2005"`` or
+ ``"mpl2014"``, default ``"serial"``.
+ corner_mask (bool, optional): Enable/disable corner masking, which only has an effect if
+ ``z`` is a masked array. If ``False``, any quad touching a masked point is masked out.
+ If ``True``, only the triangular corners of quads nearest these points are always masked
+ out, other triangular corners comprising three unmasked points are contoured as usual.
+ If not specified, uses the default provided by the algorithm ``name``.
+ line_type (LineType or str, optional): The format of contour line data returned from calls
+ to :meth:`~.ContourGenerator.lines`, specified either as a :class:`~.LineType` or its
+ string equivalent such as ``"SeparateCode"``.
+ If not specified, uses the default provided by the algorithm ``name``.
+ The relationship between the :class:`~.LineType` enum and the data format returned from
+ :meth:`~.ContourGenerator.lines` is explained at :ref:`line_type`.
+ fill_type (FillType or str, optional): The format of filled contour data returned from calls
+ to :meth:`~.ContourGenerator.filled`, specified either as a :class:`~.FillType` or its
+ string equivalent such as ``"OuterOffset"``.
+ If not specified, uses the default provided by the algorithm ``name``.
+ The relationship between the :class:`~.FillType` enum and the data format returned from
+ :meth:`~.ContourGenerator.filled` is explained at :ref:`fill_type`.
+ chunk_size (int or tuple(int, int), optional): Chunk size in (y, x) directions, or the same
+ size in both directions if only one value is specified.
+ chunk_count (int or tuple(int, int), optional): Chunk count in (y, x) directions, or the
+ same count in both directions if only one value is specified.
+ total_chunk_count (int, optional): Total number of chunks.
+ quad_as_tri (bool): Enable/disable treating quads as 4 triangles, default ``False``.
+ If ``False``, a contour line within a quad is a straight line between points on two of
+ its edges. If ``True``, each full quad is divided into 4 triangles using a virtual point
+ at the centre (mean x, y of the corner points) and a contour line is piecewise linear
+ within those triangles. Corner-masked triangles are not affected by this setting, only
+ full unmasked quads.
+ z_interp (ZInterp or str, optional): How to interpolate ``z`` values when determining where
+ contour lines intersect the edges of quads and the ``z`` values of the central points of
+ quads, specified either as a :class:`~contourpy.ZInterp` or its string equivalent such
+ as ``"Log"``. Default is ``ZInterp.Linear``.
+ thread_count (int): Number of threads to use for contour calculation, default 0. Threads can
+ only be used with an algorithm ``name`` that supports threads (currently only
+ ``name="threaded"``) and there must be at least the same number of chunks as threads.
+ If ``thread_count=0`` and ``name="threaded"`` then it uses the maximum number of threads
+ as determined by the C++11 call ``std::thread::hardware_concurrency()``. If ``name`` is
+ something other than ``"threaded"`` then the ``thread_count`` will be set to ``1``.
+
+ Return:
+ :class:`~.ContourGenerator`.
+
+ Note:
+ A maximum of one of ``chunk_size``, ``chunk_count`` and ``total_chunk_count`` may be
+ specified.
+
+ Warning:
+ The ``name="mpl2005"`` algorithm does not implement chunking for contour lines.
+ """
+ x = np.asarray(x, dtype=np.float64)
+ y = np.asarray(y, dtype=np.float64)
+ z, mask = _remove_z_mask(z)
+
+ # Check arguments: z.
+ if z.ndim != 2:
+ raise TypeError(f"Input z must be 2D, not {z.ndim}D")
+
+ if z.shape[0] < 2 or z.shape[1] < 2:
+ raise TypeError(f"Input z must be at least a (2, 2) shaped array, but has shape {z.shape}")
+
+ ny, nx = z.shape
+
+ # Check arguments: x and y.
+ if x.ndim != y.ndim:
+ raise TypeError(f"Number of dimensions of x ({x.ndim}) and y ({y.ndim}) do not match")
+
+ if x.ndim == 0:
+ x = np.arange(nx, dtype=np.float64)
+ y = np.arange(ny, dtype=np.float64)
+ x, y = np.meshgrid(x, y)
+ elif x.ndim == 1:
+ if len(x) != nx:
+ raise TypeError(f"Length of x ({len(x)}) must match number of columns in z ({nx})")
+ if len(y) != ny:
+ raise TypeError(f"Length of y ({len(y)}) must match number of rows in z ({ny})")
+ x, y = np.meshgrid(x, y)
+ elif x.ndim == 2:
+ if x.shape != z.shape:
+ raise TypeError(f"Shapes of x {x.shape} and z {z.shape} do not match")
+ if y.shape != z.shape:
+ raise TypeError(f"Shapes of y {y.shape} and z {z.shape} do not match")
+ else:
+ raise TypeError(f"Inputs x and y must be None, 1D or 2D, not {x.ndim}D")
+
+ # Check mask shape just in case.
+ if mask is not None and mask.shape != z.shape:
+ raise ValueError("If mask is set it must be a 2D array with the same shape as z")
+
+ # Check arguments: name.
+ if name not in _class_lookup:
+ raise ValueError(f"Unrecognised contour generator name: {name}")
+
+ # Check arguments: chunk_size, chunk_count and total_chunk_count.
+ y_chunk_size, x_chunk_size = calc_chunk_sizes(
+ chunk_size, chunk_count, total_chunk_count, ny, nx)
+
+ cls = _class_lookup[name]
+
+ # Check arguments: corner_mask.
+ if corner_mask is None:
+ # Set it to default, which is True if the algorithm supports it.
+ corner_mask = cls.supports_corner_mask()
+ elif corner_mask and not cls.supports_corner_mask():
+ raise ValueError(f"{name} contour generator does not support corner_mask=True")
+
+ # Check arguments: line_type.
+ if line_type is None:
+ line_type = cls.default_line_type
+ else:
+ line_type = as_line_type(line_type)
+
+ if not cls.supports_line_type(line_type):
+ raise ValueError(f"{name} contour generator does not support line_type {line_type}")
+
+ # Check arguments: fill_type.
+ if fill_type is None:
+ fill_type = cls.default_fill_type
+ else:
+ fill_type = as_fill_type(fill_type)
+
+ if not cls.supports_fill_type(fill_type):
+ raise ValueError(f"{name} contour generator does not support fill_type {fill_type}")
+
+ # Check arguments: quad_as_tri.
+ if quad_as_tri and not cls.supports_quad_as_tri():
+ raise ValueError(f"{name} contour generator does not support quad_as_tri=True")
+
+ # Check arguments: z_interp.
+ if z_interp is None:
+ z_interp = ZInterp.Linear
+ else:
+ z_interp = as_z_interp(z_interp)
+
+ if z_interp != ZInterp.Linear and not cls.supports_z_interp():
+ raise ValueError(f"{name} contour generator does not support z_interp {z_interp}")
+
+ # Check arguments: thread_count.
+ if thread_count not in (0, 1) and not cls.supports_threads():
+ raise ValueError(f"{name} contour generator does not support thread_count {thread_count}")
+
+ # Prepare args and kwargs for contour generator constructor.
+ args = [x, y, z, mask]
+ kwargs: dict[str, int | bool | LineType | FillType | ZInterp] = {
+ "x_chunk_size": x_chunk_size,
+ "y_chunk_size": y_chunk_size,
+ }
+
+ if name not in ("mpl2005", "mpl2014"):
+ kwargs["line_type"] = line_type
+ kwargs["fill_type"] = fill_type
+
+ if cls.supports_corner_mask():
+ kwargs["corner_mask"] = corner_mask
+
+ if cls.supports_quad_as_tri():
+ kwargs["quad_as_tri"] = quad_as_tri
+
+ if cls.supports_z_interp():
+ kwargs["z_interp"] = z_interp
+
+ if cls.supports_threads():
+ kwargs["thread_count"] = thread_count
+
+ # Create contour generator.
+ return cls(*args, **kwargs)
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/__pycache__/array.cpython-310.pyc b/videollama2/lib/python3.10/site-packages/contourpy/__pycache__/array.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2f8ebf69b55a9f708c35a1527fb161c7b2172669
Binary files /dev/null and b/videollama2/lib/python3.10/site-packages/contourpy/__pycache__/array.cpython-310.pyc differ
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/__pycache__/convert.cpython-310.pyc b/videollama2/lib/python3.10/site-packages/contourpy/__pycache__/convert.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4f07ea7296bf02fe29fb0d8f9fdcbc07bff1dffc
Binary files /dev/null and b/videollama2/lib/python3.10/site-packages/contourpy/__pycache__/convert.cpython-310.pyc differ
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/__pycache__/typecheck.cpython-310.pyc b/videollama2/lib/python3.10/site-packages/contourpy/__pycache__/typecheck.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2e05dbdcaffabba1116e9ec29c41e1d404691a51
Binary files /dev/null and b/videollama2/lib/python3.10/site-packages/contourpy/__pycache__/typecheck.cpython-310.pyc differ
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/__pycache__/types.cpython-310.pyc b/videollama2/lib/python3.10/site-packages/contourpy/__pycache__/types.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9d8e435a18000b1e858bad6bdf3deb4cbdd81723
Binary files /dev/null and b/videollama2/lib/python3.10/site-packages/contourpy/__pycache__/types.cpython-310.pyc differ
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/_contourpy.cpython-310-x86_64-linux-gnu.so b/videollama2/lib/python3.10/site-packages/contourpy/_contourpy.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..d53ad79339bfa925387e2e889cd01bdd7d4f91b2
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/contourpy/_contourpy.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe9c88f2f427be9957274766f567919180820ca775e77ab75173142f2501ce4f
+size 844208
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/array.py b/videollama2/lib/python3.10/site-packages/contourpy/array.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b41fb2589b3ed8e50e83f5c0e82bb6d76a72591
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/contourpy/array.py
@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+from itertools import chain
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from contourpy.typecheck import check_code_array, check_offset_array, check_point_array
+from contourpy.types import CLOSEPOLY, LINETO, MOVETO, code_dtype, offset_dtype, point_dtype
+
+if TYPE_CHECKING:
+ import contourpy._contourpy as cpy
+
+
+def codes_from_offsets(offsets: cpy.OffsetArray) -> cpy.CodeArray:
+ """Determine codes from offsets, assuming they all correspond to closed polygons.
+ """
+ check_offset_array(offsets)
+
+ n = offsets[-1]
+ codes = np.full(n, LINETO, dtype=code_dtype)
+ codes[offsets[:-1]] = MOVETO
+ codes[offsets[1:] - 1] = CLOSEPOLY
+ return codes
+
+
+def codes_from_offsets_and_points(
+ offsets: cpy.OffsetArray,
+ points: cpy.PointArray,
+) -> cpy.CodeArray:
+ """Determine codes from offsets and points, using the equality of the start and end points of
+ each line to determine if lines are closed or not.
+ """
+ check_offset_array(offsets)
+ check_point_array(points)
+
+ codes = np.full(len(points), LINETO, dtype=code_dtype)
+ codes[offsets[:-1]] = MOVETO
+
+ end_offsets = offsets[1:] - 1
+ closed = np.all(points[offsets[:-1]] == points[end_offsets], axis=1)
+ codes[end_offsets[closed]] = CLOSEPOLY
+
+ return codes
+
+
+def codes_from_points(points: cpy.PointArray) -> cpy.CodeArray:
+ """Determine codes for a single line, using the equality of the start and end points to
+ determine if the line is closed or not.
+ """
+ check_point_array(points)
+
+ n = len(points)
+ codes = np.full(n, LINETO, dtype=code_dtype)
+ codes[0] = MOVETO
+ if np.all(points[0] == points[-1]):
+ codes[-1] = CLOSEPOLY
+ return codes
+
+
+def concat_codes(list_of_codes: list[cpy.CodeArray]) -> cpy.CodeArray:
+ """Concatenate a list of codes arrays into a single code array.
+ """
+ if not list_of_codes:
+ raise ValueError("Empty list passed to concat_codes")
+
+ return np.concatenate(list_of_codes, dtype=code_dtype)
+
+
+def concat_codes_or_none(list_of_codes_or_none: list[cpy.CodeArray | None]) -> cpy.CodeArray | None:
+ """Concatenate a list of codes arrays or None into a single code array or None.
+ """
+ list_of_codes = [codes for codes in list_of_codes_or_none if codes is not None]
+ if list_of_codes:
+ return concat_codes(list_of_codes)
+ else:
+ return None
+
+
+def concat_offsets(list_of_offsets: list[cpy.OffsetArray]) -> cpy.OffsetArray:
+ """Concatenate a list of offsets arrays into a single offset array.
+ """
+ if not list_of_offsets:
+ raise ValueError("Empty list passed to concat_offsets")
+
+ n = len(list_of_offsets)
+ cumulative = np.cumsum([offsets[-1] for offsets in list_of_offsets], dtype=offset_dtype)
+ ret: cpy.OffsetArray = np.concatenate(
+ (list_of_offsets[0], *(list_of_offsets[i+1][1:] + cumulative[i] for i in range(n-1))),
+ dtype=offset_dtype,
+ )
+ return ret
+
+
+def concat_offsets_or_none(
+ list_of_offsets_or_none: list[cpy.OffsetArray | None],
+) -> cpy.OffsetArray | None:
+ """Concatenate a list of offsets arrays or None into a single offset array or None.
+ """
+ list_of_offsets = [offsets for offsets in list_of_offsets_or_none if offsets is not None]
+ if list_of_offsets:
+ return concat_offsets(list_of_offsets)
+ else:
+ return None
+
+
+def concat_points(list_of_points: list[cpy.PointArray]) -> cpy.PointArray:
+ """Concatenate a list of point arrays into a single point array.
+ """
+ if not list_of_points:
+ raise ValueError("Empty list passed to concat_points")
+
+ return np.concatenate(list_of_points, dtype=point_dtype)
+
+
+def concat_points_or_none(
+ list_of_points_or_none: list[cpy.PointArray | None],
+) -> cpy.PointArray | None:
+ """Concatenate a list of point arrays or None into a single point array or None.
+ """
+ list_of_points = [points for points in list_of_points_or_none if points is not None]
+ if list_of_points:
+ return concat_points(list_of_points)
+ else:
+ return None
+
+
+def concat_points_or_none_with_nan(
+ list_of_points_or_none: list[cpy.PointArray | None],
+) -> cpy.PointArray | None:
+ """Concatenate a list of points or None into a single point array or None, with NaNs used to
+ separate each line.
+ """
+ list_of_points = [points for points in list_of_points_or_none if points is not None]
+ if list_of_points:
+ return concat_points_with_nan(list_of_points)
+ else:
+ return None
+
+
+def concat_points_with_nan(list_of_points: list[cpy.PointArray]) -> cpy.PointArray:
+ """Concatenate a list of points into a single point array with NaNs used to separate each line.
+ """
+ if not list_of_points:
+ raise ValueError("Empty list passed to concat_points_with_nan")
+
+ if len(list_of_points) == 1:
+ return list_of_points[0]
+ else:
+ nan_spacer = np.full((1, 2), np.nan, dtype=point_dtype)
+ list_of_points = [list_of_points[0],
+ *list(chain(*((nan_spacer, x) for x in list_of_points[1:])))]
+ return concat_points(list_of_points)
+
+
+def insert_nan_at_offsets(points: cpy.PointArray, offsets: cpy.OffsetArray) -> cpy.PointArray:
+ """Insert NaNs into a point array at locations specified by an offset array.
+ """
+ check_point_array(points)
+ check_offset_array(offsets)
+
+ if len(offsets) <= 2:
+ return points
+ else:
+ nan_spacer = np.array([np.nan, np.nan], dtype=point_dtype)
+ # Convert offsets to int64 to avoid numpy error when mixing signed and unsigned ints.
+ return np.insert(points, offsets[1:-1].astype(np.int64), nan_spacer, axis=0)
+
+
+def offsets_from_codes(codes: cpy.CodeArray) -> cpy.OffsetArray:
+ """Determine offsets from codes using locations of MOVETO codes.
+ """
+ check_code_array(codes)
+
+ return np.append(np.nonzero(codes == MOVETO)[0], len(codes)).astype(offset_dtype)
+
+
+def offsets_from_lengths(list_of_points: list[cpy.PointArray]) -> cpy.OffsetArray:
+ """Determine offsets from lengths of point arrays.
+ """
+ if not list_of_points:
+ raise ValueError("Empty list passed to offsets_from_lengths")
+
+ return np.cumsum([0] + [len(line) for line in list_of_points], dtype=offset_dtype)
+
+
+def outer_offsets_from_list_of_codes(list_of_codes: list[cpy.CodeArray]) -> cpy.OffsetArray:
+ """Determine outer offsets from codes using locations of MOVETO codes.
+ """
+ if not list_of_codes:
+ raise ValueError("Empty list passed to outer_offsets_from_list_of_codes")
+
+ return np.cumsum([0] + [np.count_nonzero(codes == MOVETO) for codes in list_of_codes],
+ dtype=offset_dtype)
+
+
+def outer_offsets_from_list_of_offsets(list_of_offsets: list[cpy.OffsetArray]) -> cpy.OffsetArray:
+ """Determine outer offsets from a list of offsets.
+ """
+ if not list_of_offsets:
+ raise ValueError("Empty list passed to outer_offsets_from_list_of_offsets")
+
+ return np.cumsum([0] + [len(offsets)-1 for offsets in list_of_offsets], dtype=offset_dtype)
+
+
+def remove_nan(points: cpy.PointArray) -> tuple[cpy.PointArray, cpy.OffsetArray]:
+ """Remove NaN from a points array, also return the offsets corresponding to the NaN removed.
+ """
+ check_point_array(points)
+
+ nan_offsets = np.nonzero(np.isnan(points[:, 0]))[0]
+ if len(nan_offsets) == 0:
+ return points, np.array([0, len(points)], dtype=offset_dtype)
+ else:
+ points = np.delete(points, nan_offsets, axis=0)
+ nan_offsets -= np.arange(len(nan_offsets))
+ offsets: cpy.OffsetArray = np.empty(len(nan_offsets)+2, dtype=offset_dtype)
+ offsets[0] = 0
+ offsets[1:-1] = nan_offsets
+ offsets[-1] = len(points)
+ return points, offsets
+
+
+def split_codes_by_offsets(codes: cpy.CodeArray, offsets: cpy.OffsetArray) -> list[cpy.CodeArray]:
+ """Split a code array at locations specified by an offset array into a list of code arrays.
+ """
+ check_code_array(codes)
+ check_offset_array(offsets)
+
+ if len(offsets) > 2:
+ return np.split(codes, offsets[1:-1])
+ else:
+ return [codes]
+
+
+def split_points_by_offsets(
+ points: cpy.PointArray,
+ offsets: cpy.OffsetArray,
+) -> list[cpy.PointArray]:
+ """Split a point array at locations specified by an offset array into a list of point arrays.
+ """
+ check_point_array(points)
+ check_offset_array(offsets)
+
+ if len(offsets) > 2:
+ return np.split(points, offsets[1:-1])
+ else:
+ return [points]
+
+
+def split_points_at_nan(points: cpy.PointArray) -> list[cpy.PointArray]:
+ """Split a points array at NaNs into a list of point arrays.
+ """
+ check_point_array(points)
+
+ nan_offsets = np.nonzero(np.isnan(points[:, 0]))[0]
+ if len(nan_offsets) == 0:
+ return [points]
+ else:
+ nan_offsets = np.concatenate(([-1], nan_offsets, [len(points)]))
+ return [points[s+1:e] for s, e in zip(nan_offsets[:-1], nan_offsets[1:])]
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/convert.py b/videollama2/lib/python3.10/site-packages/contourpy/convert.py
new file mode 100644
index 0000000000000000000000000000000000000000..92adbbb5b6608f017e259c809b1255e1d8c587e9
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/contourpy/convert.py
@@ -0,0 +1,620 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import numpy as np
+
+from contourpy._contourpy import FillType, LineType
+import contourpy.array as arr
+from contourpy.enum_util import as_fill_type, as_line_type
+from contourpy.typecheck import check_filled, check_lines
+from contourpy.types import MOVETO, offset_dtype
+
+if TYPE_CHECKING:
+ import contourpy._contourpy as cpy
+
+
+def _convert_filled_from_OuterCode(
+ filled: cpy.FillReturn_OuterCode,
+ fill_type_to: FillType,
+) -> cpy.FillReturn:
+ if fill_type_to == FillType.OuterCode:
+ return filled
+ elif fill_type_to == FillType.OuterOffset:
+ return (filled[0], [arr.offsets_from_codes(codes) for codes in filled[1]])
+
+ if len(filled[0]) > 0:
+ points = arr.concat_points(filled[0])
+ codes = arr.concat_codes(filled[1])
+ else:
+ points = None
+ codes = None
+
+ if fill_type_to == FillType.ChunkCombinedCode:
+ return ([points], [codes])
+ elif fill_type_to == FillType.ChunkCombinedOffset:
+ return ([points], [None if codes is None else arr.offsets_from_codes(codes)])
+ elif fill_type_to == FillType.ChunkCombinedCodeOffset:
+ outer_offsets = None if points is None else arr.offsets_from_lengths(filled[0])
+ ret1: cpy.FillReturn_ChunkCombinedCodeOffset = ([points], [codes], [outer_offsets])
+ return ret1
+ elif fill_type_to == FillType.ChunkCombinedOffsetOffset:
+ if codes is None:
+ ret2: cpy.FillReturn_ChunkCombinedOffsetOffset = ([None], [None], [None])
+ else:
+ offsets = arr.offsets_from_codes(codes)
+ outer_offsets = arr.outer_offsets_from_list_of_codes(filled[1])
+ ret2 = ([points], [offsets], [outer_offsets])
+ return ret2
+ else:
+ raise ValueError(f"Invalid FillType {fill_type_to}")
+
+
+def _convert_filled_from_OuterOffset(
+ filled: cpy.FillReturn_OuterOffset,
+ fill_type_to: FillType,
+) -> cpy.FillReturn:
+ if fill_type_to == FillType.OuterCode:
+ separate_codes = [arr.codes_from_offsets(offsets) for offsets in filled[1]]
+ return (filled[0], separate_codes)
+ elif fill_type_to == FillType.OuterOffset:
+ return filled
+
+ if len(filled[0]) > 0:
+ points = arr.concat_points(filled[0])
+ offsets = arr.concat_offsets(filled[1])
+ else:
+ points = None
+ offsets = None
+
+ if fill_type_to == FillType.ChunkCombinedCode:
+ return ([points], [None if offsets is None else arr.codes_from_offsets(offsets)])
+ elif fill_type_to == FillType.ChunkCombinedOffset:
+ return ([points], [offsets])
+ elif fill_type_to == FillType.ChunkCombinedCodeOffset:
+ if offsets is None:
+ ret1: cpy.FillReturn_ChunkCombinedCodeOffset = ([None], [None], [None])
+ else:
+ codes = arr.codes_from_offsets(offsets)
+ outer_offsets = arr.offsets_from_lengths(filled[0])
+ ret1 = ([points], [codes], [outer_offsets])
+ return ret1
+ elif fill_type_to == FillType.ChunkCombinedOffsetOffset:
+ if points is None:
+ ret2: cpy.FillReturn_ChunkCombinedOffsetOffset = ([None], [None], [None])
+ else:
+ outer_offsets = arr.outer_offsets_from_list_of_offsets(filled[1])
+ ret2 = ([points], [offsets], [outer_offsets])
+ return ret2
+ else:
+ raise ValueError(f"Invalid FillType {fill_type_to}")
+
+
+def _convert_filled_from_ChunkCombinedCode(
+ filled: cpy.FillReturn_ChunkCombinedCode,
+ fill_type_to: FillType,
+) -> cpy.FillReturn:
+ if fill_type_to == FillType.ChunkCombinedCode:
+ return filled
+ elif fill_type_to == FillType.ChunkCombinedOffset:
+ codes = [None if codes is None else arr.offsets_from_codes(codes) for codes in filled[1]]
+ return (filled[0], codes)
+ else:
+ raise ValueError(
+ f"Conversion from {FillType.ChunkCombinedCode} to {fill_type_to} not supported")
+
+
+def _convert_filled_from_ChunkCombinedOffset(
+ filled: cpy.FillReturn_ChunkCombinedOffset,
+ fill_type_to: FillType,
+) -> cpy.FillReturn:
+ if fill_type_to == FillType.ChunkCombinedCode:
+ chunk_codes: list[cpy.CodeArray | None] = []
+ for points, offsets in zip(*filled):
+ if points is None:
+ chunk_codes.append(None)
+ else:
+ if TYPE_CHECKING:
+ assert offsets is not None
+ chunk_codes.append(arr.codes_from_offsets_and_points(offsets, points))
+ return (filled[0], chunk_codes)
+ elif fill_type_to == FillType.ChunkCombinedOffset:
+ return filled
+ else:
+ raise ValueError(
+ f"Conversion from {FillType.ChunkCombinedOffset} to {fill_type_to} not supported")
+
+
+def _convert_filled_from_ChunkCombinedCodeOffset(
+ filled: cpy.FillReturn_ChunkCombinedCodeOffset,
+ fill_type_to: FillType,
+) -> cpy.FillReturn:
+ if fill_type_to == FillType.OuterCode:
+ separate_points = []
+ separate_codes = []
+ for points, codes, outer_offsets in zip(*filled):
+ if points is not None:
+ if TYPE_CHECKING:
+ assert codes is not None
+ assert outer_offsets is not None
+ separate_points += arr.split_points_by_offsets(points, outer_offsets)
+ separate_codes += arr.split_codes_by_offsets(codes, outer_offsets)
+ return (separate_points, separate_codes)
+ elif fill_type_to == FillType.OuterOffset:
+ separate_points = []
+ separate_offsets = []
+ for points, codes, outer_offsets in zip(*filled):
+ if points is not None:
+ if TYPE_CHECKING:
+ assert codes is not None
+ assert outer_offsets is not None
+ separate_points += arr.split_points_by_offsets(points, outer_offsets)
+ separate_codes = arr.split_codes_by_offsets(codes, outer_offsets)
+ separate_offsets += [arr.offsets_from_codes(codes) for codes in separate_codes]
+ return (separate_points, separate_offsets)
+ elif fill_type_to == FillType.ChunkCombinedCode:
+ ret1: cpy.FillReturn_ChunkCombinedCode = (filled[0], filled[1])
+ return ret1
+ elif fill_type_to == FillType.ChunkCombinedOffset:
+ all_offsets = [None if codes is None else arr.offsets_from_codes(codes)
+ for codes in filled[1]]
+ ret2: cpy.FillReturn_ChunkCombinedOffset = (filled[0], all_offsets)
+ return ret2
+ elif fill_type_to == FillType.ChunkCombinedCodeOffset:
+ return filled
+ elif fill_type_to == FillType.ChunkCombinedOffsetOffset:
+ chunk_offsets: list[cpy.OffsetArray | None] = []
+ chunk_outer_offsets: list[cpy.OffsetArray | None] = []
+ for codes, outer_offsets in zip(*filled[1:]):
+ if codes is None:
+ chunk_offsets.append(None)
+ chunk_outer_offsets.append(None)
+ else:
+ if TYPE_CHECKING:
+ assert outer_offsets is not None
+ offsets = arr.offsets_from_codes(codes)
+ outer_offsets = np.array([np.nonzero(offsets == oo)[0][0] for oo in outer_offsets],
+ dtype=offset_dtype)
+ chunk_offsets.append(offsets)
+ chunk_outer_offsets.append(outer_offsets)
+ ret3: cpy.FillReturn_ChunkCombinedOffsetOffset = (
+ filled[0], chunk_offsets, chunk_outer_offsets,
+ )
+ return ret3
+ else:
+ raise ValueError(f"Invalid FillType {fill_type_to}")
+
+
+def _convert_filled_from_ChunkCombinedOffsetOffset(
+ filled: cpy.FillReturn_ChunkCombinedOffsetOffset,
+ fill_type_to: FillType,
+) -> cpy.FillReturn:
+ if fill_type_to == FillType.OuterCode:
+ separate_points = []
+ separate_codes = []
+ for points, offsets, outer_offsets in zip(*filled):
+ if points is not None:
+ if TYPE_CHECKING:
+ assert offsets is not None
+ assert outer_offsets is not None
+ codes = arr.codes_from_offsets_and_points(offsets, points)
+ outer_offsets = offsets[outer_offsets]
+ separate_points += arr.split_points_by_offsets(points, outer_offsets)
+ separate_codes += arr.split_codes_by_offsets(codes, outer_offsets)
+ return (separate_points, separate_codes)
+ elif fill_type_to == FillType.OuterOffset:
+ separate_points = []
+ separate_offsets = []
+ for points, offsets, outer_offsets in zip(*filled):
+ if points is not None:
+ if TYPE_CHECKING:
+ assert offsets is not None
+ assert outer_offsets is not None
+ if len(outer_offsets) > 2:
+ separate_offsets += [offsets[s:e+1] - offsets[s] for s, e in
+ zip(outer_offsets[:-1], outer_offsets[1:])]
+ else:
+ separate_offsets.append(offsets)
+ separate_points += arr.split_points_by_offsets(points, offsets[outer_offsets])
+ return (separate_points, separate_offsets)
+ elif fill_type_to == FillType.ChunkCombinedCode:
+ chunk_codes: list[cpy.CodeArray | None] = []
+ for points, offsets, outer_offsets in zip(*filled):
+ if points is None:
+ chunk_codes.append(None)
+ else:
+ if TYPE_CHECKING:
+ assert offsets is not None
+ assert outer_offsets is not None
+ chunk_codes.append(arr.codes_from_offsets_and_points(offsets, points))
+ ret1: cpy.FillReturn_ChunkCombinedCode = (filled[0], chunk_codes)
+ return ret1
+ elif fill_type_to == FillType.ChunkCombinedOffset:
+ return (filled[0], filled[1])
+ elif fill_type_to == FillType.ChunkCombinedCodeOffset:
+ chunk_codes = []
+ chunk_outer_offsets: list[cpy.OffsetArray | None] = []
+ for points, offsets, outer_offsets in zip(*filled):
+ if points is None:
+ chunk_codes.append(None)
+ chunk_outer_offsets.append(None)
+ else:
+ if TYPE_CHECKING:
+ assert offsets is not None
+ assert outer_offsets is not None
+ chunk_codes.append(arr.codes_from_offsets_and_points(offsets, points))
+ chunk_outer_offsets.append(offsets[outer_offsets])
+ ret2: cpy.FillReturn_ChunkCombinedCodeOffset = (filled[0], chunk_codes, chunk_outer_offsets)
+ return ret2
+ elif fill_type_to == FillType.ChunkCombinedOffsetOffset:
+ return filled
+ else:
+ raise ValueError(f"Invalid FillType {fill_type_to}")
+
+
+def convert_filled(
+ filled: cpy.FillReturn,
+ fill_type_from: FillType | str,
+ fill_type_to: FillType | str,
+) -> cpy.FillReturn:
+ """Convert filled contours from one :class:`~.FillType` to another.
+
+ Args:
+ filled (sequence of arrays): Filled contour polygons to convert, such as those returned by
+ :meth:`.ContourGenerator.filled`.
+ fill_type_from (FillType or str): :class:`~.FillType` to convert from as enum or
+ string equivalent.
+ fill_type_to (FillType or str): :class:`~.FillType` to convert to as enum or string
+ equivalent.
+
+ Return:
+ Converted filled contour polygons.
+
+ When converting non-chunked fill types (``FillType.OuterCode`` or ``FillType.OuterOffset``) to
+ chunked ones, all polygons are placed in the first chunk. When converting in the other
+ direction, all chunk information is discarded. Converting a fill type that is not aware of the
+ relationship between outer boundaries and contained holes (``FillType.ChunkCombinedCode`` or
+ ``FillType.ChunkCombinedOffset``) to one that is will raise a ``ValueError``.
+
+ .. versionadded:: 1.2.0
+ """
+ fill_type_from = as_fill_type(fill_type_from)
+ fill_type_to = as_fill_type(fill_type_to)
+
+ check_filled(filled, fill_type_from)
+
+ if fill_type_from == FillType.OuterCode:
+ if TYPE_CHECKING:
+ filled = cast(cpy.FillReturn_OuterCode, filled)
+ return _convert_filled_from_OuterCode(filled, fill_type_to)
+ elif fill_type_from == FillType.OuterOffset:
+ if TYPE_CHECKING:
+ filled = cast(cpy.FillReturn_OuterOffset, filled)
+ return _convert_filled_from_OuterOffset(filled, fill_type_to)
+ elif fill_type_from == FillType.ChunkCombinedCode:
+ if TYPE_CHECKING:
+ filled = cast(cpy.FillReturn_ChunkCombinedCode, filled)
+ return _convert_filled_from_ChunkCombinedCode(filled, fill_type_to)
+ elif fill_type_from == FillType.ChunkCombinedOffset:
+ if TYPE_CHECKING:
+ filled = cast(cpy.FillReturn_ChunkCombinedOffset, filled)
+ return _convert_filled_from_ChunkCombinedOffset(filled, fill_type_to)
+ elif fill_type_from == FillType.ChunkCombinedCodeOffset:
+ if TYPE_CHECKING:
+ filled = cast(cpy.FillReturn_ChunkCombinedCodeOffset, filled)
+ return _convert_filled_from_ChunkCombinedCodeOffset(filled, fill_type_to)
+ elif fill_type_from == FillType.ChunkCombinedOffsetOffset:
+ if TYPE_CHECKING:
+ filled = cast(cpy.FillReturn_ChunkCombinedOffsetOffset, filled)
+ return _convert_filled_from_ChunkCombinedOffsetOffset(filled, fill_type_to)
+ else:
+ raise ValueError(f"Invalid FillType {fill_type_from}")
+
+
+def _convert_lines_from_Separate(
+ lines: cpy.LineReturn_Separate,
+ line_type_to: LineType,
+) -> cpy.LineReturn:
+ if line_type_to == LineType.Separate:
+ return lines
+ elif line_type_to == LineType.SeparateCode:
+ separate_codes = [arr.codes_from_points(line) for line in lines]
+ return (lines, separate_codes)
+ elif line_type_to == LineType.ChunkCombinedCode:
+ if not lines:
+ ret1: cpy.LineReturn_ChunkCombinedCode = ([None], [None])
+ else:
+ points = arr.concat_points(lines)
+ offsets = arr.offsets_from_lengths(lines)
+ codes = arr.codes_from_offsets_and_points(offsets, points)
+ ret1 = ([points], [codes])
+ return ret1
+ elif line_type_to == LineType.ChunkCombinedOffset:
+ if not lines:
+ ret2: cpy.LineReturn_ChunkCombinedOffset = ([None], [None])
+ else:
+ ret2 = ([arr.concat_points(lines)], [arr.offsets_from_lengths(lines)])
+ return ret2
+ elif line_type_to == LineType.ChunkCombinedNan:
+ if not lines:
+ ret3: cpy.LineReturn_ChunkCombinedNan = ([None],)
+ else:
+ ret3 = ([arr.concat_points_with_nan(lines)],)
+ return ret3
+ else:
+ raise ValueError(f"Invalid LineType {line_type_to}")
+
+
+def _convert_lines_from_SeparateCode(
+ lines: cpy.LineReturn_SeparateCode,
+ line_type_to: LineType,
+) -> cpy.LineReturn:
+ if line_type_to == LineType.Separate:
+ # Drop codes.
+ return lines[0]
+ elif line_type_to == LineType.SeparateCode:
+ return lines
+ elif line_type_to == LineType.ChunkCombinedCode:
+ if not lines[0]:
+ ret1: cpy.LineReturn_ChunkCombinedCode = ([None], [None])
+ else:
+ ret1 = ([arr.concat_points(lines[0])], [arr.concat_codes(lines[1])])
+ return ret1
+ elif line_type_to == LineType.ChunkCombinedOffset:
+ if not lines[0]:
+ ret2: cpy.LineReturn_ChunkCombinedOffset = ([None], [None])
+ else:
+ ret2 = ([arr.concat_points(lines[0])], [arr.offsets_from_lengths(lines[0])])
+ return ret2
+ elif line_type_to == LineType.ChunkCombinedNan:
+ if not lines[0]:
+ ret3: cpy.LineReturn_ChunkCombinedNan = ([None],)
+ else:
+ ret3 = ([arr.concat_points_with_nan(lines[0])],)
+ return ret3
+ else:
+ raise ValueError(f"Invalid LineType {line_type_to}")
+
+
+def _convert_lines_from_ChunkCombinedCode(
+ lines: cpy.LineReturn_ChunkCombinedCode,
+ line_type_to: LineType,
+) -> cpy.LineReturn:
+ if line_type_to in (LineType.Separate, LineType.SeparateCode):
+ separate_lines = []
+ for points, codes in zip(*lines):
+ if points is not None:
+ if TYPE_CHECKING:
+ assert codes is not None
+ split_at = np.nonzero(codes == MOVETO)[0]
+ if len(split_at) > 1:
+ separate_lines += np.split(points, split_at[1:])
+ else:
+ separate_lines.append(points)
+ if line_type_to == LineType.Separate:
+ return separate_lines
+ else:
+ separate_codes = [arr.codes_from_points(line) for line in separate_lines]
+ return (separate_lines, separate_codes)
+ elif line_type_to == LineType.ChunkCombinedCode:
+ return lines
+ elif line_type_to == LineType.ChunkCombinedOffset:
+ chunk_offsets = [None if codes is None else arr.offsets_from_codes(codes)
+ for codes in lines[1]]
+ return (lines[0], chunk_offsets)
+ elif line_type_to == LineType.ChunkCombinedNan:
+ points_nan: list[cpy.PointArray | None] = []
+ for points, codes in zip(*lines):
+ if points is None:
+ points_nan.append(None)
+ else:
+ if TYPE_CHECKING:
+ assert codes is not None
+ offsets = arr.offsets_from_codes(codes)
+ points_nan.append(arr.insert_nan_at_offsets(points, offsets))
+ return (points_nan,)
+ else:
+ raise ValueError(f"Invalid LineType {line_type_to}")
+
+
+def _convert_lines_from_ChunkCombinedOffset(
+ lines: cpy.LineReturn_ChunkCombinedOffset,
+ line_type_to: LineType,
+) -> cpy.LineReturn:
+ if line_type_to in (LineType.Separate, LineType.SeparateCode):
+ separate_lines = []
+ for points, offsets in zip(*lines):
+ if points is not None:
+ if TYPE_CHECKING:
+ assert offsets is not None
+ separate_lines += arr.split_points_by_offsets(points, offsets)
+ if line_type_to == LineType.Separate:
+ return separate_lines
+ else:
+ separate_codes = [arr.codes_from_points(line) for line in separate_lines]
+ return (separate_lines, separate_codes)
+ elif line_type_to == LineType.ChunkCombinedCode:
+ chunk_codes: list[cpy.CodeArray | None] = []
+ for points, offsets in zip(*lines):
+ if points is None:
+ chunk_codes.append(None)
+ else:
+ if TYPE_CHECKING:
+ assert offsets is not None
+ chunk_codes.append(arr.codes_from_offsets_and_points(offsets, points))
+ return (lines[0], chunk_codes)
+ elif line_type_to == LineType.ChunkCombinedOffset:
+ return lines
+ elif line_type_to == LineType.ChunkCombinedNan:
+ points_nan: list[cpy.PointArray | None] = []
+ for points, offsets in zip(*lines):
+ if points is None:
+ points_nan.append(None)
+ else:
+ if TYPE_CHECKING:
+ assert offsets is not None
+ points_nan.append(arr.insert_nan_at_offsets(points, offsets))
+ return (points_nan,)
+ else:
+ raise ValueError(f"Invalid LineType {line_type_to}")
+
+
+def _convert_lines_from_ChunkCombinedNan(
+ lines: cpy.LineReturn_ChunkCombinedNan,
+ line_type_to: LineType,
+) -> cpy.LineReturn:
+ if line_type_to in (LineType.Separate, LineType.SeparateCode):
+ separate_lines = []
+ for points in lines[0]:
+ if points is not None:
+ separate_lines += arr.split_points_at_nan(points)
+ if line_type_to == LineType.Separate:
+ return separate_lines
+ else:
+ separate_codes = [arr.codes_from_points(points) for points in separate_lines]
+ return (separate_lines, separate_codes)
+ elif line_type_to == LineType.ChunkCombinedCode:
+ chunk_points: list[cpy.PointArray | None] = []
+ chunk_codes: list[cpy.CodeArray | None] = []
+ for points in lines[0]:
+ if points is None:
+ chunk_points.append(None)
+ chunk_codes.append(None)
+ else:
+ points, offsets = arr.remove_nan(points)
+ chunk_points.append(points)
+ chunk_codes.append(arr.codes_from_offsets_and_points(offsets, points))
+ return (chunk_points, chunk_codes)
+ elif line_type_to == LineType.ChunkCombinedOffset:
+ chunk_points = []
+ chunk_offsets: list[cpy.OffsetArray | None] = []
+ for points in lines[0]:
+ if points is None:
+ chunk_points.append(None)
+ chunk_offsets.append(None)
+ else:
+ points, offsets = arr.remove_nan(points)
+ chunk_points.append(points)
+ chunk_offsets.append(offsets)
+ return (chunk_points, chunk_offsets)
+ elif line_type_to == LineType.ChunkCombinedNan:
+ return lines
+ else:
+ raise ValueError(f"Invalid LineType {line_type_to}")
+
+
+def convert_lines(
+ lines: cpy.LineReturn,
+ line_type_from: LineType | str,
+ line_type_to: LineType | str,
+) -> cpy.LineReturn:
+ """Convert contour lines from one :class:`~.LineType` to another.
+
+ Args:
+ lines (sequence of arrays): Contour lines to convert, such as those returned by
+ :meth:`.ContourGenerator.lines`.
+ line_type_from (LineType or str): :class:`~.LineType` to convert from as enum or
+ string equivalent.
+ line_type_to (LineType or str): :class:`~.LineType` to convert to as enum or string
+ equivalent.
+
+ Return:
+ Converted contour lines.
+
+ When converting non-chunked line types (``LineType.Separate`` or ``LineType.SeparateCode``) to
+ chunked ones (``LineType.ChunkCombinedCode``, ``LineType.ChunkCombinedOffset`` or
+ ``LineType.ChunkCombinedNan``), all lines are placed in the first chunk. When converting in the
+ other direction, all chunk information is discarded.
+
+ .. versionadded:: 1.2.0
+ """
+ line_type_from = as_line_type(line_type_from)
+ line_type_to = as_line_type(line_type_to)
+
+ check_lines(lines, line_type_from)
+
+ if line_type_from == LineType.Separate:
+ if TYPE_CHECKING:
+ lines = cast(cpy.LineReturn_Separate, lines)
+ return _convert_lines_from_Separate(lines, line_type_to)
+ elif line_type_from == LineType.SeparateCode:
+ if TYPE_CHECKING:
+ lines = cast(cpy.LineReturn_SeparateCode, lines)
+ return _convert_lines_from_SeparateCode(lines, line_type_to)
+ elif line_type_from == LineType.ChunkCombinedCode:
+ if TYPE_CHECKING:
+ lines = cast(cpy.LineReturn_ChunkCombinedCode, lines)
+ return _convert_lines_from_ChunkCombinedCode(lines, line_type_to)
+ elif line_type_from == LineType.ChunkCombinedOffset:
+ if TYPE_CHECKING:
+ lines = cast(cpy.LineReturn_ChunkCombinedOffset, lines)
+ return _convert_lines_from_ChunkCombinedOffset(lines, line_type_to)
+ elif line_type_from == LineType.ChunkCombinedNan:
+ if TYPE_CHECKING:
+ lines = cast(cpy.LineReturn_ChunkCombinedNan, lines)
+ return _convert_lines_from_ChunkCombinedNan(lines, line_type_to)
+ else:
+ raise ValueError(f"Invalid LineType {line_type_from}")
+
+
+def convert_multi_filled(
+ multi_filled: list[cpy.FillReturn],
+ fill_type_from: FillType | str,
+ fill_type_to: FillType | str,
+) -> list[cpy.FillReturn]:
+ """Convert multiple sets of filled contours from one :class:`~.FillType` to another.
+
+ Args:
+ multi_filled (nested sequence of arrays): Filled contour polygons to convert, such as those
+ returned by :meth:`.ContourGenerator.multi_filled`.
+ fill_type_from (FillType or str): :class:`~.FillType` to convert from as enum or
+ string equivalent.
+ fill_type_to (FillType or str): :class:`~.FillType` to convert to as enum or string
+ equivalent.
+
+ Return:
+ Converted sets filled contour polygons.
+
+ When converting non-chunked fill types (``FillType.OuterCode`` or ``FillType.OuterOffset``) to
+ chunked ones, all polygons are placed in the first chunk. When converting in the other
+ direction, all chunk information is discarded. Converting a fill type that is not aware of the
+ relationship between outer boundaries and contained holes (``FillType.ChunkCombinedCode`` or
+ ``FillType.ChunkCombinedOffset``) to one that is will raise a ``ValueError``.
+
+ .. versionadded:: 1.3.0
+ """
+ fill_type_from = as_fill_type(fill_type_from)
+ fill_type_to = as_fill_type(fill_type_to)
+
+ return [convert_filled(filled, fill_type_from, fill_type_to) for filled in multi_filled]
+
+
+def convert_multi_lines(
+ multi_lines: list[cpy.LineReturn],
+ line_type_from: LineType | str,
+ line_type_to: LineType | str,
+) -> list[cpy.LineReturn]:
+ """Convert multiple sets of contour lines from one :class:`~.LineType` to another.
+
+ Args:
+ multi_lines (nested sequence of arrays): Contour lines to convert, such as those returned by
+ :meth:`.ContourGenerator.multi_lines`.
+ line_type_from (LineType or str): :class:`~.LineType` to convert from as enum or
+ string equivalent.
+ line_type_to (LineType or str): :class:`~.LineType` to convert to as enum or string
+ equivalent.
+
+ Return:
+ Converted set of contour lines.
+
+ When converting non-chunked line types (``LineType.Separate`` or ``LineType.SeparateCode``) to
+ chunked ones (``LineType.ChunkCombinedCode``, ``LineType.ChunkCombinedOffset`` or
+ ``LineType.ChunkCombinedNan``), all lines are placed in the first chunk. When converting in the
+ other direction, all chunk information is discarded.
+
+ .. versionadded:: 1.3.0
+ """
+ line_type_from = as_line_type(line_type_from)
+ line_type_to = as_line_type(line_type_to)
+
+ return [convert_lines(lines, line_type_from, line_type_to) for lines in multi_lines]
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/dechunk.py b/videollama2/lib/python3.10/site-packages/contourpy/dechunk.py
new file mode 100644
index 0000000000000000000000000000000000000000..f571b4b5ffbb4801cd687b065314b51a93a1997d
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/contourpy/dechunk.py
@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from contourpy._contourpy import FillType, LineType
+from contourpy.array import (
+ concat_codes_or_none,
+ concat_offsets_or_none,
+ concat_points_or_none,
+ concat_points_or_none_with_nan,
+)
+from contourpy.enum_util import as_fill_type, as_line_type
+from contourpy.typecheck import check_filled, check_lines
+
+if TYPE_CHECKING:
+ import contourpy._contourpy as cpy
+
+
+def dechunk_filled(filled: cpy.FillReturn, fill_type: FillType | str) -> cpy.FillReturn:
+ """Return the specified filled contours with chunked data moved into the first chunk.
+
+ Filled contours that are not chunked (``FillType.OuterCode`` and ``FillType.OuterOffset``) and
+ those that are but only contain a single chunk are returned unmodified. Individual polygons are
+ unchanged, they are not geometrically combined.
+
+ Args:
+ filled (sequence of arrays): Filled contour data, such as returned by
+ :meth:`.ContourGenerator.filled`.
+ fill_type (FillType or str): Type of :meth:`~.ContourGenerator.filled` as enum or string
+ equivalent.
+
+ Return:
+ Filled contours in a single chunk.
+
+ .. versionadded:: 1.2.0
+ """
+ fill_type = as_fill_type(fill_type)
+
+ if fill_type in (FillType.OuterCode, FillType.OuterOffset):
+ # No-op if fill_type is not chunked.
+ return filled
+
+ check_filled(filled, fill_type)
+ if len(filled[0]) < 2:
+ # No-op if just one chunk.
+ return filled
+
+ if TYPE_CHECKING:
+ filled = cast(cpy.FillReturn_Chunk, filled)
+ points = concat_points_or_none(filled[0])
+
+ if fill_type == FillType.ChunkCombinedCode:
+ if TYPE_CHECKING:
+ filled = cast(cpy.FillReturn_ChunkCombinedCode, filled)
+ if points is None:
+ ret1: cpy.FillReturn_ChunkCombinedCode = ([None], [None])
+ else:
+ ret1 = ([points], [concat_codes_or_none(filled[1])])
+ return ret1
+ elif fill_type == FillType.ChunkCombinedOffset:
+ if TYPE_CHECKING:
+ filled = cast(cpy.FillReturn_ChunkCombinedOffset, filled)
+ if points is None:
+ ret2: cpy.FillReturn_ChunkCombinedOffset = ([None], [None])
+ else:
+ ret2 = ([points], [concat_offsets_or_none(filled[1])])
+ return ret2
+ elif fill_type == FillType.ChunkCombinedCodeOffset:
+ if TYPE_CHECKING:
+ filled = cast(cpy.FillReturn_ChunkCombinedCodeOffset, filled)
+ if points is None:
+ ret3: cpy.FillReturn_ChunkCombinedCodeOffset = ([None], [None], [None])
+ else:
+ outer_offsets = concat_offsets_or_none(filled[2])
+ ret3 = ([points], [concat_codes_or_none(filled[1])], [outer_offsets])
+ return ret3
+ elif fill_type == FillType.ChunkCombinedOffsetOffset:
+ if TYPE_CHECKING:
+ filled = cast(cpy.FillReturn_ChunkCombinedOffsetOffset, filled)
+ if points is None:
+ ret4: cpy.FillReturn_ChunkCombinedOffsetOffset = ([None], [None], [None])
+ else:
+ outer_offsets = concat_offsets_or_none(filled[2])
+ ret4 = ([points], [concat_offsets_or_none(filled[1])], [outer_offsets])
+ return ret4
+ else:
+ raise ValueError(f"Invalid FillType {fill_type}")
+
+
+def dechunk_lines(lines: cpy.LineReturn, line_type: LineType | str) -> cpy.LineReturn:
+ """Return the specified contour lines with chunked data moved into the first chunk.
+
+ Contour lines that are not chunked (``LineType.Separate`` and ``LineType.SeparateCode``) and
+ those that are but only contain a single chunk are returned unmodified. Individual lines are
+ unchanged, they are not geometrically combined.
+
+ Args:
+ lines (sequence of arrays): Contour line data, such as returned by
+ :meth:`.ContourGenerator.lines`.
+ line_type (LineType or str): Type of :meth:`~.ContourGenerator.lines` as enum or string
+ equivalent.
+
+ Return:
+ Contour lines in a single chunk.
+
+ .. versionadded:: 1.2.0
+ """
+ line_type = as_line_type(line_type)
+
+ if line_type in (LineType.Separate, LineType.SeparateCode):
+ # No-op if line_type is not chunked.
+ return lines
+
+ check_lines(lines, line_type)
+ if len(lines[0]) < 2:
+ # No-op if just one chunk.
+ return lines
+
+ if TYPE_CHECKING:
+ lines = cast(cpy.LineReturn_Chunk, lines)
+
+ if line_type == LineType.ChunkCombinedCode:
+ if TYPE_CHECKING:
+ lines = cast(cpy.LineReturn_ChunkCombinedCode, lines)
+ points = concat_points_or_none(lines[0])
+ if points is None:
+ ret1: cpy.LineReturn_ChunkCombinedCode = ([None], [None])
+ else:
+ ret1 = ([points], [concat_codes_or_none(lines[1])])
+ return ret1
+ elif line_type == LineType.ChunkCombinedOffset:
+ if TYPE_CHECKING:
+ lines = cast(cpy.LineReturn_ChunkCombinedOffset, lines)
+ points = concat_points_or_none(lines[0])
+ if points is None:
+ ret2: cpy.LineReturn_ChunkCombinedOffset = ([None], [None])
+ else:
+ ret2 = ([points], [concat_offsets_or_none(lines[1])])
+ return ret2
+ elif line_type == LineType.ChunkCombinedNan:
+ if TYPE_CHECKING:
+ lines = cast(cpy.LineReturn_ChunkCombinedNan, lines)
+ points = concat_points_or_none_with_nan(lines[0])
+ ret3: cpy.LineReturn_ChunkCombinedNan = ([points],)
+ return ret3
+ else:
+ raise ValueError(f"Invalid LineType {line_type}")
+
+
+def dechunk_multi_filled(
+ multi_filled: list[cpy.FillReturn],
+ fill_type: FillType | str,
+) -> list[cpy.FillReturn]:
+ """Return multiple sets of filled contours with chunked data moved into the first chunks.
+
+ Filled contours that are not chunked (``FillType.OuterCode`` and ``FillType.OuterOffset``) and
+ those that are but only contain a single chunk are returned unmodified. Individual polygons are
+ unchanged, they are not geometrically combined.
+
+ Args:
+ multi_filled (nested sequence of arrays): Filled contour data, such as returned by
+ :meth:`.ContourGenerator.multi_filled`.
+ fill_type (FillType or str): Type of :meth:`~.ContourGenerator.filled` as enum or string
+ equivalent.
+
+ Return:
+ Multiple sets of filled contours in a single chunk.
+
+ .. versionadded:: 1.3.0
+ """
+ fill_type = as_fill_type(fill_type)
+
+ if fill_type in (FillType.OuterCode, FillType.OuterOffset):
+ # No-op if fill_type is not chunked.
+ return multi_filled
+
+ return [dechunk_filled(filled, fill_type) for filled in multi_filled]
+
+
+def dechunk_multi_lines(
+ multi_lines: list[cpy.LineReturn],
+ line_type: LineType | str,
+) -> list[cpy.LineReturn]:
+ """Return multiple sets of contour lines with all chunked data moved into the first chunks.
+
+ Contour lines that are not chunked (``LineType.Separate`` and ``LineType.SeparateCode``) and
+ those that are but only contain a single chunk are returned unmodified. Individual lines are
+ unchanged, they are not geometrically combined.
+
+ Args:
+ multi_lines (nested sequence of arrays): Contour line data, such as returned by
+ :meth:`.ContourGenerator.multi_lines`.
+ line_type (LineType or str): Type of :meth:`~.ContourGenerator.lines` as enum or string
+ equivalent.
+
+ Return:
+ Multiple sets of contour lines in a single chunk.
+
+ .. versionadded:: 1.3.0
+ """
+ line_type = as_line_type(line_type)
+
+ if line_type in (LineType.Separate, LineType.SeparateCode):
+ # No-op if line_type is not chunked.
+ return multi_lines
+
+ return [dechunk_lines(lines, line_type) for lines in multi_lines]
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/py.typed b/videollama2/lib/python3.10/site-packages/contourpy/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/__init__.cpython-310.pyc b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cf60ec329161b02c0b3d88c560ddd6a33aa4ccf7
Binary files /dev/null and b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/__init__.cpython-310.pyc differ
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/_build_config.cpython-310.pyc b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/_build_config.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b22e3f3f3e71b11a840c1433507e55efef19e61f
Binary files /dev/null and b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/_build_config.cpython-310.pyc differ
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/bokeh_renderer.cpython-310.pyc b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/bokeh_renderer.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..225d27ee432f89048ce01827869f102e195df4eb
Binary files /dev/null and b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/bokeh_renderer.cpython-310.pyc differ
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/bokeh_util.cpython-310.pyc b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/bokeh_util.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4762b3ebec8755f9bbc004a4220c79f4ecf92be8
Binary files /dev/null and b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/bokeh_util.cpython-310.pyc differ
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/data.cpython-310.pyc b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/data.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a77601d882f78d12ae8f2dca0c58591183cd36d1
Binary files /dev/null and b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/data.cpython-310.pyc differ
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/mpl_renderer.cpython-310.pyc b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/mpl_renderer.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8bc78179612eb2fdc106c9df81b22d3ca4b78f69
Binary files /dev/null and b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/mpl_renderer.cpython-310.pyc differ
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/mpl_util.cpython-310.pyc b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/mpl_util.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..413e10c28784f99b3c0286dd02a26f12841291cb
Binary files /dev/null and b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/mpl_util.cpython-310.pyc differ
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/renderer.cpython-310.pyc b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/renderer.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b9db381d5697d33b81fb595247fe7124da938725
Binary files /dev/null and b/videollama2/lib/python3.10/site-packages/contourpy/util/__pycache__/renderer.cpython-310.pyc differ
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/bokeh_renderer.py b/videollama2/lib/python3.10/site-packages/contourpy/util/bokeh_renderer.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8a10e8ad3581240456450f0c5ffa31c1d1bea9c
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/contourpy/util/bokeh_renderer.py
@@ -0,0 +1,335 @@
+from __future__ import annotations
+
+import io
+from typing import TYPE_CHECKING, Any
+
+from bokeh.io import export_png, export_svg, show
+from bokeh.io.export import get_screenshot_as_png
+from bokeh.layouts import gridplot
+from bokeh.models.annotations.labels import Label
+from bokeh.palettes import Category10
+from bokeh.plotting import figure
+import numpy as np
+
+from contourpy.enum_util import as_fill_type, as_line_type
+from contourpy.util.bokeh_util import filled_to_bokeh, lines_to_bokeh
+from contourpy.util.renderer import Renderer
+
+if TYPE_CHECKING:
+ from bokeh.models import GridPlot
+ from bokeh.palettes import Palette
+ from numpy.typing import ArrayLike
+ from selenium.webdriver.remote.webdriver import WebDriver
+
+ from contourpy import FillType, LineType
+ from contourpy._contourpy import FillReturn, LineReturn
+
+
+class BokehRenderer(Renderer):
+ """Utility renderer using Bokeh to render a grid of plots over the same (x, y) range.
+
+ Args:
+ nrows (int, optional): Number of rows of plots, default ``1``.
+ ncols (int, optional): Number of columns of plots, default ``1``.
+ figsize (tuple(float, float), optional): Figure size in inches (assuming 100 dpi), default
+ ``(9, 9)``.
+ show_frame (bool, optional): Whether to show frame and axes ticks, default ``True``.
+ want_svg (bool, optional): Whether output is required in SVG format or not, default
+ ``False``.
+
+ Warning:
+ :class:`~.BokehRenderer`, unlike :class:`~.MplRenderer`, needs to be told in advance if
+ output to SVG format will be required later, otherwise it will assume PNG output.
+ """
+ _figures: list[figure]
+ _layout: GridPlot
+ _palette: Palette
+ _want_svg: bool
+
+ def __init__(
+ self,
+ nrows: int = 1,
+ ncols: int = 1,
+ figsize: tuple[float, float] = (9, 9),
+ show_frame: bool = True,
+ want_svg: bool = False,
+ ) -> None:
+ self._want_svg = want_svg
+ self._palette = Category10[10]
+
+ total_size = 100*np.asarray(figsize, dtype=int) # Assuming 100 dpi.
+
+ nfigures = nrows*ncols
+ self._figures = []
+ backend = "svg" if self._want_svg else "canvas"
+ for _ in range(nfigures):
+ fig = figure(output_backend=backend)
+ fig.xgrid.visible = False
+ fig.ygrid.visible = False
+ self._figures.append(fig)
+ if not show_frame:
+ fig.outline_line_color = None # type: ignore[assignment]
+ fig.axis.visible = False
+
+ self._layout = gridplot(
+ self._figures, ncols=ncols, toolbar_location=None, # type: ignore[arg-type]
+ width=total_size[0] // ncols, height=total_size[1] // nrows)
+
+ def _convert_color(self, color: str) -> str:
+ if isinstance(color, str) and color[0] == "C":
+ index = int(color[1:])
+ color = self._palette[index]
+ return color
+
+ def _get_figure(self, ax: figure | int) -> figure:
+ if isinstance(ax, int):
+ ax = self._figures[ax]
+ return ax
+
+ def filled(
+ self,
+ filled: FillReturn,
+ fill_type: FillType | str,
+ ax: figure | int = 0,
+ color: str = "C0",
+ alpha: float = 0.7,
+ ) -> None:
+ """Plot filled contours on a single plot.
+
+ Args:
+ filled (sequence of arrays): Filled contour data as returned by
+ :meth:`~.ContourGenerator.filled`.
+ fill_type (FillType or str): Type of :meth:`~.ContourGenerator.filled` data as returned
+ by :attr:`~.ContourGenerator.fill_type`, or a string equivalent.
+ ax (int or Bokeh Figure, optional): Which plot to use, default ``0``.
+ color (str, optional): Color to plot with. May be a string color or the letter ``"C"``
+ followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the
+ ``Category10`` palette. Default ``"C0"``.
+ alpha (float, optional): Opacity to plot with, default ``0.7``.
+ """
+ fill_type = as_fill_type(fill_type)
+ fig = self._get_figure(ax)
+ color = self._convert_color(color)
+ xs, ys = filled_to_bokeh(filled, fill_type)
+ if len(xs) > 0:
+ fig.multi_polygons(xs=[xs], ys=[ys], color=color, fill_alpha=alpha, line_width=0)
+
+ def grid(
+ self,
+ x: ArrayLike,
+ y: ArrayLike,
+ ax: figure | int = 0,
+ color: str = "black",
+ alpha: float = 0.1,
+ point_color: str | None = None,
+ quad_as_tri_alpha: float = 0,
+ ) -> None:
+ """Plot quad grid lines on a single plot.
+
+ Args:
+ x (array-like of shape (ny, nx) or (nx,)): The x-coordinates of the grid points.
+ y (array-like of shape (ny, nx) or (ny,)): The y-coordinates of the grid points.
+ ax (int or Bokeh Figure, optional): Which plot to use, default ``0``.
+ color (str, optional): Color to plot grid lines, default ``"black"``.
+ alpha (float, optional): Opacity to plot lines with, default ``0.1``.
+ point_color (str, optional): Color to plot grid points or ``None`` if grid points
+ should not be plotted, default ``None``.
+ quad_as_tri_alpha (float, optional): Opacity to plot ``quad_as_tri`` grid, default
+ ``0``.
+
+ Colors may be a string color or the letter ``"C"`` followed by an integer in the range
+ ``"C0"`` to ``"C9"`` to use a color from the ``Category10`` palette.
+
+ Warning:
+ ``quad_as_tri_alpha > 0`` plots all quads as though they are unmasked.
+ """
+ fig = self._get_figure(ax)
+ x, y = self._grid_as_2d(x, y)
+ xs = list(x) + list(x.T)
+ ys = list(y) + list(y.T)
+ kwargs = {"line_color": color, "alpha": alpha}
+ fig.multi_line(xs, ys, **kwargs)
+ if quad_as_tri_alpha > 0:
+ # Assumes no quad mask.
+ xmid = (0.25*(x[:-1, :-1] + x[1:, :-1] + x[:-1, 1:] + x[1:, 1:])).ravel()
+ ymid = (0.25*(y[:-1, :-1] + y[1:, :-1] + y[:-1, 1:] + y[1:, 1:])).ravel()
+ fig.multi_line(
+ list(np.stack((x[:-1, :-1].ravel(), xmid, x[1:, 1:].ravel()), axis=1)),
+ list(np.stack((y[:-1, :-1].ravel(), ymid, y[1:, 1:].ravel()), axis=1)),
+ **kwargs)
+ fig.multi_line(
+ list(np.stack((x[:-1, 1:].ravel(), xmid, x[1:, :-1].ravel()), axis=1)),
+ list(np.stack((y[:-1, 1:].ravel(), ymid, y[1:, :-1].ravel()), axis=1)),
+ **kwargs)
+ if point_color is not None:
+ fig.circle(
+ x=x.ravel(), y=y.ravel(), fill_color=color, line_color=None, alpha=alpha, size=8)
+
+ def lines(
+ self,
+ lines: LineReturn,
+ line_type: LineType | str,
+ ax: figure | int = 0,
+ color: str = "C0",
+ alpha: float = 1.0,
+ linewidth: float = 1,
+ ) -> None:
+ """Plot contour lines on a single plot.
+
+ Args:
+ lines (sequence of arrays): Contour line data as returned by
+ :meth:`~.ContourGenerator.lines`.
+ line_type (LineType or str): Type of :meth:`~.ContourGenerator.lines` data as returned
+ by :attr:`~.ContourGenerator.line_type`, or a string equivalent.
+ ax (int or Bokeh Figure, optional): Which plot to use, default ``0``.
+ color (str, optional): Color to plot lines. May be a string color or the letter ``"C"``
+ followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the
+ ``Category10`` palette. Default ``"C0"``.
+ alpha (float, optional): Opacity to plot lines with, default ``1.0``.
+ linewidth (float, optional): Width of lines, default ``1``.
+
+ Note:
+ Assumes all lines are open line strips not closed line loops.
+ """
+ line_type = as_line_type(line_type)
+ fig = self._get_figure(ax)
+ color = self._convert_color(color)
+ xs, ys = lines_to_bokeh(lines, line_type)
+ if xs is not None:
+ fig.line(xs, ys, line_color=color, line_alpha=alpha, line_width=linewidth)
+
+ def mask(
+ self,
+ x: ArrayLike,
+ y: ArrayLike,
+ z: ArrayLike | np.ma.MaskedArray[Any, Any],
+ ax: figure | int = 0,
+ color: str = "black",
+ ) -> None:
+ """Plot masked out grid points as circles on a single plot.
+
+ Args:
+ x (array-like of shape (ny, nx) or (nx,)): The x-coordinates of the grid points.
+ y (array-like of shape (ny, nx) or (ny,)): The y-coordinates of the grid points.
+ z (masked array of shape (ny, nx): z-values.
+ ax (int or Bokeh Figure, optional): Which plot to use, default ``0``.
+ color (str, optional): Circle color, default ``"black"``.
+ """
+ mask = np.ma.getmask(z) # type: ignore[no-untyped-call]
+ if mask is np.ma.nomask:
+ return
+ fig = self._get_figure(ax)
+ color = self._convert_color(color)
+ x, y = self._grid_as_2d(x, y)
+ fig.circle(x[mask], y[mask], fill_color=color, size=10)
+
+ def save(
+ self,
+ filename: str,
+ transparent: bool = False,
+ *,
+ webdriver: WebDriver | None = None,
+ ) -> None:
+ """Save plots to SVG or PNG file.
+
+ Args:
+ filename (str): Filename to save to.
+ transparent (bool, optional): Whether background should be transparent, default
+ ``False``.
+ webdriver (WebDriver, optional): Selenium WebDriver instance to use to create the image.
+
+ .. versionadded:: 1.1.1
+
+ Warning:
+ To output to SVG file, ``want_svg=True`` must have been passed to the constructor.
+ """
+ if transparent:
+ for fig in self._figures:
+ fig.background_fill_color = None # type: ignore[assignment]
+ fig.border_fill_color = None # type: ignore[assignment]
+
+ if self._want_svg:
+ export_svg(self._layout, filename=filename, webdriver=webdriver)
+ else:
+ export_png(self._layout, filename=filename, webdriver=webdriver)
+
+ def save_to_buffer(self, *, webdriver: WebDriver | None = None) -> io.BytesIO:
+ """Save plots to an ``io.BytesIO`` buffer.
+
+ Args:
+ webdriver (WebDriver, optional): Selenium WebDriver instance to use to create the image.
+
+ .. versionadded:: 1.1.1
+
+ Return:
+ BytesIO: PNG image buffer.
+ """
+ image = get_screenshot_as_png(self._layout, driver=webdriver)
+ buffer = io.BytesIO()
+ image.save(buffer, "png")
+ return buffer
+
+ def show(self) -> None:
+ """Show plots in web browser, in usual Bokeh manner.
+ """
+ show(self._layout)
+
+ def title(self, title: str, ax: figure | int = 0, color: str | None = None) -> None:
+ """Set the title of a single plot.
+
+ Args:
+ title (str): Title text.
+ ax (int or Bokeh Figure, optional): Which plot to set the title of, default ``0``.
+ color (str, optional): Color to set title. May be a string color or the letter ``"C"``
+ followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the
+ ``Category10`` palette. Default ``None`` which is ``black``.
+ """
+ fig = self._get_figure(ax)
+ fig.title = title # type: ignore[assignment]
+ fig.title.align = "center" # type: ignore[attr-defined]
+ if color is not None:
+ fig.title.text_color = self._convert_color(color) # type: ignore[attr-defined]
+
+ def z_values(
+ self,
+ x: ArrayLike,
+ y: ArrayLike,
+ z: ArrayLike,
+ ax: figure | int = 0,
+ color: str = "green",
+ fmt: str = ".1f",
+ quad_as_tri: bool = False,
+ ) -> None:
+ """Show ``z`` values on a single plot.
+
+ Args:
+ x (array-like of shape (ny, nx) or (nx,)): The x-coordinates of the grid points.
+ y (array-like of shape (ny, nx) or (ny,)): The y-coordinates of the grid points.
+ z (array-like of shape (ny, nx): z-values.
+ ax (int or Bokeh Figure, optional): Which plot to use, default ``0``.
+ color (str, optional): Color of added text. May be a string color or the letter ``"C"``
+ followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the
+ ``Category10`` palette. Default ``"green"``.
+ fmt (str, optional): Format to display z-values, default ``".1f"``.
+ quad_as_tri (bool, optional): Whether to show z-values at the ``quad_as_tri`` centres
+ of quads.
+
+ Warning:
+ ``quad_as_tri=True`` shows z-values for all quads, even if masked.
+ """
+ fig = self._get_figure(ax)
+ color = self._convert_color(color)
+ x, y = self._grid_as_2d(x, y)
+ z = np.asarray(z)
+ ny, nx = z.shape
+ kwargs = {"text_color": color, "text_align": "center", "text_baseline": "middle"}
+ for j in range(ny):
+ for i in range(nx):
+ fig.add_layout(Label(x=x[j, i], y=y[j, i], text=f"{z[j, i]:{fmt}}", **kwargs))
+ if quad_as_tri:
+ for j in range(ny-1):
+ for i in range(nx-1):
+ xx = np.mean(x[j:j+2, i:i+2])
+ yy = np.mean(y[j:j+2, i:i+2])
+ zz = np.mean(z[j:j+2, i:i+2])
+ fig.add_layout(Label(x=xx, y=yy, text=f"{zz:{fmt}}", **kwargs))
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/bokeh_util.py b/videollama2/lib/python3.10/site-packages/contourpy/util/bokeh_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..e75eb844536b26dfe90de08bb65328e5d2e5ba1c
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/contourpy/util/bokeh_util.py
@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from contourpy import FillType, LineType
+from contourpy.array import offsets_from_codes
+from contourpy.convert import convert_lines
+from contourpy.dechunk import dechunk_lines
+
+if TYPE_CHECKING:
+ from contourpy._contourpy import (
+ CoordinateArray,
+ FillReturn,
+ LineReturn,
+ LineReturn_ChunkCombinedNan,
+ )
+
+
+def filled_to_bokeh(
+ filled: FillReturn,
+ fill_type: FillType,
+) -> tuple[list[list[CoordinateArray]], list[list[CoordinateArray]]]:
+ xs: list[list[CoordinateArray]] = []
+ ys: list[list[CoordinateArray]] = []
+ if fill_type in (FillType.OuterOffset, FillType.ChunkCombinedOffset,
+ FillType.OuterCode, FillType.ChunkCombinedCode):
+ have_codes = fill_type in (FillType.OuterCode, FillType.ChunkCombinedCode)
+
+ for points, offsets in zip(*filled):
+ if points is None:
+ continue
+ if have_codes:
+ offsets = offsets_from_codes(offsets)
+ xs.append([]) # New outer with zero or more holes.
+ ys.append([])
+ for i in range(len(offsets)-1):
+ xys = points[offsets[i]:offsets[i+1]]
+ xs[-1].append(xys[:, 0])
+ ys[-1].append(xys[:, 1])
+ elif fill_type in (FillType.ChunkCombinedCodeOffset, FillType.ChunkCombinedOffsetOffset):
+ for points, codes_or_offsets, outer_offsets in zip(*filled):
+ if points is None:
+ continue
+ for j in range(len(outer_offsets)-1):
+ if fill_type == FillType.ChunkCombinedCodeOffset:
+ codes = codes_or_offsets[outer_offsets[j]:outer_offsets[j+1]]
+ offsets = offsets_from_codes(codes) + outer_offsets[j]
+ else:
+ offsets = codes_or_offsets[outer_offsets[j]:outer_offsets[j+1]+1]
+ xs.append([]) # New outer with zero or more holes.
+ ys.append([])
+ for k in range(len(offsets)-1):
+ xys = points[offsets[k]:offsets[k+1]]
+ xs[-1].append(xys[:, 0])
+ ys[-1].append(xys[:, 1])
+ else:
+ raise RuntimeError(f"Conversion of FillType {fill_type} to Bokeh is not implemented")
+
+ return xs, ys
+
+
+def lines_to_bokeh(
+ lines: LineReturn,
+ line_type: LineType,
+) -> tuple[CoordinateArray | None, CoordinateArray | None]:
+ lines = convert_lines(lines, line_type, LineType.ChunkCombinedNan)
+ lines = dechunk_lines(lines, LineType.ChunkCombinedNan)
+ if TYPE_CHECKING:
+ lines = cast(LineReturn_ChunkCombinedNan, lines)
+ points = lines[0][0]
+ if points is None:
+ return None, None
+ else:
+ return points[:, 0], points[:, 1]
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/mpl_renderer.py b/videollama2/lib/python3.10/site-packages/contourpy/util/mpl_renderer.py
new file mode 100644
index 0000000000000000000000000000000000000000..e078ca28f7ae4673c629588766d9b36b708baf6c
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/contourpy/util/mpl_renderer.py
@@ -0,0 +1,534 @@
+from __future__ import annotations
+
+import io
+from typing import TYPE_CHECKING, Any, cast
+
+import matplotlib.collections as mcollections
+import matplotlib.pyplot as plt
+import numpy as np
+
+from contourpy import FillType, LineType
+from contourpy.convert import convert_filled, convert_lines
+from contourpy.enum_util import as_fill_type, as_line_type
+from contourpy.util.mpl_util import filled_to_mpl_paths, lines_to_mpl_paths
+from contourpy.util.renderer import Renderer
+
+if TYPE_CHECKING:
+ from collections.abc import Sequence
+
+ from matplotlib.axes import Axes
+ from matplotlib.figure import Figure
+ from numpy.typing import ArrayLike
+
+ import contourpy._contourpy as cpy
+
+
+class MplRenderer(Renderer):
+ """Utility renderer using Matplotlib to render a grid of plots over the same (x, y) range.
+
+ Args:
+ nrows (int, optional): Number of rows of plots, default ``1``.
+ ncols (int, optional): Number of columns of plots, default ``1``.
+ figsize (tuple(float, float), optional): Figure size in inches, default ``(9, 9)``.
+ show_frame (bool, optional): Whether to show frame and axes ticks, default ``True``.
+ backend (str, optional): Matplotlib backend to use or ``None`` for default backend.
+ Default ``None``.
+ gridspec_kw (dict, optional): Gridspec keyword arguments to pass to ``plt.subplots``,
+ default None.
+ """
+ _axes: Sequence[Axes]
+ _fig: Figure
+ _want_tight: bool
+
+ def __init__(
+ self,
+ nrows: int = 1,
+ ncols: int = 1,
+ figsize: tuple[float, float] = (9, 9),
+ show_frame: bool = True,
+ backend: str | None = None,
+ gridspec_kw: dict[str, Any] | None = None,
+ ) -> None:
+ if backend is not None:
+ import matplotlib as mpl
+ mpl.use(backend)
+
+ kwargs: dict[str, Any] = {"figsize": figsize, "squeeze": False,
+ "sharex": True, "sharey": True}
+ if gridspec_kw is not None:
+ kwargs["gridspec_kw"] = gridspec_kw
+ else:
+ kwargs["subplot_kw"] = {"aspect": "equal"}
+
+ self._fig, axes = plt.subplots(nrows, ncols, **kwargs)
+ self._axes = axes.flatten()
+ if not show_frame:
+ for ax in self._axes:
+ ax.axis("off")
+
+ self._want_tight = True
+
+ def __del__(self) -> None:
+ if hasattr(self, "_fig"):
+ plt.close(self._fig)
+
+ def _autoscale(self) -> None:
+ # Using axes._need_autoscale attribute if need to autoscale before rendering after adding
+ # lines/filled. Only want to autoscale once per axes regardless of how many lines/filled
+ # added.
+ for ax in self._axes:
+ if getattr(ax, "_need_autoscale", False):
+ ax.autoscale_view(tight=True)
+ ax._need_autoscale = False # type: ignore[attr-defined]
+ if self._want_tight and len(self._axes) > 1:
+ self._fig.tight_layout()
+
+ def _get_ax(self, ax: Axes | int) -> Axes:
+ if isinstance(ax, int):
+ ax = self._axes[ax]
+ return ax
+
+ def filled(
+ self,
+ filled: cpy.FillReturn,
+ fill_type: FillType | str,
+ ax: Axes | int = 0,
+ color: str = "C0",
+ alpha: float = 0.7,
+ ) -> None:
+ """Plot filled contours on a single Axes.
+
+ Args:
+ filled (sequence of arrays): Filled contour data as returned by
+ :meth:`~.ContourGenerator.filled`.
+ fill_type (FillType or str): Type of :meth:`~.ContourGenerator.filled` data as returned
+ by :attr:`~.ContourGenerator.fill_type`, or string equivalent
+ ax (int or Maplotlib Axes, optional): Which axes to plot on, default ``0``.
+ color (str, optional): Color to plot with. May be a string color or the letter ``"C"``
+ followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the
+ ``tab10`` colormap. Default ``"C0"``.
+ alpha (float, optional): Opacity to plot with, default ``0.7``.
+ """
+ fill_type = as_fill_type(fill_type)
+ ax = self._get_ax(ax)
+ paths = filled_to_mpl_paths(filled, fill_type)
+ collection = mcollections.PathCollection(
+ paths, facecolors=color, edgecolors="none", lw=0, alpha=alpha)
+ ax.add_collection(collection)
+ ax._need_autoscale = True # type: ignore[attr-defined]
+
+ def grid(
+ self,
+ x: ArrayLike,
+ y: ArrayLike,
+ ax: Axes | int = 0,
+ color: str = "black",
+ alpha: float = 0.1,
+ point_color: str | None = None,
+ quad_as_tri_alpha: float = 0,
+ ) -> None:
+ """Plot quad grid lines on a single Axes.
+
+ Args:
+ x (array-like of shape (ny, nx) or (nx,)): The x-coordinates of the grid points.
+ y (array-like of shape (ny, nx) or (ny,)): The y-coordinates of the grid points.
+ ax (int or Matplotlib Axes, optional): Which Axes to plot on, default ``0``.
+ color (str, optional): Color to plot grid lines, default ``"black"``.
+ alpha (float, optional): Opacity to plot lines with, default ``0.1``.
+ point_color (str, optional): Color to plot grid points or ``None`` if grid points
+ should not be plotted, default ``None``.
+ quad_as_tri_alpha (float, optional): Opacity to plot ``quad_as_tri`` grid, default 0.
+
+ Colors may be a string color or the letter ``"C"`` followed by an integer in the range
+ ``"C0"`` to ``"C9"`` to use a color from the ``tab10`` colormap.
+
+ Warning:
+ ``quad_as_tri_alpha > 0`` plots all quads as though they are unmasked.
+ """
+ ax = self._get_ax(ax)
+ x, y = self._grid_as_2d(x, y)
+ kwargs: dict[str, Any] = {"color": color, "alpha": alpha}
+ ax.plot(x, y, x.T, y.T, **kwargs)
+ if quad_as_tri_alpha > 0:
+ # Assumes no quad mask.
+ xmid = 0.25*(x[:-1, :-1] + x[1:, :-1] + x[:-1, 1:] + x[1:, 1:])
+ ymid = 0.25*(y[:-1, :-1] + y[1:, :-1] + y[:-1, 1:] + y[1:, 1:])
+ kwargs["alpha"] = quad_as_tri_alpha
+ ax.plot(
+ np.stack((x[:-1, :-1], xmid, x[1:, 1:])).reshape((3, -1)),
+ np.stack((y[:-1, :-1], ymid, y[1:, 1:])).reshape((3, -1)),
+ np.stack((x[1:, :-1], xmid, x[:-1, 1:])).reshape((3, -1)),
+ np.stack((y[1:, :-1], ymid, y[:-1, 1:])).reshape((3, -1)),
+ **kwargs)
+ if point_color is not None:
+ ax.plot(x, y, color=point_color, alpha=alpha, marker="o", lw=0)
+ ax._need_autoscale = True # type: ignore[attr-defined]
+
+ def lines(
+ self,
+ lines: cpy.LineReturn,
+ line_type: LineType | str,
+ ax: Axes | int = 0,
+ color: str = "C0",
+ alpha: float = 1.0,
+ linewidth: float = 1,
+ ) -> None:
+ """Plot contour lines on a single Axes.
+
+ Args:
+ lines (sequence of arrays): Contour line data as returned by
+ :meth:`~.ContourGenerator.lines`.
+ line_type (LineType or str): Type of :meth:`~.ContourGenerator.lines` data as returned
+ by :attr:`~.ContourGenerator.line_type`, or string equivalent.
+ ax (int or Matplotlib Axes, optional): Which Axes to plot on, default ``0``.
+ color (str, optional): Color to plot lines. May be a string color or the letter ``"C"``
+ followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the
+ ``tab10`` colormap. Default ``"C0"``.
+ alpha (float, optional): Opacity to plot lines with, default ``1.0``.
+ linewidth (float, optional): Width of lines, default ``1``.
+ """
+ line_type = as_line_type(line_type)
+ ax = self._get_ax(ax)
+ paths = lines_to_mpl_paths(lines, line_type)
+ collection = mcollections.PathCollection(
+ paths, facecolors="none", edgecolors=color, lw=linewidth, alpha=alpha)
+ ax.add_collection(collection)
+ ax._need_autoscale = True # type: ignore[attr-defined]
+
+ def mask(
+ self,
+ x: ArrayLike,
+ y: ArrayLike,
+ z: ArrayLike | np.ma.MaskedArray[Any, Any],
+ ax: Axes | int = 0,
+ color: str = "black",
+ ) -> None:
+ """Plot masked out grid points as circles on a single Axes.
+
+ Args:
+ x (array-like of shape (ny, nx) or (nx,)): The x-coordinates of the grid points.
+ y (array-like of shape (ny, nx) or (ny,)): The y-coordinates of the grid points.
+ z (masked array of shape (ny, nx): z-values.
+ ax (int or Matplotlib Axes, optional): Which Axes to plot on, default ``0``.
+ color (str, optional): Circle color, default ``"black"``.
+ """
+ mask = np.ma.getmask(z) # type: ignore[no-untyped-call]
+ if mask is np.ma.nomask:
+ return
+ ax = self._get_ax(ax)
+ x, y = self._grid_as_2d(x, y)
+ ax.plot(x[mask], y[mask], "o", c=color)
+
+ def save(self, filename: str, transparent: bool = False) -> None:
+ """Save plots to SVG or PNG file.
+
+ Args:
+ filename (str): Filename to save to.
+ transparent (bool, optional): Whether background should be transparent, default
+ ``False``.
+ """
+ self._autoscale()
+ self._fig.savefig(filename, transparent=transparent)
+
+ def save_to_buffer(self) -> io.BytesIO:
+ """Save plots to an ``io.BytesIO`` buffer.
+
+ Return:
+ BytesIO: PNG image buffer.
+ """
+ self._autoscale()
+ buf = io.BytesIO()
+ self._fig.savefig(buf, format="png")
+ buf.seek(0)
+ return buf
+
+ def show(self) -> None:
+ """Show plots in an interactive window, in the usual Matplotlib manner.
+ """
+ self._autoscale()
+ plt.show()
+
+ def title(self, title: str, ax: Axes | int = 0, color: str | None = None) -> None:
+ """Set the title of a single Axes.
+
+ Args:
+ title (str): Title text.
+ ax (int or Matplotlib Axes, optional): Which Axes to set the title of, default ``0``.
+ color (str, optional): Color to set title. May be a string color or the letter ``"C"``
+ followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the
+ ``tab10`` colormap. Default is ``None`` which uses Matplotlib's default title color
+ that depends on the stylesheet in use.
+ """
+ if color:
+ self._get_ax(ax).set_title(title, color=color)
+ else:
+ self._get_ax(ax).set_title(title)
+
+ def z_values(
+ self,
+ x: ArrayLike,
+ y: ArrayLike,
+ z: ArrayLike,
+ ax: Axes | int = 0,
+ color: str = "green",
+ fmt: str = ".1f",
+ quad_as_tri: bool = False,
+ ) -> None:
+ """Show ``z`` values on a single Axes.
+
+ Args:
+ x (array-like of shape (ny, nx) or (nx,)): The x-coordinates of the grid points.
+ y (array-like of shape (ny, nx) or (ny,)): The y-coordinates of the grid points.
+ z (array-like of shape (ny, nx): z-values.
+ ax (int or Matplotlib Axes, optional): Which Axes to plot on, default ``0``.
+ color (str, optional): Color of added text. May be a string color or the letter ``"C"``
+ followed by an integer in the range ``"C0"`` to ``"C9"`` to use a color from the
+ ``tab10`` colormap. Default ``"green"``.
+ fmt (str, optional): Format to display z-values, default ``".1f"``.
+ quad_as_tri (bool, optional): Whether to show z-values at the ``quad_as_tri`` centers
+ of quads.
+
+ Warning:
+ ``quad_as_tri=True`` shows z-values for all quads, even if masked.
+ """
+ ax = self._get_ax(ax)
+ x, y = self._grid_as_2d(x, y)
+ z = np.asarray(z)
+ ny, nx = z.shape
+ for j in range(ny):
+ for i in range(nx):
+ ax.text(x[j, i], y[j, i], f"{z[j, i]:{fmt}}", ha="center", va="center",
+ color=color, clip_on=True)
+ if quad_as_tri:
+ for j in range(ny-1):
+ for i in range(nx-1):
+ xx = np.mean(x[j:j+2, i:i+2])
+ yy = np.mean(y[j:j+2, i:i+2])
+ zz = np.mean(z[j:j+2, i:i+2])
+ ax.text(xx, yy, f"{zz:{fmt}}", ha="center", va="center", color=color,
+ clip_on=True)
+
+
+class MplTestRenderer(MplRenderer):
+ """Test renderer implemented using Matplotlib.
+
+ No whitespace around plots and no spines/ticks displayed.
+ Uses Agg backend, so can only save to file/buffer, cannot call ``show()``.
+ """
+ def __init__(
+ self,
+ nrows: int = 1,
+ ncols: int = 1,
+ figsize: tuple[float, float] = (9, 9),
+ ) -> None:
+ gridspec = {
+ "left": 0.01,
+ "right": 0.99,
+ "top": 0.99,
+ "bottom": 0.01,
+ "wspace": 0.01,
+ "hspace": 0.01,
+ }
+ super().__init__(
+ nrows, ncols, figsize, show_frame=True, backend="Agg", gridspec_kw=gridspec,
+ )
+
+ for ax in self._axes:
+ ax.set_xmargin(0.0)
+ ax.set_ymargin(0.0)
+ ax.set_xticks([])
+ ax.set_yticks([])
+
+ self._want_tight = False
+
+
+class MplDebugRenderer(MplRenderer):
+ """Debug renderer implemented using Matplotlib.
+
+ Extends ``MplRenderer`` to add extra information to help in debugging such as markers, arrows,
+ text, etc.
+ """
+ def __init__(
+ self,
+ nrows: int = 1,
+ ncols: int = 1,
+ figsize: tuple[float, float] = (9, 9),
+ show_frame: bool = True,
+ ) -> None:
+ super().__init__(nrows, ncols, figsize, show_frame)
+
+ def _arrow(
+ self,
+ ax: Axes,
+ line_start: cpy.CoordinateArray,
+ line_end: cpy.CoordinateArray,
+ color: str,
+ alpha: float,
+ arrow_size: float,
+ ) -> None:
+ mid = 0.5*(line_start + line_end)
+ along = line_end - line_start
+ along /= np.sqrt(np.dot(along, along)) # Unit vector.
+ right = np.asarray((along[1], -along[0]))
+ arrow = np.stack((
+ mid - (along*0.5 - right)*arrow_size,
+ mid + along*0.5*arrow_size,
+ mid - (along*0.5 + right)*arrow_size,
+ ))
+ ax.plot(arrow[:, 0], arrow[:, 1], "-", c=color, alpha=alpha)
+
+ def filled(
+ self,
+ filled: cpy.FillReturn,
+ fill_type: FillType | str,
+ ax: Axes | int = 0,
+ color: str = "C1",
+ alpha: float = 0.7,
+ line_color: str = "C0",
+ line_alpha: float = 0.7,
+ point_color: str = "C0",
+ start_point_color: str = "red",
+ arrow_size: float = 0.1,
+ ) -> None:
+ fill_type = as_fill_type(fill_type)
+ super().filled(filled, fill_type, ax, color, alpha)
+
+ if line_color is None and point_color is None:
+ return
+
+ ax = self._get_ax(ax)
+ filled = convert_filled(filled, fill_type, FillType.ChunkCombinedOffset)
+
+ # Lines.
+ if line_color is not None:
+ for points, offsets in zip(*filled):
+ if points is None:
+ continue
+ for start, end in zip(offsets[:-1], offsets[1:]):
+ xys = points[start:end]
+ ax.plot(xys[:, 0], xys[:, 1], c=line_color, alpha=line_alpha)
+
+ if arrow_size > 0.0:
+ n = len(xys)
+ for i in range(n-1):
+ self._arrow(ax, xys[i], xys[i+1], line_color, line_alpha, arrow_size)
+
+ # Points.
+ if point_color is not None:
+ for points, offsets in zip(*filled):
+ if points is None:
+ continue
+ mask = np.ones(offsets[-1], dtype=bool)
+ mask[offsets[1:]-1] = False # Exclude end points.
+ if start_point_color is not None:
+ start_indices = offsets[:-1]
+ mask[start_indices] = False # Exclude start points.
+ ax.plot(
+ points[:, 0][mask], points[:, 1][mask], "o", c=point_color, alpha=line_alpha)
+
+ if start_point_color is not None:
+ ax.plot(points[:, 0][start_indices], points[:, 1][start_indices], "o",
+ c=start_point_color, alpha=line_alpha)
+
+ def lines(
+ self,
+ lines: cpy.LineReturn,
+ line_type: LineType | str,
+ ax: Axes | int = 0,
+ color: str = "C0",
+ alpha: float = 1.0,
+ linewidth: float = 1,
+ point_color: str = "C0",
+ start_point_color: str = "red",
+ arrow_size: float = 0.1,
+ ) -> None:
+ line_type = as_line_type(line_type)
+ super().lines(lines, line_type, ax, color, alpha, linewidth)
+
+ if arrow_size == 0.0 and point_color is None:
+ return
+
+ ax = self._get_ax(ax)
+ separate_lines = convert_lines(lines, line_type, LineType.Separate)
+ if TYPE_CHECKING:
+ separate_lines = cast(cpy.LineReturn_Separate, separate_lines)
+
+ if arrow_size > 0.0:
+ for line in separate_lines:
+ for i in range(len(line)-1):
+ self._arrow(ax, line[i], line[i+1], color, alpha, arrow_size)
+
+ if point_color is not None:
+ for line in separate_lines:
+ start_index = 0
+ end_index = len(line)
+ if start_point_color is not None:
+ ax.plot(line[0, 0], line[0, 1], "o", c=start_point_color, alpha=alpha)
+ start_index = 1
+ if line[0][0] == line[-1][0] and line[0][1] == line[-1][1]:
+ end_index -= 1
+ ax.plot(line[start_index:end_index, 0], line[start_index:end_index, 1], "o",
+ c=color, alpha=alpha)
+
+ def point_numbers(
+ self,
+ x: ArrayLike,
+ y: ArrayLike,
+ z: ArrayLike,
+ ax: Axes | int = 0,
+ color: str = "red",
+ ) -> None:
+ ax = self._get_ax(ax)
+ x, y = self._grid_as_2d(x, y)
+ z = np.asarray(z)
+ ny, nx = z.shape
+ for j in range(ny):
+ for i in range(nx):
+ quad = i + j*nx
+ ax.text(x[j, i], y[j, i], str(quad), ha="right", va="top", color=color,
+ clip_on=True)
+
+ def quad_numbers(
+ self,
+ x: ArrayLike,
+ y: ArrayLike,
+ z: ArrayLike,
+ ax: Axes | int = 0,
+ color: str = "blue",
+ ) -> None:
+ ax = self._get_ax(ax)
+ x, y = self._grid_as_2d(x, y)
+ z = np.asarray(z)
+ ny, nx = z.shape
+ for j in range(1, ny):
+ for i in range(1, nx):
+ quad = i + j*nx
+ xmid = x[j-1:j+1, i-1:i+1].mean()
+ ymid = y[j-1:j+1, i-1:i+1].mean()
+ ax.text(xmid, ymid, str(quad), ha="center", va="center", color=color, clip_on=True)
+
+ def z_levels(
+ self,
+ x: ArrayLike,
+ y: ArrayLike,
+ z: ArrayLike,
+ lower_level: float,
+ upper_level: float | None = None,
+ ax: Axes | int = 0,
+ color: str = "green",
+ ) -> None:
+ ax = self._get_ax(ax)
+ x, y = self._grid_as_2d(x, y)
+ z = np.asarray(z)
+ ny, nx = z.shape
+ for j in range(ny):
+ for i in range(nx):
+ zz = z[j, i]
+ if upper_level is not None and zz > upper_level:
+ z_level = 2
+ elif zz > lower_level:
+ z_level = 1
+ else:
+ z_level = 0
+ ax.text(x[j, i], y[j, i], str(z_level), ha="left", va="bottom", color=color,
+ clip_on=True)
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/mpl_util.py b/videollama2/lib/python3.10/site-packages/contourpy/util/mpl_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..10a2ccdb23571ded75ae52a2e8ea2ad332a2bb75
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/contourpy/util/mpl_util.py
@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import matplotlib.path as mpath
+import numpy as np
+
+from contourpy import FillType, LineType
+from contourpy.array import codes_from_offsets
+
+if TYPE_CHECKING:
+ from contourpy._contourpy import FillReturn, LineReturn, LineReturn_Separate
+
+
+def filled_to_mpl_paths(filled: FillReturn, fill_type: FillType) -> list[mpath.Path]:
+ if fill_type in (FillType.OuterCode, FillType.ChunkCombinedCode):
+ paths = [mpath.Path(points, codes) for points, codes in zip(*filled) if points is not None]
+ elif fill_type in (FillType.OuterOffset, FillType.ChunkCombinedOffset):
+ paths = [mpath.Path(points, codes_from_offsets(offsets))
+ for points, offsets in zip(*filled) if points is not None]
+ elif fill_type == FillType.ChunkCombinedCodeOffset:
+ paths = []
+ for points, codes, outer_offsets in zip(*filled):
+ if points is None:
+ continue
+ points = np.split(points, outer_offsets[1:-1])
+ codes = np.split(codes, outer_offsets[1:-1])
+ paths += [mpath.Path(p, c) for p, c in zip(points, codes)]
+ elif fill_type == FillType.ChunkCombinedOffsetOffset:
+ paths = []
+ for points, offsets, outer_offsets in zip(*filled):
+ if points is None:
+ continue
+ for i in range(len(outer_offsets)-1):
+ offs = offsets[outer_offsets[i]:outer_offsets[i+1]+1]
+ pts = points[offs[0]:offs[-1]]
+ paths += [mpath.Path(pts, codes_from_offsets(offs - offs[0]))]
+ else:
+ raise RuntimeError(f"Conversion of FillType {fill_type} to MPL Paths is not implemented")
+ return paths
+
+
+def lines_to_mpl_paths(lines: LineReturn, line_type: LineType) -> list[mpath.Path]:
+ if line_type == LineType.Separate:
+ if TYPE_CHECKING:
+ lines = cast(LineReturn_Separate, lines)
+ paths = []
+ for line in lines:
+ # Drawing as Paths so that they can be closed correctly.
+ closed = line[0, 0] == line[-1, 0] and line[0, 1] == line[-1, 1]
+ paths.append(mpath.Path(line, closed=closed))
+ elif line_type in (LineType.SeparateCode, LineType.ChunkCombinedCode):
+ paths = [mpath.Path(points, codes) for points, codes in zip(*lines) if points is not None]
+ elif line_type == LineType.ChunkCombinedOffset:
+ paths = []
+ for points, offsets in zip(*lines):
+ if points is None:
+ continue
+ for i in range(len(offsets)-1):
+ line = points[offsets[i]:offsets[i+1]]
+ closed = line[0, 0] == line[-1, 0] and line[0, 1] == line[-1, 1]
+ paths.append(mpath.Path(line, closed=closed))
+ elif line_type == LineType.ChunkCombinedNan:
+ paths = []
+ for points in lines[0]:
+ if points is None:
+ continue
+ nan_offsets = np.nonzero(np.isnan(points[:, 0]))[0]
+ nan_offsets = np.concatenate([[-1], nan_offsets, [len(points)]])
+ for s, e in zip(nan_offsets[:-1], nan_offsets[1:]):
+ line = points[s+1:e]
+ closed = line[0, 0] == line[-1, 0] and line[0, 1] == line[-1, 1]
+ paths.append(mpath.Path(line, closed=closed))
+ else:
+ raise RuntimeError(f"Conversion of LineType {line_type} to MPL Paths is not implemented")
+ return paths
diff --git a/videollama2/lib/python3.10/site-packages/contourpy/util/renderer.py b/videollama2/lib/python3.10/site-packages/contourpy/util/renderer.py
new file mode 100644
index 0000000000000000000000000000000000000000..716569f776c4df9197a36f40e9f0a5e176292114
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/contourpy/util/renderer.py
@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+if TYPE_CHECKING:
+ import io
+
+ from numpy.typing import ArrayLike
+
+ from contourpy._contourpy import CoordinateArray, FillReturn, FillType, LineReturn, LineType
+
+
+class Renderer(ABC):
+ """Abstract base class for renderers."""
+
+ def _grid_as_2d(self, x: ArrayLike, y: ArrayLike) -> tuple[CoordinateArray, CoordinateArray]:
+ x = np.asarray(x)
+ y = np.asarray(y)
+ if x.ndim == 1:
+ x, y = np.meshgrid(x, y)
+ return x, y
+
+ @abstractmethod
+ def filled(
+ self,
+ filled: FillReturn,
+ fill_type: FillType | str,
+ ax: Any = 0,
+ color: str = "C0",
+ alpha: float = 0.7,
+ ) -> None:
+ pass
+
+ @abstractmethod
+ def grid(
+ self,
+ x: ArrayLike,
+ y: ArrayLike,
+ ax: Any = 0,
+ color: str = "black",
+ alpha: float = 0.1,
+ point_color: str | None = None,
+ quad_as_tri_alpha: float = 0,
+ ) -> None:
+ pass
+
+ @abstractmethod
+ def lines(
+ self,
+ lines: LineReturn,
+ line_type: LineType | str,
+ ax: Any = 0,
+ color: str = "C0",
+ alpha: float = 1.0,
+ linewidth: float = 1,
+ ) -> None:
+ pass
+
+ @abstractmethod
+ def mask(
+ self,
+ x: ArrayLike,
+ y: ArrayLike,
+ z: ArrayLike | np.ma.MaskedArray[Any, Any],
+ ax: Any = 0,
+ color: str = "black",
+ ) -> None:
+ pass
+
+ def multi_filled(
+ self,
+ multi_filled: list[FillReturn],
+ fill_type: FillType | str,
+ ax: Any = 0,
+ color: str | None = None,
+ **kwargs: Any,
+ ) -> None:
+ """Plot multiple sets of filled contours on a single axes.
+
+ Args:
+ multi_filled (list of filled contour arrays): Multiple filled contour sets as returned
+ by :meth:`.ContourGenerator.multi_filled`.
+ fill_type (FillType or str): Type of filled data as returned by
+ :attr:`~.ContourGenerator.fill_type`, or string equivalent.
+ ax (int or Renderer-specific axes or figure object, optional): Which axes to plot on,
+ default ``0``.
+ color (str or None, optional): If a string color then this same color is used for all
+ filled contours. If ``None``, the default, then the filled contour sets use colors
+ from the ``tab10`` colormap in order, wrapping around to the beginning if more than
+ 10 sets of filled contours are rendered.
+ kwargs: All other keyword argument are passed on to
+ :meth:`.Renderer.filled` unchanged.
+
+ .. versionadded:: 1.3.0
+ """
+ if color is not None:
+ kwargs["color"] = color
+ for i, filled in enumerate(multi_filled):
+ if color is None:
+ kwargs["color"] = f"C{i % 10}"
+ self.filled(filled, fill_type, ax, **kwargs)
+
+ def multi_lines(
+ self,
+ multi_lines: list[LineReturn],
+ line_type: LineType | str,
+ ax: Any = 0,
+ color: str | None = None,
+ **kwargs: Any,
+ ) -> None:
+ """Plot multiple sets of contour lines on a single axes.
+
+ Args:
+ multi_lines (list of contour line arrays): Multiple contour line sets as returned by
+ :meth:`.ContourGenerator.multi_lines`.
+ line_type (LineType or str): Type of line data as returned by
+ :attr:`~.ContourGenerator.line_type`, or string equivalent.
+ ax (int or Renderer-specific axes or figure object, optional): Which axes to plot on,
+ default ``0``.
+ color (str or None, optional): If a string color then this same color is used for all
+ lines. If ``None``, the default, then the line sets use colors from the ``tab10``
+ colormap in order, wrapping around to the beginning if more than 10 sets of lines
+ are rendered.
+ kwargs: All other keyword argument are passed on to
+ :meth:`Renderer.lines` unchanged.
+
+ .. versionadded:: 1.3.0
+ """
+ if color is not None:
+ kwargs["color"] = color
+ for i, lines in enumerate(multi_lines):
+ if color is None:
+ kwargs["color"] = f"C{i % 10}"
+ self.lines(lines, line_type, ax, **kwargs)
+
+ @abstractmethod
+ def save(self, filename: str, transparent: bool = False) -> None:
+ pass
+
+ @abstractmethod
+ def save_to_buffer(self) -> io.BytesIO:
+ pass
+
+ @abstractmethod
+ def show(self) -> None:
+ pass
+
+ @abstractmethod
+ def title(self, title: str, ax: Any = 0, color: str | None = None) -> None:
+ pass
+
+ @abstractmethod
+ def z_values(
+ self,
+ x: ArrayLike,
+ y: ArrayLike,
+ z: ArrayLike,
+ ax: Any = 0,
+ color: str = "green",
+ fmt: str = ".1f",
+ quad_as_tri: bool = False,
+ ) -> None:
+ pass
diff --git a/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/LICENSE.txt b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d18210bc55ab19347d7f8781222b89e5cda9c11
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/LICENSE.txt
@@ -0,0 +1,910 @@
+Copyright (c) 2005-2022, NumPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+
+ * Neither the name of the NumPy Developers nor the names of any
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----
+
+This binary distribution of NumPy also bundles the following software:
+
+
+Name: OpenBLAS
+Files: .libs/libopenb*.so
+Description: bundled as a dynamically linked library
+Availability: https://github.com/xianyi/OpenBLAS/
+License: 3-clause BSD
+ Copyright (c) 2011-2014, The OpenBLAS Project
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the
+ distribution.
+ 3. Neither the name of the OpenBLAS project nor the names of
+ its contributors may be used to endorse or promote products
+ derived from this software without specific prior written
+ permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Name: LAPACK
+Files: .libs/libopenb*.so
+Description: bundled in OpenBLAS
+Availability: https://github.com/xianyi/OpenBLAS/
+License 3-clause BSD
+ Copyright (c) 1992-2013 The University of Tennessee and The University
+ of Tennessee Research Foundation. All rights
+ reserved.
+ Copyright (c) 2000-2013 The University of California Berkeley. All
+ rights reserved.
+ Copyright (c) 2006-2013 The University of Colorado Denver. All rights
+ reserved.
+
+ $COPYRIGHT$
+
+ Additional copyrights may follow
+
+ $HEADER$
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ - Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer listed
+ in this license in the documentation and/or other materials
+ provided with the distribution.
+
+ - Neither the name of the copyright holders nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ The copyright holders provide no reassurances that the source code
+ provided does not infringe any patent, copyright, or any other
+ intellectual property rights of third parties. The copyright holders
+ disclaim any liability to any recipient for claims brought against
+ recipient by any third party for infringement of that parties
+ intellectual property rights.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Name: GCC runtime library
+Files: .libs/libgfortran*.so
+Description: dynamically linked to files compiled with gcc
+Availability: https://gcc.gnu.org/viewcvs/gcc/
+License: GPLv3 + runtime exception
+ Copyright (C) 2002-2017 Free Software Foundation, Inc.
+
+ Libgfortran is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgfortran is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ .
+
+----
+
+Full text of license texts referred to above follows (that they are
+listed below does not necessarily imply the conditions apply to the
+present binary release):
+
+----
+
+GCC RUNTIME LIBRARY EXCEPTION
+
+Version 3.1, 31 March 2009
+
+Copyright (C) 2009 Free Software Foundation, Inc.
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+This GCC Runtime Library Exception ("Exception") is an additional
+permission under section 7 of the GNU General Public License, version
+3 ("GPLv3"). It applies to a given file (the "Runtime Library") that
+bears a notice placed by the copyright holder of the file stating that
+the file is governed by GPLv3 along with this Exception.
+
+When you use GCC to compile a program, GCC may combine portions of
+certain GCC header files and runtime libraries with the compiled
+program. The purpose of this Exception is to allow compilation of
+non-GPL (including proprietary) programs to use, in this way, the
+header files and runtime libraries covered by this Exception.
+
+0. Definitions.
+
+A file is an "Independent Module" if it either requires the Runtime
+Library for execution after a Compilation Process, or makes use of an
+interface provided by the Runtime Library, but is not otherwise based
+on the Runtime Library.
+
+"GCC" means a version of the GNU Compiler Collection, with or without
+modifications, governed by version 3 (or a specified later version) of
+the GNU General Public License (GPL) with the option of using any
+subsequent versions published by the FSF.
+
+"GPL-compatible Software" is software whose conditions of propagation,
+modification and use would permit combination with GCC in accord with
+the license of GCC.
+
+"Target Code" refers to output from any compiler for a real or virtual
+target processor architecture, in executable form or suitable for
+input to an assembler, loader, linker and/or execution
+phase. Notwithstanding that, Target Code does not include data in any
+format that is used as a compiler intermediate representation, or used
+for producing a compiler intermediate representation.
+
+The "Compilation Process" transforms code entirely represented in
+non-intermediate languages designed for human-written code, and/or in
+Java Virtual Machine byte code, into Target Code. Thus, for example,
+use of source code generators and preprocessors need not be considered
+part of the Compilation Process, since the Compilation Process can be
+understood as starting with the output of the generators or
+preprocessors.
+
+A Compilation Process is "Eligible" if it is done using GCC, alone or
+with other GPL-compatible software, or if it is done without using any
+work based on GCC. For example, using non-GPL-compatible Software to
+optimize any GCC intermediate representations would not qualify as an
+Eligible Compilation Process.
+
+1. Grant of Additional Permission.
+
+You have permission to propagate a work of Target Code formed by
+combining the Runtime Library with Independent Modules, even if such
+propagation would otherwise violate the terms of GPLv3, provided that
+all Target Code was generated by Eligible Compilation Processes. You
+may then convey such a combination under terms of your choice,
+consistent with the licensing of the Independent Modules.
+
+2. No Weakening of GCC Copyleft.
+
+The availability of this Exception does not imply any general
+presumption that third-party software is unaffected by the copyleft
+requirements of the license of GCC.
+
+----
+
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc.
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+ Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+ For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+ Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+ Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Use with the GNU Affero General Public License.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+
+ Copyright (C)
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+ Copyright (C)
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+.
+
+ The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+.
diff --git a/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/LICENSES_bundled.txt b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/LICENSES_bundled.txt
new file mode 100644
index 0000000000000000000000000000000000000000..26c7a7829361f509728fc4c53146377437588dde
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/LICENSES_bundled.txt
@@ -0,0 +1,22 @@
+The NumPy repository and source distributions bundle several libraries that are
+compatibly licensed. We list these here.
+
+Name: lapack-lite
+Files: numpy/linalg/lapack_lite/*
+License: BSD-3-Clause
+ For details, see numpy/linalg/lapack_lite/LICENSE.txt
+
+Name: tempita
+Files: tools/npy_tempita/*
+License: MIT
+ For details, see tools/npy_tempita/license.txt
+
+Name: dragon4
+Files: numpy/core/src/multiarray/dragon4.c
+License: MIT
+ For license text, see numpy/core/src/multiarray/dragon4.c
+
+Name: libdivide
+Files: numpy/core/include/numpy/libdivide/*
+License: Zlib
+ For license text, see numpy/core/include/numpy/libdivide/LICENSE.txt
diff --git a/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/METADATA b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..6137a937fd7e2ee67880f1f90245d8b77f815187
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/METADATA
@@ -0,0 +1,130 @@
+Metadata-Version: 2.1
+Name: numpy
+Version: 1.24.4
+Summary: Fundamental package for array computing in Python
+Home-page: https://www.numpy.org
+Author: Travis E. Oliphant et al.
+Maintainer: NumPy Developers
+Maintainer-email: numpy-discussion@python.org
+License: BSD-3-Clause
+Download-URL: https://pypi.python.org/pypi/numpy
+Project-URL: Bug Tracker, https://github.com/numpy/numpy/issues
+Project-URL: Documentation, https://numpy.org/doc/1.24
+Project-URL: Source Code, https://github.com/numpy/numpy
+Platform: Windows
+Platform: Linux
+Platform: Solaris
+Platform: Mac OS-X
+Platform: Unix
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering
+Classifier: Typing :: Typed
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+License-File: LICENSES_bundled.txt
+
+
+
+
+
+
+[](
+https://numfocus.org)
+[](
+https://pypi.org/project/numpy/)
+[](
+https://anaconda.org/conda-forge/numpy)
+[](
+https://stackoverflow.com/questions/tagged/numpy)
+[](
+https://doi.org/10.1038/s41586-020-2649-2)
+[](https://api.securityscorecards.dev/projects/github.com/numpy/numpy)
+
+
+NumPy is the fundamental package for scientific computing with Python.
+
+- **Website:** https://www.numpy.org
+- **Documentation:** https://numpy.org/doc
+- **Mailing list:** https://mail.python.org/mailman/listinfo/numpy-discussion
+- **Source code:** https://github.com/numpy/numpy
+- **Contributing:** https://www.numpy.org/devdocs/dev/index.html
+- **Bug reports:** https://github.com/numpy/numpy/issues
+- **Report a security vulnerability:** https://tidelift.com/docs/security
+
+It provides:
+
+- a powerful N-dimensional array object
+- sophisticated (broadcasting) functions
+- tools for integrating C/C++ and Fortran code
+- useful linear algebra, Fourier transform, and random number capabilities
+
+Testing:
+
+NumPy requires `pytest` and `hypothesis`. Tests can then be run after installation with:
+
+ python -c 'import numpy; numpy.test()'
+
+Code of Conduct
+----------------------
+
+NumPy is a community-driven open source project developed by a diverse group of
+[contributors](https://numpy.org/teams/). The NumPy leadership has made a strong
+commitment to creating an open, inclusive, and positive community. Please read the
+[NumPy Code of Conduct](https://numpy.org/code-of-conduct/) for guidance on how to interact
+with others in a way that makes our community thrive.
+
+Call for Contributions
+----------------------
+
+The NumPy project welcomes your expertise and enthusiasm!
+
+Small improvements or fixes are always appreciated. If you are considering larger contributions
+to the source code, please contact us through the [mailing
+list](https://mail.python.org/mailman/listinfo/numpy-discussion) first.
+
+Writing code isn’t the only way to contribute to NumPy. You can also:
+- review pull requests
+- help us stay on top of new and old issues
+- develop tutorials, presentations, and other educational materials
+- maintain and improve [our website](https://github.com/numpy/numpy.org)
+- develop graphic design for our brand assets and promotional materials
+- translate website content
+- help with outreach and onboard new contributors
+- write grant proposals and help with other fundraising efforts
+
+For more information about the ways you can contribute to NumPy, visit [our website](https://numpy.org/contribute/).
+If you’re unsure where to start or how your skills fit in, reach out! You can
+ask on the mailing list or here, on GitHub, by opening a new issue or leaving a
+comment on a relevant issue that is already open.
+
+Our preferred channels of communication are all public, but if you’d like to
+speak to us in private first, contact our community coordinators at
+numpy-team@googlegroups.com or on Slack (write numpy-team@googlegroups.com for
+an invitation).
+
+We also have a biweekly community call, details of which are announced on the
+mailing list. You are very welcome to join.
+
+If you are new to contributing to open source, [this
+guide](https://opensource.guide/how-to-contribute/) helps explain why, what,
+and how to successfully get involved.
+
+
diff --git a/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/RECORD b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..d061bacb4b912ddab443eeb7e1ed29be04b4cf93
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/RECORD
@@ -0,0 +1,1364 @@
+../../../bin/f2py,sha256=oljWZdXbrEdnD6qwfuYhJ0R2cfqHs2mOQJ3UXgbB5zs,233
+../../../bin/f2py3,sha256=oljWZdXbrEdnD6qwfuYhJ0R2cfqHs2mOQJ3UXgbB5zs,233
+../../../bin/f2py3.10,sha256=oljWZdXbrEdnD6qwfuYhJ0R2cfqHs2mOQJ3UXgbB5zs,233
+numpy-1.24.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+numpy-1.24.4.dist-info/LICENSE.txt,sha256=ATdhUdRkXvut-KobrcV16_CzXbH65FRWBNVF9cmzL94,45692
+numpy-1.24.4.dist-info/LICENSES_bundled.txt,sha256=VyI3ubJn_nVdgqKOIT9pF2vVavoWKlpkGzegbjAHKNE,634
+numpy-1.24.4.dist-info/METADATA,sha256=kBZ3ucbglz7ZHs5aefrTxC2v2ITh1ymc9cOSp-fGI5g,5556
+numpy-1.24.4.dist-info/RECORD,,
+numpy-1.24.4.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy-1.24.4.dist-info/WHEEL,sha256=6B0vZ-Dd34LpGZN_4Y_GbBSl1fSb7keGXRzuHUFcOBA,152
+numpy-1.24.4.dist-info/entry_points.txt,sha256=ceukqz6cu6_fhbhEOHcWlogsjr32LVwUzyOe7xgyd_w,209
+numpy-1.24.4.dist-info/top_level.txt,sha256=4J9lbBMLnAiyxatxh8iRKV5Entd_6-oqbO7pzJjMsPw,6
+numpy.libs/libgfortran-040039e1.so.5.0.0,sha256=R6s7aClbCjzomQpEjef6sRq928Fg-IlZcsqapxLPhtA,2686064
+numpy.libs/libopenblas64_p-r0-15028c96.3.21.so,sha256=VUveHYoMcdjcIa503gXETaT_9dvGeRqBn2rPWt_pC9k,32955056
+numpy.libs/libquadmath-96973f99.so.0.0.0,sha256=l82oXdtRY-Labh7bTh1rVXgzqZpA7aB5rjflA5Rltl0,247608
+numpy/LICENSE.txt,sha256=ATdhUdRkXvut-KobrcV16_CzXbH65FRWBNVF9cmzL94,45692
+numpy/__config__.py,sha256=TXvjW8PcKIkWSx3pLCYYC2SMqmRP-0gKkOOvckDq6Ao,5143
+numpy/__init__.cython-30.pxd,sha256=_i5eaLZlfHTIF8mDwNehqFvem0CZGtHmU6gIQ1tlDIw,36216
+numpy/__init__.pxd,sha256=0CIC53c2iCvgV5itsP73rUHiAjkJ85XIoBOzrul-L9Y,34584
+numpy/__init__.py,sha256=7dGP7_kzSL6wLzkpWegLn9oYdahC1_l2CEfzI4b9_Ug,16174
+numpy/__init__.pyi,sha256=KfSicFjBo5mL9Y1gqsTO-oJwABSe60nRcn5clqTviSY,153310
+numpy/__pycache__/__config__.cpython-310.pyc,,
+numpy/__pycache__/__init__.cpython-310.pyc,,
+numpy/__pycache__/_distributor_init.cpython-310.pyc,,
+numpy/__pycache__/_globals.cpython-310.pyc,,
+numpy/__pycache__/_pytesttester.cpython-310.pyc,,
+numpy/__pycache__/_version.cpython-310.pyc,,
+numpy/__pycache__/conftest.cpython-310.pyc,,
+numpy/__pycache__/ctypeslib.cpython-310.pyc,,
+numpy/__pycache__/dual.cpython-310.pyc,,
+numpy/__pycache__/matlib.cpython-310.pyc,,
+numpy/__pycache__/setup.cpython-310.pyc,,
+numpy/__pycache__/version.cpython-310.pyc,,
+numpy/_distributor_init.py,sha256=IgPkSK3H9bgjFeUfWuXhjKrgetQl5ztUW-rTyjGHK3c,331
+numpy/_globals.py,sha256=0bbvPQeFlmtaRcudQ1WoFE3VuEnRFh-A_QearJW74gM,3885
+numpy/_pyinstaller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/_pyinstaller/__pycache__/__init__.cpython-310.pyc,,
+numpy/_pyinstaller/__pycache__/hook-numpy.cpython-310.pyc,,
+numpy/_pyinstaller/__pycache__/pyinstaller-smoke.cpython-310.pyc,,
+numpy/_pyinstaller/__pycache__/test_pyinstaller.cpython-310.pyc,,
+numpy/_pyinstaller/hook-numpy.py,sha256=NiNJWF0o2g-vuyKTHGSe3UoDvDRmQPBBTeZfSMAFoJY,1422
+numpy/_pyinstaller/pyinstaller-smoke.py,sha256=6iL-eHMQaG3rxnS5EgcvrCqElm9aKL07Cjr1FZJSXls,1143
+numpy/_pyinstaller/test_pyinstaller.py,sha256=8K-7QxmfoXCG0NwR0bhIgCNrDjGlrTzWnrR1sR8btgU,1135
+numpy/_pytesttester.py,sha256=FEboeZMDjBKCQd6vLHiiDPcVGMfG2xN30yUmuoqa98A,6668
+numpy/_pytesttester.pyi,sha256=OtyXSiuSy8o_78w3QNQRjMLpvvNyEdC0aMsx6T-vRxU,489
+numpy/_typing/__init__.py,sha256=WHbp91iVwuU88_4yefIJ0B8kE03os4C-AOo-Ko7Qo5o,7108
+numpy/_typing/__pycache__/__init__.cpython-310.pyc,,
+numpy/_typing/__pycache__/_add_docstring.cpython-310.pyc,,
+numpy/_typing/__pycache__/_array_like.cpython-310.pyc,,
+numpy/_typing/__pycache__/_char_codes.cpython-310.pyc,,
+numpy/_typing/__pycache__/_dtype_like.cpython-310.pyc,,
+numpy/_typing/__pycache__/_extended_precision.cpython-310.pyc,,
+numpy/_typing/__pycache__/_generic_alias.cpython-310.pyc,,
+numpy/_typing/__pycache__/_nbit.cpython-310.pyc,,
+numpy/_typing/__pycache__/_nested_sequence.cpython-310.pyc,,
+numpy/_typing/__pycache__/_scalars.cpython-310.pyc,,
+numpy/_typing/__pycache__/_shape.cpython-310.pyc,,
+numpy/_typing/__pycache__/setup.cpython-310.pyc,,
+numpy/_typing/_add_docstring.py,sha256=fviZAxCBB5w1OY5PnnP9Hj2Da7krEs8ixpj8yk_0aLM,3925
+numpy/_typing/_array_like.py,sha256=dd4jX6_JY5yykayFT7WYei1BDtb2CDXjY-0zNPw_lqM,4391
+numpy/_typing/_callable.pyi,sha256=Vh9_vJmAyjX7WNXHtvzFIHFFYcKNTcszlQpXbZYVUZI,11124
+numpy/_typing/_char_codes.py,sha256=LR51O5AUBDbCmJvlMoxyUvsfvb1p7WHrexgtTGtuWTc,5916
+numpy/_typing/_dtype_like.py,sha256=Uf5196lPEC6aU8UVoXNXuv47oknCyMsIXjCporDhwHA,5628
+numpy/_typing/_extended_precision.py,sha256=PfQZUM8xlS7lFXPVQbJJX1quiMKobeJJP4S9TvtyTrE,1111
+numpy/_typing/_generic_alias.py,sha256=l2EcoRmN7KK2ABfsYFZZlWDGodXu_pE2cvgsUrrxyCg,7479
+numpy/_typing/_nbit.py,sha256=-EQOShHpB3r30b4RVEcruQRTcTaFAZwtqCJ4BsvpEzA,345
+numpy/_typing/_nested_sequence.py,sha256=vtnHIox9hs-3hpUZNanD07qIQksCAz-ZmGx07gORigU,2701
+numpy/_typing/_scalars.py,sha256=CRoiNAYZqELubR2hbplA5qom-k4kUpWLNX4GgX8Hli0,957
+numpy/_typing/_shape.py,sha256=tsMDZ41GBVM9PiGa3GpGV2gEWxP57c7HqmPMWKrkCQo,191
+numpy/_typing/_ufunc.pyi,sha256=e74LtOP9e8kkRhvrIJ_RXz9Ua_L43Pd9IixwNwermnM,12638
+numpy/_typing/setup.py,sha256=SE0Q6HPqDjWUfceA4yXgkII8y3z7EiSF0Z-MNwOIyG4,337
+numpy/_version.py,sha256=TmpckvDgZ3QnyrSyiccAudMJc-SHhngkpOozK0OM-Po,498
+numpy/array_api/__init__.py,sha256=b2FtjmWpOJp27Q3SDmHO7PKdsIQcIW8__3WFMxqJy5s,10221
+numpy/array_api/__pycache__/__init__.cpython-310.pyc,,
+numpy/array_api/__pycache__/_array_object.cpython-310.pyc,,
+numpy/array_api/__pycache__/_constants.cpython-310.pyc,,
+numpy/array_api/__pycache__/_creation_functions.cpython-310.pyc,,
+numpy/array_api/__pycache__/_data_type_functions.cpython-310.pyc,,
+numpy/array_api/__pycache__/_dtypes.cpython-310.pyc,,
+numpy/array_api/__pycache__/_elementwise_functions.cpython-310.pyc,,
+numpy/array_api/__pycache__/_manipulation_functions.cpython-310.pyc,,
+numpy/array_api/__pycache__/_searching_functions.cpython-310.pyc,,
+numpy/array_api/__pycache__/_set_functions.cpython-310.pyc,,
+numpy/array_api/__pycache__/_sorting_functions.cpython-310.pyc,,
+numpy/array_api/__pycache__/_statistical_functions.cpython-310.pyc,,
+numpy/array_api/__pycache__/_typing.cpython-310.pyc,,
+numpy/array_api/__pycache__/_utility_functions.cpython-310.pyc,,
+numpy/array_api/__pycache__/linalg.cpython-310.pyc,,
+numpy/array_api/__pycache__/setup.cpython-310.pyc,,
+numpy/array_api/_array_object.py,sha256=5YD915C7EH_UJ2S6RIIxllZNE7QTlPZXnJU9sTpkMY4,43226
+numpy/array_api/_constants.py,sha256=Z6bImx0puhVuCwc5dPXvZ6TZt46exiuuX1TubSyQ62E,66
+numpy/array_api/_creation_functions.py,sha256=6SqHdzZqHOJFEyWFtqnj6KIKRivrGXxROlgnez_3Mt0,10050
+numpy/array_api/_data_type_functions.py,sha256=Hk00nh4MxXHBCJHRR7fS3fZAW7B982REfp_oSUbnG_k,4480
+numpy/array_api/_dtypes.py,sha256=WEy1XztJIbSI9kosFqesv_Fzb_bHwH_nOlrVFlhbyx0,3707
+numpy/array_api/_elementwise_functions.py,sha256=arizOQ2iM3d_bOFpk_rwwCXZM3Zyhx9_fnyCki6Z8eY,24772
+numpy/array_api/_manipulation_functions.py,sha256=6zpKXKPqul2FWJiHcTBYH9YnsnlwQcvlhRzptYQeSM0,3008
+numpy/array_api/_searching_functions.py,sha256=M75BEj5b94Z5cya6_OzbgvhR9GGIDGdJ8eyydJHuWPQ,1457
+numpy/array_api/_set_functions.py,sha256=ULpfK1zznW9joX1DXSiP0R3ahcDB_po7mZlpsRqi7Fs,2948
+numpy/array_api/_sorting_functions.py,sha256=V0pmt1xALcAy76SDqwIHnMUzpFqU98x648tH02X-k44,1754
+numpy/array_api/_statistical_functions.py,sha256=AxiYkz-lW1k8uFaQfCDXJrXiDzG6Qhju-hrm5A9IFSE,3378
+numpy/array_api/_typing.py,sha256=HN0Ao-n6m1XAuIFNkGEUQ56REPmPJ-lKSAernfUxoDc,1376
+numpy/array_api/_utility_functions.py,sha256=HwycylbPAgRVz4nZvjvwqN3mQnJbqKA-NRMaAvIP-CE,824
+numpy/array_api/linalg.py,sha256=ubHrbutTuaVJWO5ghE9MBVSxHU_-PQ07QgUwyWgqNu4,17860
+numpy/array_api/setup.py,sha256=Wx6qD7GU_APiqKolYPO0OHv4eHGYrjPZmDAgjWhOEhM,341
+numpy/array_api/tests/__init__.py,sha256=t_2GZ3lKcsu4ec4GMKPUDYaeMUJyDquBlQAcPgj7kFE,282
+numpy/array_api/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/array_api/tests/__pycache__/test_array_object.cpython-310.pyc,,
+numpy/array_api/tests/__pycache__/test_creation_functions.cpython-310.pyc,,
+numpy/array_api/tests/__pycache__/test_data_type_functions.cpython-310.pyc,,
+numpy/array_api/tests/__pycache__/test_elementwise_functions.cpython-310.pyc,,
+numpy/array_api/tests/__pycache__/test_set_functions.cpython-310.pyc,,
+numpy/array_api/tests/__pycache__/test_sorting_functions.cpython-310.pyc,,
+numpy/array_api/tests/__pycache__/test_validation.cpython-310.pyc,,
+numpy/array_api/tests/test_array_object.py,sha256=xdv2z-j5R0wdGp5hxE6QvvGMqSsYYSPDqJCzdbyzoHM,15771
+numpy/array_api/tests/test_creation_functions.py,sha256=s3A1COWmXIAJdhzd8v7VtL-jbiSspskTqwYy0BTpmpw,5023
+numpy/array_api/tests/test_data_type_functions.py,sha256=Ukkpb-qjORIYb8T1FrStiwciDWaEr27qRso7QJgIS0E,422
+numpy/array_api/tests/test_elementwise_functions.py,sha256=_DEB5r6VCDVhUos7VDaFzCId2_M5y7KoyK-HTGybdkc,3619
+numpy/array_api/tests/test_set_functions.py,sha256=D016G7v3ko49bND5sVERP8IqQXZiwr-2yrKbBPJ-oqg,546
+numpy/array_api/tests/test_sorting_functions.py,sha256=INPiYnuGBcsmWtYqdTTX3ENHmM4iUx4zs9KdwDaSmdA,602
+numpy/array_api/tests/test_validation.py,sha256=QUG9yWC3QhkPxNhbQeakwBbl-0Rr0iTuZ41_0sfVIGU,676
+numpy/compat/__init__.py,sha256=vDaDPwY2qBEKixsIfjwPjyKeWiyWg0kPJdgcSxua8R8,432
+numpy/compat/__pycache__/__init__.cpython-310.pyc,,
+numpy/compat/__pycache__/_inspect.cpython-310.pyc,,
+numpy/compat/__pycache__/_pep440.cpython-310.pyc,,
+numpy/compat/__pycache__/py3k.cpython-310.pyc,,
+numpy/compat/__pycache__/setup.cpython-310.pyc,,
+numpy/compat/_inspect.py,sha256=8Ma7QBRwfSWKeK1ShJpFNc7CDhE6fkIE_wr1FxrG1A8,7447
+numpy/compat/_pep440.py,sha256=Vr7B3QsijR5p6h8YAz2LjNGUyzHUJ5gZ4v26NpZAKDc,14069
+numpy/compat/py3k.py,sha256=h5a6n0ha5JMgWKcUyTDbsvHm3Tm7hn3bfeGiUCxagGI,3929
+numpy/compat/setup.py,sha256=36X1kF0C_NVROXfJ7w3SQeBm5AIDBuJbM5qT7cvSDgU,335
+numpy/compat/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/compat/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/compat/tests/__pycache__/test_compat.cpython-310.pyc,,
+numpy/compat/tests/test_compat.py,sha256=34ggbcnYlQpKXZZZpr34jGmb2EOQMo9M1skrFMZ2Oic,955
+numpy/conftest.py,sha256=xssw1kZs2IpBLWT1-RM7s5TeNS09z1o8O3fkc8EHPfc,4528
+numpy/core/__init__.py,sha256=1mE4t3NAICJE_T4jiewRq8emwk-KUvqcBoPOyxWUaAM,5750
+numpy/core/__init__.pyi,sha256=xtd9OFYza-ZG3jyEJrlzRPT-SkVoB_qYmVCe6FxRks0,126
+numpy/core/__pycache__/__init__.cpython-310.pyc,,
+numpy/core/__pycache__/_add_newdocs.cpython-310.pyc,,
+numpy/core/__pycache__/_add_newdocs_scalars.cpython-310.pyc,,
+numpy/core/__pycache__/_asarray.cpython-310.pyc,,
+numpy/core/__pycache__/_dtype.cpython-310.pyc,,
+numpy/core/__pycache__/_dtype_ctypes.cpython-310.pyc,,
+numpy/core/__pycache__/_exceptions.cpython-310.pyc,,
+numpy/core/__pycache__/_internal.cpython-310.pyc,,
+numpy/core/__pycache__/_machar.cpython-310.pyc,,
+numpy/core/__pycache__/_methods.cpython-310.pyc,,
+numpy/core/__pycache__/_string_helpers.cpython-310.pyc,,
+numpy/core/__pycache__/_type_aliases.cpython-310.pyc,,
+numpy/core/__pycache__/_ufunc_config.cpython-310.pyc,,
+numpy/core/__pycache__/arrayprint.cpython-310.pyc,,
+numpy/core/__pycache__/cversions.cpython-310.pyc,,
+numpy/core/__pycache__/defchararray.cpython-310.pyc,,
+numpy/core/__pycache__/einsumfunc.cpython-310.pyc,,
+numpy/core/__pycache__/fromnumeric.cpython-310.pyc,,
+numpy/core/__pycache__/function_base.cpython-310.pyc,,
+numpy/core/__pycache__/generate_numpy_api.cpython-310.pyc,,
+numpy/core/__pycache__/getlimits.cpython-310.pyc,,
+numpy/core/__pycache__/memmap.cpython-310.pyc,,
+numpy/core/__pycache__/multiarray.cpython-310.pyc,,
+numpy/core/__pycache__/numeric.cpython-310.pyc,,
+numpy/core/__pycache__/numerictypes.cpython-310.pyc,,
+numpy/core/__pycache__/overrides.cpython-310.pyc,,
+numpy/core/__pycache__/records.cpython-310.pyc,,
+numpy/core/__pycache__/setup.cpython-310.pyc,,
+numpy/core/__pycache__/setup_common.cpython-310.pyc,,
+numpy/core/__pycache__/shape_base.cpython-310.pyc,,
+numpy/core/__pycache__/umath.cpython-310.pyc,,
+numpy/core/__pycache__/umath_tests.cpython-310.pyc,,
+numpy/core/_add_newdocs.py,sha256=2Rv9VCUAsZQK6FnzuMSj556TdaFtFnXyJ8amefGQyis,209060
+numpy/core/_add_newdocs_scalars.py,sha256=CXvuSi3DXrNFK8jJNdTw8ECxlGNC6N32UfEXxSbpN3A,12081
+numpy/core/_asarray.py,sha256=2GRUFO-sl5PMNanwopu47R-eQ3I5FVZzdtWSrYrrWwk,4023
+numpy/core/_asarray.pyi,sha256=_A6h99LV-8BkgLxDKvG6i1NXBLB_Drxoq51Qz2F_gC4,1051
+numpy/core/_dtype.py,sha256=3eg6vYQtknrX4eBxEZF1yfRpU_uJzd03HnXtQHHPvzU,10495
+numpy/core/_dtype_ctypes.py,sha256=Vug4i7xKhznK2tdIjmn4ebclClpaCJwSZUlvEoYl0Eg,3673
+numpy/core/_exceptions.py,sha256=MDV77tyU0jsTjzDCE3v_YH6UznqfgTxGEkB0B86MJAI,8615
+numpy/core/_internal.py,sha256=lTGXtgvh55uTPmlZLdMaY33qJAhw_AZqh18sLBK-YZc,28195
+numpy/core/_internal.pyi,sha256=_mCTOX6Su8D4R9fV4HNeohPJx7515B-WOlv4uq6mry8,1032
+numpy/core/_machar.py,sha256=ZKzS3o2wWw6ROTDTMgMIRZTDYuhFifEl3D1GxQsC3Qc,11618
+numpy/core/_methods.py,sha256=nNsCjsA8-FzgX17zgKG7xpfSXcQmpnyjGe8Vy5LlYYo,11068
+numpy/core/_multiarray_tests.cpython-310-x86_64-linux-gnu.so,sha256=xq3EqK7e9PcQ0NR3B_nfw7hZF6XK8P6WWjBtDOoO4qA,174880
+numpy/core/_multiarray_umath.cpython-310-x86_64-linux-gnu.so,sha256=42d-x2HpTHV3qtD7aq06z3qhUj17rsGrjoTKB3VTUbw,6311456
+numpy/core/_operand_flag_tests.cpython-310-x86_64-linux-gnu.so,sha256=TIi2KoDbMCtuIO0cditXHeaziAD7sDAPzpSKC0n-hZ8,17072
+numpy/core/_rational_tests.cpython-310-x86_64-linux-gnu.so,sha256=POPMhYKgtXaeaDZBobUhtC-FLkHLqqx8Df5Fd_7Zbh4,59808
+numpy/core/_simd.cpython-310-x86_64-linux-gnu.so,sha256=lTKIoxxgKROnhoQr2c02qrGqtuC1TNsjaS-gKVQoLQ8,2264056
+numpy/core/_string_helpers.py,sha256=NGGGhaFdU5eGiUAj3GTIBoOgWs4r9aTNlsE2r9NgX6Q,2855
+numpy/core/_struct_ufunc_tests.cpython-310-x86_64-linux-gnu.so,sha256=pviwAV1hNpfLGDugqMDsgv-Y0O1CZapyfWm76OULM6g,17176
+numpy/core/_type_aliases.py,sha256=qV6AZlsUWHMWTydmZya73xuBkKXiUKq_WXLj7q2CbZ0,7534
+numpy/core/_type_aliases.pyi,sha256=7A0M5_QvMCH8ZytWpz70-YJ6bLy7vqZxehrm0_GaXJ8,374
+numpy/core/_ufunc_config.py,sha256=s6Uh3d_S89DDEqyo3ZJN68-9xW9DDOBDUVzAewAEu9E,13946
+numpy/core/_ufunc_config.pyi,sha256=-615enOVQMBhVx7Pln7DY_s4H6JjSgSnBy89YkpvuLg,1066
+numpy/core/_umath_tests.cpython-310-x86_64-linux-gnu.so,sha256=0qKkqrSmNQbtikfPBHAwgEnqiqkRfUgbS23tid9G56o,41856
+numpy/core/arrayprint.py,sha256=YyPzy0LWZknBZhY3xN1Pg1wxEsJl49O7WJt_9VHm1tA,62717
+numpy/core/arrayprint.pyi,sha256=21pOWjTSfJOBaKgOOPzRox1ERb3c9ydufqL0b11_P_Q,4428
+numpy/core/cversions.py,sha256=H_iNIpx9-hY1cQNxqjT2d_5SXZhJbMo_caq4_q6LB7I,347
+numpy/core/defchararray.py,sha256=MCiHewOWEW8ROOjoH1gwy3XDKqFDukqa1O4eLg0Qi8I,73025
+numpy/core/defchararray.pyi,sha256=ib3aWFcM7F4KooU57mWUNi4GlosNjdfgrLKBVSIKDvU,9216
+numpy/core/einsumfunc.py,sha256=C12IJQmlUi1UgyCNwANqLAVwwojZPc1NAMi7ABzlzmk,51869
+numpy/core/einsumfunc.pyi,sha256=-lSAtJnJqMT3Y6YSi54HUdf_ydfnV1mK1F4gx0OaPFI,3778
+numpy/core/fromnumeric.py,sha256=H31A0YvWsc_eM9skq8_A7L3UgMqCjXcs0Z0plxRQgN0,125221
+numpy/core/fromnumeric.pyi,sha256=fLvQT6mBX8IBO48mNziBs_o65fUFxItLrX124EINGUY,23472
+numpy/core/function_base.py,sha256=NYSbMgzttX_exTP8NgzKdZXjScKAgq8cru2V7i-XXnE,19283
+numpy/core/function_base.pyi,sha256=3ZYad3cdaGwNEyP8VwK97IYMqk2PDoVjpjQzhIYHjk0,4725
+numpy/core/generate_numpy_api.py,sha256=RXWZdiaiQ6DOz1BsJ70jgyhviE3C1K_YfMWabexbkjo,7405
+numpy/core/getlimits.py,sha256=kuN_KtFWYvJQEpV0OmM_XKqoWd85b04mcgePnDvS_34,24889
+numpy/core/getlimits.pyi,sha256=qeIXUEtognTHr_T-tv-VcZI7n8Z2VzAyIpIgKXzsLkc,82
+numpy/core/include/numpy/.doxyfile,sha256=goOZR7LcINt3snuBGH8Me-_aVTGm5f4u4wEaSpjM_W4,58
+numpy/core/include/numpy/__multiarray_api.h,sha256=iSlyW-BjmwifI4hlZpJwCVZHmeXHZ6znbB95ePVsito,62712
+numpy/core/include/numpy/__ufunc_api.h,sha256=kOT0I320xLGHnuE8XSaomEiCmFaup8fTOTied514XiM,12614
+numpy/core/include/numpy/_neighborhood_iterator_imp.h,sha256=A6YPpQihUwscZYxz0oODrBjRSYZdJM2dG0vcdtJtY64,1877
+numpy/core/include/numpy/_numpyconfig.h,sha256=DYhvMSbnzi1OVUxC_e4qjpjq0PKGZdqiMwu8B3I43kI,971
+numpy/core/include/numpy/arrayobject.h,sha256=-BlWQ7kfVbzCqzHn0qaeMe0_08AbwliuG98XWG57lT8,282
+numpy/core/include/numpy/arrayscalars.h,sha256=h6MKjFHzguTZ5CQd7HATAVWHoZ7mkC-86R1uMHeLT04,3818
+numpy/core/include/numpy/experimental_dtype_api.h,sha256=kEL5c82yLl3zAlTGJygDDNeuOi7Sta-xvYcmUs1q-LA,19943
+numpy/core/include/numpy/halffloat.h,sha256=TRZfXgipa-dFppX2uNgkrjrPli-1BfJtadWjAembJ4s,1959
+numpy/core/include/numpy/libdivide/LICENSE.txt,sha256=-8U59H0M-DvGE3gID7hz1cFGMBJsrL_nVANcOSbapew,1018
+numpy/core/include/numpy/libdivide/libdivide.h,sha256=ew9MNhPQd1LsCZiWiFmj9IZ7yOnA3HKOXffDeR9X1jw,80138
+numpy/core/include/numpy/multiarray_api.txt,sha256=qV4lIDhedn5WfXUOhQGLudMl24ruWc_OoRAvVJRqo1E,57378
+numpy/core/include/numpy/ndarrayobject.h,sha256=Lvr0ljFumbLtDgepidCtA1V3fHoTRpL432B-t7sWVh0,10191
+numpy/core/include/numpy/ndarraytypes.h,sha256=MRxdiWjZf9dFpiKOgZX0cb4EMXcjfwWatvzUohWilgw,68688
+numpy/core/include/numpy/noprefix.h,sha256=d83l1QpCCVqMV2k29NMkL3Ld1qNjiC6hzOPWZAivEjQ,6830
+numpy/core/include/numpy/npy_1_7_deprecated_api.h,sha256=y0MJ8Qw7Bkt4H_4VxIzHzpkw5JqAdj5ECgtn08fZFrI,4327
+numpy/core/include/numpy/npy_3kcompat.h,sha256=kkHpOP0HozJwzKj6h7A2MLJLdJGDUL_pJjYbC1aq6Kc,15990
+numpy/core/include/numpy/npy_common.h,sha256=_INzM3hdWejf7egw0_FnzYl_wxf1PBfxifXI5X2wG8Y,39015
+numpy/core/include/numpy/npy_cpu.h,sha256=s5wuxe4hDuxffIlhstEd5k5bZtNdrGWwjUo0haegE0E,4603
+numpy/core/include/numpy/npy_endian.h,sha256=we7X9fPeWzNpo_YTh09MPGDwdE0Rw_WDM4c9y4nBj5I,2786
+numpy/core/include/numpy/npy_interrupt.h,sha256=DQZIxi6FycLXD8drdHn2SSmLoRhIpo6osvPv13vowUA,1948
+numpy/core/include/numpy/npy_math.h,sha256=CIcke0nkm8glJOpoF4p50ARZb0vRIV3NSCOUl3wFl7k,19874
+numpy/core/include/numpy/npy_no_deprecated_api.h,sha256=0yZrJcQEJ6MCHJInQk5TP9_qZ4t7EfBuoLOJ34IlJd4,678
+numpy/core/include/numpy/npy_os.h,sha256=6ih9znx3n8PIIwg5sSJkK3g4JtUvcyJahY2Wxs3mFe8,1120
+numpy/core/include/numpy/numpyconfig.h,sha256=c4XjyM3uf7hZNF25NZT26LGqkHVFJ00woPF4z996hOY,2943
+numpy/core/include/numpy/old_defines.h,sha256=xuYQDDlMywu0Zsqm57hkgGwLsOFx6IvxzN2eiNF-gJY,6405
+numpy/core/include/numpy/oldnumeric.h,sha256=laP57STtFtJSs_fjRRDlrk34hqfqCwxP-BFEytR6lTM,899
+numpy/core/include/numpy/random/bitgen.h,sha256=49AwKOR552r-NkhuSOF1usb_URiMSRMvD22JF5pKIng,488
+numpy/core/include/numpy/random/distributions.h,sha256=uJVR8qB0LXdvRg7VZakVrZ8qDPRS9FWkxtLFfXzj-Jc,9865
+numpy/core/include/numpy/ufunc_api.txt,sha256=CMYRT5Wl36VufbEnjRR_yLg1vf0R3ydcNODyJY3WPCw,7198
+numpy/core/include/numpy/ufuncobject.h,sha256=PDpFN5loASykuAgmCEt2t38yt5RiNP54tDyQB33yT98,11895
+numpy/core/include/numpy/utils.h,sha256=wMNomSH3Dfj0q78PrjLVtFtN-FPo7UJ4o0ifCUO-6Es,1185
+numpy/core/lib/libnpymath.a,sha256=v0Xz6APa8BrAHC5VxgGKzXbb2VxJDQDlttL4HvbNDFM,433482
+numpy/core/lib/npy-pkg-config/mlib.ini,sha256=_LsWV1eStNqwhdiYPa2538GL46dnfVwT4MrI1zbsoFw,147
+numpy/core/lib/npy-pkg-config/npymath.ini,sha256=kamUNrYKAmXqQa8BcNv7D5sLqHh6bnChM0_5rZCsTfY,360
+numpy/core/memmap.py,sha256=tIDygBke18_QnYw2mZNw5pBilnDhydFoJS8alv8KmP8,11688
+numpy/core/memmap.pyi,sha256=sxIQ7T5hPLG-RBNndAc8JPvrsKEX1amBSH2HGg48Obo,55
+numpy/core/multiarray.py,sha256=43ncUHcruiht1wiXK-OST3U_0ByUVls4Vfz4RL6pOR8,55987
+numpy/core/multiarray.pyi,sha256=1k-IMlIRAVjKaQn9QJObG4D3Bzm3DNhDRgvA7ODY-qo,24761
+numpy/core/numeric.py,sha256=SkVC13WPiqdp5Pp_9iKOEGN4hwAzIpjePahGCABN8SI,77704
+numpy/core/numeric.pyi,sha256=bmKTFtg6SaPe9x64Mt1T-Af-PsH-Xi4cDGT4HB-lFiE,14230
+numpy/core/numerictypes.py,sha256=O7nhsBqqAl8a2EiuK7hc_z6w5SmE_czVwrPSBySEj9g,17239
+numpy/core/numerictypes.pyi,sha256=nsQaevKSF_vVK6TIta8lr4tv_ZO1TuWt0icpkSRGkJs,3388
+numpy/core/overrides.py,sha256=k8tDHEWd8harz0ycj5v775eUrMwW0leDHcAeUMFxkug,8348
+numpy/core/records.py,sha256=kIsUns_m8BQ40HTmB39S2ogY5WRphF0EK_PXSzwZ2tY,37545
+numpy/core/records.pyi,sha256=uYwE6cAoGKgN6U4ryfGZx_3m-3sY006jytjWLrDRRy0,5692
+numpy/core/setup.py,sha256=NIF6oANRl3Bf-j4oWIkHfPi_8orAk4lmL8JWHRfS1eE,52357
+numpy/core/setup_common.py,sha256=SCz93xOY9Xob9ch8FH7c0LBMgFo2Qq1BfUpBIsVxVMc,19519
+numpy/core/shape_base.py,sha256=wjoTaEGNEMcEbavzJD_JoQWNlyU58DKAcjBcRm8waF4,30487
+numpy/core/shape_base.pyi,sha256=Ilb4joJmbjkIZLzKww7NJeaxg2FP3AfFib3HtfOsrC0,2774
+numpy/core/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/core/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/core/tests/__pycache__/_locales.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test__exceptions.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_abc.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_api.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_argparse.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_array_coercion.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_array_interface.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_arraymethod.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_arrayprint.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_casting_floatingpoint_errors.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_casting_unittests.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_conversion_utils.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_cpu_dispatcher.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_cpu_features.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_custom_dtypes.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_cython.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_datetime.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_defchararray.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_deprecations.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_dlpack.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_dtype.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_einsum.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_errstate.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_extint128.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_function_base.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_getlimits.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_half.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_hashtable.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_indexerrors.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_indexing.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_item_selection.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_limited_api.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_longdouble.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_machar.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_mem_overlap.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_mem_policy.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_memmap.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_multiarray.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_nditer.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_nep50_promotions.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_numeric.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_numerictypes.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_overrides.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_print.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_protocols.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_records.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_regression.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_scalar_ctors.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_scalar_methods.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_scalarbuffer.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_scalarinherit.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_scalarmath.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_scalarprint.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_shape_base.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_simd.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_simd_module.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_strings.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_ufunc.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_umath.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_umath_accuracy.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_umath_complex.cpython-310.pyc,,
+numpy/core/tests/__pycache__/test_unicode.cpython-310.pyc,,
+numpy/core/tests/_locales.py,sha256=S4x5soqF0oxpBYOE8J9Iky72O9J25IiZ8349m93pWC4,2206
+numpy/core/tests/data/astype_copy.pkl,sha256=lWSzCcvzRB_wpuRGj92spGIw-rNPFcd9hwJaRVvfWdk,716
+numpy/core/tests/data/generate_umath_validation_data.cpp,sha256=NQSRK6tJpdTsR6jxim5Ek4ty8J6HJ5JdAe0wBQlrACw,5840
+numpy/core/tests/data/recarray_from_file.fits,sha256=NA0kliz31FlLnYxv3ppzeruONqNYkuEvts5wzXEeIc4,8640
+numpy/core/tests/data/umath-validation-set-README.txt,sha256=pxWwOaGGahaRd-AlAidDfocLyrAiDp0whf5hC7hYwqM,967
+numpy/core/tests/data/umath-validation-set-arccos.csv,sha256=W_aL99bjzVjlVyd5omfDUORag8jHzx6uctedPVZgOHQ,61365
+numpy/core/tests/data/umath-validation-set-arccosh.csv,sha256=Uko_d0kDXr1YlN-6Ii-fQQxUvbXAhRfC7Un4gJ23GJk,61365
+numpy/core/tests/data/umath-validation-set-arcsin.csv,sha256=15Aenze4WD2a2dF2aOBXpv9B7u3wwAeUVJdEm4TjOkQ,61339
+numpy/core/tests/data/umath-validation-set-arcsinh.csv,sha256=uDwx4PStpfV21IaPF8pmzQpul6i72g7zDwlfcynWaVQ,60289
+numpy/core/tests/data/umath-validation-set-arctan.csv,sha256=mw5tYze_BMs6ugGEZfg5mcXoInGYdn7fvSCYSUi9Bqw,60305
+numpy/core/tests/data/umath-validation-set-arctanh.csv,sha256=95l4Uu5RmZajljabfqlv5U34RVrifCMhhkop6iLeNBo,61339
+numpy/core/tests/data/umath-validation-set-cbrt.csv,sha256=v855MTZih-fZp_GuEDst2qaIsxU4a7vlAbeIJy2xKpc,60846
+numpy/core/tests/data/umath-validation-set-cos.csv,sha256=yxd7BNaicgyEysvp8Tx2qEM-S4zVJA0f0ZXR_VG4y1E,59122
+numpy/core/tests/data/umath-validation-set-cosh.csv,sha256=FGCNeUSUTAeASsb_j18iRSsCxXLxmzF-_C7tq1elVrQ,60869
+numpy/core/tests/data/umath-validation-set-exp.csv,sha256=BKg1_cyrKD2GXYMX_EB0DnXua8DI2O1KWODXf_BRhrk,17491
+numpy/core/tests/data/umath-validation-set-exp2.csv,sha256=f1b05MRXPOXihC9M-yi52udKBzVXalhbTuIcqoDAk-g,58624
+numpy/core/tests/data/umath-validation-set-expm1.csv,sha256=_ghc1xiUECNsBGrKCFUAy2lvu01_lkpeYJN0zDtCYWk,60299
+numpy/core/tests/data/umath-validation-set-log.csv,sha256=z9ej1ykKUoMRqYMUIJENWXbYi_A_x_RKs7K_GuXZJus,11692
+numpy/core/tests/data/umath-validation-set-log10.csv,sha256=RJgpruL16FVPgUT3-3xW4eppS_tn6o5yEW79KnITn48,68922
+numpy/core/tests/data/umath-validation-set-log1p.csv,sha256=IZZI-hi55HGCOvBat3vSBVha_8Nt-5alf2fqz6QeTG0,60303
+numpy/core/tests/data/umath-validation-set-log2.csv,sha256=HL2rOCsrEi378rNrbsXHPqlWlEGkXQq8R4e63YeTksU,68917
+numpy/core/tests/data/umath-validation-set-sin.csv,sha256=5I2h5CI8Hv6L9o2mh6x5pttnL23VhhY1h5LA8cjIWTg,58611
+numpy/core/tests/data/umath-validation-set-sinh.csv,sha256=CYiibE8aX7MQnBatl__5k_PWc_9vHUifwS-sFZzzKk0,60293
+numpy/core/tests/data/umath-validation-set-tan.csv,sha256=Oq7gxMvblRVBrQ23kMxc8iT0bHnCWKg9EE4ZqzbJbOA,60299
+numpy/core/tests/data/umath-validation-set-tanh.csv,sha256=iolZF_MOyWRgYSa-SsD4df5mnyFK18zrICI740SWoTc,60299
+numpy/core/tests/examples/cython/__pycache__/setup.cpython-310.pyc,,
+numpy/core/tests/examples/cython/checks.pyx,sha256=plK9y11kHceBfR6puFLDwU8H5RBGS6ZEmqSFVq-rzOE,615
+numpy/core/tests/examples/cython/setup.py,sha256=aAR-TvQabUabnCzuB6UdWdmRXaaPfIG7MzTIfMF-0tk,496
+numpy/core/tests/examples/limited_api/__pycache__/setup.cpython-310.pyc,,
+numpy/core/tests/examples/limited_api/limited_api.c,sha256=mncE8TjjXmYpkwli433G0jB2zGQO_5NqWmGKdzRJZug,344
+numpy/core/tests/examples/limited_api/setup.py,sha256=p2w7F1ardi_GRXSrnNIR8W1oeH_pgmw_1P2wS0A2I6M,435
+numpy/core/tests/test__exceptions.py,sha256=QqxQSLXboPXEVwHz-TyE2JeIl_TC-rPugzfo25nbcns,2846
+numpy/core/tests/test_abc.py,sha256=FfgYA_HjYAi8XWGK_oOh6Zw86chB_KG_XoW_7ZlFp4c,2220
+numpy/core/tests/test_api.py,sha256=Q6qHtji9ELhHR09bOjcKwFZC0vvjeDrhne52uAHnQ4k,22434
+numpy/core/tests/test_argparse.py,sha256=rkbQloOqMiIGIdUsaZb20oHyBO3y9JFqSYr7FawdtDk,1977
+numpy/core/tests/test_array_coercion.py,sha256=hTLWAEmciIpxH157bxA0oXtSdTAxNKn4c_s9WphuAyA,32269
+numpy/core/tests/test_array_interface.py,sha256=lgfhLk8A0FBzbXE0ZWgR36aDXsw0CQKBFsUfyR0Ag7U,7596
+numpy/core/tests/test_arraymethod.py,sha256=d4lhcYQwYPpXhfuc69MPNqTO3yo39P02z5KUhOnCIa0,3570
+numpy/core/tests/test_arrayprint.py,sha256=gIGEkYDVbrnqLBc5UpFVxoCRPWh85s7kMgzlcZGqiI8,37163
+numpy/core/tests/test_casting_floatingpoint_errors.py,sha256=W3Fgk0oKtXFv684fEZ7POwj6DHTYK0Jj_oGRLZ8UdyA,5063
+numpy/core/tests/test_casting_unittests.py,sha256=9-vkR0oXczQz8ED8DxGVPmalC8IZXe2jKgOCMGr8hIg,34298
+numpy/core/tests/test_conversion_utils.py,sha256=jNhbNNI-T8qtQnsIMEax7KFN30kjh0ICntLMwTyxJ5Q,6559
+numpy/core/tests/test_cpu_dispatcher.py,sha256=JmYHyBedXNu8pPgGCegP4it6UXY0sifW4EjdM9C0f8M,1521
+numpy/core/tests/test_cpu_features.py,sha256=7CXENItSVtgjlAefnXRczQiC-VILowYHrqeeg4aGqgg,7169
+numpy/core/tests/test_custom_dtypes.py,sha256=JdvtCZNfL_KuZprE5tnZIRHmUNodCISYM7BRKOQ5QZQ,7677
+numpy/core/tests/test_cython.py,sha256=xU70VFqiyHs31qmpja4ITr6KqW7jm4mhVEyWPfEDd-U,3623
+numpy/core/tests/test_datetime.py,sha256=1E-CUQaBqGwr_zXr4nkSCjmZ0w9P7pikcnnEEem0lXU,115699
+numpy/core/tests/test_defchararray.py,sha256=V-E6mexuUA5SF6gwZCx7aBS87l0G8BBDTckLSFr4IGY,24607
+numpy/core/tests/test_deprecations.py,sha256=_sEOa8agrfokanmmtb82qHjEo8g1EIN2L5PAJaxwIpA,45494
+numpy/core/tests/test_dlpack.py,sha256=mAqacwV5eBvIaqJNwg-uKhzcn7bcQqLIgVXSsSwYWT8,3503
+numpy/core/tests/test_dtype.py,sha256=mcPfstAEKzVZVswTsVDoIgyGK90G8rRG2aSC9j3lqNA,72563
+numpy/core/tests/test_einsum.py,sha256=3tTWdEdqtD1bYF7fG5nY9P-n3YY9htIvRnv2THX4h04,50176
+numpy/core/tests/test_errstate.py,sha256=U3GT9I058jkF725mx4GdWUr9RoceCkGDV7Go79VA4wY,2219
+numpy/core/tests/test_extint128.py,sha256=gCZfAwPOb-F1TLsEEeDI0amQYwHk-60-OXi0ccZrrZ8,5643
+numpy/core/tests/test_function_base.py,sha256=MyX8TSOh251NfC6M8LHFpc-ooVj_jfP-V6l00F5wb7M,14411
+numpy/core/tests/test_getlimits.py,sha256=K2BRfqMLqidXQ8rSh4vn5z5dggwz8RGtX6Y3FS2ky9c,5306
+numpy/core/tests/test_half.py,sha256=k3p2NL9i84Z9i0Nd5nSwUUKrmwzR4KjPQFJv5nu0K8Y,24226
+numpy/core/tests/test_hashtable.py,sha256=ZV8HL8NkDnoQZfnje7BP0fyIp4fSFqjKsQc40PaTggc,1011
+numpy/core/tests/test_indexerrors.py,sha256=kN9xLl6FVTzmI7fumn_cuZ3k0omXnTetgtCnPY44cvw,5130
+numpy/core/tests/test_indexing.py,sha256=ZHaJav_X2Rlpuw3T5D1NWkdETzz3eJMlug5yBE_8Z-c,54317
+numpy/core/tests/test_item_selection.py,sha256=DGJNZRtyOxXoyY67EFwUqmLhQ04v0Kqy_QAOpEL42M0,3579
+numpy/core/tests/test_limited_api.py,sha256=5yO0nGmCKZ9b3S66QP7vY-HIgAoyOtHZmp8mvzKuOHI,1172
+numpy/core/tests/test_longdouble.py,sha256=nXQKxT10J4cQW27r3vXFAsrfuKryyWJzCZWTxMVS9WM,13042
+numpy/core/tests/test_machar.py,sha256=_5_TDUVtAJvJI5jBfEFKpCZtAfKCsCFt7tXlWSkWzzc,1067
+numpy/core/tests/test_mem_overlap.py,sha256=ucDIgmgMqor7JdE8u3FvOg_jSJPvPn0xQqyr_iWz210,29089
+numpy/core/tests/test_mem_policy.py,sha256=bhOBeByMFV7OJuRxhM6oLNWKgLf-CMU-DQChwBbGGhk,15948
+numpy/core/tests/test_memmap.py,sha256=gQ74BGUYSkLYFCYk31MrwXQX4zxN4oh3IbG1Ue6A7Xc,7483
+numpy/core/tests/test_multiarray.py,sha256=QvPc0uWmhy1mwwvYU17-mGv9PkwyV5tgW8zOE41bqbU,370512
+numpy/core/tests/test_nditer.py,sha256=WuYgv5_bp4HEcO3FRmhFmScNcizolgbtGno3u_v8ht0,129553
+numpy/core/tests/test_nep50_promotions.py,sha256=iRLK6ykMgpz9_5yjHyINZ6C3bUXWywHv2p-WqueSQLs,6460
+numpy/core/tests/test_numeric.py,sha256=tq3NCPfPAK5IcJmDbSU4e1wsRXFMxbeEh2tfFVBuEeU,137666
+numpy/core/tests/test_numerictypes.py,sha256=sw4oFBLxgyebHCuOP2h99E1VO8pU_let_yPOI0gPZJM,21260
+numpy/core/tests/test_overrides.py,sha256=kxzvLkSAPjbjGgmmrtRq8rSoLtKXmcrtmmglw67JuvE,22084
+numpy/core/tests/test_print.py,sha256=URYIP2BX0uTkkCH_-YwYp6hhyYENaV4sarPaD2rRbZc,6737
+numpy/core/tests/test_protocols.py,sha256=fEXE9K9s22oiVWkX92BY-g00-uXCK-HxjZhZxxYAKFc,1168
+numpy/core/tests/test_records.py,sha256=pluit5x6jkWoPEIrHXM13L3xZuuSSiaxoXFsOdkakCU,20269
+numpy/core/tests/test_regression.py,sha256=rOFhDiqy08v2lNjV11w9G1Gwwb0CvmK_DbC-zdwQbXU,91243
+numpy/core/tests/test_scalar_ctors.py,sha256=qDIZV-tBukwAxNDhUmGtH3CemDXlS3xd_q3L52touuA,6115
+numpy/core/tests/test_scalar_methods.py,sha256=pFjc813_JlYQfyAUD1xLP9f-hY8o8RI6ycDkS_HkloI,7872
+numpy/core/tests/test_scalarbuffer.py,sha256=5urlHsgHE9H63Tp9mlM48iRh_A1VNxSZohBntl0RnqM,5588
+numpy/core/tests/test_scalarinherit.py,sha256=vYkHz6OWLhufPnyhsAb_WFTkR1J5ocksPnsc6_14wMA,2378
+numpy/core/tests/test_scalarmath.py,sha256=qrydWu28rvsSHz1gF-RU9528sFKJ0Vum2tJM12x4oto,42813
+numpy/core/tests/test_scalarprint.py,sha256=8FkIQLdQmPH_SZ0Ps6D48T3MRTHVFZYgAKB_IxtNpaE,18694
+numpy/core/tests/test_shape_base.py,sha256=1dV4RSl0g1F_0lTGgP7YCmFL7DrlD_Ak1w9xVtwZKVw,29661
+numpy/core/tests/test_simd.py,sha256=o474F7uiTpzvkN9pOb0sPB-UGHPM80OD1tq9i6ZSbPM,43624
+numpy/core/tests/test_simd_module.py,sha256=j1iOWvtCZQFr0yHKX9jFcMT1uDPvCXPxW-za9fRy-Fo,3805
+numpy/core/tests/test_strings.py,sha256=A9t1B65lFrYRLXgDJSg3mMDAe_hypIPcTMVOdAYIbU0,3835
+numpy/core/tests/test_ufunc.py,sha256=LRWdQAwxA_JEDQzHWM-IA17QV1e2PsHAbC51tOf8X0s,116618
+numpy/core/tests/test_umath.py,sha256=-tP3WZs_VzHqaFHBT9v7JjUzdLRqHIG6KCx0a2aZ6Qg,172489
+numpy/core/tests/test_umath_accuracy.py,sha256=mFcVdzXhhD9mqhzLDJVZsWfCHbjbFQ6XeEl5G8l-PTc,3897
+numpy/core/tests/test_umath_complex.py,sha256=7_5NdvJbk80iA5G71mQvSsAD7hOG2g9B4PjdsudgCYo,23243
+numpy/core/tests/test_unicode.py,sha256=oyECvySG1o9SZmfLusE2qTExYjUMxsVcVNrYDzXZUDo,12647
+numpy/core/umath.py,sha256=JbT_SxnZ_3MEmjOI9UtX3CcAzX5Q-4RDlnnhDAEJ5Vo,2040
+numpy/core/umath_tests.py,sha256=TIzaDfrEHHgSc2J5kxFEibq8MOPhwSuyOZOUBsZNVSM,389
+numpy/ctypeslib.py,sha256=Ae4Lbhr_EJRzzXb2dNYdYPXzjAP6wS6X7XePD8Dx6kc,17460
+numpy/ctypeslib.pyi,sha256=xbs_DWIxXd9Hk4M7bfpNsCJTY_ZVMfJepuYqq7U26SM,7962
+numpy/distutils/__config__.py,sha256=TXvjW8PcKIkWSx3pLCYYC2SMqmRP-0gKkOOvckDq6Ao,5143
+numpy/distutils/__init__.py,sha256=BU1C21439HRo7yH1SsN9me6WCDPpOwRQ37ZpNwDMqCw,2074
+numpy/distutils/__init__.pyi,sha256=D8LRE6BNOmuBGO-oakJGnjT9UJTk9zSR5rxMfZzlX64,119
+numpy/distutils/__pycache__/__config__.cpython-310.pyc,,
+numpy/distutils/__pycache__/__init__.cpython-310.pyc,,
+numpy/distutils/__pycache__/_shell_utils.cpython-310.pyc,,
+numpy/distutils/__pycache__/armccompiler.cpython-310.pyc,,
+numpy/distutils/__pycache__/ccompiler.cpython-310.pyc,,
+numpy/distutils/__pycache__/ccompiler_opt.cpython-310.pyc,,
+numpy/distutils/__pycache__/conv_template.cpython-310.pyc,,
+numpy/distutils/__pycache__/core.cpython-310.pyc,,
+numpy/distutils/__pycache__/cpuinfo.cpython-310.pyc,,
+numpy/distutils/__pycache__/exec_command.cpython-310.pyc,,
+numpy/distutils/__pycache__/extension.cpython-310.pyc,,
+numpy/distutils/__pycache__/from_template.cpython-310.pyc,,
+numpy/distutils/__pycache__/intelccompiler.cpython-310.pyc,,
+numpy/distutils/__pycache__/lib2def.cpython-310.pyc,,
+numpy/distutils/__pycache__/line_endings.cpython-310.pyc,,
+numpy/distutils/__pycache__/log.cpython-310.pyc,,
+numpy/distutils/__pycache__/mingw32ccompiler.cpython-310.pyc,,
+numpy/distutils/__pycache__/misc_util.cpython-310.pyc,,
+numpy/distutils/__pycache__/msvc9compiler.cpython-310.pyc,,
+numpy/distutils/__pycache__/msvccompiler.cpython-310.pyc,,
+numpy/distutils/__pycache__/npy_pkg_config.cpython-310.pyc,,
+numpy/distutils/__pycache__/numpy_distribution.cpython-310.pyc,,
+numpy/distutils/__pycache__/pathccompiler.cpython-310.pyc,,
+numpy/distutils/__pycache__/setup.cpython-310.pyc,,
+numpy/distutils/__pycache__/system_info.cpython-310.pyc,,
+numpy/distutils/__pycache__/unixccompiler.cpython-310.pyc,,
+numpy/distutils/_shell_utils.py,sha256=kMLOIoimB7PdFRgoVxCIyCFsIl1pP3d0hkm_s3E9XdA,2613
+numpy/distutils/armccompiler.py,sha256=8qUaYh8QHOJlz7MNvkuJNyYdCOCivuW0pbmf_2OPZu0,962
+numpy/distutils/ccompiler.py,sha256=YkP9IhAaujo6eGTqv2JbooxpA2xVa8va4JlRp4IPkwg,28126
+numpy/distutils/ccompiler_opt.py,sha256=3CtzyP7K62R7pDARzFkZURxaWlVPsvREzXCCIZK_mI0,100034
+numpy/distutils/checks/cpu_asimd.c,sha256=nXUsTLrSlhRL-UzDM8zMqn1uqJnR7TRlJi3Ixqw539w,818
+numpy/distutils/checks/cpu_asimddp.c,sha256=E4b9zT1IdSfGR2ACZJiQoR-BqaeDtzFqRNW8lBOXAaY,432
+numpy/distutils/checks/cpu_asimdfhm.c,sha256=6tXINVEpmA-lYRSbL6CrBu2ejNFmd9WONFGgg-JFXZE,529
+numpy/distutils/checks/cpu_asimdhp.c,sha256=SfwrEEA_091tmyI4vN3BNLs7ypUnrF_VbTg6gPl-ocs,379
+numpy/distutils/checks/cpu_avx.c,sha256=LuZW8o93VZZi7cYEP30dvKWTm7Mw1TLmCt5UaXDxCJg,779
+numpy/distutils/checks/cpu_avx2.c,sha256=jlDlea393op0JOiMJgmmPyKmyAXztLcObPOp9F9FaS0,749
+numpy/distutils/checks/cpu_avx512_clx.c,sha256=P-YHjj2XE4SithBkPwDgShOxGWnVSNUXg72h8O3kpbs,842
+numpy/distutils/checks/cpu_avx512_cnl.c,sha256=f_c2Z0xwAKTJeK3RYMIp1dgXYV8QyeOxUgKkMht4qko,948
+numpy/distutils/checks/cpu_avx512_icl.c,sha256=isI35-gm7Hqn2Qink5hP1XHWlh52a5vwKhEdW_CRviE,1004
+numpy/distutils/checks/cpu_avx512_knl.c,sha256=Veq4zNRDDqABV1dPyYdpyPzqZnEBrRsPsTZU1ebPi_Y,956
+numpy/distutils/checks/cpu_avx512_knm.c,sha256=eszPGr3XC9Js7mQUB0gFxlrNjQwfucQFz_UwFyNLjes,1132
+numpy/distutils/checks/cpu_avx512_skx.c,sha256=59VD8ebEJJHLlbY-4dakZV34bmq_lr9mBKz8BAcsdYc,1010
+numpy/distutils/checks/cpu_avx512cd.c,sha256=Qfh5FJUv9ZWd_P5zxkvYYIkvqsPptgaDuKkeX_F8vyA,759
+numpy/distutils/checks/cpu_avx512f.c,sha256=d97NRcbJhqpvURnw7zyG0TOuEijKXvU0g4qOTWHbwxY,755
+numpy/distutils/checks/cpu_f16c.c,sha256=nzZzpUc8AfTtw-INR3KOxcjx9pyzVUM8OhsrdH2dO_w,868
+numpy/distutils/checks/cpu_fma3.c,sha256=YN6IDwuZALJHVVmpQ2tj-14HI_PcxH_giV8-XjzlmkU,817
+numpy/distutils/checks/cpu_fma4.c,sha256=qKdgTNNFg-n8vSB1Txco60HBLCcOi1aH23gZOX7yKqs,301
+numpy/distutils/checks/cpu_neon.c,sha256=Y0SjuVLzh3upcbY47igHjmKgjHbXxbvzncwB7acfjxw,600
+numpy/distutils/checks/cpu_neon_fp16.c,sha256=E7YOGyYP41u1sqiCHpCGGqjmo7Cs6yUkmJ46K7LZloc,251
+numpy/distutils/checks/cpu_neon_vfpv4.c,sha256=qFY1C_fQYz7M_a_8j0KTdn7vaE3NNVmWY2JGArDGM3w,609
+numpy/distutils/checks/cpu_popcnt.c,sha256=vRcXHVw2j1F9I_07eIZ_xzDX3fd3mqgiQXL1w3pULJk,1049
+numpy/distutils/checks/cpu_sse.c,sha256=6MHITtC76UpSR9uh0SiURpnkpPkLzT5tbrcXT4xBFxo,686
+numpy/distutils/checks/cpu_sse2.c,sha256=yUZzdjDtBS-vYlhfP-pEzj3m0UPmgZs-hA99TZAEACU,697
+numpy/distutils/checks/cpu_sse3.c,sha256=j5XRHumUuccgN9XPZyjWUUqkq8Nu8XCSWmvUhmJTJ08,689
+numpy/distutils/checks/cpu_sse41.c,sha256=y_k81P-1b-Hx8OeRVDE9V1O9JakS0zPvlFKJ3VbSmEw,675
+numpy/distutils/checks/cpu_sse42.c,sha256=3PXucdI2mII-txO7zFN99TlVveT_QUAETTGvRk-_hYw,692
+numpy/distutils/checks/cpu_ssse3.c,sha256=X6VWxIXMRpdSCBsHPXvot3yTZ4d5yK9Bi1ScQP3WC-Q,705
+numpy/distutils/checks/cpu_vsx.c,sha256=FVmR4iliKjcihzMCwloR1F2JYwSZK9P4f_hvIRLHSDQ,478
+numpy/distutils/checks/cpu_vsx2.c,sha256=yESs25Rt5ztb5-stuYbu3TbiyJKmllMpMLu01GOAHqE,263
+numpy/distutils/checks/cpu_vsx3.c,sha256=omC50tbEZNigsKMFPtE3zGRlIS2VuDTm3vZ9TBZWo4U,250
+numpy/distutils/checks/cpu_vsx4.c,sha256=ngezA1KuINqJkLAcMrZJR7bM0IeA25U6I-a5aISGXJo,305
+numpy/distutils/checks/cpu_vx.c,sha256=OpLU6jIfwvGJR4JPVVZLlUfvo7oAZ0YvsjafM2qtPlk,461
+numpy/distutils/checks/cpu_vxe.c,sha256=rYW_nKwXnlB0b8xCrJEr4TmvrEvS-NToxwyqqOHV8Bk,788
+numpy/distutils/checks/cpu_vxe2.c,sha256=Hv4wO23kwC2G6lqqercq4NE4K0nrvBxR7RIzr5HTXCc,624
+numpy/distutils/checks/cpu_xop.c,sha256=7uabsGeqvmVJQvuSEjs8-Sm8kpmvl6uZ9YHMF5h2opQ,234
+numpy/distutils/checks/extra_avx512bw_mask.c,sha256=pVPOhcu80yJVnIhOcHHXOlZ2proJ1MUf0XgccqhPoNk,636
+numpy/distutils/checks/extra_avx512dq_mask.c,sha256=nMfIvepISGFDexPrMYl5LWtdmt6Uy9TKPzF4BVayw2I,504
+numpy/distutils/checks/extra_avx512f_reduce.c,sha256=_NfbtfSAkm_A67umjR1oEb9yRnBL5EnTA76fvQIuNVk,1595
+numpy/distutils/checks/extra_vsx4_mma.c,sha256=GiQGZ9-6wYTgH42bJgSlXhWcTIrkjh5xv4uymj6rglk,499
+numpy/distutils/checks/extra_vsx_asm.c,sha256=BngiMVS9nyr22z6zMrOrHLeCloe_5luXhf5T5mYucgI,945
+numpy/distutils/checks/test_flags.c,sha256=uAIbhfAhyGe4nTdK_mZmoCefj9P0TGHNF9AUv_Cdx5A,16
+numpy/distutils/command/__init__.py,sha256=fW49zUB3syMFsKpf1oRBO0h8tmnTwRP3zUPrsB0R22M,1032
+numpy/distutils/command/__pycache__/__init__.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/autodist.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/bdist_rpm.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/build.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/build_clib.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/build_ext.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/build_py.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/build_scripts.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/build_src.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/config.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/config_compiler.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/develop.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/egg_info.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/install.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/install_clib.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/install_data.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/install_headers.cpython-310.pyc,,
+numpy/distutils/command/__pycache__/sdist.cpython-310.pyc,,
+numpy/distutils/command/autodist.py,sha256=8KWwr5mnjX20UpY4ITRDx-PreApyh9M7B92IwsEtTsQ,3718
+numpy/distutils/command/bdist_rpm.py,sha256=-tkZupIJr_jLqeX7xbRhE8-COXHRI0GoRpAKchVte54,709
+numpy/distutils/command/build.py,sha256=aj1SUGsDUTxs4Tch2ALLcPnuAVhaPjEPIZIobzMajm0,2613
+numpy/distutils/command/build_clib.py,sha256=qbxvwF5n8kfGSsL7H5BS7zguUYZss0X3kct8U20JQio,19235
+numpy/distutils/command/build_ext.py,sha256=JO0k5M9Ic7-7HNm8VV7P_-0WqkVmScEnl89Xu8MeBwk,32243
+numpy/distutils/command/build_py.py,sha256=XiLZ2d_tmCE8uG5VAU5OK2zlzQayBfeY4l8FFEltbig,1144
+numpy/distutils/command/build_scripts.py,sha256=P2ytmZb3UpwfmbMXkFB2iMQk15tNUCynzMATllmp-Gs,1665
+numpy/distutils/command/build_src.py,sha256=Lw3JsmSdi_DpWCtCxU4X5iYC6da5vkOhXzCrnlrgS98,31172
+numpy/distutils/command/config.py,sha256=SdN-Cxvwx3AD5k-Xx_VyS2WWpVGmflnYGiTIyruj_xM,20670
+numpy/distutils/command/config_compiler.py,sha256=Cp9RTpW72gg8XC_3-9dCTlLYr352pBfBRZA8YBWvOoY,4369
+numpy/distutils/command/develop.py,sha256=9SbbnFnVbSJVZxTFoV9pwlOcM1D30GnOWm2QonQDvHI,575
+numpy/distutils/command/egg_info.py,sha256=i-Zk4sftK5cMQVQ2jqSxTMpVI-gYyXN16-p5TvmjURc,921
+numpy/distutils/command/install.py,sha256=wZfVabAMw-Y3tiAKcXTxC-So65RHo3zCy1ucoTmyECw,3078
+numpy/distutils/command/install_clib.py,sha256=1xv0_lPVu3g16GgICjjlh7T8zQ6PSlevCuq8Bocx5YM,1399
+numpy/distutils/command/install_data.py,sha256=Y59EBG61MWP_5C8XJvSCVfzYpMNVNVcH_Z6c0qgr9KA,848
+numpy/distutils/command/install_headers.py,sha256=tVpOGqkmh8AA_tam0K0SeCd4kvZj3UqSOjWKm6Kz4jY,919
+numpy/distutils/command/sdist.py,sha256=8Tsju1RwXNbPyQcjv8GRMFveFQqYlbNdSZh2X1OV-VU,733
+numpy/distutils/conv_template.py,sha256=F-4vkkfAjCb-fN79WYrXX3BMHMoiQO-W2u09q12OPuI,9536
+numpy/distutils/core.py,sha256=QBJNJdIE0a9Rr4lo-3QnmEaWyVV068l6HbVPdJ75iZg,8173
+numpy/distutils/cpuinfo.py,sha256=XuNhsx_-tyrui_AOgn10yfZ9p4YBM68vW2_bGmKj07I,22639
+numpy/distutils/exec_command.py,sha256=0EGasX7tM47Q0k8yJA1q-BvIcjV_1UAC-zDmen-j6Lg,10283
+numpy/distutils/extension.py,sha256=YgeB8e2fVc2l_1etuRBv0P8c1NULOz4SaudHgsVBc30,3568
+numpy/distutils/fcompiler/__init__.py,sha256=aqsZMwMUfeNC56YwATyfs9G8dDrQ1JkdnF2Ah2ZTShQ,40535
+numpy/distutils/fcompiler/__pycache__/__init__.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/absoft.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/arm.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/compaq.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/environment.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/fujitsu.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/g95.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/gnu.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/hpux.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/ibm.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/intel.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/lahey.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/mips.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/nag.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/none.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/nv.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/pathf95.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/pg.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/sun.cpython-310.pyc,,
+numpy/distutils/fcompiler/__pycache__/vast.cpython-310.pyc,,
+numpy/distutils/fcompiler/absoft.py,sha256=NJxm5Qpiv9F1Z5VClIXwXKGmJoCCEDSZmZthJQZS2Rs,5499
+numpy/distutils/fcompiler/arm.py,sha256=MCri346qo1bYwjlm32xHRyRl-bAINTlfVIubN6HDz68,2090
+numpy/distutils/fcompiler/compaq.py,sha256=sjU2GKHJGuChtRb_MhnouMqvkIOQflmowFE6ErCWZhE,3903
+numpy/distutils/fcompiler/environment.py,sha256=DOD2FtKDk6O9k6U0h9UKWQ-65wU8z1tSPn3gUlRwCso,3080
+numpy/distutils/fcompiler/fujitsu.py,sha256=yK3wdHoF5qq25UcnIM6FzTXsJGJxdfKa_f__t04Ne7M,1333
+numpy/distutils/fcompiler/g95.py,sha256=FH4uww6re50OUT_BfdoWSLCDUqk8LvmQ2_j5RhF5nLQ,1330
+numpy/distutils/fcompiler/gnu.py,sha256=ag8v_pp-fYpDPKJsVmNaFwN621b1MFQAxew0T1KdE_Y,20502
+numpy/distutils/fcompiler/hpux.py,sha256=gloUjWGo7MgJmukorDq7ZxDnnUKXx-C6AQfryQshVM4,1353
+numpy/distutils/fcompiler/ibm.py,sha256=W7r6W7kvGPBuWsrv-VsDHEUTq7bS73l4dVIU1ipm-IA,3539
+numpy/distutils/fcompiler/intel.py,sha256=XYF0GLVhJWjS8noEx4TJ704Eqt-JGBolRZEOkwgNItE,6570
+numpy/distutils/fcompiler/lahey.py,sha256=U63KMfN8zDAd_jnvMkS2N-dvP4UiSRB9Ces290qLNXw,1327
+numpy/distutils/fcompiler/mips.py,sha256=LAwT0DY5yqlYh20hNMYR1-OKu8A9GNw-TbUfI8pvglM,1714
+numpy/distutils/fcompiler/nag.py,sha256=9pQCMUlwjRVHGKwZxvwd4bW5p-9v7VXcflELEImHg1g,2777
+numpy/distutils/fcompiler/none.py,sha256=6RX2X-mV1HuhJZnVfQmDmLVhIUWseIT4P5wf3rdLq9Y,758
+numpy/distutils/fcompiler/nv.py,sha256=LGBQY417zibQ-fnPis5rNtP_I1Qk9OlhEFOnPvmwXHI,1560
+numpy/distutils/fcompiler/pathf95.py,sha256=MiHVar6-beUEYVEpqXORIX4f8G29I47D36kreltdfoQ,1061
+numpy/distutils/fcompiler/pg.py,sha256=NOB1stzrjvQMZS7bIPTgWTcAFe3cjNveA5-SztUZqD0,3568
+numpy/distutils/fcompiler/sun.py,sha256=mfS3RTj9uYT6K9Ikp8RjmsEPIWAtUTzMhX9sGjEyF6I,1577
+numpy/distutils/fcompiler/vast.py,sha256=Xuxa4sNraUPcQmt45SogAfN0kDHFb6C73uNZNmX3RBE,1667
+numpy/distutils/from_template.py,sha256=hpoFQortsLZdMSr_fJILzXzrIwFlZoFjsDSo6jNtvWs,7913
+numpy/distutils/intelccompiler.py,sha256=N_pvWjlLORdlH34cs97oU4LBNr_s9r5ddsmme7XEvs4,4234
+numpy/distutils/lib2def.py,sha256=-3rDf9FXsDik3-Qpp-A6N_cYZKTlmVjVi4Jzyo-pSlY,3630
+numpy/distutils/line_endings.py,sha256=a8ZZECrPRffsbs0UygeR47_fOUlZppnx-QPssrIXtB0,2032
+numpy/distutils/log.py,sha256=m8caNBwPhIG7YTnD9iq9jjc6_yJOeU9FHuau2CSulds,2879
+numpy/distutils/mingw/gfortran_vs2003_hack.c,sha256=cbsN3Lk9Hkwzr9c-yOP2xEBg1_ml1X7nwAMDWxGjzc8,77
+numpy/distutils/mingw32ccompiler.py,sha256=jTD1yAsYi0TSww0-5ndtsbDjx5WYRHPH4pPe6lhcpqI,22076
+numpy/distutils/misc_util.py,sha256=teoJQKXYxkMqBzGCfkJX12VwG9dcOG8QpukgJITH1cM,89369
+numpy/distutils/msvc9compiler.py,sha256=FCtP7g34AVuMIaqQlH8AV1ZBdIUXbk5G7eBeeTSr1zE,2192
+numpy/distutils/msvccompiler.py,sha256=ILookUifVJF9tAtPJoVCqZ673m5od6MVKuAHuA3Rcfk,2647
+numpy/distutils/npy_pkg_config.py,sha256=fIFyWLTqRySO3hn-0i0FNdHeblRN_hDv-wc68-sa3hQ,12972
+numpy/distutils/numpy_distribution.py,sha256=10Urolg1aDAG0EHYfcvObzOgqRV0ARh2GhDklEg4vS0,634
+numpy/distutils/pathccompiler.py,sha256=KnJEA5H4cXg7SLrMjwWtidD24VSvOdu72d17votiY9E,713
+numpy/distutils/setup.py,sha256=l9ke_Bws431UdBfysaq7ZeGtZ8dix76oh9Huq5qqbkU,634
+numpy/distutils/system_info.py,sha256=9jHSv4qtDjVbSqiy9eKmRpSKY7WRwzKL7AEcNctxY6g,111028
+numpy/distutils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/distutils/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_build_ext.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_ccompiler_opt.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_ccompiler_opt_conf.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_exec_command.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_fcompiler.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_fcompiler_gnu.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_fcompiler_intel.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_fcompiler_nagfor.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_from_template.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_log.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_mingw32ccompiler.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_misc_util.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_npy_pkg_config.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_shell_utils.cpython-310.pyc,,
+numpy/distutils/tests/__pycache__/test_system_info.cpython-310.pyc,,
+numpy/distutils/tests/test_build_ext.py,sha256=RNrEi-YMTGQG5YDi5GWL8iJRkk_bQHBQKcqp43TdJco,2769
+numpy/distutils/tests/test_ccompiler_opt.py,sha256=TGkOrqyYXOnzlr8yKR1GRaqkfV9LIc7sToHLXuha8F0,28763
+numpy/distutils/tests/test_ccompiler_opt_conf.py,sha256=maXytv39amuojbQIieIGIXMV4Cv-s0fsPMZeFEh9XyY,6347
+numpy/distutils/tests/test_exec_command.py,sha256=BK-hHfIIrkCep-jNmS5_Cwq5oESvsvX3V_0XDAkT1Ok,7395
+numpy/distutils/tests/test_fcompiler.py,sha256=mJXezTXDUbduhCwVGAfABHpEARWhnj8hLW9EOU3rn84,1277
+numpy/distutils/tests/test_fcompiler_gnu.py,sha256=nmfaFCVzbViIOQ2-MjgXt-bN8Uj674hCgiwr5Iol-_U,2136
+numpy/distutils/tests/test_fcompiler_intel.py,sha256=mxkfFD2rNfg8nn1pp_413S0uCdYXydPWBcz9ilgGkA0,1058
+numpy/distutils/tests/test_fcompiler_nagfor.py,sha256=CKEjik7YVfSJGL4abuctkmlkIUhAhv-x2aUcXiTR9b0,1102
+numpy/distutils/tests/test_from_template.py,sha256=SDYoe0XUpAayyEQDq7ZhrvEEz7U9upJDLYzhcdoVifc,1103
+numpy/distutils/tests/test_log.py,sha256=0tSM4q-00CjbMIRb9QOJzI4A7GHUiRGOG1SOOLz8dnM,868
+numpy/distutils/tests/test_mingw32ccompiler.py,sha256=rMC8-IyBOiuZVfAoklV_KnD9qVeB_hFVvb5dStxfk08,1609
+numpy/distutils/tests/test_misc_util.py,sha256=Qs96vTr8GZSyVCWuamzcNlVMRa15vt0Y-T2yZSUm_QA,3218
+numpy/distutils/tests/test_npy_pkg_config.py,sha256=apGrmViPcXoPCEOgDthJgL13C9N0qQMs392QjZDxJd4,2557
+numpy/distutils/tests/test_shell_utils.py,sha256=UKU_t5oIa_kVMv89Ys9KN6Z_Fy5beqPDUsDAWPmcoR8,2114
+numpy/distutils/tests/test_system_info.py,sha256=BZLAIYdTxASkBeiPNPWDE9MHyiVL-KhcpX3g9nzQClo,11009
+numpy/distutils/unixccompiler.py,sha256=fN4-LH6JJp44SLE7JkdG2kKQlK4LC8zuUpVC-RtmJ-U,5426
+numpy/doc/__init__.py,sha256=OYmE-F6x0CD05PCDY2MiW1HLlwB6i9vhDpk-a3r4lHY,508
+numpy/doc/__pycache__/__init__.cpython-310.pyc,,
+numpy/doc/__pycache__/constants.cpython-310.pyc,,
+numpy/doc/__pycache__/ufuncs.cpython-310.pyc,,
+numpy/doc/constants.py,sha256=PlXoj7b4A8Aa9nADbg83uzTBRJaX8dvJmEdbn4FDPPo,9155
+numpy/doc/ufuncs.py,sha256=i1alLg19mNyCFZ2LYSOZGm--RsRN1x63U_UYU-N3x60,5357
+numpy/dual.py,sha256=aWZFc7rFVWLoWs9M4-nhf_S131RvsLRUdZrMIag_AzU,2214
+numpy/f2py/__init__.py,sha256=Bw8AsdY1o7Oj-fVMbS8x0lfMsUOjEIwyLKOV0FVCMV8,5227
+numpy/f2py/__init__.pyi,sha256=Hg1AY3we-8hmhXq1fsFrTaUe5TD_FvIxkJIDiw5eI8Y,1107
+numpy/f2py/__main__.py,sha256=6i2jVH2fPriV1aocTY_dUFvWK18qa-zjpnISA-OpF3w,130
+numpy/f2py/__pycache__/__init__.cpython-310.pyc,,
+numpy/f2py/__pycache__/__main__.cpython-310.pyc,,
+numpy/f2py/__pycache__/__version__.cpython-310.pyc,,
+numpy/f2py/__pycache__/auxfuncs.cpython-310.pyc,,
+numpy/f2py/__pycache__/capi_maps.cpython-310.pyc,,
+numpy/f2py/__pycache__/cb_rules.cpython-310.pyc,,
+numpy/f2py/__pycache__/cfuncs.cpython-310.pyc,,
+numpy/f2py/__pycache__/common_rules.cpython-310.pyc,,
+numpy/f2py/__pycache__/crackfortran.cpython-310.pyc,,
+numpy/f2py/__pycache__/diagnose.cpython-310.pyc,,
+numpy/f2py/__pycache__/f2py2e.cpython-310.pyc,,
+numpy/f2py/__pycache__/f90mod_rules.cpython-310.pyc,,
+numpy/f2py/__pycache__/func2subr.cpython-310.pyc,,
+numpy/f2py/__pycache__/rules.cpython-310.pyc,,
+numpy/f2py/__pycache__/setup.cpython-310.pyc,,
+numpy/f2py/__pycache__/symbolic.cpython-310.pyc,,
+numpy/f2py/__pycache__/use_rules.cpython-310.pyc,,
+numpy/f2py/__version__.py,sha256=7HHdjR82FCBmftwMRyrlhcEj-8mGQb6oCH-wlUPH4Nw,34
+numpy/f2py/auxfuncs.py,sha256=t8mxpgOS4dG0NDG93ef5QRA6w4qU0Zod7t6n7oNWRn0,22703
+numpy/f2py/capi_maps.py,sha256=G0hc7pEtAsUTRsPmaZs8QyqkhL72NwEvMtzlAB4H29s,33008
+numpy/f2py/cb_rules.py,sha256=osSAGP1A4ARNjsfRJmYLkZjrBqaWkQQh5rao8q1vjZw,25039
+numpy/f2py/cfuncs.py,sha256=RyTDK7IoHAur-OrGmgB8pkENK-CaLXaL4YippNO3p5E,51359
+numpy/f2py/common_rules.py,sha256=jvbAHF1YESIuG-vQRiNwQ8KLwfMyMlX9ZugL-R4Fbtc,5089
+numpy/f2py/crackfortran.py,sha256=4Myc3FOry8RErUWs7xfegZ1m7KSFrjfYYJEZWLH_C3E,138973
+numpy/f2py/diagnose.py,sha256=W59xcrGVf-1ed9FkQgCxgW0d9a2lENaxHUpYVAZ2w00,5230
+numpy/f2py/f2py2e.py,sha256=LYDZRmF4McQV68jOkjg-JHk1MhAU5z0YVgLEkFsE_5k,24626
+numpy/f2py/f90mod_rules.py,sha256=OSPvisoDck70-XtgGLbU9rsM-m8Oc91ti_uu8E8Q-bA,9436
+numpy/f2py/func2subr.py,sha256=liQ_LDFX86eL_5LTHj0a8yq1_QPMymLpylsd60WeQOg,9454
+numpy/f2py/rules.py,sha256=cD2sEEQbgWp5KmC0Oy8gBuckmsu2KwtZH4x4R2mqIq8,62755
+numpy/f2py/setup.py,sha256=9QD603_UEa1HAuJHtoNY2twKwDKoepk72ikyKQpwhjM,2335
+numpy/f2py/src/fortranobject.c,sha256=Wdy2jEoqdcsOi5wdDzjfRCKNiRboC1vMpKkUiDh8yxc,46010
+numpy/f2py/src/fortranobject.h,sha256=neMKotYWbHvrhW9KXz4QzQ8fzPkiQXLHHjy82vLSeog,5835
+numpy/f2py/symbolic.py,sha256=3ERySC3mYO8-NfAfTDmMOd0yfPuYs8kceqxTXKFbpZA,53004
+numpy/f2py/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/f2py/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_abstract_interface.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_array_from_pyobj.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_assumed_shape.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_block_docstring.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_callback.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_character.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_common.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_compile_function.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_crackfortran.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_docs.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_f2cmap.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_f2py2e.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_kind.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_mixed.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_module_doc.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_parameter.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_quoted_character.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_regression.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_return_character.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_return_complex.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_return_integer.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_return_logical.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_return_real.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_semicolon_split.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_size.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_string.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_symbolic.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/test_value_attrspec.cpython-310.pyc,,
+numpy/f2py/tests/__pycache__/util.cpython-310.pyc,,
+numpy/f2py/tests/src/abstract_interface/foo.f90,sha256=JFU2w98cB_XNwfrqNtI0yDTmpEdxYO_UEl2pgI_rnt8,658
+numpy/f2py/tests/src/abstract_interface/gh18403_mod.f90,sha256=gvQJIzNtvacWE0dhysxn30-iUeI65Hpq7DiE9oRauz8,105
+numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c,sha256=Ff5wHYV9-OJnZuelfFWcjAibRvDkEIlbTVczTyv6TG8,7299
+numpy/f2py/tests/src/assumed_shape/.f2py_f2cmap,sha256=But9r9m4iL7EGq_haMW8IiQ4VivH0TgUozxX4pPvdpE,29
+numpy/f2py/tests/src/assumed_shape/foo_free.f90,sha256=oBwbGSlbr9MkFyhVO2aldjc01dr9GHrMrSiRQek8U64,460
+numpy/f2py/tests/src/assumed_shape/foo_mod.f90,sha256=rfzw3QdI-eaDSl-hslCgGpd5tHftJOVhXvb21Y9Gf6M,499
+numpy/f2py/tests/src/assumed_shape/foo_use.f90,sha256=rmT9k4jP9Ru1PLcGqepw9Jc6P9XNXM0axY7o4hi9lUw,269
+numpy/f2py/tests/src/assumed_shape/precision.f90,sha256=r08JeTVmTTExA-hYZ6HzaxVwBn1GMbPAuuwBhBDtJUk,130
+numpy/f2py/tests/src/block_docstring/foo.f,sha256=y7lPCPu7_Fhs_Tf2hfdpDQo1bhtvNSKRaZAOpM_l3dg,97
+numpy/f2py/tests/src/callback/foo.f,sha256=C1hjfpRCQWiOVVzIHqnsYcnLrqQcixrnHCn8hd9GhVk,1254
+numpy/f2py/tests/src/callback/gh17797.f90,sha256=_Nrl0a2HgUbtymGU0twaJ--7rMa1Uco2A3swbWvHoMo,148
+numpy/f2py/tests/src/callback/gh18335.f90,sha256=NraOyKIXyvv_Y-3xGnmTjtNjW2Znsnlk8AViI8zfovc,506
+numpy/f2py/tests/src/cli/hi77.f,sha256=ttyI6vAP3qLnDqy82V04XmoqrXNM6uhMvvLri2p0dq0,71
+numpy/f2py/tests/src/cli/hiworld.f90,sha256=QWOLPrTxYQu1yrEtyQMbM0fE9M2RmXe7c185KnD5x3o,51
+numpy/f2py/tests/src/common/block.f,sha256=GQ0Pd-VMX3H3a-__f2SuosSdwNXHpBqoGnQDjf8aG9g,224
+numpy/f2py/tests/src/crackfortran/accesstype.f90,sha256=-5Din7YlY1TU7tUHD2p-_DSTxGBpDsWYNeT9WOwGhno,208
+numpy/f2py/tests/src/crackfortran/foo_deps.f90,sha256=CaH7mnWTG7FcnJe2vXN_0zDbMadw6NCqK-JJ2HmDjK8,128
+numpy/f2py/tests/src/crackfortran/gh15035.f,sha256=jJly1AzF5L9VxbVQ0vr-sf4LaUo4eQzJguhuemFxnvg,375
+numpy/f2py/tests/src/crackfortran/gh17859.f,sha256=7K5dtOXGuBDAENPNCt-tAGJqTfNKz5OsqVSk16_e7Es,340
+numpy/f2py/tests/src/crackfortran/gh2848.f90,sha256=gPNasx98SIf7Z9ibk_DHiGKCvl7ERtsfoGXiFDT7FbM,282
+numpy/f2py/tests/src/crackfortran/operators.f90,sha256=-Fc-qjW1wBr3Dkvdd5dMTrt0hnjnV-1AYo-NFWcwFSo,1184
+numpy/f2py/tests/src/crackfortran/privatemod.f90,sha256=7bubZGMIn7iD31wDkjF1TlXCUM7naCIK69M9d0e3y-U,174
+numpy/f2py/tests/src/crackfortran/publicmod.f90,sha256=Pnwyf56Qd6W3FUH-ZMgnXEYkb7gn18ptNTdwmGan0Jo,167
+numpy/f2py/tests/src/crackfortran/pubprivmod.f90,sha256=eYpJwBYLKGOxVbKgEqfny1znib-b7uYhxcRXIf7uwXg,165
+numpy/f2py/tests/src/crackfortran/unicode_comment.f90,sha256=aINLh6GlfTwFewxvDoqnMqwuCNb4XAqi5Nj5vXguXYs,98
+numpy/f2py/tests/src/f2cmap/.f2py_f2cmap,sha256=iUOtfHd3OuT1Rz2-yiSgt4uPKGvCt5AzQ1iygJt_yjg,82
+numpy/f2py/tests/src/f2cmap/isoFortranEnvMap.f90,sha256=Jc20TOyOB4up6ZlPTgVX5qqfZFutYZ6rLKA7wSNNGw0,298
+numpy/f2py/tests/src/kind/foo.f90,sha256=zIHpw1KdkWbTzbXb73hPbCg4N2Htj3XL8DIwM7seXpo,347
+numpy/f2py/tests/src/mixed/foo.f,sha256=90zmbSHloY1XQYcPb8B5d9bv9mCZx8Z8AMTtgDwJDz8,85
+numpy/f2py/tests/src/mixed/foo_fixed.f90,sha256=pxKuPzxF3Kn5khyFq9ayCsQiolxB3SaNtcWaK5j6Rv4,179
+numpy/f2py/tests/src/mixed/foo_free.f90,sha256=fIQ71wrBc00JUAVUj_r3QF9SdeNniBiMw6Ly7CGgPWU,139
+numpy/f2py/tests/src/module_data/mod.mod,sha256=EkjrU7NTZrOH68yKrz6C_eyJMSFSxGgC2yMQT9Zscek,412
+numpy/f2py/tests/src/module_data/module_data_docstring.f90,sha256=tDZ3fUlazLL8ThJm3VwNGJ75QIlLcW70NnMFv-JA4W0,224
+numpy/f2py/tests/src/negative_bounds/issue_20853.f90,sha256=fdOPhRi7ipygwYCXcda7p_dlrws5Hd2GlpF9EZ-qnck,157
+numpy/f2py/tests/src/parameter/constant_both.f90,sha256=-bBf2eqHb-uFxgo6Q7iAtVUUQzrGFqzhHDNaxwSICfQ,1939
+numpy/f2py/tests/src/parameter/constant_compound.f90,sha256=re7pfzcuaquiOia53UT7qNNrTYu2euGKOF4IhoLmT6g,469
+numpy/f2py/tests/src/parameter/constant_integer.f90,sha256=nEmMLitKoSAG7gBBEQLWumogN-KS3DBZOAZJWcSDnFw,612
+numpy/f2py/tests/src/parameter/constant_non_compound.f90,sha256=IcxESVLKJUZ1k9uYKoSb8Hfm9-O_4rVnlkiUU2diy8Q,609
+numpy/f2py/tests/src/parameter/constant_real.f90,sha256=quNbDsM1Ts2rN4WtPO67S9Xi_8l2cXabWRO00CPQSSQ,610
+numpy/f2py/tests/src/quoted_character/foo.f,sha256=WjC9D9171fe2f7rkUAZUvik9bkIf9adByfRGzh6V0cM,482
+numpy/f2py/tests/src/regression/inout.f90,sha256=CpHpgMrf0bqA1W3Ozo3vInDz0RP904S7LkpdAH6ODck,277
+numpy/f2py/tests/src/return_character/foo77.f,sha256=WzDNF3d_hUDSSZjtxd3DtE-bSx1ilOMEviGyYHbcFgM,980
+numpy/f2py/tests/src/return_character/foo90.f90,sha256=ULcETDEt7gXHRzmsMhPsGG4o3lGrcx-FEFaJsPGFKyA,1248
+numpy/f2py/tests/src/return_complex/foo77.f,sha256=8ECRJkfX82oFvGWKbIrCvKjf5QQQClx4sSEvsbkB6A8,973
+numpy/f2py/tests/src/return_complex/foo90.f90,sha256=c1BnrtWwL2dkrTr7wvlEqNDg59SeNMo3gyJuGdRwcDw,1238
+numpy/f2py/tests/src/return_integer/foo77.f,sha256=_8k1evlzBwvgZ047ofpdcbwKdF8Bm3eQ7VYl2Y8b5kA,1178
+numpy/f2py/tests/src/return_integer/foo90.f90,sha256=bzxbYtofivGRYH35Ang9ScnbNsVERN8-6ub5-eI-LGQ,1531
+numpy/f2py/tests/src/return_logical/foo77.f,sha256=FxiF_X0HkyXHzJM2rLyTubZJu4JB-ObLnVqfZwAQFl8,1188
+numpy/f2py/tests/src/return_logical/foo90.f90,sha256=9KmCe7yJYpi4ftkKOM3BCDnPOdBPTbUNrKxY3p37O14,1531
+numpy/f2py/tests/src/return_real/foo77.f,sha256=ZTrzb6oDrIDPlrVWP3Bmtkbz3ffHaaSQoXkfTGtCuFE,933
+numpy/f2py/tests/src/return_real/foo90.f90,sha256=gZuH5lj2lG6gqHlH766KQ3J4-Ero-G4WpOOo2MG3ohU,1194
+numpy/f2py/tests/src/size/foo.f90,sha256=IlFAQazwBRr3zyT7v36-tV0-fXtB1d7WFp6S1JVMstg,815
+numpy/f2py/tests/src/string/char.f90,sha256=ihr_BH9lY7eXcQpHHDQhFoKcbu7VMOX5QP2Tlr7xlaM,618
+numpy/f2py/tests/src/string/fixed_string.f90,sha256=5n6IkuASFKgYICXY9foCVoqndfAY0AQZFEK8L8ARBGM,695
+numpy/f2py/tests/src/string/scalar_string.f90,sha256=ACxV2i6iPDk-a6L_Bs4jryVKYJMEGUTitEIYTjbJes4,176
+numpy/f2py/tests/src/string/string.f,sha256=shr3fLVZaa6SyUJFYIF1OZuhff8v5lCwsVNBU2B-3pk,248
+numpy/f2py/tests/src/value_attrspec/gh21665.f90,sha256=JC0FfVXsnB2lZHb-nGbySnxv_9VHAyD0mKaLDowczFU,190
+numpy/f2py/tests/test_abstract_interface.py,sha256=C8-ly0_TqkmpQNZmwPHwo2IV2MBH0jQEjAhpqHrg8Y4,832
+numpy/f2py/tests/test_array_from_pyobj.py,sha256=Txff89VUeEhWqUCRVybIqsqH4YQvpk4Uyjmh_XjyMi0,24049
+numpy/f2py/tests/test_assumed_shape.py,sha256=FeaqtrWyBf5uyArcmI0D2e_f763aSMpgU3QmdDXe-tA,1466
+numpy/f2py/tests/test_block_docstring.py,sha256=SEpuq73T9oVtHhRVilFf1xF7nb683d4-Kv7V0kfL4AA,564
+numpy/f2py/tests/test_callback.py,sha256=t129L4PrDSCeGdr4S405XuJjeSKlrNLHlosDsEmz1e0,6152
+numpy/f2py/tests/test_character.py,sha256=-HSJgOxUspNQtsiyScuWmsurgUAOdS-uoxyRuSIZmcM,20468
+numpy/f2py/tests/test_common.py,sha256=SZlrUR1e_CbkUD4O6i99QgUmOctHQNP0MmyhMWpio5E,584
+numpy/f2py/tests/test_compile_function.py,sha256=9d_FZ8P2wbIlQ2qPDRrsFqPb4nMH8tiWqYZN-P_shCs,4186
+numpy/f2py/tests/test_crackfortran.py,sha256=oKTU-h7Y1liPiSSY4HHveCYTtC18jo2jPyufBWB0_18,10650
+numpy/f2py/tests/test_docs.py,sha256=jqtuHE5ZjxP4D8Of3Fkzz36F8_0qKbeS040_m0ac4v4,1662
+numpy/f2py/tests/test_f2cmap.py,sha256=p-Sylbr3ctdKT3UQV9FzpCuYPH5U7Vyn8weXFAjiI9o,391
+numpy/f2py/tests/test_f2py2e.py,sha256=xXmOiu4Q3kDRq2lAen6RUPn_aqKLoPp6n0kb4KEwl5Y,20848
+numpy/f2py/tests/test_kind.py,sha256=PVTTv8_7JyYK-443Hsup0CY97nkK_5AVth-agnNG87g,847
+numpy/f2py/tests/test_mixed.py,sha256=Ctuw-H7DxhPjSt7wZdJ2xffawIoEBCPWc5F7PSkY4HY,848
+numpy/f2py/tests/test_module_doc.py,sha256=sjCXWIKrqMD1NQ1DUAzgQqkjS5w9h9gvM_Lj29Rdcrg,863
+numpy/f2py/tests/test_parameter.py,sha256=ADI7EV_CM4ztICpqHqeq8LI-WdB6cX0ttatdRdjbsUA,3941
+numpy/f2py/tests/test_quoted_character.py,sha256=cpjMdrHwimnkoJkXd_W_FSlh43oWytY5VHySW9oskO4,454
+numpy/f2py/tests/test_regression.py,sha256=19GNZxElsPX1HV0p5pXrh4_KWt0whjeZTLDEttA0aHI,2157
+numpy/f2py/tests/test_return_character.py,sha256=18HJtiRwQ7a_2mdPUonD5forKWZJEapD-Vi1DsbTjVs,1493
+numpy/f2py/tests/test_return_complex.py,sha256=BZIIqQ1abdiPLgVmu03_q37yCtND0ijxGSMhGz2Wf-o,2397
+numpy/f2py/tests/test_return_integer.py,sha256=JwxT4obkr0PZsdJqJWIpdY0UiL0xa4xgVBlkWV0LqO4,1850
+numpy/f2py/tests/test_return_logical.py,sha256=XCmp8E8I6BOeNYF59HjSFAdv1hM9WaDvl8UDS10_05o,2017
+numpy/f2py/tests/test_return_real.py,sha256=sszzxombXl8Qm731Wy0kFUX-0YZDlfFcUVNiyXlRjU8,3353
+numpy/f2py/tests/test_semicolon_split.py,sha256=_Mdsi84lES18pPjl9J-QsbGttV4tPFFjZvJvejNcqPc,1635
+numpy/f2py/tests/test_size.py,sha256=q6YqQvcyqdXJeWbGijTiCbxyEG3EkPcvT8AlAW6RCMo,1164
+numpy/f2py/tests/test_string.py,sha256=5xZOfdReoHnId0950XfmtfduPPfBbtMkzBoXMtygvMk,2962
+numpy/f2py/tests/test_symbolic.py,sha256=28quk2kTKfWhKe56n4vINJ8G9weKBfc7HysMlE9J3_g,18341
+numpy/f2py/tests/test_value_attrspec.py,sha256=rWwJBfE2qGzqilZZurJ-7ucNoJDICye6lLetQSLFees,323
+numpy/f2py/tests/util.py,sha256=Oozrsc9UxKMfgnn9I7IF1bXmK5Hm0Qb5Z_BKy4MiXuo,10445
+numpy/f2py/use_rules.py,sha256=5t6X17rF6y42SwuUYe1LtNihJJEIgCU7f9jPqKphfgA,3587
+numpy/fft/__init__.py,sha256=HqjmF6s_dh0Ri4UZzUDtOKbNUyfAfJAWew3e3EL_KUk,8175
+numpy/fft/__init__.pyi,sha256=vD9Xzz5r13caF4AVL87Y4U9KOj9ic25Vci_wb3dmgpk,550
+numpy/fft/__pycache__/__init__.cpython-310.pyc,,
+numpy/fft/__pycache__/_pocketfft.cpython-310.pyc,,
+numpy/fft/__pycache__/helper.cpython-310.pyc,,
+numpy/fft/__pycache__/setup.cpython-310.pyc,,
+numpy/fft/_pocketfft.py,sha256=Xkm8wcP4JyBNMbp0ZoHIWhNDlgliX24RzrDuo29uRks,52897
+numpy/fft/_pocketfft.pyi,sha256=S6-ylUuHbgm8vNbh7tLru6K2R5SJzE81BC_Sllm6QrQ,2371
+numpy/fft/_pocketfft_internal.cpython-310-x86_64-linux-gnu.so,sha256=TNLO2BXMwO7rNNVLjDObEWkj9oHOPtEPa4ykxwp82Wg,97032
+numpy/fft/helper.py,sha256=aNj1AcLvtfoX26RiLOwcR-k2QSMuBZkGj2Fu0CeFPJs,6154
+numpy/fft/helper.pyi,sha256=NLTEjy2Gz1aAMDZwCgssIyUne0ubjJqukfYkpsL3gXM,1176
+numpy/fft/setup.py,sha256=OJPeJK4PuEtWRw_yVTZj4dKxfu2y-w3ZtQ6EUaQjQyk,728
+numpy/fft/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/fft/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/fft/tests/__pycache__/test_helper.cpython-310.pyc,,
+numpy/fft/tests/__pycache__/test_pocketfft.cpython-310.pyc,,
+numpy/fft/tests/test_helper.py,sha256=whgeaQ8PzFf3B1wkbXobGZ5sF4WxPp4gf1UPUVZest8,6148
+numpy/fft/tests/test_pocketfft.py,sha256=RdeCCvUQmJYVvccOJwToobTKDg9yzUL06o9MkPmRfmI,12895
+numpy/lib/__init__.py,sha256=KoSy7mPbGp3r8X1Lio2TDrcwq5cFY0zIlxyQTbGwekQ,2253
+numpy/lib/__init__.pyi,sha256=y5ANokFm7EkrlNoHdeQm1FsUhLFxkYtLuanCbsWrGio,5596
+numpy/lib/__pycache__/__init__.cpython-310.pyc,,
+numpy/lib/__pycache__/_datasource.cpython-310.pyc,,
+numpy/lib/__pycache__/_iotools.cpython-310.pyc,,
+numpy/lib/__pycache__/_version.cpython-310.pyc,,
+numpy/lib/__pycache__/arraypad.cpython-310.pyc,,
+numpy/lib/__pycache__/arraysetops.cpython-310.pyc,,
+numpy/lib/__pycache__/arrayterator.cpython-310.pyc,,
+numpy/lib/__pycache__/format.cpython-310.pyc,,
+numpy/lib/__pycache__/function_base.cpython-310.pyc,,
+numpy/lib/__pycache__/histograms.cpython-310.pyc,,
+numpy/lib/__pycache__/index_tricks.cpython-310.pyc,,
+numpy/lib/__pycache__/mixins.cpython-310.pyc,,
+numpy/lib/__pycache__/nanfunctions.cpython-310.pyc,,
+numpy/lib/__pycache__/npyio.cpython-310.pyc,,
+numpy/lib/__pycache__/polynomial.cpython-310.pyc,,
+numpy/lib/__pycache__/recfunctions.cpython-310.pyc,,
+numpy/lib/__pycache__/scimath.cpython-310.pyc,,
+numpy/lib/__pycache__/setup.cpython-310.pyc,,
+numpy/lib/__pycache__/shape_base.cpython-310.pyc,,
+numpy/lib/__pycache__/stride_tricks.cpython-310.pyc,,
+numpy/lib/__pycache__/twodim_base.cpython-310.pyc,,
+numpy/lib/__pycache__/type_check.cpython-310.pyc,,
+numpy/lib/__pycache__/ufunclike.cpython-310.pyc,,
+numpy/lib/__pycache__/user_array.cpython-310.pyc,,
+numpy/lib/__pycache__/utils.cpython-310.pyc,,
+numpy/lib/_datasource.py,sha256=8S1FpiqOhaFkFW8dJw969p2i94eC7uz8ynqOel2-bNc,22643
+numpy/lib/_iotools.py,sha256=OL6MmiWabT1_g30YhGjYrNFuBoNSyDCHqiDgXuu_qFQ,30873
+numpy/lib/_version.py,sha256=6vK7czNSB_KrWx2rZJzJ1pyOc73Q07hAgfLB5ItUCnU,4855
+numpy/lib/_version.pyi,sha256=B572hyWrUWG-TAAAXrNNAT4AgyUAmJ4lvgpwMkDzunk,633
+numpy/lib/arraypad.py,sha256=Hr6-ZYs3wHGRad4MmZDpu95kPz5Do0yJZ5tDrCiG_tA,31362
+numpy/lib/arraypad.pyi,sha256=ADXphtAORYl3EqvE5qs_u32B_TALKSOtF43jOLmoxRw,1728
+numpy/lib/arraysetops.py,sha256=GJ2RhkzIJmIbwyG6h3LOFTPXg62kM9tcV1a-7tdbVuU,33655
+numpy/lib/arraysetops.pyi,sha256=zFIbRBIx5FMqc86QIKFjHRcjukm5rQ60UOJzid0-kNs,8337
+numpy/lib/arrayterator.py,sha256=BQ97S00zvfURUZfes0GZo-5hydYNRuvwX1I1bLzeRik,7063
+numpy/lib/arrayterator.pyi,sha256=f7Pwp83_6DiMYmJGUsffncM-FRAynB1iYGvhmHM_SZE,1537
+numpy/lib/format.py,sha256=9YxI4XEJmeGHbsfxryvm_OnGjuOpFi_e2uqhGE7g8Ww,34245
+numpy/lib/format.pyi,sha256=YWBxC3GdsZ7SKBN8I7nMwWeVuFD1aT9d-VJ8zE4-P-o,748
+numpy/lib/function_base.py,sha256=4sA9o8ou4PkYuHWd81piHbQi823GwBfu8PdpGIyNRS4,185141
+numpy/lib/function_base.pyi,sha256=KWaC5UOBANU4hiIoN2eptE4HYsm4vgp_8BMFV1Y3JX4,16585
+numpy/lib/histograms.py,sha256=abpAYgr4OmYhxpo5ZksZnBX8KnpWxlOWz6YoR60uJB8,37698
+numpy/lib/histograms.pyi,sha256=hNwR2xYWkgJCP-nfRGxc-EgHLTD3qm4zmWXthZLt08M,995
+numpy/lib/index_tricks.py,sha256=kAkciyg_xcuD2qgiERwa6Nhu5mNJTiZN_dvFwuUigas,30944
+numpy/lib/index_tricks.pyi,sha256=1zACf_X8lbHWOkfkxLJZ5o5Ig_wmRXT_EbA7wnqOlvw,4241
+numpy/lib/mixins.py,sha256=awJWn-wXkA6fg3TaPvMtXzUWaJVXKAn8fOt3XLPJ690,7052
+numpy/lib/mixins.pyi,sha256=h9N1kbZsUntF0zjOxPYeD_rCB2dMiG35TYYPl9ymkI4,3117
+numpy/lib/nanfunctions.py,sha256=LbUU7ANMqBa4WW5qtjgC9PerkUKiXrIxjNM0atSjq6I,65556
+numpy/lib/nanfunctions.pyi,sha256=oPqAfCinmBL85Ji7ko4QlzAzLAK9nZL0t2_CllEbCEU,606
+numpy/lib/npyio.py,sha256=x9mtHVNryAS-xUERB6W5o4vfaZE1xtltE8VGsOpfy8I,97461
+numpy/lib/npyio.pyi,sha256=tw5eZd7Tk6ohtH2C7uBGgYjJbSHx0qSOnSeCUBSlKKI,9616
+numpy/lib/polynomial.py,sha256=tfqWBGIDhT9oCs9YU66Xv5UejeM1GliLVMhcCAKXVnc,44143
+numpy/lib/polynomial.pyi,sha256=GerIpQnf5LdtFMOy9AxhOTqUyfn57k4MxqEYrfdckWE,6958
+numpy/lib/recfunctions.py,sha256=AZSnD-lLH3o1UBQSpDBiDokHeuJlcWWofE34v9Id408,56247
+numpy/lib/scimath.py,sha256=T4ITysZgqhY1J8IxyXCtioHjMTg2ci-4i3mr9TBF2UA,15037
+numpy/lib/scimath.pyi,sha256=E2roKJzMFwWSyhLu8UPUr54WOpxF8jp_pyXYBgsUSQ8,2883
+numpy/lib/setup.py,sha256=0K5NJKuvKvNEWp-EX7j0ODi3ZQQgIMHobzSFJq3G7yM,405
+numpy/lib/shape_base.py,sha256=SyP0QGyroBugy2n45sfV7aMDwxgO0KdhIGpuA8Pujng,39267
+numpy/lib/shape_base.pyi,sha256=t7koJnkOXLootnfoqtUsMC1r7kUMmWkNRpCMh34MTDg,5184
+numpy/lib/stride_tricks.py,sha256=brY5b-0YQJuIH2CavfpIinMolyTUv5k9DUvLoZ-imis,17911
+numpy/lib/stride_tricks.pyi,sha256=0pQ4DP9l6g21q2Ajv6dJFRWMr9auPGTNV9BmZUbogPY,1747
+numpy/lib/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/lib/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test__datasource.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test__iotools.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test__version.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_arraypad.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_arraysetops.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_arrayterator.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_financial_expired.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_format.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_function_base.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_histograms.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_index_tricks.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_io.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_loadtxt.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_mixins.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_nanfunctions.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_packbits.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_polynomial.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_recfunctions.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_regression.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_shape_base.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_stride_tricks.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_twodim_base.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_type_check.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_ufunclike.cpython-310.pyc,,
+numpy/lib/tests/__pycache__/test_utils.cpython-310.pyc,,
+numpy/lib/tests/data/py2-objarr.npy,sha256=F4cyUC-_TB9QSFLAo2c7c44rC6NUYIgrfGx9PqWPSKk,258
+numpy/lib/tests/data/py2-objarr.npz,sha256=xo13HBT0FbFZ2qvZz0LWGDb3SuQASSaXh7rKfVcJjx4,366
+numpy/lib/tests/data/py3-objarr.npy,sha256=pTTVh8ezp-lwAK3fkgvdKU8Arp5NMKznVD-M6Ex_uA0,341
+numpy/lib/tests/data/py3-objarr.npz,sha256=qQR0gS57e9ta16d_vCQjaaKM74gPdlwCPkp55P-qrdw,449
+numpy/lib/tests/data/python3.npy,sha256=X0ad3hAaLGXig9LtSHAo-BgOvLlFfPYMnZuVIxRmj-0,96
+numpy/lib/tests/data/win64python2.npy,sha256=agOcgHVYFJrV-nrRJDbGnUnF4ZTPYXuSeF-Mtg7GMpc,96
+numpy/lib/tests/test__datasource.py,sha256=65KXfUUvp8wXSqgQisuYlkhg-qHjBV5FXYetL8Ba-rc,10571
+numpy/lib/tests/test__iotools.py,sha256=HerCqvDE07JxjFQlWEfpZO7lC9z0Sbr3z20GSutoCPs,13743
+numpy/lib/tests/test__version.py,sha256=aO3YgkAohLsLzCNQ7vjIwdpFUMz0cPLbcuuxIkjuN74,1999
+numpy/lib/tests/test_arraypad.py,sha256=7B0YTEigf2Gt163-AREMrzJmMzm4lXMeusmNPUk5xIQ,54259
+numpy/lib/tests/test_arraysetops.py,sha256=5-T1MVhfIMivat8Z47GZw0ZaR811W_FskM1bAXnFyLU,35912
+numpy/lib/tests/test_arrayterator.py,sha256=AYs2SwV5ankgwnvKI9RSO1jZck118nu3SyZ4ngzZNso,1291
+numpy/lib/tests/test_financial_expired.py,sha256=yq5mqGMvqpkiiw9CuZhJgrYa7Squj1mXr_G-IvAFgwI,247
+numpy/lib/tests/test_format.py,sha256=bWDvWlqMoU1P5M_D5VIuIfUfFjKyEiqaGuC2BpY3Ts0,40857
+numpy/lib/tests/test_function_base.py,sha256=-f90812VeUFcLtxNYqjrxY6G84iIte83SZu1ugxaycQ,149343
+numpy/lib/tests/test_histograms.py,sha256=fPYsXmn-z5wb04WNZHH5hImdLbIDbiVsFDvMymtkYAs,32452
+numpy/lib/tests/test_index_tricks.py,sha256=Vjz25Y6H_ih0iEE2AG0kaxO9U8PwcXSrofzqnN4XBwI,20256
+numpy/lib/tests/test_io.py,sha256=pydfB5kHW_ddFpcVVsv26NIiYSflQ8OOSCWP2kHrj3Q,107115
+numpy/lib/tests/test_loadtxt.py,sha256=PDKVeaNoBxxDRWdb_WIXKZ1x0KC2phabFLQ_NmrUDv4,38314
+numpy/lib/tests/test_mixins.py,sha256=Wivwz3XBWsEozGzrzsyyvL3qAuE14t1BHk2LPm9Z9Zc,7030
+numpy/lib/tests/test_nanfunctions.py,sha256=RA1Im8EFjlDHqikyc8o5FV1NGzK-fOu3t0fFuBy_Q8Y,46590
+numpy/lib/tests/test_packbits.py,sha256=OWGAd5g5GG0gl7WHqNfwkZ7G-2rrtLt2sI854PG4nnw,17546
+numpy/lib/tests/test_polynomial.py,sha256=URouxJpr8FQ5hiKybqhtOcLA7e-3hj4kWzjLBROByyA,11395
+numpy/lib/tests/test_recfunctions.py,sha256=TMla6aYcRi6wulPz3EfModTbGybtes-ghNuWOs3Rhp8,41565
+numpy/lib/tests/test_regression.py,sha256=KzGFkhTcvEG97mymoOQ2hP2CEr2nPZou0Ztf4-WaXCs,8257
+numpy/lib/tests/test_shape_base.py,sha256=VqGH23F3MF_a12cxcJcU97xR0z4hezP-vXKq1VQ3LnE,26757
+numpy/lib/tests/test_stride_tricks.py,sha256=wprpWWH5eq07DY7rzG0WDv5fMtLxzRQz6fm6TZWlScQ,22849
+numpy/lib/tests/test_twodim_base.py,sha256=zbTVB5bz9m1o1F1UKsSseF6BcfYoJPg_6n3HPNwp_BY,18951
+numpy/lib/tests/test_type_check.py,sha256=akjNP3V7IGIdvoA73cxrx6XdaNRTaUaKdAR-XPYm9tw,15119
+numpy/lib/tests/test_ufunclike.py,sha256=8umwt73iT_zIbk20MxQSoK5LWD6Bvv9gBUkaPXiRNEw,3278
+numpy/lib/tests/test_utils.py,sha256=-CweWn45038x6FpoUzbTuzKXIos7LibMDxaXLrAHYFI,4636
+numpy/lib/twodim_base.py,sha256=nrBUEo7Va4ts5efh_RkLGlYMYQ988pS83LBNXcs9yqA,31381
+numpy/lib/twodim_base.pyi,sha256=xFRcEVJdDj4mrXW_6iVP1lTMoJx4QJjYRD3o2_9f2eY,5370
+numpy/lib/type_check.py,sha256=fLW_HRLqV4zzsL0QHVgJ7axUtAghK90za-BweERX200,19931
+numpy/lib/type_check.pyi,sha256=LPvAvIxU-p5i_Qe-ic7hEvo4OTfSrNpplxMG7OAZe8Q,5571
+numpy/lib/ufunclike.py,sha256=8WVNpHtt5kOkPYDhvlmHql-Swg5zV0f09bJwnVJNpm0,8031
+numpy/lib/ufunclike.pyi,sha256=hLxcYfQprh1tTY_UO2QscA3Hd9Zd7cVGXIINZLhMFqY,1293
+numpy/lib/user_array.py,sha256=LE958--CMkBI2r3l1SQxmCHdCSw6HY6-RhWCnduzGA4,7721
+numpy/lib/utils.py,sha256=gI6o00zfkMfmUztXpO8ybT-4t_9CQsgOtEkP_Wu_gQM,36147
+numpy/lib/utils.pyi,sha256=mVHVzWuc2-M3Oz60lFsbok0v8LH_HRHMjZpXwrtzF_c,2360
+numpy/linalg/__init__.py,sha256=mpdlEXWtTvpF7In776ONLwp6RIyo4U_GLPT1L1eIJnw,1813
+numpy/linalg/__init__.pyi,sha256=XBy4ocuypsRVflw_mbSTUhR4N5Roemu6w5SfeVwbkAc,620
+numpy/linalg/__pycache__/__init__.cpython-310.pyc,,
+numpy/linalg/__pycache__/linalg.cpython-310.pyc,,
+numpy/linalg/__pycache__/setup.cpython-310.pyc,,
+numpy/linalg/_umath_linalg.cpython-310-x86_64-linux-gnu.so,sha256=d9mJ2vMOkbFLZX8KElN30cW_SdfZUFIrrv3OmnqT-Sc,230272
+numpy/linalg/lapack_lite.cpython-310-x86_64-linux-gnu.so,sha256=ZCeZ4ahDWSJrngnMqdNNtK7VAIxoYh75zl-5vtwvgTg,29992
+numpy/linalg/linalg.py,sha256=MEoAsbvV-TPjkgJkyT96IaRuQJGgX8cUJISStU540ck,89351
+numpy/linalg/linalg.pyi,sha256=CzYJbM2F5LqUuGtIAQ3fztzMd4O9Fxz10ujmDgZxm4k,7440
+numpy/linalg/setup.py,sha256=ySh_ehy-JJ4VOrt_20DHL_wJxZUhtnu8aoT8g_g8WTE,3316
+numpy/linalg/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/linalg/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/linalg/tests/__pycache__/test_deprecations.cpython-310.pyc,,
+numpy/linalg/tests/__pycache__/test_linalg.cpython-310.pyc,,
+numpy/linalg/tests/__pycache__/test_regression.cpython-310.pyc,,
+numpy/linalg/tests/test_deprecations.py,sha256=9p_SRmtxj2zc1doY9Ie3dyy5JzWy-tCQWFoajcAJUmM,640
+numpy/linalg/tests/test_linalg.py,sha256=zaMIB4qfl2a78tvfue509c0m91qN5rW0ApOlIpxpTF4,77576
+numpy/linalg/tests/test_regression.py,sha256=wfJx2G8SeApiIta80xN2hzot-wvXSw-TF8TXXIYZwyE,5597
+numpy/ma/__init__.py,sha256=dgP0WdnOpph28Fd6UiqoyDKhfrct0H6QWqbCcETsk6M,1404
+numpy/ma/__init__.pyi,sha256=89bS3ZnV7UOFx0ioGZW79E_GQOgfBJ6Sa1DWsvbR7BQ,6085
+numpy/ma/__pycache__/__init__.cpython-310.pyc,,
+numpy/ma/__pycache__/bench.cpython-310.pyc,,
+numpy/ma/__pycache__/core.cpython-310.pyc,,
+numpy/ma/__pycache__/extras.cpython-310.pyc,,
+numpy/ma/__pycache__/mrecords.cpython-310.pyc,,
+numpy/ma/__pycache__/setup.cpython-310.pyc,,
+numpy/ma/__pycache__/testutils.cpython-310.pyc,,
+numpy/ma/__pycache__/timer_comparison.cpython-310.pyc,,
+numpy/ma/bench.py,sha256=tSsmn5f59rOx6e7UGU3kyAedPhJG2sp-8LZHeZPla6g,4859
+numpy/ma/core.py,sha256=HeNPiNSfos_WCIgGpYXgQg8rxaoNpdq4il4dkvQdwgI,272643
+numpy/ma/core.pyi,sha256=F1E9cti713GNxKS5qHoIp_p6KurkIoMIrYIokgpYQMw,14277
+numpy/ma/extras.py,sha256=KcKwLiiBvopC248XtIafIjdz4bNebC6P8QjjlZjQmwQ,61910
+numpy/ma/extras.pyi,sha256=BBsiCZbaPpGCY506fkmqZdBkJNCXcglc3wcSBuAACNk,2646
+numpy/ma/mrecords.py,sha256=degd6dLaDEvEWNHmvSnUZXos1csIzaqjR_jAutm8JfI,27232
+numpy/ma/mrecords.pyi,sha256=r1a2I662ywnhGS6zvfcyK-9RHVvb4sHxiCx9Dhf5AE4,1934
+numpy/ma/setup.py,sha256=MqmMicr_xHkAGoG-T7NJ4YdUZIJLO4ZFp6AmEJDlyhw,418
+numpy/ma/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/ma/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/ma/tests/__pycache__/test_core.cpython-310.pyc,,
+numpy/ma/tests/__pycache__/test_deprecations.cpython-310.pyc,,
+numpy/ma/tests/__pycache__/test_extras.cpython-310.pyc,,
+numpy/ma/tests/__pycache__/test_mrecords.cpython-310.pyc,,
+numpy/ma/tests/__pycache__/test_old_ma.cpython-310.pyc,,
+numpy/ma/tests/__pycache__/test_regression.cpython-310.pyc,,
+numpy/ma/tests/__pycache__/test_subclassing.cpython-310.pyc,,
+numpy/ma/tests/test_core.py,sha256=E25sxK4WLrbzLCREk7Oj4S7Xn3v-NA8j1K8aR2d5ffA,210962
+numpy/ma/tests/test_deprecations.py,sha256=nq_wFVt2EBHcT3AHxattfKXx2JDf1K5D-QBzUU0_15A,2566
+numpy/ma/tests/test_extras.py,sha256=Kc8zyrt3Ap2bnZSPE_nOvHODe6oblAPd7QGdyQhauVU,72950
+numpy/ma/tests/test_mrecords.py,sha256=PsJhUlABgdpSsPUeijonfyFNqz5AfNSGQTtJUte7yts,19890
+numpy/ma/tests/test_old_ma.py,sha256=s08gE_AaPjIF96mu1cSnk6hly-_a4ojixfQeaP-U2P8,32702
+numpy/ma/tests/test_regression.py,sha256=Se594vUGpVg0s8mevpkU0Yb6gHfNfWJxPL4GqNz_Y3s,3078
+numpy/ma/tests/test_subclassing.py,sha256=h-wRcgd7FaD1bMJ0ZM7lWZWFXnJnr8JH7TSzIvIlZQo,16570
+numpy/ma/testutils.py,sha256=KOD9yEe6rUTZ_nMDcZyXphBP1vpfV1vzvbmIhVaJrsg,10239
+numpy/ma/timer_comparison.py,sha256=pIGSZG-qYYYlRWSTgzPlyCAINbGKhXrZrDZBBjiM080,15658
+numpy/matlib.py,sha256=-54vTuGIgeTMg9ZUmElRPZ4Hr-XZ-om9xLzAsSoTvnc,10465
+numpy/matrixlib/__init__.py,sha256=BHBpQKoQv4EjT0UpWBA-Ck4L5OsMqTI2IuY24p-ucXk,242
+numpy/matrixlib/__init__.pyi,sha256=-t3ZuvbzRuRwWfZOeN4xlNWdm7gQEprhUsWzu8MRvUE,252
+numpy/matrixlib/__pycache__/__init__.cpython-310.pyc,,
+numpy/matrixlib/__pycache__/defmatrix.cpython-310.pyc,,
+numpy/matrixlib/__pycache__/setup.cpython-310.pyc,,
+numpy/matrixlib/defmatrix.py,sha256=K9ecSTjVAETfgpCLPEALKn5CvT-QynDDFQvMn_3gmv0,30667
+numpy/matrixlib/defmatrix.pyi,sha256=lmBMRahKcMOl2PHDo79J67VRAZOkI54BzfDaTLpE0LI,451
+numpy/matrixlib/setup.py,sha256=1r7JRkSM4HyVorgtjoKJGWLcOcPO3wmvivpeEsVtAEg,426
+numpy/matrixlib/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/matrixlib/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/matrixlib/tests/__pycache__/test_defmatrix.cpython-310.pyc,,
+numpy/matrixlib/tests/__pycache__/test_interaction.cpython-310.pyc,,
+numpy/matrixlib/tests/__pycache__/test_masked_matrix.cpython-310.pyc,,
+numpy/matrixlib/tests/__pycache__/test_matrix_linalg.cpython-310.pyc,,
+numpy/matrixlib/tests/__pycache__/test_multiarray.cpython-310.pyc,,
+numpy/matrixlib/tests/__pycache__/test_numeric.cpython-310.pyc,,
+numpy/matrixlib/tests/__pycache__/test_regression.cpython-310.pyc,,
+numpy/matrixlib/tests/test_defmatrix.py,sha256=8E_-y7VD2vsq1y8CcI8km37pp5qcAtkciO16xqf2UIs,14982
+numpy/matrixlib/tests/test_interaction.py,sha256=PpjmgjEKighDXvt38labKE6L7f2jP74UEmp3JRb_iOY,11875
+numpy/matrixlib/tests/test_masked_matrix.py,sha256=7YO_LCO8DOhW3CuXJuxH93rnmttfvHnU7El-MBzxzFw,8932
+numpy/matrixlib/tests/test_matrix_linalg.py,sha256=ObbSUXU4R2pWajH__xAdizADrU2kBKDDCxkDV-oVBXc,2059
+numpy/matrixlib/tests/test_multiarray.py,sha256=jB3XCBmAtcqf-Wb9PwBW6uIykPpMPthuXLJ0giTKzZE,554
+numpy/matrixlib/tests/test_numeric.py,sha256=MP70qUwgshTtThKZaZDp7_6U-Z66NIV1geVhasGXejQ,441
+numpy/matrixlib/tests/test_regression.py,sha256=8sHDtO8Zi8p3a1eQKEWxtCmKrXmHoD3qxlIokg2AIAU,927
+numpy/polynomial/__init__.py,sha256=braLh6zP2QwuNKRKAaZGdC_qKWZ-tJlc3BN83LeuE_0,6781
+numpy/polynomial/__init__.pyi,sha256=W8szYtVUy0RUi83jmFLK58BN8CKVSoHA2CW7IcdUl1c,701
+numpy/polynomial/__pycache__/__init__.cpython-310.pyc,,
+numpy/polynomial/__pycache__/_polybase.cpython-310.pyc,,
+numpy/polynomial/__pycache__/chebyshev.cpython-310.pyc,,
+numpy/polynomial/__pycache__/hermite.cpython-310.pyc,,
+numpy/polynomial/__pycache__/hermite_e.cpython-310.pyc,,
+numpy/polynomial/__pycache__/laguerre.cpython-310.pyc,,
+numpy/polynomial/__pycache__/legendre.cpython-310.pyc,,
+numpy/polynomial/__pycache__/polynomial.cpython-310.pyc,,
+numpy/polynomial/__pycache__/polyutils.cpython-310.pyc,,
+numpy/polynomial/__pycache__/setup.cpython-310.pyc,,
+numpy/polynomial/_polybase.py,sha256=8HZDmhbqB2NY3fmI1ug9B1fKry_KI9n22r30aq29ft8,38691
+numpy/polynomial/_polybase.pyi,sha256=J7yU9PPZW4W8mkqAltDfnL4ZNwljuM-bDEj4DPTJZpY,2321
+numpy/polynomial/chebyshev.py,sha256=ioMcXqY_uMX_DrxPF8oQPhSvIEddSFzJPPFBD1yk0Ko,62520
+numpy/polynomial/chebyshev.pyi,sha256=035CNdOas4dnb6lFLzRiBrYT_VnWh2T1-A3ibm_HYkI,1387
+numpy/polynomial/hermite.py,sha256=EWb1Fa-0Hl8qI18bkplFOXoyR7aU3_etQjsC6g1VikY,52238
+numpy/polynomial/hermite.pyi,sha256=hdsvTULow8bIjnATudf0i6brpLHV7vbOoHzaMvbjMy0,1217
+numpy/polynomial/hermite_e.py,sha256=9gSngNFbr3U39lUEU8lxwfLMxi5K5E7c64b2Sjz8rLY,52366
+numpy/polynomial/hermite_e.pyi,sha256=zV7msb9v9rV0iv_rnD3SjP-TGyc6pd3maCqiPCj3PbA,1238
+numpy/polynomial/laguerre.py,sha256=mn0MySU8yqQClfc-sFBslLDV5CDI2qlSo8w_6HJ_bmw,50582
+numpy/polynomial/laguerre.pyi,sha256=Gxc9SLISNKMWrKdsVJ9fKFFFwfxxZzfF-Yc-2r__z5M,1178
+numpy/polynomial/legendre.py,sha256=Pyp8xafrILE0qZxSHnQLo5C6xB4zNHWRikHEcLsyU00,51274
+numpy/polynomial/legendre.pyi,sha256=9dmANwkxf7EbOHV3XQBPoaDtc56cCkf75Wo7FG9Zfj4,1178
+numpy/polynomial/polynomial.py,sha256=8VaFgpJFBv6sIgUu51vj5TMKj_8Q_i76UI7V10zLjOg,48836
+numpy/polynomial/polynomial.pyi,sha256=bOPRnub4xXxsUwNGeiQLTT4PCfN1ysSrf6LBZIcAN2Y,1132
+numpy/polynomial/polyutils.py,sha256=Xy5qjdrjnRaqSlClG1ROmwWccLkAPC7IcHaNJLvhCf4,23237
+numpy/polynomial/polyutils.pyi,sha256=cFAyZ9Xzuw8Huhn9FEz4bhyD00m2Dp-2DiUSyogJwSo,264
+numpy/polynomial/setup.py,sha256=dXQfzVUMP9OcB6iKv5yo1GLEwFB3gJ48phIgo4N-eM0,373
+numpy/polynomial/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/polynomial/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/polynomial/tests/__pycache__/test_chebyshev.cpython-310.pyc,,
+numpy/polynomial/tests/__pycache__/test_classes.cpython-310.pyc,,
+numpy/polynomial/tests/__pycache__/test_hermite.cpython-310.pyc,,
+numpy/polynomial/tests/__pycache__/test_hermite_e.cpython-310.pyc,,
+numpy/polynomial/tests/__pycache__/test_laguerre.cpython-310.pyc,,
+numpy/polynomial/tests/__pycache__/test_legendre.cpython-310.pyc,,
+numpy/polynomial/tests/__pycache__/test_polynomial.cpython-310.pyc,,
+numpy/polynomial/tests/__pycache__/test_polyutils.cpython-310.pyc,,
+numpy/polynomial/tests/__pycache__/test_printing.cpython-310.pyc,,
+numpy/polynomial/tests/__pycache__/test_symbol.cpython-310.pyc,,
+numpy/polynomial/tests/test_chebyshev.py,sha256=6tMsFP1h7K8Zf72mNOta6Tv52_fVTlXknseuffj080c,20522
+numpy/polynomial/tests/test_classes.py,sha256=DFyY2IQBj3r2GZkvbRIeZO2EEY466xbuwc4PShAl4Sw,18331
+numpy/polynomial/tests/test_hermite.py,sha256=N9b2dx2UWPyja5v02dSoWYPnKvb6H-Ozgtrx-xjWz2k,18577
+numpy/polynomial/tests/test_hermite_e.py,sha256=_A3ohAWS4HXrQG06S8L47dImdZGTwYosCXnoyw7L45o,18911
+numpy/polynomial/tests/test_laguerre.py,sha256=BZOgs49VBXOFBepHopxuEDkIROHEvFBfWe4X73UZhn8,17511
+numpy/polynomial/tests/test_legendre.py,sha256=b_bblHs0F_BWw9ESuSq52ZsLKcQKFR5eqPf_SppWFqo,18673
+numpy/polynomial/tests/test_polynomial.py,sha256=4cuO8-5wdIxcz5CrucB5Ix7ySuMROokUF12F7ogQ_hc,20529
+numpy/polynomial/tests/test_polyutils.py,sha256=IxkbVfpcBqe5lOZluHFUPbLATLu1rwVg7ghLASpfYrY,3579
+numpy/polynomial/tests/test_printing.py,sha256=rfP4MaQbjGcO52faHmYrgsaarkm3Ndi3onwr6DDuapE,20525
+numpy/polynomial/tests/test_symbol.py,sha256=msTPv7B1niaKujU33kuZmdxJvLYvOjfl1oykmlL0dXo,5371
+numpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/random/__init__.pxd,sha256=9JbnX540aJNSothGs-7e23ozhilG6U8tINOUEp08M_k,431
+numpy/random/__init__.py,sha256=81Thnexg5umN5WZwD5TRyzNc2Yp-d14B6UC7NBgVKh8,7506
+numpy/random/__init__.pyi,sha256=RfW8mco48UaWDL1UC5ROv9vXiFZ9EGho62avhgEAHPc,2143
+numpy/random/__pycache__/__init__.cpython-310.pyc,,
+numpy/random/__pycache__/_pickle.cpython-310.pyc,,
+numpy/random/__pycache__/setup.cpython-310.pyc,,
+numpy/random/_bounded_integers.cpython-310-x86_64-linux-gnu.so,sha256=iFbKeznyPMv8AhP2XxRfhchAxl_v-2z79Z8WN2m-nr4,382600
+numpy/random/_bounded_integers.pxd,sha256=hcoucPH5hkFEM2nm12zYO-5O_Rt8RujEXT5YWuAzl1Q,1669
+numpy/random/_common.cpython-310-x86_64-linux-gnu.so,sha256=8-VfYw6efPn4HSVBogBhQhruBnXfJFTA0DJzbAGidr4,291072
+numpy/random/_common.pxd,sha256=x1bLUtACXSCekLTfYAXlVy9XUEn0ytcf1leZ_frCKFY,4741
+numpy/random/_examples/cffi/__pycache__/extending.cpython-310.pyc,,
+numpy/random/_examples/cffi/__pycache__/parse.cpython-310.pyc,,
+numpy/random/_examples/cffi/extending.py,sha256=xSla3zWqxi6Hj48EvnYfD3WHfE189VvC4XsKu4_T_Iw,880
+numpy/random/_examples/cffi/parse.py,sha256=o41aw7pB_nA8RfLDUlaP0DNDO_bDo__B0XM5pGLxtY0,1829
+numpy/random/_examples/cython/__pycache__/setup.cpython-310.pyc,,
+numpy/random/_examples/cython/extending.pyx,sha256=4IE692pq1V53UhPZqQiQGcIHXDoNyqTx62x5a36puVg,2290
+numpy/random/_examples/cython/extending_distributions.pyx,sha256=oazFVWeemfE0eDzax7r7MMHNL1_Yofws2m-c_KT2Hbo,3870
+numpy/random/_examples/cython/setup.py,sha256=FPAnf3nC8BQWrKZ6fNheKbcxLapqd9LW7rC995px9I8,1401
+numpy/random/_examples/numba/__pycache__/extending.cpython-310.pyc,,
+numpy/random/_examples/numba/__pycache__/extending_distributions.cpython-310.pyc,,
+numpy/random/_examples/numba/extending.py,sha256=Ipyzel_h5iU_DMJ_vnXUgQC38uMDMn7adUpWSeEQLFE,1957
+numpy/random/_examples/numba/extending_distributions.py,sha256=Jnr9aWkHyIWygNbdae32GVURK-5T9BTGhuExRpvve98,2034
+numpy/random/_generator.cpython-310-x86_64-linux-gnu.so,sha256=cEgfI_9MdZAx2nhX5rOlhlKPHZ1giVwz6a_0uAejfLs,988720
+numpy/random/_generator.pyi,sha256=WWrF4oNiUPalnzPeiDO1rkWsm6iAqicTvQC-59pJNlg,21682
+numpy/random/_mt19937.cpython-310-x86_64-linux-gnu.so,sha256=sPZ_Kjrj9e0ZVAiaNH0ywJPQgda3DxhHaRVFEJtOsL4,120128
+numpy/random/_mt19937.pyi,sha256=_iZKaAmuKBQ4itSggfQvYYj_KjktcN4rt-YpE6bqFAM,724
+numpy/random/_pcg64.cpython-310-x86_64-linux-gnu.so,sha256=1Jn4JPVdx_V-uTyoQ22Tj8KlyV_glHRnfESs7PAWGl8,118416
+numpy/random/_pcg64.pyi,sha256=uxr5CbEJetN6lv9vBG21jlRhuzOK8SQnXrwqAQBxj_c,1091
+numpy/random/_philox.cpython-310-x86_64-linux-gnu.so,sha256=jkpqefUSGogvyxLud57sPYsqJoTbU4vj8NWqXi7n7nY,101648
+numpy/random/_philox.pyi,sha256=OKlaiIU-hj72Bp04zjNifwusOD_3-mYxIfvyuys8c_o,978
+numpy/random/_pickle.py,sha256=4NhdT-yk7C0m3tyZWmouYAs3ZGNPdPVNGfUIyuh8HDY,2318
+numpy/random/_sfc64.cpython-310-x86_64-linux-gnu.so,sha256=eGSxaGJ7OEPhQARmbljZLpUhh4gdvc5YLY2oqrJEyR4,71752
+numpy/random/_sfc64.pyi,sha256=09afHTedVW-519493ZXtGcl-H-_zluj-B_yfEJG8MMs,709
+numpy/random/bit_generator.cpython-310-x86_64-linux-gnu.so,sha256=dsKlMleB15ASk67y6eK2SHSW94RR4bM_v3nyKP6Xl5w,226896
+numpy/random/bit_generator.pxd,sha256=lArpIXSgTwVnJMYc4XX0NGxegXq3h_QsUDK6qeZKbNc,1007
+numpy/random/bit_generator.pyi,sha256=cGZU1H0hAszMBzP4BhvmfWCGXHlXOp5Kx_Koar6r0Dw,3387
+numpy/random/c_distributions.pxd,sha256=FrGMrxWXGD8tc4HUWnzLpzUU8codNR-alXk1hjIAjmI,6033
+numpy/random/lib/libnpyrandom.a,sha256=7f5zIZP-SVl13kp642u8gKunxd2HXOPWYPNihp4KlX8,274050
+numpy/random/mtrand.cpython-310-x86_64-linux-gnu.so,sha256=EXt3TfDmNkQlXtPek-IODArrQuAtJdO1UxFQep0d3wY,801800
+numpy/random/mtrand.pyi,sha256=Vfwx7H5GUd_Sbvh6UxYEig7EXQDlMkh4LGuHzIvVfyQ,19728
+numpy/random/setup.py,sha256=5cYX-xuKpfoyWqrWnytewMq3FzuAksG_BSaD2v7oSOc,6688
+numpy/random/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/random/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/random/tests/__pycache__/test_direct.cpython-310.pyc,,
+numpy/random/tests/__pycache__/test_extending.cpython-310.pyc,,
+numpy/random/tests/__pycache__/test_generator_mt19937.cpython-310.pyc,,
+numpy/random/tests/__pycache__/test_generator_mt19937_regressions.cpython-310.pyc,,
+numpy/random/tests/__pycache__/test_random.cpython-310.pyc,,
+numpy/random/tests/__pycache__/test_randomstate.cpython-310.pyc,,
+numpy/random/tests/__pycache__/test_randomstate_regression.cpython-310.pyc,,
+numpy/random/tests/__pycache__/test_regression.cpython-310.pyc,,
+numpy/random/tests/__pycache__/test_seed_sequence.cpython-310.pyc,,
+numpy/random/tests/__pycache__/test_smoke.cpython-310.pyc,,
+numpy/random/tests/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/random/tests/data/__pycache__/__init__.cpython-310.pyc,,
+numpy/random/tests/data/mt19937-testset-1.csv,sha256=Xkef402AVB-eZgYQkVtoxERHkxffCA9Jyt_oMbtJGwY,15844
+numpy/random/tests/data/mt19937-testset-2.csv,sha256=nsBEQNnff-aFjHYK4thjvUK4xSXDSfv5aTbcE59pOkE,15825
+numpy/random/tests/data/pcg64-testset-1.csv,sha256=xB00DpknGUTTCxDr9L6aNo9Hs-sfzEMbUSS4t11TTfE,23839
+numpy/random/tests/data/pcg64-testset-2.csv,sha256=NTdzTKvG2U7_WyU_IoQUtMzU3kEvDH39CgnR6VzhTkw,23845
+numpy/random/tests/data/pcg64dxsm-testset-1.csv,sha256=vNSUT-gXS_oEw_awR3O30ziVO4seNPUv1UIZ01SfVnI,23833
+numpy/random/tests/data/pcg64dxsm-testset-2.csv,sha256=uylS8PU2AIKZ185OC04RBr_OePweGRtvn-dE4YN0yYA,23839
+numpy/random/tests/data/philox-testset-1.csv,sha256=SedRaIy5zFadmk71nKrGxCFZ6BwKz8g1A9-OZp3IkkY,23852
+numpy/random/tests/data/philox-testset-2.csv,sha256=dWECt-sbfvaSiK8-Ygp5AqyjoN5i26VEOrXqg01rk3g,23838
+numpy/random/tests/data/sfc64-testset-1.csv,sha256=iHs6iX6KR8bxGwKk-3tedAdMPz6ZW8slDSUECkAqC8Q,23840
+numpy/random/tests/data/sfc64-testset-2.csv,sha256=FIDIDFCaPZfWUSxsJMAe58hPNmMrU27kCd9FhCEYt_k,23833
+numpy/random/tests/test_direct.py,sha256=ROlEv_OqQQ2-vtypmqNtg-wzLXNuNe8YIQaMgBQfhLs,16429
+numpy/random/tests/test_extending.py,sha256=s09lJxqfPE4RVG2skTxg8bDTBQCr0n4YMNfRNgECXC4,3676
+numpy/random/tests/test_generator_mt19937.py,sha256=XqffS2OHxImdIDPfQ7-4YLs5gcmBaWRdjpQRYxNCjms,114760
+numpy/random/tests/test_generator_mt19937_regressions.py,sha256=SAdHm3KlGjdh0IKyOF8TQd1YS-P59nSkIwKOe9SuT0U,5639
+numpy/random/tests/test_random.py,sha256=pWhNMRjEI8IAmAzcCAUQnTuvtIuov741lh62-nFbees,69969
+numpy/random/tests/test_randomstate.py,sha256=_1tl2Ol9VercjBmX9sj6yOHQazr5hDzsFcqcwfH7fiw,84892
+numpy/random/tests/test_randomstate_regression.py,sha256=VucYWIjA7sAquWsalvZMnfkmYLM1O6ysyWnLl931-lA,7917
+numpy/random/tests/test_regression.py,sha256=trntK51UvajOVELiluEO85l64CKSw5nvBSc5SqYyr9w,5439
+numpy/random/tests/test_seed_sequence.py,sha256=GNRJ4jyzrtfolOND3gUWamnbvK6-b_p1bBK_RIG0sfU,3311
+numpy/random/tests/test_smoke.py,sha256=jjNz0aEGD1_oQl9a9UWt6Mz_298alG7KryLT1pgHljw,28183
+numpy/setup.py,sha256=u3vdMH69z-UM6XNxec8o2cIp9AEfNqZ7fsVGp48ChLk,1101
+numpy/testing/__init__.py,sha256=Ajd0bx2jflAqy2F8p4W_D25Dm8KRnVdL6UL1mpt79o8,673
+numpy/testing/__init__.pyi,sha256=FB_4wiugmKbDTWXr-FVxp-mGNvJQjGUBYz5C5xblgnI,1803
+numpy/testing/__pycache__/__init__.cpython-310.pyc,,
+numpy/testing/__pycache__/print_coercion_tables.cpython-310.pyc,,
+numpy/testing/__pycache__/setup.cpython-310.pyc,,
+numpy/testing/__pycache__/utils.cpython-310.pyc,,
+numpy/testing/_private/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/testing/_private/__pycache__/__init__.cpython-310.pyc,,
+numpy/testing/_private/__pycache__/decorators.cpython-310.pyc,,
+numpy/testing/_private/__pycache__/extbuild.cpython-310.pyc,,
+numpy/testing/_private/__pycache__/noseclasses.cpython-310.pyc,,
+numpy/testing/_private/__pycache__/nosetester.cpython-310.pyc,,
+numpy/testing/_private/__pycache__/parameterized.cpython-310.pyc,,
+numpy/testing/_private/__pycache__/utils.cpython-310.pyc,,
+numpy/testing/_private/decorators.py,sha256=amFUfIH86_F8qvD-jqky59GYVtqMLs7uSxZ6euHblh8,11401
+numpy/testing/_private/extbuild.py,sha256=2Y6yC3_KCBmOHY9OLtsODqCGrI7JCGTKJBkFbfpHkaY,7816
+numpy/testing/_private/noseclasses.py,sha256=0wuRHsQVkz1c5bX1F0v2C4QEJWdhCuAdVOwo8uOefP8,14516
+numpy/testing/_private/nosetester.py,sha256=wKjN3dagwDInzGdeN6wO9JnLe6IoTxGqF_idSL0qpCQ,19435
+numpy/testing/_private/parameterized.py,sha256=mSWTmj1C2R9jjgqwMbqFlRXRcIBUaalAO8pYMg5nCpo,16156
+numpy/testing/_private/utils.py,sha256=p7CO1qmi1nH-VUc1ectNjebzYtDLeAAVjlze1HQY-l0,87918
+numpy/testing/_private/utils.pyi,sha256=zeS0TQla0MvwuAS9YRVJus1x_a8vcOPs67ghJpWq0e4,10048
+numpy/testing/print_coercion_tables.py,sha256=ndxOsS4XfrZ4UY_9nqRTCnxhkzgdqcuUHL8nezd7Op4,6180
+numpy/testing/setup.py,sha256=GPKAtTTBRsNW4kmR7NjP6mmBR_GTdpaTvkTm10_VcLg,709
+numpy/testing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/testing/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/testing/tests/__pycache__/test_doctesting.cpython-310.pyc,,
+numpy/testing/tests/__pycache__/test_utils.cpython-310.pyc,,
+numpy/testing/tests/test_doctesting.py,sha256=84GCZsWBQ3gqKrRI5NzmH_PmFHMShaVpZ4m0b_T1qNA,1347
+numpy/testing/tests/test_utils.py,sha256=2bVj-mV0u2yyc29LqZvZz5QZi7iDw7HOEAcohhwLg1I,56820
+numpy/testing/utils.py,sha256=B77PkK2qIw8R8tKk09OpWGVQV2O_P77fu4wt5QGOXSM,1255
+numpy/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/tests/__pycache__/test__all__.cpython-310.pyc,,
+numpy/tests/__pycache__/test_ctypeslib.cpython-310.pyc,,
+numpy/tests/__pycache__/test_lazyloading.cpython-310.pyc,,
+numpy/tests/__pycache__/test_matlib.cpython-310.pyc,,
+numpy/tests/__pycache__/test_numpy_version.cpython-310.pyc,,
+numpy/tests/__pycache__/test_public_api.cpython-310.pyc,,
+numpy/tests/__pycache__/test_reloading.cpython-310.pyc,,
+numpy/tests/__pycache__/test_scripts.cpython-310.pyc,,
+numpy/tests/__pycache__/test_warnings.cpython-310.pyc,,
+numpy/tests/test__all__.py,sha256=L3mCnYPTpzAgNfedVuq9g7xPWbc0c1Pot94k9jZ9NpI,221
+numpy/tests/test_ctypeslib.py,sha256=uAckGtgfFsaRGhD6ySPD5YR77US98TIUwR8DVS1bQvU,12290
+numpy/tests/test_lazyloading.py,sha256=YETrYiDLAqLX04K_u5_3NVxAfxDoeguxwkIRfz6qKcY,1162
+numpy/tests/test_matlib.py,sha256=gwhIXrJJo9DiecaGLCHLJBjhx2nVGl6yHq80AOUQSRM,1852
+numpy/tests/test_numpy_version.py,sha256=87imE8sJR6w16YYiTAfHxBSq7IFLnmgNpL6DUgqjKTs,1575
+numpy/tests/test_public_api.py,sha256=O7wH10DshuPhFHObOD0D5KrE0YXr8H7u5Pup7SecbM0,16138
+numpy/tests/test_reloading.py,sha256=QuVaPQulcNLg4Fl31Lw-O89L42KclYCK68n5GVy0PNQ,2354
+numpy/tests/test_scripts.py,sha256=jluCLfG94VM1cuX-5RcLFBli_yaJZpIvmVuMxRKRJrc,1645
+numpy/tests/test_warnings.py,sha256=b7x4zdms9sNJkO9FJ-LTzYI4BWhbeLGy2oFMC6Z85ig,2280
+numpy/typing/__init__.py,sha256=VoTILNDrUWvZx0LK9_97lBLQFKtSGmDt4QLOH8zYvlo,5234
+numpy/typing/__pycache__/__init__.cpython-310.pyc,,
+numpy/typing/__pycache__/mypy_plugin.cpython-310.pyc,,
+numpy/typing/__pycache__/setup.cpython-310.pyc,,
+numpy/typing/mypy_plugin.py,sha256=-Lzl_iaVlYSvDZwDSk0Ee-IaWQsI1OUFbtd_aNchegU,6479
+numpy/typing/setup.py,sha256=Cnz9q53w-vJNyE6vYxqYvQXx0pJbrG9quHyz9sqxfek,374
+numpy/typing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numpy/typing/tests/__pycache__/__init__.cpython-310.pyc,,
+numpy/typing/tests/__pycache__/test_generic_alias.cpython-310.pyc,,
+numpy/typing/tests/__pycache__/test_isfile.cpython-310.pyc,,
+numpy/typing/tests/__pycache__/test_runtime.cpython-310.pyc,,
+numpy/typing/tests/__pycache__/test_typing.cpython-310.pyc,,
+numpy/typing/tests/data/fail/arithmetic.pyi,sha256=4rY_ASCERAl8WCus1RakOe0Aw-8vvjilL29mgdD4lv0,3850
+numpy/typing/tests/data/fail/array_constructors.pyi,sha256=X9y_jUYS17WfYmXW5NwkVudyiR6ouUaAwEh0JRte42o,1089
+numpy/typing/tests/data/fail/array_like.pyi,sha256=OVAlEJZ5k8ZRKt0aGpZQwIjlUGpy0PzOOYqfI-IMqBQ,455
+numpy/typing/tests/data/fail/array_pad.pyi,sha256=57oK0Yp53rtKjjIrRFYLcxa-IfIGhtI-bEem7ggJKwI,132
+numpy/typing/tests/data/fail/arrayprint.pyi,sha256=-Fs9VnQfxyfak008Hq8kJWfB0snA6jGDXZz8ljQnwGE,549
+numpy/typing/tests/data/fail/arrayterator.pyi,sha256=FoU4ahHkJZ67dwWXer5FXLjjjesKKg-w2Jq1X1bHymA,480
+numpy/typing/tests/data/fail/bitwise_ops.pyi,sha256=GN9dVqk4_HFXn7zbRrHzJq_UGRFBccoYVUG1UuE7bXs,515
+numpy/typing/tests/data/fail/char.pyi,sha256=-vgN6EmfQ8VaA4SOZ5Ol9u4-Z7Q5I7G78LmaxZOuZ90,2615
+numpy/typing/tests/data/fail/chararray.pyi,sha256=jrNryZFpr8nxG2IHb9e0x3ranpvJpBy_RDex-WpT5rU,2296
+numpy/typing/tests/data/fail/comparisons.pyi,sha256=U4neWzwwtxG6QXsKlNGJuKXHBtwzYBQOa47_7SKF5Wg,888
+numpy/typing/tests/data/fail/constants.pyi,sha256=YSqNbXdhbdMmYbs7ntH0FCKbnm8IFeqsDlZBqcU43iw,286
+numpy/typing/tests/data/fail/datasource.pyi,sha256=PRT2hixR-mVxr2UILvHa99Dr54EF2h3snJXE-v3rWcc,395
+numpy/typing/tests/data/fail/dtype.pyi,sha256=OAGABqdXNB8gClJFEGMckoycuZcIasMaAlS2RkiKROI,334
+numpy/typing/tests/data/fail/einsumfunc.pyi,sha256=O6lo1B3IpdBQ_r6nvJudEYRekl_2g8j3PAH_eahvvyY,737
+numpy/typing/tests/data/fail/false_positives.pyi,sha256=Q61qMsSsNCtmO0EMRxHj5Z7RYTyrELVpkzfJY5eK8Z0,366
+numpy/typing/tests/data/fail/flatiter.pyi,sha256=qLM4qm7gvJtEZ0rTHcyasUzoP5JbX4FREtqV3g1w6Lo,843
+numpy/typing/tests/data/fail/fromnumeric.pyi,sha256=FH2mjkgtCbA9soqlJRhYN7IIfRRrUL1i9mwqcbYKZSc,5591
+numpy/typing/tests/data/fail/histograms.pyi,sha256=yAPVt0rYTwtxnigoGT-u7hhKCE9iYxsXc24x2HGBrmA,367
+numpy/typing/tests/data/fail/index_tricks.pyi,sha256=moINir9iQoi6Q1ZuVg5BuSB9hSBtbg_uzv-Qm_lLYZk,509
+numpy/typing/tests/data/fail/lib_function_base.pyi,sha256=6y9T773CBLX-jUry1sCQGVuKVKM2wMuQ56Ni5V5j4Dw,2081
+numpy/typing/tests/data/fail/lib_polynomial.pyi,sha256=siSXSVM0FqwwdHnYrYksOrnMrgdK_zdZ9xGVQ67iMNw,913
+numpy/typing/tests/data/fail/lib_utils.pyi,sha256=VFpE6_DisvlDByyp1PiNPJEe5IcZp8cH0FlAJyoZipo,276
+numpy/typing/tests/data/fail/lib_version.pyi,sha256=7-ZJDZwDcB-wzpMN8TeYtZAgaqc7xnQ8Dnx2ISiX2Ts,158
+numpy/typing/tests/data/fail/linalg.pyi,sha256=yDd05aK1dI37RPt3pD2eJYo4dZFaT2yB1PEu3K0y9Tg,1322
+numpy/typing/tests/data/fail/memmap.pyi,sha256=HSTCQYNuW1Y6X1Woj361pN4rusSPs4oDCXywqk20yUo,159
+numpy/typing/tests/data/fail/modules.pyi,sha256=biKdya7jl9ptCNorql1AFHoOtXU9bdTFodlIUQtbwUY,652
+numpy/typing/tests/data/fail/multiarray.pyi,sha256=XCdBxufNhR8ZtG8UMzk8nt9_NC5gJTKP9-xTqKO_K9I,1693
+numpy/typing/tests/data/fail/ndarray.pyi,sha256=YnjXy16RHs_esKelMjB07865CQ7gLyQnXhnitq5Kv5c,405
+numpy/typing/tests/data/fail/ndarray_misc.pyi,sha256=w-10xTDDWoff9Lq0dBO-jBeiBR-XjCz2qmes0dLx238,1372
+numpy/typing/tests/data/fail/nditer.pyi,sha256=w7emjnOxnf3NcvLktNLlke6Cuivn2gU3sVmGCfbG6rw,325
+numpy/typing/tests/data/fail/nested_sequence.pyi,sha256=em4GZwLDFE0QSxxg081wVwhh-Dmtkn8f7wThI0DiXVs,427
+numpy/typing/tests/data/fail/npyio.pyi,sha256=nUAt8mHO_ZzKsdo_G9mjJfaBCdrba_Q3KiyJwzMiHys,780
+numpy/typing/tests/data/fail/numerictypes.pyi,sha256=S_AIFg4DsJ1sX3EcCAh7ZlsAkpCsycZ_tU92Sj1DWyY,341
+numpy/typing/tests/data/fail/random.pyi,sha256=p5WsUGyOL-MGIeALh9Y0dVhYSRQLaUwMdjXc3G6C_7Q,2830
+numpy/typing/tests/data/fail/rec.pyi,sha256=Ws3TyesnoQjt7Q0wwtpShRDJmZCs2jjP17buFMomVGA,704
+numpy/typing/tests/data/fail/scalars.pyi,sha256=o91BwSfzPTczYVtbXsirqQUoUoYP1C_msGjc2GYsV04,2952
+numpy/typing/tests/data/fail/shape_base.pyi,sha256=Y_f4buHtX2Q2ZA4kaDTyR8LErlPXTzCB_-jBoScGh_Q,152
+numpy/typing/tests/data/fail/stride_tricks.pyi,sha256=IjA0Xrnx0lG3m07d1Hjbhtyo1Te5cXgjgr5fLUo4LYQ,315
+numpy/typing/tests/data/fail/testing.pyi,sha256=e7b5GKTWCtKGoB8z2a8edsW0Xjl1rMheALsvzEJjlCw,1370
+numpy/typing/tests/data/fail/twodim_base.pyi,sha256=ZqbRJfy5S_pW3fFLuomy4L5SBNqj6Nklexg9KDTo65c,899
+numpy/typing/tests/data/fail/type_check.pyi,sha256=CIyI0j0Buxv0QgCvNG2urjaKpoIZ-ZNawC2m6NzGlbo,379
+numpy/typing/tests/data/fail/ufunc_config.pyi,sha256=ukA0xwfJHLoGfoOIpWIN-91wj-DG8oaIjYbO72ymjg4,733
+numpy/typing/tests/data/fail/ufunclike.pyi,sha256=lbxjJyfARmt_QK1HxhxFxvwQTqCEZwJ9I53Wp8X3KIY,679
+numpy/typing/tests/data/fail/ufuncs.pyi,sha256=YaDTL7QLmGSUxE6JVMzpOlZTjHWrgbOo0UIlkX-6ZQk,1347
+numpy/typing/tests/data/fail/warnings_and_errors.pyi,sha256=PrbYDFI7IGN3Gf0OPBkVfefzQs4AXHwDQ495pvrX3RY,174
+numpy/typing/tests/data/misc/extended_precision.pyi,sha256=XJE_Qjaou-yzhww8K_3ypc4WTPudW0b3g0-T82aB8QE,347
+numpy/typing/tests/data/mypy.ini,sha256=a4--l5EymPReC-WKEsCfl2Nve_1T4XTFcoexa5q2MpY,166
+numpy/typing/tests/data/pass/__pycache__/arithmetic.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/array_constructors.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/array_like.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/arrayprint.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/arrayterator.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/bitwise_ops.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/comparisons.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/dtype.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/einsumfunc.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/flatiter.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/fromnumeric.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/index_tricks.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/lib_utils.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/lib_version.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/literal.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/mod.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/modules.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/multiarray.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/ndarray_conversion.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/ndarray_misc.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/ndarray_shape_manipulation.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/numeric.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/numerictypes.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/random.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/scalars.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/simple.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/simple_py3.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/ufunc_config.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/ufunclike.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/ufuncs.cpython-310.pyc,,
+numpy/typing/tests/data/pass/__pycache__/warnings_and_errors.cpython-310.pyc,,
+numpy/typing/tests/data/pass/arithmetic.py,sha256=2z3dmuysQQmiPz8x0bg8SOOKW62mVJn97uMa9T0L7Vk,7455
+numpy/typing/tests/data/pass/array_constructors.py,sha256=3GrhfBcmWX53pJHD0NvhXjwr2-uNKREbR1I9WCcZ7rI,2419
+numpy/typing/tests/data/pass/array_like.py,sha256=ce_IVubBd7J6FkSpJmD7qMlRLuwmiidhOqhYfZb16Wo,916
+numpy/typing/tests/data/pass/arrayprint.py,sha256=y_KkuLz1uM7pv53qfq7GQOuud4LoXE3apK1wtARdVyM,766
+numpy/typing/tests/data/pass/arrayterator.py,sha256=FqcpKdUQBQ0FazHFxr9MsLEZG-jnJVGKWZX2owRr4DQ,393
+numpy/typing/tests/data/pass/bitwise_ops.py,sha256=UnmxVr9HwI8ifdrutGm_u3EZU4iOOPQhrOku7hTaH0c,970
+numpy/typing/tests/data/pass/comparisons.py,sha256=nTE-fvraLK6xTZcP4uPV02wOShzYKWDaoapx35AeDOY,2992
+numpy/typing/tests/data/pass/dtype.py,sha256=lI_5QlB7_20TyC1Urxr0No9MbrhpBHQxs-F_v7UyPmo,1073
+numpy/typing/tests/data/pass/einsumfunc.py,sha256=eXj5L5MWPtQHgrHPsJ36qqrmBHqct9UoujjJCvHnF1k,1370
+numpy/typing/tests/data/pass/flatiter.py,sha256=0BnbuLMBC7MQlprNZ0QhNSscfYwPhEhXOhWoyiRACWU,174
+numpy/typing/tests/data/pass/fromnumeric.py,sha256=Xd_nJVVDoONdztUX8ddgo7EXJ2FD8AX51MO_Yujnmog,3742
+numpy/typing/tests/data/pass/index_tricks.py,sha256=oaFD9vY01_RI5OkrXt-xTk1n_dd-SpuPp-eZ58XR3c8,1492
+numpy/typing/tests/data/pass/lib_utils.py,sha256=SEJRuh7J7JHHlOVctf-zQ9zRwVpCvZ_HvAXHvDrjxw0,420
+numpy/typing/tests/data/pass/lib_version.py,sha256=HnuGOx7tQA_bcxFIJ3dRoMAR0fockxg4lGqQ4g7LGIw,299
+numpy/typing/tests/data/pass/literal.py,sha256=DLzdWHD6ttW4S0NEvGQbsH_UEJjhZyhvO4OXJjoyvZQ,1331
+numpy/typing/tests/data/pass/mod.py,sha256=HB9aK4_wGJbc44tomaoroNy0foIL5cI9KIjknvMTbkk,1578
+numpy/typing/tests/data/pass/modules.py,sha256=f-6R2TbqrLX7F8A3Z9VgSyPAlOwvOy1zZyvUgivD250,595
+numpy/typing/tests/data/pass/multiarray.py,sha256=MxHax6l94yqlTVZleAqG77ILEbW6wU5osPcHzxJ85ns,1331
+numpy/typing/tests/data/pass/ndarray_conversion.py,sha256=yPgzXG6paY1uF_z-QyHYrcmrZvhX7qtvTUh7ANLseCA,1626
+numpy/typing/tests/data/pass/ndarray_misc.py,sha256=GXgleH_TDgS9cMVYhEpWwOmSs3_jfB09zGEb10cizk0,2715
+numpy/typing/tests/data/pass/ndarray_shape_manipulation.py,sha256=37eYwMNqMLwanIW9-63hrokacnSz2K_qtPUlkdpsTjo,640
+numpy/typing/tests/data/pass/numeric.py,sha256=SdnsD5zv0wm8T2hnIylyS14ig2McSz6rG9YslckbNQ4,1490
+numpy/typing/tests/data/pass/numerictypes.py,sha256=JnP5m-QpK7YEfeeYzaDyIUUQ_q95hjSQMIgUIPTdSwU,973
+numpy/typing/tests/data/pass/random.py,sha256=uJCnzlsOn9hr_G1TpHLdsweJI4EdhUSEQ4dxROPjqAs,61881
+numpy/typing/tests/data/pass/scalars.py,sha256=En0adCZAwEigZrzdQ0JQwDEmrS0b-DMd1vvjkFcvwo8,3479
+numpy/typing/tests/data/pass/simple.py,sha256=Vf3nKTGD6kSqoaH2MWSDRny2-knWX-fQHoEJONC7q9s,2684
+numpy/typing/tests/data/pass/simple_py3.py,sha256=HuLrc5aphThQkLjU2_19KgGFaXwKOfSzXe0p2xMm8ZI,96
+numpy/typing/tests/data/pass/ufunc_config.py,sha256=b0nWLyq0V2H4mKZXrNM0kT-GM-x8ig9tv3al50_YAWM,1120
+numpy/typing/tests/data/pass/ufunclike.py,sha256=Gve6cJ2AT3TAwOjUOQQDIUnqsRCGYq70_tv_sgODiiA,1039
+numpy/typing/tests/data/pass/ufuncs.py,sha256=xGuKuqPetUTS4io5YDHaki5nbYRu-wC29SGU32tzVIg,462
+numpy/typing/tests/data/pass/warnings_and_errors.py,sha256=Pcg-QWfY4PAhTKyehae8q6LhtbUABxa2Ye63-3h1f4w,150
+numpy/typing/tests/data/reveal/arithmetic.pyi,sha256=kTKcuu9SHUdR_1LCp4lA7DdbY_Olhx8s17zyrGc3sNM,20805
+numpy/typing/tests/data/reveal/array_constructors.pyi,sha256=Xxqgv57qeqGcBgv0oi8qtl2p3Gr4ecGwF4c2IkA5_sY,11831
+numpy/typing/tests/data/reveal/arraypad.pyi,sha256=9S-6k9KTi4TrKO-s-cW1jvoWry7mc-8G4VVIU7cqICY,694
+numpy/typing/tests/data/reveal/arrayprint.pyi,sha256=2C2mIauAAGfor2_YsCTXPGu5gZhln7acekNp5T4Ekxs,686
+numpy/typing/tests/data/reveal/arraysetops.pyi,sha256=cKxJCQKVLOAXRDi0XGc-pFvHqzYfJW3w3O5JwD3bfW0,4671
+numpy/typing/tests/data/reveal/arrayterator.pyi,sha256=OEt5c-fFsve0Qc4e2Jb9_HN1BKUrCJU-YSAf_GTvKe8,1128
+numpy/typing/tests/data/reveal/bitwise_ops.pyi,sha256=t7nz7G8SNpGw_8Hdmpwl68pBH1fGHS6JVQAa5e8dd2s,3607
+numpy/typing/tests/data/reveal/char.pyi,sha256=VjyPAgov14MyqEuGJO-4NovgqcU5nfuZ0opefDZmfzE,8047
+numpy/typing/tests/data/reveal/chararray.pyi,sha256=_7dslcz7tDdoicD8XAa6ql7Ye71LRWeH1bnNQ4bxxN4,6312
+numpy/typing/tests/data/reveal/comparisons.pyi,sha256=jkpzpxnjqahq6dw9ynuHto54SH9nwUMWuMWBf3zT6Gk,8018
+numpy/typing/tests/data/reveal/constants.pyi,sha256=RFPG2UQfP6aRLtDLmL72iz2tqfkLC0GX0uIPUQPLfi8,1940
+numpy/typing/tests/data/reveal/ctypeslib.pyi,sha256=Qps3eZyBg8vLhPHj5z_osnlltRHba5F1qgAMHCeHl6o,5107
+numpy/typing/tests/data/reveal/datasource.pyi,sha256=melhwwltIDET_oudcv-skR8jKrGeVF5UOZVqfSKjXBw,557
+numpy/typing/tests/data/reveal/dtype.pyi,sha256=LPfmLrzHAnlRqvDbpNu5_HB61GH5PxYiiP7NgsPwfGM,2787
+numpy/typing/tests/data/reveal/einsumfunc.pyi,sha256=Gx1K9tAxlP-dH7kgKiiJfJXeUvqWjY5XSLxEk0EGLjw,2075
+numpy/typing/tests/data/reveal/emath.pyi,sha256=iieDKvLNdM0DSJ-CiG9DNrnBc-p7LhV6DDDZxGFGDfQ,2538
+numpy/typing/tests/data/reveal/false_positives.pyi,sha256=oQx8mhWsl0V7Zg7d49ZmFGiUV9azVdGPbrXgk1Faj70,349
+numpy/typing/tests/data/reveal/fft.pyi,sha256=T5w3JYzXQhZdfYk7oGXr9fZf1T9kOqaHS2e0DSAOB4I,1852
+numpy/typing/tests/data/reveal/flatiter.pyi,sha256=Ks3dXflFJzOD3uo4S3J_SsodD0AqlL7uRMISweDDyxI,819
+numpy/typing/tests/data/reveal/fromnumeric.pyi,sha256=qHv6SiH3llJjvrL8A3P3eg6b-wNnNribI60Gv9uPFSw,13631
+numpy/typing/tests/data/reveal/getlimits.pyi,sha256=XCjHClh1U8G-KawZAif3B4vD60e83YTEie1cR9oFRKw,1547
+numpy/typing/tests/data/reveal/histograms.pyi,sha256=9xBXQvL5n670oencXNwqNveDPH8dXHKK9djEvnQ0d7Q,1391
+numpy/typing/tests/data/reveal/index_tricks.pyi,sha256=oMkRrY65nIZTQ4WWRPdN7GFv9A0FA47MF_8ALYQbS14,3481
+numpy/typing/tests/data/reveal/lib_function_base.pyi,sha256=0NM8272vgD_RhbLm2vlzX9vYkdFc_yV_4KKy4xSgqzg,9140
+numpy/typing/tests/data/reveal/lib_polynomial.pyi,sha256=r3WFzw-MOAyl2DeNIKrAPOTjBBjrTJHJYtE7chiAbyw,6353
+numpy/typing/tests/data/reveal/lib_utils.pyi,sha256=3FASdA5Z7XlefhOBamomqbx917hDl4LoBqFD10BC3x0,917
+numpy/typing/tests/data/reveal/lib_version.pyi,sha256=SEo2pRemac1XnmhNDOKEEM0oHf8E0BTJR4rqJekI3fI,605
+numpy/typing/tests/data/reveal/linalg.pyi,sha256=QPfMGXSOSoIT-kGPV0PysdJxVr7Qfklr9zM7R8hy_N8,6389
+numpy/typing/tests/data/reveal/matrix.pyi,sha256=QiJFt5JxiM_KTmzSs3k9jUcjNssdMGBjD1RrbP4nEdM,3033
+numpy/typing/tests/data/reveal/memmap.pyi,sha256=rNVyEHg5RU_g77H7UgDBpPHHmgRsWogqf09wXc0n7oI,755
+numpy/typing/tests/data/reveal/mod.pyi,sha256=a-d4dlG69pP_2YmQ-H63S7gfgAr_EzqzZlVLXrCAam8,5989
+numpy/typing/tests/data/reveal/modules.pyi,sha256=xarouCu6De5qF9dFqrGZafxZ85p7npV958o-uYIxG0E,1910
+numpy/typing/tests/data/reveal/multiarray.pyi,sha256=uSLZoWQSHHImm7nOmBtHy9Psmxy6qO3Xjt8ETvLNozs,5670
+numpy/typing/tests/data/reveal/nbit_base_example.pyi,sha256=dlpC5thGC-6iPNwjEckkequk2jeNjbfAFK0xyDNqmOQ,500
+numpy/typing/tests/data/reveal/ndarray_conversion.pyi,sha256=wzVZpYgNbyeHmMWZd_k0wwbiXRrOMy-_0YL-uVeiJCw,1913
+numpy/typing/tests/data/reveal/ndarray_misc.pyi,sha256=m-dyLVRdHByzXxoUhhKqWYjdF9j6D_SJ_GaNpuAOts8,7797
+numpy/typing/tests/data/reveal/ndarray_shape_manipulation.pyi,sha256=Ywz-fsGOQBfzs62Z2hwLlStZJk1-XqU12EhF1XV-80M,904
+numpy/typing/tests/data/reveal/nditer.pyi,sha256=7bxrQBoMou8014t7biD44Gx53-w0yK7dipZuX-GHPVI,2067
+numpy/typing/tests/data/reveal/nested_sequence.pyi,sha256=k8Aac9HP6cunRWwkU7BKR25UrTHpEpPOX5zsyldRdiQ,648
+numpy/typing/tests/data/reveal/npyio.pyi,sha256=UJ1znmJlAW7_hH6ph0PyWKw6tzK6XQNqppPrO54r9uU,4464
+numpy/typing/tests/data/reveal/numeric.pyi,sha256=YJBFghgxK3BBueERO5V3o7VqrmklKUtrmGsXXQPH3RY,6802
+numpy/typing/tests/data/reveal/numerictypes.pyi,sha256=Hjj6lrqqtDWvBtYECcfm4_xoeJvY5MiTCaqprt8Gxx0,1786
+numpy/typing/tests/data/reveal/random.pyi,sha256=DHNG_nJnRd6M1pWJVp5trOGrikeSXStRdRIC91xQoMM,129510
+numpy/typing/tests/data/reveal/rec.pyi,sha256=SObXQ2Td2wWPmI_Ilu_4MU9OfZpv-F_FeQIS-kVCjVs,3380
+numpy/typing/tests/data/reveal/scalars.pyi,sha256=0E5riHyQYmnT683H0L-fINyNQa_vn-Gl89OyYDlSjtE,5397
+numpy/typing/tests/data/reveal/shape_base.pyi,sha256=4p8Pazg55LxX41edkDu8wwAUg6wwUfrPVjCvfL4tVo8,2632
+numpy/typing/tests/data/reveal/stride_tricks.pyi,sha256=hhWXM8W88kieGN-07k5vgJnc5T9jBtx0e9S6f3AkXus,1563
+numpy/typing/tests/data/reveal/testing.pyi,sha256=suu0v3cHRAoz9bZ9zcMJdIavomX1IDDI8OpQRlDQFsI,9020
+numpy/typing/tests/data/reveal/twodim_base.pyi,sha256=Nst-USEDdDOddfyBy1RrmxQWmDHRKPd32SVHIhPd9fk,3327
+numpy/typing/tests/data/reveal/type_check.pyi,sha256=bkUwGo1PRIOwlsQ5Lzb4CI-4vc_QaD-75wwW9dxfrGs,3031
+numpy/typing/tests/data/reveal/ufunc_config.pyi,sha256=178x2bi3cwqRvGtfMWVdgy1zngKWtYPKq3iRfNicbHo,1304
+numpy/typing/tests/data/reveal/ufunclike.pyi,sha256=49gm2MdQWkwURr3iiykm5xzLWSe1op1z8yIm0SC3Gik,1319
+numpy/typing/tests/data/reveal/ufuncs.pyi,sha256=iau_uG1ombTNB2nhpUgdGnY3Pxx6mUj667tRXfLOvEI,2919
+numpy/typing/tests/data/reveal/version.pyi,sha256=T2ECJgJDcQDd5f71eJmnm_QqmXWYtBnlT5xomJqxAmI,313
+numpy/typing/tests/data/reveal/warnings_and_errors.pyi,sha256=QJb7pCEw-B3pz9OcD6RyK135lYT4CQiyt70yxp708qQ,420
+numpy/typing/tests/test_generic_alias.py,sha256=h8x4spOLptF3RtjlKEvI4YaV1YXxXEdKhK_LFebZqDA,7030
+numpy/typing/tests/test_isfile.py,sha256=xF6aWRj0ciBAPowsGx3fMUwRAryz8lxGDFiJPp-IGxc,812
+numpy/typing/tests/test_runtime.py,sha256=xJn6gWjpA44mRRNwRmKqO4z5ku1kn2V1tlXOaIwHLsA,3375
+numpy/typing/tests/test_typing.py,sha256=VqgCr14b1pN2EvC_LjyNnMNvwc3suIV0j6wAcFeZrPE,15312
+numpy/version.py,sha256=7WfmOFcKsQVxivXN6g0qZS_-D2PO9GisAfROkq5VlA8,475
diff --git a/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/REQUESTED b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/WHEEL b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..df5f4fa4e42392b77ac9a5cca84d7d88eb1d1689
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+
diff --git a/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/entry_points.txt b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..48f792162e858754e9b3ce903cc6c0ab3eeec6d4
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/entry_points.txt
@@ -0,0 +1,11 @@
+[array_api]
+numpy = numpy.array_api
+
+[console_scripts]
+f2py = numpy.f2py.f2py2e:main
+f2py3 = numpy.f2py.f2py2e:main
+f2py3.10 = numpy.f2py.f2py2e:main
+
+[pyinstaller40]
+hook-dirs = numpy:_pyinstaller_hooks_dir
+
diff --git a/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/top_level.txt b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..24ce15ab7ead32f98c7ac3edcd34bb2010ff4326
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/numpy-1.24.4.dist-info/top_level.txt
@@ -0,0 +1 @@
+numpy
diff --git a/videollama2/lib/python3.10/site-packages/shortuuid-1.0.13.dist-info/INSTALLER b/videollama2/lib/python3.10/site-packages/shortuuid-1.0.13.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/shortuuid-1.0.13.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/videollama2/lib/python3.10/site-packages/shortuuid-1.0.13.dist-info/WHEEL b/videollama2/lib/python3.10/site-packages/shortuuid-1.0.13.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..3695fd1473b2fb25c1cbe89250e443f498e8bc37
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/shortuuid-1.0.13.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.7.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/videollama2/lib/python3.10/site-packages/shortuuid-1.0.13.dist-info/entry_points.txt b/videollama2/lib/python3.10/site-packages/shortuuid-1.0.13.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1df30b91515c8d44755d46a35d3cbb933c7ee0e6
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/shortuuid-1.0.13.dist-info/entry_points.txt
@@ -0,0 +1,3 @@
+[console_scripts]
+shortuuid=shortuuid.cli:cli
+
diff --git a/videollama2/lib/python3.10/site-packages/timm-1.0.3.dist-info/WHEEL b/videollama2/lib/python3.10/site-packages/timm-1.0.3.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..20fb324c0c6ef128ac6ebbe521f682e37e5c629f
--- /dev/null
+++ b/videollama2/lib/python3.10/site-packages/timm-1.0.3.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/advance.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/advance.h
new file mode 100644
index 0000000000000000000000000000000000000000..17ba093634a93afa2196f37cd8ef63e59b4c50f5
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/advance.h
@@ -0,0 +1,243 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_ADVANCE_H
+#define _LIBCUDACXX___ITERATOR_ADVANCE_H
+
+#include
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+# pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+# pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+# pragma system_header
+#endif // no system header
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void
+__advance(_InputIter& __i, typename iterator_traits<_InputIter>::difference_type __n, input_iterator_tag)
+{
+ for (; __n > 0; --__n)
+ {
+ ++__i;
+ }
+}
+
+template
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void
+__advance(_BiDirIter& __i, typename iterator_traits<_BiDirIter>::difference_type __n, bidirectional_iterator_tag)
+{
+ if (__n >= 0)
+ {
+ for (; __n > 0; --__n)
+ {
+ ++__i;
+ }
+ }
+ else
+ {
+ for (; __n < 0; ++__n)
+ {
+ --__i;
+ }
+ }
+}
+
+template
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void
+__advance(_RandIter& __i, typename iterator_traits<_RandIter>::difference_type __n, random_access_iterator_tag)
+{
+ __i += __n;
+}
+
+template ())),
+ class = enable_if_t::value>>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 void advance(_InputIter& __i, _Distance __orig_n)
+{
+ typedef typename iterator_traits<_InputIter>::difference_type _Difference;
+ _Difference __n = static_cast<_Difference>(_CUDA_VSTD::__convert_to_integral(__orig_n));
+ _CCCL_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
+ "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
+ _CUDA_VSTD::__advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#if _CCCL_STD_VER > 2014 && !defined(_LICBUDACXX_COMPILER_MSVC_2017)
+
+// [range.iter.op.advance]
+
+_LIBCUDACXX_BEGIN_NAMESPACE_RANGES
+_LIBCUDACXX_BEGIN_NAMESPACE_CPO(__advance)
+struct __fn
+{
+private:
+ template
+ _LIBCUDACXX_HIDE_FROM_ABI static constexpr void __advance_forward(_Ip& __i, iter_difference_t<_Ip> __n)
+ {
+ while (__n > 0)
+ {
+ --__n;
+ ++__i;
+ }
+ }
+
+ template
+ _LIBCUDACXX_HIDE_FROM_ABI static constexpr void __advance_backward(_Ip& __i, iter_difference_t<_Ip> __n)
+ {
+ while (__n < 0)
+ {
+ ++__n;
+ --__i;
+ }
+ }
+
+ template
+ _LIBCUDACXX_HIDE_FROM_ABI static constexpr auto __magnitude_geq(_Iter_difference __a, _Iter_difference __b) noexcept
+ {
+ return __a == 0 ? __b == 0 : //
+ __a > 0 ? __a >= __b
+ : __a <= __b;
+ };
+
+public:
+ // Preconditions: If `I` does not model `bidirectional_iterator`, `n` is not negative.
+
+ _CCCL_TEMPLATE(class _Ip)
+ _CCCL_REQUIRES(input_or_output_iterator<_Ip>)
+ _LIBCUDACXX_HIDE_FROM_ABI constexpr void operator()(_Ip& __i, iter_difference_t<_Ip> __n) const
+ {
+ _CCCL_ASSERT(__n >= 0 || bidirectional_iterator<_Ip>, "If `n < 0`, then `bidirectional_iterator` must be true.");
+
+ // If `I` models `random_access_iterator`, equivalent to `i += n`.
+ if constexpr (random_access_iterator<_Ip>)
+ {
+ __i += __n;
+ return;
+ }
+ else if constexpr (bidirectional_iterator<_Ip>)
+ {
+ // Otherwise, if `n` is non-negative, increments `i` by `n`.
+ __advance_forward(__i, __n);
+ // Otherwise, decrements `i` by `-n`.
+ __advance_backward(__i, __n);
+ return;
+ }
+ else
+ {
+ // Otherwise, if `n` is non-negative, increments `i` by `n`.
+ __advance_forward(__i, __n);
+ return;
+ }
+ }
+
+ _CCCL_TEMPLATE(class _Ip, class _Sp)
+ _CCCL_REQUIRES(input_or_output_iterator<_Ip> _CCCL_AND sentinel_for<_Sp, _Ip>)
+ _LIBCUDACXX_HIDE_FROM_ABI constexpr void operator()(_Ip& __i, _Sp __bound_sentinel) const
+ {
+ // If `I` and `S` model `assignable_from`, equivalent to `i = std::move(bound_sentinel)`.
+ if constexpr (assignable_from<_Ip&, _Sp>)
+ {
+ __i = _CUDA_VSTD::move(__bound_sentinel);
+ }
+ // Otherwise, if `S` and `I` model `sized_sentinel_for`,
+ // equivalent to `ranges::advance(i, bound_sentinel - i)`.
+ else if constexpr (sized_sentinel_for<_Sp, _Ip>)
+ {
+ (*this)(__i, __bound_sentinel - __i);
+ }
+ // Otherwise, while `bool(i != bound_sentinel)` is true, increments `i`.
+ else
+ {
+ while (__i != __bound_sentinel)
+ {
+ ++__i;
+ }
+ }
+ }
+
+ // Preconditions:
+ // * If `n > 0`, [i, bound_sentinel) denotes a range.
+ // * If `n == 0`, [i, bound_sentinel) or [bound_sentinel, i) denotes a range.
+ // * If `n < 0`, [bound_sentinel, i) denotes a range, `I` models `bidirectional_iterator`,
+ // and `I` and `S` model `same_as`.
+ // Returns: `n - M`, where `M` is the difference between the ending and starting position.
+ _CCCL_TEMPLATE(class _Ip, class _Sp)
+ _CCCL_REQUIRES(input_or_output_iterator<_Ip> _CCCL_AND sentinel_for<_Sp, _Ip>)
+ _LIBCUDACXX_HIDE_FROM_ABI constexpr iter_difference_t<_Ip>
+ operator()(_Ip& __i, iter_difference_t<_Ip> __n, _Sp __bound_sentinel) const
+ {
+ _CCCL_ASSERT((__n >= 0) || (bidirectional_iterator<_Ip> && same_as<_Ip, _Sp>),
+ "If `n < 0`, then `bidirectional_iterator && same_as` must be true.");
+ // If `S` and `I` model `sized_sentinel_for`:
+ if constexpr (sized_sentinel_for<_Sp, _Ip>)
+ {
+ // If |n| >= |bound_sentinel - i|, equivalent to `ranges::advance(i, bound_sentinel)`.
+ // __magnitude_geq(a, b) returns |a| >= |b|, assuming they have the same sign.
+ const auto __M = __bound_sentinel - __i;
+ if (__magnitude_geq(__n, __M))
+ {
+ (*this)(__i, __bound_sentinel);
+ return __n - __M;
+ }
+
+ // Otherwise, equivalent to `ranges::advance(i, n)`.
+ (*this)(__i, __n);
+ return 0;
+ }
+ else
+ {
+ // Otherwise, if `n` is non-negative, while `bool(i != bound_sentinel)` is true, increments `i` but at
+ // most `n` times.
+ while (__i != __bound_sentinel && __n > 0)
+ {
+ ++__i;
+ --__n;
+ }
+
+ // Otherwise, while `bool(i != bound_sentinel)` is true, decrements `i` but at most `-n` times.
+ if constexpr (bidirectional_iterator<_Ip> && same_as<_Ip, _Sp>)
+ {
+ while (__i != __bound_sentinel && __n < 0)
+ {
+ --__i;
+ ++__n;
+ }
+ }
+ return __n;
+ }
+ _CCCL_UNREACHABLE();
+ }
+};
+_LIBCUDACXX_END_NAMESPACE_CPO
+
+inline namespace __cpo
+{
+_CCCL_GLOBAL_CONSTANT auto advance = __advance::__fn{};
+} // namespace __cpo
+
+_LIBCUDACXX_END_NAMESPACE_RANGES
+
+#endif // _CCCL_STD_VER > 2014 && !_LICBUDACXX_COMPILER_MSVC_2017
+
+#endif // _LIBCUDACXX___ITERATOR_ADVANCE_H
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/data.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/data.h
new file mode 100644
index 0000000000000000000000000000000000000000..f51d84888dfde5abddd631e1af7d4238d0879604
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/data.h
@@ -0,0 +1,63 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_DATA_H
+#define _LIBCUDACXX___ITERATOR_DATA_H
+
+#include
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+# pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+# pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+# pragma system_header
+#endif // no system header
+
+#include
+#include
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _CCCL_STD_VER > 2011
+
+_CCCL_EXEC_CHECK_DISABLE
+template
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr auto
+data(_Cont& __c) noexcept(noexcept(__c.data())) -> decltype(__c.data())
+{
+ return __c.data();
+}
+
+_CCCL_EXEC_CHECK_DISABLE
+template
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr auto
+data(const _Cont& __c) noexcept(noexcept(__c.data())) -> decltype(__c.data())
+{
+ return __c.data();
+}
+
+template
+_LIBCUDACXX_HIDE_FROM_ABI constexpr _Tp* data(_Tp (&__array)[_Sz]) noexcept
+{
+ return __array;
+}
+
+template
+_LIBCUDACXX_HIDE_FROM_ABI constexpr const _Ep* data(initializer_list<_Ep> __il) noexcept
+{
+ return __il.begin();
+}
+
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_DATA_H
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/default_sentinel.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/default_sentinel.h
new file mode 100644
index 0000000000000000000000000000000000000000..f921e1f9af20eb730ed40c7c1c4926561f8d2316
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/default_sentinel.h
@@ -0,0 +1,36 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_DEFAULT_SENTINEL_H
+#define _LIBCUDACXX___ITERATOR_DEFAULT_SENTINEL_H
+
+#include
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+# pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+# pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+# pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _CCCL_STD_VER > 2014
+
+struct default_sentinel_t
+{};
+inline constexpr default_sentinel_t default_sentinel{};
+
+#endif // _CCCL_STD_VER > 2014
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_DEFAULT_SENTINEL_H
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/distance.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/distance.h
new file mode 100644
index 0000000000000000000000000000000000000000..441c30c9a9ffd2212c0ff4ae9655406e2280f40c
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/distance.h
@@ -0,0 +1,123 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023-24 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_DISTANCE_H
+#define _LIBCUDACXX___ITERATOR_DISTANCE_H
+
+#include
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+# pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+# pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+# pragma system_header
+#endif // no system header
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 typename iterator_traits<_InputIter>::difference_type
+__distance(_InputIter __first, _InputIter __last, input_iterator_tag)
+{
+ typename iterator_traits<_InputIter>::difference_type __r(0);
+ for (; __first != __last; ++__first)
+ {
+ ++__r;
+ }
+ return __r;
+}
+
+template
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 typename iterator_traits<_RandIter>::difference_type
+__distance(_RandIter __first, _RandIter __last, random_access_iterator_tag)
+{
+ return __last - __first;
+}
+
+template
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 typename iterator_traits<_InputIter>::difference_type
+distance(_InputIter __first, _InputIter __last)
+{
+ return _CUDA_VSTD::__distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category());
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+#if _CCCL_STD_VER > 2014 && !_CCCL_COMPILER(MSVC2017)
+
+// [range.iter.op.distance]
+
+_LIBCUDACXX_BEGIN_NAMESPACE_RANGES
+_LIBCUDACXX_BEGIN_NAMESPACE_CPO(__distance)
+struct __fn
+{
+ _CCCL_TEMPLATE(class _Ip, class _Sp)
+ _CCCL_REQUIRES((sentinel_for<_Sp, _Ip> && !sized_sentinel_for<_Sp, _Ip>) )
+ _LIBCUDACXX_HIDE_FROM_ABI constexpr iter_difference_t<_Ip> operator()(_Ip __first, _Sp __last) const
+ {
+ iter_difference_t<_Ip> __n = 0;
+ while (__first != __last)
+ {
+ ++__first;
+ ++__n;
+ }
+ return __n;
+ }
+
+ _CCCL_TEMPLATE(class _Ip, class _Sp)
+ _CCCL_REQUIRES((sized_sentinel_for<_Sp, decay_t<_Ip>>) )
+ _LIBCUDACXX_HIDE_FROM_ABI constexpr iter_difference_t<_Ip> operator()(_Ip&& __first, _Sp __last) const
+ {
+ if constexpr (sized_sentinel_for<_Sp, remove_cvref_t<_Ip>>)
+ {
+ return __last - __first;
+ }
+ else
+ {
+ return __last - decay_t<_Ip>(__first);
+ }
+ _CCCL_UNREACHABLE();
+ }
+
+ _CCCL_TEMPLATE(class _Rp)
+ _CCCL_REQUIRES((range<_Rp>) )
+ _LIBCUDACXX_HIDE_FROM_ABI constexpr range_difference_t<_Rp> operator()(_Rp&& __r) const
+ {
+ if constexpr (sized_range<_Rp>)
+ {
+ return static_cast>(_CUDA_VRANGES::size(__r));
+ }
+ else
+ {
+ return operator()(_CUDA_VRANGES::begin(__r), _CUDA_VRANGES::end(__r));
+ }
+ _CCCL_UNREACHABLE();
+ }
+};
+_LIBCUDACXX_END_NAMESPACE_CPO
+
+inline namespace __cpo
+{
+_CCCL_GLOBAL_CONSTANT auto distance = __distance::__fn{};
+} // namespace __cpo
+_LIBCUDACXX_END_NAMESPACE_RANGES
+
+#endif // _CCCL_STD_VER > 2014 && !_CCCL_COMPILER(MSVC2017)
+
+#endif // _LIBCUDACXX___ITERATOR_DISTANCE_H
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/empty.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/empty.h
new file mode 100644
index 0000000000000000000000000000000000000000..4dea0eb53e0f97a2a388724ef4d5432acba224f5
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/empty.h
@@ -0,0 +1,54 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_EMPTY_H
+#define _LIBCUDACXX___ITERATOR_EMPTY_H
+
+#include
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+# pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+# pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+# pragma system_header
+#endif // no system header
+
+#include
+#include
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _CCCL_STD_VER > 2011
+
+template
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr auto
+empty(const _Cont& __c) noexcept(noexcept(__c.empty())) -> decltype(__c.empty())
+{
+ return __c.empty();
+}
+
+template
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr bool empty(const _Tp (&)[_Sz]) noexcept
+{
+ return false;
+}
+
+template
+_CCCL_NODISCARD _LIBCUDACXX_HIDE_FROM_ABI constexpr bool empty(initializer_list<_Ep> __il) noexcept
+{
+ return __il.size() == 0;
+}
+
+#endif // _CCCL_STD_VER > 2017
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_EMPTY_H
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/erase_if_container.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/erase_if_container.h
new file mode 100644
index 0000000000000000000000000000000000000000..e4573dc187b17075412765cbf57c83135bf09643
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/erase_if_container.h
@@ -0,0 +1,49 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_ERASE_IF_CONTAINER_H
+#define _LIBCUDACXX___ITERATOR_ERASE_IF_CONTAINER_H
+
+#include
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+# pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+# pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+# pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template
+_LIBCUDACXX_HIDE_FROM_ABI typename _Container::size_type __cccl_erase_if_container(_Container& __c, _Predicate& __pred)
+{
+ typename _Container::size_type __old_size = __c.size();
+
+ const typename _Container::iterator __last = __c.end();
+ for (typename _Container::iterator __iter = __c.begin(); __iter != __last;)
+ {
+ if (__pred(*__iter))
+ {
+ __iter = __c.erase(__iter);
+ }
+ else
+ {
+ ++__iter;
+ }
+ }
+
+ return __old_size - __c.size();
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_ERASE_IF_CONTAINER_H
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/indirectly_comparable.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/indirectly_comparable.h
new file mode 100644
index 0000000000000000000000000000000000000000..7646e3dfb94de6081479e1e97cc716690043ed9d
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/indirectly_comparable.h
@@ -0,0 +1,57 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_INDIRECTLY_COMPARABLE_H
+#define _LIBCUDACXX___ITERATOR_INDIRECTLY_COMPARABLE_H
+
+#include
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+# pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+# pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+# pragma system_header
+#endif // no system header
+
+#include
+#include
+#include
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _CCCL_STD_VER > 2017
+
+template
+concept indirectly_comparable =
+ indirect_binary_predicate<_BinaryPred, projected<_Iter1, _Proj1>, projected<_Iter2, _Proj2>>;
+
+#elif _CCCL_STD_VER >= 2014
+
+// clang-format off
+
+template
+_CCCL_CONCEPT_FRAGMENT(
+ __indirectly_comparable_,
+ requires()(
+ requires(indirect_binary_predicate<_BinaryPred, projected<_Iter1, _Proj1>, projected<_Iter2, _Proj2>>)
+ ));
+
+template
+_CCCL_CONCEPT indirectly_comparable =
+ _CCCL_FRAGMENT(__indirectly_comparable_, _Iter1, _Iter2, _BinaryPred, _Proj1, _Proj2);
+
+// clang-format on
+
+#endif // _CCCL_STD_VER >= 2014
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_INDIRECTLY_COMPARABLE_H
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/insert_iterator.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/insert_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..5d63ba9184731d7de26964059d8a0c094963868e
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/insert_iterator.h
@@ -0,0 +1,101 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_INSERT_ITERATOR_H
+#define _LIBCUDACXX___ITERATOR_INSERT_ITERATOR_H
+
+#include
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+# pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+# pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+# pragma system_header
+#endif // no system header
+
+#include
+#include
+#include
+#include
+#include
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template
+using __insert_iterator_iter_t = typename _Container::iterator;
+
+_CCCL_SUPPRESS_DEPRECATED_PUSH
+template
+class _CCCL_TYPE_VISIBILITY_DEFAULT insert_iterator
+#if _CCCL_STD_VER <= 2014 || !defined(_LIBCUDACXX_ABI_NO_ITERATOR_BASES)
+ : public iterator
+#endif
+{
+ _CCCL_SUPPRESS_DEPRECATED_POP
+
+protected:
+ _Container* container;
+ __insert_iterator_iter_t<_Container> iter;
+
+public:
+ typedef output_iterator_tag iterator_category;
+ typedef void value_type;
+#if _CCCL_STD_VER > 2017
+ typedef ptrdiff_t difference_type;
+#else
+ typedef void difference_type;
+#endif
+ typedef void pointer;
+ typedef void reference;
+ typedef _Container container_type;
+
+ _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20
+ insert_iterator(_Container& __x, __insert_iterator_iter_t<_Container> __i)
+ : container(_CUDA_VSTD::addressof(__x))
+ , iter(__i)
+ {}
+ _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 insert_iterator&
+ operator=(const typename _Container::value_type& __value)
+ {
+ iter = container->insert(iter, __value);
+ ++iter;
+ return *this;
+ }
+ _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 insert_iterator& operator=(typename _Container::value_type&& __value)
+ {
+ iter = container->insert(iter, _CUDA_VSTD::move(__value));
+ ++iter;
+ return *this;
+ }
+ _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 insert_iterator& operator*()
+ {
+ return *this;
+ }
+ _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 insert_iterator& operator++()
+ {
+ return *this;
+ }
+ _LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 insert_iterator& operator++(int)
+ {
+ return *this;
+ }
+};
+
+template
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX20 insert_iterator<_Container>
+inserter(_Container& __x, __insert_iterator_iter_t<_Container> __i)
+{
+ return insert_iterator<_Container>(__x, __i);
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_INSERT_ITERATOR_H
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/istreambuf_iterator.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/istreambuf_iterator.h
new file mode 100644
index 0000000000000000000000000000000000000000..b716ea77c08046ae129bafca721d2afa581add77
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/istreambuf_iterator.h
@@ -0,0 +1,159 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_ISTREAMBUF_ITERATOR_H
+#define _LIBCUDACXX___ITERATOR_ISTREAMBUF_ITERATOR_H
+
+#include
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+# pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+# pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+# pragma system_header
+#endif // no system header
+
+#include
+#include
+#include
+#include
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+_CCCL_SUPPRESS_DEPRECATED_PUSH
+template
+class _CCCL_TYPE_VISIBILITY_DEFAULT istreambuf_iterator
+#if _CCCL_STD_VER <= 2014 || !defined(_LIBCUDACXX_ABI_NO_ITERATOR_BASES)
+ : public iterator
+#endif
+{
+ _CCCL_SUPPRESS_DEPRECATED_POP
+
+public:
+ typedef input_iterator_tag iterator_category;
+ typedef _CharT value_type;
+ typedef typename _Traits::off_type difference_type;
+ typedef _CharT* pointer;
+ typedef _CharT reference;
+ typedef _CharT char_type;
+ typedef _Traits traits_type;
+ typedef typename _Traits::int_type int_type;
+ typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+ typedef basic_istream<_CharT, _Traits> istream_type;
+
+private:
+ mutable streambuf_type* __sbuf_;
+
+ class __proxy
+ {
+ char_type __keep_;
+ streambuf_type* __sbuf_;
+ _LIBCUDACXX_HIDE_FROM_ABI explicit __proxy(char_type __c, streambuf_type* __s)
+ : __keep_(__c)
+ , __sbuf_(__s)
+ {}
+ friend class istreambuf_iterator;
+
+ public:
+ _LIBCUDACXX_HIDE_FROM_ABI char_type operator*() const
+ {
+ return __keep_;
+ }
+ };
+
+ _LIBCUDACXX_HIDE_FROM_ABI bool __test_for_eof() const
+ {
+ if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
+ {
+ __sbuf_ = nullptr;
+ }
+ return __sbuf_ == nullptr;
+ }
+
+public:
+ _LIBCUDACXX_HIDE_FROM_ABI constexpr istreambuf_iterator() noexcept
+ : __sbuf_(nullptr)
+ {}
+#if _CCCL_STD_VER > 2017
+ _LIBCUDACXX_HIDE_FROM_ABI constexpr istreambuf_iterator(default_sentinel_t) noexcept
+ : istreambuf_iterator()
+ {}
+#endif // _CCCL_STD_VER > 2017
+ _LIBCUDACXX_HIDE_FROM_ABI istreambuf_iterator(istream_type& __s) noexcept
+ : __sbuf_(__s.rdbuf())
+ {}
+ _LIBCUDACXX_HIDE_FROM_ABI istreambuf_iterator(streambuf_type* __s) noexcept
+ : __sbuf_(__s)
+ {}
+ _LIBCUDACXX_HIDE_FROM_ABI istreambuf_iterator(const __proxy& __p) noexcept
+ : __sbuf_(__p.__sbuf_)
+ {}
+
+ _LIBCUDACXX_HIDE_FROM_ABI char_type operator*() const
+ {
+ return static_cast(__sbuf_->sgetc());
+ }
+ _LIBCUDACXX_HIDE_FROM_ABI istreambuf_iterator& operator++()
+ {
+ __sbuf_->sbumpc();
+ return *this;
+ }
+ _LIBCUDACXX_HIDE_FROM_ABI __proxy operator++(int)
+ {
+ return __proxy(__sbuf_->sbumpc(), __sbuf_);
+ }
+
+ _LIBCUDACXX_HIDE_FROM_ABI bool equal(const istreambuf_iterator& __b) const
+ {
+ return __test_for_eof() == __b.__test_for_eof();
+ }
+
+#if _CCCL_STD_VER > 2014
+ friend _LIBCUDACXX_HIDE_FROM_ABI bool operator==(const istreambuf_iterator& __i, default_sentinel_t)
+ {
+ return __i.__test_for_eof();
+ }
+# if _CCCL_STD_VER < 2020
+ friend _LIBCUDACXX_HIDE_FROM_ABI bool operator==(default_sentinel_t, const istreambuf_iterator& __i)
+ {
+ return __i.__test_for_eof();
+ }
+ friend _LIBCUDACXX_HIDE_FROM_ABI bool operator!=(const istreambuf_iterator& __i, default_sentinel_t)
+ {
+ return !__i.__test_for_eof();
+ }
+ friend _LIBCUDACXX_HIDE_FROM_ABI bool operator!=(default_sentinel_t, const istreambuf_iterator& __i)
+ {
+ return !__i.__test_for_eof();
+ }
+# endif // _CCCL_STD_VER < 2020
+#endif // _CCCL_STD_VER > 2014
+};
+
+template
+_LIBCUDACXX_HIDE_FROM_ABI bool
+operator==(const istreambuf_iterator<_CharT, _Traits>& __a, const istreambuf_iterator<_CharT, _Traits>& __b)
+{
+ return __a.equal(__b);
+}
+
+#if _CCCL_STD_VER <= 2017
+template
+_LIBCUDACXX_HIDE_FROM_ABI bool
+operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, const istreambuf_iterator<_CharT, _Traits>& __b)
+{
+ return !__a.equal(__b);
+}
+#endif // _CCCL_STD_VER <= 2017
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_ISTREAMBUF_ITERATOR_H
diff --git a/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/iterator_traits.h b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/iterator_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..095880f7cce983324db9358fad60fd588b321ef0
--- /dev/null
+++ b/vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__iterator/iterator_traits.h
@@ -0,0 +1,977 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_ITERATOR_TRAITS_H
+#define _LIBCUDACXX___ITERATOR_ITERATOR_TRAITS_H
+
+#include
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+# pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+# pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+# pragma system_header
+#endif // no system header
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#if !_CCCL_COMPILER(NVRTC)
+# if _CCCL_COMPILER(MSVC)
+# include // for ::std::input_iterator_tag
+# else // ^^^ _CCCL_COMPILER(MSVC) ^^^ / vvv !_CCCL_COMPILER(MSVC) vvv
+# include // for ::std::input_iterator_tag
+# endif // !_CCCL_COMPILER(MSVC)
+
+# ifdef _GLIBCXX_DEBUG
+# include
+# endif
+
+# if _CCCL_STD_VER >= 2020
+template
+struct __cccl_type_is_defined : _CUDA_VSTD::false_type
+{};
+
+template
+struct __cccl_type_is_defined<_Tp, _CUDA_VSTD::void_t> : _CUDA_VSTD::true_type
+{};
+
+// detect whether the used STL has contiguous_iterator_tag defined
+namespace std
+{
+struct __cccl_std_contiguous_iterator_tag_exists : __cccl_type_is_defined
+{};
+} // namespace std
+# endif // _CCCL_STD_VER >= 2020
+
+#endif // !_CCCL_COMPILER(NVRTC)
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if !defined(_CCCL_NO_CONCEPTS)
+
+template
+using __with_reference = _Tp&;
+
+template
+concept __can_reference = requires { typename __with_reference<_Tp>; };
+
+template
+concept __dereferenceable = requires(_Tp& __t) {
+ { *__t } -> __can_reference; // not required to be equality-preserving
+};
+
+// [iterator.traits]
+template <__dereferenceable _Tp>
+using iter_reference_t = decltype(*declval<_Tp&>());
+
+template
+struct _CCCL_TYPE_VISIBILITY_DEFAULT iterator_traits;
+
+#elif _CCCL_STD_VER >= 2014 // ^^^ !_CCCL_NO_CONCEPTS ^^^
+
+template
+using __with_reference = _Tp&;
+
+template
+_CCCL_CONCEPT_FRAGMENT(__can_reference_, requires()(typename(__with_reference<_Tp>)));
+
+template
+_CCCL_CONCEPT __can_reference = _CCCL_FRAGMENT(__can_reference_, _Tp);
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_CLANG("-Wvoid-ptr-dereference")
+template
+_CCCL_CONCEPT_FRAGMENT(__dereferenceable_, requires(_Tp& __t)(requires(__can_reference)));
+_CCCL_DIAG_POP
+
+template
+_CCCL_CONCEPT __dereferenceable = _CCCL_FRAGMENT(__dereferenceable_, _Tp);
+
+// [iterator.traits]
+template
+using iter_reference_t = enable_if_t<__dereferenceable<_Tp>, decltype(*declval<_Tp&>())>;
+
+template
+struct _CCCL_TYPE_VISIBILITY_DEFAULT iterator_traits;
+#else // ^^^ _CCCL_STD_VER >= 2014 ^^^ / vvv _CCCL_STD_VER < 2014 vvv
+template
+struct _CCCL_TYPE_VISIBILITY_DEFAULT iterator_traits;
+#endif // _CCCL_STD_VER < 2014
+
+#if _CCCL_COMPILER(NVRTC)
+
+struct _CCCL_TYPE_VISIBILITY_DEFAULT input_iterator_tag
+{};
+struct _CCCL_TYPE_VISIBILITY_DEFAULT output_iterator_tag
+{};
+struct _CCCL_TYPE_VISIBILITY_DEFAULT forward_iterator_tag : public input_iterator_tag
+{};
+struct _CCCL_TYPE_VISIBILITY_DEFAULT bidirectional_iterator_tag : public forward_iterator_tag
+{};
+struct _CCCL_TYPE_VISIBILITY_DEFAULT random_access_iterator_tag : public bidirectional_iterator_tag
+{};
+# if _CCCL_STD_VER >= 2014
+struct _CCCL_TYPE_VISIBILITY_DEFAULT contiguous_iterator_tag : public random_access_iterator_tag
+{};
+# endif // _CCCL_STD_VER >= 2014
+
+#else // ^^^ _CCCL_COMPILER(NVRTC) ^^^ / vvv !_CCCL_COMPILER(NVRTC) vvv
+
+using input_iterator_tag = ::std::input_iterator_tag;
+using output_iterator_tag = ::std::output_iterator_tag;
+using forward_iterator_tag = ::std::forward_iterator_tag;
+using bidirectional_iterator_tag = ::std::bidirectional_iterator_tag;
+using random_access_iterator_tag = ::std::random_access_iterator_tag;
+
+# if _CCCL_STD_VER >= 2020
+struct _CCCL_TYPE_VISIBILITY_DEFAULT __contiguous_iterator_tag_backfill : public ::std::random_access_iterator_tag
+{};
+using contiguous_iterator_tag =
+ _If<::std::__cccl_std_contiguous_iterator_tag_exists::value,
+ ::std::contiguous_iterator_tag,
+ __contiguous_iterator_tag_backfill>;
+# elif _CCCL_STD_VER >= 2014
+struct _CCCL_TYPE_VISIBILITY_DEFAULT contiguous_iterator_tag : public random_access_iterator_tag
+{};
+# endif // _CCCL_STD_VER >= 2014
+
+#endif // !_CCCL_COMPILER(NVRTC)
+
+template
+struct __iter_traits_cache
+{
+ using type = _If<__is_primary_template>::value, _Iter, iterator_traits<_Iter>>;
+};
+template
+using _ITER_TRAITS = typename __iter_traits_cache<_Iter>::type;
+
+#if _CCCL_STD_VER >= 2014
+# if defined(_GLIBCXX_DEBUG)
+_CCCL_TEMPLATE(class _Iter, class _Ty, class _Range)
+_CCCL_REQUIRES(_IsSame<_Iter, ::__gnu_debug::_Safe_iterator<_Ty*, _Range>>::value)
+_LIBCUDACXX_HIDE_FROM_ABI auto
+ __iter_concept_fn(::__gnu_debug::_Safe_iterator<_Ty*, _Range>, __priority_tag<3>) -> contiguous_iterator_tag;
+# endif
+# if defined(__GLIBCXX__)
+_CCCL_TEMPLATE(class _Iter, class _Ty, class _Range)
+_CCCL_REQUIRES(_IsSame<_Iter, ::__gnu_cxx::__normal_iterator<_Ty*, _Range>>::value)
+_LIBCUDACXX_HIDE_FROM_ABI auto
+ __iter_concept_fn(::__gnu_cxx::__normal_iterator<_Ty*, _Range>, __priority_tag<3>) -> contiguous_iterator_tag;
+# endif // __GLIBCXX__
+# if defined(_LIBCPP_VERSION)
+_CCCL_TEMPLATE(class _Iter, class _Ty)
+_CCCL_REQUIRES(_IsSame<_Iter, ::std::__wrap_iter<_Ty*>>::value)
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(::std::__wrap_iter<_Ty*>, __priority_tag<3>) -> contiguous_iterator_tag;
+# elif defined(_MSVC_STL_VERSION) || defined(_IS_WRS)
+_CCCL_TEMPLATE(class _Iter)
+_CCCL_REQUIRES(_IsSame<_Iter, class _Iter::_Array_iterator>::value)
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(_Iter, __priority_tag<3>) -> contiguous_iterator_tag;
+_CCCL_TEMPLATE(class _Iter)
+_CCCL_REQUIRES(_IsSame<_Iter, class _Iter::_Array_const_iterator>::value)
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(_Iter, __priority_tag<3>) -> contiguous_iterator_tag;
+_CCCL_TEMPLATE(class _Iter)
+_CCCL_REQUIRES(_IsSame<_Iter, class _Iter::_Vector_iterator>::value)
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(_Iter, __priority_tag<3>) -> contiguous_iterator_tag;
+_CCCL_TEMPLATE(class _Iter)
+_CCCL_REQUIRES(_IsSame<_Iter, class _Iter::_Vector_const_iterator>::value)
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(_Iter, __priority_tag<3>) -> contiguous_iterator_tag;
+_CCCL_TEMPLATE(class _Iter)
+_CCCL_REQUIRES(_IsSame<_Iter, class _Iter::_String_iterator>::value)
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(_Iter, __priority_tag<3>) -> contiguous_iterator_tag;
+_CCCL_TEMPLATE(class _Iter)
+_CCCL_REQUIRES(_IsSame<_Iter, class _Iter::_String_const_iterator>::value)
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(_Iter, __priority_tag<3>) -> contiguous_iterator_tag;
+_CCCL_TEMPLATE(class _Iter)
+_CCCL_REQUIRES(_IsSame<_Iter, class _Iter::_String_view_iterator>::value)
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(_Iter, __priority_tag<3>) -> contiguous_iterator_tag;
+_CCCL_TEMPLATE(class _Iter)
+_CCCL_REQUIRES(_IsSame<_Iter, class _Iter::_Span_iterator>::value)
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(_Iter, __priority_tag<3>) -> contiguous_iterator_tag;
+# endif // _MSVC_STL_VERSION
+_CCCL_TEMPLATE(class _Iter, class _Ty)
+_CCCL_REQUIRES(_IsSame<_Iter, _Ty*>::value)
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(_Ty*, __priority_tag<3>) -> contiguous_iterator_tag;
+#endif // _CCCL_STD_VER >= 2014
+template
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(_Iter, __priority_tag<2>) ->
+ typename _ITER_TRAITS<_Iter>::iterator_concept;
+template
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(_Iter, __priority_tag<1>) ->
+ typename _ITER_TRAITS<_Iter>::iterator_category;
+template
+_LIBCUDACXX_HIDE_FROM_ABI auto __iter_concept_fn(_Iter, __priority_tag<0>)
+ -> enable_if_t<__is_primary_template>::value, random_access_iterator_tag>;
+
+template
+using __iter_concept_t = decltype(_CUDA_VSTD::__iter_concept_fn<_Iter>(declval<_Iter>(), __priority_tag<3>{}));
+
+template
+struct __iter_concept_cache
+{};
+
+template
+struct __iter_concept_cache<_Iter, void_t<__iter_concept_t<_Iter>>>
+{
+ using type = __iter_concept_t<_Iter>;
+};
+
+template
+using _ITER_CONCEPT = typename __iter_concept_cache<_Iter>::type;
+
+template
+struct __has_iterator_typedefs
+{
+private:
+ template
+ _LIBCUDACXX_HIDE_FROM_ABI static false_type __test(...);
+ template
+ _LIBCUDACXX_HIDE_FROM_ABI static true_type
+ __test(void_t* = nullptr,
+ void_t* = nullptr,
+ void_t* = nullptr,
+ void_t* = nullptr,
+ void_t* = nullptr);
+
+public:
+ static const bool value = decltype(__test<_Tp>(0, 0, 0, 0, 0))::value;
+};
+
+template
+struct __has_iterator_category
+{
+private:
+ template
+ _LIBCUDACXX_HIDE_FROM_ABI static false_type __test(...);
+ template
+ _LIBCUDACXX_HIDE_FROM_ABI static true_type __test(typename _Up::iterator_category* = nullptr);
+
+public:
+ static const bool value = decltype(__test<_Tp>(nullptr))::value;
+};
+
+template
+struct __has_iterator_concept
+{
+private:
+ template
+ _LIBCUDACXX_HIDE_FROM_ABI static false_type __test(...);
+ template
+ _LIBCUDACXX_HIDE_FROM_ABI static true_type __test(typename _Up::iterator_concept* = nullptr);
+
+public:
+ static const bool value = decltype(__test<_Tp>(nullptr))::value;
+};
+
+#if !defined(_CCCL_NO_CONCEPTS)
+
+// The `cpp17-*-iterator` exposition-only concepts have very similar names to the `Cpp17*Iterator` named requirements
+// from `[iterator.cpp17]`. To avoid confusion between the two, the exposition-only concepts have been banished to
+// a "detail" namespace indicating they have a niche use-case.
+namespace __iterator_traits_detail
+{
+template
+concept __cpp17_iterator = requires(_Ip __i) {
+ { *__i } -> __can_reference;
+ { ++__i } -> same_as<_Ip&>;
+ { *__i++ } -> __can_reference;
+} && copyable<_Ip>;
+
+template
+concept __cpp17_input_iterator = __cpp17_iterator<_Ip> && equality_comparable<_Ip> && requires(_Ip __i) {
+ typename incrementable_traits<_Ip>::difference_type;
+ typename indirectly_readable_traits<_Ip>::value_type;
+ typename common_reference_t&&, typename indirectly_readable_traits<_Ip>::value_type&>;
+ typename common_reference_t::value_type&>;
+ requires signed_integral::difference_type>;
+};
+
+template
+concept __cpp17_forward_iterator =
+ __cpp17_input_iterator<_Ip> && constructible_from<_Ip> && is_lvalue_reference_v>
+ && same_as>, typename indirectly_readable_traits<_Ip>::value_type>
+ && requires(_Ip __i) {
+ { __i++ } -> convertible_to<_Ip const&>;
+ { *__i++ } -> same_as>;
+ };
+
+template
+concept __cpp17_bidirectional_iterator = __cpp17_forward_iterator<_Ip> && requires(_Ip __i) {
+ { --__i } -> same_as<_Ip&>;
+ { __i-- } -> convertible_to<_Ip const&>;
+ { *__i-- } -> same_as>;
+};
+
+template
+concept __cpp17_random_access_iterator =
+ __cpp17_bidirectional_iterator<_Ip> && totally_ordered<_Ip>
+ && requires(_Ip __i, typename incrementable_traits<_Ip>::difference_type __n) {
+ { __i += __n } -> same_as<_Ip&>;
+ { __i -= __n } -> same_as<_Ip&>;
+ { __i + __n } -> same_as<_Ip>;
+ { __n + __i } -> same_as<_Ip>;
+ { __i - __n } -> same_as<_Ip>;
+ { __i - __i } -> same_as; // NOLINT(misc-redundant-expression) ; This is llvm.org/PR54114
+ { __i[__n] } -> convertible_to>;
+ };
+} // namespace __iterator_traits_detail
+
+template
+concept __has_member_reference = requires { typename _Ip::reference; };
+
+template
+concept __has_member_pointer = requires { typename _Ip::pointer; };
+
+template
+concept __has_member_iterator_category = requires { typename _Ip::iterator_category; };
+
+template
+concept __specifies_members = requires {
+ typename _Ip::value_type;
+ typename _Ip::difference_type;
+ requires __has_member_reference<_Ip>;
+ requires __has_member_iterator_category<_Ip>;
+};
+
+template
+struct __iterator_traits_member_pointer_or_void
+{
+ using type = void;
+};
+
+template <__has_member_pointer _Tp>
+struct __iterator_traits_member_pointer_or_void<_Tp>
+{
+ using type = typename _Tp::pointer;
+};
+
+template
+concept __cpp17_iterator_missing_members = !__specifies_members<_Tp> && __iterator_traits_detail::__cpp17_iterator<_Tp>;
+
+template
+concept __cpp17_input_iterator_missing_members =
+ __cpp17_iterator_missing_members<_Tp> && __iterator_traits_detail::__cpp17_input_iterator<_Tp>;
+
+// Otherwise, `pointer` names `void`.
+template
+struct __iterator_traits_member_pointer_or_arrow_or_void
+{
+ using type = void;
+};
+
+// [iterator.traits]/3.2.1
+// If the qualified-id `I::pointer` is valid and denotes a type, `pointer` names that type.
+template <__has_member_pointer _Ip>
+struct __iterator_traits_member_pointer_or_arrow_or_void<_Ip>
+{
+ using type = typename _Ip::pointer;
+};
+
+// Otherwise, if `decltype(declval().operator->())` is well-formed, then `pointer` names that
+// type.
+template
+ requires requires(_Ip& __i) { __i.operator->(); } && (!__has_member_pointer<_Ip>)
+struct __iterator_traits_member_pointer_or_arrow_or_void<_Ip>
+{
+ using type = decltype(declval<_Ip&>().operator->());
+};
+
+// Otherwise, `reference` names `iter-reference-t`.
+template
+struct __iterator_traits_member_reference
+{
+ using type = iter_reference_t<_Ip>;
+};
+
+// [iterator.traits]/3.2.2
+// If the qualified-id `I::reference` is valid and denotes a type, `reference` names that type.
+template <__has_member_reference _Ip>
+struct __iterator_traits_member_reference<_Ip>
+{
+ using type = typename _Ip::reference;
+};
+
+// [iterator.traits]/3.2.3.4
+// input_iterator_tag
+template
+struct __deduce_iterator_category
+{
+ using type = input_iterator_tag;
+};
+
+// [iterator.traits]/3.2.3.1
+// `random_access_iterator_tag` if `I` satisfies `cpp17-random-access-iterator`, or otherwise
+template <__iterator_traits_detail::__cpp17_random_access_iterator _Ip>
+struct __deduce_iterator_category<_Ip>
+{
+ using type = random_access_iterator_tag;
+};
+
+// [iterator.traits]/3.2.3.2
+// `bidirectional_iterator_tag` if `I` satisfies `cpp17-bidirectional-iterator`, or otherwise
+template <__iterator_traits_detail::__cpp17_bidirectional_iterator _Ip>
+ requires(!__iterator_traits_detail::__cpp17_random_access_iterator<_Ip>) // nvbug 3885350
+struct __deduce_iterator_category<_Ip>
+{
+ using type = bidirectional_iterator_tag;
+};
+
+// [iterator.traits]/3.2.3.3
+// `forward_iterator_tag` if `I` satisfies `cpp17-forward-iterator`, or otherwise
+template <__iterator_traits_detail::__cpp17_forward_iterator _Ip>
+ requires(!__iterator_traits_detail::__cpp17_bidirectional_iterator<_Ip>) // nvbug 3885350
+struct __deduce_iterator_category<_Ip>
+{
+ using type = forward_iterator_tag;
+};
+
+template
+struct __iterator_traits_iterator_category : __deduce_iterator_category<_Ip>
+{};
+
+// [iterator.traits]/3.2.3
+// If the qualified-id `I::iterator-category` is valid and denotes a type, `iterator-category` names
+// that type.
+template <__has_member_iterator_category _Ip>
+struct __iterator_traits_iterator_category<_Ip>
+{
+ using type = typename _Ip::iterator_category;
+};
+
+// otherwise, it names void.
+template
+struct __iterator_traits_difference_type
+{
+ using type = void;
+};
+
+// If the qualified-id `incrementable_traits::difference_type` is valid and denotes a type, then
+// `difference_type` names that type;
+template
+ requires requires { typename incrementable_traits<_Ip>::difference_type; }
+struct __iterator_traits_difference_type<_Ip>
+{
+ using type = typename incrementable_traits<_Ip>::difference_type;
+};
+
+// [iterator.traits]/3.4
+// Otherwise, `iterator_traits` has no members by any of the above names.
+template
+struct __iterator_traits
+{};
+
+// [iterator.traits]/3.1
+// If `I` has valid ([temp.deduct]) member types `difference-type`, `value-type`, `reference`, and
+// `iterator-category`, then `iterator-traits` has the following publicly accessible members:
+template <__specifies_members _Ip>
+struct __iterator_traits<_Ip>
+{
+ using iterator_category = typename _Ip::iterator_category;
+ using value_type = typename _Ip::value_type;
+ using difference_type = typename _Ip::difference_type;
+ using pointer = typename __iterator_traits_member_pointer_or_void<_Ip>::type;
+ using reference = typename _Ip::reference;
+};
+
+// [iterator.traits]/3.2
+// Otherwise, if `I` satisfies the exposition-only concept `cpp17-input-iterator`,
+// `iterator-traits` has the following publicly accessible members:
+template <__cpp17_input_iterator_missing_members _Ip>
+struct __iterator_traits<_Ip>
+{
+ using iterator_category = typename __iterator_traits_iterator_category<_Ip>::type;
+ using value_type = typename indirectly_readable_traits<_Ip>::value_type;
+ using difference_type = typename incrementable_traits<_Ip>::difference_type;
+ using pointer = typename __iterator_traits_member_pointer_or_arrow_or_void<_Ip>::type;
+ using reference = typename __iterator_traits_member_reference<_Ip>::type;
+};
+
+// Otherwise, if `I` satisfies the exposition-only concept `cpp17-iterator`, then
+// `iterator_traits` has the following publicly accessible members:
+template <__cpp17_iterator_missing_members _Ip>
+ requires(!__cpp17_input_iterator_missing_members<_Ip>) // nvbug 3885350
+struct __iterator_traits<_Ip>
+{
+ using iterator_category = output_iterator_tag;
+ using value_type = void;
+ using difference_type = typename __iterator_traits_difference_type<_Ip>::type;
+ using pointer = void;
+ using reference = void;
+};
+
+template
+struct _CCCL_TYPE_VISIBILITY_DEFAULT iterator_traits : __iterator_traits<_Ip>
+{
+ using __primary_template = iterator_traits;
+};
+
+#elif _CCCL_STD_VER >= 2014 // ^^^ !_CCCL_NO_CONCEPTS ^^^ / vvv _CCCL_STD_VER > 2014 vvv
+
+// The `cpp17-*-iterator` exposition-only concepts have very similar names to the `Cpp17*Iterator` named requirements
+// from `[iterator.cpp17]`. To avoid confusion between the two, the exposition-only concepts have been banished to
+// a "detail" namespace indicating they have a niche use-case.
+namespace __iterator_traits_detail
+{
+template
+_CCCL_CONCEPT_FRAGMENT(
+ __cpp17_iterator_,
+ requires(_Ip __i)(requires(__can_reference),
+ requires(same_as<_Ip&, decltype(++__i)>),
+ requires(__can_reference),
+ requires(copyable<_Ip>)));
+
+template
+_CCCL_CONCEPT __cpp17_iterator = _CCCL_FRAGMENT(__cpp17_iterator_, _Ip);
+
+template
+_CCCL_CONCEPT_FRAGMENT(
+ __cpp17_input_iterator_,
+ requires(_Ip __i)(
+ typename(common_reference_t&&, typename indirectly_readable_traits<_Ip>::value_type&>),
+ typename(common_reference_t::value_type&>),
+ requires(__cpp17_iterator<_Ip>),
+ requires(equality_comparable<_Ip>),
+ requires(__has_member_difference_type>),
+ requires(__has_member_value_type>),
+ requires(signed_integral::difference_type>)));
+
+template
+_CCCL_CONCEPT __cpp17_input_iterator = _CCCL_FRAGMENT(__cpp17_input_iterator_, _Ip);
+
+template
+_CCCL_CONCEPT_FRAGMENT(
+ __cpp17_forward_iterator_,
+ requires(_Ip __i)(
+ requires(__cpp17_input_iterator<_Ip>),
+ requires(convertible_to),
+ requires(same_as, decltype(*__i++)>),
+ requires(constructible_from<_Ip>),
+ requires(_CCCL_TRAIT(is_lvalue_reference, iter_reference_t<_Ip>)),
+ requires(same_as>, typename indirectly_readable_traits<_Ip>::value_type>)));
+
+template
+_CCCL_CONCEPT __cpp17_forward_iterator = _CCCL_FRAGMENT(__cpp17_forward_iterator_, _Ip);
+
+template
+_CCCL_CONCEPT_FRAGMENT(
+ __cpp17_bidirectional_iterator_,
+ requires(_Ip __i)(requires(__cpp17_forward_iterator<_Ip>),
+ requires(same_as<_Ip&, decltype(--__i)>),
+ requires(convertible_to),
+ requires(same_as, decltype(*__i--)>)));
+
+template
+_CCCL_CONCEPT __cpp17_bidirectional_iterator = _CCCL_FRAGMENT(__cpp17_bidirectional_iterator_, _Ip);
+
+template
+_CCCL_CONCEPT_FRAGMENT(
+ __cpp17_random_access_iterator_,
+ requires(_Ip __i, typename incrementable_traits<_Ip>::difference_type __n)(
+ requires(same_as<_Ip&, decltype(__i += __n)>),
+ requires(same_as<_Ip&, decltype(__i -= __n)>),
+ requires(same_as<_Ip, decltype(__i + __n)>),
+ requires(same_as<_Ip, decltype(__n + __i)>),
+ requires(same_as<_Ip, decltype(__i - __n)>),
+ requires(same_as),
+ requires(convertible_to>)));
+
+template
+_CCCL_CONCEPT __cpp17_random_access_iterator =
+ __cpp17_bidirectional_iterator<_Ip> && totally_ordered<_Ip> && _CCCL_FRAGMENT(__cpp17_random_access_iterator_, _Ip);
+} // namespace __iterator_traits_detail
+
+template
+_CCCL_INLINE_VAR constexpr bool __has_member_reference = false;
+
+template
+_CCCL_INLINE_VAR constexpr bool __has_member_reference<_Tp, void_t> = true;
+
+template
+_CCCL_INLINE_VAR constexpr bool __has_member_pointer = false;
+
+template
+_CCCL_INLINE_VAR constexpr bool __has_member_pointer<_Tp, void_t> = true;
+
+template
+_CCCL_INLINE_VAR constexpr bool __has_member_iterator_category = false;
+
+template
+_CCCL_INLINE_VAR constexpr bool __has_member_iterator_category<_Tp, void_t> = true;
+
+template
+_CCCL_CONCEPT __specifies_members =
+ __has_member_value_type<_Ip> && __has_member_difference_type<_Ip> && __has_member_reference<_Ip>
+ && __has_member_iterator_category<_Ip>;
+
+template
+struct __iterator_traits_member_pointer_or_void
+{
+ using type = void;
+};
+
+template
+struct __iterator_traits_member_pointer_or_void<_Tp, enable_if_t<__has_member_pointer<_Tp>>>
+{
+ using type = typename _Tp::pointer;
+};
+
+template
+_CCCL_CONCEPT __cpp17_iterator_missing_members =
+ !__specifies_members<_Tp> && __iterator_traits_detail::__cpp17_iterator<_Tp>;
+
+template
+_CCCL_CONCEPT __cpp17_input_iterator_missing_members =
+ __cpp17_iterator_missing_members<_Tp> && __iterator_traits_detail::__cpp17_input_iterator<_Tp>;
+
+// Otherwise, `pointer` names `void`.
+template
+struct __iterator_traits_member_pointer_or_arrow_or_void
+{
+ using type = void;
+};
+
+// [iterator.traits]/3.2.1
+// If the qualified-id `I::pointer` is valid and denotes a type, `pointer` names that type.
+template
+struct __iterator_traits_member_pointer_or_arrow_or_void<_Ip, enable_if_t<__has_member_pointer<_Ip>>>
+{
+ using type = typename _Ip::pointer;
+};
+
+template
+_CCCL_CONCEPT_FRAGMENT(__has_operator_arrow_, requires(_Ip& __i)(__i.operator->()));
+
+template
+_CCCL_CONCEPT __has_operator_arrow = _CCCL_FRAGMENT(__has_operator_arrow_, _Ip);
+
+// Otherwise, if `decltype(declval().operator->())` is well-formed, then `pointer` names that
+// type.
+template
+struct __iterator_traits_member_pointer_or_arrow_or_void<
+ _Ip,
+ enable_if_t<__has_operator_arrow<_Ip> && !__has_member_pointer<_Ip>>>
+{
+ using type = decltype(declval<_Ip&>().operator->());
+};
+
+// Otherwise, `reference` names `iter-reference-t`.
+template
+struct __iterator_traits_member_reference
+{
+ using type = iter_reference_t<_Ip>;
+};
+
+// [iterator.traits]/3.2.2
+// If the qualified-id `I::reference` is valid and denotes a type, `reference` names that type.
+template
+struct __iterator_traits_member_reference<_Ip, enable_if_t<__has_member_reference<_Ip>>>
+{
+ using type = typename _Ip::reference;
+};
+
+// [iterator.traits]/3.2.3.4
+// input_iterator_tag
+template
+struct __deduce_iterator_category
+{
+ using type = input_iterator_tag;
+};
+
+// [iterator.traits]/3.2.3.1
+// `random_access_iterator_tag` if `I` satisfies `cpp17-random-access-iterator`, or otherwise
+template
+struct __deduce_iterator_category<_Ip, enable_if_t<__iterator_traits_detail::__cpp17_random_access_iterator<_Ip>>>
+{
+ using type = random_access_iterator_tag;
+};
+
+// [iterator.traits]/3.2.3.2
+// `bidirectional_iterator_tag` if `I` satisfies `cpp17-bidirectional-iterator`, or otherwise
+template
+struct __deduce_iterator_category<_Ip,
+ enable_if_t
+ && __iterator_traits_detail::__cpp17_bidirectional_iterator<_Ip>>>
+{
+ using type = bidirectional_iterator_tag;
+};
+
+// [iterator.traits]/3.2.3.3
+// `forward_iterator_tag` if `I` satisfies `cpp17-forward-iterator`, or otherwise
+template
+struct __deduce_iterator_category<_Ip,
+ enable_if_t
+ && __iterator_traits_detail::__cpp17_forward_iterator<_Ip>>>
+{
+ using type = forward_iterator_tag;
+};
+
+template
+struct __iterator_traits_iterator_category : __deduce_iterator_category<_Ip>
+{};
+
+// [iterator.traits]/3.2.3
+// If the qualified-id `I::iterator-category` is valid and denotes a type, `iterator-category` names
+// that type.
+template
+struct __iterator_traits_iterator_category<_Ip, enable_if_t<__has_member_iterator_category<_Ip>>>
+{
+ using type = typename _Ip::iterator_category;
+};
+
+// otherwise, it names void.
+template
+struct __iterator_traits_difference_type
+{
+ using type = void;
+};
+
+// If the qualified-id `incrementable_traits::difference_type` is valid and denotes a type, then
+// `difference_type` names that type;
+template
+struct __iterator_traits_difference_type<_Ip, void_t::difference_type>>
+{
+ using type = typename incrementable_traits<_Ip>::difference_type;
+};
+
+// [iterator.traits]/3.4
+// Otherwise, `iterator_traits` has no members by any of the above names.
+template
+struct __iterator_traits
+{};
+
+// [iterator.traits]/3.1
+// If `I` has valid ([temp.deduct]) member types `difference-type`, `value-type`, `reference`, and
+// `iterator-category`, then `iterator-traits` has the following publicly accessible members:
+template
+struct __iterator_traits<_Ip, enable_if_t<__specifies_members<_Ip>>>
+{
+ using iterator_category = typename _Ip::iterator_category;
+ using value_type = typename _Ip::value_type;
+ using difference_type = typename _Ip::difference_type;
+ using pointer = typename __iterator_traits_member_pointer_or_void<_Ip>::type;
+ using reference = typename _Ip::reference;
+};
+
+// [iterator.traits]/3.2
+// Otherwise, if `I` satisfies the exposition-only concept `cpp17-input-iterator`,
+// `iterator-traits` has the following publicly accessible members:
+template
+struct __iterator_traits<_Ip, enable_if_t && __cpp17_input_iterator_missing_members<_Ip>>>
+{
+ using iterator_category = typename __iterator_traits_iterator_category<_Ip>::type;
+ using value_type = typename indirectly_readable_traits<_Ip>::value_type;
+ using difference_type = typename incrementable_traits<_Ip>::difference_type;
+ using pointer = typename __iterator_traits_member_pointer_or_arrow_or_void<_Ip>::type;
+ using reference = typename __iterator_traits_member_reference<_Ip>::type;
+};
+
+// Otherwise, if `I` satisfies the exposition-only concept `cpp17-iterator`, then
+// `iterator_traits` has the following publicly accessible members:
+template
+struct __iterator_traits<_Ip,
+ enable_if_t && !__cpp17_input_iterator_missing_members<_Ip>
+ && __cpp17_iterator_missing_members<_Ip>>>
+{
+ using iterator_category = output_iterator_tag;
+ using value_type = void;
+ using difference_type = typename __iterator_traits_difference_type<_Ip>::type;
+ using pointer = void;
+ using reference = void;
+};
+
+template
+struct _CCCL_TYPE_VISIBILITY_DEFAULT iterator_traits : __iterator_traits<_Ip>
+{
+ using __primary_template = iterator_traits;
+};
+
+#else // ^^^ _CCCL_STD_VER > 2014 ^^^ / vvv _CCCL_STD_VER <= 2014 vvv
+
+template