'''simple docstring'''





# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os

from accelerate.utils import ComputeEnvironment

from .cluster import get_cluster_input
from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file  # noqa: F401
from .config_utils import _ask_field, _ask_options, _convert_compute_environment  # noqa: F401
from .sagemaker import get_sagemaker_input


SCREAMING_SNAKE_CASE_:     Dict  ='Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine'





def 	lowerCAmelCase_				(					)    ->      Optional[Any]:


     '''simple docstring'''




     UpperCAmelCase_           =   _ask_options(
         "In which compute environment are you running?"					,    ["This machine", "AWS (Amazon SageMaker)"]					,    _convert_compute_environment					,    )
     if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
          UpperCAmelCase_           =   get_sagemaker_input()
     else:
          UpperCAmelCase_           =   get_cluster_input()
     return config





def 	lowerCAmelCase_				(					snake_case_       : Dict=None			)    ->      Union[str, Any]:


     '''simple docstring'''




     if subparsers is not None:
          UpperCAmelCase_           =   subparsers.add_parser("config"					,    description=snake_case_			)
     else:
          UpperCAmelCase_           =   argparse.ArgumentParser("Accelerate config command"					,    description=snake_case_			)

     parser.add_argument(
         "--config_file"					,    default=snake_case_					,    help=(
             "The path to use to store the config file. Will default to a file named default_config.yaml in the cache "
             "location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have "
             "such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed "
             "with 'huggingface'."
         )					,    )

     if subparsers is not None:
          parser.set_defaults(func=snake_case_			)
     return parser





def 	lowerCAmelCase_				(					snake_case_       : int			)    ->      Any:


     '''simple docstring'''




     UpperCAmelCase_           =   get_user_input()
     if args.config_file is not None:
          UpperCAmelCase_           =   args.config_file
     else:
          if not os.path.isdir(snake_case_			):
               os.makedirs(snake_case_			)
          UpperCAmelCase_           =   default_yaml_config_file

     if config_file.endswith(".json"			):
          config.to_json_file(snake_case_			)
     else:
          config.to_yaml_file(snake_case_			)
     print(f"""accelerate configuration saved at {config_file}"""			)





def 	lowerCAmelCase_				(					)    ->      Optional[int]:


     '''simple docstring'''




     UpperCAmelCase_           =   config_command_parser()
     UpperCAmelCase_           =   parser.parse_args()
     config_command(snake_case_			)


if __name__ == "__main__":
    main()





'''simple docstring'''





from transformers import DistilBertTokenizer, DistilBertTokenizerFast
from transformers.testing_utils import require_tokenizers, slow

from ..bert.test_tokenization_bert import BertTokenizationTest




@require_tokenizers
class        __A      ( UpperCamelCase__	):
    a__       :						Optional[Any]          =  DistilBertTokenizer
    a__       :						Any          =  DistilBertTokenizerFast
    a__       :						str          =  True



    @slow
    def 					_lowercase						(self    :    int ):
         UpperCAmelCase_           =   DistilBertTokenizer.from_pretrained("distilbert-base-uncased" )

         UpperCAmelCase_           =   tokenizer.encode("sequence builders"   ,			add_special_tokens=__a )
         UpperCAmelCase_           =   tokenizer.encode("multi-sequence build"   ,			add_special_tokens=__a )

         UpperCAmelCase_           =   tokenizer.build_inputs_with_special_tokens(__a )
         UpperCAmelCase_           =   tokenizer.build_inputs_with_special_tokens(__a   ,			__a )

         assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]
         assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [
             tokenizer.sep_token_id
         ]




