Add files using upload-large-folder tool

.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

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.

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

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)

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)

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
+            )
+        )

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

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)
+        )

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]

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))

parrot/lib/python3.10/site-packages/narwhals/stable/__init__.py

@@ -0,0 +1,3 @@
+from narwhals.stable import v1
+
+__all__ = ["v1"]

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

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

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)

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

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:])]

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]

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]

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))