


"""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


UpperCAmelCase__  							=random.Random()


def lowerCAmelCase_      (				UpperCamelCase__	: Any				,   UpperCamelCase__	: Dict=1.0				,   UpperCamelCase__	: List[str]=None				,   UpperCamelCase__	: List[Any]=None ):






 """simple docstring"""







 if rng is None:
  __lowercase									=	global_rng

 __lowercase									=	[]
 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    lowerCamelCase__						(		unittest.TestCase    ):
      def __init__(		self	:	Union[str, Any]      ,       A_	:	str      ,       A_	:	int=7      ,       A_	:	Optional[int]=4_0_0      ,       A_	:	Dict=2_0_0_0      ,       A_	:	Tuple=1      ,       A_	:	List[Any]=0.0      ,       A_	:	Tuple=1_6_0_0_0      ,       A_	:	Tuple=True      ,       A_	:	Dict=8_0      ,       A_	:	Dict=1_6      ,       A_	:	List[str]=6_4      ,       A_	:	List[Any]="hann_window"      ,       A_	:	Optional[int]=8_0      ,       A_	:	Any=7_6_0_0      ,       A_	:	int=1e-1_0      ,       A_	:	Union[str, Any]=True      ,       ):






       '''simple docstring'''


       __lowercase									=	parent
       __lowercase									=	batch_size
       __lowercase									=	min_seq_length
       __lowercase									=	max_seq_length
       __lowercase									=	(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
       __lowercase									=	feature_size
       __lowercase									=	padding_value
       __lowercase									=	sampling_rate
       __lowercase									=	do_normalize
       __lowercase									=	num_mel_bins
       __lowercase									=	hop_length
       __lowercase									=	win_length
       __lowercase									=	win_function
       __lowercase									=	fmin
       __lowercase									=	fmax
       __lowercase									=	mel_floor
       __lowercase									=	return_attention_mask
      def SCREAMING_SNAKE_CASE_	(		self	:	Tuple							):






       '''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 SCREAMING_SNAKE_CASE_	(		self	:	List[str]      ,       A_	:	Any=False      ,       A_	:	List[str]=False							):






       '''simple docstring'''


       def _flatten(A_	:	List[str]							):
        return list(itertools.chain(*A_							)							)

       if equal_length:
        __lowercase									=	floats_list((self.batch_size, self.max_seq_length)							)
       else:
        # make sure that inputs increase in size
        __lowercase									=	[
            _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:
        __lowercase									=	[np.asarray(A_							) for x in speech_inputs]

       return speech_inputs






      def SCREAMING_SNAKE_CASE_	(		self	:	Tuple      ,       A_	:	List[str]=False      ,       A_	:	Optional[Any]=False							):






       '''simple docstring'''


       if equal_length:
        __lowercase									=	[floats_list((self.max_seq_length, self.num_mel_bins)							) for _ in range(self.batch_size							)]
       else:
        # make sure that inputs increase in size
        __lowercase									=	[
            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:
        __lowercase									=	[np.asarray(A_							) for x in speech_inputs]

       return speech_inputs






@require_torch
class    lowerCamelCase__						(		_a			,   unittest.TestCase    ):
      a :     Optional[Any]											=		SpeechTaFeatureExtractor
      def SCREAMING_SNAKE_CASE_	(		self	:	Dict							):






       '''simple docstring'''


       __lowercase									=	SpeechTaFeatureExtractionTester(self							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Any      ,       A_	:	Union[str, Any]							):






       '''simple docstring'''


       self.assertTrue(np.all(np.mean(A_      ,       axis=0							) < 1e-3							)							)
       self.assertTrue(np.all(np.abs(np.var(A_      ,       axis=0							) - 1							) < 1e-3							)							)
      def SCREAMING_SNAKE_CASE_	(		self	:	List[Any]							):






       '''simple docstring'''


       __lowercase									=	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
       # create three inputs of length 800, 1000, and 1200
       __lowercase									=	[floats_list((1, x)							)[0] for x in range(8_0_0      ,       1_4_0_0      ,       2_0_0							)]
       __lowercase									=	[np.asarray(A_							) for speech_input in speech_inputs]

       # Test not batched input
       __lowercase									=	feat_extract(speech_inputs[0]      ,       return_tensors="""np"""							).input_values
       __lowercase									=	feat_extract(np_speech_inputs[0]      ,       return_tensors="""np"""							).input_values
       self.assertTrue(np.allclose(A_      ,       A_      ,       atol=1e-3							)							)

       # Test batched
       __lowercase									=	feat_extract(A_      ,       return_tensors="""np"""							).input_values
       __lowercase									=	feat_extract(A_      ,       return_tensors="""np"""							).input_values
       for enc_seq_a, enc_seq_a in zip(A_      ,       A_							):
        self.assertTrue(np.allclose(A_      ,       A_      ,       atol=1e-3							)							)
      def SCREAMING_SNAKE_CASE_	(		self	:	str							):






       '''simple docstring'''


       __lowercase									=	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
       __lowercase									=	[floats_list((1, x)							)[0] for x in range(8_0_0      ,       1_4_0_0      ,       2_0_0							)]

       __lowercase									=	["""longest""", """max_length""", """do_not_pad"""]
       __lowercase									=	[None, 1_6_0_0, None]
       for max_length, padding in zip(A_      ,       A_							):
        __lowercase									=	feat_extract(A_      ,       padding=A_      ,       max_length=A_      ,       return_tensors="""np"""							)
        __lowercase									=	processed.input_values

        self._check_zero_mean_unit_variance(input_values[0][:8_0_0]							)
        self.assertTrue(input_values[0][8_0_0:].sum() < 1e-6							)
        self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0]							)
        self.assertTrue(input_values[0][1_0_0_0:].sum() < 1e-6							)
        self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0]							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[Any]							):






       '''simple docstring'''


       __lowercase									=	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
       __lowercase									=	range(8_0_0      ,       1_4_0_0      ,       2_0_0							)
       __lowercase									=	[floats_list((1, x)							)[0] for x in lengths]

       __lowercase									=	["""longest""", """max_length""", """do_not_pad"""]
       __lowercase									=	[None, 1_6_0_0, None]

       for max_length, padding in zip(A_      ,       A_							):
        __lowercase									=	feat_extract(A_      ,       max_length=A_      ,       padding=A_							)
        __lowercase									=	processed.input_values

        self._check_zero_mean_unit_variance(input_values[0][:8_0_0]							)
        self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0]							)
        self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0]							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Tuple							):






       '''simple docstring'''


       __lowercase									=	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
       __lowercase									=	[floats_list((1, x)							)[0] for x in range(8_0_0      ,       1_4_0_0      ,       2_0_0							)]
       __lowercase									=	feat_extract(
           A_      ,       truncation=A_      ,       max_length=1_0_0_0      ,       padding="""max_length"""      ,       return_tensors="""np"""							)
       __lowercase									=	processed.input_values

       self._check_zero_mean_unit_variance(input_values[0, :8_0_0]							)
       self._check_zero_mean_unit_variance(input_values[1]							)
       self._check_zero_mean_unit_variance(input_values[2]							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[int]							):






       '''simple docstring'''


       __lowercase									=	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
       __lowercase									=	[floats_list((1, x)							)[0] for x in range(8_0_0      ,       1_4_0_0      ,       2_0_0							)]
       __lowercase									=	feat_extract(
           A_      ,       truncation=A_      ,       max_length=1_0_0_0      ,       padding="""longest"""      ,       return_tensors="""np"""							)
       __lowercase									=	processed.input_values

       self._check_zero_mean_unit_variance(input_values[0, :8_0_0]							)
       self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0]							)
       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, 1_0_0_0)							)

       __lowercase									=	[floats_list((1, x)							)[0] for x in range(8_0_0      ,       1_4_0_0      ,       2_0_0							)]
       __lowercase									=	feat_extract(
           A_      ,       truncation=A_      ,       max_length=2_0_0_0      ,       padding="""longest"""      ,       return_tensors="""np"""							)
       __lowercase									=	processed.input_values

       self._check_zero_mean_unit_variance(input_values[0, :8_0_0]							)
       self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0]							)
       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, 1_2_0_0)							)
      def SCREAMING_SNAKE_CASE_	(		self	:	int							):






       '''simple docstring'''


       __lowercase									=	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
       __lowercase									=	np.random.rand(1_0_0							).astype(np.floataa							)
       __lowercase									=	np_speech_inputs.tolist()

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






       '''simple docstring'''


       __lowercase									=	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
       # create three inputs of length 800, 1000, and 1200
       __lowercase									=	[floats_list((1, x)							)[0] for x in range(8_0_0      ,       1_4_0_0      ,       2_0_0							)]
       __lowercase									=	[np.asarray(A_							) for speech_input in speech_inputs]

       # Test feature size
       __lowercase									=	feature_extractor(audio_target=A_      ,       padding=A_      ,       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
       __lowercase									=	feature_extractor(speech_inputs[0]      ,       return_tensors="""np"""							).input_values
       __lowercase									=	feature_extractor(np_speech_inputs[0]      ,       return_tensors="""np"""							).input_values
       self.assertTrue(np.allclose(A_      ,       A_      ,       atol=1e-3							)							)

       # Test batched
       __lowercase									=	feature_extractor(A_      ,       return_tensors="""np"""							).input_values
       __lowercase									=	feature_extractor(A_      ,       return_tensors="""np"""							).input_values
       for enc_seq_a, enc_seq_a in zip(A_      ,       A_							):
        self.assertTrue(np.allclose(A_      ,       A_      ,       atol=1e-3							)							)

       # Test 2-D numpy arrays are batched.
       __lowercase									=	[floats_list((1, x)							)[0] for x in (8_0_0, 8_0_0, 8_0_0)]
       __lowercase									=	np.asarray(A_							)
       __lowercase									=	feature_extractor(A_      ,       return_tensors="""np"""							).input_values
       __lowercase									=	feature_extractor(A_      ,       return_tensors="""np"""							).input_values
       for enc_seq_a, enc_seq_a in zip(A_      ,       A_							):
        self.assertTrue(np.allclose(A_      ,       A_      ,       atol=1e-3							)							)
      def SCREAMING_SNAKE_CASE_	(		self	:	List[str]							):






       '''simple docstring'''


       __lowercase									=	self.feat_extract_tester.prepare_inputs_for_target()
       __lowercase									=	self.feature_extraction_class(**self.feat_extract_dict							)
       __lowercase									=	feat_extract.model_input_names[0]

       __lowercase									=	BatchFeature({input_name: speech_inputs}							)

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

       __lowercase									=	self.feat_extract_tester.prepare_inputs_for_target(equal_length=A_							)
       __lowercase									=	BatchFeature({input_name: speech_inputs}      ,       tensor_type="""np"""							)

       __lowercase									=	processed_features[input_name]

       if len(batch_features_input.shape							) < 3:
        __lowercase									=	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 SCREAMING_SNAKE_CASE_	(		self	:	Optional[int]							):






       '''simple docstring'''


       __lowercase									=	self.feat_extract_tester.prepare_inputs_for_target(equal_length=A_							)
       __lowercase									=	self.feature_extraction_class(**self.feat_extract_dict							)
       __lowercase									=	feat_extract.model_input_names[0]

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

       __lowercase									=	processed_features[input_name]

       if len(batch_features_input.shape							) < 3:
        __lowercase									=	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 SCREAMING_SNAKE_CASE_	(		self	:	int							):






       '''simple docstring'''


       __lowercase									=	self.feature_extraction_class(**self.feat_extract_dict							)
       __lowercase									=	self.feat_extract_tester.prepare_inputs_for_target()
       __lowercase									=	feat_extract.model_input_names[0]

       __lowercase									=	BatchFeature({input_name: speech_inputs}							)

       __lowercase									=	feat_extract.num_mel_bins  # hack!

       __lowercase									=	feat_extract.pad(A_      ,       padding="""longest"""      ,       return_tensors="""np"""							)[input_name]
       __lowercase									=	feat_extract.pad(A_      ,       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 SCREAMING_SNAKE_CASE_	(		self	:	str							):






       '''simple docstring'''


       __lowercase									=	self.feat_extract_dict
       __lowercase									=	True
       __lowercase									=	self.feature_extraction_class(**A_							)
       __lowercase									=	self.feat_extract_tester.prepare_inputs_for_target()
       __lowercase									=	[len(A_							) for x in speech_inputs]
       __lowercase									=	feat_extract.model_input_names[0]

       __lowercase									=	BatchFeature({input_name: speech_inputs}							)

       __lowercase									=	feat_extract.num_mel_bins  # hack!

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






       '''simple docstring'''


       __lowercase									=	self.feat_extract_dict
       __lowercase									=	True
       __lowercase									=	self.feature_extraction_class(**A_							)
       __lowercase									=	self.feat_extract_tester.prepare_inputs_for_target()
       __lowercase									=	[len(A_							) for x in speech_inputs]
       __lowercase									=	feat_extract.model_input_names[0]

       __lowercase									=	BatchFeature({input_name: speech_inputs}							)
       __lowercase									=	min(A_							)

       __lowercase									=	feat_extract.num_mel_bins  # hack!

       __lowercase									=	feat_extract.pad(
           A_      ,       padding="""max_length"""      ,       max_length=A_      ,       truncation=A_      ,       return_tensors="""np"""							)
       self.assertIn("""attention_mask"""      ,       A_							)
       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 SCREAMING_SNAKE_CASE_	(		self	:	str      ,       A_	:	Union[str, Any]							):






       '''simple docstring'''


       from datasets import load_dataset

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

       return [x["array"] for x in speech_samples]
      def SCREAMING_SNAKE_CASE_	(		self	:	Any							):






       '''simple docstring'''


       __lowercase									=	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

       __lowercase									=	self._load_datasamples(1							)
       __lowercase									=	SpeechTaFeatureExtractor()
       __lowercase									=	feature_extractor(A_      ,       return_tensors="""pt"""							).input_values
       self.assertEquals(input_values.shape      ,       (1, 9_3_6_8_0)							)
       self.assertTrue(torch.allclose(input_values[0, :3_0]      ,       A_      ,       atol=1e-6							)							)






      def SCREAMING_SNAKE_CASE_	(		self	:	Union[str, Any]							):






       '''simple docstring'''


       __lowercase									=	torch.tensor(
           [-2.68_70, -3.01_04, -3.13_56, -3.53_52, -3.00_44, -3.03_53, -3.47_19, -3.67_77,
            -3.15_20, -2.94_35, -2.65_53, -2.87_95, -2.99_44, -2.59_21, -3.02_79, -3.03_86,
            -3.08_64, -3.12_91, -3.23_53, -2.74_44, -2.68_31, -2.72_87, -3.17_61, -3.15_71,
            -3.27_26, -3.05_82, -3.10_07, -3.45_33, -3.46_95, -3.09_98]							)
       # fmt: on

       __lowercase									=	self._load_datasamples(1							)
       __lowercase									=	SpeechTaFeatureExtractor()
       __lowercase									=	feature_extractor(audio_target=A_      ,       return_tensors="""pt"""							).input_values
       self.assertEquals(input_values.shape      ,       (1, 3_6_6, 8_0)							)
       self.assertTrue(torch.allclose(input_values[0, 0, :3_0]      ,       A_      ,       atol=1e-4							)							)






"""simple docstring"""

def lowerCAmelCase_      (				UpperCamelCase__	: Optional[Any]				,   UpperCamelCase__	: int				,   UpperCamelCase__	: Optional[Any]				,   UpperCamelCase__	: str ):






 """simple docstring"""







 __lowercase									=	[False] * len(UpperCamelCase__ )
 __lowercase									=	[]
 queue.append(UpperCamelCase__ )
 __lowercase									=	True

 while queue:
  __lowercase									=	queue.pop(0 )
  for ind in range(len(graph[u] ) ):
   if visited[ind] is False and graph[u][ind] > 0:
    queue.append(UpperCamelCase__ )
    __lowercase									=	True
    __lowercase									=	u

 return visited[t]


def lowerCAmelCase_      (				UpperCamelCase__	: str				,   UpperCamelCase__	: Any				,   UpperCamelCase__	: Optional[int] ):






 """simple docstring"""







 __lowercase									=	[-1] * (len(UpperCamelCase__ ))
 __lowercase									=	0
 while bfs(UpperCamelCase__				,   UpperCamelCase__				,   UpperCamelCase__				,   UpperCamelCase__ ):
  __lowercase									=	float("""Inf""" )
  __lowercase									=	sink

  while s != source:
   # Find the minimum value in select path
   __lowercase									=	min(UpperCamelCase__				,   graph[parent[s]][s] )
   __lowercase									=	parent[s]

  max_flow += path_flow
  __lowercase									=	sink

  while v != source:
   __lowercase									=	parent[v]
   graph[u][v] -= path_flow
   graph[v][u] += path_flow
   __lowercase									=	parent[v]
 return max_flow


UpperCAmelCase__  							=[
    [0, 16, 13, 0, 0, 0],
    [0, 0, 10, 12, 0, 0],
    [0, 4, 0, 0, 14, 0],
    [0, 0, 9, 0, 0, 20],
    [0, 0, 0, 7, 0, 4],
    [0, 0, 0, 0, 0, 0],
]

UpperCAmelCase__							,      UpperCAmelCase__  							=0, 5

print(ford_fulkerson(graph, source, sink))
