"""simple docstring"""







UpperCamelCase_				:				Optional[int]							      =						{
    """0000""": """0""",
    """0001""": """1""",
    """0010""": """2""",
    """0011""": """3""",
    """0100""": """4""",
    """0101""": """5""",
    """0110""": """6""",
    """0111""": """7""",
    """1000""": """8""",
    """1001""": """9""",
    """1010""": """a""",
    """1011""": """b""",
    """1100""": """c""",
    """1101""": """d""",
    """1110""": """e""",
    """1111""": """f""",
}


def      a__					(						UpperCAmelCase__				:	str	)->		Any:
						UpperCAmelCase__    		=						str(UpperCamelCase__	).strip()

						# Exceptions
						if not binary_str:
												raise ValueError("""Empty string was passed to the function"""	)
						UpperCAmelCase__    		=						binary_str[0] == """-"""
						UpperCAmelCase__    		=						binary_str[1:] if is_negative else binary_str
						if not all(char in """01""" for char in binary_str	):
												raise ValueError("""Non-binary value was passed to the function"""	)

						UpperCAmelCase__    		=						(
						    """0""" * (4 * (divmod(len(UpperCamelCase__	)						,	4	)[0] + 1) - len(UpperCamelCase__	)) + binary_str
						)

						UpperCAmelCase__    		=						[]
						for x in range(0						,	len(UpperCamelCase__	)						,	4	):
												hexadecimal.append(BITS_TO_HEX[binary_str[x : x + 4]]	)
						UpperCAmelCase__    		=						"""0x""" + """""".join(UpperCamelCase__	)

						return "-" + hexadecimal_str if is_negative else hexadecimal_str


if __name__ == "__main__":
						from doctest import testmod

						testmod()








import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin




class      UpperCamelCase_				(   UpperCamelCase__			):
							lowerCamelCase_							=    ["image_processor", "tokenizer"]
							lowerCamelCase_							=    "AutoImageProcessor"
							lowerCamelCase_							=    "AutoTokenizer"


							def __init__(							self			:Any							, __A			:List[str]=None							, __A			:Dict=None							, **__A			:List[str]						)      ->      List[Any]:



									"""simple docstring"""



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

									SCREAMING_SNAKE_CASE__								=					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__(__A							, __A						)
									SCREAMING_SNAKE_CASE__								=					self.image_processor
									SCREAMING_SNAKE_CASE__								=					False


							def __call__(							self			:List[str]							, *__A			:int							, **__A			:Optional[int]						)      ->      Optional[Any]:



									"""simple docstring"""



									if self._in_target_context_manager:
											return self.current_processor(*__A							, **__A						)

									SCREAMING_SNAKE_CASE__								=					kwargs.pop("""images"""							, __A						)
									SCREAMING_SNAKE_CASE__								=					kwargs.pop("""text"""							, __A						)
									if len(__A						) > 0:
											SCREAMING_SNAKE_CASE__								=					args[0]
											SCREAMING_SNAKE_CASE__								=					args[1:]

									if images is None and text is None:
											raise ValueError("""You need to specify either an `images` or `text` input to process."""						)

									if images is not None:
											SCREAMING_SNAKE_CASE__								=					self.image_processor(__A							, *__A							, **__A						)
									if text is not None:
											SCREAMING_SNAKE_CASE__								=					self.tokenizer(__A							, **__A						)

									if text is None:
											return inputs
									elif images is None:
											return encodings
									else:
											SCREAMING_SNAKE_CASE__								=					encodings["""input_ids"""]
											return inputs


							def    _snake_case     (							self			:Any							, *__A			:Optional[Any]							, **__A			:int						)      ->      List[Any]:



									"""simple docstring"""



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


							def    _snake_case     (							self			:str							, *__A			:Optional[int]							, **__A			:List[Any]						)      ->      List[str]:



									"""simple docstring"""



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


							@contextmanager
							def    _snake_case     (							self			:Dict						)      ->      List[str]:



									"""simple docstring"""



									warnings.warn(
									    """`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your """
									    """labels by using the argument `text` of the regular `__call__` method (either in the same call as """
									    """your images inputs, or in a separate call."""						)
									SCREAMING_SNAKE_CASE__								=					True
									SCREAMING_SNAKE_CASE__								=					self.tokenizer
									yield
									SCREAMING_SNAKE_CASE__								=					self.image_processor
									SCREAMING_SNAKE_CASE__								=					False


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



									"""simple docstring"""



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


							@property
							def    _snake_case     (							self			:str						)      ->      List[Any]:



									"""simple docstring"""



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