



from __future__ import annotations

import copy
import inspect
import json
import math
import os
import tempfile
import unittest
from importlib import import_module

import numpy as np

from transformers import ViTMAEConfig
from transformers.file_utils import cached_property, is_tf_available, is_vision_available
from transformers.testing_utils import require_tf, require_vision, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers import TFViTMAEForPreTraining, TFViTMAEModel


if is_vision_available():
    from PIL import Image

    from transformers import ViTImageProcessor





class 		UpperCAmelCase						:





   def __init__(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase=13       ,     _lowerCAmelCase=30       ,     _lowerCAmelCase=2       ,     _lowerCAmelCase=3       ,     _lowerCAmelCase=True       ,     _lowerCAmelCase=True       ,     _lowerCAmelCase=32       ,     _lowerCAmelCase=2       ,     _lowerCAmelCase=4       ,     _lowerCAmelCase=37       ,     _lowerCAmelCase="gelu"       ,     _lowerCAmelCase=0.1       ,     _lowerCAmelCase=0.1       ,     _lowerCAmelCase=10       ,     _lowerCAmelCase=0.02       ,     _lowerCAmelCase=3       ,     _lowerCAmelCase=0.6       ,     _lowerCAmelCase=None       ,     ):
         _lowerCAmelCase 			=  parent
         _lowerCAmelCase 			=  batch_size
         _lowerCAmelCase 			=  image_size
         _lowerCAmelCase 			=  patch_size
         _lowerCAmelCase 			=  num_channels
         _lowerCAmelCase 			=  is_training
         _lowerCAmelCase 			=  use_labels
         _lowerCAmelCase 			=  hidden_size
         _lowerCAmelCase 			=  num_hidden_layers
         _lowerCAmelCase 			=  num_attention_heads
         _lowerCAmelCase 			=  intermediate_size
         _lowerCAmelCase 			=  hidden_act
         _lowerCAmelCase 			=  hidden_dropout_prob
         _lowerCAmelCase 			=  attention_probs_dropout_prob
         _lowerCAmelCase 			=  type_sequence_label_size
         _lowerCAmelCase 			=  initializer_range
         _lowerCAmelCase 			=  mask_ratio
         _lowerCAmelCase 			=  scope

         # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
         # (we add 1 for the [CLS] token)
         _lowerCAmelCase 			=  (image_size // patch_size) ** 2
         _lowerCAmelCase 			=  int(math.ceil((1 - mask_ratio) * (num_patches + 1)			)			)





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

         _lowerCAmelCase 			=  None
         if self.use_labels:
               _lowerCAmelCase 			=  ids_tensor([self.batch_size]       ,     self.type_sequence_label_size			)

         _lowerCAmelCase 			=  self.get_config()

         return config, pixel_values, labels





   def 	__lowerCAmelCase							(	self			):
         return ViTMAEConfig(
             image_size=self.image_size       ,     patch_size=self.patch_size       ,     num_channels=self.num_channels       ,     hidden_size=self.hidden_size       ,     num_hidden_layers=self.num_hidden_layers       ,     num_attention_heads=self.num_attention_heads       ,     intermediate_size=self.intermediate_size       ,     decoder_hidden_size=self.hidden_size       ,     decoder_num_hidden_layers=self.num_hidden_layers       ,     decoder_num_attention_heads=self.num_attention_heads       ,     decoder_intermediate_size=self.intermediate_size       ,     hidden_act=self.hidden_act       ,     hidden_dropout_prob=self.hidden_dropout_prob       ,     attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,     is_decoder=_lowerCAmelCase       ,     initializer_range=self.initializer_range       ,     mask_ratio=self.mask_ratio       ,     )





   def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase       ,     _lowerCAmelCase			):
         _lowerCAmelCase 			=  TFViTMAEModel(config=_lowerCAmelCase			)
         _lowerCAmelCase 			=  model(_lowerCAmelCase       ,     training=_lowerCAmelCase			)
         self.parent.assertEqual(result.last_hidden_state.shape       ,     (self.batch_size, self.seq_length, self.hidden_size)			)





   def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase       ,     _lowerCAmelCase			):
         _lowerCAmelCase 			=  TFViTMAEForPreTraining(_lowerCAmelCase			)
         _lowerCAmelCase 			=  model(_lowerCAmelCase       ,     training=_lowerCAmelCase			)
         # expected sequence length = num_patches
         _lowerCAmelCase 			=  (self.image_size // self.patch_size) ** 2
         _lowerCAmelCase 			=  self.patch_size**2 * self.num_channels
         self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, num_patches, expected_num_channels)			)

         # test greyscale images
         _lowerCAmelCase 			=  1
         _lowerCAmelCase 			=  TFViTMAEForPreTraining(_lowerCAmelCase			)

         _lowerCAmelCase 			=  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
         _lowerCAmelCase 			=  model(_lowerCAmelCase       ,     training=_lowerCAmelCase			)
         _lowerCAmelCase 			=  self.patch_size**2
         self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, num_patches, expected_num_channels)			)





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  self.prepare_config_and_inputs()
         ((_lowerCAmelCase)			,   (_lowerCAmelCase)			,   (_lowerCAmelCase)) 			=  config_and_inputs
         _lowerCAmelCase 			=  {'''pixel_values''': pixel_values}
         return config, inputs_dict






@require_tf
class 		UpperCAmelCase						(						snake_case_       ,snake_case_       ,unittest.TestCase				):
   SCREAMING_SNAKE_CASE__							=     (TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
   SCREAMING_SNAKE_CASE__							=     {'''feature-extraction''': TFViTMAEModel} if is_tf_available() else {}

   SCREAMING_SNAKE_CASE__							=     False
   SCREAMING_SNAKE_CASE__							=     False
   SCREAMING_SNAKE_CASE__							=     False
   SCREAMING_SNAKE_CASE__							=     False





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  TFViTMAEModelTester(self			)
         _lowerCAmelCase 			=  ConfigTester(self       ,     config_class=_lowerCAmelCase       ,     has_text_modality=_lowerCAmelCase       ,     hidden_size=37			)





   def 	__lowerCAmelCase							(	self			):
         self.config_tester.run_common_tests()





   @unittest.skip(reason='''ViTMAE does not use inputs_embeds'''			)
   def 	__lowerCAmelCase							(	self			):
         pass





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
               _lowerCAmelCase 			=  model_class(_lowerCAmelCase			)
               self.assertIsInstance(model.get_input_embeddings()       ,     (tf.keras.layers.Layer)			)
               _lowerCAmelCase 			=  model.get_output_embeddings()
               self.assertTrue(x is None or isinstance(_lowerCAmelCase       ,     tf.keras.layers.Layer			)			)





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
               _lowerCAmelCase 			=  model_class(_lowerCAmelCase			)
               _lowerCAmelCase 			=  inspect.signature(model.call			)
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               _lowerCAmelCase 			=  [*signature.parameters.keys()]

               _lowerCAmelCase 			=  ['''pixel_values''']
               self.assertListEqual(arg_names[:1]       ,     _lowerCAmelCase			)





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_lowerCAmelCase			)





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_pretraining(*_lowerCAmelCase			)





   def 	__lowerCAmelCase							(	self			):
         # make the mask reproducible
         np.random.seed(2			)

         _lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()

         _lowerCAmelCase 			=  int((config.image_size // config.patch_size) ** 2			)
         _lowerCAmelCase 			=  np.random.uniform(size=(self.model_tester.batch_size, num_patches)			)

         for model_class in self.all_model_classes:
               _lowerCAmelCase 			=  model_class(_lowerCAmelCase			)
               _lowerCAmelCase 			=  self._prepare_for_class(_lowerCAmelCase       ,     _lowerCAmelCase			)

               _lowerCAmelCase 			=  model(_lowerCAmelCase       ,     noise=_lowerCAmelCase			)

               _lowerCAmelCase 			=  copy.deepcopy(self._prepare_for_class(_lowerCAmelCase       ,     _lowerCAmelCase			)			)
               _lowerCAmelCase 			=  model(**_lowerCAmelCase       ,     noise=_lowerCAmelCase			)
               _lowerCAmelCase 			=  outputs_dict[0].numpy()
               _lowerCAmelCase 			=  outputs_keywords[0].numpy()

               self.assertLess(np.sum(np.abs(output_dict - output_keywords			)			)       ,     1E-6			)





   def 	__lowerCAmelCase							(	self			):
         # make the mask reproducible
         np.random.seed(2			)

         _lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()

         _lowerCAmelCase 			=  int((config.image_size // config.patch_size) ** 2			)
         _lowerCAmelCase 			=  np.random.uniform(size=(self.model_tester.batch_size, num_patches)			)

         def prepare_numpy_arrays(_lowerCAmelCase			):
               _lowerCAmelCase 			=  {}
               for k, v in inputs_dict.items():
                     if tf.is_tensor(_lowerCAmelCase			):
                           _lowerCAmelCase 			=  v.numpy()
                     else:
                           _lowerCAmelCase 			=  np.array(_lowerCAmelCase			)

               return inputs_np_dict

         for model_class in self.all_model_classes:
               _lowerCAmelCase 			=  model_class(_lowerCAmelCase			)

               _lowerCAmelCase 			=  self._prepare_for_class(_lowerCAmelCase       ,     _lowerCAmelCase			)
               _lowerCAmelCase 			=  prepare_numpy_arrays(_lowerCAmelCase			)

               _lowerCAmelCase 			=  model(_lowerCAmelCase       ,     noise=_lowerCAmelCase			)
               _lowerCAmelCase 			=  model(**_lowerCAmelCase       ,     noise=_lowerCAmelCase			)
               self.assert_outputs_same(_lowerCAmelCase       ,     _lowerCAmelCase			)





   def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase       ,     _lowerCAmelCase			):
         # make masks reproducible
         np.random.seed(2			)

         _lowerCAmelCase 			=  int((tf_model.config.image_size // tf_model.config.patch_size) ** 2			)
         _lowerCAmelCase 			=  np.random.uniform(size=(self.model_tester.batch_size, num_patches)			)
         _lowerCAmelCase 			=  tf.constant(_lowerCAmelCase			)

         # Add `noise` argument.
         # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
         _lowerCAmelCase 			=  tf_noise

         super().check_pt_tf_models(_lowerCAmelCase       ,     _lowerCAmelCase       ,     _lowerCAmelCase			)





   def 	__lowerCAmelCase							(	self			):
         # make mask reproducible
         np.random.seed(2			)

         _lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()

         _lowerCAmelCase 			=  {
             module_member
             for model_class in self.all_model_classes
             for module in (import_module(model_class.__module__			),)
             for module_member_name in dir(_lowerCAmelCase			)
             if module_member_name.endswith('''MainLayer'''			)
             # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`.
             and module_member_name[: -len('''MainLayer'''			)] == model_class.__name__[: -len('''Model'''			)]
             for module_member in (getattr(_lowerCAmelCase       ,     _lowerCAmelCase			),)
             if isinstance(_lowerCAmelCase       ,     _lowerCAmelCase			)
             and tf.keras.layers.Layer in module_member.__bases__
             and getattr(_lowerCAmelCase       ,     '''_keras_serializable'''       ,     _lowerCAmelCase			)
         }

         _lowerCAmelCase 			=  int((config.image_size // config.patch_size) ** 2			)
         _lowerCAmelCase 			=  np.random.uniform(size=(self.model_tester.batch_size, num_patches)			)
         _lowerCAmelCase 			=  tf.convert_to_tensor(_lowerCAmelCase			)
         inputs_dict.update({'''noise''': noise}			)

         for main_layer_class in tf_main_layer_classes:
               _lowerCAmelCase 			=  main_layer_class(_lowerCAmelCase			)

               _lowerCAmelCase 			=  {
                   name: tf.keras.Input(tensor.shape[1:]       ,     dtype=tensor.dtype			) for name, tensor in inputs_dict.items()
               }

               _lowerCAmelCase 			=  tf.keras.Model(_lowerCAmelCase       ,     outputs=main_layer(_lowerCAmelCase			)			)
               _lowerCAmelCase 			=  model(_lowerCAmelCase			)

               with tempfile.TemporaryDirectory() as tmpdirname:
                     _lowerCAmelCase 			=  os.path.join(_lowerCAmelCase       ,     '''keras_model.h5'''			)
                     model.save(_lowerCAmelCase			)
                     _lowerCAmelCase 			=  tf.keras.models.load_model(
                         _lowerCAmelCase       ,     custom_objects={main_layer_class.__name__: main_layer_class}			)
                     assert isinstance(_lowerCAmelCase       ,     tf.keras.Model			)
                     _lowerCAmelCase 			=  model(_lowerCAmelCase			)
                     self.assert_outputs_same(_lowerCAmelCase       ,     _lowerCAmelCase			)





   @slow
   def 	__lowerCAmelCase							(	self			):
         # make mask reproducible
         np.random.seed(2			)

         _lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()

         _lowerCAmelCase 			=  int((config.image_size // config.patch_size) ** 2			)
         _lowerCAmelCase 			=  np.random.uniform(size=(self.model_tester.batch_size, num_patches)			)

         for model_class in self.all_model_classes:
               _lowerCAmelCase 			=  model_class(_lowerCAmelCase			)
               _lowerCAmelCase 			=  self._prepare_for_class(_lowerCAmelCase       ,     _lowerCAmelCase			)
               _lowerCAmelCase 			=  model(_lowerCAmelCase       ,     noise=_lowerCAmelCase			)

               if model_class.__name__ == "TFViTMAEModel":
                     _lowerCAmelCase 			=  outputs.last_hidden_state.numpy()
                     _lowerCAmelCase 			=  0
               else:
                     _lowerCAmelCase 			=  outputs.logits.numpy()
                     _lowerCAmelCase 			=  0

               with tempfile.TemporaryDirectory() as tmpdirname:
                     model.save_pretrained(_lowerCAmelCase       ,     saved_model=_lowerCAmelCase			)
                     _lowerCAmelCase 			=  model_class.from_pretrained(_lowerCAmelCase			)
                     _lowerCAmelCase 			=  model(_lowerCAmelCase       ,     noise=_lowerCAmelCase			)

                     if model_class.__name__ == "TFViTMAEModel":
                           _lowerCAmelCase 			=  after_outputs['''last_hidden_state'''].numpy()
                           _lowerCAmelCase 			=  0
                     else:
                           _lowerCAmelCase 			=  after_outputs['''logits'''].numpy()
                           _lowerCAmelCase 			=  0

                     _lowerCAmelCase 			=  np.amax(np.abs(out_a - out_a			)			)
                     self.assertLessEqual(_lowerCAmelCase       ,     1E-5			)





   def 	__lowerCAmelCase							(	self			):
         # make mask reproducible
         np.random.seed(2			)

         _lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()

         _lowerCAmelCase 			=  int((config.image_size // config.patch_size) ** 2			)
         _lowerCAmelCase 			=  np.random.uniform(size=(self.model_tester.batch_size, num_patches)			)

         for model_class in self.all_model_classes:
               _lowerCAmelCase 			=  model_class(_lowerCAmelCase			)
               _lowerCAmelCase 			=  self._prepare_for_class(_lowerCAmelCase       ,     _lowerCAmelCase			)

               _lowerCAmelCase 			=  model(_lowerCAmelCase       ,     noise=_lowerCAmelCase			)
               _lowerCAmelCase 			=  model.get_config()
               # make sure that returned config is jsonifiable, which is required by keras
               json.dumps(_lowerCAmelCase			)
               _lowerCAmelCase 			=  model_class.from_config(model.get_config()			)
               # make sure it also accepts a normal config
               _lowerCAmelCase 			=  model_class.from_config(model.config			)
               _lowerCAmelCase 			=  new_model(_lowerCAmelCase			)  # Build model
               new_model.set_weights(model.get_weights()			)
               _lowerCAmelCase 			=  new_model(_lowerCAmelCase       ,     noise=_lowerCAmelCase			)

               self.assert_outputs_same(_lowerCAmelCase       ,     _lowerCAmelCase			)





   @unittest.skip(
       reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results.'''			)
   def 	__lowerCAmelCase							(	self			):
         pass





   @unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load'''			)
   def 	__lowerCAmelCase							(	self			):
         pass





   @slow
   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  TFViTMAEModel.from_pretrained('''google/vit-base-patch16-224'''			)
         self.assertIsNotNone(_lowerCAmelCase			)






def 							UpperCAmelCase__		(				)->Optional[Any]:
      _lowerCAmelCase 			=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
      return image





@require_tf
@require_vision
class 		UpperCAmelCase						(						unittest.TestCase				):





   @cached_property
   def 	__lowerCAmelCase							(	self			):
         return ViTImageProcessor.from_pretrained('''facebook/vit-mae-base'''			) if is_vision_available() else None





   @slow
   def 	__lowerCAmelCase							(	self			):
         # make random mask reproducible across the PT and TF model
         np.random.seed(2			)

         _lowerCAmelCase 			=  TFViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base'''			)

         _lowerCAmelCase 			=  self.default_image_processor
         _lowerCAmelCase 			=  prepare_img()
         _lowerCAmelCase 			=  image_processor(images=_lowerCAmelCase       ,     return_tensors='''tf'''			)

         # prepare a noise vector that will be also used for testing the TF model
         # (this way we can ensure that the PT and TF models operate on the same inputs)
         _lowerCAmelCase 			=  ViTMAEConfig()
         _lowerCAmelCase 			=  int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2			)
         _lowerCAmelCase 			=  np.random.uniform(size=(1, num_patches)			)

         # forward pass
         _lowerCAmelCase 			=  model(**_lowerCAmelCase       ,     noise=_lowerCAmelCase			)

         # verify the logits
         _lowerCAmelCase 			=  tf.convert_to_tensor([1, 196, 768]			)
         self.assertEqual(outputs.logits.shape       ,     _lowerCAmelCase			)

         _lowerCAmelCase 			=  tf.convert_to_tensor(
             [[-0.0_548, -1.7_023, -0.9_325], [0.3_721, -0.5_670, -0.2_233], [0.8_235, -1.3_878, -0.3_524]]			)

         tf.debugging.assert_near(outputs.logits[0, :3, :3]       ,     _lowerCAmelCase       ,     atol=1E-4			)




# 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


UpperCAmelCase_									=							"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 							UpperCAmelCase__		(				)->Any:
      _lowerCAmelCase 			=  _ask_options(
          '''In which compute environment are you running?'''     ,				['''This machine''', '''AWS (Amazon SageMaker)''']     ,				_convert_compute_environment     ,				)
      if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
            _lowerCAmelCase 			=  get_sagemaker_input()
      else:
            _lowerCAmelCase 			=  get_cluster_input()
      return config
def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	int=None				)->str:
      if subparsers is not None:
            _lowerCAmelCase 			=  subparsers.add_parser('''config'''     ,				description=_SCREAMING_SNAKE_CASE				)
      else:
            _lowerCAmelCase 			=  argparse.ArgumentParser('''Accelerate config command'''     ,				description=_SCREAMING_SNAKE_CASE				)

      parser.add_argument(
          '''--config_file'''     ,				default=_SCREAMING_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=_SCREAMING_SNAKE_CASE				)
      return parser
def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	Dict				)->str:
      _lowerCAmelCase 			=  get_user_input()
      if args.config_file is not None:
            _lowerCAmelCase 			=  args.config_file
      else:
            if not os.path.isdir(_SCREAMING_SNAKE_CASE				):
                  os.makedirs(_SCREAMING_SNAKE_CASE				)
            _lowerCAmelCase 			=  default_yaml_config_file

      if config_file.endswith('''.json'''				):
            config.to_json_file(_SCREAMING_SNAKE_CASE				)
      else:
            config.to_yaml_file(_SCREAMING_SNAKE_CASE				)
      print(f'''accelerate configuration saved at {config_file}'''				)
def 							UpperCAmelCase__		(				)->List[Any]:
      _lowerCAmelCase 			=  config_command_parser()
      _lowerCAmelCase 			=  parser.parse_args()
      config_command(_SCREAMING_SNAKE_CASE				)


if __name__ == "__main__":
    main()