'''simple docstring'''






import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
  import torch


SCREAMING_SNAKE_CASE_	   =			random.Random()






def  UpperCamelCase__					(					_lowercase    :				int   ,    _lowercase    :				Tuple=1.0   ,    _lowercase    :				Optional[Any]=None   ,    _lowercase    :				Any=None     )							->	Any:
  if rng is None:
    __UpperCAmelCase:					List[Any]		= global_rng

  __UpperCAmelCase:					List[str]		= []
  for batch_idx in range(shape[0]     ):
    values.append([]     )
    for _ in range(shape[1]     ):
      values[-1].append(rng.random() * scale     )

  return values




@require_torch
class    a (       unittest.TestCase				):



  """simple docstring"""







  def __init__(							self   ,    snake_case_   ,    snake_case_=7   ,    snake_case_=400   ,    snake_case_=2000   ,    snake_case_=1   ,    snake_case_=0.0   ,    snake_case_=1_6000   ,    snake_case_=True   ,    snake_case_=80   ,    snake_case_=16   ,    snake_case_=64   ,    snake_case_="hann_window"   ,    snake_case_=80   ,    snake_case_=7600   ,    snake_case_=1e-1_0   ,    snake_case_=True   ,    ):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[Any]		= parent
    __UpperCAmelCase:					List[str]		= batch_size
    __UpperCAmelCase:					Union[str, Any]		= min_seq_length
    __UpperCAmelCase:					str		= max_seq_length
    __UpperCAmelCase:					Union[str, Any]		= (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
    __UpperCAmelCase:					Dict		= feature_size
    __UpperCAmelCase:					str		= padding_value
    __UpperCAmelCase:					Optional[int]		= sampling_rate
    __UpperCAmelCase:					Union[str, Any]		= do_normalize
    __UpperCAmelCase:					int		= num_mel_bins
    __UpperCAmelCase:					List[Any]		= hop_length
    __UpperCAmelCase:					str		= win_length
    __UpperCAmelCase:					Dict		= win_function
    __UpperCAmelCase:					List[Any]		= fmin
    __UpperCAmelCase:					Optional[Any]		= fmax
    __UpperCAmelCase:					Any		= mel_floor
    __UpperCAmelCase:					List[Any]		= return_attention_mask







  def    lowercase_  (							self					):

    '''simple docstring'''







    return {
        "feature_size": self.feature_size,
        "padding_value": self.padding_value,
        "sampling_rate": self.sampling_rate,
        "do_normalize": self.do_normalize,
        "num_mel_bins": self.num_mel_bins,
        "hop_length": self.hop_length,
        "win_length": self.win_length,
        "win_function": self.win_function,
        "fmin": self.fmin,
        "fmax": self.fmax,
        "mel_floor": self.mel_floor,
        "return_attention_mask": self.return_attention_mask,
    }







  def    lowercase_  (							self   ,    snake_case_=False   ,    snake_case_=False					):

    '''simple docstring'''







    def _flatten(snake_case_					):
      return list(itertools.chain(*lowerCAmelCase_					)					)

    if equal_length:
      __UpperCAmelCase:					Optional[Any]		= floats_list((self.batch_size, self.max_seq_length)					)
    else:
      # make sure that inputs increase in size
      __UpperCAmelCase:					Optional[int]		= [
          _flatten(floats_list((x, self.feature_size)					)					)
          for x in range(self.min_seq_length   ,    self.max_seq_length   ,    self.seq_length_diff					)
      ]

    if numpify:
      __UpperCAmelCase:					Any		= [np.asarray(lowerCAmelCase_					) for x in speech_inputs]

    return speech_inputs







  def    lowercase_  (							self   ,    snake_case_=False   ,    snake_case_=False					):

    '''simple docstring'''







    if equal_length:
      __UpperCAmelCase:					Tuple		= [floats_list((self.max_seq_length, self.num_mel_bins)					) for _ in range(self.batch_size					)]
    else:
      # make sure that inputs increase in size
      __UpperCAmelCase:					Optional[int]		= [
          floats_list((x, self.num_mel_bins)					)
          for x in range(self.min_seq_length   ,    self.max_seq_length   ,    self.seq_length_diff					)
      ]

    if numpify:
      __UpperCAmelCase:					str		= [np.asarray(lowerCAmelCase_					) for x in speech_inputs]

    return speech_inputs




@require_torch
class    a (       __lowerCAmelCase						,  unittest.TestCase				):



  """simple docstring"""
  __lowerCAmelCase				      =					SpeechTaFeatureExtractor







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[int]		= SpeechTaFeatureExtractionTester(self					)







  def    lowercase_  (							self   ,    snake_case_					):

    '''simple docstring'''







    self.assertTrue(np.all(np.mean(lowerCAmelCase_   ,    axis=0					) < 1e-3					)					)
    self.assertTrue(np.all(np.abs(np.var(lowerCAmelCase_   ,    axis=0					) - 1					) < 1e-3					)					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					str		= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
    # create three inputs of length 800, 1000, and 1200
    __UpperCAmelCase:					Union[str, Any]		= [floats_list((1, x)					)[0] for x in range(800   ,    1400   ,    200					)]
    __UpperCAmelCase:					List[Any]		= [np.asarray(lowerCAmelCase_					) for speech_input in speech_inputs]

    # Test not batched input
    __UpperCAmelCase:					List[str]		= feat_extract(speech_inputs[0]   ,    return_tensors="""np"""					).input_values
    __UpperCAmelCase:					Union[str, Any]		= feat_extract(np_speech_inputs[0]   ,    return_tensors="""np"""					).input_values
    self.assertTrue(np.allclose(lowerCAmelCase_   ,    lowerCAmelCase_   ,    atol=1e-3					)					)

    # Test batched
    __UpperCAmelCase:					Optional[Any]		= feat_extract(lowerCAmelCase_   ,    return_tensors="""np"""					).input_values
    __UpperCAmelCase:					Optional[int]		= feat_extract(lowerCAmelCase_   ,    return_tensors="""np"""					).input_values
    for enc_seq_a, enc_seq_a in zip(lowerCAmelCase_   ,    lowerCAmelCase_					):
      self.assertTrue(np.allclose(lowerCAmelCase_   ,    lowerCAmelCase_   ,    atol=1e-3					)					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					int		= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
    __UpperCAmelCase:					Dict		= [floats_list((1, x)					)[0] for x in range(800   ,    1400   ,    200					)]

    __UpperCAmelCase:					Dict		= ["""longest""", """max_length""", """do_not_pad"""]
    __UpperCAmelCase:					Tuple		= [None, 1600, None]
    for max_length, padding in zip(lowerCAmelCase_   ,    lowerCAmelCase_					):
      __UpperCAmelCase:					Dict		= feat_extract(lowerCAmelCase_   ,    padding=lowerCAmelCase_   ,    max_length=lowerCAmelCase_   ,    return_tensors="""np"""					)
      __UpperCAmelCase:					Optional[int]		= processed.input_values

      self._check_zero_mean_unit_variance(input_values[0][:800]					)
      self.assertTrue(input_values[0][800:].sum() < 1e-6					)
      self._check_zero_mean_unit_variance(input_values[1][:1000]					)
      self.assertTrue(input_values[0][1000:].sum() < 1e-6					)
      self._check_zero_mean_unit_variance(input_values[2][:1200]					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Tuple		= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
    __UpperCAmelCase:					Tuple		= range(800   ,    1400   ,    200					)
    __UpperCAmelCase:					str		= [floats_list((1, x)					)[0] for x in lengths]

    __UpperCAmelCase:					Dict		= ["""longest""", """max_length""", """do_not_pad"""]
    __UpperCAmelCase:					List[Any]		= [None, 1600, None]

    for max_length, padding in zip(lowerCAmelCase_   ,    lowerCAmelCase_					):
      __UpperCAmelCase:					Dict		= feat_extract(lowerCAmelCase_   ,    max_length=lowerCAmelCase_   ,    padding=lowerCAmelCase_					)
      __UpperCAmelCase:					List[Any]		= processed.input_values

      self._check_zero_mean_unit_variance(input_values[0][:800]					)
      self._check_zero_mean_unit_variance(input_values[1][:1000]					)
      self._check_zero_mean_unit_variance(input_values[2][:1200]					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Dict		= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
    __UpperCAmelCase:					Tuple		= [floats_list((1, x)					)[0] for x in range(800   ,    1400   ,    200					)]
    __UpperCAmelCase:					Any		= feat_extract(
        lowerCAmelCase_   ,    truncation=lowerCAmelCase_   ,    max_length=1000   ,    padding="""max_length"""   ,    return_tensors="""np"""					)
    __UpperCAmelCase:					Optional[int]		= processed.input_values

    self._check_zero_mean_unit_variance(input_values[0, :800]					)
    self._check_zero_mean_unit_variance(input_values[1]					)
    self._check_zero_mean_unit_variance(input_values[2]					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Dict		= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
    __UpperCAmelCase:					Optional[Any]		= [floats_list((1, x)					)[0] for x in range(800   ,    1400   ,    200					)]
    __UpperCAmelCase:					List[str]		= feat_extract(
        lowerCAmelCase_   ,    truncation=lowerCAmelCase_   ,    max_length=1000   ,    padding="""longest"""   ,    return_tensors="""np"""					)
    __UpperCAmelCase:					Optional[Any]		= processed.input_values

    self._check_zero_mean_unit_variance(input_values[0, :800]					)
    self._check_zero_mean_unit_variance(input_values[1, :1000]					)
    self._check_zero_mean_unit_variance(input_values[2]					)

    # make sure that if max_length < longest -> then pad to max_length
    self.assertTrue(input_values.shape == (3, 1000)					)

    __UpperCAmelCase:					int		= [floats_list((1, x)					)[0] for x in range(800   ,    1400   ,    200					)]
    __UpperCAmelCase:					List[Any]		= feat_extract(
        lowerCAmelCase_   ,    truncation=lowerCAmelCase_   ,    max_length=2000   ,    padding="""longest"""   ,    return_tensors="""np"""					)
    __UpperCAmelCase:					str		= processed.input_values

    self._check_zero_mean_unit_variance(input_values[0, :800]					)
    self._check_zero_mean_unit_variance(input_values[1, :1000]					)
    self._check_zero_mean_unit_variance(input_values[2]					)

    # make sure that if max_length > longest -> then pad to longest
    self.assertTrue(input_values.shape == (3, 1200)					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					str		= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
    __UpperCAmelCase:					Optional[Any]		= np.random.rand(100					).astype(np.floataa					)
    __UpperCAmelCase:					int		= np_speech_inputs.tolist()

    for inputs in [py_speech_inputs, np_speech_inputs]:
      __UpperCAmelCase:					int		= feature_extractor.pad([{"""input_values""": inputs}]   ,    return_tensors="""np"""					)
      self.assertTrue(np_processed.input_values.dtype == np.floataa					)
      __UpperCAmelCase:					Any		= feature_extractor.pad([{"""input_values""": inputs}]   ,    return_tensors="""pt"""					)
      self.assertTrue(pt_processed.input_values.dtype == torch.floataa					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					int		= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
    # create three inputs of length 800, 1000, and 1200
    __UpperCAmelCase:					Optional[int]		= [floats_list((1, x)					)[0] for x in range(800   ,    1400   ,    200					)]
    __UpperCAmelCase:					List[Any]		= [np.asarray(lowerCAmelCase_					) for speech_input in speech_inputs]

    # Test feature size
    __UpperCAmelCase:					int		= feature_extractor(audio_target=lowerCAmelCase_   ,    padding=lowerCAmelCase_   ,    return_tensors="""np"""					).input_values
    self.assertTrue(input_values.ndim == 3					)
    self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins					)

    # Test not batched input
    __UpperCAmelCase:					List[Any]		= feature_extractor(speech_inputs[0]   ,    return_tensors="""np"""					).input_values
    __UpperCAmelCase:					List[Any]		= feature_extractor(np_speech_inputs[0]   ,    return_tensors="""np"""					).input_values
    self.assertTrue(np.allclose(lowerCAmelCase_   ,    lowerCAmelCase_   ,    atol=1e-3					)					)

    # Test batched
    __UpperCAmelCase:					Dict		= feature_extractor(lowerCAmelCase_   ,    return_tensors="""np"""					).input_values
    __UpperCAmelCase:					Union[str, Any]		= feature_extractor(lowerCAmelCase_   ,    return_tensors="""np"""					).input_values
    for enc_seq_a, enc_seq_a in zip(lowerCAmelCase_   ,    lowerCAmelCase_					):
      self.assertTrue(np.allclose(lowerCAmelCase_   ,    lowerCAmelCase_   ,    atol=1e-3					)					)

    # Test 2-D numpy arrays are batched.
    __UpperCAmelCase:					str		= [floats_list((1, x)					)[0] for x in (800, 800, 800)]
    __UpperCAmelCase:					Optional[int]		= np.asarray(lowerCAmelCase_					)
    __UpperCAmelCase:					Tuple		= feature_extractor(lowerCAmelCase_   ,    return_tensors="""np"""					).input_values
    __UpperCAmelCase:					int		= feature_extractor(lowerCAmelCase_   ,    return_tensors="""np"""					).input_values
    for enc_seq_a, enc_seq_a in zip(lowerCAmelCase_   ,    lowerCAmelCase_					):
      self.assertTrue(np.allclose(lowerCAmelCase_   ,    lowerCAmelCase_   ,    atol=1e-3					)					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					str		= self.feat_extract_tester.prepare_inputs_for_target()
    __UpperCAmelCase:					Tuple		= self.feature_extraction_class(**self.feat_extract_dict					)
    __UpperCAmelCase:					Any		= feat_extract.model_input_names[0]

    __UpperCAmelCase:					int		= BatchFeature({input_name: speech_inputs}					)

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

    __UpperCAmelCase:					Optional[Any]		= self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCAmelCase_					)
    __UpperCAmelCase:					List[str]		= BatchFeature({input_name: speech_inputs}   ,    tensor_type="""np"""					)

    __UpperCAmelCase:					List[Any]		= processed_features[input_name]

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

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







  @require_torch
  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					str		= self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCAmelCase_					)
    __UpperCAmelCase:					List[Any]		= self.feature_extraction_class(**self.feat_extract_dict					)
    __UpperCAmelCase:					Optional[Any]		= feat_extract.model_input_names[0]

    __UpperCAmelCase:					Optional[int]		= BatchFeature({input_name: speech_inputs}   ,    tensor_type="""pt"""					)

    __UpperCAmelCase:					Dict		= processed_features[input_name]

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

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







  @require_torch
  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Dict		= self.feature_extraction_class(**self.feat_extract_dict					)
    __UpperCAmelCase:					List[str]		= self.feat_extract_tester.prepare_inputs_for_target()
    __UpperCAmelCase:					Dict		= feat_extract.model_input_names[0]

    __UpperCAmelCase:					str		= BatchFeature({input_name: speech_inputs}					)

    __UpperCAmelCase:					List[str]		= feat_extract.num_mel_bins  # hack!

    __UpperCAmelCase:					Optional[Any]		= feat_extract.pad(lowerCAmelCase_   ,    padding="""longest"""   ,    return_tensors="""np"""					)[input_name]
    __UpperCAmelCase:					List[str]		= 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					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Any		= self.feat_extract_dict
    __UpperCAmelCase:					List[Any]		= True
    __UpperCAmelCase:					Union[str, Any]		= self.feature_extraction_class(**lowerCAmelCase_					)
    __UpperCAmelCase:					List[Any]		= self.feat_extract_tester.prepare_inputs_for_target()
    __UpperCAmelCase:					List[Any]		= [len(lowerCAmelCase_					) for x in speech_inputs]
    __UpperCAmelCase:					Tuple		= feat_extract.model_input_names[0]

    __UpperCAmelCase:					Any		= BatchFeature({input_name: speech_inputs}					)

    __UpperCAmelCase:					Dict		= feat_extract.num_mel_bins  # hack!

    __UpperCAmelCase:					str		= 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    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Tuple		= self.feat_extract_dict
    __UpperCAmelCase:					str		= True
    __UpperCAmelCase:					str		= self.feature_extraction_class(**lowerCAmelCase_					)
    __UpperCAmelCase:					int		= self.feat_extract_tester.prepare_inputs_for_target()
    __UpperCAmelCase:					List[str]		= [len(lowerCAmelCase_					) for x in speech_inputs]
    __UpperCAmelCase:					Optional[int]		= feat_extract.model_input_names[0]

    __UpperCAmelCase:					Optional[int]		= BatchFeature({input_name: speech_inputs}					)
    __UpperCAmelCase:					Dict		= min(lowerCAmelCase_					)

    __UpperCAmelCase:					str		= feat_extract.num_mel_bins  # hack!

    __UpperCAmelCase:					List[Any]		= 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]					)







  def    lowercase_  (							self   ,    snake_case_					):

    '''simple docstring'''







    from datasets import load_dataset

    __UpperCAmelCase:					Any		= load_dataset("""hf-internal-testing/librispeech_asr_dummy"""   ,    """clean"""   ,    split="""validation"""					)
    # automatic decoding with librispeech
    __UpperCAmelCase:					List[Any]		= ds.sort("""id"""					).select(range(lowerCAmelCase_					)					)[:num_samples]["""audio"""]

    return [x["array"] for x in speech_samples]







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Union[str, Any]		= torch.tensor(
        [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
         3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
         2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
         4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
         7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
         4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]					)
    # fmt: on

    __UpperCAmelCase:					Any		= self._load_datasamples(1					)
    __UpperCAmelCase:					Optional[Any]		= SpeechTaFeatureExtractor()
    __UpperCAmelCase:					int		= feature_extractor(lowerCAmelCase_   ,    return_tensors="""pt"""					).input_values
    self.assertEquals(input_values.shape   ,    (1, 9_3680)					)
    self.assertTrue(torch.allclose(input_values[0, :30]   ,    lowerCAmelCase_   ,    atol=1e-6					)					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					List[str]		= torch.tensor(
        [-2.6_8_7_0, -3.0_1_0_4, -3.1_3_5_6, -3.5_3_5_2, -3.0_0_4_4, -3.0_3_5_3, -3.4_7_1_9, -3.6_7_7_7,
         -3.1_5_2_0, -2.9_4_3_5, -2.6_5_5_3, -2.8_7_9_5, -2.9_9_4_4, -2.5_9_2_1, -3.0_2_7_9, -3.0_3_8_6,
         -3.0_8_6_4, -3.1_2_9_1, -3.2_3_5_3, -2.7_4_4_4, -2.6_8_3_1, -2.7_2_8_7, -3.1_7_6_1, -3.1_5_7_1,
         -3.2_7_2_6, -3.0_5_8_2, -3.1_0_0_7, -3.4_5_3_3, -3.4_6_9_5, -3.0_9_9_8]					)
    # fmt: on

    __UpperCAmelCase:					List[str]		= self._load_datasamples(1					)
    __UpperCAmelCase:					Optional[Any]		= SpeechTaFeatureExtractor()
    __UpperCAmelCase:					List[Any]		= feature_extractor(audio_target=lowerCAmelCase_   ,    return_tensors="""pt"""					).input_values
    self.assertEquals(input_values.shape   ,    (1, 366, 80)					)
    self.assertTrue(torch.allclose(input_values[0, 0, :30]   ,    lowerCAmelCase_   ,    atol=1e-4					)					)
'''simple docstring'''






from __future__ import annotations

SCREAMING_SNAKE_CASE_	   =			10






def  UpperCamelCase__					(					_lowercase    :				list[int]     )							->	list[int]:
  __UpperCAmelCase:					Union[str, Any]		= 1
  __UpperCAmelCase:					Optional[Any]		= max(_lowercase     )
  while placement <= max_digit:
    # declare and initialize empty buckets
    __UpperCAmelCase:					list[list]		= [[] for _ in range(_lowercase     )]
    # split list_of_ints between the buckets
    for i in list_of_ints:
      __UpperCAmelCase:					Optional[Any]		= int((i / placement) % RADIX     )
      buckets[tmp].append(_lowercase     )
    # put each buckets' contents into list_of_ints
    __UpperCAmelCase:					Optional[int]		= 0
    for b in range(_lowercase     ):
      for i in buckets[b]:
        __UpperCAmelCase:					str		= i
        a += 1
        # move to next
    placement *= RADIX
  return list_of_ints


if __name__ == "__main__":
    import doctest

    doctest.testmod()