code: def _internal_read_csv(path, blocksize="256 MiB", **kwargs):
      if isinstance(blocksize, str):
          blocksize = parse_bytes(blocksize)
  
      if isinstance(path, list):
          filenames = path
      elif isinstance(path, str):
          filenames = sorted(glob(path))
      elif hasattr(path, "__fspath__"):
          filenames = sorted(glob(path.__fspath__()))
      else:
          raise TypeError(f"Path type not understood:{type(path)}")
  
      if not filenames:
          msg = f"A file in: {filenames} does not exist."
          raise FileNotFoundError(msg)
  
      name = "read-csv-" + tokenize(
          path, tokenize, **kwargs
      )  # TODO: get last modified time
  
      compression = kwargs.get("compression", "infer")
  
      if compression == "infer":
          # Infer compression from first path by default
          compression = infer_compression(filenames[0])
  
      if compression and blocksize:
          # compressed CSVs reading must read the entire file
          kwargs.pop("byte_range", None)
          warn(
              "Warning %s compression does not support breaking apart files\n"
              "Please ensure that each individual file can fit in memory and\n"
              "use the keyword ``blocksize=None to remove this message``\n"
              "Setting ``blocksize=(size of file)``" % compression
          )
          blocksize = None
  
      if blocksize is None:
          return read_csv_without_blocksize(path, **kwargs)
  
      # Let dask.dataframe generate meta
      dask_reader = make_reader(cudf.read_csv, "read_csv", "CSV")
      kwargs1 = kwargs.copy()
      usecols = kwargs1.pop("usecols", None)
      dtype = kwargs1.pop("dtype", None)
      meta = dask_reader(filenames[0], **kwargs1)._meta
      names = meta.columns
      if usecols or dtype:
          # Regenerate meta with original kwargs if
          # `usecols` or `dtype` was specified
          meta = dask_reader(filenames[0], **kwargs)._meta
  
      dsk = {}
      i = 0
      dtypes = meta.dtypes.values
  
      for fn in filenames:
          size = os.path.getsize(fn)
          for start in range(0, size, blocksize):
              kwargs2 = kwargs.copy()
              kwargs2["byte_range"] = (
                  start,
                  blocksize,
              )  # specify which chunk of the file we care about
              if start != 0:
                  kwargs2[
                      "names"
                  ] = names  # no header in the middle of the file
                  kwargs2["header"] = None
              dsk[(name, i)] = (apply, _read_csv, [fn, dtypes], kwargs2)
  
              i += 1
  
      divisions = [None] * (len(dsk) + 1)
      return dd.core.new_dd_object(dsk, name, meta, divisions)
  
file_path: cudf/python/dask_cudf/dask_cudf/io/csv.py
imports: import os
  from glob import glob
  from warnings import warn
  from fsspec.utils import infer_compression
  from dask import dataframe
  from dask.base import tokenize
  from dask.dataframe.io.csv import make_reader
  from dask.utils import apply, parse_bytes
  import cudf
label_desc: Use image node_id 2 for calling a global function with example usage: _internal_read_csv(path, blocksize) and returns: dd, read_csv_without_blocksize