code: def read_csv(path, blocksize="default", **kwargs):
      """
      Read CSV files into a :class:`.DataFrame`.
  
      This API parallelizes the :func:`cudf:cudf.read_csv` function in
      the following ways:
  
      It supports loading many files at once using globstrings:
  
      >>> import dask_cudf
      >>> df = dask_cudf.read_csv("myfiles.*.csv")
  
      In some cases it can break up large files:
  
      >>> df = dask_cudf.read_csv("largefile.csv", blocksize="256 MiB")
  
      It can read CSV files from external resources (e.g. S3, HTTP, FTP)
  
      >>> df = dask_cudf.read_csv("s3://bucket/myfiles.*.csv")
      >>> df = dask_cudf.read_csv("https://www.mycloud.com/sample.csv")
  
      Internally ``read_csv`` uses :func:`cudf:cudf.read_csv` and
      supports many of the same keyword arguments with the same
      performance guarantees. See the docstring for
      :func:`cudf:cudf.read_csv` for more information on available
      keyword arguments.
  
      Parameters
      ----------
      path : str, path object, or file-like object
          Either a path to a file (a str, :py:class:`pathlib.Path`, or
          py._path.local.LocalPath), URL (including http, ftp, and S3
          locations), or any object with a read() method (such as
          builtin :py:func:`open` file handler function or
          :py:class:`~io.StringIO`).
      blocksize : int or str, default "256 MiB"
          The target task partition size. If ``None``, a single block
          is used for each file.
      **kwargs : dict
          Passthrough key-word arguments that are sent to
          :func:`cudf:cudf.read_csv`.
  
      Notes
      -----
      If any of `skipfooter`/`skiprows`/`nrows` are passed,
      `blocksize` will default to None.
  
      Examples
      --------
      >>> import dask_cudf
      >>> ddf = dask_cudf.read_csv("sample.csv", usecols=["a", "b"])
      >>> ddf.compute()
         a      b
      0  1     hi
      1  2  hello
      2  3     ai
  
      """
  
      # Handle `chunksize` deprecation
      if "chunksize" in kwargs:
          chunksize = kwargs.pop("chunksize", "default")
          warn(
              "`chunksize` is deprecated and will be removed in the future. "
              "Please use `blocksize` instead.",
              FutureWarning,
          )
          if blocksize == "default":
              blocksize = chunksize
  
      # Set default `blocksize`
      if blocksize == "default":
          if (
              kwargs.get("skipfooter", 0) != 0
              or kwargs.get("skiprows", 0) != 0
              or kwargs.get("nrows", None) is not None
          ):
              # Cannot read in blocks if skipfooter,
              # skiprows or nrows is passed.
              blocksize = None
          else:
              blocksize = "256 MiB"
  
      if "://" in str(path):
          func = make_reader(cudf.read_csv, "read_csv", "CSV")
          return func(path, blocksize=blocksize, **kwargs)
      else:
          return _internal_read_csv(
              path=path, blocksize=blocksize, **kwargs
          )
  
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 1 for calling a global function with example usage: read_csv(path, blocksize) and returns: func, _internal_read_csv