




"""simple docstring"""



import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin




class      UpperCAmelCase_  (						a__							):
    lowercase__						 =				None
    lowercase__						 =				None




    @property
    def 							__magic_name__							(   self						:	int				)				->							Tuple:




     '''simple docstring'''

     return self.feat_extract_tester.prepare_feat_extract_dict()




    def 							__magic_name__							(   self						:	Any				)				->							Any:




     '''simple docstring'''

     A__	=    self.feature_extraction_class(**self.feat_extract_dict				)
     self.assertTrue(hasattr(_lowerCamelCase     ,			"feature_size"				)				)
     self.assertTrue(hasattr(_lowerCamelCase     ,			"sampling_rate"				)				)
     self.assertTrue(hasattr(_lowerCamelCase     ,			"padding_value"				)				)




    def 							__magic_name__							(   self						:	Dict				)				->							List[str]:




     '''simple docstring'''

     A__	=    self.feat_extract_tester.prepare_inputs_for_common()
     A__	=    self.feature_extraction_class(**self.feat_extract_dict				)
     A__	=    feat_extract.model_input_names[0]

     A__	=    BatchFeature({input_name: speech_inputs}				)

     self.assertTrue(all(len(_lowerCamelCase				) == len(_lowerCamelCase				) for x, y in zip(_lowerCamelCase     ,			processed_features[input_name]				)				)				)

     A__	=    self.feat_extract_tester.prepare_inputs_for_common(equal_length=_lowerCamelCase				)
     A__	=    BatchFeature({input_name: speech_inputs}     ,			tensor_type="np"				)

     A__	=    processed_features[input_name]

     if len(batch_features_input.shape				) < 3:
      A__	=    batch_features_input[:, :, None]

     self.assertTrue(
         batch_features_input.shape
         == (self.feat_extract_tester.batch_size, len(speech_inputs[0]				), self.feat_extract_tester.feature_size)				)




    @require_torch
    def 							__magic_name__							(   self						:	Any				)				->							Tuple:




     '''simple docstring'''

     A__	=    self.feat_extract_tester.prepare_inputs_for_common(equal_length=_lowerCamelCase				)
     A__	=    self.feature_extraction_class(**self.feat_extract_dict				)
     A__	=    feat_extract.model_input_names[0]

     A__	=    BatchFeature({input_name: speech_inputs}     ,			tensor_type="pt"				)

     A__	=    processed_features[input_name]

     if len(batch_features_input.shape				) < 3:
      A__	=    batch_features_input[:, :, None]

     self.assertTrue(
         batch_features_input.shape
         == (self.feat_extract_tester.batch_size, len(speech_inputs[0]				), self.feat_extract_tester.feature_size)				)




    @require_tf
    def 							__magic_name__							(   self						:	List[Any]				)				->							List[str]:




     '''simple docstring'''

     A__	=    self.feat_extract_tester.prepare_inputs_for_common(equal_length=_lowerCamelCase				)
     A__	=    self.feature_extraction_class(**self.feat_extract_dict				)
     A__	=    feat_extract.model_input_names[0]

     A__	=    BatchFeature({input_name: speech_inputs}     ,			tensor_type="tf"				)

     A__	=    processed_features[input_name]

     if len(batch_features_input.shape				) < 3:
      A__	=    batch_features_input[:, :, None]

     self.assertTrue(
         batch_features_input.shape
         == (self.feat_extract_tester.batch_size, len(speech_inputs[0]				), self.feat_extract_tester.feature_size)				)




    def 							__magic_name__							(   self						:	Union[str, Any]     ,			snake_case_						:	Dict=False				)				->							Optional[Any]:




     '''simple docstring'''

     def _inputs_have_equal_length(snake_case_						:	str				):
      A__	=    len(input[0]				)
      for input_slice in input[1:]:
       if len(_lowerCamelCase				) != length:
        return False
      return True

     def _inputs_are_equal(snake_case_						:	str     ,			snake_case_						:	Tuple				):
      if len(_lowerCamelCase				) != len(_lowerCamelCase				):
       return False

      for input_slice_a, input_slice_a in zip(_lowerCamelCase     ,			_lowerCamelCase				):
       if not np.allclose(np.asarray(_lowerCamelCase				)     ,			np.asarray(_lowerCamelCase				)     ,			atol=1e-3				):
        return False
      return True

     A__	=    self.feature_extraction_class(**self.feat_extract_dict				)
     A__	=    self.feat_extract_tester.prepare_inputs_for_common(numpify=_lowerCamelCase				)
     A__	=    feat_extract.model_input_names[0]

     A__	=    BatchFeature({input_name: speech_inputs}				)

     A__	=    self.feat_extract_tester.seq_length_diff
     A__	=    self.feat_extract_tester.max_seq_length + pad_diff
     A__	=    self.feat_extract_tester.min_seq_length
     A__	=    self.feat_extract_tester.batch_size
     A__	=    self.feat_extract_tester.feature_size

     # test padding for List[int] + numpy
     A__	=    feat_extract.pad(_lowerCamelCase     ,			padding=_lowerCamelCase				)
     A__	=    input_a[input_name]

     A__	=    feat_extract.pad(_lowerCamelCase     ,			padding="longest"				)
     A__	=    input_a[input_name]

     A__	=    feat_extract.pad(_lowerCamelCase     ,			padding="max_length"     ,			max_length=len(speech_inputs[-1]				)				)
     A__	=    input_a[input_name]

     A__	=    feat_extract.pad(_lowerCamelCase     ,			padding="longest"     ,			return_tensors="np"				)
     A__	=    input_a[input_name]

     # max_length parameter has to be provided when setting `padding="max_length"`
     with self.assertRaises(_lowerCamelCase				):
      feat_extract.pad(_lowerCamelCase     ,			padding="max_length"				)[input_name]

     A__	=    feat_extract.pad(
         _lowerCamelCase     ,			padding="max_length"     ,			max_length=_lowerCamelCase     ,			return_tensors="np"				)
     A__	=    input_a[input_name]

     self.assertFalse(_inputs_have_equal_length(_lowerCamelCase				)				)
     self.assertTrue(_inputs_have_equal_length(_lowerCamelCase				)				)
     self.assertTrue(_inputs_have_equal_length(_lowerCamelCase				)				)
     self.assertTrue(_inputs_are_equal(_lowerCamelCase     ,			_lowerCamelCase				)				)
     self.assertTrue(len(input_a[0]				) == pad_min_length				)
     self.assertTrue(len(input_a[1]				) == pad_min_length + pad_diff				)
     self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]				))				)
     self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)				)

     if feature_size > 1:
      self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size				)

     # test padding for `pad_to_multiple_of` for List[int] + numpy
     A__	=    feat_extract.pad(_lowerCamelCase     ,			pad_to_multiple_of=10				)
     A__	=    input_a[input_name]

     A__	=    feat_extract.pad(_lowerCamelCase     ,			padding="longest"     ,			pad_to_multiple_of=10				)
     A__	=    input_a[input_name]

     A__	=    feat_extract.pad(
         _lowerCamelCase     ,			padding="max_length"     ,			pad_to_multiple_of=10     ,			max_length=_lowerCamelCase				)
     A__	=    input_a[input_name]

     A__	=    feat_extract.pad(
         _lowerCamelCase     ,			padding="max_length"     ,			pad_to_multiple_of=10     ,			max_length=_lowerCamelCase     ,			return_tensors="np"     ,			)
     A__	=    input_a[input_name]

     self.assertTrue(all(len(_lowerCamelCase				) % 10 == 0 for x in input_a				)				)
     self.assertTrue(_inputs_are_equal(_lowerCamelCase     ,			_lowerCamelCase				)				)

     A__	=    pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
     self.assertTrue(all(len(_lowerCamelCase				) == expected_mult_pad_length for x in input_a				)				)
     self.assertEqual(input_a.shape[:2]     ,			(batch_size, expected_mult_pad_length)				)

     if feature_size > 1:
      self.assertTrue(input_a.shape[2] == feature_size				)

     # Check padding value is correct
     A__	=    (np.ones(self.feat_extract_tester.feature_size				) * feat_extract.padding_value).sum()
     self.assertTrue(
         abs(np.asarray(input_a[0]				)[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)				)
         < 1e-3				)
     self.assertTrue(
         abs(
             np.asarray(input_a[1]				)[pad_min_length + pad_diff :].sum()
             - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)				)
         < 1e-3				)
     self.assertTrue(
         abs(
             np.asarray(input_a[2]				)[pad_min_length + 2 * pad_diff :].sum()
             - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)				)
         < 1e-3				)
     self.assertTrue(
         abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)				) < 1e-3				)
     self.assertTrue(
         abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)				)
         < 1e-3				)




    def 							__magic_name__							(   self						:	Any     ,			snake_case_						:	str=False				)				->							Tuple:




     '''simple docstring'''

     def _inputs_have_equal_length(snake_case_						:	str				):
      A__	=    len(input[0]				)
      for input_slice in input[1:]:
       if len(_lowerCamelCase				) != length:
        return False
      return True

     def _inputs_are_equal(snake_case_						:	Tuple     ,			snake_case_						:	int				):
      if len(_lowerCamelCase				) != len(_lowerCamelCase				):
       return False

      for input_slice_a, input_slice_a in zip(_lowerCamelCase     ,			_lowerCamelCase				):
       if not np.allclose(np.asarray(_lowerCamelCase				)     ,			np.asarray(_lowerCamelCase				)     ,			atol=1e-3				):
        return False
      return True

     A__	=    self.feature_extraction_class(**self.feat_extract_dict				)
     A__	=    self.feat_extract_tester.prepare_inputs_for_common(numpify=_lowerCamelCase				)
     A__	=    feat_extract.model_input_names[0]

     A__	=    BatchFeature({input_name: speech_inputs}				)

     # truncate to smallest
     A__	=    feat_extract.pad(
         _lowerCamelCase     ,			padding="max_length"     ,			max_length=len(speech_inputs[0]				)     ,			truncation=_lowerCamelCase				)
     A__	=    input_a[input_name]

     A__	=    feat_extract.pad(_lowerCamelCase     ,			padding="max_length"     ,			max_length=len(speech_inputs[0]				)				)
     A__	=    input_a[input_name]

     self.assertTrue(_inputs_have_equal_length(_lowerCamelCase				)				)
     self.assertFalse(_inputs_have_equal_length(_lowerCamelCase				)				)

     # truncate to smallest with np
     A__	=    feat_extract.pad(
         _lowerCamelCase     ,			padding="max_length"     ,			max_length=len(speech_inputs[0]				)     ,			return_tensors="np"     ,			truncation=_lowerCamelCase     ,			)
     A__	=    input_a[input_name]

     A__	=    feat_extract.pad(
         _lowerCamelCase     ,			padding="max_length"     ,			max_length=len(speech_inputs[0]				)     ,			return_tensors="np"				)
     A__	=    input_a[input_name]

     self.assertTrue(_inputs_have_equal_length(_lowerCamelCase				)				)
     self.assertTrue(input_a.shape[1] == len(speech_inputs[0]				)				)

     # since truncation forces padding to be smaller than longest input
     # function can't return `np.ndarray`, but has to return list
     self.assertFalse(_inputs_have_equal_length(_lowerCamelCase				)				)

     # truncate to middle
     A__	=    feat_extract.pad(
         _lowerCamelCase     ,			padding="max_length"     ,			max_length=len(speech_inputs[1]				)     ,			truncation=_lowerCamelCase     ,			return_tensors="np"     ,			)
     A__	=    input_a[input_name]

     A__	=    feat_extract.pad(
         _lowerCamelCase     ,			padding="max_length"     ,			max_length=len(speech_inputs[1]				)     ,			truncation=_lowerCamelCase				)
     A__	=    input_a[input_name]

     A__	=    feat_extract.pad(
         _lowerCamelCase     ,			padding="max_length"     ,			max_length=len(speech_inputs[1]				)     ,			return_tensors="np"				)
     A__	=    input_a[input_name]

     self.assertTrue(input_a.shape[1] == len(speech_inputs[1]				)				)
     self.assertTrue(_inputs_have_equal_length(_lowerCamelCase				)				)
     self.assertTrue(_inputs_have_equal_length(_lowerCamelCase				)				)
     self.assertTrue(_inputs_are_equal(_lowerCamelCase     ,			_lowerCamelCase				)				)

     # since truncation forces padding to be smaller than longest input
     # function can't return `np.ndarray`, but has to return list
     self.assertFalse(_inputs_have_equal_length(_lowerCamelCase				)				)
     self.assertTrue(len(input_a[-1]				) == len(speech_inputs[-1]				)				)

     # padding has to be max_length when setting `truncation=True`
     with self.assertRaises(_lowerCamelCase				):
      feat_extract.pad(_lowerCamelCase     ,			truncation=_lowerCamelCase				)[input_name]

     # padding has to be max_length when setting `truncation=True`
     with self.assertRaises(_lowerCamelCase				):
      feat_extract.pad(_lowerCamelCase     ,			padding="longest"     ,			truncation=_lowerCamelCase				)[input_name]

     # padding has to be max_length when setting `truncation=True`
     with self.assertRaises(_lowerCamelCase				):
      feat_extract.pad(_lowerCamelCase     ,			padding="longest"     ,			truncation=_lowerCamelCase				)[input_name]

     # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
     with self.assertRaises(_lowerCamelCase				):
      feat_extract.pad(_lowerCamelCase     ,			padding="max_length"     ,			truncation=_lowerCamelCase				)[input_name]

     # test truncation for `pad_to_multiple_of` for List[int] + numpy
     A__	=    12
     A__	=    feat_extract.pad(
         _lowerCamelCase     ,			padding="max_length"     ,			max_length=len(speech_inputs[0]				)     ,			pad_to_multiple_of=_lowerCamelCase     ,			truncation=_lowerCamelCase     ,			)
     A__	=    input_a[input_name]

     A__	=    feat_extract.pad(
         _lowerCamelCase     ,			padding="max_length"     ,			max_length=len(speech_inputs[0]				)     ,			pad_to_multiple_of=_lowerCamelCase     ,			)
     A__	=    input_a[input_name]

     # retrieve expected_length as multiple of pad_to_multiple_of
     A__	=    len(speech_inputs[0]				)
     if expected_length % pad_to_multiple_of != 0:
      A__	=    ((len(speech_inputs[0]				) // pad_to_multiple_of) + 1) * pad_to_multiple_of

     self.assertTrue(len(input_a[0]				) == expected_length				)
     self.assertTrue(_inputs_have_equal_length(_lowerCamelCase				)				)
     self.assertFalse(_inputs_have_equal_length(_lowerCamelCase				)				)




    def 							__magic_name__							(   self						:	Optional[int]				)				->							List[str]:




     '''simple docstring'''

     self._check_padding(numpify=_lowerCamelCase				)




    def 							__magic_name__							(   self						:	str				)				->							Dict:




     '''simple docstring'''

     self._check_padding(numpify=_lowerCamelCase				)




    def 							__magic_name__							(   self						:	str				)				->							Union[str, Any]:




     '''simple docstring'''

     self._check_truncation(numpify=_lowerCamelCase				)




    def 							__magic_name__							(   self						:	Tuple				)				->							str:




     '''simple docstring'''

     self._check_truncation(numpify=_lowerCamelCase				)




    @require_torch
    def 							__magic_name__							(   self						:	List[Any]				)				->							Tuple:




     '''simple docstring'''

     A__	=    self.feature_extraction_class(**self.feat_extract_dict				)
     A__	=    self.feat_extract_tester.prepare_inputs_for_common()
     A__	=    feat_extract.model_input_names[0]

     A__	=    BatchFeature({input_name: speech_inputs}				)

     A__	=    feat_extract.pad(_lowerCamelCase     ,			padding="longest"     ,			return_tensors="np"				)[input_name]
     A__	=    feat_extract.pad(_lowerCamelCase     ,			padding="longest"     ,			return_tensors="pt"				)[input_name]

     self.assertTrue(abs(input_np.astype(np.floataa				).sum() - input_pt.numpy().astype(np.floataa				).sum()				) < 1e-2				)




    @require_tf
    def 							__magic_name__							(   self						:	Optional[int]				)				->							str:




     '''simple docstring'''

     A__	=    self.feature_extraction_class(**self.feat_extract_dict				)
     A__	=    self.feat_extract_tester.prepare_inputs_for_common()
     A__	=    feat_extract.model_input_names[0]

     A__	=    BatchFeature({input_name: speech_inputs}				)

     A__	=    feat_extract.pad(_lowerCamelCase     ,			padding="longest"     ,			return_tensors="np"				)[input_name]
     A__	=    feat_extract.pad(_lowerCamelCase     ,			padding="longest"     ,			return_tensors="tf"				)[input_name]

     self.assertTrue(abs(input_np.astype(np.floataa				).sum() - input_tf.numpy().astype(np.floataa				).sum()				) < 1e-2				)




    def 							__magic_name__							(   self						:	int				)				->							Any:




     '''simple docstring'''

     A__	=    self.feat_extract_dict
     A__	=    True
     A__	=    self.feature_extraction_class(**_lowerCamelCase				)
     A__	=    self.feat_extract_tester.prepare_inputs_for_common()
     A__	=    [len(_lowerCamelCase				) for x in speech_inputs]
     A__	=    feat_extract.model_input_names[0]

     A__	=    BatchFeature({input_name: speech_inputs}				)

     A__	=    feat_extract.pad(_lowerCamelCase     ,			padding="longest"     ,			return_tensors="np"				)
     self.assertIn("attention_mask"     ,			_lowerCamelCase				)
     self.assertListEqual(list(processed.attention_mask.shape				)     ,			list(processed[input_name].shape[:2]				)				)
     self.assertListEqual(processed.attention_mask.sum(-1				).tolist()     ,			_lowerCamelCase				)




    def 							__magic_name__							(   self						:	Dict				)				->							Tuple:




     '''simple docstring'''

     A__	=    self.feat_extract_dict
     A__	=    True
     A__	=    self.feature_extraction_class(**_lowerCamelCase				)
     A__	=    self.feat_extract_tester.prepare_inputs_for_common()
     A__	=    [len(_lowerCamelCase				) for x in speech_inputs]
     A__	=    feat_extract.model_input_names[0]

     A__	=    BatchFeature({input_name: speech_inputs}				)
     A__	=    min(_lowerCamelCase				)

     A__	=    feat_extract.pad(
         _lowerCamelCase     ,			padding="max_length"     ,			max_length=_lowerCamelCase     ,			truncation=_lowerCamelCase     ,			return_tensors="np"				)
     self.assertIn("attention_mask"     ,			_lowerCamelCase				)
     self.assertListEqual(
         list(processed_pad.attention_mask.shape				)     ,			[processed_pad[input_name].shape[0], max_length]				)
     self.assertListEqual(
         processed_pad.attention_mask[:, :max_length].sum(-1				).tolist()     ,			[max_length for x in speech_inputs]				)






"""simple docstring"""



# Copyright 2022 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
import platform

import numpy as np
import psutil
import torch

from accelerate import __version__ as version
from accelerate.commands.config import default_config_file, load_config_from_file

from ..utils import is_npu_available, is_xpu_available







def   _SCREAMING_SNAKE_CASE       (							lowercase_=None						)						->		Any:
 if subparsers is not None:
  A__	=    subparsers.add_parser("env"						)
 else:
  A__	=    argparse.ArgumentParser("Accelerate env command"						)

 parser.add_argument(
     "--config_file"      ,			default=lowercase_      ,			help="The config file to use for the default values in the launching script."						)

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







def   _SCREAMING_SNAKE_CASE       (							lowercase_						)						->		Dict:
 A__	=    torch.__version__
 A__	=    torch.cuda.is_available()
 A__	=    is_xpu_available()
 A__	=    is_npu_available()

 A__	=    "Not found"
 # Get the default from the config file.
 if args.config_file is not None or os.path.isfile(lowercase_						):
  A__	=    load_config_from_file(args.config_file						).to_dict()

 A__	=    {
     "`Accelerate` version": version,
     "Platform": platform.platform(),
     "Python version": platform.python_version(),
     "Numpy version": np.__version__,
     "PyTorch version (GPU?)": f"""{pt_version} ({pt_cuda_available})""",
     "PyTorch XPU available": str(lowercase_						),
     "PyTorch NPU available": str(lowercase_						),
     "System RAM": f"""{psutil.virtual_memory().total / 10_24 ** 3:.2f} GB""",
 }
 if pt_cuda_available:
  A__	=    torch.cuda.get_device_name()

 print("\nCopy-and-paste the text below in your GitHub issue\n"						)
 print("\n".join([f"""- {prop}: {val}""" for prop, val in info.items()]						)						)

 print("- `Accelerate` default config:" if args.config_file is None else "- `Accelerate` config passed:"						)
 A__	=    (
     "\n".join([f"""\t- {prop}: {val}""" for prop, val in accelerate_config.items()]						)
     if isinstance(lowercase_      ,			lowercase_						)
     else f"""\t{accelerate_config}"""
 )
 print(lowercase_						)

 A__	=    accelerate_config

 return info







def   _SCREAMING_SNAKE_CASE       (							)						->		int:
 A__	=    env_command_parser()
 A__	=    parser.parse_args()
 env_command(lowercase_						)
 return 0


if __name__ == "__main__":
      raise SystemExit(main())





