bigframes 1.41.0__tar.gz → 2.0.0.dev0__tar.gz

{bigframes-1.41.0/bigframes.egg-info → bigframes-2.0.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bigframes
-Version: 1.41.0
+Version: 2.0.0.dev0
 Summary: BigQuery DataFrames -- scalable analytics and machine learning with BigQuery
 Home-page: https://github.com/googleapis/python-bigquery-dataframes
 Author: Google LLC
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Internet
 Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: cloudpickle>=2.0.0
 Requires-Dist: fsspec>=2023.3.0
@@ -28,7 +29,7 @@ Requires-Dist: geopandas>=0.12.2
 Requires-Dist: google-auth<3.0dev,>=2.15.0
 Requires-Dist: google-cloud-bigtable>=2.24.0
 Requires-Dist: google-cloud-pubsub>=2.21.4
-Requires-Dist: google-cloud-bigquery[bqstorage,pandas]>=3.18.0
+Requires-Dist: google-cloud-bigquery[bqstorage,pandas]>=3.31.0
 Requires-Dist: google-cloud-functions>=1.12.0
 Requires-Dist: google-cloud-bigquery-connection>=1.12.0
 Requires-Dist: google-cloud-iam>=2.12.1
@@ -37,7 +38,7 @@ Requires-Dist: google-cloud-storage>=2.0.0
 Requires-Dist: jellyfish<1.1.2,>=0.8.9
 Requires-Dist: numpy>=1.24.0
 Requires-Dist: pandas>=1.5.3
-Requires-Dist: pandas-gbq>=0.26.0
+Requires-Dist: pandas-gbq>=0.26.1
 Requires-Dist: pyarrow>=15.0.2
 Requires-Dist: pydata-google-auth>=1.8.2
 Requires-Dist: requests>=2.27.1
@@ -88,6 +89,30 @@ powered by the BigQuery engine.
 BigQuery DataFrames is an open-source package. You can run
 ``pip install --upgrade bigframes`` to install the latest version.
 
+⚠️ Warning: Breaking Changes in BigQuery DataFrames v2.0
+--------------------------------------------------------
+
+Version 2.0 introduces breaking changes for improved security and performance. Key default behaviors have changed, including
+
+* **Large Results (>10GB):** The default value for ``allow_large_results`` has changed to ``False``.
+  Methods like ``to_pandas()`` will now fail if the query result's compressed data size exceeds 10GB,
+  unless large results are explicitly permitted.
+* **Remote Function Security:** The library no longer automatically lets the Compute Engine default service
+  account become the identity of the Cloud Run functions. If that is desired, it has to be indicated by passing
+  ``cloud_function_service_account="default"``. And network ingress now defaults to ``"internal-only"``.
+* **@remote_function Argument Passing:** Arguments other than ``input_types``, ``output_type``, and ``dataset``
+  to ``remote_function`` must now be passed using keyword syntax, as positional arguments are no longer supported.
+* **Endpoint Connections:** Automatic fallback to locational endpoints in certain regions is removed.
+* **LLM Updates (Gemini Integration):** Integrations now default to the ``gemini-2.0-flash-001`` model.
+  PaLM2 support has been removed; please migrate any existing PaLM2 usage to Gemini. **Note:** The current default
+  model will be removed in Version 3.0.
+
+**Important:** If you are not ready to adapt to these changes, please pin your dependency to a version less than 2.0
+(e.g., ``bigframes==1.42.0``) to avoid disruption.
+
+To learn about these changes and how to migrate to version 2.0, see the
+`updated introduction guide <https://cloud.google.com/bigquery/docs/bigquery-dataframes-introduction>`_.
+
 .. |GA| image:: https://img.shields.io/badge/support-GA-gold.svg
    :target: https://github.com/googleapis/google-cloud-python/blob/main/README.rst#general-availability
 .. |pypi| image:: https://img.shields.io/pypi/v/bigframes.svg

{bigframes-1.41.0 → bigframes-2.0.0.dev0}/README.rst

@@ -12,6 +12,30 @@ powered by the BigQuery engine.
 BigQuery DataFrames is an open-source package. You can run
 ``pip install --upgrade bigframes`` to install the latest version.
 
+⚠️ Warning: Breaking Changes in BigQuery DataFrames v2.0
+--------------------------------------------------------
+
+Version 2.0 introduces breaking changes for improved security and performance. Key default behaviors have changed, including
+
+* **Large Results (>10GB):** The default value for ``allow_large_results`` has changed to ``False``.
+  Methods like ``to_pandas()`` will now fail if the query result's compressed data size exceeds 10GB,
+  unless large results are explicitly permitted.
+* **Remote Function Security:** The library no longer automatically lets the Compute Engine default service
+  account become the identity of the Cloud Run functions. If that is desired, it has to be indicated by passing
+  ``cloud_function_service_account="default"``. And network ingress now defaults to ``"internal-only"``.
+* **@remote_function Argument Passing:** Arguments other than ``input_types``, ``output_type``, and ``dataset``
+  to ``remote_function`` must now be passed using keyword syntax, as positional arguments are no longer supported.
+* **Endpoint Connections:** Automatic fallback to locational endpoints in certain regions is removed.
+* **LLM Updates (Gemini Integration):** Integrations now default to the ``gemini-2.0-flash-001`` model.
+  PaLM2 support has been removed; please migrate any existing PaLM2 usage to Gemini. **Note:** The current default
+  model will be removed in Version 3.0.
+
+**Important:** If you are not ready to adapt to these changes, please pin your dependency to a version less than 2.0
+(e.g., ``bigframes==1.42.0``) to avoid disruption.
+
+To learn about these changes and how to migrate to version 2.0, see the
+`updated introduction guide <https://cloud.google.com/bigquery/docs/bigquery-dataframes-introduction>`_.
+
 .. |GA| image:: https://img.shields.io/badge/support-GA-gold.svg
    :target: https://github.com/googleapis/google-cloud-python/blob/main/README.rst#general-availability
 .. |pypi| image:: https://img.shields.io/pypi/v/bigframes.svg

{bigframes-1.41.0 → bigframes-2.0.0.dev0}/bigframes/_config/bigquery_options.py

@@ -89,7 +89,7 @@ class BigQueryOptions:
         kms_key_name: Optional[str] = None,
         skip_bq_connection_check: bool = False,
         *,
-        allow_large_results: bool = True,
+        allow_large_results: bool = False,
         ordering_mode: Literal["strict", "partial"] = "strict",
         client_endpoints_override: Optional[dict] = None,
     ):
@@ -258,7 +258,8 @@ class BigQueryOptions:
 
     @property
     def use_regional_endpoints(self) -> bool:
-        """Flag to connect to regional API endpoints.
+        """Flag to connect to regional API endpoints for BigQuery API and
+        BigQuery Storage API.
 
         .. note::
             Use of regional endpoints is a feature in Preview and available only
@@ -267,18 +268,16 @@ class BigQueryOptions:
             "us-east5", "us-east7", "us-south1", "us-west1", "us-west2", "us-west3"
             and "us-west4".
 
-        .. deprecated:: 0.13.0
-            Use of locational endpoints is available only in selected projects.
-
-        Requires that ``location`` is set. For supported regions, for example
-        ``europe-west3``, you need to specify ``location='europe-west3'`` and
-        ``use_regional_endpoints=True``, and then BigQuery DataFrames would
-        connect to the BigQuery endpoint ``bigquery.europe-west3.rep.googleapis.com``.
-        For not supported regions, for example ``asia-northeast1``, when you
-        specify ``location='asia-northeast1'`` and ``use_regional_endpoints=True``,
-        a different endpoint (called locational endpoint, now deprecated, used
-        to provide weaker promise on the request remaining within the location
-        during transit) ``europe-west3-bigquery.googleapis.com`` would be used.
+        Requires that ``location`` is set. For [supported regions](https://cloud.google.com/bigquery/docs/regional-endpoints),
+        for example ``europe-west3``, you need to specify
+        ``location='europe-west3'`` and ``use_regional_endpoints=True``, and
+        then BigQuery DataFrames would connect to the BigQuery endpoint
+        ``bigquery.europe-west3.rep.googleapis.com``. For not supported regions,
+        for example ``asia-northeast1``, when you specify
+        ``location='asia-northeast1'`` and ``use_regional_endpoints=True``,
+        the global endpoint ``bigquery.googleapis.com`` would be used, which
+        does not promise any guarantee on the request remaining within the
+        location during transit.
 
         Returns:
             bool:

{bigframes-1.41.0 → bigframes-2.0.0.dev0}/bigframes/_config/compute_options.py

@@ -60,19 +60,31 @@ class ComputeOptions:
             bytes billed beyond this limit will fail (without incurring a
             charge). If unspecified, this will be set to your project default.
             See `maximum_bytes_billed`: https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.job.QueryJobConfig#google_cloud_bigquery_job_QueryJobConfig_maximum_bytes_billed.
+
         enable_multi_query_execution (bool, Options):
             If enabled, large queries may be factored into multiple smaller queries
             in order to avoid generating queries that are too complex for the query
             engine to handle. However this comes at the cost of increase cost and latency.
+
         extra_query_labels (Dict[str, Any], Options):
             Stores additional custom labels for query configuration.
-        semmantic_ops_confirmation_threshold (int, optional):
-            Guards against unexepcted processing of large amount of rows by semantic operators.
+
+        semantic_ops_confirmation_threshold (int, optional):
+            .. deprecated:: 1.42.0
+                Semantic operators are deprecated. Please use AI operators instead
+
+        semantic_ops_threshold_autofail (bool):
+            .. deprecated:: 1.42.0
+                Semantic operators are deprecated. Please use AI operators instead
+
+        ai_ops_confirmation_threshold (int, optional):
+            Guards against unexpected processing of large amount of rows by semantic operators.
             If the number of rows exceeds the threshold, the user will be asked to confirm
             their operations to resume. The default value is 0. Set the value to None
             to turn off the guard.
-        semantic_ops_threshold_autofail (bool):
-            Guards against unexepcted processing of large amount of rows by semantic operators.
+
+        ai_ops_threshold_autofail (bool):
+            Guards against unexpected processing of large amount of rows by semantic operators.
             When set to True, the operation automatically fails without asking for user inputs.
     """
 
@@ -84,6 +96,9 @@ class ComputeOptions:
     semantic_ops_confirmation_threshold: Optional[int] = 0
     semantic_ops_threshold_autofail = False
 
+    ai_ops_confirmation_threshold: Optional[int] = 0
+    ai_ops_threshold_autofail = False
+
     def assign_extra_query_labels(self, **kwargs: Any) -> None:
         """
         Assigns additional custom labels for query configuration. The method updates the

{bigframes-1.41.0 → bigframes-2.0.0.dev0}/bigframes/_config/experiment_options.py

@@ -24,8 +24,8 @@ class ExperimentOptions:
 
     def __init__(self):
         self._semantic_operators: bool = False
+        self._ai_operators: bool = False
         self._blob: bool = False
-        self._udf: bool = False
 
     @property
     def semantic_operators(self) -> bool:
@@ -35,11 +35,24 @@ class ExperimentOptions:
     def semantic_operators(self, value: bool):
         if value is True:
             msg = bfe.format_message(
-                "Semantic operators are still under experiments, and are subject "
+                "Semantic operators are deprecated, and will be removed in the future"
+            )
+            warnings.warn(msg, category=FutureWarning)
+        self._semantic_operators = value
+
+    @property
+    def ai_operators(self) -> bool:
+        return self._ai_operators
+
+    @ai_operators.setter
+    def ai_operators(self, value: bool):
+        if value is True:
+            msg = bfe.format_message(
+                "AI operators are still under experiments, and are subject "
                 "to change in the future."
             )
             warnings.warn(msg, category=bfe.PreviewWarning)
-        self._semantic_operators = value
+        self._ai_operators = value
 
     @property
     def blob(self) -> bool:
@@ -54,17 +67,3 @@ class ExperimentOptions:
             )
             warnings.warn(msg, category=bfe.PreviewWarning)
         self._blob = value
-
-    @property
-    def udf(self) -> bool:
-        return self._udf
-
-    @udf.setter
-    def udf(self, value: bool):
-        if value is True:
-            msg = bfe.format_message(
-                "BigFrames managed function (udf) is still under experiments. "
-                "It may not work and subject to change in the future."
-            )
-            warnings.warn(msg, category=bfe.PreviewWarning)
-        self._udf = value

{bigframes-1.41.0 → bigframes-2.0.0.dev0}/bigframes/bigquery/__init__.py

@@ -27,7 +27,7 @@ from bigframes.bigquery._operations.datetime import (
     unix_millis,
     unix_seconds,
 )
-from bigframes.bigquery._operations.geo import st_area
+from bigframes.bigquery._operations.geo import st_area, st_difference, st_intersection
 from bigframes.bigquery._operations.json import (
     json_extract,
     json_extract_array,
@@ -48,6 +48,8 @@ __all__ = [
     "array_to_string",
     # geo ops
     "st_area",
+    "st_difference",
+    "st_intersection",
     # json ops
     "json_set",
     "json_extract",

bigframes-2.0.0.dev0/bigframes/bigquery/_operations/geo.py

@@ -0,0 +1,305 @@
+# Copyright 2025 Google LLC
+#
+# 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.
+
+from __future__ import annotations
+
+from bigframes import operations as ops
+import bigframes.dtypes
+import bigframes.geopandas
+import bigframes.series
+
+"""
+Search functions defined from
+https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions
+"""
+
+
+def st_area(series: bigframes.series.Series) -> bigframes.series.Series:
+    """
+    Returns the area in square meters covered by the polygons in the input
+    `GEOGRAPHY`.
+
+    If geography_expression is a point or a line, returns zero. If
+    geography_expression is a collection, returns the area of the polygons
+    in the collection; if the collection doesn't contain polygons, returns zero.
+
+
+    .. note::
+        BigQuery's Geography functions, like `st_area`, interpret the geometry
+        data type as a point set on the Earth's surface. A point set is a set
+        of points, lines, and polygons on the WGS84 reference spheroid, with
+        geodesic edges. See: https://cloud.google.com/bigquery/docs/geospatial-data
+
+
+    **Examples:**
+
+        >>> import bigframes.geopandas
+        >>> import bigframes.pandas as bpd
+        >>> import bigframes.bigquery as bbq
+        >>> from shapely.geometry import Polygon, LineString, Point
+        >>> bpd.options.display.progress_bar = None
+
+        >>> series = bigframes.geopandas.GeoSeries(
+        ...         [
+        ...             Polygon([(0.0, 0.0), (0.1, 0.1), (0.0, 0.1)]),
+        ...             Polygon([(0.10, 0.4), (0.9, 0.5), (0.10, 0.5)]),
+        ...             Polygon([(0.1, 0.1), (0.2, 0.1), (0.2, 0.2)]),
+        ...             LineString([(0, 0), (1, 1), (0, 1)]),
+        ...             Point(0, 1),
+        ...         ]
+        ... )
+        >>> series
+        0              POLYGON ((0 0, 0.1 0.1, 0 0.1, 0 0))
+        1    POLYGON ((0.1 0.4, 0.9 0.5, 0.1 0.5, 0.1 0.4))
+        2    POLYGON ((0.1 0.1, 0.2 0.1, 0.2 0.2, 0.1 0.1))
+        3                        LINESTRING (0 0, 1 1, 0 1)
+        4                                       POINT (0 1)
+        dtype: geometry
+
+        >>> bbq.st_area(series)
+        0    61821689.855985
+        1    494563347.88721
+        2    61821689.855841
+        3                0.0
+        4                0.0
+        dtype: Float64
+
+    Use `round()` to round the outputed areas to the neares ten millions
+
+        >>> bbq.st_area(series).round(-7)
+        0     60000000.0
+        1    490000000.0
+        2     60000000.0
+        3            0.0
+        4            0.0
+        dtype: Float64
+
+    Returns:
+      bigframes.pandas.Series:
+          Series of float representing the areas.
+    """
+    series = series._apply_unary_op(ops.geo_area_op)
+    series.name = None
+    return series
+
+
+def st_difference(
+    series: bigframes.series.Series, other: bigframes.series.Series
+) -> bigframes.series.Series:
+    """
+    Returns a `GEOGRAPHY` that represents the point set difference of
+    `geography_1` and `geography_2`. Therefore, the result consists of the part
+    of `geography_1` that doesn't intersect with `geography_2`.
+
+    If `geometry_1` is completely contained in `geometry_2`, then `ST_DIFFERENCE`
+    returns an empty `GEOGRAPHY`.
+
+    .. note::
+        BigQuery's Geography functions, like `st_difference`, interpret the geometry
+        data type as a point set on the Earth's surface. A point set is a set
+        of points, lines, and polygons on the WGS84 reference spheroid, with
+        geodesic edges. See: https://cloud.google.com/bigquery/docs/geospatial-data
+
+    **Examples:**
+
+        >>> import bigframes as bpd
+        >>> import bigframes.bigquery as bbq
+        >>> import bigframes.geopandas
+        >>> from shapely.geometry import Polygon, LineString, Point
+        >>> bpd.options.display.progress_bar = None
+
+    We can check two GeoSeries against each other, row by row:
+
+        >>> s1 = bigframes.geopandas.GeoSeries(
+        ...    [
+        ...        Polygon([(0, 0), (2, 2), (0, 2)]),
+        ...        Polygon([(0, 0), (2, 2), (0, 2)]),
+        ...        LineString([(0, 0), (2, 2)]),
+        ...        LineString([(2, 0), (0, 2)]),
+        ...        Point(0, 1),
+        ...    ],
+        ... )
+        >>> s2 = bigframes.geopandas.GeoSeries(
+        ...    [
+        ...        Polygon([(0, 0), (1, 1), (0, 1)]),
+        ...        LineString([(1, 0), (1, 3)]),
+        ...        LineString([(2, 0), (0, 2)]),
+        ...        Point(1, 1),
+        ...        Point(0, 1),
+        ...    ],
+        ...    index=range(1, 6),
+        ... )
+
+        >>> s1
+        0    POLYGON ((0 0, 2 2, 0 2, 0 0))
+        1    POLYGON ((0 0, 2 2, 0 2, 0 0))
+        2             LINESTRING (0 0, 2 2)
+        3             LINESTRING (2 0, 0 2)
+        4                       POINT (0 1)
+        dtype: geometry
+
+        >>> s2
+        1    POLYGON ((0 0, 1 1, 0 1, 0 0))
+        2             LINESTRING (1 0, 1 3)
+        3             LINESTRING (2 0, 0 2)
+        4                       POINT (1 1)
+        5                       POINT (0 1)
+        dtype: geometry
+
+        >>> bbq.st_difference(s1, s2)
+        0                                               None
+        1    POLYGON ((0.99954 1, 2 2, 0 2, 0 1, 0.99954 1))
+        2                   LINESTRING (0 0, 1 1.00046, 2 2)
+        3                           GEOMETRYCOLLECTION EMPTY
+        4                                        POINT (0 1)
+        5                                               None
+        dtype: geometry
+
+    We can also check difference of single shapely geometries:
+
+        >>> polygon_s1 = bigframes.geopandas.GeoSeries(
+        ...     [
+        ...         Polygon([(0, 0), (10, 0), (10, 10), (0, 0)])
+        ...     ]
+        ... )
+        >>> polygon_s2 = bigframes.geopandas.GeoSeries(
+        ...     [
+        ...         Polygon([(4, 2), (6, 2), (8, 6), (4, 2)])
+        ...     ]
+        ... )
+
+        >>> polygon_s1
+        0    POLYGON ((0 0, 10 0, 10 10, 0 0))
+        dtype: geometry
+
+        >>> polygon_s2
+        0    POLYGON ((4 2, 6 2, 8 6, 4 2))
+        dtype: geometry
+
+        >>> bbq.st_difference(polygon_s1, polygon_s2)
+        0    POLYGON ((0 0, 10 0, 10 10, 0 0), (8 6, 6 2, 4...
+        dtype: geometry
+
+    Additionally, we can check difference of a GeoSeries against a single shapely geometry:
+
+        >>> bbq.st_difference(s1, polygon_s2)
+        0    POLYGON ((0 0, 2 2, 0 2, 0 0))
+        1                              None
+        2                              None
+        3                              None
+        4                              None
+        dtype: geometry
+
+    Args:
+        other (bigframes.series.Series or geometric object):
+            The GeoSeries (elementwise) or geometric object to find the difference to.
+
+    Returns:
+        bigframes.series.Series:
+            A GeoSeries of the points in each aligned geometry that are not
+            in other.
+    """
+    return series._apply_binary_op(other, ops.geo_st_difference_op)
+
+
+def st_intersection(
+    series: bigframes.series.Series, other: bigframes.series.Series
+) -> bigframes.series.Series:
+    """
+    Returns a `GEOGRAPHY` that represents the point set intersection of the two
+    input `GEOGRAPHYs`. Thus, every point in the intersection appears in both
+    `geography_1` and `geography_2`.
+
+    .. note::
+        BigQuery's Geography functions, like `st_intersection`, interpret the geometry
+        data type as a point set on the Earth's surface. A point set is a set
+        of points, lines, and polygons on the WGS84 reference spheroid, with
+        geodesic edges. See: https://cloud.google.com/bigquery/docs/geospatial-data
+
+    **Examples:**
+
+        >>> import bigframes as bpd
+        >>> import bigframes.bigquery as bbq
+        >>> import bigframes.geopandas
+        >>> from shapely.geometry import Polygon, LineString, Point
+        >>> bpd.options.display.progress_bar = None
+
+    We can check two GeoSeries against each other, row by row.
+
+        >>> s1 = bigframes.geopandas.GeoSeries(
+        ...    [
+        ...        Polygon([(0, 0), (2, 2), (0, 2)]),
+        ...        Polygon([(0, 0), (2, 2), (0, 2)]),
+        ...        LineString([(0, 0), (2, 2)]),
+        ...        LineString([(2, 0), (0, 2)]),
+        ...        Point(0, 1),
+        ...    ],
+        ... )
+        >>> s2 = bigframes.geopandas.GeoSeries(
+        ...    [
+        ...        Polygon([(0, 0), (1, 1), (0, 1)]),
+        ...        LineString([(1, 0), (1, 3)]),
+        ...        LineString([(2, 0), (0, 2)]),
+        ...        Point(1, 1),
+        ...        Point(0, 1),
+        ...    ],
+        ...    index=range(1, 6),
+        ... )
+
+        >>> s1
+        0    POLYGON ((0 0, 2 2, 0 2, 0 0))
+        1    POLYGON ((0 0, 2 2, 0 2, 0 0))
+        2             LINESTRING (0 0, 2 2)
+        3             LINESTRING (2 0, 0 2)
+        4                       POINT (0 1)
+        dtype: geometry
+
+        >>> s2
+        1    POLYGON ((0 0, 1 1, 0 1, 0 0))
+        2             LINESTRING (1 0, 1 3)
+        3             LINESTRING (2 0, 0 2)
+        4                       POINT (1 1)
+        5                       POINT (0 1)
+        dtype: geometry
+
+        >>> bbq.st_intersection(s1, s2)
+        0                                    None
+        1    POLYGON ((0 0, 0.99954 1, 0 1, 0 0))
+        2                       POINT (1 1.00046)
+        3                   LINESTRING (2 0, 0 2)
+        4                GEOMETRYCOLLECTION EMPTY
+        5                                    None
+        dtype: geometry
+
+    We can also do intersection of each geometry and a single shapely geometry:
+
+        >>> bbq.st_intersection(s1, bigframes.geopandas.GeoSeries([Polygon([(0, 0), (1, 1), (0, 1)])]))
+        0    POLYGON ((0 0, 0.99954 1, 0 1, 0 0))
+        1                                    None
+        2                                    None
+        3                                    None
+        4                                    None
+        dtype: geometry
+
+    Args:
+        other (GeoSeries or geometric object):
+            The Geoseries (elementwise) or geometric object to find the
+            intersection with.
+
+    Returns:
+        bigframes.geopandas.GeoSeries:
+            The Geoseries (elementwise) of the intersection of points in
+            each aligned geometry with other.
+    """
+    return series._apply_binary_op(other, ops.geo_st_intersection_op)