code: def points(
      coords,
      y=None,
      z=None,
      indices=None,
      handle_nan=HandleNaN.allow,
      out=None,
      **kwargs,
  ):
      """Create an array of points.
  
      Parameters
      ----------
      coords : array_like
          An array of coordinate tuples (2- or 3-dimensional) or, if ``y`` is
          provided, an array of x coordinates.
      y : array_like, optional
      z : array_like, optional
      indices : array_like, optional
          Indices into the target array where input coordinates belong. If
          provided, the coords should be 2D with shape (N, 2) or (N, 3) and
          indices should be an array of shape (N,) with integers in increasing
          order. Missing indices result in a ValueError unless ``out`` is
          provided, in which case the original value in ``out`` is kept.
      handle_nan : shapely.HandleNaN or {'allow', 'skip', 'error'}, default 'allow'
          Specifies what to do when a NaN or Inf is encountered in the coordinates:
  
          - 'allow': the geometries are created with NaN or Inf coordinates.
            Note that this can result in unexpected behaviour in subsequent
            operations, and generally it is discouraged to have non-finite
            coordinate values. One can use this option if you know all
            coordinates are finite and want to avoid the overhead of checking
            for this.
          - 'skip': if any of x, y or z values are NaN or Inf, an empty point
            will be created.
          - 'error': if any NaN or Inf is detected in the coordinates, a ValueError
            is raised. This option ensures that the created geometries have all
            finite coordinate values.
      out : ndarray, optional
          An array (with dtype object) to output the geometries into.
      **kwargs
          See :ref:`NumPy ufunc docs <ufuncs.kwargs>` for other keyword arguments.
          Ignored if ``indices`` is provided.
  
      Examples
      --------
      >>> points([[0, 1], [4, 5]]).tolist()
      [<POINT (0 1)>, <POINT (4 5)>]
      >>> points([0, 1, 2])
      <POINT Z (0 1 2)>
  
      Notes
      -----
  
      - GEOS 3.10, 3.11 and 3.12 automatically converts POINT (nan nan) to POINT EMPTY.
      - GEOS 3.10 and 3.11 will transform a 3D point to 2D if its Z coordinate is NaN.
      - Usage of the ``y`` and ``z`` arguments will prevents lazy evaluation in ``dask``.
        Instead provide the coordinates as an array with shape ``(..., 2)`` or ``(..., 3)`` using only the ``coords`` argument.
      """
      coords = _xyz_to_coords(coords, y, z)
      if isinstance(handle_nan, str):
          handle_nan = HandleNaN.get_value(handle_nan)
      if indices is None:
          return lib.points(
              coords, np.intc(handle_nan), out=out, **kwargs
          )
      else:
          return simple_geometries_1d(
              coords,
              indices,
              GeometryType.POINT,
              handle_nan=handle_nan,
              out=out,
          )
  
imports: import numpy
  from shapely import Geometry, GeometryType, lib
  from shapely._enum import ParamEnum
  from shapely._geometry_helpers import collections_1d, simple_geometries_1d
  from shapely.decorators import multithreading_enabled
  from shapely.io import from_wkt
label_desc: Use image node_id 2 for calling a global function with example usage: points(coords, y, z, indices, handle_nan, out) and returns: lib, simple_geometries_1d