





import enum
import warnings

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_tf_available():
		import tensorflow as tf

		from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

if is_torch_available():
		from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

SCREAMING_SNAKE_CASE_   :      List[str]			=   logging.get_logger(__name__)

class 		snake_case_   (							enum.Enum						):







	'''simple docstring'''
	__UpperCamelCase   =		0
	__UpperCamelCase   =		1





@add_end_docstrings(UpperCAmelCase_						)
class 		snake_case_   (							UpperCAmelCase_						):







	'''simple docstring'''
	__UpperCamelCase   =		'''generated'''




	def __init__(						self							:     List[Any]					,      *__lowerCamelCase							:     List[Any]					,      **__lowerCamelCase							:     int   )       -> Tuple:

			'''simple docstring'''




			super().__init__(*__lowerCamelCase					,      **__lowerCamelCase   )

			self.check_model_type(
			    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
			    if self.framework == 'tf'
			    else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING   )




	def    UpperCAmelCase			(						self							:     Dict					,      __lowerCamelCase							:     int=None					,      __lowerCamelCase							:     Optional[Any]=None					,      __lowerCamelCase							:     Union[str, Any]=None					,      __lowerCamelCase							:     Optional[int]=None					,      __lowerCamelCase							:     int=None					,      __lowerCamelCase							:     int=None					,      **__lowerCamelCase							:     int					,      )       -> Optional[int]:

			'''simple docstring'''




			__lowercase											=     {}
			if truncation is not None:
					__lowercase											=     truncation

			__lowercase											=     generate_kwargs

			__lowercase											=     {}
			if return_tensors is not None and return_type is None:
					__lowercase											=     ReturnType.TENSORS if return_tensors else ReturnType.TEXT
			if return_type is not None:
					__lowercase											=     return_type

			if clean_up_tokenization_spaces is not None:
					__lowercase											=     clean_up_tokenization_spaces

			if stop_sequence is not None:
					__lowercase											=     self.tokenizer.encode(__lowerCamelCase					,      add_special_tokens=__lowerCamelCase   )
					if len(__lowerCamelCase   ) > 1:
							warnings.warn(
							    'Stopping on a multiple token sequence is not yet supported on transformers. The first token of'
							    ' the stop sequence will be used as the stop sequence string in the interim.'   )
					__lowercase											=     stop_sequence_ids[0]

			return preprocess_params, forward_params, postprocess_params




	def    UpperCAmelCase			(						self							:     Dict					,      __lowerCamelCase							:     int					,      __lowerCamelCase							:     int					,      __lowerCamelCase							:     int   )       -> Optional[int]:

			'''simple docstring'''




			return True




	def    UpperCAmelCase			(						self							:     Dict					,      *__lowerCamelCase							:     List[str]					,      __lowerCamelCase							:     List[Any]   )       -> List[Any]:

			'''simple docstring'''




			__lowercase											=     self.model.config.prefix if self.model.config.prefix is not None else ''
			if isinstance(args[0]					,      __lowerCamelCase   ):
					if self.tokenizer.pad_token_id is None:
							raise ValueError('Please make sure that the tokenizer has a pad_token_id when using a batch input'   )
					__lowercase											=     ([prefix + arg for arg in args[0]],)
					__lowercase											=     True

			elif isinstance(args[0]					,      __lowerCamelCase   ):
					__lowercase											=     (prefix + args[0],)
					__lowercase											=     False
			else:
					raise ValueError(
					    F" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`"   )
			__lowercase											=     self.tokenizer(*__lowerCamelCase					,      padding=__lowerCamelCase					,      truncation=__lowerCamelCase					,      return_tensors=self.framework   )
			# This is produced by tokenizers but is an invalid generate kwargs
			if "token_type_ids" in inputs:
					del inputs["token_type_ids"]
			return inputs




	def __call__(						self							:     str					,      *__lowerCamelCase							:     Optional[int]					,      **__lowerCamelCase							:     int   )       -> Optional[Any]:

			'''simple docstring'''




			__lowercase											=     super().__call__(*__lowerCamelCase					,      **__lowerCamelCase   )
			if (
			    isinstance(args[0]					,      __lowerCamelCase   )
			    and all(isinstance(__lowerCamelCase					,      __lowerCamelCase   ) for el in args[0]   )
			    and all(len(__lowerCamelCase   ) == 1 for res in result   )
			):
					return [res[0] for res in result]
			return result




	def    UpperCAmelCase			(						self							:     Optional[int]					,      __lowerCamelCase							:     List[str]					,      __lowerCamelCase							:     Any=TruncationStrategy.DO_NOT_TRUNCATE					,      **__lowerCamelCase							:     Optional[int]   )       -> Dict:

			'''simple docstring'''




			__lowercase											=     self._parse_and_tokenize(__lowerCamelCase					,      truncation=__lowerCamelCase					,      **__lowerCamelCase   )
			return inputs




	def    UpperCAmelCase			(						self							:     Optional[Any]					,      __lowerCamelCase							:     List[Any]					,      **__lowerCamelCase							:     Tuple   )       -> List[Any]:

			'''simple docstring'''




			if self.framework == "pt":
					__lowercase						,      __lowercase											=     model_inputs['input_ids'].shape
			elif self.framework == "tf":
					__lowercase						,      __lowercase											=     tf.shape(model_inputs['input_ids']   ).numpy()

			__lowercase											=     generate_kwargs.get('min_length'					,      self.model.config.min_length   )
			__lowercase											=     generate_kwargs.get('max_length'					,      self.model.config.max_length   )
			self.check_inputs(__lowerCamelCase					,      generate_kwargs['min_length']					,      generate_kwargs['max_length']   )
			__lowercase											=     self.model.generate(**__lowerCamelCase					,      **__lowerCamelCase   )
			__lowercase											=     output_ids.shape[0]
			if self.framework == "pt":
					__lowercase											=     output_ids.reshape(__lowerCamelCase					,      out_b // in_b					,      *output_ids.shape[1:]   )
			elif self.framework == "tf":
					__lowercase											=     tf.reshape(__lowerCamelCase					,      (in_b, out_b // in_b, *output_ids.shape[1:])   )
			return {"output_ids": output_ids}






	def    UpperCAmelCase			(						self							:     str					,      __lowerCamelCase							:     Union[str, Any]					,      __lowerCamelCase							:     List[Any]=ReturnType.TEXT					,      __lowerCamelCase							:     Optional[int]=False   )       -> Any:

			'''simple docstring'''




			__lowercase											=     []
			for output_ids in model_outputs["output_ids"][0]:
					if return_type == ReturnType.TENSORS:
							__lowercase											=     {F"{self.return_name}_token_ids": output_ids}
					elif return_type == ReturnType.TEXT:
							__lowercase											=     {
							    F"{self.return_name}_text": self.tokenizer.decode(
							        __lowerCamelCase					,      skip_special_tokens=__lowerCamelCase					,      clean_up_tokenization_spaces=__lowerCamelCase					,      )
							}
					records.append(__lowerCamelCase   )
			return records





@add_end_docstrings(UpperCAmelCase_						)
class 		snake_case_   (							UpperCAmelCase_						):







	'''simple docstring'''
	__UpperCamelCase   =		'''summary'''




	def __call__(						self							:     Dict					,      *__lowerCamelCase							:     Optional[int]					,      **__lowerCamelCase							:     List[Any]   )       -> Tuple:

			'''simple docstring'''




			return super().__call__(*__lowerCamelCase					,      **__lowerCamelCase   )






	def    UpperCAmelCase			(						self							:     Optional[int]					,      __lowerCamelCase							:     int					,      __lowerCamelCase							:     int					,      __lowerCamelCase							:     int   )       -> bool:

			'''simple docstring'''




			if max_length < min_length:
					logger.warning(F"Your min_length={min_length} must be inferior than your max_length={max_length}."   )

			if input_length < max_length:
					logger.warning(
					    F"Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is "
					    'a summarization task, where outputs shorter than the input are typically wanted, you might '
					    F"consider decreasing max_length manually, e.g. summarizer('...', max_length={input_length//2})"   )





@add_end_docstrings(UpperCAmelCase_						)
class 		snake_case_   (							UpperCAmelCase_						):







	'''simple docstring'''
	__UpperCamelCase   =		'''translation'''




	def    UpperCAmelCase			(						self							:     List[str]					,      __lowerCamelCase							:     int					,      __lowerCamelCase							:     int					,      __lowerCamelCase							:     int   )       -> Any:

			'''simple docstring'''




			if input_length > 0.9 * max_length:
					logger.warning(
					    F"Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider "
					    'increasing your max_length manually, e.g. translator(\'...\', max_length=400)'   )
			return True




	def    UpperCAmelCase			(						self							:     Dict					,      *__lowerCamelCase							:     Dict					,      __lowerCamelCase							:     Optional[Any]=TruncationStrategy.DO_NOT_TRUNCATE					,      __lowerCamelCase							:     str=None					,      __lowerCamelCase							:     Tuple=None   )       -> Dict:

			'''simple docstring'''




			if getattr(self.tokenizer					,      '_build_translation_inputs'					,      __lowerCamelCase   ):
					return self.tokenizer._build_translation_inputs(
					    *__lowerCamelCase					,      return_tensors=self.framework					,      truncation=__lowerCamelCase					,      src_lang=__lowerCamelCase					,      tgt_lang=__lowerCamelCase   )
			else:
					return super()._parse_and_tokenize(*__lowerCamelCase					,      truncation=__lowerCamelCase   )




	def    UpperCAmelCase			(						self							:     Tuple					,      __lowerCamelCase							:     Dict=None					,      __lowerCamelCase							:     List[Any]=None					,      **__lowerCamelCase							:     Optional[int]   )       -> Tuple:

			'''simple docstring'''




			__lowercase						,      __lowercase						,      __lowercase											=     super()._sanitize_parameters(**__lowerCamelCase   )
			if src_lang is not None:
					__lowercase											=     src_lang
			if tgt_lang is not None:
					__lowercase											=     tgt_lang
			if src_lang is None and tgt_lang is None:
					# Backward compatibility, direct arguments use is preferred.
					__lowercase											=     kwargs.get('task'					,      self.task   )
					__lowercase											=     task.split('_'   )
					if task and len(__lowerCamelCase   ) == 4:
							# translation, XX, to YY
							__lowercase											=     items[1]
							__lowercase											=     items[3]
			return preprocess_params, forward_params, postprocess_params






	def __call__(						self							:     str					,      *__lowerCamelCase							:     Union[str, Any]					,      **__lowerCamelCase							:     Union[str, Any]   )       -> str:

			'''simple docstring'''




			return super().__call__(*__lowerCamelCase					,      **__lowerCamelCase   )











import os
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen, xsplitext
from ..table import array_cast
from ..utils.py_utils import no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
		from .features import FeatureType


SCREAMING_SNAKE_CASE_	,SCREAMING_SNAKE_CASE_	,SCREAMING_SNAKE_CASE_   :      Any			=   False, False, False

@dataclass
class 		snake_case_   :







	'''simple docstring'''
	__UpperCamelCase   =		None
	__UpperCamelCase   =		True
	__UpperCamelCase   =		True
	__UpperCamelCase   =		None
	# Automatically constructed
	__UpperCamelCase   =		"dict"
	__UpperCamelCase   =		pa.struct({'''bytes''': pa.binary(), '''path''': pa.string()}						)
	__UpperCamelCase   =		field(default='''Audio'''     ,     init=UpperCAmelCase_     ,     repr=UpperCAmelCase_						)




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

			'''simple docstring'''




			return self.pa_type




	def    UpperCAmelCase			(						self							:     List[Any]					,      __lowerCamelCase							:     Union[str, bytes, dict]   )       -> dict:

			'''simple docstring'''




			try:
					import soundfile as sf  # soundfile is a dependency of librosa, needed to decode audio files.
			except ImportError as err:
					raise ImportError('To support encoding audio data, please install \'soundfile\'.'   ) from err
			if isinstance(__lowerCamelCase					,      __lowerCamelCase   ):
					return {"bytes": None, "path": value}
			elif isinstance(__lowerCamelCase					,      __lowerCamelCase   ):
					return {"bytes": value, "path": None}
			elif "array" in value:
					# convert the audio array to wav bytes
					__lowercase											=     BytesIO()
					sf.write(__lowerCamelCase					,      value['array']					,      value['sampling_rate']					,      format='wav'   )
					return {"bytes": buffer.getvalue(), "path": None}
			elif value.get('path'   ) is not None and os.path.isfile(value['path']   ):
					# we set "bytes": None to not duplicate the data if they're already available locally
					if value["path"].endswith('pcm'   ):
							# "PCM" only has raw audio bytes
							if value.get('sampling_rate'   ) is None:
									# At least, If you want to convert "PCM-byte" to "WAV-byte", you have to know sampling rate
									raise KeyError('To use PCM files, please specify a \'sampling_rate\' in Audio object'   )
							if value.get('bytes'   ):
									# If we already had PCM-byte, we don`t have to make "read file, make bytes" (just use it!)
									__lowercase											=     np.frombuffer(value['bytes']					,      dtype=np.intaa   ).astype(np.floataa   ) / 32_767
							else:
									__lowercase											=     np.memmap(value['path']					,      dtype='h'					,      mode='r'   ).astype(np.floataa   ) / 32_767

							__lowercase											=     BytesIO(bytes()   )
							sf.write(__lowerCamelCase					,      __lowerCamelCase					,      value['sampling_rate']					,      format='wav'   )
							return {"bytes": buffer.getvalue(), "path": None}
					else:
							return {"bytes": None, "path": value.get('path'   )}
			elif value.get('bytes'   ) is not None or value.get('path'   ) is not None:
					# store the audio bytes, and path is used to infer the audio format using the file extension
					return {"bytes": value.get('bytes'   ), "path": value.get('path'   )}
			else:
					raise ValueError(
					    F"An audio sample should have one of 'path' or 'bytes' but they are missing or None in {value}."   )




	def    UpperCAmelCase			(						self							:     Any					,      __lowerCamelCase							:     dict					,      __lowerCamelCase							:     Optional[Dict[str, Union[str, bool, None]]] = None   )       -> dict:

			'''simple docstring'''




			if not self.decode:
					raise RuntimeError('Decoding is disabled for this feature. Please use Audio(decode=True) instead.'   )

			__lowercase						,      __lowercase											=     (value['path'], BytesIO(value['bytes']   )) if value['bytes'] is not None else (value['path'], None)
			if path is None and file is None:
					raise ValueError(F"An audio sample should have one of 'path' or 'bytes' but both are None in {value}."   )

			try:
					import librosa
					import soundfile as sf
			except ImportError as err:
					raise ImportError('To support decoding audio files, please install \'librosa\' and \'soundfile\'.'   ) from err

			__lowercase											=     xsplitext(__lowerCamelCase   )[1][1:].lower() if path is not None else None
			if not config.IS_OPUS_SUPPORTED and audio_format == "opus":
					raise RuntimeError(
					    'Decoding \'opus\' files requires system library \'libsndfile\'>=1.0.31, '
					    'You can try to update `soundfile` python library: `pip install "soundfile>=0.12.1"`. '   )
			elif not config.IS_MP3_SUPPORTED and audio_format == "mp3":
					raise RuntimeError(
					    'Decoding \'mp3\' files requires system library \'libsndfile\'>=1.1.0, '
					    'You can try to update `soundfile` python library: `pip install "soundfile>=0.12.1"`. '   )

			if file is None:
					__lowercase											=     token_per_repo_id or {}
					__lowercase											=     path.split('::'   )[-1]
					try:
							__lowercase											=     string_to_dict(__lowerCamelCase					,      config.HUB_DATASETS_URL   )['repo_id']
							__lowercase											=     token_per_repo_id[repo_id]
					except (ValueError, KeyError):
							__lowercase											=     None

					with xopen(__lowerCamelCase					,      'rb'					,      use_auth_token=__lowerCamelCase   ) as f:
							__lowercase						,      __lowercase											=     sf.read(__lowerCamelCase   )

			else:
					__lowercase						,      __lowercase											=     sf.read(__lowerCamelCase   )

			__lowercase											=     array.T
			if self.mono:
					__lowercase											=     librosa.to_mono(__lowerCamelCase   )
			if self.sampling_rate and self.sampling_rate != sampling_rate:
					__lowercase											=     librosa.resample(__lowerCamelCase					,      orig_sr=__lowerCamelCase					,      target_sr=self.sampling_rate   )
					__lowercase											=     self.sampling_rate

			return {"path": path, "array": array, "sampling_rate": sampling_rate}




	def    UpperCAmelCase			(						self							:     int   )       -> Union["FeatureType", Dict[str, "FeatureType"]]:

			'''simple docstring'''




			from .features import Value

			if self.decode:
					raise ValueError('Cannot flatten a decoded Audio feature.'   )
			return {
			    "bytes": Value('binary'   ),
			    "path": Value('string'   ),
			}




	def    UpperCAmelCase			(						self							:     List[Any]					,      __lowerCamelCase							:     Union[pa.StringArray, pa.StructArray]   )       -> pa.StructArray:

			'''simple docstring'''




			if pa.types.is_string(storage.type   ):
					__lowercase											=     pa.array([None] * len(__lowerCamelCase   )					,      type=pa.binary()   )
					__lowercase											=     pa.StructArray.from_arrays([bytes_array, storage]					,      ['bytes', 'path']					,      mask=storage.is_null()   )
			elif pa.types.is_binary(storage.type   ):
					__lowercase											=     pa.array([None] * len(__lowerCamelCase   )					,      type=pa.string()   )
					__lowercase											=     pa.StructArray.from_arrays([storage, path_array]					,      ['bytes', 'path']					,      mask=storage.is_null()   )
			elif pa.types.is_struct(storage.type   ) and storage.type.get_all_field_indices('array'   ):
					__lowercase											=     pa.array([Audio().encode_example(__lowerCamelCase   ) if x is not None else None for x in storage.to_pylist()]   )
			elif pa.types.is_struct(storage.type   ):
					if storage.type.get_field_index('bytes'   ) >= 0:
							__lowercase											=     storage.field('bytes'   )
					else:
							__lowercase											=     pa.array([None] * len(__lowerCamelCase   )					,      type=pa.binary()   )
					if storage.type.get_field_index('path'   ) >= 0:
							__lowercase											=     storage.field('path'   )
					else:
							__lowercase											=     pa.array([None] * len(__lowerCamelCase   )					,      type=pa.string()   )
					__lowercase											=     pa.StructArray.from_arrays([bytes_array, path_array]					,      ['bytes', 'path']					,      mask=storage.is_null()   )
			return array_cast(__lowerCamelCase					,      self.pa_type   )






	def    UpperCAmelCase			(						self							:     Union[str, Any]					,      __lowerCamelCase							:     pa.StructArray   )       -> pa.StructArray:

			'''simple docstring'''




			@no_op_if_value_is_null
			def path_to_bytes(__lowerCamelCase							:     Any   ):
					with xopen(__lowerCamelCase					,      'rb'   ) as f:
							__lowercase											=     f.read()
					return bytes_

			__lowercase											=     pa.array(
			    [
			        (path_to_bytes(x['path']   ) if x['bytes'] is None else x['bytes']) if x is not None else None
			        for x in storage.to_pylist()
			    ]					,      type=pa.binary()					,      )
			__lowercase											=     pa.array(
			    [os.path.basename(__lowerCamelCase   ) if path is not None else None for path in storage.field('path'   ).to_pylist()]					,      type=pa.string()					,      )
			__lowercase											=     pa.StructArray.from_arrays([bytes_array, path_array]					,      ['bytes', 'path']					,      mask=bytes_array.is_null()   )
			return array_cast(__lowerCamelCase					,      self.pa_type   )




