Add files using upload-large-folder tool

.gitattributes

@@ -1717,3 +1717,7 @@ vllm/lib/python3.10/site-packages/cupy/cuda/memory_hook.cpython-310-x86_64-linux
 vllm/lib/python3.10/site-packages/cupy/cuda/cufft.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/cupy/fft/_callback.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/cupy/cuda/graph.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/scipy/stats/__pycache__/_morestats.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/scipy/linalg/_decomp_update.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/scipy/optimize/__pycache__/_optimize.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+vllm/lib/python3.10/site-packages/cupy/lib/_polynomial.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

parrot/lib/python3.10/site-packages/narwhals/_arrow/dataframe.py

@@ -0,0 +1,617 @@
+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._arrow.utils import broadcast_series
+from narwhals._arrow.utils import convert_str_slice_to_int_slice
+from narwhals._arrow.utils import select_rows
+from narwhals._arrow.utils import translate_dtype
+from narwhals._arrow.utils import validate_dataframe_comparand
+from narwhals._expression_parsing import evaluate_into_exprs
+from narwhals.dependencies import get_pyarrow
+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 pyarrow as pa
+    from typing_extensions import Self
+
+    from narwhals._arrow.group_by import ArrowGroupBy
+    from narwhals._arrow.namespace import ArrowNamespace
+    from narwhals._arrow.series import ArrowSeries
+    from narwhals._arrow.typing import IntoArrowExpr
+    from narwhals.dtypes import DType
+
+
+class ArrowDataFrame:
+    # --- not in the spec ---
+    def __init__(
+        self, native_dataframe: pa.Table, *, backend_version: tuple[int, ...]
+    ) -> None:
+        self._native_frame = native_dataframe
+        self._implementation = Implementation.PYARROW
+        self._backend_version = backend_version
+
+    def __narwhals_namespace__(self) -> ArrowNamespace:
+        from narwhals._arrow.namespace import ArrowNamespace
+
+        return ArrowNamespace(backend_version=self._backend_version)
+
+    def __native_namespace__(self) -> Any:
+        return get_pyarrow()
+
+    def __narwhals_dataframe__(self) -> Self:
+        return self
+
+    def __narwhals_lazyframe__(self) -> Self:
+        return self
+
+    def _from_native_frame(self, df: Any) -> Self:
+        return self.__class__(df, backend_version=self._backend_version)
+
+    @property
+    def shape(self) -> tuple[int, int]:
+        return self._native_frame.shape  # type: ignore[no-any-return]
+
+    def __len__(self) -> int:
+        return len(self._native_frame)
+
+    def row(self, index: int) -> tuple[Any, ...]:
+        return tuple(col[index] for col in self._native_frame)
+
+    def rows(
+        self, *, named: bool = False
+    ) -> list[tuple[Any, ...]] | list[dict[str, Any]]:
+        if not named:
+            msg = "Unnamed rows are not yet supported on PyArrow tables"
+            raise NotImplementedError(msg)
+        return self._native_frame.to_pylist()  # type: ignore[no-any-return]
+
+    def iter_rows(
+        self,
+        *,
+        named: bool = False,
+        buffer_size: int = 512,
+    ) -> Iterator[tuple[Any, ...]] | Iterator[dict[str, Any]]:
+        df = self._native_frame
+        num_rows = df.num_rows
+
+        if not named:
+            for i in range(0, num_rows, buffer_size):
+                rows = df[i : i + buffer_size].to_pydict().values()
+                yield from zip(*rows)
+        else:
+            for i in range(0, num_rows, buffer_size):
+                yield from df[i : i + buffer_size].to_pylist()
+
+    def get_column(self, name: str) -> ArrowSeries:
+        from narwhals._arrow.series import ArrowSeries
+
+        if not isinstance(name, str):
+            msg = f"Expected str, got: {type(name)}"
+            raise TypeError(msg)
+
+        return ArrowSeries(
+            self._native_frame[name],
+            name=name,
+            backend_version=self._backend_version,
+        )
+
+    def __array__(self, dtype: Any = None, copy: bool | None = None) -> np.ndarray:
+        return self._native_frame.__array__(dtype, copy=copy)
+
+    @overload
+    def __getitem__(self, item: tuple[Sequence[int], str | int]) -> ArrowSeries: ...  # type: ignore[overload-overlap]
+
+    @overload
+    def __getitem__(self, item: Sequence[int]) -> ArrowDataFrame: ...
+
+    @overload
+    def __getitem__(self, item: str) -> ArrowSeries: ...
+
+    @overload
+    def __getitem__(self, item: slice) -> ArrowDataFrame: ...
+
+    @overload
+    def __getitem__(self, item: tuple[slice, slice]) -> ArrowDataFrame: ...
+
+    def __getitem__(
+        self,
+        item: str
+        | slice
+        | Sequence[int]
+        | Sequence[str]
+        | tuple[Sequence[int], str | int]
+        | tuple[slice, str | int]
+        | tuple[slice, slice],
+    ) -> ArrowSeries | ArrowDataFrame:
+        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._arrow.series import ArrowSeries
+
+            return ArrowSeries(
+                self._native_frame[item],
+                name=item,
+                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.slice(0, 0).select([]))
+            selected_rows = select_rows(self._native_frame, item[0])
+            return self._from_native_frame(selected_rows.select(item[1]))
+
+        elif isinstance(item, tuple) and len(item) == 2:
+            if isinstance(item[1], slice):
+                columns = self.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.take(item[0]).select(columns[start:stop:step])
+                    )
+                if isinstance(item[1].start, int) or isinstance(item[1].stop, int):
+                    return self._from_native_frame(
+                        self._native_frame.take(item[0]).select(
+                            columns[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
+            from narwhals._arrow.series import ArrowSeries
+
+            # PyArrow columns are always strings
+            col_name = item[1] if isinstance(item[1], str) else self.columns[item[1]]
+            if isinstance(item[0], str):  # pragma: no cover
+                msg = "Can not slice with tuple with the first element as a str"
+                raise TypeError(msg)
+            if (isinstance(item[0], slice)) and (item[0] == slice(None)):
+                return ArrowSeries(
+                    self._native_frame[col_name],
+                    name=col_name,
+                    backend_version=self._backend_version,
+                )
+            selected_rows = select_rows(self._native_frame, item[0])
+            return ArrowSeries(
+                selected_rows[col_name],
+                name=col_name,
+                backend_version=self._backend_version,
+            )
+
+        elif isinstance(item, slice):
+            if item.step is not None and item.step != 1:
+                msg = "Slicing with step is not supported on PyArrow tables"
+                raise NotImplementedError(msg)
+            columns = self.columns
+            if 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])
+                )
+            start = item.start or 0
+            stop = item.stop if item.stop is not None else len(self._native_frame)
+            return self._from_native_frame(
+                self._native_frame.slice(start, stop - start),
+            )
+
+        elif isinstance(item, Sequence) or (is_numpy_array(item) and item.ndim == 1):
+            if (
+                isinstance(item, Sequence)
+                and all(isinstance(x, str) for x in item)
+                and len(item) > 0
+            ):
+                return self._from_native_frame(self._native_frame.select(item))
+            if isinstance(item, Sequence) and len(item) == 0:
+                return self._from_native_frame(self._native_frame.slice(0, 0))
+            return self._from_native_frame(self._native_frame.take(item))
+
+        else:  # pragma: no cover
+            msg = f"Expected str or slice, got: {type(item)}"
+            raise TypeError(msg)
+
+    @property
+    def schema(self) -> dict[str, DType]:
+        schema = self._native_frame.schema
+        return {
+            name: translate_dtype(dtype)
+            for name, dtype in zip(schema.names, schema.types)
+        }
+
+    def collect_schema(self) -> dict[str, DType]:
+        return self.schema
+
+    @property
+    def columns(self) -> list[str]:
+        return self._native_frame.schema.names  # type: ignore[no-any-return]
+
+    def select(
+        self,
+        *exprs: IntoArrowExpr,
+        **named_exprs: IntoArrowExpr,
+    ) -> Self:
+        import pyarrow as pa  # ignore-banned-import()
+
+        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__.from_arrays([]))
+        names = [s.name for s in new_series]
+        df = pa.Table.from_arrays(
+            broadcast_series(new_series),
+            names=names,
+        )
+        return self._from_native_frame(df)
+
+    def with_columns(
+        self,
+        *exprs: IntoArrowExpr,
+        **named_exprs: IntoArrowExpr,
+    ) -> Self:
+        new_columns = evaluate_into_exprs(self, *exprs, **named_exprs)
+        new_column_name_to_new_column_map = {s.name: s for s in new_columns}
+        to_concat = []
+        output_names = []
+        # Make sure to preserve column order
+        length = len(self)
+        for name in self.columns:
+            if name in new_column_name_to_new_column_map:
+                to_concat.append(
+                    validate_dataframe_comparand(
+                        length=length,
+                        other=new_column_name_to_new_column_map.pop(name),
+                        backend_version=self._backend_version,
+                    )
+                )
+            else:
+                to_concat.append(self._native_frame[name])
+            output_names.append(name)
+        for s in new_column_name_to_new_column_map:
+            to_concat.append(
+                validate_dataframe_comparand(
+                    length=length,
+                    other=new_column_name_to_new_column_map[s],
+                    backend_version=self._backend_version,
+                )
+            )
+            output_names.append(s)
+        df = self._native_frame.__class__.from_arrays(to_concat, names=output_names)
+        return self._from_native_frame(df)
+
+    def group_by(self, *keys: str) -> ArrowGroupBy:
+        from narwhals._arrow.group_by import ArrowGroupBy
+
+        return ArrowGroupBy(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:
+        how_to_join_map = {
+            "anti": "left anti",
+            "semi": "left semi",
+            "inner": "inner",
+            "left": "left outer",
+        }
+
+        if how == "cross":
+            plx = self.__narwhals_namespace__()
+            key_token = generate_unique_token(
+                n_bytes=8, columns=[*self.columns, *other.columns]
+            )
+
+            return self._from_native_frame(
+                self.with_columns(**{key_token: plx.lit(0, None)})
+                ._native_frame.join(
+                    other.with_columns(**{key_token: plx.lit(0, None)})._native_frame,
+                    keys=key_token,
+                    right_keys=key_token,
+                    join_type="inner",
+                    right_suffix=suffix,
+                )
+                .drop([key_token]),
+            )
+
+        return self._from_native_frame(
+            self._native_frame.join(
+                other._native_frame,
+                keys=left_on,
+                right_keys=right_on,
+                join_type=how_to_join_map[how],
+                right_suffix=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:
+        msg = "join_asof is not yet supported on PyArrow tables"
+        raise NotImplementedError(msg)
+
+    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(to_drop))
+
+    def drop_nulls(self: Self, subset: str | list[str] | None) -> Self:
+        if subset is None:
+            return self._from_native_frame(self._native_frame.drop_null())
+        subset = [subset] if isinstance(subset, str) else subset
+        plx = self.__narwhals_namespace__()
+        return self.filter(~plx.any_horizontal(plx.col(*subset).is_null()))
+
+    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):
+            order = "descending" if descending else "ascending"
+            sorting = [(key, order) for key in flat_keys]
+        else:
+            sorting = [
+                (key, "descending" if is_descending else "ascending")
+                for key, is_descending in zip(flat_keys, descending)
+            ]
+        return self._from_native_frame(df.sort_by(sorting=sorting))
+
+    def to_pandas(self) -> Any:
+        return self._native_frame.to_pandas()
+
+    def to_numpy(self) -> Any:
+        import numpy as np  # ignore-banned-import
+
+        return np.column_stack([col.to_numpy() for col in self._native_frame.columns])
+
+    def to_dict(self, *, as_series: bool) -> Any:
+        df = self._native_frame
+
+        names_and_values = zip(df.column_names, df.columns)
+        if as_series:
+            from narwhals._arrow.series import ArrowSeries
+
+            return {
+                name: ArrowSeries(col, name=name, backend_version=self._backend_version)
+                for name, col in names_and_values
+            }
+        else:
+            return {name: col.to_pylist() for name, col in names_and_values}
+
+    def with_row_index(self, name: str) -> Self:
+        import pyarrow as pa  # ignore-banned-import()
+
+        df = self._native_frame
+
+        row_indices = pa.array(range(df.num_rows))
+        return self._from_native_frame(df.append_column(name, row_indices))
+
+    def filter(
+        self,
+        *predicates: IntoArrowExpr,
+    ) -> Self:
+        if (
+            len(predicates) == 1
+            and isinstance(predicates[0], list)
+            and all(isinstance(x, bool) for x in predicates[0])
+        ):
+            mask = predicates[0]
+        else:
+            plx = self.__narwhals_namespace__()
+            expr = plx.all_horizontal(*predicates)
+            # Safety: all_horizontal's expression only returns a single column.
+            mask = expr._call(self)[0]._native_series
+        return self._from_native_frame(self._native_frame.filter(mask))
+
+    def null_count(self) -> Self:
+        import pyarrow as pa  # ignore-banned-import()
+
+        df = self._native_frame
+        names_and_values = zip(df.column_names, df.columns)
+
+        return self._from_native_frame(
+            pa.table({name: [col.null_count] for name, col in names_and_values})
+        )
+
+    def head(self, n: int) -> Self:
+        df = self._native_frame
+        if n >= 0:
+            return self._from_native_frame(df.slice(0, n))
+        else:
+            num_rows = df.num_rows
+            return self._from_native_frame(df.slice(0, max(0, num_rows + n)))
+
+    def tail(self, n: int) -> Self:
+        df = self._native_frame
+        if n >= 0:
+            num_rows = df.num_rows
+            return self._from_native_frame(df.slice(max(0, num_rows - n)))
+        else:
+            return self._from_native_frame(df.slice(abs(n)))
+
+    def lazy(self) -> Self:
+        return self
+
+    def collect(self) -> ArrowDataFrame:
+        return ArrowDataFrame(self._native_frame, backend_version=self._backend_version)
+
+    def clone(self) -> Self:
+        msg = "clone is not yet supported on PyArrow tables"
+        raise NotImplementedError(msg)
+
+    def is_empty(self: Self) -> bool:
+        return self.shape[0] == 0
+
+    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[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[_col][row]
+
+    def rename(self, mapping: dict[str, str]) -> Self:
+        df = self._native_frame
+        new_cols = [mapping.get(c, c) for c in df.column_names]
+        return self._from_native_frame(df.rename_columns(new_cols))
+
+    def write_parquet(self, file: Any) -> Any:
+        import pyarrow.parquet as pp  # ignore-banned-import
+
+        pp.write_table(self._native_frame, file)
+
+    def write_csv(self, file: Any) -> Any:
+        import pyarrow as pa  # ignore-banned-import
+        import pyarrow.csv as pa_csv  # ignore-banned-import
+
+        pa_table = self._native_frame
+        if file is None:
+            csv_buffer = pa.BufferOutputStream()
+            pa_csv.write_csv(pa_table, csv_buffer)
+            return csv_buffer.getvalue().to_pybytes().decode()
+        return pa_csv.write_csv(pa_table, file)
+
+    def is_duplicated(self: Self) -> ArrowSeries:
+        import numpy as np  # ignore-banned-import
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        from narwhals._arrow.series import ArrowSeries
+
+        df = self._native_frame
+
+        columns = self.columns
+        col_token = generate_unique_token(n_bytes=8, columns=columns)
+        row_count = (
+            df.append_column(col_token, pa.array(np.arange(len(self))))
+            .group_by(columns)
+            .aggregate([(col_token, "count")])
+        )
+        is_duplicated = pc.greater(
+            df.join(
+                row_count, keys=columns, right_keys=columns, join_type="inner"
+            ).column(f"{col_token}_count"),
+            1,
+        )
+        return ArrowSeries(is_duplicated, name="", backend_version=self._backend_version)
+
+    def is_unique(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        from narwhals._arrow.series import ArrowSeries
+
+        is_duplicated = self.is_duplicated()._native_series
+
+        return ArrowSeries(
+            pc.invert(is_duplicated), name="", backend_version=self._backend_version
+        )
+
+    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.
+        """
+        import numpy as np  # ignore-banned-import
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        df = self._native_frame
+
+        if isinstance(subset, str):
+            subset = [subset]
+        subset = subset or self.columns
+
+        if keep in {"any", "first", "last"}:
+            agg_func_map = {"any": "min", "first": "min", "last": "max"}
+
+            agg_func = agg_func_map[keep]
+            col_token = generate_unique_token(n_bytes=8, columns=self.columns)
+            keep_idx = (
+                df.append_column(col_token, pa.array(np.arange(len(self))))
+                .group_by(subset)
+                .aggregate([(col_token, agg_func)])
+                .column(f"{col_token}_{agg_func}")
+            )
+
+            return self._from_native_frame(pc.take(df, keep_idx))
+
+        keep_idx = self.select(*subset).is_unique()
+        return self.filter(keep_idx)
+
+    def gather_every(self: Self, n: int, offset: int = 0) -> Self:
+        return self._from_native_frame(self._native_frame[offset::n])
+
+    def to_arrow(self: Self) -> Any:
+        return self._native_frame
+
+    def sample(
+        self: Self,
+        n: int | None = None,
+        *,
+        fraction: float | None = None,
+        with_replacement: bool = False,
+        seed: int | None = None,
+    ) -> Self:
+        import numpy as np  # ignore-banned-import
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        frame = self._native_frame
+        num_rows = len(self)
+        if n is None and fraction is not None:
+            n = int(num_rows * fraction)
+
+        rng = np.random.default_rng(seed=seed)
+        idx = np.arange(0, num_rows)
+        mask = rng.choice(idx, size=n, replace=with_replacement)
+
+        return self._from_native_frame(pc.take(frame, mask))

parrot/lib/python3.10/site-packages/narwhals/_arrow/expr.py

@@ -0,0 +1,671 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Callable
+from typing import Literal
+
+from narwhals._expression_parsing import reuse_series_implementation
+from narwhals._expression_parsing import reuse_series_namespace_implementation
+from narwhals.utils import Implementation
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from narwhals._arrow.dataframe import ArrowDataFrame
+    from narwhals._arrow.namespace import ArrowNamespace
+    from narwhals._arrow.series import ArrowSeries
+    from narwhals._arrow.typing import IntoArrowExpr
+    from narwhals.dtypes import DType
+
+
+class ArrowExpr:
+    def __init__(
+        self,
+        call: Callable[[ArrowDataFrame], list[ArrowSeries]],
+        *,
+        depth: int,
+        function_name: str,
+        root_names: list[str] | None,
+        output_names: list[str] | None,
+        backend_version: tuple[int, ...],
+    ) -> None:
+        self._call = call
+        self._depth = depth
+        self._function_name = function_name
+        self._root_names = root_names
+        self._depth = depth
+        self._output_names = output_names
+        self._implementation = Implementation.PYARROW
+        self._backend_version = backend_version
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return (
+            f"ArrowExpr("
+            f"depth={self._depth}, "
+            f"function_name={self._function_name}, "
+            f"root_names={self._root_names}, "
+            f"output_names={self._output_names}"
+        )
+
+    @classmethod
+    def from_column_names(
+        cls: type[Self], *column_names: str, backend_version: tuple[int, ...]
+    ) -> Self:
+        from narwhals._arrow.series import ArrowSeries
+
+        def func(df: ArrowDataFrame) -> list[ArrowSeries]:
+            return [
+                ArrowSeries(
+                    df._native_frame[column_name],
+                    name=column_name,
+                    backend_version=df._backend_version,
+                )
+                for column_name in column_names
+            ]
+
+        return cls(
+            func,
+            depth=0,
+            function_name="col",
+            root_names=list(column_names),
+            output_names=list(column_names),
+            backend_version=backend_version,
+        )
+
+    def __narwhals_namespace__(self) -> ArrowNamespace:
+        from narwhals._arrow.namespace import ArrowNamespace
+
+        return ArrowNamespace(backend_version=self._backend_version)
+
+    def __narwhals_expr__(self) -> None: ...
+
+    def __eq__(self, other: ArrowExpr | Any) -> Self:  # type: ignore[override]
+        return reuse_series_implementation(self, "__eq__", other=other)
+
+    def __ne__(self, other: ArrowExpr | Any) -> Self:  # type: ignore[override]
+        return reuse_series_implementation(self, "__ne__", other=other)
+
+    def __ge__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__ge__", other=other)
+
+    def __gt__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__gt__", other=other)
+
+    def __le__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__le__", other=other)
+
+    def __lt__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__lt__", other=other)
+
+    def __and__(self, other: ArrowExpr | bool | Any) -> Self:
+        return reuse_series_implementation(self, "__and__", other=other)
+
+    def __rand__(self, other: ArrowExpr | bool | Any) -> Self:
+        return reuse_series_implementation(self, "__rand__", other=other)
+
+    def __or__(self, other: ArrowExpr | bool | Any) -> Self:
+        return reuse_series_implementation(self, "__or__", other=other)
+
+    def __ror__(self, other: ArrowExpr | bool | Any) -> Self:
+        return reuse_series_implementation(self, "__ror__", other=other)
+
+    def __add__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__add__", other)
+
+    def __radd__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__radd__", other)
+
+    def __sub__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__sub__", other)
+
+    def __rsub__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__rsub__", other)
+
+    def __mul__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__mul__", other)
+
+    def __rmul__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__rmul__", other)
+
+    def __pow__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__pow__", other)
+
+    def __rpow__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__rpow__", other)
+
+    def __floordiv__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__floordiv__", other)
+
+    def __rfloordiv__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__rfloordiv__", other)
+
+    def __truediv__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__truediv__", other)
+
+    def __rtruediv__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__rtruediv__", other)
+
+    def __mod__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__mod__", other)
+
+    def __rmod__(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "__rmod__", other)
+
+    def __invert__(self) -> Self:
+        return reuse_series_implementation(self, "__invert__")
+
+    def len(self) -> Self:
+        return reuse_series_implementation(self, "len", returns_scalar=True)
+
+    def filter(self, *predicates: IntoArrowExpr) -> Self:
+        plx = self.__narwhals_namespace__()
+        expr = plx.all_horizontal(*predicates)
+        return reuse_series_implementation(self, "filter", other=expr)
+
+    def mean(self) -> Self:
+        return reuse_series_implementation(self, "mean", returns_scalar=True)
+
+    def count(self) -> Self:
+        return reuse_series_implementation(self, "count", returns_scalar=True)
+
+    def n_unique(self) -> Self:
+        return reuse_series_implementation(self, "n_unique", returns_scalar=True)
+
+    def std(self, ddof: int = 1) -> Self:
+        return reuse_series_implementation(self, "std", ddof=ddof, returns_scalar=True)
+
+    def cast(self, dtype: DType) -> Self:
+        return reuse_series_implementation(self, "cast", dtype)
+
+    def abs(self) -> Self:
+        return reuse_series_implementation(self, "abs")
+
+    def diff(self) -> Self:
+        return reuse_series_implementation(self, "diff")
+
+    def cum_sum(self) -> Self:
+        return reuse_series_implementation(self, "cum_sum")
+
+    def round(self, decimals: int) -> Self:
+        return reuse_series_implementation(self, "round", decimals)
+
+    def any(self) -> Self:
+        return reuse_series_implementation(self, "any", returns_scalar=True)
+
+    def min(self) -> Self:
+        return reuse_series_implementation(self, "min", returns_scalar=True)
+
+    def max(self) -> Self:
+        return reuse_series_implementation(self, "max", returns_scalar=True)
+
+    def all(self) -> Self:
+        return reuse_series_implementation(self, "all", returns_scalar=True)
+
+    def sum(self) -> Self:
+        return reuse_series_implementation(self, "sum", returns_scalar=True)
+
+    def drop_nulls(self) -> Self:
+        return reuse_series_implementation(self, "drop_nulls")
+
+    def shift(self, n: int) -> Self:
+        return reuse_series_implementation(self, "shift", n)
+
+    def alias(self, name: str) -> Self:
+        # Define this one manually, so that we can
+        # override `output_names` and not increase depth
+        return self.__class__(
+            lambda df: [series.alias(name) for series in self._call(df)],
+            depth=self._depth,
+            function_name=self._function_name,
+            root_names=self._root_names,
+            output_names=[name],
+            backend_version=self._backend_version,
+        )
+
+    def null_count(self) -> Self:
+        return reuse_series_implementation(self, "null_count", returns_scalar=True)
+
+    def is_null(self) -> Self:
+        return reuse_series_implementation(self, "is_null")
+
+    def is_between(self, lower_bound: Any, upper_bound: Any, closed: str) -> Self:
+        return reuse_series_implementation(
+            self, "is_between", lower_bound, upper_bound, closed
+        )
+
+    def head(self, n: int) -> Self:
+        return reuse_series_implementation(self, "head", n)
+
+    def tail(self, n: int) -> Self:
+        return reuse_series_implementation(self, "tail", n)
+
+    def is_in(self, other: ArrowExpr | Any) -> Self:
+        return reuse_series_implementation(self, "is_in", other)
+
+    def arg_true(self) -> Self:
+        return reuse_series_implementation(self, "arg_true")
+
+    def sample(
+        self: Self,
+        n: int | None = None,
+        *,
+        fraction: float | None = None,
+        with_replacement: bool = False,
+        seed: int | None = None,
+    ) -> Self:
+        return reuse_series_implementation(
+            self,
+            "sample",
+            n=n,
+            fraction=fraction,
+            with_replacement=with_replacement,
+            seed=seed,
+        )
+
+    def fill_null(self: Self, value: Any) -> Self:
+        return reuse_series_implementation(self, "fill_null", value=value)
+
+    def is_duplicated(self: Self) -> Self:
+        return reuse_series_implementation(self, "is_duplicated")
+
+    def is_unique(self: Self) -> Self:
+        return reuse_series_implementation(self, "is_unique")
+
+    def is_first_distinct(self: Self) -> Self:
+        return reuse_series_implementation(self, "is_first_distinct")
+
+    def is_last_distinct(self: Self) -> Self:
+        return reuse_series_implementation(self, "is_last_distinct")
+
+    def unique(self: Self) -> Self:
+        return reuse_series_implementation(self, "unique")
+
+    def sort(self: Self, *, descending: bool = False, nulls_last: bool = False) -> Self:
+        return reuse_series_implementation(
+            self, "sort", descending=descending, nulls_last=nulls_last
+        )
+
+    def quantile(
+        self,
+        quantile: float,
+        interpolation: Literal["nearest", "higher", "lower", "midpoint", "linear"],
+    ) -> Self:
+        return reuse_series_implementation(
+            self, "quantile", quantile, interpolation, returns_scalar=True
+        )
+
+    def gather_every(self: Self, n: int, offset: int = 0) -> Self:
+        return reuse_series_implementation(self, "gather_every", n=n, offset=offset)
+
+    def clip(
+        self: Self, lower_bound: Any | None = None, upper_bound: Any | None = None
+    ) -> Self:
+        return reuse_series_implementation(
+            self, "clip", lower_bound=lower_bound, upper_bound=upper_bound
+        )
+
+    def over(self: Self, keys: list[str]) -> Self:
+        def func(df: ArrowDataFrame) -> list[ArrowSeries]:
+            if self._output_names is None:
+                msg = (
+                    "Anonymous expressions are not supported in over.\n"
+                    "Instead of `nw.all()`, try using a named expression, such as "
+                    "`nw.col('a', 'b')`\n"
+                )
+                raise ValueError(msg)
+            tmp = df.group_by(*keys).agg(self)
+            tmp = df.select(*keys).join(
+                tmp, how="left", left_on=keys, right_on=keys, suffix="_right"
+            )
+            return [tmp[name] for name in self._output_names]
+
+        return self.__class__(
+            func,
+            depth=self._depth + 1,
+            function_name=self._function_name + "->over",
+            root_names=self._root_names,
+            output_names=self._output_names,
+            backend_version=self._backend_version,
+        )
+
+    def mode(self: Self) -> Self:
+        return reuse_series_implementation(self, "mode")
+
+    @property
+    def dt(self: Self) -> ArrowExprDateTimeNamespace:
+        return ArrowExprDateTimeNamespace(self)
+
+    @property
+    def str(self: Self) -> ArrowExprStringNamespace:
+        return ArrowExprStringNamespace(self)
+
+    @property
+    def cat(self: Self) -> ArrowExprCatNamespace:
+        return ArrowExprCatNamespace(self)
+
+    @property
+    def name(self: Self) -> ArrowExprNameNamespace:
+        return ArrowExprNameNamespace(self)
+
+
+class ArrowExprCatNamespace:
+    def __init__(self, expr: ArrowExpr) -> None:
+        self._expr = expr
+
+    def get_categories(self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr,
+            "cat",
+            "get_categories",
+        )
+
+
+class ArrowExprDateTimeNamespace:
+    def __init__(self: Self, expr: ArrowExpr) -> None:
+        self._expr = expr
+
+    def to_string(self: Self, format: str) -> ArrowExpr:  # noqa: A002
+        return reuse_series_namespace_implementation(
+            self._expr, "dt", "to_string", format
+        )
+
+    def date(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "date")
+
+    def year(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "year")
+
+    def month(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "month")
+
+    def day(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "day")
+
+    def hour(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "hour")
+
+    def minute(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "minute")
+
+    def second(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "second")
+
+    def millisecond(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "millisecond")
+
+    def microsecond(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "microsecond")
+
+    def nanosecond(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "nanosecond")
+
+    def ordinal_day(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "ordinal_day")
+
+    def total_minutes(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "total_minutes")
+
+    def total_seconds(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "dt", "total_seconds")
+
+    def total_milliseconds(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr, "dt", "total_milliseconds"
+        )
+
+    def total_microseconds(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr, "dt", "total_microseconds"
+        )
+
+    def total_nanoseconds(self: Self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr, "dt", "total_nanoseconds"
+        )
+
+
+class ArrowExprStringNamespace:
+    def __init__(self, expr: ArrowExpr) -> None:
+        self._expr = expr
+
+    def len_chars(self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(self._expr, "str", "len_chars")
+
+    def replace(
+        self,
+        pattern: str,
+        value: str,
+        *,
+        literal: bool = False,
+        n: int = 1,
+    ) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr,
+            "str",
+            "replace",
+            pattern,
+            value,
+            literal=literal,
+            n=n,
+        )
+
+    def replace_all(
+        self,
+        pattern: str,
+        value: str,
+        *,
+        literal: bool = False,
+    ) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr,
+            "str",
+            "replace_all",
+            pattern,
+            value,
+            literal=literal,
+        )
+
+    def strip_chars(self, characters: str | None = None) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr,
+            "str",
+            "strip_chars",
+            characters,
+        )
+
+    def starts_with(self, prefix: str) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr,
+            "str",
+            "starts_with",
+            prefix,
+        )
+
+    def ends_with(self, suffix: str) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr,
+            "str",
+            "ends_with",
+            suffix,
+        )
+
+    def contains(self, pattern: str, *, literal: bool) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr, "str", "contains", pattern, literal=literal
+        )
+
+    def slice(self, offset: int, length: int | None = None) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr, "str", "slice", offset, length
+        )
+
+    def to_datetime(self, format: str | None = None) -> ArrowExpr:  # noqa: A002
+        return reuse_series_namespace_implementation(
+            self._expr,
+            "str",
+            "to_datetime",
+            format,
+        )
+
+    def to_uppercase(self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr,
+            "str",
+            "to_uppercase",
+        )
+
+    def to_lowercase(self) -> ArrowExpr:
+        return reuse_series_namespace_implementation(
+            self._expr,
+            "str",
+            "to_lowercase",
+        )
+
+
+class ArrowExprNameNamespace:
+    def __init__(self: Self, expr: ArrowExpr) -> None:
+        self._expr = expr
+
+    def keep(self: Self) -> ArrowExpr:
+        root_names = self._expr._root_names
+
+        if root_names is None:
+            msg = (
+                "Anonymous expressions are not supported in `.name.keep`.\n"
+                "Instead of `nw.all()`, try using a named expression, such as "
+                "`nw.col('a', 'b')`\n"
+            )
+            raise ValueError(msg)
+
+        return self._expr.__class__(
+            lambda df: [
+                series.alias(name)
+                for series, name in zip(self._expr._call(df), root_names)
+            ],
+            depth=self._expr._depth,
+            function_name=self._expr._function_name,
+            root_names=root_names,
+            output_names=root_names,
+            backend_version=self._expr._backend_version,
+        )
+
+    def map(self: Self, function: Callable[[str], str]) -> ArrowExpr:
+        root_names = self._expr._root_names
+
+        if root_names is None:
+            msg = (
+                "Anonymous expressions are not supported in `.name.map`.\n"
+                "Instead of `nw.all()`, try using a named expression, such as "
+                "`nw.col('a', 'b')`\n"
+            )
+            raise ValueError(msg)
+
+        output_names = [function(str(name)) for name in root_names]
+
+        return self._expr.__class__(
+            lambda df: [
+                series.alias(name)
+                for series, name in zip(self._expr._call(df), output_names)
+            ],
+            depth=self._expr._depth,
+            function_name=self._expr._function_name,
+            root_names=root_names,
+            output_names=output_names,
+            backend_version=self._expr._backend_version,
+        )
+
+    def prefix(self: Self, prefix: str) -> ArrowExpr:
+        root_names = self._expr._root_names
+        if root_names is None:
+            msg = (
+                "Anonymous expressions are not supported in `.name.prefix`.\n"
+                "Instead of `nw.all()`, try using a named expression, such as "
+                "`nw.col('a', 'b')`\n"
+            )
+            raise ValueError(msg)
+
+        output_names = [prefix + str(name) for name in root_names]
+        return self._expr.__class__(
+            lambda df: [
+                series.alias(name)
+                for series, name in zip(self._expr._call(df), output_names)
+            ],
+            depth=self._expr._depth,
+            function_name=self._expr._function_name,
+            root_names=root_names,
+            output_names=output_names,
+            backend_version=self._expr._backend_version,
+        )
+
+    def suffix(self: Self, suffix: str) -> ArrowExpr:
+        root_names = self._expr._root_names
+        if root_names is None:
+            msg = (
+                "Anonymous expressions are not supported in `.name.suffix`.\n"
+                "Instead of `nw.all()`, try using a named expression, such as "
+                "`nw.col('a', 'b')`\n"
+            )
+            raise ValueError(msg)
+
+        output_names = [str(name) + suffix for name in root_names]
+
+        return self._expr.__class__(
+            lambda df: [
+                series.alias(name)
+                for series, name in zip(self._expr._call(df), output_names)
+            ],
+            depth=self._expr._depth,
+            function_name=self._expr._function_name,
+            root_names=root_names,
+            output_names=output_names,
+            backend_version=self._expr._backend_version,
+        )
+
+    def to_lowercase(self: Self) -> ArrowExpr:
+        root_names = self._expr._root_names
+
+        if root_names is None:
+            msg = (
+                "Anonymous expressions are not supported in `.name.to_lowercase`.\n"
+                "Instead of `nw.all()`, try using a named expression, such as "
+                "`nw.col('a', 'b')`\n"
+            )
+            raise ValueError(msg)
+        output_names = [str(name).lower() for name in root_names]
+
+        return self._expr.__class__(
+            lambda df: [
+                series.alias(name)
+                for series, name in zip(self._expr._call(df), output_names)
+            ],
+            depth=self._expr._depth,
+            function_name=self._expr._function_name,
+            root_names=root_names,
+            output_names=output_names,
+            backend_version=self._expr._backend_version,
+        )
+
+    def to_uppercase(self: Self) -> ArrowExpr:
+        root_names = self._expr._root_names
+
+        if root_names is None:
+            msg = (
+                "Anonymous expressions are not supported in `.name.to_uppercase`.\n"
+                "Instead of `nw.all()`, try using a named expression, such as "
+                "`nw.col('a', 'b')`\n"
+            )
+            raise ValueError(msg)
+        output_names = [str(name).upper() for name in root_names]
+
+        return self._expr.__class__(
+            lambda df: [
+                series.alias(name)
+                for series, name in zip(self._expr._call(df), output_names)
+            ],
+            depth=self._expr._depth,
+            function_name=self._expr._function_name,
+            root_names=root_names,
+            output_names=output_names,
+            backend_version=self._expr._backend_version,
+        )

parrot/lib/python3.10/site-packages/narwhals/_arrow/group_by.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from copy import copy
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Callable
+from typing import Iterator
+
+from narwhals._expression_parsing import is_simple_aggregation
+from narwhals._expression_parsing import parse_into_exprs
+from narwhals.utils import remove_prefix
+
+if TYPE_CHECKING:
+    from narwhals._arrow.dataframe import ArrowDataFrame
+    from narwhals._arrow.expr import ArrowExpr
+    from narwhals._arrow.typing import IntoArrowExpr
+
+POLARS_TO_ARROW_AGGREGATIONS = {
+    "len": "count",
+    "n_unique": "count_distinct",
+    "std": "stddev",
+    "var": "variance",  # currently unused, we don't have `var` yet
+}
+
+
+def get_function_name_option(function_name: str) -> Any | None:
+    """Map specific pyarrow compute function to respective option to match polars behaviour."""
+    import pyarrow.compute as pc  # ignore-banned-import
+
+    function_name_to_options = {
+        "count": pc.CountOptions(mode="all"),
+        "count_distinct": pc.CountOptions(mode="all"),
+        "stddev": pc.VarianceOptions(ddof=1),
+        "variance": pc.VarianceOptions(ddof=1),
+    }
+    return function_name_to_options.get(function_name)
+
+
+class ArrowGroupBy:
+    def __init__(self, df: ArrowDataFrame, keys: list[str]) -> None:
+        import pyarrow as pa  # ignore-banned-import()
+
+        self._df = df
+        self._keys = list(keys)
+        self._grouped = pa.TableGroupBy(self._df._native_frame, list(self._keys))
+
+    def agg(
+        self,
+        *aggs: IntoArrowExpr,
+        **named_aggs: IntoArrowExpr,
+    ) -> ArrowDataFrame:
+        exprs = parse_into_exprs(
+            *aggs,
+            namespace=self._df.__narwhals_namespace__(),
+            **named_aggs,
+        )
+        output_names: list[str] = copy(self._keys)
+        for expr in exprs:
+            if expr._output_names is None:
+                msg = (
+                    "Anonymous expressions are not supported in group_by.agg.\n"
+                    "Instead of `nw.all()`, try using a named expression, such as "
+                    "`nw.col('a', 'b')`\n"
+                )
+                raise ValueError(msg)
+            output_names.extend(expr._output_names)
+
+        return agg_arrow(
+            self._grouped,
+            exprs,
+            self._keys,
+            output_names,
+            self._df._from_native_frame,
+        )
+
+    def __iter__(self) -> Iterator[tuple[Any, ArrowDataFrame]]:
+        key_values = (
+            self._df.select(*self._keys)
+            .unique(subset=self._keys, keep="first")
+            .iter_rows()
+        )
+        nw_namespace = self._df.__narwhals_namespace__()
+        yield from (
+            (
+                key_value,
+                self._df.filter(
+                    *[nw_namespace.col(k) == v for k, v in zip(self._keys, key_value)]
+                ),
+            )
+            for key_value in key_values
+        )
+
+
+def agg_arrow(
+    grouped: Any,
+    exprs: list[ArrowExpr],
+    keys: list[str],
+    output_names: list[str],
+    from_dataframe: Callable[[Any], ArrowDataFrame],
+) -> ArrowDataFrame:
+    import pyarrow.compute as pc  # ignore-banned-import()
+
+    all_simple_aggs = True
+    for expr in exprs:
+        if not is_simple_aggregation(expr):
+            all_simple_aggs = False
+            break
+
+    if all_simple_aggs:
+        # Mapping from output name to
+        # (aggregation_args, pyarrow_output_name)  # noqa: ERA001
+        simple_aggregations: dict[str, tuple[tuple[Any, ...], str]] = {}
+        for expr in exprs:
+            if expr._depth == 0:
+                # e.g. agg(nw.len()) # noqa: ERA001
+                if (
+                    expr._output_names is None or expr._function_name != "len"
+                ):  # pragma: no cover
+                    msg = "Safety assertion failed, please report a bug to https://github.com/narwhals-dev/narwhals/issues"
+                    raise AssertionError(msg)
+                simple_aggregations[expr._output_names[0]] = (
+                    (keys[0], "count", pc.CountOptions(mode="all")),
+                    f"{keys[0]}_count",
+                )
+                continue
+
+            # e.g. agg(nw.mean('a')) # noqa: ERA001
+            if (
+                expr._depth != 1 or expr._root_names is None or expr._output_names is None
+            ):  # pragma: no cover
+                msg = "Safety assertion failed, please report a bug to https://github.com/narwhals-dev/narwhals/issues"
+                raise AssertionError(msg)
+
+            function_name = remove_prefix(expr._function_name, "col->")
+            function_name = POLARS_TO_ARROW_AGGREGATIONS.get(function_name, function_name)
+
+            option = get_function_name_option(function_name)
+            for root_name, output_name in zip(expr._root_names, expr._output_names):
+                simple_aggregations[output_name] = (
+                    (root_name, function_name, option),
+                    f"{root_name}_{function_name}",
+                )
+
+        aggs: list[Any] = []
+        name_mapping = {}
+        for output_name, (
+            aggregation_args,
+            pyarrow_output_name,
+        ) in simple_aggregations.items():
+            aggs.append(aggregation_args)
+            name_mapping[pyarrow_output_name] = output_name
+        result_simple = grouped.aggregate(aggs)
+        result_simple = result_simple.rename_columns(
+            [name_mapping.get(col, col) for col in result_simple.column_names]
+        ).select(output_names)
+        return from_dataframe(result_simple)
+
+    msg = (
+        "Non-trivial complex found.\n\n"
+        "Hint: you were probably trying to apply a non-elementary aggregation with a "
+        "pyarrow table.\n"
+        "Please rewrite your query such that group-by aggregations "
+        "are elementary. For example, instead of:\n\n"
+        "    df.group_by('a').agg(nw.col('b').round(2).mean())\n\n"
+        "use:\n\n"
+        "    df.with_columns(nw.col('b').round(2)).group_by('a').agg(nw.col('b').mean())\n\n"
+    )
+    raise ValueError(msg)

parrot/lib/python3.10/site-packages/narwhals/_arrow/selectors.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import NoReturn
+
+from narwhals import dtypes
+from narwhals._arrow.expr import ArrowExpr
+from narwhals.utils import Implementation
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from narwhals._arrow.dataframe import ArrowDataFrame
+    from narwhals._arrow.series import ArrowSeries
+    from narwhals.dtypes import DType
+
+
+class ArrowSelectorNamespace:
+    def __init__(self: Self, *, backend_version: tuple[int, ...]) -> None:
+        self._backend_version = backend_version
+        self._implementation = Implementation.PYARROW
+
+    def by_dtype(self: Self, dtypes: list[DType | type[DType]]) -> ArrowSelector:
+        def func(df: ArrowDataFrame) -> list[ArrowSeries]:
+            return [df[col] for col in df.columns if df.schema[col] in dtypes]
+
+        return ArrowSelector(
+            func,
+            depth=0,
+            function_name="type_selector",
+            root_names=None,
+            output_names=None,
+            backend_version=self._backend_version,
+        )
+
+    def numeric(self: Self) -> ArrowSelector:
+        return self.by_dtype(
+            [
+                dtypes.Int64,
+                dtypes.Int32,
+                dtypes.Int16,
+                dtypes.Int8,
+                dtypes.UInt64,
+                dtypes.UInt32,
+                dtypes.UInt16,
+                dtypes.UInt8,
+                dtypes.Float64,
+                dtypes.Float32,
+            ],
+        )
+
+    def categorical(self: Self) -> ArrowSelector:
+        return self.by_dtype([dtypes.Categorical])
+
+    def string(self: Self) -> ArrowSelector:
+        return self.by_dtype([dtypes.String])
+
+    def boolean(self: Self) -> ArrowSelector:
+        return self.by_dtype([dtypes.Boolean])
+
+    def all(self: Self) -> ArrowSelector:
+        def func(df: ArrowDataFrame) -> list[ArrowSeries]:
+            return [df[col] for col in df.columns]
+
+        return ArrowSelector(
+            func,
+            depth=0,
+            function_name="type_selector",
+            root_names=None,
+            output_names=None,
+            backend_version=self._backend_version,
+        )
+
+
+class ArrowSelector(ArrowExpr):
+    def __repr__(self: Self) -> str:  # pragma: no cover
+        return (
+            f"ArrowSelector("
+            f"depth={self._depth}, "
+            f"function_name={self._function_name}, "
+            f"root_names={self._root_names}, "
+            f"output_names={self._output_names}"
+        )
+
+    def _to_expr(self: Self) -> ArrowExpr:
+        return ArrowExpr(
+            self._call,
+            depth=self._depth,
+            function_name=self._function_name,
+            root_names=self._root_names,
+            output_names=self._output_names,
+            backend_version=self._backend_version,
+        )
+
+    def __sub__(self: Self, other: Self | Any) -> ArrowSelector | Any:
+        if isinstance(other, ArrowSelector):
+
+            def call(df: ArrowDataFrame) -> list[ArrowSeries]:
+                lhs = self._call(df)
+                rhs = other._call(df)
+                return [x for x in lhs if x.name not in {x.name for x in rhs}]
+
+            return ArrowSelector(
+                call,
+                depth=0,
+                function_name="type_selector",
+                root_names=None,
+                output_names=None,
+                backend_version=self._backend_version,
+            )
+        else:
+            return self._to_expr() - other
+
+    def __or__(self: Self, other: Self | Any) -> ArrowSelector | Any:
+        if isinstance(other, ArrowSelector):
+
+            def call(df: ArrowDataFrame) -> list[ArrowSeries]:
+                lhs = self._call(df)
+                rhs = other._call(df)
+                return [x for x in lhs if x.name not in {x.name for x in rhs}] + rhs
+
+            return ArrowSelector(
+                call,
+                depth=0,
+                function_name="type_selector",
+                root_names=None,
+                output_names=None,
+                backend_version=self._backend_version,
+            )
+        else:
+            return self._to_expr() | other
+
+    def __and__(self: Self, other: Self | Any) -> ArrowSelector | Any:
+        if isinstance(other, ArrowSelector):
+
+            def call(df: ArrowDataFrame) -> list[ArrowSeries]:
+                lhs = self._call(df)
+                rhs = other._call(df)
+                return [x for x in lhs if x.name in {x.name for x in rhs}]
+
+            return ArrowSelector(
+                call,
+                depth=0,
+                function_name="type_selector",
+                root_names=None,
+                output_names=None,
+                backend_version=self._backend_version,
+            )
+        else:
+            return self._to_expr() & other
+
+    def __invert__(self: Self) -> ArrowSelector:
+        return ArrowSelectorNamespace(backend_version=self._backend_version).all() - self
+
+    def __rsub__(self: Self, other: Any) -> NoReturn:
+        raise NotImplementedError
+
+    def __rand__(self: Self, other: Any) -> NoReturn:
+        raise NotImplementedError
+
+    def __ror__(self: Self, other: Any) -> NoReturn:
+        raise NotImplementedError

parrot/lib/python3.10/site-packages/narwhals/_arrow/series.py

@@ -0,0 +1,1038 @@
+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._arrow.utils import cast_for_truediv
+from narwhals._arrow.utils import floordiv_compat
+from narwhals._arrow.utils import narwhals_to_native_dtype
+from narwhals._arrow.utils import translate_dtype
+from narwhals._arrow.utils import validate_column_comparand
+from narwhals.dependencies import get_pandas
+from narwhals.dependencies import get_pyarrow
+from narwhals.utils import Implementation
+from narwhals.utils import generate_unique_token
+
+if TYPE_CHECKING:
+    import pyarrow as pa
+    from typing_extensions import Self
+
+    from narwhals._arrow.dataframe import ArrowDataFrame
+    from narwhals._arrow.namespace import ArrowNamespace
+    from narwhals.dtypes import DType
+
+
+class ArrowSeries:
+    def __init__(
+        self,
+        native_series: pa.ChunkedArray,
+        *,
+        name: str,
+        backend_version: tuple[int, ...],
+    ) -> None:
+        self._name = name
+        self._native_series = native_series
+        self._implementation = Implementation.PYARROW
+        self._backend_version = backend_version
+
+    def _from_native_series(self, series: Any) -> Self:
+        import pyarrow as pa  # ignore-banned-import()
+
+        if isinstance(series, pa.Array):
+            series = pa.chunked_array([series])
+        return self.__class__(
+            series,
+            name=self._name,
+            backend_version=self._backend_version,
+        )
+
+    @classmethod
+    def _from_iterable(
+        cls: type[Self],
+        data: Iterable[Any],
+        name: str,
+        *,
+        backend_version: tuple[int, ...],
+    ) -> Self:
+        import pyarrow as pa  # ignore-banned-import()
+
+        return cls(
+            pa.chunked_array([data]),
+            name=name,
+            backend_version=backend_version,
+        )
+
+    def __narwhals_namespace__(self) -> ArrowNamespace:
+        from narwhals._arrow.namespace import ArrowNamespace
+
+        return ArrowNamespace(backend_version=self._backend_version)
+
+    def __len__(self) -> int:
+        return len(self._native_series)
+
+    def __eq__(self, other: object) -> Self:  # type: ignore[override]
+        import pyarrow.compute as pc
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.equal(ser, other))
+
+    def __ne__(self, other: object) -> Self:  # type: ignore[override]
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.not_equal(ser, other))
+
+    def __ge__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.greater_equal(ser, other))
+
+    def __gt__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.greater(ser, other))
+
+    def __le__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.less_equal(ser, other))
+
+    def __lt__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.less(ser, other))
+
+    def __and__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.and_kleene(ser, other))
+
+    def __rand__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.and_kleene(other, ser))
+
+    def __or__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.or_kleene(ser, other))
+
+    def __ror__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.or_kleene(other, ser))
+
+    def __add__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.add(self._native_series, other))
+
+    def __radd__(self, other: Any) -> Self:
+        return self + other  # type: ignore[no-any-return]
+
+    def __sub__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.subtract(self._native_series, other))
+
+    def __rsub__(self, other: Any) -> Self:
+        return (self - other) * (-1)  # type: ignore[no-any-return]
+
+    def __mul__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.multiply(self._native_series, other))
+
+    def __rmul__(self, other: Any) -> Self:
+        return self * other  # type: ignore[no-any-return]
+
+    def __pow__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.power(ser, other))
+
+    def __rpow__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(pc.power(other, ser))
+
+    def __floordiv__(self, other: Any) -> Self:
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(floordiv_compat(ser, other))
+
+    def __rfloordiv__(self, other: Any) -> Self:
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        return self._from_native_series(floordiv_compat(other, ser))
+
+    def __truediv__(self, other: Any) -> Self:
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        if not isinstance(other, (pa.Array, pa.ChunkedArray)):
+            # scalar
+            other = pa.scalar(other)
+        return self._from_native_series(pc.divide(*cast_for_truediv(ser, other)))
+
+    def __rtruediv__(self, other: Any) -> Self:
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        if not isinstance(other, (pa.Array, pa.ChunkedArray)):
+            # scalar
+            other = pa.scalar(other)
+        return self._from_native_series(pc.divide(*cast_for_truediv(other, ser)))
+
+    def __mod__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        floor_div = (self // other)._native_series
+        res = pc.subtract(ser, pc.multiply(floor_div, other))
+        return self._from_native_series(res)
+
+    def __rmod__(self, other: Any) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        other = validate_column_comparand(other)
+        floor_div = (other // self)._native_series
+        res = pc.subtract(other, pc.multiply(floor_div, ser))
+        return self._from_native_series(res)
+
+    def __invert__(self) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._from_native_series(pc.invert(self._native_series))
+
+    def len(self) -> int:
+        return len(self._native_series)
+
+    def filter(self, other: Any) -> Self:
+        if not (isinstance(other, list) and all(isinstance(x, bool) for x in other)):
+            other = validate_column_comparand(other)
+        return self._from_native_series(self._native_series.filter(other))
+
+    def mean(self) -> int:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return pc.mean(self._native_series)  # type: ignore[no-any-return]
+
+    def min(self) -> int:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return pc.min(self._native_series)  # type: ignore[no-any-return]
+
+    def max(self) -> int:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return pc.max(self._native_series)  # type: ignore[no-any-return]
+
+    def sum(self) -> int:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return pc.sum(self._native_series)  # type: ignore[no-any-return]
+
+    def drop_nulls(self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._from_native_series(pc.drop_null(self._native_series))
+
+    def shift(self, n: int) -> Self:
+        import pyarrow as pa  # ignore-banned-import()
+
+        ca = self._native_series
+
+        if n > 0:
+            result = pa.concat_arrays([pa.nulls(n, ca.type), *ca[:-n].chunks])
+        elif n < 0:
+            result = pa.concat_arrays([*ca[-n:].chunks, pa.nulls(-n, ca.type)])
+        else:
+            result = ca
+        return self._from_native_series(result)
+
+    def std(self, ddof: int = 1) -> int:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return pc.stddev(self._native_series, ddof=ddof)  # type: ignore[no-any-return]
+
+    def count(self) -> int:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return pc.count(self._native_series)  # type: ignore[no-any-return]
+
+    def n_unique(self) -> int:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        unique_values = pc.unique(self._native_series)
+        return pc.count(unique_values, mode="all")  # type: ignore[no-any-return]
+
+    def __native_namespace__(self) -> Any:  # pragma: no cover
+        return get_pyarrow()
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    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[idx]
+        if isinstance(idx, Sequence):
+            return self._from_native_series(self._native_series.take(idx))
+        return self._from_native_series(self._native_series[idx])
+
+    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:
+        import numpy as np  # ignore-banned-import
+        import pyarrow as pa  # ignore-banned-import
+        import pyarrow.compute as pc  # ignore-banned-import
+
+        ca = self._native_series
+        mask = np.zeros(len(ca), dtype=bool)
+        mask[indices] = True
+        if isinstance(values, self.__class__):
+            values = validate_column_comparand(values)
+        if isinstance(values, pa.ChunkedArray):
+            values = values.combine_chunks()
+        if not isinstance(values, pa.Array):
+            values = pa.array(values)
+        result = pc.replace_with_mask(ca, mask, values.take(indices))
+        return self._from_native_series(result)
+
+    def to_list(self) -> Any:
+        return self._native_series.to_pylist()
+
+    def __array__(self, dtype: Any = None, copy: bool | None = None) -> Any:
+        return self._native_series.__array__(dtype=dtype, copy=copy)
+
+    def to_numpy(self) -> Any:
+        return self._native_series.to_numpy()
+
+    def alias(self, name: str) -> Self:
+        return self.__class__(
+            self._native_series,
+            name=name,
+            backend_version=self._backend_version,
+        )
+
+    @property
+    def dtype(self: Self) -> DType:
+        return translate_dtype(self._native_series.type)
+
+    def abs(self) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._from_native_series(pc.abs(self._native_series))
+
+    def cum_sum(self) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._from_native_series(pc.cumulative_sum(self._native_series))
+
+    def round(self, decimals: int) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._from_native_series(
+            pc.round(self._native_series, decimals, round_mode="half_towards_infinity")
+        )
+
+    def diff(self) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._from_native_series(
+            pc.pairwise_diff(self._native_series.combine_chunks())
+        )
+
+    def any(self) -> bool:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return pc.any(self._native_series)  # type: ignore[no-any-return]
+
+    def all(self) -> bool:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return pc.all(self._native_series)  # type: ignore[no-any-return]
+
+    def is_between(
+        self, lower_bound: Any, upper_bound: Any, closed: str = "both"
+    ) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        if closed == "left":
+            ge = pc.greater_equal(ser, lower_bound)
+            lt = pc.less(ser, upper_bound)
+            res = pc.and_kleene(ge, lt)
+        elif closed == "right":
+            gt = pc.greater(ser, lower_bound)
+            le = pc.less_equal(ser, upper_bound)
+            res = pc.and_kleene(gt, le)
+        elif closed == "none":
+            gt = pc.greater(ser, lower_bound)
+            lt = pc.less(ser, upper_bound)
+            res = pc.and_kleene(gt, lt)
+        elif closed == "both":
+            ge = pc.greater_equal(ser, lower_bound)
+            le = pc.less_equal(ser, upper_bound)
+            res = pc.and_kleene(ge, le)
+        else:  # pragma: no cover
+            raise AssertionError
+        return self._from_native_series(res)
+
+    def is_empty(self) -> bool:
+        return len(self) == 0
+
+    def is_null(self) -> Self:
+        ser = self._native_series
+        return self._from_native_series(ser.is_null())
+
+    def cast(self, dtype: DType) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        dtype = narwhals_to_native_dtype(dtype)
+        return self._from_native_series(pc.cast(ser, dtype))
+
+    def null_count(self: Self) -> int:
+        return self._native_series.null_count  # type: ignore[no-any-return]
+
+    def head(self, n: int) -> Self:
+        ser = self._native_series
+        if n >= 0:
+            return self._from_native_series(ser.slice(0, n))
+        else:
+            num_rows = len(ser)
+            return self._from_native_series(ser.slice(0, max(0, num_rows + n)))
+
+    def tail(self, n: int) -> Self:
+        ser = self._native_series
+        if n >= 0:
+            num_rows = len(ser)
+            return self._from_native_series(ser.slice(max(0, num_rows - n)))
+        else:
+            return self._from_native_series(ser.slice(abs(n)))
+
+    def is_in(self, other: Any) -> Self:
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        value_set = pa.array(other)
+        ser = self._native_series
+        return self._from_native_series(pc.is_in(ser, value_set=value_set))
+
+    def arg_true(self) -> Self:
+        import numpy as np  # ignore-banned-import
+
+        ser = self._native_series
+        res = np.flatnonzero(ser)
+        return self._from_iterable(
+            res, name=self.name, backend_version=self._backend_version
+        )
+
+    def item(self: Self, index: int | None = None) -> Any:
+        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[0]
+        return self._native_series[index]
+
+    def value_counts(
+        self: Self,
+        *,
+        sort: bool = False,
+        parallel: bool = False,
+        name: str | None = None,
+        normalize: bool = False,
+    ) -> ArrowDataFrame:
+        """Parallel is unused, exists for compatibility"""
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        from narwhals._arrow.dataframe import ArrowDataFrame
+
+        index_name_ = "index" if self._name is None else self._name
+        value_name_ = name or ("proportion" if normalize else "count")
+
+        val_count = pc.value_counts(self._native_series)
+        values = val_count.field("values")
+        counts = val_count.field("counts")
+
+        if normalize:
+            counts = pc.divide(*cast_for_truediv(counts, pc.sum(counts)))
+
+        val_count = pa.Table.from_arrays(
+            [values, counts], names=[index_name_, value_name_]
+        )
+
+        if sort:
+            val_count = val_count.sort_by([(value_name_, "descending")])
+
+        return ArrowDataFrame(
+            val_count,
+            backend_version=self._backend_version,
+        )
+
+    def zip_with(self: Self, mask: Self, other: Self) -> Self:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        mask = mask._native_series.combine_chunks()
+        return self._from_native_series(
+            pc.if_else(
+                mask,
+                self._native_series,
+                other._native_series,
+            )
+        )
+
+    def sample(
+        self: Self,
+        n: int | None = None,
+        *,
+        fraction: float | None = None,
+        with_replacement: bool = False,
+        seed: int | None = None,
+    ) -> Self:
+        import numpy as np  # ignore-banned-import
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        num_rows = len(self)
+
+        if n is None and fraction is not None:
+            n = int(num_rows * fraction)
+
+        rng = np.random.default_rng(seed=seed)
+        idx = np.arange(0, num_rows)
+        mask = rng.choice(idx, size=n, replace=with_replacement)
+
+        return self._from_native_series(pc.take(ser, mask))
+
+    def fill_null(self: Self, value: Any) -> Self:
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        dtype = ser.type
+
+        return self._from_native_series(pc.fill_null(ser, pa.scalar(value, dtype)))
+
+    def to_frame(self: Self) -> ArrowDataFrame:
+        import pyarrow as pa  # ignore-banned-import()
+
+        from narwhals._arrow.dataframe import ArrowDataFrame
+
+        df = pa.Table.from_arrays([self._native_series], names=[self.name])
+        return ArrowDataFrame(df, backend_version=self._backend_version)
+
+    def to_pandas(self: Self) -> Any:
+        pd = get_pandas()
+        return pd.Series(self._native_series, name=self.name)
+
+    def is_duplicated(self: Self) -> ArrowSeries:
+        return self.to_frame().is_duplicated().alias(self.name)
+
+    def is_unique(self: Self) -> ArrowSeries:
+        return self.to_frame().is_unique().alias(self.name)
+
+    def is_first_distinct(self: Self) -> Self:
+        import numpy as np  # ignore-banned-import
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        row_number = pa.array(np.arange(len(self)))
+        col_token = generate_unique_token(n_bytes=8, columns=[self.name])
+        first_distinct_index = (
+            pa.Table.from_arrays([self._native_series], names=[self.name])
+            .append_column(col_token, row_number)
+            .group_by(self.name)
+            .aggregate([(col_token, "min")])
+            .column(f"{col_token}_min")
+        )
+
+        return self._from_native_series(pc.is_in(row_number, first_distinct_index))
+
+    def is_last_distinct(self: Self) -> Self:
+        import numpy as np  # ignore-banned-import
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        row_number = pa.array(np.arange(len(self)))
+        col_token = generate_unique_token(n_bytes=8, columns=[self.name])
+        last_distinct_index = (
+            pa.Table.from_arrays([self._native_series], names=[self.name])
+            .append_column(col_token, row_number)
+            .group_by(self.name)
+            .aggregate([(col_token, "max")])
+            .column(f"{col_token}_max")
+        )
+
+        return self._from_native_series(pc.is_in(row_number, last_distinct_index))
+
+    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)
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        ser = self._native_series
+        if descending:
+            return pc.all(pc.greater_equal(ser[:-1], ser[1:]))  # type: ignore[no-any-return]
+        else:
+            return pc.all(pc.less_equal(ser[:-1], ser[1:]))  # type: ignore[no-any-return]
+
+    def unique(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._from_native_series(pc.unique(self._native_series))
+
+    def sort(
+        self: Self, *, descending: bool = False, nulls_last: bool = False
+    ) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        series = self._native_series
+        order = "descending" if descending else "ascending"
+        null_placement = "at_end" if nulls_last else "at_start"
+        sorted_indices = pc.array_sort_indices(
+            series, order=order, null_placement=null_placement
+        )
+
+        return self._from_native_series(pc.take(series, sorted_indices))
+
+    def to_dummies(
+        self: Self, *, separator: str = "_", drop_first: bool = False
+    ) -> ArrowDataFrame:
+        import numpy as np  # ignore-banned-import
+        import pyarrow as pa  # ignore-banned-import()
+
+        from narwhals._arrow.dataframe import ArrowDataFrame
+
+        series = self._native_series
+        da = series.dictionary_encode().combine_chunks()
+
+        columns = np.zeros((len(da.dictionary), len(da)), np.uint8)
+        columns[da.indices, np.arange(len(da))] = 1
+        names = [f"{self._name}{separator}{v}" for v in da.dictionary]
+
+        return ArrowDataFrame(
+            pa.Table.from_arrays(columns, names=names),
+            backend_version=self._backend_version,
+        ).select(*sorted(names)[int(drop_first) :])
+
+    def quantile(
+        self: Self,
+        quantile: float,
+        interpolation: Literal["nearest", "higher", "lower", "midpoint", "linear"],
+    ) -> Any:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return pc.quantile(self._native_series, q=quantile, interpolation=interpolation)[
+            0
+        ]
+
+    def gather_every(self: Self, n: int, offset: int = 0) -> Self:
+        return self._from_native_series(self._native_series[offset::n])
+
+    def clip(
+        self: Self, lower_bound: Any | None = None, upper_bound: Any | None = None
+    ) -> Self:
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        arr = self._native_series
+        arr = pc.max_element_wise(arr, pa.scalar(lower_bound, type=arr.type))
+        arr = pc.min_element_wise(arr, pa.scalar(upper_bound, type=arr.type))
+
+        return self._from_native_series(arr)
+
+    def to_arrow(self: Self) -> pa.Array:
+        return self._native_series.combine_chunks()
+
+    def mode(self: Self) -> ArrowSeries:
+        plx = self.__narwhals_namespace__()
+        col_token = generate_unique_token(n_bytes=8, columns=[self.name])
+        return self.value_counts(name=col_token, normalize=False).filter(
+            plx.col(col_token) == plx.col(col_token).max()
+        )[self.name]
+
+    def __iter__(self: Self) -> Iterator[Any]:
+        yield from self._native_series.__iter__()
+
+    @property
+    def shape(self) -> tuple[int]:
+        return (len(self._native_series),)
+
+    @property
+    def dt(self) -> ArrowSeriesDateTimeNamespace:
+        return ArrowSeriesDateTimeNamespace(self)
+
+    @property
+    def cat(self) -> ArrowSeriesCatNamespace:
+        return ArrowSeriesCatNamespace(self)
+
+    @property
+    def str(self) -> ArrowSeriesStringNamespace:
+        return ArrowSeriesStringNamespace(self)
+
+
+class ArrowSeriesDateTimeNamespace:
+    def __init__(self: Self, series: ArrowSeries) -> None:
+        self._arrow_series = series
+
+    def to_string(self: Self, format: str) -> ArrowSeries:  # noqa: A002
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        # PyArrow differs from other libraries in that %S also prints out
+        # the fractional part of the second...:'(
+        # https://arrow.apache.org/docs/python/generated/pyarrow.compute.strftime.html
+        format = format.replace("%S.%f", "%S").replace("%S%.f", "%S")
+        return self._arrow_series._from_native_series(
+            pc.strftime(self._arrow_series._native_series, format)
+        )
+
+    def date(self: Self) -> ArrowSeries:
+        import pyarrow as pa  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            self._arrow_series._native_series.cast(pa.date64())
+        )
+
+    def year(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.year(self._arrow_series._native_series)
+        )
+
+    def month(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.month(self._arrow_series._native_series)
+        )
+
+    def day(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.day(self._arrow_series._native_series)
+        )
+
+    def hour(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.hour(self._arrow_series._native_series)
+        )
+
+    def minute(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.minute(self._arrow_series._native_series)
+        )
+
+    def second(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.second(self._arrow_series._native_series)
+        )
+
+    def millisecond(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.millisecond(self._arrow_series._native_series)
+        )
+
+    def microsecond(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        arr = self._arrow_series._native_series
+        result = pc.add(pc.multiply(pc.millisecond(arr), 1000), pc.microsecond(arr))
+
+        return self._arrow_series._from_native_series(result)
+
+    def nanosecond(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        arr = self._arrow_series._native_series
+        result = pc.add(
+            pc.multiply(self.microsecond()._native_series, 1000), pc.nanosecond(arr)
+        )
+        return self._arrow_series._from_native_series(result)
+
+    def ordinal_day(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.day_of_year(self._arrow_series._native_series)
+        )
+
+    def total_minutes(self: Self) -> ArrowSeries:
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        arr = self._arrow_series._native_series
+        unit = arr.type.unit
+
+        unit_to_minutes_factor = {
+            "s": 60,  # seconds
+            "ms": 60 * 1e3,  # milli
+            "us": 60 * 1e6,  # micro
+            "ns": 60 * 1e9,  # nano
+        }
+
+        factor = pa.scalar(unit_to_minutes_factor[unit], type=pa.int64())
+        return self._arrow_series._from_native_series(
+            pc.cast(pc.divide(arr, factor), pa.int64())
+        )
+
+    def total_seconds(self: Self) -> ArrowSeries:
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        arr = self._arrow_series._native_series
+        unit = arr.type.unit
+
+        unit_to_seconds_factor = {
+            "s": 1,  # seconds
+            "ms": 1e3,  # milli
+            "us": 1e6,  # micro
+            "ns": 1e9,  # nano
+        }
+        factor = pa.scalar(unit_to_seconds_factor[unit], type=pa.int64())
+
+        return self._arrow_series._from_native_series(
+            pc.cast(pc.divide(arr, factor), pa.int64())
+        )
+
+    def total_milliseconds(self: Self) -> ArrowSeries:
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        arr = self._arrow_series._native_series
+        unit = arr.type.unit
+
+        unit_to_milli_factor = {
+            "s": 1e3,  # seconds
+            "ms": 1,  # milli
+            "us": 1e3,  # micro
+            "ns": 1e6,  # nano
+        }
+
+        factor = pa.scalar(unit_to_milli_factor[unit], type=pa.int64())
+
+        if unit == "s":
+            return self._arrow_series._from_native_series(
+                pc.cast(pc.multiply(arr, factor), pa.int64())
+            )
+
+        return self._arrow_series._from_native_series(
+            pc.cast(pc.divide(arr, factor), pa.int64())
+        )
+
+    def total_microseconds(self: Self) -> ArrowSeries:
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        arr = self._arrow_series._native_series
+        unit = arr.type.unit
+
+        unit_to_micro_factor = {
+            "s": 1e6,  # seconds
+            "ms": 1e3,  # milli
+            "us": 1,  # micro
+            "ns": 1e3,  # nano
+        }
+
+        factor = pa.scalar(unit_to_micro_factor[unit], type=pa.int64())
+
+        if unit in {"s", "ms"}:
+            return self._arrow_series._from_native_series(
+                pc.cast(pc.multiply(arr, factor), pa.int64())
+            )
+        return self._arrow_series._from_native_series(
+            pc.cast(pc.divide(arr, factor), pa.int64())
+        )
+
+    def total_nanoseconds(self: Self) -> ArrowSeries:
+        import pyarrow as pa  # ignore-banned-import()
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        arr = self._arrow_series._native_series
+        unit = arr.type.unit
+
+        unit_to_nano_factor = {
+            "s": 1e9,  # seconds
+            "ms": 1e6,  # milli
+            "us": 1e3,  # micro
+            "ns": 1,  # nano
+        }
+
+        factor = pa.scalar(unit_to_nano_factor[unit], type=pa.int64())
+
+        return self._arrow_series._from_native_series(
+            pc.cast(pc.multiply(arr, factor), pa.int64())
+        )
+
+
+class ArrowSeriesCatNamespace:
+    def __init__(self, series: ArrowSeries) -> None:
+        self._arrow_series = series
+
+    def get_categories(self) -> ArrowSeries:
+        import pyarrow as pa  # ignore-banned-import()
+
+        ca = self._arrow_series._native_series
+        # TODO(Unassigned): this looks potentially expensive - is there no better way?
+        # https://github.com/narwhals-dev/narwhals/issues/464
+        out = pa.chunked_array(
+            [pa.concat_arrays([x.dictionary for x in ca.chunks]).unique()]
+        )
+        return self._arrow_series._from_native_series(out)
+
+
+class ArrowSeriesStringNamespace:
+    def __init__(self: Self, series: ArrowSeries) -> None:
+        self._arrow_series = series
+
+    def len_chars(self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.utf8_length(self._arrow_series._native_series)
+        )
+
+    def replace(
+        self, pattern: str, value: str, *, literal: bool = False, n: int = 1
+    ) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        method = "replace_substring" if literal else "replace_substring_regex"
+        return self._arrow_series._from_native_series(
+            getattr(pc, method)(
+                self._arrow_series._native_series,
+                pattern=pattern,
+                replacement=value,
+                max_replacements=n,
+            )
+        )
+
+    def replace_all(
+        self, pattern: str, value: str, *, literal: bool = False
+    ) -> ArrowSeries:
+        return self.replace(pattern, value, literal=literal, n=-1)
+
+    def strip_chars(self: Self, characters: str | None = None) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        whitespace = " \t\n\r\v\f"
+        return self._arrow_series._from_native_series(
+            pc.utf8_trim(
+                self._arrow_series._native_series,
+                characters or whitespace,
+            )
+        )
+
+    def starts_with(self: Self, prefix: str) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.equal(self.slice(0, len(prefix))._native_series, prefix)
+        )
+
+    def ends_with(self: Self, suffix: str) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.equal(self.slice(-len(suffix))._native_series, suffix)
+        )
+
+    def contains(self: Self, pattern: str, *, literal: bool = False) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        check_func = pc.match_substring if literal else pc.match_substring_regex
+        return self._arrow_series._from_native_series(
+            check_func(self._arrow_series._native_series, pattern)
+        )
+
+    def slice(self: Self, offset: int, length: int | None = None) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        stop = offset + length if length else None
+        return self._arrow_series._from_native_series(
+            pc.utf8_slice_codeunits(
+                self._arrow_series._native_series, start=offset, stop=stop
+            ),
+        )
+
+    def to_datetime(self: Self, format: str | None = None) -> ArrowSeries:  # noqa: A002
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.strptime(self._arrow_series._native_series, format=format, unit="us")
+        )
+
+    def to_uppercase(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.utf8_upper(self._arrow_series._native_series),
+        )
+
+    def to_lowercase(self: Self) -> ArrowSeries:
+        import pyarrow.compute as pc  # ignore-banned-import()
+
+        return self._arrow_series._from_native_series(
+            pc.utf8_lower(self._arrow_series._native_series),
+        )

parrot/lib/python3.10/site-packages/narwhals/_arrow/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._arrow.expr import ArrowExpr
+    from narwhals._arrow.series import ArrowSeries
+
+    IntoArrowExpr: TypeAlias = Union[ArrowExpr, str, int, float, ArrowSeries]

parrot/lib/python3.10/site-packages/narwhals/_dask/dataframe.py

@@ -0,0 +1,357 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Iterable
+from typing import Literal
+from typing import Sequence
+
+from narwhals._dask.utils import add_row_index
+from narwhals._dask.utils import parse_exprs_and_named_exprs
+from narwhals._pandas_like.utils import translate_dtype
+from narwhals.dependencies import get_dask_dataframe
+from narwhals.dependencies import get_pandas
+from narwhals.utils import Implementation
+from narwhals.utils import flatten
+from narwhals.utils import generate_unique_token
+from narwhals.utils import parse_columns_to_drop
+from narwhals.utils import parse_version
+
+if TYPE_CHECKING:
+    import dask.dataframe as dd
+    from typing_extensions import Self
+
+    from narwhals._dask.expr import DaskExpr
+    from narwhals._dask.group_by import DaskLazyGroupBy
+    from narwhals._dask.namespace import DaskNamespace
+    from narwhals._dask.typing import IntoDaskExpr
+    from narwhals.dtypes import DType
+
+
+class DaskLazyFrame:
+    def __init__(
+        self, native_dataframe: dd.DataFrame, *, backend_version: tuple[int, ...]
+    ) -> None:
+        self._native_frame = native_dataframe
+        self._backend_version = backend_version
+        self._implementation = Implementation.DASK
+
+    def __native_namespace__(self) -> Any:  # pragma: no cover
+        return get_dask_dataframe()
+
+    def __narwhals_namespace__(self) -> DaskNamespace:
+        from narwhals._dask.namespace import DaskNamespace
+
+        return DaskNamespace(backend_version=self._backend_version)
+
+    def __narwhals_lazyframe__(self) -> Self:
+        return self
+
+    def _from_native_frame(self, df: Any) -> Self:
+        return self.__class__(df, backend_version=self._backend_version)
+
+    def with_columns(self, *exprs: DaskExpr, **named_exprs: DaskExpr) -> Self:
+        df = self._native_frame
+        new_series = parse_exprs_and_named_exprs(self, *exprs, **named_exprs)
+        df = df.assign(**new_series)
+        return self._from_native_frame(df)
+
+    def collect(self) -> Any:
+        from narwhals._pandas_like.dataframe import PandasLikeDataFrame
+
+        result = self._native_frame.compute()
+        return PandasLikeDataFrame(
+            result,
+            implementation=Implementation.PANDAS,
+            backend_version=parse_version(get_pandas().__version__),
+        )
+
+    @property
+    def columns(self) -> list[str]:
+        return self._native_frame.columns.tolist()  # type: ignore[no-any-return]
+
+    def filter(
+        self,
+        *predicates: DaskExpr,
+    ) -> Self:
+        if (
+            len(predicates) == 1
+            and isinstance(predicates[0], list)
+            and all(isinstance(x, bool) for x in predicates[0])
+        ):
+            msg = (
+                "`LazyFrame.filter` is not supported for Dask backend with boolean masks."
+            )
+            raise NotImplementedError(msg)
+
+        from narwhals._dask.namespace import DaskNamespace
+
+        plx = DaskNamespace(backend_version=self._backend_version)
+        expr = plx.all_horizontal(*predicates)
+        # Safety: all_horizontal's expression only returns a single column.
+        mask = expr._call(self)[0]
+        return self._from_native_frame(self._native_frame.loc[mask])
+
+    def lazy(self) -> Self:
+        return self
+
+    def select(
+        self: Self,
+        *exprs: IntoDaskExpr,
+        **named_exprs: IntoDaskExpr,
+    ) -> Self:
+        import dask.dataframe as dd  # ignore-banned-import
+
+        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[:, exprs])
+
+        new_series = parse_exprs_and_named_exprs(self, *exprs, **named_exprs)
+
+        if not new_series:
+            # return empty dataframe, like Polars does
+            import pandas as pd  # ignore-banned-import
+
+            return self._from_native_frame(
+                dd.from_pandas(pd.DataFrame(), npartitions=self._native_frame.npartitions)
+            )
+
+        if all(getattr(expr, "_returns_scalar", False) for expr in exprs) and all(
+            getattr(val, "_returns_scalar", False) for val in named_exprs.values()
+        ):
+            df = dd.concat(
+                [val.to_series().rename(name) for name, val in new_series.items()], axis=1
+            )
+            return self._from_native_frame(df)
+
+        df = self._native_frame.assign(**new_series).loc[:, list(new_series.keys())]
+        return self._from_native_frame(df)
+
+    def drop_nulls(self: Self, subset: str | list[str] | None) -> Self:
+        if subset is None:
+            return self._from_native_frame(self._native_frame.dropna())
+        subset = [subset] if isinstance(subset, str) else subset
+        plx = self.__narwhals_namespace__()
+        return self.filter(~plx.any_horizontal(plx.col(*subset).is_null()))
+
+    @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
+
+    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))
+
+    def with_row_index(self: Self, name: str) -> Self:
+        # Implementation is based on the following StackOverflow reply:
+        # https://stackoverflow.com/questions/60831518/in-dask-how-does-one-add-a-range-of-integersauto-increment-to-a-new-column/60852409#60852409
+        return self._from_native_frame(add_row_index(self._native_frame, name))
+
+    def rename(self: Self, mapping: dict[str, str]) -> Self:
+        return self._from_native_frame(self._native_frame.rename(columns=mapping))
+
+    def head(self: Self, n: int) -> Self:
+        return self._from_native_frame(
+            self._native_frame.head(n=n, compute=False, npartitions=-1)
+        )
+
+    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.
+        """
+        subset = flatten(subset) if subset else None
+        native_frame = self._native_frame
+        if keep == "none":
+            subset = subset or self.columns
+            token = generate_unique_token(n_bytes=8, columns=subset)
+            ser = native_frame.groupby(subset).size().rename(token)
+            ser = ser.loc[ser == 1]
+            unique = ser.reset_index().drop(columns=token)
+            result = native_frame.merge(unique, on=subset, how="inner")
+        else:
+            mapped_keep = {"any": "first"}.get(keep, keep)
+            result = native_frame.drop_duplicates(subset=subset, keep=mapped_keep)
+        return self._from_native_frame(result)
+
+    def sort(
+        self: 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))
+
+    def join(
+        self: 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":
+            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),
+            )
+
+        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()
+            )
+            df = self._native_frame.merge(
+                other_native,
+                how="outer",
+                indicator=indicator_token,
+                left_on=left_on,
+                right_on=left_on,
+            )
+            return self._from_native_frame(
+                df.loc[df[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}_right")
+            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"),
+            ),
+        )
+
+    def group_by(self, *by: str) -> DaskLazyGroupBy:
+        from narwhals._dask.group_by import DaskLazyGroupBy
+
+        return DaskLazyGroupBy(self, list(by))
+
+    def tail(self: Self, n: int) -> Self:
+        native_frame = self._native_frame
+        n_partitions = native_frame.npartitions
+
+        if n_partitions == 1:
+            return self._from_native_frame(self._native_frame.tail(n=n, compute=False))
+        else:
+            msg = "`LazyFrame.tail` is not supported for Dask backend with multiple partitions."
+            raise NotImplementedError(msg)
+
+    def gather_every(self: Self, n: int, offset: int) -> Self:
+        row_index_token = generate_unique_token(n_bytes=8, columns=self.columns)
+        pln = self.__narwhals_namespace__()
+        return (
+            self.with_row_index(name=row_index_token)
+            .filter(
+                pln.col(row_index_token) >= offset,  # type: ignore[operator]
+                (pln.col(row_index_token) - offset) % n == 0,  # type: ignore[arg-type]
+            )
+            .drop([row_index_token], strict=False)
+        )

parrot/lib/python3.10/site-packages/narwhals/_dask/namespace.py

@@ -0,0 +1,331 @@
+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 NoReturn
+from typing import cast
+
+from narwhals import dtypes
+from narwhals._dask.dataframe import DaskLazyFrame
+from narwhals._dask.expr import DaskExpr
+from narwhals._dask.selectors import DaskSelectorNamespace
+from narwhals._dask.utils import reverse_translate_dtype
+from narwhals._dask.utils import validate_comparand
+from narwhals._expression_parsing import parse_into_exprs
+
+if TYPE_CHECKING:
+    import dask_expr
+
+    from narwhals._dask.typing import IntoDaskExpr
+    from narwhals.dtypes import DType
+
+
+class DaskNamespace:
+    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) -> DaskSelectorNamespace:
+        return DaskSelectorNamespace(backend_version=self._backend_version)
+
+    def __init__(self, *, backend_version: tuple[int, ...]) -> None:
+        self._backend_version = backend_version
+
+    def all(self) -> DaskExpr:
+        def func(df: DaskLazyFrame) -> list[Any]:
+            return [df._native_frame.loc[:, column_name] for column_name in df.columns]
+
+        return DaskExpr(
+            func,
+            depth=0,
+            function_name="all",
+            root_names=None,
+            output_names=None,
+            returns_scalar=False,
+            backend_version=self._backend_version,
+        )
+
+    def col(self, *column_names: str) -> DaskExpr:
+        return DaskExpr.from_column_names(
+            *column_names,
+            backend_version=self._backend_version,
+        )
+
+    def lit(self, value: Any, dtype: dtypes.DType | None) -> DaskExpr:
+        def convert_if_dtype(
+            series: dask_expr.Series, dtype: DType | type[DType]
+        ) -> dask_expr.Series:
+            return series.astype(reverse_translate_dtype(dtype)) if dtype else series
+
+        return DaskExpr(
+            lambda df: [
+                df._native_frame.assign(lit=value)
+                .loc[:, "lit"]
+                .pipe(convert_if_dtype, dtype)
+            ],
+            depth=0,
+            function_name="lit",
+            root_names=None,
+            output_names=["lit"],
+            returns_scalar=False,
+            backend_version=self._backend_version,
+        )
+
+    def min(self, *column_names: str) -> DaskExpr:
+        return DaskExpr.from_column_names(
+            *column_names,
+            backend_version=self._backend_version,
+        ).min()
+
+    def max(self, *column_names: str) -> DaskExpr:
+        return DaskExpr.from_column_names(
+            *column_names,
+            backend_version=self._backend_version,
+        ).max()
+
+    def mean(self, *column_names: str) -> DaskExpr:
+        return DaskExpr.from_column_names(
+            *column_names,
+            backend_version=self._backend_version,
+        ).mean()
+
+    def sum(self, *column_names: str) -> DaskExpr:
+        return DaskExpr.from_column_names(
+            *column_names,
+            backend_version=self._backend_version,
+        ).sum()
+
+    def len(self) -> DaskExpr:
+        import dask.dataframe as dd  # ignore-banned-import
+        import pandas as pd  # ignore-banned-import
+
+        def func(df: DaskLazyFrame) -> list[Any]:
+            if not df.columns:
+                return [
+                    dd.from_pandas(
+                        pd.Series([0], name="len"),
+                        npartitions=df._native_frame.npartitions,
+                    )
+                ]
+            return [df._native_frame.loc[:, df.columns[0]].size.to_series().rename("len")]
+
+        # coverage bug? this is definitely hit
+        return DaskExpr(  # pragma: no cover
+            func,
+            depth=0,
+            function_name="len",
+            root_names=None,
+            output_names=["len"],
+            returns_scalar=True,
+            backend_version=self._backend_version,
+        )
+
+    def all_horizontal(self, *exprs: IntoDaskExpr) -> DaskExpr:
+        return reduce(lambda x, y: x & y, parse_into_exprs(*exprs, namespace=self))
+
+    def any_horizontal(self, *exprs: IntoDaskExpr) -> DaskExpr:
+        return reduce(lambda x, y: x | y, parse_into_exprs(*exprs, namespace=self))
+
+    def sum_horizontal(self, *exprs: IntoDaskExpr) -> DaskExpr:
+        return reduce(
+            lambda x, y: x + y,
+            [expr.fill_null(0) for expr in parse_into_exprs(*exprs, namespace=self)],
+        )
+
+    def concat(
+        self,
+        items: Iterable[DaskLazyFrame],
+        *,
+        how: str = "vertical",
+    ) -> DaskLazyFrame:
+        import dask.dataframe as dd  # ignore-banned-import
+
+        if len(list(items)) == 0:
+            msg = "No items to concatenate"  # pragma: no cover
+            raise AssertionError(msg)
+        native_frames = [i._native_frame for i in items]
+        if how == "vertical":
+            if not all(
+                tuple(i.columns) == tuple(native_frames[0].columns) for i in native_frames
+            ):  # pragma: no cover
+                msg = "unable to vstack with non-matching columns"
+                raise AssertionError(msg)
+            return DaskLazyFrame(
+                dd.concat(native_frames, axis=0, join="inner"),
+                backend_version=self._backend_version,
+            )
+        if how == "horizontal":
+            all_column_names: list[str] = [
+                column for frame in native_frames for column in frame.columns
+            ]
+            if len(all_column_names) != len(set(all_column_names)):  # pragma: no cover
+                duplicates = [
+                    i for i in all_column_names if all_column_names.count(i) > 1
+                ]
+                msg = (
+                    f"Columns with name(s): {', '.join(duplicates)} "
+                    "have more than one occurrence"
+                )
+                raise AssertionError(msg)
+            return DaskLazyFrame(
+                dd.concat(native_frames, axis=1, join="outer"),
+                backend_version=self._backend_version,
+            )
+        raise NotImplementedError
+
+    def mean_horizontal(self, *exprs: IntoDaskExpr) -> IntoDaskExpr:
+        dask_exprs = parse_into_exprs(*exprs, namespace=self)
+        total = reduce(lambda x, y: x + y, (e.fill_null(0.0) for e in dask_exprs))
+        n_non_zero = reduce(lambda x, y: x + y, ((1 - e.is_null()) for e in dask_exprs))
+        return total / n_non_zero
+
+    def _create_expr_from_series(self, _: Any) -> NoReturn:
+        msg = "`_create_expr_from_series` for DaskNamespace exists only for compatibility"
+        raise NotImplementedError(msg)
+
+    def _create_compliant_series(self, _: Any) -> NoReturn:
+        msg = "`_create_compliant_series` for DaskNamespace exists only for compatibility"
+        raise NotImplementedError(msg)
+
+    def _create_series_from_scalar(self, *_: Any) -> NoReturn:
+        msg = (
+            "`_create_series_from_scalar` for DaskNamespace exists only for compatibility"
+        )
+        raise NotImplementedError(msg)
+
+    def _create_expr_from_callable(  # pragma: no cover
+        self,
+        func: Callable[[DaskLazyFrame], list[DaskExpr]],
+        *,
+        depth: int,
+        function_name: str,
+        root_names: list[str] | None,
+        output_names: list[str] | None,
+    ) -> DaskExpr:
+        msg = (
+            "`_create_expr_from_callable` for DaskNamespace exists only for compatibility"
+        )
+        raise NotImplementedError(msg)
+
+    def when(
+        self,
+        *predicates: IntoDaskExpr,
+    ) -> DaskWhen:
+        plx = self.__class__(backend_version=self._backend_version)
+        if predicates:
+            condition = plx.all_horizontal(*predicates)
+        else:
+            msg = "at least one predicate needs to be provided"
+            raise TypeError(msg)
+
+        return DaskWhen(condition, self._backend_version, returns_scalar=False)
+
+
+class DaskWhen:
+    def __init__(
+        self,
+        condition: DaskExpr,
+        backend_version: tuple[int, ...],
+        then_value: Any = None,
+        otherwise_value: Any = None,
+        *,
+        returns_scalar: bool,
+    ) -> None:
+        self._backend_version = backend_version
+        self._condition = condition
+        self._then_value = then_value
+        self._otherwise_value = otherwise_value
+        self._returns_scalar = returns_scalar
+
+    def __call__(self, df: DaskLazyFrame) -> list[Any]:
+        from narwhals._dask.namespace import DaskNamespace
+        from narwhals._expression_parsing import parse_into_expr
+
+        plx = DaskNamespace(backend_version=self._backend_version)
+
+        condition = parse_into_expr(self._condition, namespace=plx)._call(df)[0]  # type: ignore[arg-type]
+        condition = cast("dask_expr.Series", condition)
+        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
+            _df = condition.to_frame("a")
+            _df["tmp"] = self._then_value
+            value_series = _df["tmp"]
+        value_series = cast("dask_expr.Series", value_series)
+        validate_comparand(condition, value_series)
+
+        if self._otherwise_value is None:
+            return [value_series.where(condition)]
+        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.where(condition, self._otherwise_value)]
+        validate_comparand(condition, otherwise_series)
+        return [value_series.zip_with(condition, otherwise_series)]
+
+    def then(self, value: DaskExpr | Any) -> DaskThen:
+        self._then_value = value
+
+        return DaskThen(
+            self,
+            depth=0,
+            function_name="whenthen",
+            root_names=None,
+            output_names=None,
+            returns_scalar=self._returns_scalar,
+            backend_version=self._backend_version,
+        )
+
+
+class DaskThen(DaskExpr):
+    def __init__(
+        self,
+        call: DaskWhen,
+        *,
+        depth: int,
+        function_name: str,
+        root_names: list[str] | None,
+        output_names: list[str] | None,
+        returns_scalar: bool,
+        backend_version: tuple[int, ...],
+    ) -> None:
+        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
+        self._returns_scalar = returns_scalar
+
+    def otherwise(self, value: DaskExpr | Any) -> DaskExpr:
+        # type ignore because we are setting the `_call` attribute to a
+        # callable object of type `DaskWhen`, 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/_dask/typing.py

@@ -0,0 +1,16 @@
+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._dask.expr import DaskExpr
+
+    IntoDaskExpr: TypeAlias = Union[DaskExpr, str]

parrot/lib/python3.10/site-packages/narwhals/_exceptions.py

@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+
+class ColumnNotFoundError(Exception): ...

parrot/lib/python3.10/site-packages/narwhals/group_by.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Generic
+from typing import Iterable
+from typing import Iterator
+from typing import TypeVar
+from typing import cast
+
+from narwhals.dataframe import DataFrame
+from narwhals.dataframe import LazyFrame
+from narwhals.utils import tupleify
+
+if TYPE_CHECKING:
+    from narwhals.typing import IntoExpr
+
+DataFrameT = TypeVar("DataFrameT")
+LazyFrameT = TypeVar("LazyFrameT")
+
+
+class GroupBy(Generic[DataFrameT]):
+    def __init__(self, df: DataFrameT, *keys: str) -> None:
+        self._df = cast(DataFrame[Any], df)
+        self._keys = keys
+        self._grouped = self._df._compliant_frame.group_by(*self._keys)
+
+    def agg(
+        self, *aggs: IntoExpr | Iterable[IntoExpr], **named_aggs: IntoExpr
+    ) -> DataFrameT:
+        """
+        Compute aggregations for each group of a group by operation.
+
+        Arguments:
+            aggs: Aggregations to compute for each group of the group by operation,
+                specified as positional arguments.
+
+            named_aggs: Additional aggregations, specified as keyword arguments.
+
+        Examples:
+            Group by one column or by multiple columns and call `agg` to compute
+            the grouped sum of another column.
+
+            >>> import pandas as pd
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_pd = pd.DataFrame(
+            ...     {
+            ...         "a": ["a", "b", "a", "b", "c"],
+            ...         "b": [1, 2, 1, 3, 3],
+            ...         "c": [5, 4, 3, 2, 1],
+            ...     }
+            ... )
+            >>> df_pl = pl.DataFrame(
+            ...     {
+            ...         "a": ["a", "b", "a", "b", "c"],
+            ...         "b": [1, 2, 1, 3, 3],
+            ...         "c": [5, 4, 3, 2, 1],
+            ...     }
+            ... )
+
+            We define library agnostic functions:
+
+            >>> @nw.narwhalify
+            ... def func(df):
+            ...     return df.group_by("a").agg(nw.col("b").sum()).sort("a")
+
+            >>> @nw.narwhalify
+            ... def func_mult_col(df):
+            ...     return df.group_by("a", "b").agg(nw.sum("c")).sort("a", "b")
+
+            We can then pass either pandas or Polars to `func` and `func_mult_col`:
+
+            >>> func(df_pd)
+               a  b
+            0  a  2
+            1  b  5
+            2  c  3
+            >>> func(df_pl)
+            shape: (3, 2)
+            ┌─────┬─────┐
+            │ a   ┆ b   │
+            │ --- ┆ --- │
+            │ str ┆ i64 │
+            ╞═════╪═════╡
+            │ a   ┆ 2   │
+            │ b   ┆ 5   │
+            │ c   ┆ 3   │
+            └─────┴─────┘
+            >>> func_mult_col(df_pd)
+               a  b  c
+            0  a  1  8
+            1  b  2  4
+            2  b  3  2
+            3  c  3  1
+            >>> func_mult_col(df_pl)
+            shape: (4, 3)
+            ┌─────┬─────┬─────┐
+            │ a   ┆ b   ┆ c   │
+            │ --- ┆ --- ┆ --- │
+            │ str ┆ i64 ┆ i64 │
+            ╞═════╪═════╪═════╡
+            │ a   ┆ 1   ┆ 8   │
+            │ b   ┆ 2   ┆ 4   │
+            │ b   ┆ 3   ┆ 2   │
+            │ c   ┆ 3   ┆ 1   │
+            └─────┴─────┴─────┘
+        """
+        aggs, named_aggs = self._df._flatten_and_extract(*aggs, **named_aggs)
+        return self._df._from_compliant_dataframe(  # type: ignore[return-value]
+            self._grouped.agg(*aggs, **named_aggs),
+        )
+
+    def __iter__(self) -> Iterator[tuple[Any, DataFrameT]]:
+        yield from (  # type: ignore[misc]
+            (tupleify(key), self._df._from_compliant_dataframe(df))
+            for (key, df) in self._grouped.__iter__()
+        )
+
+
+class LazyGroupBy(Generic[LazyFrameT]):
+    def __init__(self, df: LazyFrameT, *keys: str) -> None:
+        self._df = cast(LazyFrame[Any], df)
+        self._keys = keys
+        self._grouped = self._df._compliant_frame.group_by(*self._keys)
+
+    def agg(
+        self, *aggs: IntoExpr | Iterable[IntoExpr], **named_aggs: IntoExpr
+    ) -> LazyFrameT:
+        aggs, named_aggs = self._df._flatten_and_extract(*aggs, **named_aggs)
+        return self._df._from_compliant_dataframe(  # type: ignore[return-value]
+            self._grouped.agg(*aggs, **named_aggs),
+        )

parrot/lib/python3.10/site-packages/narwhals/typing.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Protocol
+from typing import TypeVar
+from typing import Union
+
+if TYPE_CHECKING:
+    import sys
+
+    if sys.version_info >= (3, 10):
+        from typing import TypeAlias
+    else:
+        from typing_extensions import TypeAlias
+
+    from narwhals.dataframe import DataFrame
+    from narwhals.dataframe import LazyFrame
+    from narwhals.expr import Expr
+    from narwhals.series import Series
+
+    # All dataframes supported by Narwhals have a
+    # `columns` property. Their similarities don't extend
+    # _that_ much further unfortunately...
+    class NativeFrame(Protocol):
+        @property
+        def columns(self) -> Any: ...
+
+        def join(self, *args: Any, **kwargs: Any) -> Any: ...
+
+    class DataFrameLike(Protocol):
+        def __dataframe__(self, *args: Any, **kwargs: Any) -> Any: ...
+
+
+IntoExpr: TypeAlias = Union["Expr", str, "Series"]
+"""Anything which can be converted to an expression."""
+
+IntoDataFrame: TypeAlias = Union["NativeFrame", "DataFrame[Any]", "DataFrameLike"]
+"""Anything which can be converted to a Narwhals DataFrame."""
+
+IntoFrame: TypeAlias = Union[
+    "NativeFrame", "DataFrame[Any]", "LazyFrame[Any]", "DataFrameLike"
+]
+"""Anything which can be converted to a Narwhals DataFrame or LazyFrame."""
+
+Frame: TypeAlias = Union["DataFrame[Any]", "LazyFrame[Any]"]
+"""DataFrame or LazyFrame"""
+
+# TypeVars for some of the above
+IntoFrameT = TypeVar("IntoFrameT", bound="IntoFrame")
+IntoDataFrameT = TypeVar("IntoDataFrameT", bound="IntoDataFrame")
+FrameT = TypeVar("FrameT", "DataFrame[Any]", "LazyFrame[Any]")
+DataFrameT = TypeVar("DataFrameT", bound="DataFrame[Any]")
+
+__all__ = [
+    "IntoExpr",
+    "IntoDataFrame",
+    "IntoDataFrameT",
+    "IntoFrame",
+    "IntoFrameT",
+    "Frame",
+    "FrameT",
+    "DataFrameT",
+]

parrot/lib/python3.10/site-packages/scipy/linalg/_decomp_update.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a6204b7f449307731e48304a53bb75d6ae9c04988273ebb536c2c8a561798a1
+size 368608

parrot/lib/python3.10/site-packages/scipy/optimize/__pycache__/_optimize.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:765aafc800a8969959920f235bf84e3153f5f0155e4e8ca2345540b5c8e629f0
+size 114363

parrot/lib/python3.10/site-packages/scipy/stats/__pycache__/_morestats.cpython-310.pyc

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

parrot/lib/python3.10/site-packages/scipy/stats/tests/data/levy_stable/stable-Z1-cdf-sample-data.npy

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

parrot/lib/python3.10/site-packages/six-1.16.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

parrot/lib/python3.10/site-packages/six-1.16.0.dist-info/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2010-2020 Benjamin Peterson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

parrot/lib/python3.10/site-packages/six-1.16.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+__pycache__/six.cpython-310.pyc,,
+six-1.16.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+six-1.16.0.dist-info/LICENSE,sha256=i7hQxWWqOJ_cFvOkaWWtI9gq3_YPI5P8J2K2MYXo5sk,1066
+six-1.16.0.dist-info/METADATA,sha256=VQcGIFCAEmfZcl77E5riPCN4v2TIsc_qtacnjxKHJoI,1795
+six-1.16.0.dist-info/RECORD,,
+six-1.16.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+six-1.16.0.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
+six-1.16.0.dist-info/top_level.txt,sha256=_iVH_iYEtEXnD8nYGQYpYFUvkUW9sEO1GYbkeKSAais,4
+six.py,sha256=TOOfQi7nFGfMrIvtdr6wX4wyHH8M7aknmuLfo2cBBrM,34549

parrot/lib/python3.10/site-packages/six-1.16.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+six

parrot/lib/python3.10/site-packages/sty-1.0.6.dist-info/LICENSE

@@ -0,0 +1,204 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018-present Felix Meyer-Wolters
+
+   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/sty-1.0.6.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.8.1
+Root-Is-Purelib: true
+Tag: py3-none-any

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/detail/TensorDataContainer.h

@@ -0,0 +1,372 @@
+#pragma once
+
+#include <ATen/Dispatch.h>
+#include <ATen/ScalarOps.h>
+#include <ATen/core/Tensor.h>
+#include <ATen/core/grad_mode.h>
+
+#include <c10/util/irange.h>
+
+#ifndef AT_PER_OPERATOR_HEADERS
+#include <ATen/Functions.h>
+#else
+#include <ATen/ops/empty.h>
+#include <ATen/ops/tensor.h>
+#endif
+
+#include <initializer_list>
+
+namespace torch {
+
+namespace detail {
+
+enum class TensorDataContainerType { Scalar, InitList, Tensor };
+
+struct TensorDataContainer;
+
+inline std::ostream& operator<<(
+    std::ostream& stream,
+    const TensorDataContainer& tensor_data_container);
+
+// FIXME: There is no `operator<<` overload for `at::kBFloat16` type,
+// and we need to convert it to `float` type using `operator float()` function
+// defined in `c10/util/BFloat16.h`.
+// Tracking issue: https://github.com/pytorch/pytorch/issues/28845
+inline std::ostream& operator<<(std::ostream& stream, c10::BFloat16 value) {
+  stream << static_cast<float>(value);
+  return stream;
+}
+
+inline c10::ScalarType compute_desired_dtype(c10::ScalarType scalar_type) {
+  if (scalar_type == at::kInt || scalar_type == at::kLong) {
+    // C++ `torch::tensor` with an integer type or an `at::ArrayRef` /
+    // `std::vector` / (nested) braced-init-list of integer types always
+    // produces a tensor of dtype `at::kLong` (aka. int64_t), matching Python
+    // `torch.tensor` behavior.
+    return at::kLong;
+  } else if (scalar_type == at::kFloat || scalar_type == at::kDouble) {
+    // C++ `torch::tensor` with a floating-point type or an `at::ArrayRef` /
+    // `std::vector` / (nested) braced-init-list of floating-point types always
+    // produces a tensor of dtype `torch::get_default_dtype()`, matching Python
+    // `torch.tensor` behavior.
+    return at::typeMetaToScalarType(at::get_default_dtype());
+  } else {
+    return scalar_type;
+  }
+}
+
+// We use `TensorDataContainer` to support converting the following data
+// container types into the equivalent Tensor:
+//
+// 1. Arbitrarily nested braced-init-list (e.g. `{{1, 2}, {3, 4}}`).
+// 2. `at::ArrayRef` of supported tensor data types.
+// 3. `std::vector` of supported tensor data types.
+//
+// At any time, a `TensorDataContainer` object represents one of the following:
+//
+// 1. A scalar with value `scalar()` and type `scalar_type()`.
+// 2. A Tensor represented in `std::initializer_list<TensorDataContainer>` form,
+//    with value `init_list()`, Tensor scalar type `scalar_type()`, and Tensor
+//    sizes `sizes()`.
+// 3. A Tensor represented in `at::Tensor` form, with value `tensor()`, scalar
+// type `scalar_type()`,
+//    and Tensor sizes `sizes()`.
+//
+// All the infrastructure here is mostly to support converting an arbitrarily
+// nested braced-init-list to the equivalent Tensor successfully. Consider the
+// following example:
+//
+// `torch::tensor({{1}, {2}})`
+//
+// this will call into the `torch::tensor` function:
+//
+// `at::Tensor tensor(detail::TensorDataContainer tensor_data_container, const
+// at::TensorOptions& options = {})`
+//
+// the compiler will first try to convert `{{1}, {2}}` to `TensorDataContainer`
+// type:
+//
+// `TensorDataContainer({{1}, {2}})`
+//
+// which matches to the
+// `TensorDataContainer(std::initializer_list<TensorDataContainer>)`
+// constructor, and in an attempt to convert `{1}` and `{2}` to
+// `TensorDataContainer`, it calls the following:
+//
+// `TensorDataContainer({1})`  (same call path happens for `{2}`, and we'll just
+// focus on `{1}` here)
+//
+// At this point, theoretically there are two plausible ways for `{1}` to be
+// matched to one of the constructors of `TensorDataContainer`:
+//
+// 1. It can be a list-initialization of a scalar value, thus matching
+// `TensorDataContainer(int value)`.
+// 2. It can be converted to `std::initializer_list<TensorDataContainer>`, thus
+// matching
+//    `TensorDataContainer(std::initializer_list<TensorDataContainer>)`.
+//
+// How does the compiler decide which one to choose? According to
+// `https://en.cppreference.com/w/cpp/language/list_initialization`,
+// braced-init-list always prefers the constructor that takes
+// `std::initializer_list`. Hence we happily move forward with constructor #2,
+// and it calls the following:
+//
+// `TensorDataContainer(1)`
+//
+// Now it matches `TensorDataContainer(int value)`, which stores `1` as a scalar
+// value. All is good.
+struct TensorDataContainer {
+  // NOTE: For tensors with zero-size dimensions (e.g. `torch::tensor({{},
+  // {}})`), the innermost empty braced-init-list `{}` matches the default
+  // constructor of the innermost `TensorDataContainer`.
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+  TensorDataContainer()
+      : sizes_({0}),
+        // NOTE: In Python, the dtype of tensors with zero-size dimensions (e.g.
+        // `torch.tensor([[], []])`) depends on the value of
+        // `torch.get_default_dtype()`, and we should do the same for the C++
+        // equivalent.
+        scalar_type_(at::typeMetaToScalarType(at::get_default_dtype())),
+        type_(TensorDataContainerType::InitList) {}
+#define TENSOR(T, S)                            \
+  TensorDataContainer(T value)                  \
+      : sizes_(),                               \
+        scalar_type_(at::k##S),                 \
+        type_(TensorDataContainerType::Scalar), \
+        scalar_(value) {}
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+  AT_FORALL_SCALAR_TYPES_AND3(Bool, Half, BFloat16, TENSOR)
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+  AT_FORALL_COMPLEX_TYPES(TENSOR)
+#undef TENSOR
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+  TensorDataContainer(std::initializer_list<TensorDataContainer> init_list)
+      : sizes_(),
+        scalar_type_(init_list.begin()->scalar_type()),
+        type_(TensorDataContainerType::InitList),
+        init_list_(init_list) {
+    const TensorDataContainer& first_elem = *(init_list.begin());
+    for (const auto& elem : init_list) {
+      TORCH_CHECK(
+          elem.sizes() == first_elem.sizes(),
+          "Expected all sub-lists to have sizes: ",
+          first_elem.sizes(),
+          " (e.g. ",
+          first_elem,
+          "), ",
+          "but got sub-list ",
+          elem,
+          " with sizes: ",
+          elem.sizes());
+      TORCH_CHECK(
+          elem.scalar_type() == first_elem.scalar_type(),
+          "Expected all elements of the tensor to have the same scalar type: ",
+          first_elem.scalar_type(),
+          ", but got element of scalar type: ",
+          elem.scalar_type());
+    }
+    sizes_.reserve(first_elem.sizes().size() + 1);
+    sizes_.push_back(init_list.size());
+    sizes_.insert(
+        sizes_.end(), first_elem.sizes().begin(), first_elem.sizes().end());
+  }
+
+#define TENSOR(T, S)                                                          \
+  TensorDataContainer(at::ArrayRef<T> values)                                 \
+      : sizes_({(int64_t)values.size()}),                                     \
+        scalar_type_(at::k##S),                                               \
+        type_(TensorDataContainerType::Tensor) {                              \
+    at::AutoDispatchBelowAutograd mode;                                       \
+    if (scalar_type_ == at::kBool) {                                          \
+      tensor_ = at::tensor(values, at::TensorOptions().device(at::kCPU));     \
+    } else {                                                                  \
+      tensor_ = at::tensor(values, at::dtype(scalar_type_).device(at::kCPU)); \
+    }                                                                         \
+  }
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+  AT_FORALL_SCALAR_TYPES_AND3(Bool, Half, BFloat16, TENSOR)
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+  AT_FORALL_COMPLEX_TYPES(TENSOR)
+#undef TENSOR
+
+  // NOTE: We need to handle `std::vector` explicitly instead of relying on an
+  // implicit conversion to `at::ArrayRef`, otherwise the following error can be
+  // thrown when calling `torch::tensor(std::vector<int>({1, 2}))`:
+  // ```
+  // error: no matching function for call to 'tensor(const std::vector<int>&)'
+  // no known conversion for argument 1 from 'const std::vector<int>' to
+  // 'torch::detail::TensorDataContainer'
+  // ```
+  //
+  // NOTE: `torch::tensor(std::vector<bool>)` is not supported for now, because
+  // ArrayRef<bool> cannot be constructed from a std::vector<bool> bitfield.
+#define TENSOR(T, S)                                \
+  TensorDataContainer(const std::vector<T>& values) \
+      : TensorDataContainer(at::ArrayRef<T>(values)) {}
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+  AT_FORALL_SCALAR_TYPES_AND2(Half, BFloat16, TENSOR)
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+  AT_FORALL_COMPLEX_TYPES(TENSOR)
+#undef TENSOR
+
+  bool is_scalar() const {
+    return type_ == TensorDataContainerType::Scalar;
+  }
+
+  const c10::Scalar& scalar() const {
+    TORCH_CHECK(
+        is_scalar(),
+        "Can only call `scalar()` on a TensorDataContainer that has `is_scalar() == true`");
+    return scalar_;
+  }
+
+  bool is_init_list() const {
+    return type_ == TensorDataContainerType::InitList;
+  }
+
+  const std::initializer_list<TensorDataContainer>& init_list() const {
+    TORCH_CHECK(
+        is_init_list(),
+        "Can only call `init_list()` on a TensorDataContainer that has `is_init_list() == true`");
+    return init_list_;
+  }
+
+  bool is_tensor() const {
+    return type_ == TensorDataContainerType::Tensor;
+  }
+
+  const at::Tensor& tensor() const {
+    TORCH_CHECK(
+        is_tensor(),
+        "Can only call `tensor()` on a TensorDataContainer that has `is_tensor() == true`");
+    return tensor_;
+  }
+
+  const std::vector<int64_t>& sizes() const {
+    return sizes_;
+  }
+
+  const c10::ScalarType& scalar_type() const {
+    return scalar_type_;
+  }
+
+  at::Tensor convert_to_tensor(at::TensorOptions options) const {
+    if (!options.has_dtype()) {
+      options = options.dtype(compute_desired_dtype(scalar_type_));
+    }
+
+    if (is_scalar()) {
+      at::AutoDispatchBelowAutograd mode;
+      return at::scalar_tensor(scalar_, options);
+    } else if (is_init_list()) {
+      // NOTE: Here we explicitly choose to initialize the tensor on CPU first,
+      // fill each element of the tensor, and then move the tensor to the
+      // desired device. For CUDA device, this approach only involves 1 CUDA
+      // kernel launch, and is much faster than initializing the tensor on CUDA
+      // first and then filling each element of it (which involves `N` CUDA
+      // kernel launches where `N` is the number of the elements in the tensor).
+      at::Tensor tensor = ([&]() {
+        at::AutoDispatchBelowAutograd mode;
+        return at::empty(sizes_, options.device(at::kCPU));
+      })();
+      fill_tensor(tensor);
+      return tensor.to(options.device());
+    } else if (is_tensor()) {
+      auto output = tensor_.to(options);
+      TORCH_CHECK(
+          !tensor_.is_complex() || output.is_complex(),
+          "can not do torch::tensor(complex, dtype=non-complex) because complex can not be casted to real number without loss of information");
+      return output;
+    } else {
+      TORCH_INTERNAL_ASSERT(false, "Invalid TensorDataContainer type");
+    }
+  }
+
+  void pretty_print_recursive(std::ostream& stream) const {
+    if (is_scalar()) {
+      AT_DISPATCH_ALL_TYPES_AND3(
+          at::kBool,
+          at::kHalf,
+          at::kBFloat16,
+          scalar_type_,
+          "TensorDataContainer_pretty_print_scalar",
+          [&] { stream << scalar_.to<scalar_t>(); });
+    } else if (is_init_list()) {
+      stream << "{";
+      for (const TensorDataContainer* it = init_list_.begin();
+           it != init_list_.end();
+           it++) {
+        stream << *it;
+        if (std::next(it) != init_list_.end())
+          stream << ", ";
+      }
+      stream << "}";
+    } else if (is_tensor()) {
+      stream << "{";
+      for (const auto i : c10::irange(tensor_.sizes()[0])) {
+        AT_DISPATCH_ALL_TYPES_AND3(
+            at::kBool,
+            at::kHalf,
+            at::kBFloat16,
+            scalar_type_,
+            "TensorDataContainer_pretty_print_tensor_item",
+            [&] { stream << tensor_[i].item<scalar_t>(); });
+        if (i != tensor_.sizes()[0] - 1)
+          stream << ", ";
+      }
+      stream << "}";
+    } else {
+      TORCH_INTERNAL_ASSERT(false, "Invalid TensorDataContainer type");
+    }
+  }
+
+ private:
+  void fill_tensor(at::Tensor& tensor) const {
+    if (is_scalar()) {
+      TORCH_INTERNAL_ASSERT(
+          tensor.dim() == 0,
+          "Expected a 0-dim Tensor, but got Tensor with dimensions: ",
+          tensor.dim());
+      at::NoGradGuard guard;
+      tensor.fill_(scalar_);
+    } else if (is_init_list()) {
+      TORCH_INTERNAL_ASSERT(
+          tensor.sizes()[0] == (int64_t)init_list_.size(),
+          "Expected a Tensor with size ",
+          init_list_.size(),
+          " in its first dimension, but got Tensor with size ",
+          tensor.sizes()[0],
+          " in its first dimension");
+      size_t index = 0;
+      for (const auto& elem : init_list_) {
+        at::Tensor slice = tensor[index];
+        elem.fill_tensor(slice);
+        index++;
+      }
+    } else if (is_tensor()) {
+      TORCH_INTERNAL_ASSERT(
+          false,
+          "TensorDataContainer is already a Tensor type, `fill_tensor` should not be called");
+    } else {
+      TORCH_INTERNAL_ASSERT(false, "Invalid TensorDataContainer type");
+    }
+  }
+
+  std::vector<int64_t> sizes_;
+  c10::ScalarType scalar_type_;
+  TensorDataContainerType type_;
+  c10::Scalar scalar_;
+  std::initializer_list<TensorDataContainer> init_list_;
+  at::Tensor tensor_;
+};
+
+inline std::ostream& operator<<(
+    std::ostream& stream,
+    const TensorDataContainer& tensor_data_container) {
+  tensor_data_container.pretty_print_recursive(stream);
+  return stream;
+}
+
+} // namespace detail
+
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/detail/static.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <torch/csrc/utils/variadic.h>
+#include <torch/types.h>
+
+#include <cstdint>
+#include <type_traits>
+
+namespace torch {
+namespace nn {
+class Module;
+} // namespace nn
+} // namespace torch
+
+namespace torch {
+namespace detail {
+/// Detects if a type T has a forward() method.
+template <typename T>
+struct has_forward {
+  // Declare two types with differing size.
+  using yes = int8_t;
+  using no = int16_t;
+
+  // Here we declare two functions. The first is only enabled if `&U::forward`
+  // is well-formed and returns the `yes` type. In C++, the ellipsis parameter
+  // type (`...`) always puts the function at the bottom of overload resolution.
+  // This is specified in the standard as: 1) A standard conversion sequence is
+  // always better than a user-defined conversion sequence or an ellipsis
+  // conversion sequence. 2) A user-defined conversion sequence is always better
+  // than an ellipsis conversion sequence This means that if the first overload
+  // is viable, it will be preferred over the second as long as we pass any
+  // convertible type. The type of `&U::forward` is a pointer type, so we can
+  // pass e.g. 0.
+  template <typename U>
+  static yes test(decltype(&U::forward));
+  template <typename U>
+  static no test(...);
+
+  // Finally we test statically whether the size of the type returned by the
+  // selected overload is the size of the `yes` type.
+  static constexpr bool value = (sizeof(test<T>(nullptr)) == sizeof(yes));
+};
+
+template <typename Head = void, typename... Tail>
+constexpr bool check_not_lvalue_references() {
+  return (!std::is_lvalue_reference<Head>::value ||
+          std::is_const<typename std::remove_reference<Head>::type>::value) &&
+      check_not_lvalue_references<Tail...>();
+}
+
+template <>
+inline constexpr bool check_not_lvalue_references<void>() {
+  return true;
+}
+
+/// A type trait whose `value` member is true if `M` derives from `Module`.
+template <typename M>
+using is_module =
+    std::is_base_of<torch::nn::Module, typename std::decay<M>::type>;
+
+template <typename M, typename T = void>
+using enable_if_module_t =
+    typename std::enable_if<is_module<M>::value, T>::type;
+} // namespace detail
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/nn/cloneable.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <torch/nn/module.h>
+#include <torch/types.h>
+#include <torch/utils.h>
+
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Exception.h>
+
+#include <memory>
+#include <utility>
+
+namespace torch {
+namespace nn {
+/// The `clone()` method in the base `Module` class does not have knowledge of
+/// the concrete runtime type of its subclasses. Therefore, `clone()` must
+/// either be called from within the subclass, or from a base class that has
+/// knowledge of the concrete type. `Cloneable` uses the CRTP to gain
+/// knowledge of the subclass' static type and provide an implementation of the
+/// `clone()` method. We do not want to use this pattern in the base class,
+/// because then storing a module would always require templatizing it.
+template <typename Derived>
+// NOLINTNEXTLINE(bugprone-exception-escape)
+class Cloneable : public Module {
+ public:
+  using Module::Module;
+
+  /// `reset()` must perform initialization of all members with reference
+  /// semantics, most importantly parameters, buffers and submodules.
+  virtual void reset() = 0;
+
+  /// Performs a recursive "deep copy" of the `Module`, such that all parameters
+  /// and submodules in the cloned module are different from those in the
+  /// original module.
+  std::shared_ptr<Module> clone(
+      const optional<Device>& device = nullopt) const override {
+    NoGradGuard no_grad;
+
+    const auto& self = static_cast<const Derived&>(*this);
+    auto copy = std::make_shared<Derived>(self);
+    copy->parameters_.clear();
+    copy->buffers_.clear();
+    copy->children_.clear();
+    copy->reset();
+    TORCH_CHECK(
+        copy->parameters_.size() == parameters_.size(),
+        "The cloned module does not have the same number of "
+        "parameters as the original module after calling reset(). "
+        "Are you sure you called register_parameter() inside reset() "
+        "and not the constructor?");
+    for (const auto& parameter : named_parameters(/*recurse=*/false)) {
+      auto& tensor = *parameter;
+      auto data = device && tensor.device() != *device
+          ? tensor.to(*device)
+          : autograd::Variable(tensor).clone();
+      copy->parameters_[parameter.key()].set_data(data);
+    }
+    TORCH_CHECK(
+        copy->buffers_.size() == buffers_.size(),
+        "The cloned module does not have the same number of "
+        "buffers as the original module after calling reset(). "
+        "Are you sure you called register_buffer() inside reset() "
+        "and not the constructor?");
+    for (const auto& buffer : named_buffers(/*recurse=*/false)) {
+      auto& tensor = *buffer;
+      auto data = device && tensor.device() != *device
+          ? tensor.to(*device)
+          : autograd::Variable(tensor).clone();
+      copy->buffers_[buffer.key()].set_data(data);
+    }
+    TORCH_CHECK(
+        copy->children_.size() == children_.size(),
+        "The cloned module does not have the same number of "
+        "child modules as the original module after calling reset(). "
+        "Are you sure you called register_module() inside reset() "
+        "and not the constructor?");
+    for (const auto& child : children_) {
+      copy->children_[child.key()]->clone_(*child.value(), device);
+    }
+    return copy;
+  }
+
+ private:
+  void clone_(Module& other, const optional<Device>& device) final {
+    // Here we are *pretty* certain that `other's` type is `Derived` (because it
+    // was registered under the same name as `this`), but you never know what
+    // crazy things `reset()` does, so `dynamic_cast` just to be safe.
+    auto clone = std::dynamic_pointer_cast<Derived>(other.clone(device));
+    TORCH_CHECK(
+        clone != nullptr,
+        "Attempted to clone submodule, but it is of a "
+        "different type than the submodule it was to be cloned into");
+    static_cast<Derived&>(*this) = *clone;
+  }
+};
+
+} // namespace nn
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/nn/functional.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <torch/nn/functional/batchnorm.h>
+#include <torch/nn/functional/conv.h>
+#include <torch/nn/functional/distance.h>
+#include <torch/nn/functional/dropout.h>
+#include <torch/nn/functional/embedding.h>
+#include <torch/nn/functional/fold.h>
+#include <torch/nn/functional/instancenorm.h>
+#include <torch/nn/functional/linear.h>
+#include <torch/nn/functional/loss.h>
+#include <torch/nn/functional/normalization.h>
+#include <torch/nn/functional/padding.h>
+#include <torch/nn/functional/pixelshuffle.h>
+#include <torch/nn/functional/pooling.h>
+#include <torch/nn/functional/upsampling.h>
+#include <torch/nn/functional/vision.h>

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/nn/init.h

@@ -0,0 +1,124 @@
+#pragma once
+
+#include <torch/csrc/Export.h>
+#include <torch/enum.h>
+#include <torch/types.h>
+
+namespace torch {
+namespace nn {
+namespace init {
+
+using NonlinearityType = std::variant<
+    enumtype::kLinear,
+    enumtype::kConv1D,
+    enumtype::kConv2D,
+    enumtype::kConv3D,
+    enumtype::kConvTranspose1D,
+    enumtype::kConvTranspose2D,
+    enumtype::kConvTranspose3D,
+    enumtype::kSigmoid,
+    enumtype::kTanh,
+    enumtype::kReLU,
+    enumtype::kLeakyReLU>;
+
+using FanModeType = std::variant<enumtype::kFanIn, enumtype::kFanOut>;
+
+} // namespace init
+} // namespace nn
+
+namespace nn {
+namespace init {
+
+/// Return the recommended gain value for the given nonlinearity function.
+TORCH_API double calculate_gain(
+    NonlinearityType nonlinearity,
+    double param = 0.01);
+
+/// Fills the given `tensor` with the provided `value` in-place, and returns it.
+/// No gradient will be recorded for this operation.
+TORCH_API Tensor constant_(Tensor tensor, Scalar value);
+
+/// Fills the given `tensor` with the Dirac delta function in-place, and returns
+/// it. No gradient will be recorded for this operation.
+TORCH_API Tensor dirac_(Tensor tensor);
+
+/// Fills the given 2-dimensional `matrix` with an identity matrix.
+/// No gradient will be recorded for this operation.
+TORCH_API Tensor eye_(Tensor matrix);
+
+/// Fills the given 2-dimensional `matrix` with values drawn from a normal
+/// distribution parameterized by `mean` and `std`.
+/// No gradient will be recorded for this operation.
+TORCH_API Tensor normal_(Tensor tensor, double mean = 0, double std = 1);
+
+/// Fills the given `tensor` with ones.
+/// No gradient will be recorded for this operation.
+TORCH_API Tensor ones_(Tensor tensor);
+
+/// Fills the input `Tensor` with a (semi) orthogonal matrix, as described in
+/// "Exact solutions to the nonlinear dynamics of learning in deep linear neural
+/// networks" - Saxe, A. et al. (2013). The input tensor must have at least 2
+/// dimensions, and for tensors with more than 2 dimensions the trailing
+/// dimensions are flattened.
+/// No gradient will be recorded for this operation.
+TORCH_API Tensor orthogonal_(Tensor tensor, double gain = 1.0);
+
+/// Fills the 2D input `Tensor` as a sparse matrix, where the
+/// non-zero elements will be drawn from a centered normal distribution
+/// with the given standard deviation `std`, as described in "Deep learning via
+/// Hessian-free optimization" - Martens, J. (2010). The `sparsity` is a real
+/// value between 0 and 1 that controls the fraction of elements in each column
+/// to be set to zero.
+/// No gradient will be recorded for this operation.
+TORCH_API Tensor sparse_(Tensor tensor, double sparsity, double std = 0.01);
+
+/// Fills the given 2-dimensional `matrix` with values drawn from a uniform
+/// distribution parameterized by `low` and `high`.
+/// No gradient will be recorded for this operation.
+TORCH_API Tensor uniform_(Tensor tensor, double low = 0, double high = 1);
+
+/// Fills the input `Tensor` with values according to the method
+/// described in "Delving deep into rectifiers: Surpassing human-level
+/// performance on ImageNet classification" - He, K. et al. (2015), using a
+/// normal distribution. Also known as He initialization.
+/// No gradient will be recorded for this operation.
+TORCH_API Tensor kaiming_normal_(
+    Tensor tensor,
+    double a = 0,
+    FanModeType mode = torch::kFanIn,
+    NonlinearityType nonlinearity = torch::kLeakyReLU);
+
+/// Fills the input `Tensor` with values according to the method
+/// described in "Delving deep into rectifiers: Surpassing human-level
+/// performance on ImageNet classification" - He, K. et al. (2015), using a
+/// uniform distribution. Also known as He initialization.
+/// No gradient will be recorded for this operation.
+TORCH_API Tensor kaiming_uniform_(
+    Tensor tensor,
+    double a = 0,
+    FanModeType mode = torch::kFanIn,
+    NonlinearityType nonlinearity = torch::kLeakyReLU);
+
+/// Fills the input `Tensor` with values according to the method
+/// described in "Understanding the difficulty of training deep feedforward
+/// neural networks" - Glorot, X. & Bengio, Y. (2010). Values are scaled by the
+/// `gain` parameter. No gradient will be recorded for this operation.
+TORCH_API Tensor xavier_normal_(Tensor tensor, double gain = 1.0);
+
+/// Fills the input `Tensor` with values according to the method
+/// described in "Understanding the difficulty of training deep feedforward
+/// neural networks" - Glorot, X. & Bengio, Y. (2010), using a uniform
+/// distribution. Values are scaled by the `gain` parameter
+/// No gradient will be recorded for this operation.
+TORCH_API Tensor xavier_uniform_(Tensor tensor, double gain = 1.0);
+
+/// Fills the given `tensor` with zeros.
+/// No gradient will be recorded for this operation.
+TORCH_API Tensor zeros_(Tensor tensor);
+
+TORCH_API std::tuple<int64_t, int64_t> _calculate_fan_in_and_fan_out(
+    const Tensor& tensor);
+
+} // namespace init
+} // namespace nn
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/nn/module.h

@@ -0,0 +1,702 @@
+#pragma once
+
+#include <torch/nn/modules/container/any_module_holder.h>
+#include <torch/nn/modules/container/any_value.h>
+#include <torch/nn/pimpl.h>
+#include <torch/ordered_dict.h>
+#include <torch/serialize/archive.h>
+#include <torch/types.h>
+
+#include <ATen/ATen.h>
+
+#include <functional>
+#include <iosfwd>
+#include <map>
+#include <memory>
+#include <string>
+#include <type_traits>
+
+namespace torch {
+namespace nn {
+
+/// The base class for all modules in PyTorch.
+///
+/// \rst
+/// .. note::
+///   The design and implementation of this class is largely based on the Python
+///   API. You may want to consult the python documentation for
+///   :py:class:`pytorch:torch.nn.Module` for further clarification on certain
+///   methods or behavior.
+/// \endrst
+///
+/// A `Module` is an abstraction over the implementation of some function or
+/// algorithm, possibly associated with some persistent data. A `Module` may
+/// contain further `Module`s ("submodules"), each with their own
+/// implementation, persistent data and further submodules. `Module`s can thus
+/// be said to form a recursive tree structure. A `Module` is registered as a
+/// submodule to another `Module` by calling `register_module()`, typically from
+/// within a parent module's constructor.
+///
+/// A distinction is made between three kinds of persistent data that may be
+/// associated with a `Module`:
+///
+/// 1. *Parameters*: tensors that record gradients, typically weights updated
+///    during the backward step (e.g. the `weight` of a `Linear` module),
+/// 2. *Buffers*: tensors that do not record gradients, typically updated during
+///    the forward step, such as running statistics (e.g. `mean` and `variance`
+///    in the `BatchNorm` module),
+/// 3. Any additional state, not necessarily tensors, required for the
+///    implementation or configuration of a `Module`.
+///
+/// The first two kinds of state are special in that they may be registered
+/// with the `Module` system to allow convenient access and batch configuration.
+/// For example, registered parameters in any `Module` may be iterated over via
+/// the `parameters()` accessor. Further, changing the data type of a `Module`'s
+/// registered parameters can be done conveniently via `Module::to()`, e.g.
+/// `module->to(torch::kCUDA)` to move all parameters to GPU memory. Lastly,
+/// registered parameters and buffers are handled specially during a `clone()`
+/// operation, which performs a deepcopy of a cloneable `Module` hierarchy.
+///
+/// Parameters are registered with a `Module` via `register_parameter`. Buffers
+/// are registered separately via `register_buffer`. These methods are part of
+/// the public API of `Module` and are typically invoked from within a
+/// concrete `Module`s constructor.
+class TORCH_API Module : public std::enable_shared_from_this<Module> {
+ public:
+  using ModuleApplyFunction = std::function<void(Module&)>;
+  using ConstModuleApplyFunction = std::function<void(const Module&)>;
+  using NamedModuleApplyFunction =
+      std::function<void(const std::string&, Module&)>;
+  using ConstNamedModuleApplyFunction =
+      std::function<void(const std::string&, const Module&)>;
+  using ModulePointerApplyFunction =
+      std::function<void(const std::shared_ptr<Module>&)>;
+  using NamedModulePointerApplyFunction =
+      std::function<void(const std::string&, const std::shared_ptr<Module>&)>;
+
+  /// Tells the base `Module` about the name of the submodule.
+  explicit Module(std::string name);
+
+  /// Constructs the module without immediate knowledge of the submodule's name.
+  /// The name of the submodule is inferred via RTTI (if possible) the first
+  /// time `.name()` is invoked.
+  Module();
+  Module(const Module&) = default;
+  Module& operator=(const Module&) = default;
+  Module(Module&&) noexcept = default;
+  Module& operator=(Module&&) noexcept = default;
+
+  virtual ~Module() = default;
+
+  /// Returns the name of the `Module`.
+  ///
+  /// A `Module` has an associated `name`, which is a string representation of
+  /// the kind of concrete `Module` it represents, such as `"Linear"` for the
+  /// `Linear` module. Under most circumstances, this name is automatically
+  /// inferred via runtime type information (RTTI). In the unusual circumstance
+  /// that you have this feature disabled, you may want to manually name your
+  /// `Module`s by passing the string name to the `Module` base class'
+  /// constructor.
+  const std::string& name() const noexcept;
+
+  /// Performs a recursive deep copy of the module and all its registered
+  /// parameters, buffers and submodules.
+  ///
+  /// Optionally, this method sets the current device
+  /// to the one supplied before cloning. If no device is given, each
+  /// parameter and buffer will be moved to the device of its source.
+  ///
+  /// \rst
+  /// .. attention::
+  ///   Attempting to call the `clone()` method inherited from the base `Module`
+  ///   class (the one documented here) will fail. To inherit an actual
+  ///   implementation of `clone()`, you must subclass `Cloneable`. `Cloneable`
+  ///   is templatized on the concrete module type, and can thus properly copy a
+  ///   `Module`. This method is provided on the base class' API solely for an
+  ///   easier-to-use polymorphic interface.
+  /// \endrst
+  virtual std::shared_ptr<Module> clone(
+      const optional<Device>& device = nullopt) const;
+
+  /// Applies the `function` to the `Module` and recursively to every submodule.
+  /// The function must accept a `Module&`.
+  ///
+  /// \rst
+  /// .. code-block:: cpp
+  ///   MyModule module;
+  ///   module->apply([](nn::Module& module) {
+  ///     std::cout << module.name() << std::endl;
+  ///   });
+  /// \endrst
+  void apply(const ModuleApplyFunction& function);
+
+  /// Applies the `function` to the `Module` and recursively to every submodule.
+  /// The function must accept a `const Module&`.
+  ///
+  /// \rst
+  /// .. code-block:: cpp
+  ///   MyModule module;
+  ///   module->apply([](const nn::Module& module) {
+  ///     std::cout << module.name() << std::endl;
+  ///   });
+  /// \endrst
+  void apply(const ConstModuleApplyFunction& function) const;
+
+  /// Applies the `function` to the `Module` and recursively to every submodule.
+  /// The function must accept a `const std::string&` for the key of the module,
+  /// and a `Module&`. The key of the module itself is the empty string. If
+  /// `name_prefix` is given, it is prepended to every key as
+  /// `<name_prefix>.<key>` (and just `name_prefix` for the module itself).
+  ///
+  /// \rst
+  /// .. code-block:: cpp
+  ///   MyModule module;
+  ///   module->apply([](const std::string& key, nn::Module& module) {
+  ///     std::cout << key << ": " << module.name() << std::endl;
+  ///   });
+  /// \endrst
+  void apply(
+      const NamedModuleApplyFunction& function,
+      const std::string& name_prefix = std::string());
+
+  /// Applies the `function` to the `Module` and recursively to every submodule.
+  /// The function must accept a `const std::string&` for the key of the module,
+  /// and a `const Module&`. The key of the module itself is the empty string.
+  /// If `name_prefix` is given, it is prepended to every key as
+  /// `<name_prefix>.<key>` (and just `name_prefix` for the module itself).
+  ///
+  /// \rst
+  /// .. code-block:: cpp
+  ///   MyModule module;
+  ///   module->apply([](const std::string& key, const nn::Module& module) {
+  ///     std::cout << key << ": " << module.name() << std::endl;
+  ///   });
+  /// \endrst
+  void apply(
+      const ConstNamedModuleApplyFunction& function,
+      const std::string& name_prefix = std::string()) const;
+
+  /// Applies the `function` to the `Module` and recursively to every submodule.
+  /// The function must accept a `const std::shared_ptr<Module>&`.
+  ///
+  /// \rst
+  /// .. code-block:: cpp
+  ///   MyModule module;
+  ///   module->apply([](const std::shared_ptr<nn::Module>& module) {
+  ///     std::cout << module->name() << std::endl;
+  ///   });
+  /// \endrst
+  void apply(const ModulePointerApplyFunction& function) const;
+
+  /// Applies the `function` to the `Module` and recursively to every submodule.
+  /// The function must accept a `const std::string&` for the key of the module,
+  /// and a `const std::shared_ptr<Module>&`. The key of the module itself is
+  /// the empty string. If `name_prefix` is given, it is prepended to every key
+  /// as
+  /// `<name_prefix>.<key>` (and just `name_prefix` for the module itself).
+  ///
+  /// \rst
+  /// .. code-block:: cpp
+  ///   MyModule module;
+  ///   module->apply([](const std::string& key,
+  ///                    const std::shared_ptr<nn::Module>& module) {
+  ///     std::cout << key << ": " << module->name() << std::endl;
+  ///   });
+  /// \endrst
+  void apply(
+      const NamedModulePointerApplyFunction& function,
+      const std::string& name_prefix = std::string()) const;
+
+  /// Returns the parameters of this `Module` and if `recurse` is true, also
+  /// recursively of every submodule.
+  std::vector<Tensor> parameters(bool recurse = true) const;
+
+  /// Returns an `OrderedDict` with the parameters of this `Module` along with
+  /// their keys, and if `recurse` is true also recursively of every submodule.
+  OrderedDict<std::string, Tensor> named_parameters(bool recurse = true) const;
+
+  /// Returns the buffers of this `Module` and if `recurse` is true, also
+  /// recursively of every submodule.
+  std::vector<Tensor> buffers(bool recurse = true) const;
+
+  /// Returns an `OrderedDict` with the buffers of this `Module` along with
+  /// their keys, and if `recurse` is true also recursively of every submodule.
+  OrderedDict<std::string, Tensor> named_buffers(bool recurse = true) const;
+
+  /// Returns the submodules of this `Module` (the entire submodule hierarchy)
+  /// and if `include_self` is true, also inserts a `shared_ptr` to this module
+  /// in the first position.
+  ///
+  /// \rst
+  /// .. warning::
+  ///   Only pass `include_self` as `true` if this `Module` is stored in a
+  ///   `shared_ptr`! Otherwise an exception will be thrown. You may still call
+  ///   this method with `include_self` set to false if your `Module` is not
+  ///   stored in a `shared_ptr`.
+  /// \endrst
+  std::vector<std::shared_ptr<Module>> modules(bool include_self = true) const;
+
+  /// Returns an `OrderedDict` of the submodules of this `Module` (the entire
+  /// submodule hierarchy) and their keys, and if `include_self` is true, also
+  /// inserts a `shared_ptr` to this module in the first position. If
+  /// `name_prefix` is given, it is prepended to every key as
+  /// `<name_prefix>.<key>` (and just `name_prefix` for the module itself).
+  ///
+  /// \rst
+  /// .. warning::
+  ///   Only pass `include_self` as `true` if this `Module` is stored in a
+  ///   `shared_ptr`! Otherwise an exception will be thrown. You may still call
+  ///   this method with `include_self` set to false if your `Module` is not
+  ///   stored in a `shared_ptr`.
+  /// \endrst
+  OrderedDict<std::string, std::shared_ptr<Module>> named_modules(
+      const std::string& name_prefix = std::string(),
+      bool include_self = true) const;
+
+  /// Returns the direct submodules of this `Module`.
+  std::vector<std::shared_ptr<Module>> children() const;
+
+  /// Returns an `OrderedDict` of the direct submodules of this `Module` and
+  /// their keys.
+  OrderedDict<std::string, std::shared_ptr<Module>> named_children() const;
+
+  /// Enables "training" mode.
+  virtual void train(bool on = true);
+
+  /// Calls train(false) to enable "eval" mode.
+  /// Do not override this method, override `train()` instead.
+  void eval();
+
+  /// True if the module is in training mode.
+  ///
+  /// Every `Module` has a boolean associated with it that determines whether
+  /// the `Module` is currently in *training* mode (set via `.train()`) or in
+  /// *evaluation* (inference) mode (set via `.eval()`). This property is
+  /// exposed via `is_training()`, and may be used by the implementation of a
+  /// concrete module to modify its runtime behavior. See the `BatchNorm` or
+  /// `Dropout` modules for examples of `Module`s that use different code paths
+  /// depending on this property.
+  virtual bool is_training() const noexcept;
+
+  /// Recursively casts all parameters to the given `dtype` and `device`.
+  ///
+  /// If `non_blocking` is true and the source is in pinned memory and
+  /// destination is on the GPU or vice versa, the copy is performed
+  /// asynchronously with respect to the host. Otherwise, the argument has no
+  /// effect.
+  virtual void to(
+      torch::Device device,
+      torch::Dtype dtype,
+      bool non_blocking = false);
+
+  /// Recursively casts all parameters to the given dtype.
+  ///
+  /// If `non_blocking` is true and the source is in pinned memory and
+  /// destination is on the GPU or vice versa, the copy is performed
+  /// asynchronously with respect to the host. Otherwise, the argument has no
+  /// effect.
+  virtual void to(torch::Dtype dtype, bool non_blocking = false);
+
+  /// Recursively moves all parameters to the given device.
+  ///
+  /// If `non_blocking` is true and the source is in pinned memory and
+  /// destination is on the GPU or vice versa, the copy is performed
+  /// asynchronously with respect to the host. Otherwise, the argument has no
+  /// effect.
+  virtual void to(torch::Device device, bool non_blocking = false);
+
+  /// Recursively zeros out the `grad` value of each registered parameter.
+  virtual void zero_grad(bool set_to_none = true);
+
+  /// Attempts to cast this `Module` to the given `ModuleType`.
+  ///
+  /// This method is useful when calling `apply()`.
+  /// \rst
+  /// .. code-block:: cpp
+  ///
+  ///   void initialize_weights(nn::Module& module) {
+  ///     torch::NoGradGuard no_grad;
+  ///     if (auto* linear = module.as<nn::Linear>()) {
+  ///       linear->weight.normal_(0.0, 0.02);
+  ///     }
+  ///   }
+  ///
+  ///   MyModule module;
+  ///   module->apply(initialize_weights);
+  /// \endrst
+  template <typename ModuleType>
+  typename ModuleType::ContainedType* as() noexcept;
+
+  /// Attempts to cast this `Module` to the given `ModuleType`.
+  ///
+  /// This method is useful when calling `apply()`.
+  /// \rst
+  /// .. code-block:: cpp
+  ///   void initialize_weights(nn::Module& module) {
+  ///     torch::NoGradGuard no_grad;
+  ///     if (auto* linear = module.as<nn::Linear>()) {
+  ///       linear->weight.normal_(0.0, 0.02);
+  ///     }
+  ///   }
+  ///
+  ///   MyModule module;
+  ///   module->apply(initialize_weights);
+  /// \endrst
+  template <typename ModuleType>
+  const typename ModuleType::ContainedType* as() const noexcept;
+
+  /// Attempts to cast this `Module` to the given `ModuleType`.
+  ///
+  /// This method is useful when calling `apply()`.
+  /// \rst
+  /// .. code-block:: cpp
+  ///
+  ///   void initialize_weights(nn::Module& module) {
+  ///     torch::NoGradGuard no_grad;
+  ///     if (auto* linear = module.as<nn::Linear>()) {
+  ///       linear->weight.normal_(0.0, 0.02);
+  ///     }
+  ///   }
+  ///
+  ///   MyModule module;
+  ///   module.apply(initialize_weights);
+  /// \endrst
+  template <
+      typename ModuleType,
+      typename = torch::detail::disable_if_module_holder_t<ModuleType>>
+  ModuleType* as() noexcept;
+
+  /// Attempts to cast this `Module` to the given `ModuleType`.
+  ///
+  /// This method is useful when calling `apply()`.
+  /// \rst
+  /// .. code-block:: cpp
+  ///
+  ///   void initialize_weights(nn::Module& module) {
+  ///     torch::NoGradGuard no_grad;
+  ///     if (auto* linear = module.as<nn::Linear>()) {
+  ///       linear->weight.normal_(0.0, 0.02);
+  ///     }
+  ///   }
+  ///
+  ///   MyModule module;
+  ///   module.apply(initialize_weights);
+  /// \endrst
+  template <
+      typename ModuleType,
+      typename = torch::detail::disable_if_module_holder_t<ModuleType>>
+  const ModuleType* as() const noexcept;
+
+  /// Serializes the `Module` into the given `OutputArchive`.
+  ///
+  /// If the `Module` contains unserializable submodules (e.g.
+  /// `nn::Functional`), those submodules are skipped when serializing.
+  virtual void save(serialize::OutputArchive& archive) const;
+
+  /// Deserializes the `Module` from the given `InputArchive`.
+  ///
+  /// If the `Module` contains unserializable submodules (e.g.
+  /// `nn::Functional`), we don't check the existence of those submodules in the
+  /// `InputArchive` when deserializing.
+  virtual void load(serialize::InputArchive& archive);
+
+  /// Streams a pretty representation of the `Module` into the given `stream`.
+  /// By default, this representation will be the name of the module (taken from
+  /// `name()`), followed by a recursive pretty print of all of the `Module`'s
+  /// submodules.
+  ///
+  /// Override this method to change the pretty print. The input
+  /// `stream` should be returned from the method, to allow easy chaining.
+  virtual void pretty_print(std::ostream& stream) const;
+
+  /// Returns whether the `Module` is serializable.
+  virtual bool is_serializable() const;
+
+  /// Registers a parameter with this `Module`.
+  ///
+  /// A parameter should be any gradient-recording tensor used in the
+  /// implementation of your `Module`. Registering it makes it available to
+  /// methods such as `parameters()`, `clone()` or `to().`
+  ///
+  /// Note that registering an undefined Tensor (e.g.
+  /// `module.register_parameter("param", Tensor())`) is allowed, and is
+  /// equivalent to `module.register_parameter("param", None)` in Python API.
+  ///
+  /// \rst
+  /// .. code-block:: cpp
+  ///
+  ///   MyModule::MyModule() {
+  ///     weight_ = register_parameter("weight", torch::randn({A, B}));
+  ///   }
+  /// \endrst
+  Tensor& register_parameter(
+      std::string name,
+      Tensor tensor,
+      bool requires_grad = true);
+
+  /// Registers a buffer with this `Module`.
+  ///
+  /// A buffer is intended to be state in your module that does not record
+  /// gradients, such as running statistics. Registering it makes it available
+  /// to methods such as `buffers()`, `clone()` or `to().
+  ///
+  /// \rst
+  /// .. code-block:: cpp
+  ///
+  ///   MyModule::MyModule() {
+  ///     mean_ = register_buffer("mean", torch::empty({num_features_}));
+  ///   }
+  /// \endrst
+  Tensor& register_buffer(std::string name, Tensor tensor);
+
+  /// Registers a submodule with this `Module`.
+  ///
+  /// Registering a module makes it available to methods such as `modules()`,
+  /// `clone()` or `to()`.
+  ///
+  /// \rst
+  /// .. code-block:: cpp
+  ///
+  ///   MyModule::MyModule() {
+  ///     submodule_ = register_module("linear", torch::nn::Linear(3, 4));
+  ///   }
+  /// \endrst
+  template <typename ModuleType>
+  std::shared_ptr<ModuleType> register_module(
+      std::string name,
+      std::shared_ptr<ModuleType> module);
+
+  /// Registers a submodule with this `Module`.
+  ///
+  /// This method deals with `ModuleHolder`s.
+  ///
+  /// Registering a module makes it available to methods such as `modules()`,
+  /// `clone()` or `to()`.
+  ///
+  /// \rst
+  /// .. code-block:: cpp
+  ///
+  ///   MyModule::MyModule() {
+  ///     submodule_ = register_module("linear", torch::nn::Linear(3, 4));
+  ///   }
+  /// \endrst
+  template <typename ModuleType>
+  std::shared_ptr<ModuleType> register_module(
+      std::string name,
+      ModuleHolder<ModuleType> module_holder);
+
+  /// Replaces a registered submodule with this `Module`.
+  ///
+  /// This takes care of the registration, if you used submodule members, you
+  /// should
+  //  assign the submodule as well, i.e. use as
+  ///     module->submodule_ = module->replace_module("linear",
+  ///     torch::nn::Linear(3, 4));
+  /// It only works when a module of the name is already registered.
+  ///
+  /// This is useful for replacing a module after initialization, e.g.
+  /// for finetuning.
+  template <typename ModuleType>
+  std::shared_ptr<ModuleType> replace_module(
+      const std::string& name,
+      std::shared_ptr<ModuleType> module);
+
+  /// Replaces a registered submodule with this `Module`.
+  /// This method deals with `ModuleHolder`s.
+  ///
+  /// This takes care of the registration, if you used submodule members, you
+  /// should
+  //  assign the submodule as well, i.e. use as
+  ///     module->submodule_ = module->replace_module("linear", linear_holder);
+  /// It only works when a module of the name is already registered.
+  ///
+  /// This is useful for replacing a module after initialization, e.g.
+  /// for finetuning.
+  template <typename ModuleType>
+  std::shared_ptr<ModuleType> replace_module(
+      const std::string& name,
+      ModuleHolder<ModuleType> module_holder);
+
+  /// Unregisters a submodule from this `Module`. If there is no such module
+  /// with `name` an exception is thrown.
+  void unregister_module(const std::string& name);
+
+ protected:
+  /// The following three functions allow a module with default arguments in its
+  /// forward method to be used in a Sequential module.
+  /// You should NEVER override these functions manually. Instead, you should
+  /// use the `FORWARD_HAS_DEFAULT_ARGS` macro.
+  virtual bool _forward_has_default_args() {
+    return false;
+  }
+
+  virtual unsigned int _forward_num_required_args() {
+    TORCH_CHECK(
+        false,
+        "torch::nn::Module subclass that has default arguments in `forward` method ",
+        "must override `_forward_num_required_args` method. Please use ",
+        "`FORWARD_HAS_DEFAULT_ARGS` macro to do so.");
+  }
+
+  virtual std::vector<AnyValue> _forward_populate_default_args(
+      std::vector<AnyValue>&& arguments) {
+    TORCH_CHECK(
+        false,
+        "torch::nn::Module subclass that has default arguments in `forward` method ",
+        "must override `_forward_populate_default_args` method. Please use ",
+        "`FORWARD_HAS_DEFAULT_ARGS` macro to do so.");
+  }
+
+  /// The registered parameters of this `Module`.
+  /// Inorder to access parameters_ in ParameterDict and ParameterList
+  // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
+  OrderedDict<std::string, Tensor> parameters_;
+
+ private:
+  // Friend classes.
+
+  template <typename Derived>
+  friend class Cloneable;
+
+  template <typename ModuleType, typename... ArgumentTypes>
+  friend struct AnyModuleHolder;
+
+  /// Pretty prints the given `Module` into the `ostream`.
+  TORCH_API friend std::ostream& operator<<(
+      std::ostream& stream,
+      const nn::Module& module);
+
+  // data parallel using this method to configure gradient edges during the
+  // replicate step.
+  template <typename ModuleType>
+  friend void replicate_grad_edges(
+      const std::shared_ptr<Module>& module,
+      const std::vector<std::shared_ptr<ModuleType>>& replicas,
+      const std::vector<Device>& devices);
+
+  // Private methods.
+
+  /// Used in the implementation of `Cloneable`.
+  virtual void clone_(Module& other, const optional<Device>& device);
+
+  /// The implementation of the various `to()` methods.
+  template <typename... Ts>
+  void to_impl(Ts&&... ts);
+
+  /// Implements pretty printing the module hierarchy.
+  void pretty_print_recursive(
+      std::ostream& stream,
+      const std::string& indentation) const;
+
+  /// Applies the `function` to every submodule recursively, starting at this
+  /// `Module`'s children (thus not including the module itself).
+  void apply_to_submodules(
+      const NamedModulePointerApplyFunction& function,
+      const std::string& name_prefix = std::string()) const;
+
+  /// Returns a shared_ptr to `this` in a safe (checked) way.
+  std::shared_ptr<Module> shared_from_this_checked() const;
+
+  /// The registered buffers of this `Module`.
+  OrderedDict<std::string, Tensor> buffers_;
+
+  /// The registered (direct) submodules of this `Module`.
+  OrderedDict<std::string, std::shared_ptr<Module>> children_;
+
+  /// The module's name (e.g. "LSTM").
+  mutable optional<std::string> name_;
+
+  /// Whether the module is in training mode.
+  bool is_training_{true};
+};
+
+/// Serialize a `Module` pointer into an `OutputArchive`.
+TORCH_API serialize::OutputArchive& operator<<(
+    serialize::OutputArchive& archive,
+    const std::shared_ptr<nn::Module>& module);
+
+/// Deserializes a `Module` from an `InputArchive`.
+TORCH_API serialize::InputArchive& operator>>(
+    serialize::InputArchive& archive,
+    const std::shared_ptr<nn::Module>& module);
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ nn::Module ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+template <typename ModuleType>
+typename ModuleType::ContainedType* Module::as() noexcept {
+  // Use the contained type of the `ModuleHolder`, e.g. `LinearImpl` for
+  // `Linear`, since `LinearImpl` inherits `nn::Module`.
+  return as<typename ModuleType::ContainedType>();
+}
+
+template <typename ModuleType>
+const typename ModuleType::ContainedType* Module::as() const noexcept {
+  // Use the contained type of the `ModuleHolder`, e.g. `LinearImpl` for
+  // `Linear`, since `LinearImpl` inherits `nn::Module`.
+  return as<typename ModuleType::ContainedType>();
+}
+
+template <typename ModuleType, typename>
+ModuleType* Module::as() noexcept {
+  return dynamic_cast<ModuleType*>(this);
+}
+
+template <typename ModuleType, typename>
+const ModuleType* Module::as() const noexcept {
+  return dynamic_cast<const ModuleType*>(this);
+}
+
+template <typename ModuleType>
+std::shared_ptr<ModuleType> Module::register_module(
+    std::string name,
+    std::shared_ptr<ModuleType> module) {
+  TORCH_CHECK(!name.empty(), "Submodule name must not be empty");
+  TORCH_CHECK(
+      name.find('.') == std::string::npos,
+      "Submodule name must not contain a dot (got '",
+      name,
+      "')");
+  auto& base_module = children_.insert(std::move(name), std::move(module));
+  return std::dynamic_pointer_cast<ModuleType>(base_module);
+}
+
+template <typename ModuleType>
+std::shared_ptr<ModuleType> Module::register_module(
+    std::string name,
+    ModuleHolder<ModuleType> module_holder) {
+  return register_module(std::move(name), module_holder.ptr());
+}
+
+template <typename ModuleType>
+std::shared_ptr<ModuleType> Module::replace_module(
+    const std::string& name,
+    std::shared_ptr<ModuleType> module) {
+  auto& base_module = (children_[name] = std::move(module));
+  return std::dynamic_pointer_cast<ModuleType>(base_module);
+}
+
+template <typename ModuleType>
+std::shared_ptr<ModuleType> Module::replace_module(
+    const std::string& name,
+    ModuleHolder<ModuleType> module_holder) {
+  return replace_module(name, module_holder.ptr());
+}
+
+template <typename... Ts>
+void Module::to_impl(Ts&&... ts) {
+  // First call `to()` on every child module.
+  for (auto& child : children_) {
+    child.value()->to(ts...);
+  }
+  // Then move every parameter to the new dtype/device.
+  for (auto& parameter : named_parameters(/*recurse=*/false)) {
+    parameter->set_data(autograd::Variable(*parameter).to(ts...));
+  }
+  // Then move every buffer to the new dtype/device.
+  for (auto& buffer : named_buffers(/*recurse=*/false)) {
+    buffer->set_data(autograd::Variable(*buffer).to(ts...));
+  }
+}
+
+} // namespace nn
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/nn/modules.h

@@ -0,0 +1,36 @@
+#pragma once
+
+// Common
+#include <torch/nn/modules/common.h>
+
+// Containers
+#include <torch/nn/modules/container/any.h>
+#include <torch/nn/modules/container/functional.h>
+#include <torch/nn/modules/container/moduledict.h>
+#include <torch/nn/modules/container/modulelist.h>
+#include <torch/nn/modules/container/named_any.h>
+#include <torch/nn/modules/container/parameterdict.h>
+#include <torch/nn/modules/container/parameterlist.h>
+#include <torch/nn/modules/container/sequential.h>
+
+// Layers
+#include <torch/nn/modules/activation.h>
+#include <torch/nn/modules/adaptive.h>
+#include <torch/nn/modules/batchnorm.h>
+#include <torch/nn/modules/conv.h>
+#include <torch/nn/modules/distance.h>
+#include <torch/nn/modules/dropout.h>
+#include <torch/nn/modules/embedding.h>
+#include <torch/nn/modules/fold.h>
+#include <torch/nn/modules/instancenorm.h>
+#include <torch/nn/modules/linear.h>
+#include <torch/nn/modules/loss.h>
+#include <torch/nn/modules/normalization.h>
+#include <torch/nn/modules/padding.h>
+#include <torch/nn/modules/pixelshuffle.h>
+#include <torch/nn/modules/pooling.h>
+#include <torch/nn/modules/rnn.h>
+#include <torch/nn/modules/transformer.h>
+#include <torch/nn/modules/transformercoder.h>
+#include <torch/nn/modules/transformerlayer.h>
+#include <torch/nn/modules/upsampling.h>

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/nn/options.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <torch/nn/options/batchnorm.h>
+#include <torch/nn/options/conv.h>
+#include <torch/nn/options/dropout.h>
+#include <torch/nn/options/fold.h>
+#include <torch/nn/options/linear.h>
+#include <torch/nn/options/loss.h>
+#include <torch/nn/options/normalization.h>
+#include <torch/nn/options/padding.h>
+#include <torch/nn/options/pixelshuffle.h>
+#include <torch/nn/options/pooling.h>
+#include <torch/nn/options/rnn.h>
+#include <torch/nn/options/transformer.h>
+#include <torch/nn/options/transformercoder.h>
+#include <torch/nn/options/transformerlayer.h>
+#include <torch/nn/options/upsampling.h>
+#include <torch/nn/options/vision.h>

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/nn/options/linear.h

@@ -0,0 +1,95 @@
+#pragma once
+
+#include <torch/arg.h>
+#include <torch/csrc/Export.h>
+#include <torch/types.h>
+
+namespace torch {
+namespace nn {
+
+/// Options for the `Linear` module.
+///
+/// Example:
+/// ```
+/// Linear model(LinearOptions(5, 2).bias(false));
+/// ```
+struct TORCH_API LinearOptions {
+  LinearOptions(int64_t in_features, int64_t out_features);
+  /// size of each input sample
+  TORCH_ARG(int64_t, in_features);
+
+  /// size of each output sample
+  TORCH_ARG(int64_t, out_features);
+
+  /// If set to false, the layer will not learn an additive bias. Default: true
+  TORCH_ARG(bool, bias) = true;
+};
+
+// ============================================================================
+
+/// Options for the `Flatten` module.
+///
+/// Example:
+/// ```
+/// Flatten model(FlattenOptions().start_dim(2).end_dim(4));
+/// ```
+struct TORCH_API FlattenOptions {
+  /// first dim to flatten
+  TORCH_ARG(int64_t, start_dim) = 1;
+  /// last dim to flatten
+  TORCH_ARG(int64_t, end_dim) = -1;
+};
+
+// ============================================================================
+
+/// Options for the `Unflatten` module.
+///
+/// Note: If input tensor is named, use dimname and namedshape arguments.
+///
+/// Example:
+/// ```
+/// Unflatten unnamed_model(UnflattenOptions(0, {2, 2}));
+/// Unflatten named_model(UnflattenOptions("B", {{"B1", 2}, {"B2", 2}}));
+/// ```
+struct TORCH_API UnflattenOptions {
+  typedef std::vector<std::pair<std::string, int64_t>> namedshape_t;
+
+  UnflattenOptions(int64_t dim, std::vector<int64_t> sizes);
+  UnflattenOptions(const char* dimname, namedshape_t namedshape);
+  UnflattenOptions(std::string dimname, namedshape_t namedshape);
+
+  /// dim to unflatten
+  TORCH_ARG(int64_t, dim);
+  /// name of dim to unflatten, for use with named tensors
+  TORCH_ARG(std::string, dimname);
+  /// new shape of unflattened dim
+  TORCH_ARG(std::vector<int64_t>, sizes);
+  /// new shape of unflattened dim with names, for use with named tensors
+  TORCH_ARG(namedshape_t, namedshape);
+};
+
+// ============================================================================
+
+/// Options for the `Bilinear` module.
+///
+/// Example:
+/// ```
+/// Bilinear model(BilinearOptions(3, 2, 4).bias(false));
+/// ```
+struct TORCH_API BilinearOptions {
+  BilinearOptions(
+      int64_t in1_features,
+      int64_t in2_features,
+      int64_t out_features);
+  /// The number of features in input 1 (columns of the input1 matrix).
+  TORCH_ARG(int64_t, in1_features);
+  /// The number of features in input 2 (columns of the input2 matrix).
+  TORCH_ARG(int64_t, in2_features);
+  /// The number of output features to produce (columns of the output matrix).
+  TORCH_ARG(int64_t, out_features);
+  /// Whether to learn and add a bias after the bilinear transformation.
+  TORCH_ARG(bool, bias) = true;
+};
+
+} // namespace nn
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/nn/options/loss.h

@@ -0,0 +1,802 @@
+#pragma once
+
+#include <torch/arg.h>
+#include <torch/csrc/Export.h>
+#include <torch/enum.h>
+#include <torch/types.h>
+
+namespace torch {
+namespace nn {
+
+/// Options for the `L1Loss` module.
+///
+/// Example:
+/// ```
+/// L1Loss model(L1LossOptions(torch::kNone));
+/// ```
+struct TORCH_API L1LossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  TORCH_OPTIONS_CTOR_VARIANT_ARG3(L1LossOptions, reduction, kNone, kMean, kSum)
+
+  /// Specifies the reduction to apply to the output.
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::l1_loss`.
+///
+/// See the documentation for `torch::nn::L1LossOptions` class to learn what
+/// arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::l1_loss(input, target, F::L1LossFuncOptions(torch::kNone));
+/// ```
+using L1LossFuncOptions = L1LossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `KLDivLoss` module.
+///
+/// Example:
+/// ```
+/// KLDivLoss
+/// model(KLDivLossOptions().reduction(torch::kNone).log_target(false));
+/// ```
+struct TORCH_API KLDivLossOptions {
+  typedef std::variant<
+      enumtype::kNone,
+      enumtype::kBatchMean,
+      enumtype::kSum,
+      enumtype::kMean>
+      reduction_t;
+
+  TORCH_OPTIONS_CTOR_VARIANT_ARG4(
+      KLDivLossOptions,
+      reduction,
+      kNone,
+      kBatchMean,
+      kSum,
+      kMean)
+
+  /// Specifies the reduction to apply to the output.
+  /// ``'none'`` | ``'batchmean'`` | ``'sum'`` | ``'mean'``. Default: ``'mean'``
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+
+  /// Specifies whether `target` is accepted in the log space. Default: False
+  TORCH_ARG(bool, log_target) = false;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::kl_div`.
+///
+/// See the documentation for `torch::nn::KLDivLossOptions` class to learn what
+/// arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::kl_div(input, target,
+/// F::KLDivFuncOptions().reduction(torch::kNone).log_target(false));
+/// ```
+using KLDivFuncOptions = KLDivLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `MSELoss` module.
+///
+/// Example:
+/// ```
+/// MSELoss model(MSELossOptions(torch::kNone));
+/// ```
+struct TORCH_API MSELossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  TORCH_OPTIONS_CTOR_VARIANT_ARG3(MSELossOptions, reduction, kNone, kMean, kSum)
+
+  /// Specifies the reduction to apply to the output.
+  /// ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::mse_loss`.
+///
+/// See the documentation for `torch::nn::MSELossOptions` class to learn what
+/// arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::mse_loss(input, target, F::MSELossFuncOptions(torch::kNone));
+/// ```
+using MSELossFuncOptions = MSELossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `BCELoss` module.
+///
+/// Example:
+/// ```
+/// BCELoss model(BCELossOptions().reduction(torch::kNone).weight(weight));
+/// ```
+struct TORCH_API BCELossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  /// A manual rescaling weight given to the loss of each batch element.
+  TORCH_ARG(Tensor, weight) = {};
+  /// Specifies the reduction to apply to the output.
+  /// ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::binary_cross_entropy`.
+///
+/// See the documentation for `torch::nn::BCELossOptions` class to learn what
+/// arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::binary_cross_entropy(input, target,
+/// F::BinaryCrossEntropyFuncOptions().weight(weight));
+/// ```
+using BinaryCrossEntropyFuncOptions = BCELossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `HingeEmbeddingLoss` module.
+///
+/// Example:
+/// ```
+/// HingeEmbeddingLoss
+/// model(HingeEmbeddingLossOptions().margin(4).reduction(torch::kNone));
+/// ```
+struct TORCH_API HingeEmbeddingLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  /// Specifies the threshold for which the distance of a negative sample must
+  /// reach in order to incur zero loss. Default: 1
+  TORCH_ARG(double, margin) = 1.0;
+  /// Specifies the reduction to apply to the output. Default: Mean
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::hinge_embedding_loss`.
+///
+/// See the documentation for `torch::nn::HingeEmbeddingLossOptions` class to
+/// learn what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::hinge_embedding_loss(input, target,
+/// F::HingeEmbeddingLossFuncOptions().margin(2));
+/// ```
+using HingeEmbeddingLossFuncOptions = HingeEmbeddingLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `MultiMarginLoss` module.
+///
+/// Example:
+/// ```
+/// MultiMarginLoss model(MultiMarginLossOptions().margin(2).weight(weight));
+/// ```
+struct TORCH_API MultiMarginLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  /// Has a default value of :math:`1`. :math:`1` and :math:`2`
+  /// are the only supported values.
+  TORCH_ARG(int64_t, p) = 1;
+  /// Has a default value of :math:`1`.
+  TORCH_ARG(double, margin) = 1.0;
+  /// A manual rescaling weight given to each
+  /// class. If given, it has to be a Tensor of size `C`. Otherwise, it is
+  /// treated as if having all ones.
+  TORCH_ARG(Tensor, weight) = Tensor();
+  /// Specifies the reduction to apply to the output:
+  /// ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction will be
+  /// applied,
+  /// ``'mean'``: the sum of the output will be divided by the number of
+  /// elements in the output, ``'sum'``: the output will be summed. Default:
+  /// ``'mean'``
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::multi_margin_loss`.
+///
+/// See the documentation for `torch::nn::MultiMarginLossOptions` class to learn
+/// what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::multi_margin_loss(input, target,
+/// F::MultiMarginLossFuncOptions().margin(2).weight(weight));
+/// ```
+using MultiMarginLossFuncOptions = MultiMarginLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `CosineEmbeddingLoss` module.
+///
+/// Example:
+/// ```
+/// CosineEmbeddingLoss model(CosineEmbeddingLossOptions().margin(0.5));
+/// ```
+struct TORCH_API CosineEmbeddingLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  /// Specifies the threshold for which the distance of a negative sample must
+  /// reach in order to incur zero loss. Should be a number from -1 to 1, 0
+  /// to 0.5 is suggested. Default: 0.0
+  TORCH_ARG(double, margin) = 0.0;
+  /// Specifies the reduction to apply to the output. Default: Mean
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::cosine_embedding_loss`.
+///
+/// See the documentation for `torch::nn::CosineEmbeddingLossOptions` class to
+/// learn what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::cosine_embedding_loss(input1, input2, target,
+/// F::CosineEmbeddingLossFuncOptions().margin(0.5));
+/// ```
+using CosineEmbeddingLossFuncOptions = CosineEmbeddingLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `MultiLabelMarginLoss` module.
+///
+/// Example:
+/// ```
+/// MultiLabelMarginLoss model(MultiLabelMarginLossOptions(torch::kNone));
+/// ```
+struct TORCH_API MultiLabelMarginLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  TORCH_OPTIONS_CTOR_VARIANT_ARG3(
+      MultiLabelMarginLossOptions,
+      reduction,
+      kNone,
+      kMean,
+      kSum)
+
+  /// Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'.
+  /// 'none': no reduction will be applied, 'mean': the sum of the output will
+  /// be divided by the number of elements in the output, 'sum': the output will
+  /// be summed. Default: 'mean'
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::multilabel_margin_loss`.
+///
+/// See the documentation for `torch::nn::MultiLabelMarginLossOptions` class to
+/// learn what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::multilabel_margin_loss(input, target,
+/// F::MultilabelMarginLossFuncOptions(torch::kNone));
+/// ```
+using MultilabelMarginLossFuncOptions = MultiLabelMarginLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `SoftMarginLoss` module.
+///
+/// Example:
+/// ```
+/// SoftMarginLoss model(SoftMarginLossOptions(torch::kNone));
+/// ```
+struct TORCH_API SoftMarginLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  TORCH_OPTIONS_CTOR_VARIANT_ARG3(
+      SoftMarginLossOptions,
+      reduction,
+      kNone,
+      kMean,
+      kSum)
+
+  /// Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'.
+  /// 'none': no reduction will be applied, 'mean': the sum of the output will
+  /// be divided by the number of elements in the output, 'sum': the output will
+  /// be summed. Default: 'mean'
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::soft_margin_loss`.
+///
+/// See the documentation for `torch::nn::SoftMarginLossOptions` class to learn
+/// what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::soft_margin_loss(input, target,
+/// F::SoftMarginLossFuncOptions(torch::kNone));
+/// ```
+using SoftMarginLossFuncOptions = SoftMarginLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `MultiLabelSoftMarginLoss` module.
+///
+/// Example:
+/// ```
+/// MultiLabelSoftMarginLoss
+/// model(MultiLabelSoftMarginLossOptions().reduction(torch::kNone).weight(weight));
+/// ```
+struct TORCH_API MultiLabelSoftMarginLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  /// A manual rescaling weight given to each
+  /// class. If given, it has to be a Tensor of size `C`. Otherwise, it is
+  /// treated as if having all ones.
+  TORCH_ARG(Tensor, weight) = Tensor();
+
+  /// Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'.
+  /// 'none': no reduction will be applied, 'mean': the sum of the output will
+  /// be divided by the number of elements in the output, 'sum': the output will
+  /// be summed. Default: 'mean'
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::multilabel_soft_margin_loss`.
+///
+/// See the documentation for `torch::nn::MultiLabelSoftMarginLossOptions` class
+/// to learn what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::multilabel_soft_margin_loss(input, target,
+/// F::MultilabelSoftMarginLossFuncOptions().reduction(torch::kNone).weight(weight));
+/// ```
+using MultilabelSoftMarginLossFuncOptions = MultiLabelSoftMarginLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `TripletMarginLoss` module.
+///
+/// Example:
+/// ```
+/// TripletMarginLoss
+/// model(TripletMarginLossOptions().margin(3).p(2).eps(1e-06).swap(false));
+/// ```
+struct TORCH_API TripletMarginLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  /// Specifies the threshold for which the distance of a negative sample must
+  /// reach in order to incur zero loss. Default: 1
+  TORCH_ARG(double, margin) = 1.0;
+  /// Specifies the norm degree for pairwise distance. Default: 2
+  TORCH_ARG(double, p) = 2.0;
+  TORCH_ARG(double, eps) = 1e-6;
+  /// The distance swap is described in detail in the paper Learning shallow
+  /// convolutional feature descriptors with triplet losses by V. Balntas,
+  /// E. Riba et al. Default: False
+  TORCH_ARG(bool, swap) = false;
+  /// Specifies the reduction to apply to the output. Default: Mean
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::triplet_margin_loss`.
+///
+/// See the documentation for `torch::nn::TripletMarginLossOptions` class to
+/// learn what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::triplet_margin_loss(anchor, positive, negative,
+/// F::TripletMarginLossFuncOptions().margin(1.0));
+/// ```
+using TripletMarginLossFuncOptions = TripletMarginLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `TripletMarginWithDistanceLoss` module.
+///
+/// Example:
+/// ```
+/// TripletMarginWithDistanceLoss
+/// model(TripletMarginWithDistanceLossOptions().margin(3).swap(false));
+/// ```
+struct TORCH_API TripletMarginWithDistanceLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+  typedef std::function<Tensor(const Tensor&, const Tensor&)>
+      distance_function_t;
+
+  /// Specifies a nonnegative, real-valued function that quantifies the
+  /// closeness of two tensors. If not specified, `F::pairwise_distance` will
+  /// be used. Default: nullopt
+  TORCH_ARG(c10::optional<distance_function_t>, distance_function) =
+      c10::nullopt;
+  /// Specifies a nonnegative margin representing the minimum difference
+  /// between the positive and negative distances required for the loss to be 0.
+  /// Larger margins penalize cases where the negative examples are not distance
+  /// enough from the anchors, relative to the positives. Default: 1
+  TORCH_ARG(double, margin) = 1.0;
+  /// Whether to use the distance swap described in the paper Learning shallow
+  /// convolutional feature descriptors with triplet losses by V. Balntas,
+  /// E. Riba et al. If True, and if the positive example is closer to the
+  /// negative example than the anchor is, swaps the positive example and the
+  /// anchor in the loss computation. Default: False
+  TORCH_ARG(bool, swap) = false;
+  /// Specifies the reduction to apply to the output. Default: Mean
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::triplet_margin_with_distance_loss`.
+///
+/// See the documentation for `torch::nn::TripletMarginWithDistanceLossOptions`
+/// class to learn what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::triplet_margin_with_distance_loss(anchor, positive, negative,
+/// F::TripletMarginWithDistanceLossFuncOptions().margin(1.0));
+/// ```
+using TripletMarginWithDistanceLossFuncOptions =
+    TripletMarginWithDistanceLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `CTCLoss` module.
+///
+/// Example:
+/// ```
+/// CTCLoss
+/// model(CTCLossOptions().blank(42).zero_infinity(false).reduction(torch::kSum));
+/// ```
+struct TORCH_API CTCLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  /// blank label. Default `0`.
+  TORCH_ARG(int64_t, blank) = 0;
+  /// Specifies the reduction to apply to the output. Default: Mean
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+  /// Whether to zero infinite losses and the associated gradients.
+  /// Default: `false`. Infinite losses mainly occur when the inputs are
+  /// too short to be aligned to the targets.
+  TORCH_ARG(bool, zero_infinity) = false;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::ctc_loss`.
+///
+/// See the documentation for `torch::nn::CTCLossOptions` class to learn what
+/// arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::ctc_loss(log_probs, targets, input_lengths, target_lengths,
+/// F::CTCLossFuncOptions().reduction(torch::kNone));
+/// ```
+using CTCLossFuncOptions = CTCLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `SmoothL1Loss` module.
+///
+/// Example:
+/// ```
+/// SmoothL1Loss model(SmoothL1LossOptions().reduction(torch::kNone).beta(0.5));
+/// ```
+struct TORCH_API SmoothL1LossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  TORCH_OPTIONS_CTOR_VARIANT_ARG3(
+      SmoothL1LossOptions,
+      reduction,
+      kNone,
+      kMean,
+      kSum)
+
+  /// Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'.
+  /// 'none': no reduction will be applied, 'mean': the sum of the output will
+  /// be divided by the number of elements in the output, 'sum': the output will
+  /// be summed. Default: 'mean'
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+  /// Specifies the threshold at which to change between L1 and L2 loss.
+  /// If beta is not specified, a value of 1.0 will be used.
+  /// Default: nullopt
+  TORCH_ARG(c10::optional<double>, beta) = c10::nullopt;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::smooth_l1_loss`.
+///
+/// See the documentation for `torch::nn::SmoothL1LossOptions` class to learn
+/// what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::smooth_l1_loss(input, target, F::SmoothL1LossFuncOptions(torch::kNone));
+/// ```
+using SmoothL1LossFuncOptions = SmoothL1LossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `HuberLoss` module.
+///
+/// Example:
+/// ```
+/// HuberLoss model(HuberLossOptions().reduction(torch::kNone).delta(0.5));
+/// ```
+struct TORCH_API HuberLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  TORCH_OPTIONS_CTOR_VARIANT_ARG3(
+      HuberLossOptions,
+      reduction,
+      kNone,
+      kMean,
+      kSum)
+
+  /// Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'.
+  /// 'none': no reduction will be applied, 'mean': the sum of the output will
+  /// be divided by the number of elements in the output, 'sum': the output will
+  /// be summed. Default: 'mean'
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+  /// Specifies the threshold at which to change between L1 and L2 loss.
+  /// Default: 1.0
+  TORCH_ARG(double, delta) = 1.0;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::huber_loss`.
+///
+/// See the documentation for `torch::nn::HuberLossOptions` class to learn what
+/// arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::huber_loss(input, target, F::HuberLossFuncOptions(torch::kNone));
+/// ```
+using HuberLossFuncOptions = HuberLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `PoissonNLLLoss` module.
+///
+/// Example:
+/// ```
+/// PoissonNLLLoss
+/// model(PoissonNLLLossOptions().log_input(false).full(true).eps(0.42).reduction(torch::kSum));
+/// ```
+struct TORCH_API PoissonNLLLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  /// if true the loss is computed as `exp(input) - target * input`,
+  /// if false the loss is `input - target * log(input + eps)`.
+  TORCH_ARG(bool, log_input) = true;
+  /// whether to compute full loss, i.e. to add the Stirling approximation term
+  /// target * log(target) - target + 0.5 * log(2 * pi * target).
+  TORCH_ARG(bool, full) = false;
+  /// Small value to avoid evaluation of `log(0)` when `log_input = false`.
+  /// Default: 1e-8
+  TORCH_ARG(double, eps) = 1e-8;
+  /// Specifies the reduction to apply to the output. Default: Mean
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::poisson_nll_loss`.
+///
+/// See the documentation for `torch::nn::PoissonNLLLossOptions` class to learn
+/// what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::poisson_nll_loss(input, target,
+/// F::PoissonNLLLossFuncOptions().reduction(torch::kNone));
+/// ```
+using PoissonNLLLossFuncOptions = PoissonNLLLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `MarginRankingLoss` module.
+///
+/// Example:
+/// ```
+/// MarginRankingLoss
+/// model(MarginRankingLossOptions().margin(0.5).reduction(torch::kSum));
+/// ```
+struct TORCH_API MarginRankingLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  /// Has a default value of `0`.
+  TORCH_ARG(double, margin) = 0;
+  /// Specifies the reduction to apply to the output. Default: Mean
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::margin_ranking_loss`.
+///
+/// See the documentation for `torch::nn::MarginRankingLossOptions` class to
+/// learn what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::margin_ranking_loss(input1, input2, target,
+/// F::MarginRankingLossFuncOptions().margin(0.5).reduction(torch::kSum));
+/// ```
+using MarginRankingLossFuncOptions = MarginRankingLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `NLLLoss` module.
+///
+/// Example:
+/// ```
+/// NLLLoss model(NLLLossOptions().ignore_index(-100).reduction(torch::kMean));
+/// ```
+struct TORCH_API NLLLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  /// A manual rescaling weight given to each
+  /// class. If given, it has to be a Tensor of size `C`. Otherwise, it is
+  /// treated as if having all ones.
+  TORCH_ARG(Tensor, weight) = {};
+  /// Specifies a target value that is ignored
+  /// and does not contribute to the input gradient.
+  TORCH_ARG(int64_t, ignore_index) = -100;
+  /// Specifies the reduction to apply to the output. Default: Mean
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::nll_loss`.
+///
+/// See the documentation for `torch::nn::NLLLossOptions` class to learn what
+/// arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::nll_loss(input, target,
+/// F::NLLLossFuncOptions().ignore_index(-100).reduction(torch::kMean));
+/// ```
+using NLLLossFuncOptions = NLLLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `CrossEntropyLoss` module.
+///
+/// Example:
+/// ```
+/// CrossEntropyLoss
+/// model(CrossEntropyLossOptions().ignore_index(-100).reduction(torch::kMean));
+/// ```
+struct TORCH_API CrossEntropyLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+
+  /// A manual rescaling weight given to each class. If given, has to be a
+  /// Tensor of size C
+  TORCH_ARG(Tensor, weight) = {};
+  /// Specifies a target value that is ignored
+  /// and does not contribute to the input gradient.
+  TORCH_ARG(int64_t, ignore_index) = -100;
+  /// Specifies the reduction to apply to the output. Default: Mean
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+  /// Specifies the amount of smoothing when computing the loss. Default: 0.0
+  TORCH_ARG(double, label_smoothing) = 0.0;
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::cross_entropy`.
+///
+/// See the documentation for `torch::nn::CrossEntropyLossOptions` class to
+/// learn what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::cross_entropy(input, target,
+/// F::CrossEntropyFuncOptions().ignore_index(-100).reduction(torch::kMean));
+/// ```
+using CrossEntropyFuncOptions = CrossEntropyLossOptions;
+} // namespace functional
+
+// ============================================================================
+
+/// Options for the `BCEWithLogitsLoss` module.
+///
+/// Example:
+/// ```
+/// BCEWithLogitsLoss
+/// model(BCEWithLogitsLossOptions().reduction(torch::kNone).weight(weight));
+/// ```
+struct TORCH_API BCEWithLogitsLossOptions {
+  typedef std::variant<enumtype::kNone, enumtype::kMean, enumtype::kSum>
+      reduction_t;
+  /// A manual rescaling weight given to the loss of each batch element.
+  /// If given, has to be a Tensor of size `nbatch`.
+  TORCH_ARG(Tensor, weight) = {};
+  /// Specifies the reduction to apply to the output. Default: Mean
+  TORCH_ARG(reduction_t, reduction) = torch::kMean;
+  /// A weight of positive examples.
+  /// Must be a vector with length equal to the number of classes.
+  TORCH_ARG(Tensor, pos_weight) = {};
+};
+
+namespace functional {
+/// Options for `torch::nn::functional::binary_cross_entropy_with_logits`.
+///
+/// See the documentation for `torch::nn::BCEWithLogitsLossOptions` class to
+/// learn what arguments are supported.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::binary_cross_entropy_with_logits(input, target,
+/// F::BinaryCrossEntropyWithLogitsFuncOptions().pos_weight(pos_weight).reduction(torch::kSum));
+/// ```
+using BinaryCrossEntropyWithLogitsFuncOptions = BCEWithLogitsLossOptions;
+} // namespace functional
+
+} // namespace nn
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/nn/options/transformer.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <torch/arg.h>
+#include <torch/csrc/Export.h>
+#include <torch/enum.h>
+#include <torch/types.h>
+
+#include <torch/nn/modules/container/any.h>
+#include <torch/nn/options/transformerlayer.h>
+
+namespace torch {
+namespace nn {
+
+/// Options for the `Transformer` module
+///
+/// Example:
+/// ```
+/// TransformerOptions options;
+/// TransformerOptions options(16, 4);
+/// auto options = TransformerOptions().d_model(4).nhead(2).dropout(0.0);
+/// ```
+struct TORCH_API TransformerOptions {
+  // The following constructors are commonly used
+  // Please don't add more unless it is proved as a common usage
+  TransformerOptions() = default;
+  TransformerOptions(int64_t d_model, int64_t nhead);
+  TransformerOptions(
+      int64_t d_model,
+      int64_t nhead,
+      int64_t num_encoder_layers,
+      int64_t num_decoder_layers);
+
+  /// the number of expected features in the encoder/decoder inputs
+  /// (default=512)
+  TORCH_ARG(int64_t, d_model) = 512;
+
+  /// the number of heads in the multiheadattention models (default=8)
+  TORCH_ARG(int64_t, nhead) = 8;
+
+  /// the number of sub-encoder-layers in the encoder (default=6)
+  TORCH_ARG(int64_t, num_encoder_layers) = 6;
+
+  /// the number of sub-decoder-layers in the decoder (default=6)
+  TORCH_ARG(int64_t, num_decoder_layers) = 6;
+
+  /// the dimension of the feedforward network model (default=2048)
+  TORCH_ARG(int64_t, dim_feedforward) = 2048;
+
+  /// the dropout value (default=0.1)
+  TORCH_ARG(double, dropout) = 0.1;
+
+  /// the activation function of encoder/decoder intermediate layer
+  /// (default=``torch::kReLU``)
+  TORCH_ARG(activation_t, activation) = torch::kReLU;
+
+  /// custom encoder (default=None)
+  TORCH_ARG(AnyModule, custom_encoder);
+
+  /// custom decoder (default=None)
+  TORCH_ARG(AnyModule, custom_decoder);
+};
+
+} // namespace nn
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/nn/options/upsampling.h

@@ -0,0 +1,110 @@
+#pragma once
+
+#include <torch/arg.h>
+#include <torch/csrc/Export.h>
+#include <torch/enum.h>
+#include <torch/expanding_array.h>
+#include <torch/types.h>
+
+#include <vector>
+
+namespace torch {
+namespace nn {
+
+/// Options for the `Upsample` module.
+///
+/// Example:
+/// ```
+/// Upsample
+/// model(UpsampleOptions().scale_factor(std::vector<double>({3})).mode(torch::kLinear).align_corners(false));
+/// ```
+struct TORCH_API UpsampleOptions {
+  /// output spatial sizes.
+  TORCH_ARG(c10::optional<std::vector<int64_t>>, size) = c10::nullopt;
+
+  /// multiplier for spatial size.
+  TORCH_ARG(c10::optional<std::vector<double>>, scale_factor) = c10::nullopt;
+
+  /// the upsampling algorithm: one of "nearest", "linear", "bilinear",
+  /// "bicubic" and "trilinear". Default: "nearest"
+  typedef std::variant<
+      enumtype::kNearest,
+      enumtype::kLinear,
+      enumtype::kBilinear,
+      enumtype::kBicubic,
+      enumtype::kTrilinear>
+      mode_t;
+  TORCH_ARG(mode_t, mode) = torch::kNearest;
+
+  /// if "True", the corner pixels of the input and output tensors are
+  /// aligned, and thus preserving the values at those pixels. This only has
+  /// effect when :attr:`mode` is "linear", "bilinear", "bicubic", or
+  /// "trilinear". Default: "False"
+  TORCH_ARG(c10::optional<bool>, align_corners) = c10::nullopt;
+};
+
+namespace functional {
+
+/// Options for `torch::nn::functional::interpolate`.
+///
+/// Example:
+/// ```
+/// namespace F = torch::nn::functional;
+/// F::interpolate(input,
+/// F::InterpolateFuncOptions().size(std::vector<int64_t>({4})).mode(torch::kNearest));
+/// ```
+struct TORCH_API InterpolateFuncOptions {
+  typedef std::variant<
+      enumtype::kNearest,
+      enumtype::kLinear,
+      enumtype::kBilinear,
+      enumtype::kBicubic,
+      enumtype::kTrilinear,
+      enumtype::kArea,
+      enumtype::kNearestExact>
+      mode_t;
+
+  /// output spatial sizes.
+  TORCH_ARG(c10::optional<std::vector<int64_t>>, size) = c10::nullopt;
+
+  /// multiplier for spatial size.
+  TORCH_ARG(c10::optional<std::vector<double>>, scale_factor) = c10::nullopt;
+
+  /// the upsampling algorithm: one of "nearest", "linear", "bilinear",
+  /// "bicubic", "trilinear", "area", "nearest-exact". Default: "nearest"
+  TORCH_ARG(mode_t, mode) = torch::kNearest;
+
+  /// Geometrically, we consider the pixels of the input and output as squares
+  /// rather than points. If set to "True", the input and output tensors are
+  /// aligned by the center points of their corner pixels, preserving the values
+  /// at the corner pixels. If set to "False", the input and output tensors
+  /// are aligned by the corner points of their corner pixels, and the
+  /// interpolation uses edge value padding for out-of-boundary values, making
+  /// this operation *independent* of input size when :attr:`scale_factor` is
+  /// kept the same. This only has an effect when :attr:`mode` is "linear",
+  /// "bilinear", "bicubic" or "trilinear". Default: "False"
+  TORCH_ARG(c10::optional<bool>, align_corners) = c10::nullopt;
+
+  /// recompute the scale_factor for use in the
+  /// interpolation calculation.  When `scale_factor` is passed as a parameter,
+  /// it is used to compute the `output_size`.  If `recompute_scale_factor` is
+  /// `true` or not specified, a new `scale_factor` will be computed based on
+  /// the output and input sizes for use in the interpolation computation (i.e.
+  /// the computation will be identical to if the computed `output_size` were
+  /// passed-in explicitly).  Otherwise, the passed-in `scale_factor` will be
+  /// used in the interpolation computation.  Note that when `scale_factor` is
+  /// floating-point, the recomputed scale_factor may differ from the one passed
+  /// in due to rounding and precision issues.
+  TORCH_ARG(c10::optional<bool>, recompute_scale_factor) = c10::nullopt;
+
+  /// flag to apply anti-aliasing. Using anti-alias
+  /// option together with :attr:`align_corners` equals "False", interpolation
+  /// result would match Pillow result for downsampling operation. Supported
+  /// modes: "bilinear". Default: "False".
+  TORCH_ARG(bool, antialias) = false;
+};
+
+} // namespace functional
+
+} // namespace nn
+} // namespace torch

videollama2/lib/python3.10/site-packages/torch/include/torch/csrc/api/include/torch/nn/pimpl-inl.h

@@ -0,0 +1,74 @@
+// This class exists  only to do SFINAE on abstract types `T` that are really
+// `ModuleHolder<ModuleType>`, because there's no good way to say that `T` is a
+// `ModuleHolder` over some unknown type `ModuleType`. With this, you can do
+// `enable_if_t<is_base_of_v<ModuleHolderIndicator, T>>`.
+struct ModuleHolderIndicator {};
+
+// A type trait that is true for types that are `ModuleHolder`s.
+template <typename T>
+using is_module_holder = std::is_base_of<ModuleHolderIndicator, decay_t<T>>;
+
+template <typename T>
+using disable_if_module_holder_t = disable_if_t<is_module_holder<T>::value>;
+
+// A collection of templates that answer the question whether a type `T` is a
+// `ModuleHolder`, and if so whether its contained type is of type `C`. This is
+// tricky because it is hard to short circuit in template metaprogramming. A
+// naive and incorrect solution to this problem would be something like
+// `disable_if<is_module_holder<T>::value && typename T::ContainedType == C>`.
+// This would disable all types that are not `ModuleHolder`s, because even
+// though the `is_module_holder<T>::value` may be `false` for such types the
+// `T::ContainedType` access would be ill-formed and thus fail the whole
+// expression by the rules of SFINAE. Instead we have to use template
+// specialization to statically branch on the first condition
+// (`is_module_holder<T>`) and are only then allowed to query
+// `T::ContainedType` in the branch for which the condition was true.
+
+// Base template.
+template <bool is_module_holder_value, typename T, typename C>
+struct is_module_holder_of_impl;
+
+// False branch. `T` is not a `ModuleHolder` and thus not a `ModuleHolder` with
+// contained type `C`.
+template <typename T, typename C>
+struct is_module_holder_of_impl<false, T, C> : std::false_type {};
+
+// True branch. `T` is a `ModuleHolder` and thus we can legit access its
+// `ContainedType` and compare it against `C`.
+template <typename T, typename C>
+struct is_module_holder_of_impl<true, T, C>
+    : std::is_same<typename T::ContainedType, C> {};
+
+// Helper template.
+template <typename T, typename C>
+struct is_module_holder_of : is_module_holder_of_impl<
+                                 is_module_holder<T>::value,
+                                 decay_t<T>,
+                                 decay_t<C>> {};
+
+// A collection of templates that allow deducing the return type of the
+// `forward()` method, but only if a module actually has a `forward()` method,
+// and otherwise deduces to the type `void`.
+
+template <bool has_forward_value, typename C, typename... Args>
+struct return_type_of_forward_impl;
+
+template <typename C, typename... Args>
+struct return_type_of_forward_impl<true, C, Args...> {
+  using type = decltype(::std::declval<C>().forward(::std::declval<Args>()...));
+};
+
+template <typename C, typename... Args>
+struct return_type_of_forward_impl<false, C, Args...> {
+  using type = void;
+};
+
+template <typename C, typename... Args>
+using return_type_of_forward = return_type_of_forward_impl<
+    torch::detail::has_forward<C>::value,
+    C,
+    Args...>;
+
+template <typename C, typename... Args>
+using return_type_of_forward_t =
+    typename return_type_of_forward<C, Args...>::type;