






# coding=utf-8
# Copyright 2020 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import sys

import transformers


snake_case     					=		"""3"""

print("""Python version:""", sys.version)
print("""transformers version:""", transformers.__version__)

try:
   import torch

   print("""Torch version:""", torch.__version__)
   print("""Cuda available:""", torch.cuda.is_available())
   print("""Cuda version:""", torch.version.cuda)
   print("""CuDNN version:""", torch.backends.cudnn.version())
   print("""Number of GPUs available:""", torch.cuda.device_count())
   print("""NCCL version:""", torch.cuda.nccl.version())
except ImportError:
   print("""Torch version:""", None)

try:
   import deepspeed

   print("""DeepSpeed version:""", deepspeed.__version__)
except ImportError:
   print("""DeepSpeed version:""", None)

try:
   import tensorflow as tf

   print("""TensorFlow version:""", tf.__version__)
   print("""TF GPUs available:""", bool(tf.config.list_physical_devices("""GPU""")))
   print("""Number of TF GPUs available:""", len(tf.config.list_physical_devices("""GPU""")))
except ImportError:
   print("""TensorFlow version:""", None)








"""simple docstring"""






import warnings

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



class 			lowercase					( lowercase__		):
			lowercase        =     ['''image_processor''', '''tokenizer''']
			lowercase        =     '''CLIPImageProcessor'''
			lowercase        =     ('''XLMRobertaTokenizer''', '''XLMRobertaTokenizerFast''')






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





				"""simple docstring"""


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

				lowerCAmelCase												=  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__(SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_			)






			def __call__(self  :	Union[str, Any]      ,SCREAMING_SNAKE_CASE_  :	List[str]=None      ,SCREAMING_SNAKE_CASE_  :	Optional[int]=None      ,SCREAMING_SNAKE_CASE_  :	Union[str, Any]=None      ,**SCREAMING_SNAKE_CASE_  :	Any			)       ->	List[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:
					lowerCAmelCase												=  self.tokenizer(SCREAMING_SNAKE_CASE_      ,return_tensors=SCREAMING_SNAKE_CASE_      ,**SCREAMING_SNAKE_CASE_			)

				if images is not None:
					lowerCAmelCase												=  self.image_processor(SCREAMING_SNAKE_CASE_      ,return_tensors=SCREAMING_SNAKE_CASE_      ,**SCREAMING_SNAKE_CASE_			)

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






			def 					UpperCAmelCase							(self  :	List[str]      ,*SCREAMING_SNAKE_CASE_  :	Union[str, Any]      ,**SCREAMING_SNAKE_CASE_  :	Tuple			)       ->	Optional[Any]:





				"""simple docstring"""


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






			def 					UpperCAmelCase							(self  :	Union[str, Any]      ,*SCREAMING_SNAKE_CASE_  :	int      ,**SCREAMING_SNAKE_CASE_  :	Union[str, Any]			)       ->	Any:





				"""simple docstring"""


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






			@property
			def 					UpperCAmelCase							(self  :	List[Any]			)       ->	Dict:





				"""simple docstring"""


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


