code: 
  import os
  from argparse import ArgumentParser
  from pathlib import Path
  from shutil import copyfile, rmtree
  from typing import Generator
  
  import datasets.config
  from datasets.builder import DatasetBuilder
  from datasets.commands import BaseDatasetsCLICommand
  from datasets.download.download_manager import DownloadMode
  from datasets.load import dataset_module_factory, import_main_class
  from datasets.utils.filelock import logger as fl_logger
  from datasets.utils.info_utils import VerificationMode
  from datasets.utils.logging import ERROR, get_logger
  
  
  _SCREAMING_SNAKE_CASE   						=    get_logger(__name__)
  def 				__lowercase	(						lowerCamelCase__					)				->Optional[int]:
  
    '''simple docstring'''
  
  
  
  
    return TestCommand(
        args.dataset ,				args.name ,				args.cache_dir ,				args.data_dir ,				args.all_configs ,				args.save_info or args.save_infos ,				args.ignore_verifications ,				args.force_redownload ,				args.clear_cache ,				)
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							lowerCAmelCase_    ):
      UpperCAmelCase_			:       Optional[Any]						 =							False  # to tell pytest it's not a test class
  
  
  
  
      @staticmethod
      def 						__lowerCamelCase (					lowerCAmelCase  :   str   )	-> str:
        a__     		=     parser.add_parser("test"      ,      help="Test dataset implementation."   )
        test_parser.add_argument("--name"      ,      type=lowerCamelCase_      ,      default=lowerCamelCase_      ,      help="Dataset processing name"   )
        test_parser.add_argument(
            "--cache_dir"      ,      type=lowerCamelCase_      ,      default=lowerCamelCase_      ,      help="Cache directory where the datasets are stored."      ,      )
        test_parser.add_argument(
            "--data_dir"      ,      type=lowerCamelCase_      ,      default=lowerCamelCase_      ,      help="Can be used to specify a manual directory to get the files from."      ,      )
        test_parser.add_argument("--all_configs"      ,      action="store_true"      ,      help="Test all dataset configurations"   )
        test_parser.add_argument(
            "--save_info"      ,      action="store_true"      ,      help="Save the dataset infos in the dataset card (README.md)"   )
        test_parser.add_argument(
            "--ignore_verifications"      ,      action="store_true"      ,      help="Run the test without checksums and splits checks."      ,      )
        test_parser.add_argument("--force_redownload"      ,      action="store_true"      ,      help="Force dataset redownload"   )
        test_parser.add_argument(
            "--clear_cache"      ,      action="store_true"      ,      help="Remove downloaded files and cached datasets after each config test"      ,      )
        # aliases
        test_parser.add_argument("--save_infos"      ,      action="store_true"      ,      help="alias to save_info"   )
        test_parser.add_argument("dataset"      ,      type=lowerCamelCase_      ,      help="Name of the dataset to download"   )
        test_parser.set_defaults(func=_test_command_factory   )
  
  
  
  
      def __init__(					self  :   Dict      ,      lowerCAmelCase  :   Tuple      ,      lowerCAmelCase  :   Any      ,      lowerCAmelCase  :   List[str]      ,      lowerCAmelCase  :   Union[str, Any]      ,      lowerCAmelCase  :   List[str]      ,      lowerCAmelCase  :   Union[str, Any]      ,      lowerCAmelCase  :   Optional[int]      ,      lowerCAmelCase  :   Optional[Any]      ,      lowerCAmelCase  :   Tuple      ,      )	-> Union[str, Any]:
        a__     		=     dataset
        a__     		=     name
        a__     		=     cache_dir
        a__     		=     data_dir
        a__     		=     all_configs
        a__     		=     save_infos
        a__     		=     ignore_verifications
        a__     		=     force_redownload
        a__     		=     clear_cache
        if clear_cache and not cache_dir:
          print(
              "When --clear_cache is used, specifying a cache directory is mandatory.\n"
              "The 'download' folder of the cache directory and the dataset builder cache will be deleted after each configuration test.\n"
              "Please provide a --cache_dir that will be used to test the dataset script."   )
          exit(1   )
        if save_infos:
          a__     		=     True
  
  
  
  
      def 						__lowerCamelCase (					self  :   int   )	-> Union[str, Any]:
        fl_logger().setLevel(lowerCamelCase_   )
        if self._name is not None and self._all_configs:
          print("Both parameters `config` and `all_configs` can't be used at once."   )
          exit(1   )
        a__		,a__     		=     self._dataset, self._name
        a__     		=     dataset_module_factory(lowerCamelCase_   )
        a__     		=     import_main_class(module.module_path   )
        a__     		=     len(builder_cls.BUILDER_CONFIGS   ) if self._all_configs and builder_cls.BUILDER_CONFIGS else 1
  
        def get_builders() -> Generator[DatasetBuilder, None, None]:
          if self._all_configs and builder_cls.BUILDER_CONFIGS:
            for i, config in enumerate(builder_cls.BUILDER_CONFIGS   ):
              if "config_name" in module.builder_kwargs:
                yield builder_cls(
                    cache_dir=self._cache_dir      ,      data_dir=self._data_dir      ,      **module.builder_kwargs      ,      )
              else:
                yield builder_cls(
                    config_name=config.name      ,      cache_dir=self._cache_dir      ,      data_dir=self._data_dir      ,      **module.builder_kwargs      ,      )
          else:
            if "config_name" in module.builder_kwargs:
              yield builder_cls(cache_dir=self._cache_dir      ,      data_dir=self._data_dir      ,      **module.builder_kwargs   )
            else:
              yield builder_cls(
                  config_name=lowerCamelCase_      ,      cache_dir=self._cache_dir      ,      data_dir=self._data_dir      ,      **module.builder_kwargs      ,      )
  
        for j, builder in enumerate(get_builders()   ):
          print(f"Testing builder \'{builder.config.name}\' ({j + 1}/{n_builders})"   )
          a__     		=     os.path.exists(
              os.path.join(builder.get_imported_module_dir()      ,      datasets.config.DATASETDICT_INFOS_FILENAME   )   )  # record checksums only if we need to update a (deprecated) dataset_infos.json
          builder.download_and_prepare(
              download_mode=DownloadMode.REUSE_CACHE_IF_EXISTS
              if not self._force_redownload
              else DownloadMode.FORCE_REDOWNLOAD      ,      verification_mode=VerificationMode.NO_CHECKS
              if self._ignore_verifications
              else VerificationMode.ALL_CHECKS      ,      try_from_hf_gcs=lowerCamelCase_      ,      )
          builder.as_dataset()
          if self._save_infos:
            builder._save_infos()
  
          # If save_infos=True, the dataset card (README.md) is created next to the loaded module file.
          # The dataset_infos are saved in the YAML part of the README.md
  
          # Let's move it to the original directory of the dataset script, to allow the user to
          # upload them on S3 at the same time afterwards.
          if self._save_infos:
            a__     		=     os.path.join(builder_cls.get_imported_module_dir()      ,      "README.md"   )
            a__     		=     Path(lowerCamelCase_   ).name + ".py"
            a__     		=     os.path.join(lowerCamelCase_      ,      lowerCamelCase_   )
            if os.path.isfile(lowerCamelCase_   ):
              a__     		=     os.path.dirname(lowerCamelCase_   )
            elif os.path.isfile(lowerCamelCase_   ):
              a__     		=     path
            elif os.path.isdir(lowerCamelCase_   ):  # for local directories containing only data files
              a__     		=     path
            else:  # in case of a remote dataset
              a__     		=     None
              print(f"Dataset card saved at {dataset_readme_path}"   )
  
            # Move dataset_info back to the user
            if dataset_dir is not None:
              a__     		=     os.path.join(lowerCamelCase_      ,      "README.md"   )
              copyfile(lowerCamelCase_      ,      lowerCamelCase_   )
              print(f"Dataset card saved at {user_dataset_readme_path}"   )
  
              # If clear_cache=True, the download folder and the dataset builder cache directory are deleted
          if self._clear_cache:
            if os.path.isdir(builder._cache_dir   ):
              logger.warning(f"Clearing cache at {builder._cache_dir}"   )
              rmtree(builder._cache_dir   )
            a__     		=     os.path.join(self._cache_dir      ,      datasets.config.DOWNLOADED_DATASETS_DIR   )
            if os.path.isdir(lowerCamelCase_   ):
              logger.warning(f"Clearing cache at {download_dir}"   )
              rmtree(lowerCamelCase_   )
  
        print("Test successful."   )
  
  
style_context: import copy
  
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  
  
  _SCREAMING_SNAKE_CASE   						=    logging.get_logger(__name__)
  
  _SCREAMING_SNAKE_CASE   						=    {
      """facebook/sam-vit-huge""": """https://huggingface.co/facebook/sam-vit-huge/resolve/main/config.json""",
      """facebook/sam-vit-large""": """https://huggingface.co/facebook/sam-vit-large/resolve/main/config.json""",
      """facebook/sam-vit-base""": """https://huggingface.co/facebook/sam-vit-base/resolve/main/config.json""",
  }
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							_a    ):
  
  
  
  
      def __init__(					self  :   List[str]      ,      lowerCAmelCase  :   str=256      ,      lowerCAmelCase  :   Any=1024      ,      lowerCAmelCase  :   List[str]=16      ,      lowerCAmelCase  :   Union[str, Any]=16      ,      lowerCAmelCase  :   int=4      ,      lowerCAmelCase  :   List[Any]="gelu"      ,      lowerCAmelCase  :   str=1e-6      ,      **lowerCAmelCase  :   Union[str, Any]      ,      )	-> Union[str, Any]:
        super().__init__(**lowerCAmelCase   )
        a__     		=     hidden_size
        a__     		=     image_size
        a__     		=     patch_size
        a__     		=     image_size // patch_size
        a__     		=     mask_input_channels
        a__     		=     num_point_embeddings
        a__     		=     hidden_act
        a__     		=     layer_norm_eps
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							_a    ):
  
  
  
  
      def __init__(					self  :   Dict      ,      lowerCAmelCase  :   str=256      ,      lowerCAmelCase  :   Union[str, Any]="relu"      ,      lowerCAmelCase  :   Optional[int]=2048      ,      lowerCAmelCase  :   Any=2      ,      lowerCAmelCase  :   Any=8      ,      lowerCAmelCase  :   Optional[Any]=2      ,      lowerCAmelCase  :   Optional[Any]=3      ,      lowerCAmelCase  :   Union[str, Any]=3      ,      lowerCAmelCase  :   List[str]=256      ,      lowerCAmelCase  :   Optional[Any]=1e-6      ,      **lowerCAmelCase  :   Any      ,      )	-> int:
        super().__init__(**lowerCAmelCase   )
        a__     		=     hidden_size
        a__     		=     hidden_act
        a__     		=     mlp_dim
        a__     		=     num_hidden_layers
        a__     		=     num_attention_heads
        a__     		=     attention_downsample_rate
        a__     		=     num_multimask_outputs
        a__     		=     iou_head_depth
        a__     		=     iou_head_hidden_dim
        a__     		=     layer_norm_eps
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							_a    ):
  
  
  
  
      def __init__(					self  :   Optional[Any]      ,      lowerCAmelCase  :   Optional[Any]=768      ,      lowerCAmelCase  :   int=256      ,      lowerCAmelCase  :   Tuple=12      ,      lowerCAmelCase  :   List[str]=12      ,      lowerCAmelCase  :   Tuple=3      ,      lowerCAmelCase  :   Any=1024      ,      lowerCAmelCase  :   Dict=16      ,      lowerCAmelCase  :   Dict="gelu"      ,      lowerCAmelCase  :   List[Any]=1e-0_6      ,      lowerCAmelCase  :   Any=0.0      ,      lowerCAmelCase  :   Optional[Any]=1e-1_0      ,      lowerCAmelCase  :   Tuple=True      ,      lowerCAmelCase  :   Tuple=4.0      ,      lowerCAmelCase  :   Optional[Any]=True      ,      lowerCAmelCase  :   List[str]=True      ,      lowerCAmelCase  :   Dict=14      ,      lowerCAmelCase  :   Optional[int]=[2, 5, 8, 11]      ,      lowerCAmelCase  :   List[str]=128      ,      lowerCAmelCase  :   List[str]=None      ,      **lowerCAmelCase  :   str      ,      )	-> Optional[int]:
        super().__init__(**lowerCAmelCase   )
  
        a__     		=     hidden_size
        a__     		=     output_channels
        a__     		=     num_hidden_layers
        a__     		=     num_attention_heads
        a__     		=     num_channels
        a__     		=     image_size
        a__     		=     patch_size
        a__     		=     hidden_act
        a__     		=     layer_norm_eps
        a__     		=     attention_dropout
        a__     		=     initializer_range
        a__     		=     qkv_bias
        a__     		=     mlp_ratio
        a__     		=     use_abs_pos
        a__     		=     use_rel_pos
        a__     		=     window_size
        a__     		=     global_attn_indexes
        a__     		=     num_pos_feats
        a__     		=     int(hidden_size * mlp_ratio   ) if mlp_dim is None else mlp_dim
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							_a    ):
      UpperCAmelCase_			:       Optional[Any]						 =							'sam'
      UpperCAmelCase_			:       List[Any]						 =							True
  
  
  
  
      def __init__(					self  :   Dict      ,      lowerCAmelCase  :   Any=None      ,      lowerCAmelCase  :   Optional[Any]=None      ,      lowerCAmelCase  :   Optional[Any]=None      ,      lowerCAmelCase  :   str=0.02      ,      **lowerCAmelCase  :   int      ,      )	-> Dict:
        super().__init__(**lowerCAmelCase   )
        a__     		=     vision_config if vision_config is not None else {}
        a__     		=     prompt_encoder_config if prompt_encoder_config is not None else {}
        a__     		=     mask_decoder_config if mask_decoder_config is not None else {}
  
        if isinstance(lowerCAmelCase      ,      lowerCAmelCase   ):
          a__     		=     vision_config.to_dict()
        if isinstance(lowerCAmelCase      ,      lowerCAmelCase   ):
          a__     		=     prompt_encoder_config.to_dict()
        if isinstance(lowerCAmelCase      ,      lowerCAmelCase   ):
          a__     		=     mask_decoder_config.to_dict()
  
        a__     		=     SamVisionConfig(**lowerCAmelCase   )
        a__     		=     SamPromptEncoderConfig(**lowerCAmelCase   )
        a__     		=     SamMaskDecoderConfig(**lowerCAmelCase   )
        a__     		=     initializer_range
  
  
  
  
      def 						__lowerCamelCase (					self  :   Optional[Any]   )	-> Union[str, Any]:
        a__     		=     copy.deepcopy(self.__dict__   )
        a__     		=     self.vision_config.to_dict()
        a__     		=     self.prompt_encoder_config.to_dict()
        a__     		=     self.mask_decoder_config.to_dict()
        a__     		=     self.__class__.model_type
        return output
  
  