code: def assert_row(
      df,
      index: int = 0,
      names: Union[str, List] = IGNORED,
      found_name: Union[str, List] = IGNORED,
      id: Union[str, List] = IGNORED,
      city: Union[str, List] = IGNORED,
      county: Union[str, List] = IGNORED,
      state: Union[str, List] = IGNORED,
      country: Union[str, List] = IGNORED,
      lon=None,
      lat=None,
      lon_min=None,
      lon_max=None,
      lat_min=None,
      lat_max=None,
      boundary=None,
  ):
      def assert_str(column, expected):
          if expected == IGNORED:
              return
  
          if expected == NO_COLUMN:
              assert column not in df.columns.tolist()
              return
  
          if isinstance(expected, str):
              assert expected == df[column][index], "{} != {}".format(
                  expected, df[column][index]
              )
              return
  
          if isinstance(expected, list):
              actual = df[column][
                  index : index + len(expected)
              ].tolist()
              assert actual == expected, "{} != {}".format(
                  expected, actual
              )
              return
  
          raise ValueError(
              "Not support type of expected: {}".format(
                  str(type(expected))
              )
          )
  
      assert_str(get_request_column_name(df), names)
      assert_str(DF_COLUMN_ID, id)
      assert_str(DF_COLUMN_FOUND_NAME, found_name)
      assert_str(COLUMN_NAME_CITY, city)
      assert_str(DF_COLUMN_COUNTY, county)
      assert_str(DF_COLUMN_STATE, state)
      assert_str(DF_COLUMN_COUNTRY, country)
      if lon is not None:
          assert (
              Point(df.geometry[index]).x == lon
          ), "lon {} != {}".format(lon, Point(df.geometry[index]).x)
  
      if lat is not None:
          assert (
              Point(df.geometry[index]).y == lat
          ), "lat {} != {}".format(lat, Point(df.geometry[index]).y)
  
      if any(
          [v is not None for v in [lon_min, lon_max, lat_min, lat_max]]
      ):
          if isinstance(df, GeoDataFrame):
              bounds = df.geometry[index].bounds
  
              if lon_min is not None:
                  assert lon_min == bounds[0]
  
              if lat_min is not None:
                  assert lat_min == bounds[1]
  
              if lon_max is not None:
                  assert lon_max == bounds[2]
  
              if lat_max is not None:
                  assert lat_max == bounds[3]
          else:
              assert GEO_RECT_MIN_LON == df.lonmin[index]
              assert GEO_RECT_MIN_LAT == df.latmin[index]
              assert GEO_RECT_MAX_LON == df.lonmax[index]
              assert GEO_RECT_MAX_LAT == df.latmax[index]
  
      if boundary is not None:
  
          def assert_geo_multipolygon(
              geo_multipolygon, multipolygon: GJMultipolygon
          ):
              for i, geo_polygon in enumerate(geo_multipolygon.geoms):
                  assert_geo_polygon(geo_polygon, multipolygon[i])
  
          def assert_geo_polygon(geo_polygon, polygon: GJPolygon):
              assert_geo_ring(geo_polygon.exterior.coords, polygon[0])
  
              for i, interior in enumerate(geo_polygon.interiors):
                  assert_geo_ring(interior.coords, polygon[1 + i])
  
          def assert_geo_ring(geo_ring, ring: GJRing):
              for i, point in enumerate(ring):
                  assert point[0] == geo_ring[i][0]  # lon
                  assert point[1] == geo_ring[i][1]  # lat
  
          geometry = df.geometry[index]
          if isinstance(geometry, shapely.geometry.Polygon):
              assert_geo_polygon(geometry, boundary)
  
          if isinstance(geometry, shapely.geometry.MultiPolygon):
              assert_geo_multipolygon(geometry, boundary)
  
imports: import json
  from typing import List, Union, Callable, Any
  import shapely
  from geopandas import GeoDataFrame
  from shapely.geometry import Point
  from lets_plot.geo_data import DF_COLUMN_ID, DF_COLUMN_FOUND_NAME, DF_COLUMN_COUNTY, DF_COLUMN_STATE, DF_COLUMN_COUNTRY
  from lets_plot.geo_data.geocodes import Geocodes
  from lets_plot.geo_data.gis.geometry import Ring, Polygon, Multipolygon
  from lets_plot.geo_data.gis.json_response import ResponseField, GeometryKind
  from lets_plot.geo_data.gis.request import RegionQuery
  from lets_plot.geo_data.gis.response import Answer, GeocodedFeature, FeatureBuilder, LevelKind, Status, GeoRect, GeoPoint, Response, SuccessResponse, AmbiguousResponse, ErrorResponse, ResponseBuilder
label_desc: Use image node_id 5 for calling a global function with example usage: assert_row(df, index, names, found_name, id, city, county, state, country, lon, lat, lon_min, lon_max, lat_min, lat_max, boundary) without return types