



import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotConfig, is_flax_available
from transformers.testing_utils import jax_device, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
	import os

	# The slow tests are often failing with OOM error on GPU
	# This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
	# but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
	__A       =						'''platform'''

	import jax
	import jax.numpy as jnp

	from transformers import BlenderbotTokenizer
	from transformers.models.blenderbot.modeling_flax_blenderbot import (
	    FlaxBlenderbotForConditionalGeneration,
	    FlaxBlenderbotModel,
	    shift_tokens_right,
	)



def 	__a					(   lowerCAmelCase_       : Any      ,lowerCAmelCase_       : Union[str, Any]      ,lowerCAmelCase_       : int=None      ,lowerCAmelCase_       : List[str]=None      ,lowerCAmelCase_       : Optional[int]=None      ,lowerCAmelCase_       : List[str]=None      ,lowerCAmelCase_       : List[Any]=None      ,lowerCAmelCase_       : Optional[int]=None      ,)				->			List[Any]:






						'''simple docstring'''



						if attention_mask is None:
												UpperCAmelCase_=       np.where(input_ids != config.pad_token_id      ,1      ,0    )
						if decoder_attention_mask is None:
												UpperCAmelCase_=       np.where(decoder_input_ids != config.pad_token_id      ,1      ,0    )
						if head_mask is None:
												UpperCAmelCase_=       np.ones((config.encoder_layers, config.encoder_attention_heads)    )
						if decoder_head_mask is None:
												UpperCAmelCase_=       np.ones((config.decoder_layers, config.decoder_attention_heads)    )
						if cross_attn_head_mask is None:
												UpperCAmelCase_=       np.ones((config.decoder_layers, config.decoder_attention_heads)    )
						return {
						    "input_ids": input_ids,
						    "decoder_input_ids": decoder_input_ids,
						    "attention_mask": attention_mask,
						    "decoder_attention_mask": attention_mask,
						}






class 		lowercase						:






	"""simple docstring"""


	def __init__(     self     :						int						,  __UpperCAmelCase     :						Dict						,  __UpperCAmelCase     :						Tuple=13						,  __UpperCAmelCase     :						Dict=7						,  __UpperCAmelCase     :						List[str]=True						,  __UpperCAmelCase     :						Optional[int]=False						,  __UpperCAmelCase     :						List[Any]=99						,  __UpperCAmelCase     :						Optional[int]=16						,  __UpperCAmelCase     :						Union[str, Any]=2						,  __UpperCAmelCase     :						Any=4						,  __UpperCAmelCase     :						Optional[int]=4						,  __UpperCAmelCase     :						List[str]="gelu"						,  __UpperCAmelCase     :						Optional[Any]=0.1						,  __UpperCAmelCase     :						Optional[int]=0.1						,  __UpperCAmelCase     :						Union[str, Any]=32						,  __UpperCAmelCase     :						Union[str, Any]=2						,  __UpperCAmelCase     :						Tuple=1						,  __UpperCAmelCase     :						Optional[int]=0						,  __UpperCAmelCase     :						Dict=0.02						,  )      ->			Any:
							UpperCAmelCase_=       parent
							UpperCAmelCase_=       batch_size
							UpperCAmelCase_=       seq_length
							UpperCAmelCase_=       is_training
							UpperCAmelCase_=       use_labels
							UpperCAmelCase_=       vocab_size
							UpperCAmelCase_=       hidden_size
							UpperCAmelCase_=       num_hidden_layers
							UpperCAmelCase_=       num_attention_heads
							UpperCAmelCase_=       intermediate_size
							UpperCAmelCase_=       hidden_act
							UpperCAmelCase_=       hidden_dropout_prob
							UpperCAmelCase_=       attention_probs_dropout_prob
							UpperCAmelCase_=       max_position_embeddings
							UpperCAmelCase_=       eos_token_id
							UpperCAmelCase_=       pad_token_id
							UpperCAmelCase_=       bos_token_id
							UpperCAmelCase_=       initializer_range




	def   _SCREAMING_SNAKE_CASE		(     self     :						Tuple					)      ->			Any:
							UpperCAmelCase_=       np.clip(ids_tensor([self.batch_size, self.seq_length - 1]						,  self.vocab_size					)						,  3						,  self.vocab_size					)
							UpperCAmelCase_=       np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)						,  dtype=np.intaa					))						,  -1					)

							UpperCAmelCase_=       shift_tokens_right(snake_case__						,  1						,  2					)

							UpperCAmelCase_=       BlenderbotConfig(
							    vocab_size=self.vocab_size						,  d_model=self.hidden_size						,  encoder_layers=self.num_hidden_layers						,  decoder_layers=self.num_hidden_layers						,  encoder_attention_heads=self.num_attention_heads						,  decoder_attention_heads=self.num_attention_heads						,  encoder_ffn_dim=self.intermediate_size						,  decoder_ffn_dim=self.intermediate_size						,  dropout=self.hidden_dropout_prob						,  attention_dropout=self.attention_probs_dropout_prob						,  max_position_embeddings=self.max_position_embeddings						,  eos_token_id=self.eos_token_id						,  bos_token_id=self.bos_token_id						,  pad_token_id=self.pad_token_id						,  initializer_range=self.initializer_range						,  use_cache=snake_case__						,  )
							UpperCAmelCase_=       prepare_blenderbot_inputs_dict(snake_case__						,  snake_case__						,  snake_case__					)
							return config, inputs_dict




	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[int]					)      ->			List[Any]:
							UpperCAmelCase_=       self.prepare_config_and_inputs()
							return config, inputs_dict




	def   _SCREAMING_SNAKE_CASE		(     self     :						List[str]						,  __UpperCAmelCase     :						str						,  __UpperCAmelCase     :						Any						,  __UpperCAmelCase     :						Optional[Any]					)      ->			List[Any]:
							UpperCAmelCase_=       20
							UpperCAmelCase_=       model_class_name(snake_case__					)

							UpperCAmelCase_=       model.encode(inputs_dict["""input_ids"""]					)

							UpperCAmelCase_=       (
							    inputs_dict['''decoder_input_ids'''],
							    inputs_dict['''decoder_attention_mask'''],
							)

							UpperCAmelCase_=       model.init_cache(decoder_input_ids.shape[0]						,  snake_case__						,  snake_case__					)
							UpperCAmelCase_=       jnp.ones((decoder_input_ids.shape[0], max_decoder_length)						,  dtype="""i4"""					)

							UpperCAmelCase_=       jnp.broadcast_to(
							    jnp.arange(decoder_input_ids.shape[-1] - 1					)[None, :]						,  (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)						,  )
							UpperCAmelCase_=       model.decode(
							    decoder_input_ids[:, :-1]						,  snake_case__						,  decoder_attention_mask=snake_case__						,  past_key_values=snake_case__						,  decoder_position_ids=snake_case__						,  )

							UpperCAmelCase_=       jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]						,  dtype="""i4"""					)
							UpperCAmelCase_=       model.decode(
							    decoder_input_ids[:, -1:]						,  snake_case__						,  decoder_attention_mask=snake_case__						,  past_key_values=outputs_cache.past_key_values						,  decoder_position_ids=snake_case__						,  )

							UpperCAmelCase_=       model.decode(snake_case__						,  snake_case__					)

							UpperCAmelCase_=       np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])					)					)
							self.parent.assertTrue(diff < 1E-3						,  msg=F"""Max diff is {diff}"""					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict						,  __UpperCAmelCase     :						Tuple						,  __UpperCAmelCase     :						Optional[int]						,  __UpperCAmelCase     :						Optional[int]					)      ->			List[str]:
							UpperCAmelCase_=       20
							UpperCAmelCase_=       model_class_name(snake_case__					)

							UpperCAmelCase_=       model.encode(inputs_dict["""input_ids"""]					)

							UpperCAmelCase_=       (
							    inputs_dict['''decoder_input_ids'''],
							    inputs_dict['''decoder_attention_mask'''],
							)

							UpperCAmelCase_=       jnp.concatenate(
							    [
							        decoder_attention_mask,
							        jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])					),
							    ]						,  axis=-1						,  )

							UpperCAmelCase_=       model.init_cache(decoder_input_ids.shape[0]						,  snake_case__						,  snake_case__					)
							UpperCAmelCase_=       jnp.broadcast_to(
							    jnp.arange(decoder_input_ids.shape[-1] - 1					)[None, :]						,  (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)						,  )

							UpperCAmelCase_=       model.decode(
							    decoder_input_ids[:, :-1]						,  snake_case__						,  decoder_attention_mask=snake_case__						,  past_key_values=snake_case__						,  decoder_position_ids=snake_case__						,  )
							UpperCAmelCase_=       jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]						,  dtype="""i4"""					)
							UpperCAmelCase_=       model.decode(
							    decoder_input_ids[:, -1:]						,  snake_case__						,  past_key_values=outputs_cache.past_key_values						,  decoder_attention_mask=snake_case__						,  decoder_position_ids=snake_case__						,  )

							UpperCAmelCase_=       model.decode(snake_case__						,  snake_case__						,  decoder_attention_mask=snake_case__					)

							UpperCAmelCase_=       np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])					)					)
							self.parent.assertTrue(diff < 1E-3						,  msg=F"""Max diff is {diff}"""					)






@require_flax
class 		lowercase						(			unittest.TestCase):






	"""simple docstring"""


	a__				: Dict		       =							99




	def   _SCREAMING_SNAKE_CASE		(     self     :						int					)      ->			Optional[Any]:
							UpperCAmelCase_=       np.array(
							    [
							        [71, 82, 18, 33, 46, 91, 2],
							        [68, 34, 26, 58, 30, 82, 2],
							        [5, 97, 17, 39, 94, 40, 2],
							        [76, 83, 94, 25, 70, 78, 2],
							        [87, 59, 41, 35, 48, 66, 2],
							        [55, 13, 16, 58, 5, 2, 1],  # note padding
							        [64, 27, 31, 51, 12, 75, 2],
							        [52, 64, 86, 17, 83, 39, 2],
							        [48, 61, 9, 24, 71, 82, 2],
							        [26, 1, 60, 48, 22, 13, 2],
							        [21, 5, 62, 28, 14, 76, 2],
							        [45, 98, 37, 86, 59, 48, 2],
							        [70, 70, 50, 9, 28, 0, 2],
							    ]						,  dtype=np.intaa						,  )

							UpperCAmelCase_=       input_ids.shape[0]
							UpperCAmelCase_=       BlenderbotConfig(
							    vocab_size=self.vocab_size						,  d_model=24						,  encoder_layers=2						,  decoder_layers=2						,  encoder_attention_heads=2						,  decoder_attention_heads=2						,  encoder_ffn_dim=32						,  decoder_ffn_dim=32						,  max_position_embeddings=48						,  eos_token_id=2						,  pad_token_id=1						,  bos_token_id=0						,  )
							return config, input_ids, batch_size




	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			int:
							UpperCAmelCase_=       self._get_config_and_data()
							UpperCAmelCase_=       FlaxBlenderbotForConditionalGeneration(snake_case__					)
							UpperCAmelCase_=       lm_model(input_ids=snake_case__					)
							UpperCAmelCase_=       (batch_size, input_ids.shape[1], config.vocab_size)
							self.assertEqual(outputs["""logits"""].shape						,  snake_case__					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						str					)      ->			Optional[Any]:
							UpperCAmelCase_=       BlenderbotConfig(
							    vocab_size=self.vocab_size						,  d_model=14						,  encoder_layers=2						,  decoder_layers=2						,  encoder_attention_heads=2						,  decoder_attention_heads=2						,  encoder_ffn_dim=8						,  decoder_ffn_dim=8						,  max_position_embeddings=48						,  )
							UpperCAmelCase_=       FlaxBlenderbotForConditionalGeneration(snake_case__					)
							UpperCAmelCase_=       np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]						,  dtype=np.intaa					)
							UpperCAmelCase_=       np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]						,  dtype=np.intaa					)
							UpperCAmelCase_=       lm_model(input_ids=snake_case__						,  decoder_input_ids=snake_case__					)
							UpperCAmelCase_=       (*summary.shape, config.vocab_size)
							self.assertEqual(outputs["""logits"""].shape						,  snake_case__					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[int]					)      ->			int:
							UpperCAmelCase_=       np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]						,  dtype=np.intaa					)
							UpperCAmelCase_=       shift_tokens_right(snake_case__						,  1						,  2					)
							UpperCAmelCase_=       np.equal(snake_case__						,  1					).astype(np.floataa					).sum()
							UpperCAmelCase_=       np.equal(snake_case__						,  1					).astype(np.floataa					).sum()
							self.assertEqual(shifted.shape						,  input_ids.shape					)
							self.assertEqual(snake_case__						,  n_pad_before - 1					)
							self.assertTrue(np.equal(shifted[:, 0]						,  2					).all()					)






@require_flax
class 		lowercase						(			lowerCamelCase__			,   unittest.TestCase			,   lowerCamelCase__):






	"""simple docstring"""


	a__				: List[Any]		       =							True
	a__				: List[str]		       =							(
	    (
	        FlaxBlenderbotModel,
	        FlaxBlenderbotForConditionalGeneration,
	    )
	    if is_flax_available()
	    else ()
	)
	a__				: str		       =							(FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else ()




	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			Tuple:
							UpperCAmelCase_=       FlaxBlenderbotModelTester(self					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			Any:
							UpperCAmelCase_=       self.model_tester.prepare_config_and_inputs()
							for model_class in self.all_model_classes:
													self.model_tester.check_use_cache_forward(snake_case__						,  snake_case__						,  snake_case__					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Tuple					)      ->			Union[str, Any]:
							UpperCAmelCase_=       self.model_tester.prepare_config_and_inputs()
							for model_class in self.all_model_classes:
													self.model_tester.check_use_cache_forward_with_attn_mask(snake_case__						,  snake_case__						,  snake_case__					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						List[Any]					)      ->			List[Any]:
							UpperCAmelCase_=       self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													with self.subTest(model_class.__name__					):
																			UpperCAmelCase_=       self._prepare_for_class(snake_case__						,  snake_case__					)
																			UpperCAmelCase_=       model_class(snake_case__					)

																			@jax.jit
																			def encode_jitted(__UpperCAmelCase     :						Optional[int]						,  __UpperCAmelCase     :						Union[str, Any]=None						,  **__UpperCAmelCase     :						Dict					):
																									return model.encode(input_ids=snake_case__						,  attention_mask=snake_case__					)

																			with self.subTest("""JIT Enabled"""					):
																									UpperCAmelCase_=       encode_jitted(**snake_case__					).to_tuple()

																			with self.subTest("""JIT Disabled"""					):
																									with jax.disable_jit():
																															UpperCAmelCase_=       encode_jitted(**snake_case__					).to_tuple()

																			self.assertEqual(len(snake_case__					)						,  len(snake_case__					)					)
																			for jitted_output, output in zip(snake_case__						,  snake_case__					):
																									self.assertEqual(jitted_output.shape						,  output.shape					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						List[str]					)      ->			str:
							UpperCAmelCase_=       self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													with self.subTest(model_class.__name__					):
																			UpperCAmelCase_=       model_class(snake_case__					)
																			UpperCAmelCase_=       model.encode(inputs_dict["""input_ids"""]						,  inputs_dict["""attention_mask"""]					)

																			UpperCAmelCase_=       {
																			    '''decoder_input_ids''': inputs_dict['''decoder_input_ids'''],
																			    '''decoder_attention_mask''': inputs_dict['''decoder_attention_mask'''],
																			    '''encoder_outputs''': encoder_outputs,
																			}

																			@jax.jit
																			def decode_jitted(__UpperCAmelCase     :						Tuple						,  __UpperCAmelCase     :						Tuple						,  __UpperCAmelCase     :						List[str]					):
																									return model.decode(
																									    decoder_input_ids=snake_case__						,  decoder_attention_mask=snake_case__						,  encoder_outputs=snake_case__						,  )

																			with self.subTest("""JIT Enabled"""					):
																									UpperCAmelCase_=       decode_jitted(**snake_case__					).to_tuple()

																			with self.subTest("""JIT Disabled"""					):
																									with jax.disable_jit():
																															UpperCAmelCase_=       decode_jitted(**snake_case__					).to_tuple()

																			self.assertEqual(len(snake_case__					)						,  len(snake_case__					)					)
																			for jitted_output, output in zip(snake_case__						,  snake_case__					):
																									self.assertEqual(jitted_output.shape						,  output.shape					)




	@slow
	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[Any]					)      ->			Optional[int]:





							for model_class_name in self.all_model_classes:
													UpperCAmelCase_=       model_class_name.from_pretrained("""facebook/blenderbot-400M-distill"""					)
													# FlaxBlenderbotForSequenceClassification expects eos token in input_ids
													UpperCAmelCase_=       np.ones((1, 1)					) * model.config.eos_token_id
													UpperCAmelCase_=       model(snake_case__					)
													self.assertIsNotNone(snake_case__					)




	@unittest.skipUnless(jax_device != """cpu"""						,  """3B test too slow on CPU."""					)
	@slow
	def   _SCREAMING_SNAKE_CASE		(     self     :						str					)      ->			Dict:
							UpperCAmelCase_=       {'''num_beams''': 1, '''early_stopping''': True, '''min_length''': 15, '''max_length''': 25}
							UpperCAmelCase_=       {'''skip_special_tokens''': True, '''clean_up_tokenization_spaces''': True}

							UpperCAmelCase_=       FlaxBlenderbotForConditionalGeneration.from_pretrained("""facebook/blenderbot-3B"""						,  from_pt=snake_case__					)
							UpperCAmelCase_=       BlenderbotTokenizer.from_pretrained("""facebook/blenderbot-3B"""					)

							UpperCAmelCase_=       ['''Sam''']
							UpperCAmelCase_=       tokenizer(snake_case__						,  return_tensors="""jax"""					)

							UpperCAmelCase_=       model.generate(**snake_case__						,  **snake_case__					)
							UpperCAmelCase_=       '''Sam is a great name. It means "sun" in Gaelic.'''

							UpperCAmelCase_=       tokenizer.batch_decode(snake_case__						,  **snake_case__					)
							assert generated_txt[0].strip() == tgt_text





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


__A       =						{
    '''configuration_clip''': [
        '''CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''CLIPConfig''',
        '''CLIPOnnxConfig''',
        '''CLIPTextConfig''',
        '''CLIPVisionConfig''',
    ],
    '''processing_clip''': ['''CLIPProcessor'''],
    '''tokenization_clip''': ['''CLIPTokenizer'''],
}

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__A       =						['''CLIPTokenizerFast''']

try:
	if not is_vision_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__A       =						['''CLIPFeatureExtractor''']
	__A       =						['''CLIPImageProcessor''']

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__A       =						[
	    '''CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''CLIPModel''',
	    '''CLIPPreTrainedModel''',
	    '''CLIPTextModel''',
	    '''CLIPTextModelWithProjection''',
	    '''CLIPVisionModel''',
	    '''CLIPVisionModelWithProjection''',
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__A       =						[
	    '''TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''TFCLIPModel''',
	    '''TFCLIPPreTrainedModel''',
	    '''TFCLIPTextModel''',
	    '''TFCLIPVisionModel''',
	]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__A       =						[
	    '''FlaxCLIPModel''',
	    '''FlaxCLIPPreTrainedModel''',
	    '''FlaxCLIPTextModel''',
	    '''FlaxCLIPTextPreTrainedModel''',
	    '''FlaxCLIPVisionModel''',
	    '''FlaxCLIPVisionPreTrainedModel''',
	]


if TYPE_CHECKING:
	from .configuration_clip import (
	    CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    CLIPConfig,
	    CLIPOnnxConfig,
	    CLIPTextConfig,
	    CLIPVisionConfig,
	)
	from .processing_clip import CLIPProcessor
	from .tokenization_clip import CLIPTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_clip_fast import CLIPTokenizerFast

	try:
		if not is_vision_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .feature_extraction_clip import CLIPFeatureExtractor
		from .image_processing_clip import CLIPImageProcessor

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_clip import (
		    CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
		    CLIPModel,
		    CLIPPreTrainedModel,
		    CLIPTextModel,
		    CLIPTextModelWithProjection,
		    CLIPVisionModel,
		    CLIPVisionModelWithProjection,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_clip import (
		    TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFCLIPModel,
		    TFCLIPPreTrainedModel,
		    TFCLIPTextModel,
		    TFCLIPVisionModel,
		)

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_flax_clip import (
		    FlaxCLIPModel,
		    FlaxCLIPPreTrainedModel,
		    FlaxCLIPTextModel,
		    FlaxCLIPTextPreTrainedModel,
		    FlaxCLIPVisionModel,
		    FlaxCLIPVisionPreTrainedModel,
		)


else:
	import sys

	__A       =						_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




