



"""simple docstring"""


from collections import UserDict
from typing import Union

import numpy as np
import requests

from ..utils import (
    add_end_docstrings,
    logging,
)
from .audio_classification import ffmpeg_read
from .base import PIPELINE_INIT_ARGS, Pipeline


__A   :							List[str]										=   logging.get_logger(__name__)
@add_end_docstrings(lowerCAmelCase)
class 			_a (					lowerCAmelCase):
   """simple docstring"""



   def __init__(		self     :    Union[str, Any]				,   **__UpperCamelCase     :    Optional[Any]   )->List[Any]:
       super().__init__(**__UpperCamelCase   )

       if self.framework != "pt":
           raise ValueError(F'The {self.__class__} is only available in PyTorch.'   )
       # No specific FOR_XXX available yet



   def __call__(		self     :    Optional[int]				,   __UpperCamelCase     :    Union[np.ndarray, bytes, str]				,   **__UpperCamelCase     :    Tuple   )->List[str]:
       return super().__call__(__UpperCamelCase				,   **__UpperCamelCase   )



   def  lowercase__						(		self     :    Any				,   **__UpperCamelCase     :    Any   )->Union[str, Any]:
       _UpperCAmelCase					=    {}
       if "candidate_labels" in kwargs:
           _UpperCAmelCase					=    kwargs['''candidate_labels''']
       if "hypothesis_template" in kwargs:
           _UpperCAmelCase					=    kwargs['''hypothesis_template''']

       return preprocess_params, {}, {}



   def  lowercase__						(		self     :    Optional[int]				,   __UpperCamelCase     :    Union[str, Any]				,   __UpperCamelCase     :    List[Any]=None				,   __UpperCamelCase     :    Tuple="This is a sound of {}."   )->int:
       if isinstance(__UpperCamelCase				,   __UpperCamelCase   ):
           if audio.startswith('''http://'''   ) or audio.startswith('''https://'''   ):
               # We need to actually check for a real protocol, otherwise it's impossible to use a local file
               # like http_huggingface_co.png
               _UpperCAmelCase					=    requests.get(__UpperCamelCase   ).content
           else:
               with open(__UpperCamelCase				,   '''rb'''   ) as f:
                   _UpperCAmelCase					=    f.read()

       if isinstance(__UpperCamelCase				,   __UpperCamelCase   ):
           _UpperCAmelCase					=    ffmpeg_read(__UpperCamelCase				,   self.feature_extractor.sampling_rate   )

       if not isinstance(__UpperCamelCase				,   np.ndarray   ):
           raise ValueError('''We expect a numpy ndarray as input'''   )
       if len(audio.shape   ) != 1:
           raise ValueError('''We expect a single channel audio input for ZeroShotAudioClassificationPipeline'''   )

       _UpperCAmelCase					=    self.feature_extractor(
           [audio]				,   sampling_rate=self.feature_extractor.sampling_rate				,   return_tensors='''pt'''   )
       _UpperCAmelCase					=    candidate_labels
       _UpperCAmelCase					=    [hypothesis_template.format(__UpperCamelCase   ) for x in candidate_labels]
       _UpperCAmelCase					=    self.tokenizer(__UpperCamelCase				,   return_tensors=self.framework				,   padding=__UpperCamelCase   )
       _UpperCAmelCase					=    [text_inputs]
       return inputs



   def  lowercase__						(		self     :    Union[str, Any]				,   __UpperCamelCase     :    Optional[int]   )->Any:
       _UpperCAmelCase					=    model_inputs.pop('''candidate_labels'''   )
       _UpperCAmelCase					=    model_inputs.pop('''text_inputs'''   )
       if isinstance(text_inputs[0]				,   __UpperCamelCase   ):
           _UpperCAmelCase					=    text_inputs[0]
       else:
           # Batching case.
           _UpperCAmelCase					=    text_inputs[0][0]

       _UpperCAmelCase					=    self.model(**__UpperCamelCase				,   **__UpperCamelCase   )

       _UpperCAmelCase					=    {
           '''candidate_labels''': candidate_labels,
           '''logits''': outputs.logits_per_audio,
       }
       return model_outputs



   def  lowercase__						(		self     :    List[str]				,   __UpperCamelCase     :    Any   )->List[Any]:
       _UpperCAmelCase					=    model_outputs.pop('''candidate_labels'''   )
       _UpperCAmelCase					=    model_outputs['''logits'''][0]

       if self.framework == "pt":
           _UpperCAmelCase					=    logits.softmax(dim=0   )
           _UpperCAmelCase					=    probs.tolist()
       else:
           raise ValueError('''`tf` framework not supported.'''   )

       _UpperCAmelCase					=    [
           {'''score''': score, '''label''': candidate_label}
           for score, candidate_label in sorted(zip(__UpperCamelCase				,   __UpperCamelCase   )				,   key=lambda __UpperCamelCase   : -x[0]   )
       ]
       return result








"""simple docstring"""


def  lowercase	(      _SCREAMING_SNAKE_CASE   :						int					,     _SCREAMING_SNAKE_CASE   :						int				):






				'''simple docstring'''



				if a < 0 or b < 0:
								raise ValueError('''the value of both inputs must be positive'''				)

				_UpperCAmelCase					=    str(bin(_SCREAMING_SNAKE_CASE				)				)[2:]  # remove the leading "0b"
				_UpperCAmelCase					=    str(bin(_SCREAMING_SNAKE_CASE				)				)[2:]  # remove the leading "0b"

				_UpperCAmelCase					=    max(len(_SCREAMING_SNAKE_CASE				)					,     len(_SCREAMING_SNAKE_CASE				)				)

				return "0b" + "".join(
				    str(int(char_a == '''1''' and char_b == '''1'''				)				)
				    for char_a, char_b in zip(a_binary.zfill(_SCREAMING_SNAKE_CASE				)					,     b_binary.zfill(_SCREAMING_SNAKE_CASE				)				)				)


if __name__ == "__main__":
					import doctest

					doctest.testmod()



