code: def load_data(
      data_format: str = "TextData",
      as_train_test: bool = True,
      use_full_size: bool = False,
      include_properties: bool = True,
      include_embeddings: bool = False,
  ) -> t.Union[t.Tuple, t.Union[TextData, pd.DataFrame]]:
      """Load and returns the Just Dance Comment Analysis dataset (multi-label classification).
  
      Parameters
      ----------
      data_format : str, default: 'TextData'
          Represent the format of the returned value. Can be 'TextData'|'DataFrame'
          'TextData' will return the data as a TextData object
          'Dataframe' will return the data as a pandas DataFrame object
      as_train_test : bool, default: True
          If True, the returned data is split into train and test exactly like the toy model
          was trained. The first return value is the train data and the second is the test data.
          In order to get this model, call the load_fitted_model() function.
          Otherwise, returns a single object.
      use_full_size : bool, default: False
          If True, the returned data will be the full dataset, otherwise returns a subset of the data.
      include_properties : bool, default: True
          If True, the returned data will include properties of the comments. Incompatible with data_format='DataFrame'
      include_embeddings : bool, default: False
          If True, the returned data will include embeddings of the comments. Incompatible with data_format='DataFrame'
  
      Returns
      -------
      dataset : Union[TextData, pd.DataFrame]
          the data object, corresponding to the data_format attribute.
      train, test : Tuple[Union[TextData, pd.DataFrame],Union[TextData, pd.DataFrame]
          tuple if as_train_test = True. Tuple of two objects represents the dataset split to train and test sets.
      """
      if data_format.lower() not in ["textdata", "dataframe"]:
          raise ValueError(
              'data_format must be either "TextData" or "Dataframe"'
          )
      elif data_format.lower() == "dataframe":
          if include_properties or include_embeddings:
              warnings.warn(
                  'include_properties and include_embeddings are incompatible with data_format="Dataframe". '
                  "loading only original text data.",
                  UserWarning,
              )
              include_properties, include_embeddings = False, False
  
      if use_full_size:
          data = read_and_save_data(
              ASSETS_DIR,
              "just_dance_data.csv",
              _FULL_DATA_URL,
              to_numpy=False,
              include_index=False,
          )
      else:
          data = read_and_save_data(
              ASSETS_DIR,
              "just_dance_shorted_data.csv",
              _SHORT_DATA_URL,
              to_numpy=False,
          )
      data[_TIME_COL] = pd.to_datetime(data[_TIME_COL])
  
      properties = (
          load_properties(
              as_train_test=False, use_full_size=use_full_size
          )
          if include_properties
          else None
      )
      embeddings = (
          load_embeddings(
              as_train_test=False, use_full_size=use_full_size
          )
          if include_embeddings
          else None
      )
  
      if not as_train_test:
          if data_format.lower() != "textdata":
              return data
  
          label = (
              data.drop(columns=[_TEXT_COL] + _METADATA_COLS)
              .to_numpy()
              .astype(int)
          )
          dataset = TextData(
              data[_TEXT_COL],
              label=label,
              task_type="text_classification",
              metadata=data[_METADATA_COLS],
              categorical_metadata=_CAT_METADATA,
              properties=properties,
              embeddings=embeddings,
          )
          return dataset
  
      else:
          train_indexes, test_indexes = _get_train_test_indexes(
              use_full_size
          )
          train, test = data.loc[train_indexes], data.loc[test_indexes]
  
          if data_format.lower() != "textdata":
              return train, test
  
          train_metadata, test_metadata = (
              train[_METADATA_COLS],
              test[_METADATA_COLS],
          )
          label_train = (
              train.drop(columns=[_TEXT_COL] + _METADATA_COLS)
              .to_numpy()
              .astype(int)
          )
          label_test = (
              test.drop(columns=[_TEXT_COL] + _METADATA_COLS)
              .to_numpy()
              .astype(int)
          )
  
          if include_properties:
              train_properties, test_properties = (
                  properties.loc[train.index],
                  properties.loc[test.index],
              )
          else:
              train_properties, test_properties = None, None
          if include_embeddings:
              train_embeddings = embeddings[
                  train.index
              ]  # pylint: disable=unsubscriptable-object
              test_embeddings = embeddings[
                  test.index
              ]  # pylint: disable=unsubscriptable-object
          else:
              train_embeddings, test_embeddings = None, None
  
          train_ds = TextData(
              train[_TEXT_COL],
              label=label_train,
              task_type="text_classification",
              metadata=train_metadata,
              categorical_metadata=_CAT_METADATA,
              properties=train_properties,
              embeddings=train_embeddings,
          )
          test_ds = TextData(
              test[_TEXT_COL],
              label=label_test,
              task_type="text_classification",
              metadata=test_metadata,
              categorical_metadata=_CAT_METADATA,
              properties=test_properties,
              embeddings=test_embeddings,
          )
  
          return train_ds, test_ds
  
file_path: deepchecks/deepchecks/nlp/datasets/classification/just_dance_comment_analysis.py
imports: import pathlib
  import typing
  import warnings
  import numpy
  import pandas
  from deepchecks.nlp import TextData
  from deepchecks.utils.builtin_datasets_utils import read_and_save_data
label_desc: Use image node_id 4 for calling a global function with example usage: load_data(data_format, as_train_test, use_full_size, include_properties, include_embeddings) and returns: dataset, train_ds,  test_ds, data, train,  test