


'''simple docstring'''




from typing import Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
 from PIL import Image

 from ..image_utils import load_image

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

UpperCAmelCase_      :		Tuple          =		logging.get_logger(__name__)







@add_end_docstrings(snake_case__  )
class 					a			(				snake_case__  ):
 '''simple docstring'''




 def __init__(    self		,      *lowerCamelCase_		,      **lowerCamelCase_      )      ->    Optional[int]:
    super().__init__(*lowerCamelCase_		,      **lowerCamelCase_      )
    self.check_model_type(lowerCamelCase_      )




 def   __UpperCamelCase   (    self		,      lowerCamelCase_=None		,      lowerCamelCase_=None		,      lowerCamelCase_=None		,      **lowerCamelCase_      )      ->    Optional[int]:
    _a		,						_a					:  str						=  {}, {}
    if padding is not None:
       _a					:  str						=  padding
    if truncation is not None:
       _a					:  List[str]						=  truncation
    if top_k is not None:
       _a					:  Any						=  top_k
    return preprocess_params, {}, postprocess_params




 def __call__(    self		,      lowerCamelCase_		,      lowerCamelCase_ = None		,      **lowerCamelCase_      )      ->    str:
    if isinstance(lowerCamelCase_		,      (Image.Image, str)      ) and isinstance(lowerCamelCase_		,      lowerCamelCase_      ):
       _a					:  int						=  {'image': image, 'question': question}
    else:
       _a					:  Dict						=  image
    _a					:  Union[str, Any]						=  super().__call__(lowerCamelCase_		,      **lowerCamelCase_      )
    return results




 def   __UpperCamelCase   (    self		,      lowerCamelCase_		,      lowerCamelCase_=False		,      lowerCamelCase_=False      )      ->    Optional[Any]:
    _a					:  str						=  load_image(inputs['image']      )
    _a					:  Any						=  self.tokenizer(
        inputs['question']		,      return_tensors=self.framework		,      padding=lowerCamelCase_		,      truncation=lowerCamelCase_      )
    _a					:  Dict						=  self.image_processor(images=lowerCamelCase_		,      return_tensors=self.framework      )
    model_inputs.update(lowerCamelCase_      )
    return model_inputs




 def   __UpperCamelCase   (    self		,      lowerCamelCase_      )      ->    int:
    _a					:  Optional[Any]						=  self.model(**lowerCamelCase_      )
    return model_outputs




 def   __UpperCamelCase   (    self		,      lowerCamelCase_		,      lowerCamelCase_=5      )      ->    List[Any]:
    if top_k > self.model.config.num_labels:
       _a					:  int						=  self.model.config.num_labels

    if self.framework == "pt":
       _a					:  Union[str, Any]						=  model_outputs.logits.sigmoid()[0]
       _a		,						_a					:  Optional[Any]						=  probs.topk(lowerCamelCase_      )
    else:
       raise ValueError(F'''Unsupported framework: {self.framework}'''      )

    _a					:  Union[str, Any]						=  scores.tolist()
    _a					:  List[str]						=  ids.tolist()
    return [{"score": score, "answer": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase_		,      lowerCamelCase_      )]






'''simple docstring'''




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


UpperCAmelCase_     ,					UpperCAmelCase_     ,					UpperCAmelCase_      :		Dict          =		False, False, False







@dataclass
class 					a			:
 '''simple docstring'''




 __lowerCAmelCase						: Optional[int]							  =		None
 __lowerCAmelCase						: bool							  =		True
 __lowerCAmelCase						: bool							  =		True
 __lowerCAmelCase						: Optional[str]							  =		None
 # Automatically constructed
 __lowerCAmelCase						: ClassVar[str]							  =		"dict"
 __lowerCAmelCase						: ClassVar[Any]							  =		pa.struct({"""bytes""": pa.binary(), """path""": pa.string()}  )
 __lowerCAmelCase						: str							  =		field(default="""Audio"""			,							init=snake_case__			,							repr=snake_case__  )




 def __call__(    self      )      ->    Union[str, Any]:
    return self.pa_type




 def   __UpperCamelCase   (    self		,      lowerCamelCase_      )      ->    dict:
    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
       _a					:  Union[str, Any]						=  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!)
             _a					:  Optional[Any]						=  np.frombuffer(value['bytes']		,      dtype=np.intaa      ).astype(np.floataa      ) / 3_2_7_6_7
          else:
             _a					:  Optional[int]						=  np.memmap(value['path']		,      dtype='h'		,      mode='r'      ).astype(np.floataa      ) / 3_2_7_6_7

          _a					:  Dict						=  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		,      lowerCamelCase_		,      lowerCamelCase_ = None      )      ->    dict:
    if not self.decode:
       raise RuntimeError('Decoding is disabled for this feature. Please use Audio(decode=True) instead.'      )

    _a		,						_a					:  List[Any]						=  (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

    _a					:  Optional[int]						=  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:
       _a					:  Dict						=  token_per_repo_id or {}
       _a					:  List[Any]						=  path.split('::'      )[-1]
       try:
          _a					:  List[str]						=  string_to_dict(lowerCamelCase_		,      config.HUB_DATASETS_URL      )['repo_id']
          _a					:  List[Any]						=  token_per_repo_id[repo_id]
       except (ValueError, KeyError):
          _a					:  Optional[int]						=  None

       with xopen(lowerCamelCase_		,      'rb'		,      use_auth_token=lowerCamelCase_      ) as f:
          _a		,						_a					:  Union[str, Any]						=  sf.read(lowerCamelCase_      )

    else:
       _a		,						_a					:  Optional[int]						=  sf.read(lowerCamelCase_      )

    _a					:  str						=  array.T
    if self.mono:
       _a					:  List[str]						=  librosa.to_mono(lowerCamelCase_      )
    if self.sampling_rate and self.sampling_rate != sampling_rate:
       _a					:  List[Any]						=  librosa.resample(lowerCamelCase_		,      orig_sr=lowerCamelCase_		,      target_sr=self.sampling_rate      )
       _a					:  Tuple						=  self.sampling_rate

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




 def   __UpperCamelCase   (    self      )      ->    Union["FeatureType", Dict[str, "FeatureType"]]:
    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		,      lowerCamelCase_      )      ->    pa.StructArray:
    if pa.types.is_string(storage.type      ):
       _a					:  Any						=  pa.array([None] * len(lowerCamelCase_      )		,      type=pa.binary()      )
       _a					:  Tuple						=  pa.StructArray.from_arrays([bytes_array, storage]		,      ['bytes', 'path']		,      mask=storage.is_null()      )
    elif pa.types.is_binary(storage.type      ):
       _a					:  Union[str, Any]						=  pa.array([None] * len(lowerCamelCase_      )		,      type=pa.string()      )
       _a					:  Union[str, Any]						=  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'      ):
       _a					:  Optional[Any]						=  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:
          _a					:  Optional[Any]						=  storage.field('bytes'      )
       else:
          _a					:  Tuple						=  pa.array([None] * len(lowerCamelCase_      )		,      type=pa.binary()      )
       if storage.type.get_field_index('path'      ) >= 0:
          _a					:  Any						=  storage.field('path'      )
       else:
          _a					:  Tuple						=  pa.array([None] * len(lowerCamelCase_      )		,      type=pa.string()      )
       _a					:  Optional[Any]						=  pa.StructArray.from_arrays([bytes_array, path_array]		,      ['bytes', 'path']		,      mask=storage.is_null()      )
    return array_cast(lowerCamelCase_		,      self.pa_type      )




 def   __UpperCamelCase   (    self		,      lowerCamelCase_      )      ->    pa.StructArray:

    @no_op_if_value_is_null
    def path_to_bytes(lowerCamelCase_      ):
       with xopen(lowerCamelCase_		,      'rb'      ) as f:
          _a					:  Union[str, Any]						=  f.read()
       return bytes_

    _a					:  Optional[int]						=  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()		,      )
    _a					:  int						=  pa.array(
        [os.path.basename(lowerCamelCase_      ) if path is not None else None for path in storage.field('path'      ).to_pylist()]		,      type=pa.string()		,      )
    _a					:  Dict						=  pa.StructArray.from_arrays([bytes_array, path_array]		,      ['bytes', 'path']		,      mask=bytes_array.is_null()      )
    return array_cast(lowerCamelCase_		,      self.pa_type      )


