code: def linearrings(
      coords,
      y=None,
      z=None,
      indices=None,
      handle_nan=HandleNaN.allow,
      out=None,
      **kwargs,
  ):
      """Create an array of linearrings.
  
      If the provided coords do not constitute a closed linestring, or if there
      are only 3 provided coords, the first
      coordinate is duplicated at the end to close the ring. This function will
      raise an exception if a linearring contains less than three points or if
      the terminal coordinates contain NaN (not-a-number).
  
      Parameters
      ----------
      coords : array_like
          An array of lists of coordinate tuples (2- or 3-dimensional) or, if ``y``
          is provided, an array of lists 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': the coordinate pairs where any of x, y or z values are
            NaN or Inf are ignored. If this results in ignoring all coordinates
            for one geometry, an empty geometry is 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.
  
      See also
      --------
      linestrings
  
      Examples
      --------
      >>> linearrings([[0, 0], [0, 1], [1, 1], [0, 0]])
      <LINEARRING (0 0, 0 1, 1 1, 0 0)>
      >>> linearrings([[0, 0], [0, 1], [1, 1]])
      <LINEARRING (0 0, 0 1, 1 1, 0 0)>
  
      Notes
      -----
      - Usage of the ``y`` and ``z`` arguments will prevents lazy evaluation in ``dask``.
        Instead provide the coordinates as a ``(..., 2)`` or ``(..., 3)`` array using only ``coords``.
      """
      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.linearrings(
              coords, np.intc(handle_nan), out=out, **kwargs
          )
      else:
          return simple_geometries_1d(
              coords,
              indices,
              GeometryType.LINEARRING,
              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 4 for calling a global function with example usage: linearrings(coords, y, z, indices, handle_nan, out) and returns: lib, simple_geometries_1d