


import warnings
from typing import List

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import is_flax_available, is_tf_available, is_torch_available




class A  (   UpperCamelCase_     ):
      UpperCamelCase__							:  Any      =['image_processor', 'tokenizer']
      UpperCamelCase__							:  List[Any]      ='OwlViTImageProcessor'
      UpperCamelCase__							:  Tuple      =('CLIPTokenizer', 'CLIPTokenizerFast')






      def __init__(					self						:     Union[str, Any]			,   lowercase_						:     int=None			,   lowercase_						:     str=None			,   **lowercase_						:     List[str] )					->						Any:
             """simple docstring"""




             _lowerCamelCase       :		Dict		=None
             if "feature_extractor" in kwargs:
                    warnings.warn(
                        'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
                        ' instead.'			,   lowercase_			,   )
                    _lowerCamelCase       :		str		=kwargs.pop('feature_extractor' )

             _lowerCamelCase       :		Dict		=image_processor if image_processor is not None else feature_extractor
             if image_processor is None:
                    raise ValueError('You need to specify an `image_processor`.' )
             if tokenizer is None:
                    raise ValueError('You need to specify a `tokenizer`.' )

             super().__init__(lowercase_			,   lowercase_ )






      def __call__(					self						:     Optional[int]			,   lowercase_						:     List[str]=None			,   lowercase_						:     str=None			,   lowercase_						:     Tuple=None			,   lowercase_						:     Any="max_length"			,   lowercase_						:     Any="np"			,   **lowercase_						:     str )					->						Tuple:
             """simple docstring"""




             if text is None and query_images is None and images is None:
                    raise ValueError(
                        'You have to specify at least one text or query image or image. All three cannot be none.' )

             if text is not None:
                    if isinstance(lowercase_			,   lowercase_ ) or (isinstance(lowercase_			,   lowercase_ ) and not isinstance(text[0]			,   lowercase_ )):
                           _lowerCamelCase       :		Optional[int]		=[self.tokenizer(lowercase_			,   padding=lowercase_			,   return_tensors=lowercase_			,   **lowercase_ )]

                    elif isinstance(lowercase_			,   lowercase_ ) and isinstance(text[0]			,   lowercase_ ):
                           _lowerCamelCase       :		Any		=[]

                           # Maximum number of queries across batch
                           _lowerCamelCase       :		Union[str, Any]		=max([len(lowercase_ ) for t in text] )

                           # Pad all batch samples to max number of text queries
                           for t in text:
                                  if len(lowercase_ ) != max_num_queries:
                                         _lowerCamelCase       :		str		=t + [' '] * (max_num_queries - len(lowercase_ ))

                                  _lowerCamelCase       :		Dict		=self.tokenizer(lowercase_			,   padding=lowercase_			,   return_tensors=lowercase_			,   **lowercase_ )
                                  encodings.append(lowercase_ )
                    else:
                           raise TypeError('Input text should be a string, a list of strings or a nested list of strings' )

                    if return_tensors == "np":
                           _lowerCamelCase       :		List[Any]		=np.concatenate([encoding['input_ids'] for encoding in encodings]			,   axis=0 )
                           _lowerCamelCase       :		Union[str, Any]		=np.concatenate([encoding['attention_mask'] for encoding in encodings]			,   axis=0 )

                    elif return_tensors == "jax" and is_flax_available():
                           import jax.numpy as jnp

                           _lowerCamelCase       :		Any		=jnp.concatenate([encoding['input_ids'] for encoding in encodings]			,   axis=0 )
                           _lowerCamelCase       :		Union[str, Any]		=jnp.concatenate([encoding['attention_mask'] for encoding in encodings]			,   axis=0 )

                    elif return_tensors == "pt" and is_torch_available():
                           import torch

                           _lowerCamelCase       :		Tuple		=torch.cat([encoding['input_ids'] for encoding in encodings]			,   dim=0 )
                           _lowerCamelCase       :		List[Any]		=torch.cat([encoding['attention_mask'] for encoding in encodings]			,   dim=0 )

                    elif return_tensors == "tf" and is_tf_available():
                           import tensorflow as tf

                           _lowerCamelCase       :		Any		=tf.stack([encoding['input_ids'] for encoding in encodings]			,   axis=0 )
                           _lowerCamelCase       :		int		=tf.stack([encoding['attention_mask'] for encoding in encodings]			,   axis=0 )

                    else:
                           raise ValueError('Target return tensor type could not be returned' )

                    _lowerCamelCase       :		Any		=BatchEncoding()
                    _lowerCamelCase       :		Dict		=input_ids
                    _lowerCamelCase       :		str		=attention_mask

             if query_images is not None:
                    _lowerCamelCase       :		int		=BatchEncoding()
                    _lowerCamelCase       :		Any		=self.image_processor(
                        lowercase_			,   return_tensors=lowercase_			,   **lowercase_ ).pixel_values
                    _lowerCamelCase       :		List[str]		=query_pixel_values

             if images is not None:
                    _lowerCamelCase       :		List[str]		=self.image_processor(lowercase_			,   return_tensors=lowercase_			,   **lowercase_ )

             if text is not None and images is not None:
                    _lowerCamelCase       :		Union[str, Any]		=image_features.pixel_values
                    return encoding
             elif query_images is not None and images is not None:
                    _lowerCamelCase       :		Optional[int]		=image_features.pixel_values
                    return encoding
             elif text is not None or query_images is not None:
                    return encoding
             else:
                    return BatchEncoding(data=dict(**lowercase_ )			,   tensor_type=lowercase_ )






      def        lowerCamelCase       (					self						:     int			,   *lowercase_						:     Optional[Any]			,   **lowercase_						:     int )					->						List[str]:
             """simple docstring"""




             return self.image_processor.post_process(*lowercase_			,   **lowercase_ )






      def        lowerCamelCase       (					self						:     int			,   *lowercase_						:     Union[str, Any]			,   **lowercase_						:     List[str] )					->						List[str]:
             """simple docstring"""




             return self.image_processor.post_process_object_detection(*lowercase_			,   **lowercase_ )






      def        lowerCamelCase       (					self						:     Tuple			,   *lowercase_						:     List[Any]			,   **lowercase_						:     Optional[int] )					->						Optional[int]:
             """simple docstring"""




             return self.image_processor.post_process_image_guided_detection(*lowercase_			,   **lowercase_ )






      def        lowerCamelCase       (					self						:     List[Any]			,   *lowercase_						:     Optional[int]			,   **lowercase_						:     Tuple )					->						List[str]:
             """simple docstring"""




             return self.tokenizer.batch_decode(*lowercase_			,   **lowercase_ )






      def        lowerCamelCase       (					self						:     List[str]			,   *lowercase_						:     int			,   **lowercase_						:     Optional[int] )					->						List[Any]:
             """simple docstring"""




             return self.tokenizer.decode(*lowercase_			,   **lowercase_ )






      @property
      def        lowerCamelCase       (					self						:     Union[str, Any] )					->						Optional[int]:
             """simple docstring"""




             warnings.warn(
                 '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'			,   lowercase_			,   )
             return self.image_processor_class






      @property
      def        lowerCamelCase       (					self						:     Any )					->						str:
             """simple docstring"""




             warnings.warn(
                 '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'			,   lowercase_			,   )
             return self.image_processor






from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCamelCase											=       logging.get_logger(__name__)

lowerCamelCase											=       {
    'transfo-xl-wt103': 'https://huggingface.co/transfo-xl-wt103/resolve/main/config.json',
}




class A  (   UpperCamelCase_     ):
      UpperCamelCase__							:  Dict      ='transfo-xl'
      UpperCamelCase__							:  int      =['mems']
      UpperCamelCase__							:  List[str]      ={
          'n_token': 'vocab_size',
          'hidden_size': 'd_model',
          'num_attention_heads': 'n_head',
          'num_hidden_layers': 'n_layer',
      }






      def __init__(					self						:     Tuple			,   lowercase_						:     List[Any]=26_7735			,   lowercase_						:     List[Any]=[2_0000, 4_0000, 20_0000]			,   lowercase_						:     Tuple=1024			,   lowercase_						:     Optional[int]=1024			,   lowercase_						:     str=16			,   lowercase_						:     int=64			,   lowercase_						:     Any=4096			,   lowercase_						:     List[Any]=4			,   lowercase_						:     List[Any]=False			,   lowercase_						:     List[str]=18			,   lowercase_						:     Tuple=1600			,   lowercase_						:     List[str]=1000			,   lowercase_						:     Any=True			,   lowercase_						:     str=True			,   lowercase_						:     Optional[int]=0			,   lowercase_						:     List[Any]=-1			,   lowercase_						:     Optional[int]=True			,   lowercase_						:     Any=0.1			,   lowercase_						:     Tuple=0.0			,   lowercase_						:     str=True			,   lowercase_						:     Union[str, Any]="normal"			,   lowercase_						:     Dict=0.01			,   lowercase_						:     Optional[Any]=0.01			,   lowercase_						:     List[Any]=0.02			,   lowercase_						:     List[Any]=1E-5			,   lowercase_						:     Tuple=0			,   **lowercase_						:     Tuple			,   )					->						Dict:
             """simple docstring"""




             _lowerCamelCase       :		Optional[Any]		=vocab_size
             _lowerCamelCase       :		Optional[Any]		=[]
             self.cutoffs.extend(lowercase_ )
             if proj_share_all_but_first:
                    _lowerCamelCase       :		List[str]		=[False] + [True] * len(self.cutoffs )
             else:
                    _lowerCamelCase       :		str		=[False] + [False] * len(self.cutoffs )
             _lowerCamelCase       :		str		=d_model
             _lowerCamelCase       :		str		=d_embed
             _lowerCamelCase       :		str		=d_head
             _lowerCamelCase       :		Dict		=d_inner
             _lowerCamelCase       :		Union[str, Any]		=div_val
             _lowerCamelCase       :		Dict		=pre_lnorm
             _lowerCamelCase       :		Tuple		=n_layer
             _lowerCamelCase       :		Optional[Any]		=n_head
             _lowerCamelCase       :		List[Any]		=mem_len
             _lowerCamelCase       :		List[Any]		=same_length
             _lowerCamelCase       :		Optional[int]		=attn_type
             _lowerCamelCase       :		List[str]		=clamp_len
             _lowerCamelCase       :		int		=sample_softmax
             _lowerCamelCase       :		List[Any]		=adaptive
             _lowerCamelCase       :		List[str]		=dropout
             _lowerCamelCase       :		Any		=dropatt
             _lowerCamelCase       :		Dict		=untie_r
             _lowerCamelCase       :		List[Any]		=init
             _lowerCamelCase       :		List[str]		=init_range
             _lowerCamelCase       :		int		=proj_init_std
             _lowerCamelCase       :		Optional[int]		=init_std
             _lowerCamelCase       :		Tuple		=layer_norm_epsilon
             super().__init__(eos_token_id=lowercase_			,   **lowercase_ )






      @property
      def        lowerCamelCase       (					self						:     List[str] )					->						Dict:
             """simple docstring"""




             logger.info(F'''The model {self.model_type} is one of the few models that has no sequence length limit.''' )
             return -1






      @max_position_embeddings.setter
      def        lowerCamelCase       (					self						:     int			,   lowercase_						:     int )					->						List[str]:
             """simple docstring"""




             raise NotImplementedError(
                 F'''The model {self.model_type} is one of the few models that has no sequence length limit.''' )


