


import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
  from transformers import SpeechaTextFeatureExtractor

__a     =			random.Random()
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_=1.0  ,						lowerCAmelCase_=None  ,						lowerCAmelCase_=None   )						->int:



   if rng is None:
      UpperCAmelCase							=     global_rng

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

   return values






@require_torch
@require_torchaudio
class   __lowercase				(  unittest.TestCase  ):





      def __init__(		self						:					Dict					,       __lowerCamelCase						:					str					,       __lowerCamelCase						:					Optional[int]=7					,       __lowerCamelCase						:					Dict=4_0_0					,       __lowerCamelCase						:					Dict=2_0_0_0					,       __lowerCamelCase						:					str=2_4					,       __lowerCamelCase						:					Any=2_4					,       __lowerCamelCase						:					Optional[Any]=0.0					,       __lowerCamelCase						:					Optional[int]=1_6_0_0_0					,       __lowerCamelCase						:					Any=True					,       __lowerCamelCase						:					Tuple=True					,       )    ->   Optional[Any]:






         """simple docstring"""







         UpperCAmelCase							=     parent
         UpperCAmelCase							=     batch_size
         UpperCAmelCase							=     min_seq_length
         UpperCAmelCase							=     max_seq_length
         UpperCAmelCase							=     (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
         UpperCAmelCase							=     feature_size
         UpperCAmelCase							=     num_mel_bins
         UpperCAmelCase							=     padding_value
         UpperCAmelCase							=     sampling_rate
         UpperCAmelCase							=     return_attention_mask
         UpperCAmelCase							=     do_normalize





      def        _lowercase				(		self						:					Optional[Any]       )    ->   int:






         """simple docstring"""







         return {
             "feature_size": self.feature_size,
             "num_mel_bins": self.num_mel_bins,
             "padding_value": self.padding_value,
             "sampling_rate": self.sampling_rate,
             "return_attention_mask": self.return_attention_mask,
             "do_normalize": self.do_normalize,
         }





      def        _lowercase				(		self						:					Union[str, Any]					,       __lowerCamelCase						:					Optional[Any]=False					,       __lowerCamelCase						:					Optional[Any]=False       )    ->   Optional[Any]:






         """simple docstring"""







         def _flatten(__lowerCamelCase						:					Any       ):
            return list(itertools.chain(*UpperCamelCase_       )       )

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






@require_torch
@require_torchaudio
class   __lowercase				(  __lowerCamelCase ,					unittest.TestCase  ):
      UpperCamelCase								=       SpeechaTextFeatureExtractor if is_speech_available() else None





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






         """simple docstring"""







         UpperCAmelCase							=     SpeechaTextFeatureExtractionTester(self       )





      def        _lowercase				(		self						:					Tuple					,       __lowerCamelCase						:					Dict       )    ->   Any:






         """simple docstring"""







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





      def        _lowercase				(		self						:					Dict       )    ->   Dict:






         """simple docstring"""







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

         # Test feature size
         UpperCAmelCase							=     feature_extractor(UpperCamelCase_					,       padding=UpperCamelCase_					,       return_tensors="""np"""       ).input_features
         self.assertTrue(input_features.ndim == 3       )
         self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size       )

         # Test not batched input
         UpperCAmelCase							=     feature_extractor(speech_inputs[0]					,       return_tensors="""np"""       ).input_features
         UpperCAmelCase							=     feature_extractor(np_speech_inputs[0]					,       return_tensors="""np"""       ).input_features
         self.assertTrue(np.allclose(UpperCamelCase_					,       UpperCamelCase_					,       atol=1e-3       )       )

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

         # Test 2-D numpy arrays are batched.
         UpperCAmelCase							=     [floats_list((1, x)       )[0] for x in (8_0_0, 8_0_0, 8_0_0)]
         UpperCAmelCase							=     np.asarray(UpperCamelCase_       )
         UpperCAmelCase							=     feature_extractor(UpperCamelCase_					,       return_tensors="""np"""       ).input_features
         UpperCAmelCase							=     feature_extractor(UpperCamelCase_					,       return_tensors="""np"""       ).input_features
         for enc_seq_a, enc_seq_a in zip(UpperCamelCase_					,       UpperCamelCase_       ):
            self.assertTrue(np.allclose(UpperCamelCase_					,       UpperCamelCase_					,       atol=1e-3       )       )





      def        _lowercase				(		self						:					Any       )    ->   Dict:






         """simple docstring"""







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

         UpperCAmelCase							=     ["""longest""", """max_length""", """do_not_pad"""]
         UpperCAmelCase							=     [None, 1_6, None]
         for max_length, padding in zip(UpperCamelCase_					,       UpperCamelCase_       ):
            UpperCAmelCase							=     feature_extractor(
                UpperCamelCase_					,       padding=UpperCamelCase_					,       max_length=UpperCamelCase_					,       return_attention_mask=UpperCamelCase_       )
            UpperCAmelCase							=     inputs.input_features
            UpperCAmelCase							=     inputs.attention_mask
            UpperCAmelCase							=     [np.sum(UpperCamelCase_       ) for x in attention_mask]

            self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]       )
            self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]       )
            self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]       )





      def        _lowercase				(		self						:					Union[str, Any]       )    ->   Optional[int]:






         """simple docstring"""







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

         UpperCAmelCase							=     ["""longest""", """max_length""", """do_not_pad"""]
         UpperCAmelCase							=     [None, 1_6, None]
         for max_length, padding in zip(UpperCamelCase_					,       UpperCamelCase_       ):
            UpperCAmelCase							=     feature_extractor(
                UpperCamelCase_					,       max_length=UpperCamelCase_					,       padding=UpperCamelCase_					,       return_tensors="""np"""					,       return_attention_mask=UpperCamelCase_       )
            UpperCAmelCase							=     inputs.input_features
            UpperCAmelCase							=     inputs.attention_mask
            UpperCAmelCase							=     [np.sum(UpperCamelCase_       ) for x in attention_mask]

            self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]       )
            self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1e-6       )
            self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]       )
            self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1e-6       )
            self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]       )





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






         """simple docstring"""







         UpperCAmelCase							=     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         UpperCAmelCase							=     [floats_list((1, x)       )[0] for x in range(8_0_0					,       1_4_0_0					,       2_0_0       )]
         UpperCAmelCase							=     feature_extractor(
             UpperCamelCase_					,       padding="""max_length"""					,       max_length=4					,       truncation=UpperCamelCase_					,       return_tensors="""np"""					,       return_attention_mask=UpperCamelCase_					,       )
         UpperCAmelCase							=     inputs.input_features
         UpperCAmelCase							=     inputs.attention_mask
         UpperCAmelCase							=     np.sum(attention_mask == 1					,       axis=1       )

         self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]       )
         self._check_zero_mean_unit_variance(input_features[1]       )
         self._check_zero_mean_unit_variance(input_features[2]       )





      def        _lowercase				(		self						:					Tuple       )    ->   Optional[Any]:






         """simple docstring"""







         UpperCAmelCase							=     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         UpperCAmelCase							=     [floats_list((1, x)       )[0] for x in range(8_0_0					,       1_4_0_0					,       2_0_0       )]
         UpperCAmelCase							=     feature_extractor(
             UpperCamelCase_					,       padding="""longest"""					,       max_length=4					,       truncation=UpperCamelCase_					,       return_tensors="""np"""					,       return_attention_mask=UpperCamelCase_					,       )
         UpperCAmelCase							=     inputs.input_features
         UpperCAmelCase							=     inputs.attention_mask
         UpperCAmelCase							=     np.sum(attention_mask == 1					,       axis=1       )

         self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]       )
         self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]       )
         self._check_zero_mean_unit_variance(input_features[2]       )

         # make sure that if max_length < longest -> then pad to max_length
         self.assertEqual(input_features.shape					,       (3, 4, 2_4)       )

         UpperCAmelCase							=     [floats_list((1, x)       )[0] for x in range(8_0_0					,       1_4_0_0					,       2_0_0       )]
         UpperCAmelCase							=     feature_extractor(
             UpperCamelCase_					,       padding="""longest"""					,       max_length=1_6					,       truncation=UpperCamelCase_					,       return_tensors="""np"""					,       return_attention_mask=UpperCamelCase_					,       )
         UpperCAmelCase							=     inputs.input_features
         UpperCAmelCase							=     inputs.attention_mask
         UpperCAmelCase							=     np.sum(attention_mask == 1					,       axis=1       )

         self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]       )
         self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]       )
         self._check_zero_mean_unit_variance(input_features[2]       )

         # make sure that if max_length < longest -> then pad to max_length
         self.assertEqual(input_features.shape					,       (3, 6, 2_4)       )





      def        _lowercase				(		self						:					Any       )    ->   Any:






         """simple docstring"""







         import torch

         UpperCAmelCase							=     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         UpperCAmelCase							=     np.random.rand(1_0_0					,       3_2       ).astype(np.floataa       )
         UpperCAmelCase							=     np_speech_inputs.tolist()

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





      def        _lowercase				(		self						:					Union[str, Any]					,       __lowerCamelCase						:					Optional[Any]       )    ->   Any:






         """simple docstring"""







         from datasets import load_dataset

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

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





      def        _lowercase				(		self						:					Optional[Any]       )    ->   str:






         """simple docstring"""







         UpperCAmelCase							=     np.array([
             -1.5_745, -1.7_713, -1.7_020, -1.6_069, -1.2_250, -1.1_105, -0.9_072, -0.8_241,
             -1.2_310, -0.8_098, -0.3_320, -0.4_101, -0.7_985, -0.4_996, -0.8_213, -0.9_128,
             -1.0_420, -1.1_286, -1.0_440, -0.7_999, -0.8_405, -1.2_275, -1.5_443, -1.4_625,
         ]       )
         # fmt: on

         UpperCAmelCase							=     self._load_datasamples(1       )
         UpperCAmelCase							=     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         UpperCAmelCase							=     feature_extractor(UpperCamelCase_					,       return_tensors="""pt"""       ).input_features
         self.assertEquals(input_features.shape					,       (1, 5_8_4, 2_4)       )
         self.assertTrue(np.allclose(input_features[0, 0, :3_0]					,       UpperCamelCase_					,       atol=1e-4       )       )







from __future__ import annotations

from collections.abc import Sequence
from typing import Literal
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_   )						->str | Literal[False]:
   UpperCAmelCase							=     list(lowerCAmelCase_   )
   UpperCAmelCase							=     list(lowerCAmelCase_   )
   UpperCAmelCase							=     0
   for i in range(len(lowerCAmelCase_   )   ):
      if lista[i] != lista[i]:
         count += 1
         UpperCAmelCase							=     """_"""
   if count > 1:
      return False
   else:
      return "".join(lowerCAmelCase_   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->list[str]:
   UpperCAmelCase							=     []
   while True:
      UpperCAmelCase							=     ["""$"""] * len(lowerCAmelCase_   )
      UpperCAmelCase							=     []
      for i in range(len(lowerCAmelCase_   )   ):
         for j in range(i + 1  ,						len(lowerCAmelCase_   )   ):
            UpperCAmelCase							=     compare_string(binary[i]  ,						binary[j]   )
            if k is False:
               UpperCAmelCase							=     """*"""
               UpperCAmelCase							=     """*"""
               temp.append("""X"""   )
      for i in range(len(lowerCAmelCase_   )   ):
         if checka[i] == "$":
            pi.append(binary[i]   )
      if len(lowerCAmelCase_   ) == 0:
         return pi
      UpperCAmelCase							=     list(set(lowerCAmelCase_   )   )
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_   )						->list[str]:
   UpperCAmelCase							=     []
   for minterm in minterms:
      UpperCAmelCase							=     """"""
      for _ in range(lowerCAmelCase_   ):
         UpperCAmelCase							=     str(minterm % 2   ) + string
         minterm //= 2
      temp.append(lowerCAmelCase_   )
   return temp
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_   )						->bool:
   UpperCAmelCase							=     list(lowerCAmelCase_   )
   UpperCAmelCase							=     list(lowerCAmelCase_   )
   UpperCAmelCase							=     0
   for i in range(len(lowerCAmelCase_   )   ):
      if lista[i] != lista[i]:
         count_n += 1
   return count_n == count
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_   )						->list[str]:
   UpperCAmelCase							=     []
   UpperCAmelCase							=     [0] * len(lowerCAmelCase_   )
   for i in range(len(chart[0]   )   ):
      UpperCAmelCase							=     0
      UpperCAmelCase							=     -1
      for j in range(len(lowerCAmelCase_   )   ):
         if chart[j][i] == 1:
            count += 1
            UpperCAmelCase							=     j
      if count == 1:
         UpperCAmelCase							=     1
   for i in range(len(lowerCAmelCase_   )   ):
      if select[i] == 1:
         for j in range(len(chart[0]   )   ):
            if chart[i][j] == 1:
               for k in range(len(lowerCAmelCase_   )   ):
                  UpperCAmelCase							=     0
         temp.append(prime_implicants[i]   )
   while True:
      UpperCAmelCase							=     0
      UpperCAmelCase							=     -1
      UpperCAmelCase							=     0
      for i in range(len(lowerCAmelCase_   )   ):
         UpperCAmelCase							=     chart[i].count(1   )
         if count_n > max_n:
            UpperCAmelCase							=     count_n
            UpperCAmelCase							=     i

      if max_n == 0:
         return temp

      temp.append(prime_implicants[rem]   )

      for i in range(len(chart[0]   )   ):
         if chart[rem][i] == 1:
            for j in range(len(lowerCAmelCase_   )   ):
               UpperCAmelCase							=     0
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_   )						->list[list[int]]:
   UpperCAmelCase							=     [[0 for x in range(len(lowerCAmelCase_   )   )] for x in range(len(lowerCAmelCase_   )   )]
   for i in range(len(lowerCAmelCase_   )   ):
      UpperCAmelCase							=     prime_implicants[i].count("""_"""   )
      for j in range(len(lowerCAmelCase_   )   ):
         if is_for_table(prime_implicants[i]  ,						binary[j]  ,						lowerCAmelCase_   ):
            UpperCAmelCase							=     1

   return chart
def   _UpperCamelCase				(						)						->None:
   UpperCAmelCase							=     int(input("""Enter the no. of variables\n"""   )   )
   UpperCAmelCase							=     [
       float(lowerCAmelCase_   )
       for x in input(
           """Enter the decimal representation of Minterms 'Spaces Separated'\n"""   ).split()
   ]
   UpperCAmelCase							=     decimal_to_binary(lowerCAmelCase_  ,						lowerCAmelCase_   )

   UpperCAmelCase							=     check(lowerCAmelCase_   )
   print("""Prime Implicants are:"""   )
   print(lowerCAmelCase_   )
   UpperCAmelCase							=     prime_implicant_chart(lowerCAmelCase_  ,						lowerCAmelCase_   )

   UpperCAmelCase							=     selection(lowerCAmelCase_  ,						lowerCAmelCase_   )
   print("""Essential Prime Implicants are:"""   )
   print(lowerCAmelCase_   )


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 main()



