



"""simple docstring"""




from __future__ import annotations


def   lowercase__     (			_UpperCAmelCase	,      _UpperCAmelCase				)     ->			int:






      '''simple docstring'''


      lowercase	,    lowercase  :      Any					=   0, len(_UpperCAmelCase				) - 1
      while start_ind <= end_ind:
            if array[start_ind] == search_item:
                  return start_ind
            elif array[end_ind] == search_item:
                  return end_ind
            else:
                  start_ind += 1
                  end_ind -= 1
    # returns -1 if search_item is not found in array
      return -1


if __name__ == "__main__":
     print(double_linear_search(list(range(1_0_0)), 4_0))





"""simple docstring"""




import os
import pathlib
import tempfile
import uuid

import numpy as np

from ..utils import is_soundfile_availble, is_torch_available, is_vision_available, logging


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

if is_vision_available():
     import PIL.Image
     from PIL import Image
     from PIL.Image import Image as ImageType
else:
     _UpperCamelCase:				Tuple    							=  object

if is_torch_available():
     import torch

if is_soundfile_availble():
     import soundfile as sf


class   a__		:


   def __init__(							self      :							Union[str, Any],     lowerCAmelCase      :							Optional[int]			)    ->       Any:
         lowercase  :      Dict					=   value


   def __str__(							self      :							List[str]			)    ->       Union[str, Any]:
         return self.to_string()


   def        lowercase				(							self      :							Dict			)    ->       Optional[Any]:
         logger.error(
             'This is a raw AgentType of unknown type. Display in notebooks and string conversion will be unreliable'			)
         return self._value






   def        lowercase				(							self      :							List[Any]			)    ->       str:
         logger.error(
             'This is a raw AgentType of unknown type. Display in notebooks and string conversion will be unreliable'			)
         return str(self._value			)




class   a__		(						SCREAMING_SNAKE_CASE__,  SCREAMING_SNAKE_CASE__     ):


   def        lowercase				(							self      :							List[Any]			)    ->       List[Any]:
         return self._value






   def        lowercase				(							self      :							str			)    ->       Optional[int]:
         return self._value




class   a__		(						SCREAMING_SNAKE_CASE__,  SCREAMING_SNAKE_CASE__     ):


   def __init__(							self      :							int,     lowerCAmelCase      :							Optional[Any]			)    ->       Any:
         super().__init__(lowerCAmelCase			)

         if not is_vision_available():
               raise ImportError('PIL must be installed in order to handle images.'			)

         lowercase  :      Union[str, Any]					=   None
         lowercase  :      List[str]					=   None
         lowercase  :      Optional[Any]					=   None

         if isinstance(lowerCAmelCase,     lowerCAmelCase			):
               lowercase  :      List[Any]					=   value
         elif isinstance(lowerCAmelCase,     (str, pathlib.Path)			):
               lowercase  :      Any					=   value
         elif isinstance(lowerCAmelCase,     torch.Tensor			):
               lowercase  :      str					=   value
         else:
               raise ValueError(f'''Unsupported type for {self.__class__.__name__}: {type(lowerCAmelCase			)}'''			)


   def        lowercase				(							self      :							int,     lowerCAmelCase      :							Union[str, Any]=None,     lowerCAmelCase      :							Optional[Any]=None			)    ->       List[Any]:
         from IPython.display import Image, display

         display(Image(self.to_string()			)			)


   def        lowercase				(							self      :							int			)    ->       List[str]:
         if self._raw is not None:
               return self._raw

         if self._path is not None:
               lowercase  :      Any					=   Image.open(self._path			)
               return self._raw






   def        lowercase				(							self      :							List[Any]			)    ->       List[Any]:
         if self._path is not None:
               return self._path

         if self._raw is not None:
               lowercase  :      Tuple					=   tempfile.mkdtemp()
               lowercase  :      Dict					=   os.path.join(lowerCAmelCase,     str(uuid.uuida()			) + '.png'			)
               self._raw.save(self._path			)

               return self._path

         if self._tensor is not None:
               lowercase  :      Optional[int]					=   self._tensor.cpu().detach().numpy()

               # There is likely simpler than load into image into save
               lowercase  :      Dict					=   Image.fromarray((array * 255).astype(np.uinta			)			)

               lowercase  :      Optional[int]					=   tempfile.mkdtemp()
               lowercase  :      Any					=   os.path.join(lowerCAmelCase,     str(uuid.uuida()			) + '.png'			)

               img.save(self._path			)

               return self._path




class   a__		(						SCREAMING_SNAKE_CASE__     ):


   def __init__(							self      :							Dict,     lowerCAmelCase      :							Any,     lowerCAmelCase      :							Any=16000			)    ->       Tuple:
         super().__init__(lowerCAmelCase			)

         if not is_soundfile_availble():
               raise ImportError('soundfile must be installed in order to handle audio.'			)

         lowercase  :      List[str]					=   None
         lowercase  :      List[Any]					=   None

         lowercase  :      Optional[Any]					=   samplerate

         if isinstance(lowerCAmelCase,     (str, pathlib.Path)			):
               lowercase  :      List[Any]					=   value
         elif isinstance(lowerCAmelCase,     torch.Tensor			):
               lowercase  :      List[str]					=   value
         else:
               raise ValueError(f'''Unsupported audio type: {type(lowerCAmelCase			)}'''			)


   def        lowercase				(							self      :							Optional[int],     lowerCAmelCase      :							Optional[Any]=None,     lowerCAmelCase      :							int=None			)    ->       Optional[Any]:
         from IPython.display import Audio, display

         display(Audio(self.to_string(),     rate=self.samplerate			)			)


   def        lowercase				(							self      :							Any			)    ->       Union[str, Any]:
         if self._tensor is not None:
               return self._tensor

         if self._path is not None:
               lowercase	,    lowercase  :      List[Any]					=   sf.read(self._path			)
               lowercase  :      int					=   torch.tensor(lowerCAmelCase			)
               return self._tensor






   def        lowercase				(							self      :							Tuple			)    ->       Tuple:
         if self._path is not None:
               return self._path

         if self._tensor is not None:
               lowercase  :      str					=   tempfile.mkdtemp()
               lowercase  :      Union[str, Any]					=   os.path.join(lowerCAmelCase,     str(uuid.uuida()			) + '.wav'			)
               sf.write(self._path,     self._tensor,     samplerate=self.samplerate			)
               return self._path




_UpperCamelCase:				Optional[int]    							=  {'text': AgentText, 'image': AgentImage, 'audio': AgentAudio}
_UpperCamelCase:				Optional[int]    							=  {str: AgentText}

if is_vision_available():
     _UpperCamelCase:				str    							=  AgentImage


def   lowercase__     (			*_UpperCAmelCase	,      **_UpperCAmelCase				)     ->			Any:






      '''simple docstring'''


      lowercase  :      str					=   [(arg.to_raw() if isinstance(_UpperCAmelCase	,      _UpperCAmelCase				) else arg) for arg in args]
      lowercase  :      Optional[Any]					=   {k: (v.to_raw() if isinstance(_UpperCAmelCase	,      _UpperCAmelCase				) else v) for k, v in kwargs.items()}
      return args, kwargs





def   lowercase__     (			_UpperCAmelCase	,      _UpperCAmelCase=None				)     ->			Tuple:






      '''simple docstring'''


      if isinstance(_UpperCAmelCase	,      _UpperCAmelCase				):
            lowercase  :      List[Any]					=   {}
            for i, (k, v) in enumerate(outputs.items()				):
                  if output_types is not None:
                        # If the class has defined outputs, we can map directly according to the class definition
                        if output_types[i] in AGENT_TYPE_MAPPING:
                              lowercase  :      int					=   AGENT_TYPE_MAPPING[output_types[i]](_UpperCAmelCase				)
                        else:
                              lowercase  :      Union[str, Any]					=   AgentType(_UpperCAmelCase				)

                  else:
                        # If the class does not have defined output, then we map according to the type
                        for _k, _v in INSTANCE_TYPE_MAPPING.items():
                              if isinstance(_UpperCAmelCase	,      _k				):
                                    lowercase  :      Optional[int]					=   _v(_UpperCAmelCase				)
                        if k not in decoded_outputs:
                              lowercase  :      str					=   AgentType[v]

      elif isinstance(_UpperCAmelCase	,      (list, tuple)				):
            lowercase  :      Union[str, Any]					=   type(_UpperCAmelCase				)()
            for i, v in enumerate(_UpperCAmelCase				):
                  if output_types is not None:
                        # If the class has defined outputs, we can map directly according to the class definition
                        if output_types[i] in AGENT_TYPE_MAPPING:
                              decoded_outputs.append(AGENT_TYPE_MAPPING[output_types[i]](_UpperCAmelCase				)				)
                        else:
                              decoded_outputs.append(AgentType(_UpperCAmelCase				)				)
                  else:
                        # If the class does not have defined output, then we map according to the type
                        lowercase  :      Any					=   False
                        for _k, _v in INSTANCE_TYPE_MAPPING.items():
                              if isinstance(_UpperCAmelCase	,      _k				):
                                    decoded_outputs.append(_v(_UpperCAmelCase				)				)
                                    lowercase  :      Optional[Any]					=   True

                        if not found:
                              decoded_outputs.append(AgentType(_UpperCAmelCase				)				)

      else:
            if output_types[0] in AGENT_TYPE_MAPPING:
                  # If the class has defined outputs, we can map directly according to the class definition
                  lowercase  :      List[Any]					=   AGENT_TYPE_MAPPING[output_types[0]](_UpperCAmelCase				)

            else:
                  # If the class does not have defined output, then we map according to the type
                  for _k, _v in INSTANCE_TYPE_MAPPING.items():
                        if isinstance(_UpperCAmelCase	,      _k				):
                              return _v(_UpperCAmelCase				)
                  return AgentType(_UpperCAmelCase				)

      return decoded_outputs
