



import itertools
import random
import unittest

import numpy as np

from transformers import EncodecFeatureExtractor
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


UpperCamelCase_									=   random.Random()







def       lowerCamelCase_  (    _a       :						Any   ,		_a       :						List[Any]=1.0   ,		_a       :						Tuple=None   ,		_a       :						Optional[int]=None    ):



    '''simple docstring'''




    if rng is None:
        UpperCAmelCase_     :       int  		=					global_rng

    UpperCAmelCase_     :       Tuple  		=					[]
    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       _snake_case				(     unittest.TestCase ):






   '''simple docstring'''






   def __init__(    self:     Optional[Any]  ,lowerCamelCase_:     str  ,lowerCamelCase_:     List[str]=7  ,lowerCamelCase_:     int=400  ,lowerCamelCase_:     Tuple=2000  ,lowerCamelCase_:     Optional[Any]=1  ,lowerCamelCase_:     Optional[int]=0.0  ,lowerCamelCase_:     Dict=24000  ,lowerCamelCase_:     Dict=True  ,)	->      Any:
       UpperCAmelCase_     :       List[str]  		=					parent
       UpperCAmelCase_     :       List[str]  		=					batch_size
       UpperCAmelCase_     :       List[str]  		=					min_seq_length
       UpperCAmelCase_     :       Optional[int]  		=					max_seq_length
       UpperCAmelCase_     :       int  		=					(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
       UpperCAmelCase_     :       int  		=					feature_size
       UpperCAmelCase_     :       List[str]  		=					padding_value
       UpperCAmelCase_     :       Optional[Any]  		=					sampling_rate
       UpperCAmelCase_     :       Optional[int]  		=					return_attention_mask


   def       A__    (    self:     Optional[int]							)	->      Optional[Any]:
       return {
           "feature_size": self.feature_size,
           "padding_value": self.padding_value,
           "sampling_rate": self.sampling_rate,
           "return_attention_mask": self.return_attention_mask,
       }






   def       A__    (    self:     List[Any]  ,lowerCamelCase_:     List[Any]=False  ,lowerCamelCase_:     Dict=False							)	->      List[str]:
       def _flatten(lowerCamelCase_:     Optional[int]							):
           return list(itertools.chain(*lowerCamelCase_							)							)

       if equal_length:
           UpperCAmelCase_     :       Optional[int]  		=					floats_list((self.batch_size, self.max_seq_length)							)
       else:
           # make sure that inputs increase in size
           UpperCAmelCase_     :       List[Any]  		=					[
               _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_     :       str  		=					[np.asarray(lowerCamelCase_							) for x in audio_inputs]

       return audio_inputs







@require_torch
class       _snake_case				(     __snake_case ,							unittest.TestCase ):






   '''simple docstring'''






   A__      : List[Any]       =						EncodecFeatureExtractor


   def       A__    (    self:     Union[str, Any]							)	->      Union[str, Any]:
       UpperCAmelCase_     :       List[str]  		=					EnCodecFeatureExtractionTester(self							)


   def       A__    (    self:     List[Any]							)	->      Dict:
       # Tests that all call wrap to encode_plus and batch_encode_plus
       UpperCAmelCase_     :       List[Any]  		=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
       # create three inputs of length 800, 1000, and 1200
       UpperCAmelCase_     :       str  		=					[floats_list((1, x)							)[0] for x in range(800  ,1400  ,200							)]
       UpperCAmelCase_     :       int  		=					[np.asarray(lowerCamelCase_							) for audio_input in audio_inputs]

       # Test not batched input
       UpperCAmelCase_     :       Union[str, Any]  		=					feat_extract(audio_inputs[0]  ,return_tensors="""np"""							).input_values
       UpperCAmelCase_     :       Dict  		=					feat_extract(np_audio_inputs[0]  ,return_tensors="""np"""							).input_values
       self.assertTrue(np.allclose(lowerCamelCase_  ,lowerCamelCase_  ,atol=1e-3							)							)

       # Test batched
       UpperCAmelCase_     :       Tuple  		=					feat_extract(lowerCamelCase_  ,padding=lowerCamelCase_  ,return_tensors="""np"""							).input_values
       UpperCAmelCase_     :       Any  		=					feat_extract(lowerCamelCase_  ,padding=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       A__    (    self:     str							)	->      List[str]:
       UpperCAmelCase_     :       Union[str, Any]  		=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
       UpperCAmelCase_     :       Union[str, Any]  		=					np.random.rand(100							).astype(np.floataa							)
       UpperCAmelCase_     :       Union[str, Any]  		=					np_audio_inputs.tolist()

       for inputs in [py_audio_inputs, np_audio_inputs]:
           UpperCAmelCase_     :       Dict  		=					feature_extractor.pad([{"""input_values""": inputs}]  ,return_tensors="""np"""							)
           self.assertTrue(np_processed.input_values.dtype == np.floataa							)
           UpperCAmelCase_     :       Dict  		=					feature_extractor.pad([{"""input_values""": inputs}]  ,return_tensors="""pt"""							)
           self.assertTrue(pt_processed.input_values.dtype == torch.floataa							)


   def       A__    (    self:     List[str]  ,lowerCamelCase_:     Union[str, Any]							)	->      Optional[Any]:
       from datasets import load_dataset

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

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


   def       A__    (    self:     Optional[int]							)	->      Union[str, Any]:
       # fmt: off
       UpperCAmelCase_     :       Dict  		=					torch.tensor(
           [2.3804e-03, 2.0752e-03, 1.9836e-03, 2.1057e-03, 1.6174e-03,
            3.0518e-04, 9.1553e-05, 3.3569e-04, 9.7656e-04, 1.8311e-03,
            2.0142e-03, 2.1057e-03, 1.7395e-03, 4.5776e-04, -3.9673e-04,
            4.5776e-04, 1.0071e-03, 9.1553e-05, 4.8828e-04, 1.1597e-03,
            7.3242e-04, 9.4604e-04, 1.8005e-03, 1.8311e-03, 8.8501e-04,
            4.2725e-04, 4.8828e-04, 7.3242e-04, 1.0986e-03, 2.1057e-03]							)
       # fmt: on
       UpperCAmelCase_     :       Optional[Any]  		=					self._load_datasamples(1							)
       UpperCAmelCase_     :       Union[str, Any]  		=					EncodecFeatureExtractor()
       UpperCAmelCase_     :       List[Any]  		=					feature_extractor(lowerCamelCase_  ,return_tensors="""pt"""							).input_values
       self.assertEquals(input_values.shape  ,(1, 1, 93680)							)
       self.assertTrue(torch.allclose(input_values[0, 0, :30]  ,lowerCamelCase_  ,atol=1e-6							)							)


   def       A__    (    self:     List[str]							)	->      Dict:
       # fmt: off
       UpperCAmelCase_     :       Optional[int]  		=					torch.tensor(
           [2.3804e-03, 2.0752e-03, 1.9836e-03, 2.1057e-03, 1.6174e-03,
            3.0518e-04, 9.1553e-05, 3.3569e-04, 9.7656e-04, 1.8311e-03,
            2.0142e-03, 2.1057e-03, 1.7395e-03, 4.5776e-04, -3.9673e-04,
            4.5776e-04, 1.0071e-03, 9.1553e-05, 4.8828e-04, 1.1597e-03,
            7.3242e-04, 9.4604e-04, 1.8005e-03, 1.8311e-03, 8.8501e-04,
            4.2725e-04, 4.8828e-04, 7.3242e-04, 1.0986e-03, 2.1057e-03]							)
       # fmt: on
       UpperCAmelCase_     :       Tuple  		=					self._load_datasamples(1							)
       UpperCAmelCase_     :       List[Any]  		=					[np.tile(input_audio[0][None]  ,reps=(2, 1)							)]
       input_audio[0][1] *= 0.5
       UpperCAmelCase_     :       int  		=					EncodecFeatureExtractor(feature_size=2							)
       UpperCAmelCase_     :       int  		=					feature_extractor(lowerCamelCase_  ,return_tensors="""pt"""							).input_values
       self.assertEquals(input_values.shape  ,(1, 2, 93680)							)
       self.assertTrue(torch.allclose(input_values[0, 0, :30]  ,lowerCamelCase_  ,atol=1e-6							)							)
       self.assertTrue(torch.allclose(input_values[0, 1, :30]  ,EXPECTED_INPUT_VALUES * 0.5  ,atol=1e-6							)							)






   def       A__    (    self:     Optional[int]							)	->      List[str]:
       UpperCAmelCase_     :       Dict  		=					self._load_datasamples(2							)
       # would be easier if the stride was like
       UpperCAmelCase_     :       Any  		=					EncodecFeatureExtractor(feature_size=1  ,chunk_length_s=1  ,overlap=0.0_1							)

       # pad and trunc raise an error ?
       with self.assertRaisesRegex(
           lowerCamelCase_  ,"""^Both padding and truncation were set. Make sure you only set one.$"""  ,):
           UpperCAmelCase_     :       Optional[int]  		=					feature_extractor(
               lowerCamelCase_  ,padding="""max_length"""  ,truncation=lowerCamelCase_  ,return_tensors="""pt"""							).input_values

       # truncate to chunk
       UpperCAmelCase_     :       str  		=					feature_extractor(lowerCamelCase_  ,truncation=lowerCamelCase_  ,return_tensors="""pt"""							).input_values
       self.assertEquals(truncated_outputs.shape  ,(2, 1, 71520)							)  # 2 chunks

       # force truncate to max_length
       UpperCAmelCase_     :       Optional[Any]  		=					feature_extractor(
           lowerCamelCase_  ,truncation=lowerCamelCase_  ,max_length=48000  ,return_tensors="""pt"""							).input_values
       self.assertEquals(truncated_outputs.shape  ,(2, 1, 48000)							)

       # pad to chunk
       UpperCAmelCase_     :       Dict  		=					feature_extractor(lowerCamelCase_  ,padding=lowerCamelCase_  ,return_tensors="""pt"""							).input_values
       self.assertEquals(padded_outputs.shape  ,(2, 1, 95280)							)

       # pad to chunk
       UpperCAmelCase_     :       Optional[Any]  		=					feature_extractor(lowerCamelCase_  ,return_tensors="""pt"""							).input_values
       self.assertEquals(truncated_outputs.shape  ,(2, 1, 95280)							)

       # force pad to max length
       UpperCAmelCase_     :       str  		=					feature_extractor(
           lowerCamelCase_  ,padding="""max_length"""  ,max_length=100000  ,return_tensors="""pt"""							).input_values
       self.assertEquals(truncated_outputs.shape  ,(2, 1, 100000)							)

       # force no pad
       with self.assertRaisesRegex(
           lowerCamelCase_  ,"""^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$"""  ,):
           UpperCAmelCase_     :       Dict  		=					feature_extractor(lowerCamelCase_  ,padding=lowerCamelCase_  ,return_tensors="""pt"""							).input_values

       UpperCAmelCase_     :       Any  		=					feature_extractor(input_audio[0]  ,padding=lowerCamelCase_  ,return_tensors="""pt"""							).input_values
       self.assertEquals(truncated_outputs.shape  ,(1, 1, 93680)							)

       # no pad if no chunk_length_s
       UpperCAmelCase_     :       str  		=					None
       with self.assertRaisesRegex(
           lowerCamelCase_  ,"""^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$"""  ,):
           UpperCAmelCase_     :       Dict  		=					feature_extractor(lowerCamelCase_  ,padding=lowerCamelCase_  ,return_tensors="""pt"""							).input_values

       UpperCAmelCase_     :       Any  		=					feature_extractor(input_audio[0]  ,padding=lowerCamelCase_  ,return_tensors="""pt"""							).input_values
       self.assertEquals(truncated_outputs.shape  ,(1, 1, 93680)							)

       # no pad if no overlap
       UpperCAmelCase_     :       int  		=					2
       UpperCAmelCase_     :       Optional[Any]  		=					None
       with self.assertRaisesRegex(
           lowerCamelCase_  ,"""^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$"""  ,):
           UpperCAmelCase_     :       int  		=					feature_extractor(lowerCamelCase_  ,padding=lowerCamelCase_  ,return_tensors="""pt"""							).input_values

       UpperCAmelCase_     :       Optional[Any]  		=					feature_extractor(input_audio[0]  ,padding=lowerCamelCase_  ,return_tensors="""pt"""							).input_values
       self.assertEquals(truncated_outputs.shape  ,(1, 1, 93680)							)


import inspect
from typing import Callable, List, Optional, Set, Tuple, Union

import torch
from packaging import version
from safetensors.torch import storage_ptr, storage_size
from torch import nn

from .utils import logging


a__				:      Tuple    		=     [nn.LayerNorm]

a__				:      Tuple    		=     logging.get_logger(__name__)

a__				:      int    		=     version.parse(version.parse(torch.__version__).base_version)

a__				:      Dict    		=     parsed_torch_version_base >= version.parse('''2.0''')
a__				:      Any    		=     parsed_torch_version_base >= version.parse('''1.12''')
a__				:      Union[str, Any]    		=     parsed_torch_version_base >= version.parse('''1.11''')
a__				:      Union[str, Any]    		=     parsed_torch_version_base < version.parse('''1.11''')







def 				UpperCAmelCase_(    a__ ,						a__ ,						a__ ,						a__ ,						self   ):



    """simple docstring"""



    from torch import _softmax_backward_data

    if is_torch_less_than_1_11:
        return _softmax_backward_data(a__ ,						a__ ,						parent.dim ,						self   )
    else:
        return _softmax_backward_data(a__ ,						a__ ,						parent.dim ,						self.dtype   )







def 				UpperCAmelCase_(    a__ ,						a__ ,						a__ = 0   ):



    """simple docstring"""



    SCREAMING_SNAKE_CASE				:				Optional[Any]				      = index.to(layer.weight.device   )
    SCREAMING_SNAKE_CASE				:				Optional[Any]				      = layer.weight.index_select(a__ ,						a__   ).clone().detach()
    if layer.bias is not None:
        if dim == 1:
            SCREAMING_SNAKE_CASE				:				int				      = layer.bias.clone().detach()
        else:
            SCREAMING_SNAKE_CASE				:				List[Any]				      = layer.bias[index].clone().detach()
    SCREAMING_SNAKE_CASE				:				List[Any]				      = list(layer.weight.size()   )
    SCREAMING_SNAKE_CASE				:				List[Any]				      = len(a__   )
    SCREAMING_SNAKE_CASE				:				str				      = nn.Linear(new_size[1] ,						new_size[0] ,						bias=layer.bias is not None   ).to(layer.weight.device   )
    SCREAMING_SNAKE_CASE				:				Optional[Any]				      = False
    new_layer.weight.copy_(W.contiguous()   )
    SCREAMING_SNAKE_CASE				:				Tuple				      = True
    if layer.bias is not None:
        SCREAMING_SNAKE_CASE				:				Dict				      = False
        new_layer.bias.copy_(b.contiguous()   )
        SCREAMING_SNAKE_CASE				:				Tuple				      = True
    return new_layer






class     a_       (			nn.Module							):



       """simple docstring"""






       def __init__(		self				,       _lowerCamelCase				,       _lowerCamelCase   )					->int:
           super().__init__()
           SCREAMING_SNAKE_CASE				:				List[str]				      = nf
           SCREAMING_SNAKE_CASE				:				List[Any]				      = nn.Parameter(torch.empty(_lowerCamelCase				,       _lowerCamelCase   )   )
           SCREAMING_SNAKE_CASE				:				Tuple				      = nn.Parameter(torch.zeros(_lowerCamelCase   )   )
           nn.init.normal_(self.weight				,       std=0.0_2   )






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase   )					->Tuple:
           SCREAMING_SNAKE_CASE				:				Optional[Any]				      = x.size()[:-1] + (self.nf,)
           SCREAMING_SNAKE_CASE				:				int				      = torch.addmm(self.bias				,       x.view(-1				,       x.size(-1   )   )				,       self.weight   )
           SCREAMING_SNAKE_CASE				:				Tuple				      = x.view(_lowerCamelCase   )
           return x







def 				UpperCAmelCase_(    a__ ,						a__ ,						a__ = 1   ):



    """simple docstring"""



    SCREAMING_SNAKE_CASE				:				str				      = index.to(layer.weight.device   )
    SCREAMING_SNAKE_CASE				:				Any				      = layer.weight.index_select(a__ ,						a__   ).clone().detach()
    if dim == 0:
        SCREAMING_SNAKE_CASE				:				Tuple				      = layer.bias.clone().detach()
    else:
        SCREAMING_SNAKE_CASE				:				Optional[int]				      = layer.bias[index].clone().detach()
    SCREAMING_SNAKE_CASE				:				int				      = list(layer.weight.size()   )
    SCREAMING_SNAKE_CASE				:				Tuple				      = len(a__   )
    SCREAMING_SNAKE_CASE				:				Any				      = ConvaD(new_size[1] ,						new_size[0]   ).to(layer.weight.device   )
    SCREAMING_SNAKE_CASE				:				Optional[int]				      = False
    new_layer.weight.copy_(W.contiguous()   )
    SCREAMING_SNAKE_CASE				:				int				      = True
    SCREAMING_SNAKE_CASE				:				Any				      = False
    new_layer.bias.copy_(b.contiguous()   )
    SCREAMING_SNAKE_CASE				:				int				      = True
    return new_layer







def 				UpperCAmelCase_(    a__ ,						a__ ,						a__ = None   ):



    """simple docstring"""



    if isinstance(a__ ,						nn.Linear   ):
        return prune_linear_layer(a__ ,						a__ ,						dim=0 if dim is None else dim   )
    elif isinstance(a__ ,						a__   ):
        return prune_convad_layer(a__ ,						a__ ,						dim=1 if dim is None else dim   )
    else:
        raise ValueError(F"""Can't prune layer of class {layer.__class__}"""   )







def 				UpperCAmelCase_(    a__ ,						a__ ,						a__ ,						*a__   ):



    """simple docstring"""



    assert len(a__   ) > 0, F"""{input_tensors} has to be a tuple/list of tensors"""

    # inspect.signature exist since python 3.5 and is a python method -> no problem with backward compatibility
    SCREAMING_SNAKE_CASE				:				str				      = len(inspect.signature(a__   ).parameters   )
    if num_args_in_forward_chunk_fn != len(a__   ):
        raise ValueError(
            F"""forward_chunk_fn expects {num_args_in_forward_chunk_fn} arguments, but only {len(a__   )} input """
            '''tensors are given'''   )

    if chunk_size > 0:
        SCREAMING_SNAKE_CASE				:				Dict				      = input_tensors[0].shape[chunk_dim]
        for input_tensor in input_tensors:
            if input_tensor.shape[chunk_dim] != tensor_shape:
                raise ValueError(
                    F"""All input tenors have to be of the same shape: {tensor_shape}, """
                    F"""found shape {input_tensor.shape[chunk_dim]}"""   )

        if input_tensors[0].shape[chunk_dim] % chunk_size != 0:
            raise ValueError(
                F"""The dimension to be chunked {input_tensors[0].shape[chunk_dim]} has to be a multiple of the chunk """
                F"""size {chunk_size}"""   )

        SCREAMING_SNAKE_CASE				:				Any				      = input_tensors[0].shape[chunk_dim] // chunk_size

        # chunk input tensor into tuples
        SCREAMING_SNAKE_CASE				:				Optional[int]				      = tuple(input_tensor.chunk(a__ ,						dim=a__   ) for input_tensor in input_tensors   )
        # apply forward fn to every tuple
        SCREAMING_SNAKE_CASE				:				Tuple				      = tuple(forward_fn(*a__   ) for input_tensors_chunk in zip(*a__   )   )
        # concatenate output at same dimension
        return torch.cat(a__ ,						dim=a__   )

    return forward_fn(*a__   )







def 				UpperCAmelCase_(    a__ ,						a__ ,						a__ ,						a__   ):



    """simple docstring"""



    SCREAMING_SNAKE_CASE				:				Optional[int]				      = torch.ones(a__ ,						a__   )
    SCREAMING_SNAKE_CASE				:				str				      = set(a__   ) - already_pruned_heads  # Convert to set and remove already pruned heads
    for head in heads:
        # Compute how many pruned heads are before the head and move the index accordingly
        SCREAMING_SNAKE_CASE				:				Optional[Any]				      = head - sum(1 if h < head else 0 for h in already_pruned_heads   )
        SCREAMING_SNAKE_CASE				:				str				      = 0
    SCREAMING_SNAKE_CASE				:				List[str]				      = mask.view(-1   ).contiguous().eq(1   )
    SCREAMING_SNAKE_CASE				:				torch.LongTensor				      = torch.arange(len(a__   )   )[mask].long()
    return heads, index







def 				UpperCAmelCase_(    *a__ ,						a__ = None   ):



    """simple docstring"""



    return torch.meshgrid(*a__ ,						indexing=a__   )







def 				UpperCAmelCase_(    a__   ):



    """simple docstring"""



    return tensor.device, storage_ptr(a__   ), storage_size(a__   )
