





'''simple docstring'''






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


__UpperCamelCase					    =	logging.get_logger(__name__)

__UpperCamelCase					    =	{
    "microsoft/trocr-base-handwritten": (
        "https://huggingface.co/microsoft/trocr-base-handwritten/resolve/main/config.json"
    ),
    # See all TrOCR models at https://huggingface.co/models?filter=trocr
}




class  _A (					__lowercase		):
		lowercase__:   Tuple				     =   '''trocr'''
		lowercase__:   Tuple				     =   ['''past_key_values''']
		lowercase__:   Tuple				     =   {
		    '''num_attention_heads''': '''decoder_attention_heads''',
		    '''hidden_size''': '''d_model''',
		    '''num_hidden_layers''': '''decoder_layers''',
		}

		def __init__(   self					:   Dict  ,      __magic_name__					:   List[Any]=5_02_65  ,      __magic_name__					:   Tuple=10_24  ,      __magic_name__					:   List[Any]=12  ,      __magic_name__					:   int=16  ,      __magic_name__					:   Optional[Any]=40_96  ,      __magic_name__					:   str="gelu"  ,      __magic_name__					:   Optional[int]=5_12  ,      __magic_name__					:   int=0.1  ,      __magic_name__					:   List[Any]=0.0  ,      __magic_name__					:   str=0.0  ,      __magic_name__					:   Dict=2  ,      __magic_name__					:   Dict=0.02  ,      __magic_name__					:   Optional[Any]=0.0  ,      __magic_name__					:   Optional[int]=True  ,      __magic_name__					:   Dict=False  ,      __magic_name__					:   Optional[Any]=True  ,      __magic_name__					:   Optional[int]=True  ,      __magic_name__					:   List[str]=1  ,      __magic_name__					:   str=0  ,      __magic_name__					:   Dict=2  ,      **__magic_name__					:   List[str]  ,      )					->    Any:


					"""simple docstring"""

					__snake_case					:      Optional[Any]							      =     vocab_size
					__snake_case					:      Union[str, Any]							      =     d_model
					__snake_case					:      List[Any]							      =     decoder_layers
					__snake_case					:      Optional[Any]							      =     decoder_attention_heads
					__snake_case					:      Optional[int]							      =     decoder_ffn_dim
					__snake_case					:      Optional[int]							      =     activation_function
					__snake_case					:      Dict							      =     max_position_embeddings
					__snake_case					:      Optional[int]							      =     dropout
					__snake_case					:      str							      =     attention_dropout
					__snake_case					:      List[str]							      =     activation_dropout
					__snake_case					:      str							      =     init_std
					__snake_case					:      List[str]							      =     decoder_layerdrop
					__snake_case					:      Any							      =     use_cache
					__snake_case					:      int							      =     scale_embedding
					__snake_case					:      List[Any]							      =     use_learned_position_embeddings
					__snake_case					:      int							      =     layernorm_embedding

					super().__init__(
					    pad_token_id=__magic_name__  ,      bos_token_id=__magic_name__  ,      eos_token_id=__magic_name__  ,      decoder_start_token_id=__magic_name__  ,      **__magic_name__  ,      )









'''simple docstring'''






import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding




class  _A (					__lowercase		):
		lowercase__:   Any				     =   ['''image_processor''', '''tokenizer''']
		lowercase__:   Any				     =   '''CLIPImageProcessor'''
		lowercase__:   Optional[Any]				     =   ('''CLIPTokenizer''', '''CLIPTokenizerFast''')

		def __init__(   self					:   int  ,      __magic_name__					:   Dict=None  ,      __magic_name__					:   Dict=None  ,      **__magic_name__					:   Union[str, Any]			)					->    Any:


					"""simple docstring"""

					__snake_case					:      Optional[Any]							      =     None
					if "feature_extractor" in kwargs:
								warnings.warn(
								    """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
								    """ instead."""  ,      __magic_name__  ,      )
								__snake_case					:      List[Any]							      =     kwargs.pop("""feature_extractor"""			)

					__snake_case					:      List[str]							      =     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__(__magic_name__  ,      __magic_name__			)

		def __call__(   self					:   int  ,      __magic_name__					:   List[str]=None  ,      __magic_name__					:   Tuple=None  ,      __magic_name__					:   Any=None  ,      **__magic_name__					:   Union[str, Any]			)					->    Optional[int]:


					"""simple docstring"""

					if text is None and images is None:
								raise ValueError("""You have to specify either text or images. Both cannot be none."""			)

					if text is not None:
								__snake_case					:      int							      =     self.tokenizer(__magic_name__  ,      return_tensors=__magic_name__  ,      **__magic_name__			)

					if images is not None:
								__snake_case					:      str							      =     self.image_processor(__magic_name__  ,      return_tensors=__magic_name__  ,      **__magic_name__			)

					if text is not None and images is not None:
								__snake_case					:      Union[str, Any]							      =     image_features.pixel_values
								return encoding
					elif text is not None:
								return encoding
					else:
								return BatchEncoding(data=dict(**__magic_name__			)  ,      tensor_type=__magic_name__			)

		def 	lowercase__     (   self					:   Optional[int]  ,      *__magic_name__					:   List[Any]  ,      **__magic_name__					:   Any			)					->    Optional[Any]:


					"""simple docstring"""

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

		def 	lowercase__     (   self					:   List[str]  ,      *__magic_name__					:   Tuple  ,      **__magic_name__					:   List[Any]			)					->    int:


					"""simple docstring"""

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

		@property
		def 	lowercase__     (   self					:   List[Any]			)					->    Optional[Any]:


					"""simple docstring"""

					__snake_case					:      Dict							      =     self.tokenizer.model_input_names
					__snake_case					:      str							      =     self.image_processor.model_input_names
					return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names			)			)

		@property
		def 	lowercase__     (   self					:   int			)					->    List[str]:


					"""simple docstring"""

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

		@property
		def 	lowercase__     (   self					:   Union[str, Any]			)					->    Dict:


					"""simple docstring"""

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


