





import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


UpperCamelCase__     =	logging.get_logger(__name__)

class     __SCREAMING_SNAKE_CASE   (       _a    ):
							snake_case       : str         =    ["""input_features"""]






							def __init__(  self					,	__lowerCAmelCase=80					,	__lowerCAmelCase=16000					,	__lowerCAmelCase=160					,	__lowerCAmelCase=30					,	__lowerCAmelCase=400					,	__lowerCAmelCase=0.0					,	__lowerCAmelCase=False					,	**__lowerCAmelCase					,	):
														super().__init__(
														    feature_size=__lowerCAmelCase					,	sampling_rate=__lowerCAmelCase					,	padding_value=__lowerCAmelCase					,	return_attention_mask=__lowerCAmelCase					,	**__lowerCAmelCase					,	)
														UpperCamelCase__			       =     n_fft
														UpperCamelCase__			       =     hop_length
														UpperCamelCase__			       =     chunk_length
														UpperCamelCase__			       =     chunk_length * sampling_rate
														UpperCamelCase__			       =     self.n_samples // hop_length
														UpperCamelCase__			       =     sampling_rate
														UpperCamelCase__			       =     mel_filter_bank(
														    num_frequency_bins=1 + n_fft // 2					,	num_mel_filters=__lowerCAmelCase					,	min_frequency=0.0					,	max_frequency=8000.0					,	sampling_rate=__lowerCAmelCase					,	norm="""slaney"""					,	mel_scale="""slaney"""					,	)






							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					):
														UpperCamelCase__			       =     spectrogram(
														    __lowerCAmelCase					,	window_function(self.n_fft					,	"""hann"""					)					,	frame_length=self.n_fft					,	hop_length=self.hop_length					,	power=2.0					,	mel_filters=self.mel_filters					,	log_mel="""log10"""					,	)
														UpperCamelCase__			       =     log_spec[:, :-1]
														UpperCamelCase__			       =     np.maximum(__lowerCAmelCase					,	log_spec.max() - 8.0					)
														UpperCamelCase__			       =     (log_spec + 4.0) / 4.0
														return log_spec






							@staticmethod
							# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
							def 			_lowerCamelCase						(  __lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase = 0.0					):
														if attention_mask is not None:
																					UpperCamelCase__			       =     np.array(__lowerCAmelCase					,	np.intaa					)
																					UpperCamelCase__			       =     []

																					for vector, length in zip(__lowerCAmelCase					,	attention_mask.sum(-1					)					):
																												UpperCamelCase__			       =     (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7					)
																												if length < normed_slice.shape[0]:
																																			UpperCamelCase__			       =     padding_value

																												normed_input_values.append(__lowerCAmelCase					)
														else:
																					UpperCamelCase__			       =     [(x - x.mean()) / np.sqrt(x.var() + 1E-7					) for x in input_values]

														return normed_input_values






							def __call__(  self					,	__lowerCAmelCase					,	__lowerCAmelCase = True					,	__lowerCAmelCase = None					,	__lowerCAmelCase = None					,	__lowerCAmelCase = None					,	__lowerCAmelCase = "max_length"					,	__lowerCAmelCase = None					,	__lowerCAmelCase = None					,	__lowerCAmelCase = None					,	**__lowerCAmelCase					,	):

														if sampling_rate is not None:
																					if sampling_rate != self.sampling_rate:
																												raise ValueError(
																												    f"""The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a"""
																												    f""" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input"""
																												    f""" was sampled with {self.sampling_rate} and not {sampling_rate}."""					)
														else:
																					logger.warning(
																					    """It is strongly recommended to pass the `sampling_rate` argument to this function. """
																					    """Failing to do so can result in silent errors that might be hard to debug."""					)

														UpperCamelCase__			       =     isinstance(__lowerCAmelCase					,	np.ndarray					) and len(raw_speech.shape					) > 1
														if is_batched_numpy and len(raw_speech.shape					) > 2:
																					raise ValueError(f"""Only mono-channel audio is supported for input to {self}"""					)
														UpperCamelCase__			       =     is_batched_numpy or (
														    isinstance(__lowerCAmelCase					,	(list, tuple)					) and (isinstance(raw_speech[0]					,	(np.ndarray, tuple, list)					))
														)

														if is_batched:
																					UpperCamelCase__			       =     [np.asarray([speech]					,	dtype=np.floataa					).T for speech in raw_speech]
														elif not is_batched and not isinstance(__lowerCAmelCase					,	np.ndarray					):
																					UpperCamelCase__			       =     np.asarray(__lowerCAmelCase					,	dtype=np.floataa					)
														elif isinstance(__lowerCAmelCase					,	np.ndarray					) and raw_speech.dtype is np.dtype(np.floataa					):
																					UpperCamelCase__			       =     raw_speech.astype(np.floataa					)

														# always return batch
														if not is_batched:
																					UpperCamelCase__			       =     [np.asarray([raw_speech]					).T]

														UpperCamelCase__			       =     BatchFeature({"""input_features""": raw_speech}					)

														# convert into correct format for padding

														UpperCamelCase__			       =     self.pad(
														    __lowerCAmelCase					,	padding=__lowerCAmelCase					,	max_length=max_length if max_length else self.n_samples					,	truncation=__lowerCAmelCase					,	pad_to_multiple_of=__lowerCAmelCase					,	return_attention_mask=return_attention_mask or do_normalize					,	)

														# zero-mean and unit-variance normalization
														if do_normalize:
																					UpperCamelCase__			       =     self.zero_mean_unit_var_norm(
																					    padded_inputs["""input_features"""]					,	attention_mask=padded_inputs["""attention_mask"""]					,	padding_value=self.padding_value					,	)
																					UpperCamelCase__			       =     np.stack(padded_inputs["""input_features"""]					,	axis=0					)

														# make sure list is in array format
														UpperCamelCase__			       =     padded_inputs.get("""input_features"""					).transpose(2					,	0					,	1					)

														UpperCamelCase__			       =     [self._np_extract_fbank_features(__lowerCAmelCase					) for waveform in input_features[0]]

														if isinstance(input_features[0]					,	__lowerCAmelCase					):
																					UpperCamelCase__			       =     [np.asarray(__lowerCAmelCase					,	dtype=np.floataa					) for feature in input_features]
														else:
																					UpperCamelCase__			       =     input_features

														if return_attention_mask:
																					# rescale from sample (48000) to feature (3000)
																					UpperCamelCase__			       =     padded_inputs["""attention_mask"""][:, :: self.hop_length]

														if return_tensors is not None:
																					UpperCamelCase__			       =     padded_inputs.convert_to_tensors(__lowerCAmelCase					)

														return padded_inputs







							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     copy.deepcopy(self.__dict__					)
														UpperCamelCase__			       =     self.__class__.__name__
														if "mel_filters" in output:
																					del output["mel_filters"]
														return output











from datetime import datetime as dt
import os

from github import Github


UpperCamelCase__     =	[
    "good first issue",
    "good second issue",
    "good difficult issue",
    "feature request",
    "new model",
    "wip",
]





def       _UpperCamelCase       ():






							"""simple docstring"""





							UpperCamelCase__			       =     Github(os.environ["""GITHUB_TOKEN"""]    )
							UpperCamelCase__			       =     g.get_repo("""huggingface/transformers"""    )
							UpperCamelCase__			       =     repo.get_issues(state="""open"""    )

							for issue in open_issues:
														UpperCamelCase__			       =     sorted([comment for comment in issue.get_comments()]				,     key=lambda a__    : i.created_at				,     reverse=a__    )
														UpperCamelCase__			       =     comments[0] if len(a__    ) > 0 else None
														if (
														    last_comment is not None
														    and last_comment.user.login == "github-actions[bot]"
														    and (dt.utcnow() - issue.updated_at).days > 7
														    and (dt.utcnow() - issue.created_at).days >= 30
														    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()    )
														):
																					# print(f"Would close issue {issue.number} since it has been 7 days of inactivity since bot mention.")
																					issue.edit(state="""closed"""    )
														elif (
														    (dt.utcnow() - issue.updated_at).days > 23
														    and (dt.utcnow() - issue.created_at).days >= 30
														    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()    )
														):
																					# print(f"Would add stale comment to {issue.number}")
																					issue.create_comment(
																					    """This issue has been automatically marked as stale because it has not had """
																					    """recent activity. If you think this still needs to be addressed """
																					    """please comment on this thread.\n\nPlease note that issues that do not follow the """
																					    """[contributing guidelines](https://github.com/huggingface/transformers/blob/main/CONTRIBUTING.md) """
																					    """are likely to be ignored."""    )


if __name__ == "__main__":
					main()




