code: def builder(
      name: str,
      *,
      try_gcs: bool = False,
      **builder_kwargs: Any,
  ) -> dataset_builder.DatasetBuilder:
      """Fetches a `tfds.core.DatasetBuilder` by string name.
  
      Args:
        name: `str`, the registered name of the `DatasetBuilder` (the class name as
          camel or snake case: `MyDataset` or `my_dataset`). This can be either
          `'dataset_name'` or `'dataset_name/config_name'` for datasets with
          `BuilderConfig`s. As a convenience, this string may contain
          comma-separated keyword arguments for the builder. For example
          `'foo_bar/a=True,b=3'` would use the `FooBar` dataset passing the keyword
          arguments `a=True` and `b=3` (for builders with configs, it would be
          `'foo_bar/zoo/a=True,b=3'` to use the `'zoo'` config and pass to the
          builder keyword arguments `a=True` and `b=3`).
        try_gcs: `bool`, if True, `tfds.load` will see if the dataset exists on the
          public GCS bucket before building it locally. This is equivalent to
          passing `data_dir='gs://tfds-data/datasets'`. Warning: `try_gcs` is
          different than `builder_kwargs.download_config.try_download_gcs`.
          `try_gcs` (default: False) overrides `data_dir` to be the public GCS
          bucket. `try_download_gcs` (default: True) allows downloading from GCS
          while keeping a different `data_dir` than the public GCS bucket.  So, to
          fully bypass GCS, please use `try_gcs=False` and
          `download_and_prepare_kwargs={'download_config':
          tfds.core.download.DownloadConfig(try_download_gcs=False)})`.
        **builder_kwargs: `dict` of keyword arguments passed to the
          `tfds.core.DatasetBuilder`.
  
      Returns:
        A `tfds.core.DatasetBuilder`.
  
      Raises:
        DatasetNotFoundError: if `name` is unrecognized.
      """
      # 'kaggle:my_ds/config:1.0.0' -> (
      #     DatasetName('kaggle:my_ds'), {'version': '1.0.0', 'config': 'conf0'}
      # )
      name, builder_kwargs = naming.parse_builder_name_kwargs(
          name, **builder_kwargs
      )
  
      def get_dataset_repr() -> str:
          return f'dataset "{name}", builder_kwargs "{builder_kwargs}"'
  
      # `try_gcs` currently only supports non-community datasets
      if (
          try_gcs
          and not name.namespace
          and gcs_utils.is_dataset_on_gcs(str(name))
      ):
          data_dir = builder_kwargs.get("data_dir")
          if data_dir:
              raise ValueError(
                  f"Cannot have both `try_gcs=True` and `data_dir={data_dir}`"
                  f" explicitly set. Wrong arguments for {get_dataset_repr()}"
              )
          builder_kwargs["data_dir"] = gcs_utils.gcs_path("datasets")
      if name.namespace:
          if name.namespace == "huggingface":
              return huggingface_dataset_builder.builder(
                  name=name.name, **builder_kwargs
              )
          if (
              visibility.DatasetType.COMMUNITY_PUBLIC.is_available()
              and community.community_register.has_namespace(
                  name.namespace
              )
          ):
              return community.community_register.builder(
                  name=name, **builder_kwargs
              )
  
      # First check whether we can find the corresponding dataset builder code
      try:
          cls = builder_cls(str(name))
      except registered.DatasetNotFoundError as e:
          cls = None  # Class not found
          not_found_error = (
              e  # Save the exception to eventually reraise
          )
  
      # Eventually try loading from files first
      if _try_load_from_files_first(cls, **builder_kwargs):
          try:
              return read_only_builder.builder_from_files(
                  str(name), **builder_kwargs
              )
          except registered.DatasetNotFoundError as e:
              logging.info(
                  "Failed to load %s from files: %s",
                  get_dataset_repr(),
                  str(e),
              )
  
      # If code exists and loading from files was skipped (e.g. files not found),
      # load from the source code.
      if cls:
          with py_utils.try_reraise(
              prefix=f"Failed to construct {get_dataset_repr()}: "
          ):
              return cls(
                  **builder_kwargs
              )  # pytype: disable=not-instantiable
  
      # If neither the code nor the files are found, raise DatasetNotFoundError
      raise not_found_error
  
imports: from __future__ import annotations
  from collections.abc import Sequence
  import dataclasses
  import difflib
  import json
  import os
  import posixpath
  import re
  import textwrap
  import typing
  from typing import Any, Callable, Dict, Iterable, Iterator, List, Mapping, Optional, Type, Union
  from absl import logging
  from tensorflow_datasets.core import community
  from tensorflow_datasets.core import constants
  from tensorflow_datasets.core import dataset_builder
  from tensorflow_datasets.core import dataset_collection_builder
  from tensorflow_datasets.core import decode
  from tensorflow_datasets.core import file_adapters
  from tensorflow_datasets.core import lazy_imports_lib
  from tensorflow_datasets.core import logging
  from tensorflow_datasets.core import naming
  from tensorflow_datasets.core import read_only_builder
  from tensorflow_datasets.core import registered
  from tensorflow_datasets.core import splits
  from tensorflow_datasets.core import utils
  from tensorflow_datasets.core import visibility
  from tensorflow_datasets.core.dataset_builders import huggingface_dataset_builder
  from tensorflow_datasets.core.utils import error_utils
  from tensorflow_datasets.core.utils import gcs_utils
  from tensorflow_datasets.core.utils import py_utils
  from tensorflow_datasets.core.utils import read_config
  from tensorflow_datasets.core.utils import type_utils
  from tensorflow_datasets.core.utils import version
  from tensorflow_datasets.core.utils.lazy_imports_utils import tensorflow
label_desc: Use image node_id 4 for calling a global function with example usage: builder(name) and returns: str, name, str, builder_kwargs, str, huggingface_dataset_builder, community, read_only_builder, cls