revert common.py

Author: TrevorBergeron

third_party/bigframes_vendored/pandas/core/common.py

@@ -1,53 +1,68 @@
 # Contains code from https://github.com/pandas-dev/pandas/blob/main/pandas/core/common.py
 from __future__ import annotations
 
-from collections.abc import Hashable
+from typing import Callable, TYPE_CHECKING
 
-from bigframes import constants
+from bigframes_vendored.pandas.core.dtypes.inference import iterable_not_string
 
-
-class Expression:
-    """
-    Class representing a deferred column.
-
-    This is not meant to be instantiated directly. Instead, use :meth:`pandas.col`.
-    """
+if TYPE_CHECKING:
+    from bigframes_vendored.pandas.pandas._typing import T
 
 
-def col(col_name: Hashable) -> Expression:
+def pipe(
+    obj, func: Callable[..., T] | tuple[Callable[..., T], str], *args, **kwargs
+) -> T:
     """
-    Generate deferred object representing a column of a DataFrame.
-
-    Any place which accepts ``lambda df: df[col_name]``, such as
-    :meth:`DataFrame.assign` or :meth:`DataFrame.loc`, can also accept
-    ``pd.col(col_name)``.
-
-    **Examples:**
-
-        You can use `col` in `assign`.
-
-        >>> df = bpd.DataFrame({"name": ["beluga", "narwhal"], "speed": [100, 110]})
-        >>> df.assign(name_titlecase=bpd.col("name").str.title())
-            name  speed name_titlecase
-        0   beluga    100         Beluga
-        1  narwhal    110        Narwhal
-
-        You can also use it for filtering.
-
-        >>> df.loc[bpd.col("speed") > 105]
-            name  speed
-        1  narwhal    110
-
+    Apply a function ``func`` to object ``obj`` either by passing obj as the
+    first argument to the function or, in the case that the func is a tuple,
+    interpret the first element of the tuple as a function and pass the obj to
+    that function as a keyword argument whose key is the value of the second
+    element of the tuple.
 
     Args:
-        col_name (Hashable):
-            Column name.
+        func (callable or tuple of (callable, str)):
+            Function to apply to this object or, alternatively, a
+            ``(callable, data_keyword)`` tuple where ``data_keyword`` is a
+            string indicating the keyword of ``callable`` that expects the
+            object.
+        args (iterable, optional):
+            Positional arguments passed into ``func``.
+        kwargs (dict, optional):
+            A dictionary of keyword arguments passed into ``func``.
 
     Returns:
-        Expression:
-            A deferred object representing a column of a DataFrame.
+        object: the return type of ``func``.
     """
-    raise NotImplementedError(constants.ABSTRACT_METHOD_ERROR_MESSAGE)
+    if isinstance(func, tuple):
+        func, target = func
+        if target in kwargs:
+            msg = f"{target} is both the pipe target and a keyword argument"
+            raise ValueError(msg)
+        kwargs[target] = obj
+        return func(*args, **kwargs)
+    else:
+        return func(obj, *args, **kwargs)
+
+
+def flatten(line):
+    """
+    Flatten an arbitrarily nested sequence.
+
+    Parameters
+    ----------
+    line : sequence
+        The non string sequence to flatten
 
+    Notes
+    -----
+    This doesn't consider strings sequences.
 
-__all__ = ["Expression", "col"]
+    Returns
+    -------
+    flattened : generator
+    """
+    for element in line:
+        if iterable_not_string(element):
+            yield from flatten(element)
+        else:
+            yield element