


'''simple docstring'''



import warnings

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






class  UpperCamelCase__(     a__ ):
				__magic_name__       :   Dict							= ["image_processor", "tokenizer"]
				__magic_name__       :   Any							= "ChineseCLIPImageProcessor"
				__magic_name__       :   Union[str, Any]							= ("BertTokenizer", "BertTokenizerFast")




				def __init__(	self    :				Optional[int]   ,					lowerCAmelCase    :				Dict=None   ,					lowerCAmelCase    :				Dict=None   ,					**lowerCAmelCase    :				Dict   )->  Any:

										"""simple docstring"""




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

										UpperCAmelCase         =			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__(lowerCamelCase_   ,					lowerCamelCase_   )
										UpperCAmelCase         =			self.image_processor




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

										"""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:
																UpperCAmelCase         =			self.tokenizer(lowerCamelCase_   ,					return_tensors=lowerCamelCase_   ,					**lowerCamelCase_   )

										if images is not None:
																UpperCAmelCase         =			self.image_processor(lowerCamelCase_   ,					return_tensors=lowerCamelCase_   ,					**lowerCamelCase_   )

										if text is not None and images is not None:
																UpperCAmelCase         =			image_features.pixel_values
																return encoding
										elif text is not None:
																return encoding
										else:
																return BatchEncoding(data=dict(**lowerCamelCase_   )   ,					tensor_type=lowerCamelCase_   )




				def   a__(	self    :				Optional[int]   ,					*lowerCAmelCase    :				Optional[int]   ,					**lowerCAmelCase    :				Union[str, Any]   )->  str:

										"""simple docstring"""




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




				def   a__(	self    :				Optional[Any]   ,					*lowerCAmelCase    :				int   ,					**lowerCAmelCase    :				List[Any]   )->  Any:

										"""simple docstring"""




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




				@property
				def   a__(	self    :				Dict   )->  Optional[Any]:

										"""simple docstring"""




										UpperCAmelCase         =			self.tokenizer.model_input_names
										UpperCAmelCase         =			self.image_processor.model_input_names
										return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names   )   )





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

										"""simple docstring"""




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









'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_lowercase    :    Any			     =  {
    """configuration_maskformer""": ["""MASKFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MaskFormerConfig"""],
    """configuration_maskformer_swin""": ["""MaskFormerSwinConfig"""],
}

try:
	if not is_vision_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowercase    :    Any			     =  ["""MaskFormerFeatureExtractor"""]
	_lowercase    :    Dict			     =  ["""MaskFormerImageProcessor"""]


try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowercase    :    Any			     =  [
	    """MASKFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """MaskFormerForInstanceSegmentation""",
	    """MaskFormerModel""",
	    """MaskFormerPreTrainedModel""",
	]
	_lowercase    :    List[Any]			     =  [
	    """MaskFormerSwinBackbone""",
	    """MaskFormerSwinModel""",
	    """MaskFormerSwinPreTrainedModel""",
	]

if TYPE_CHECKING:
	from .configuration_maskformer import MASKFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, MaskFormerConfig
	from .configuration_maskformer_swin import MaskFormerSwinConfig

	try:
		if not is_vision_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .feature_extraction_maskformer import MaskFormerFeatureExtractor
		from .image_processing_maskformer import MaskFormerImageProcessor
	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_maskformer import (
		    MASKFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    MaskFormerForInstanceSegmentation,
		    MaskFormerModel,
		    MaskFormerPreTrainedModel,
		)
		from .modeling_maskformer_swin import (
		    MaskFormerSwinBackbone,
		    MaskFormerSwinModel,
		    MaskFormerSwinPreTrainedModel,
		)


else:
	import sys

	_lowercase    :    List[Any]			     =  _LazyModule(__name__, globals()["""__file__"""], _import_structure)





