"""simple docstring"""




import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
			from PIL import Image

			from transformers import CLIPImageProcessor, CLIPProcessor

@require_vision
class    a_   (  unittest.TestCase      ):




					def     _SCREAMING_SNAKE_CASE    (						self    :  int  ):
							lowerCAmelCase__   = tempfile.mkdtemp()

							# fmt: off
							lowerCAmelCase__   = ["""l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """lo""", """l</w>""", """w</w>""", """r</w>""", """t</w>""", """low</w>""", """er</w>""", """lowest</w>""", """newer</w>""", """wider""", """<unk>""", """<|startoftext|>""", """<|endoftext|>"""]
							# fmt: on
							lowerCAmelCase__   = dict(zip(snake_case__	,    range(len(snake_case__  )  )  )  )
							lowerCAmelCase__   = ["""#version: 0.2""", """l o""", """lo w</w>""", """e r</w>""", """"""]
							lowerCAmelCase__   = {"""unk_token""": """<unk>"""}

							lowerCAmelCase__   = os.path.join(self.tmpdirname	,    VOCAB_FILES_NAMES["""vocab_file"""]  )
							lowerCAmelCase__   = os.path.join(self.tmpdirname	,    VOCAB_FILES_NAMES["""merges_file"""]  )
							with open(self.vocab_file	,    """w"""	,    encoding="""utf-8"""  ) as fp:
									fp.write(json.dumps(snake_case__  ) + """\n"""  )
							with open(self.merges_file	,    """w"""	,    encoding="""utf-8"""  ) as fp:
									fp.write("""\n""".join(snake_case__  )  )

							lowerCAmelCase__   = {
							    """do_resize""": True,
							    """size""": 20,
							    """do_center_crop""": True,
							    """crop_size""": 18,
							    """do_normalize""": True,
							    """image_mean""": [0.4814_5466, 0.457_8275, 0.4082_1073],
							    """image_std""": [0.2686_2954, 0.2613_0258, 0.2757_7711],
							}
							lowerCAmelCase__   = os.path.join(self.tmpdirname	,    snake_case__  )
							with open(self.image_processor_file	,    """w"""	,    encoding="""utf-8"""  ) as fp:
									json.dump(snake_case__	,    snake_case__  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  str	,    **snake_case__    :  Optional[Any]  ):
							return CLIPTokenizer.from_pretrained(self.tmpdirname	,    **snake_case__  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  Any	,    **snake_case__    :  List[Any]  ):
							return CLIPTokenizerFast.from_pretrained(self.tmpdirname	,    **snake_case__  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  List[str]	,    **snake_case__    :  int  ):
							return CLIPImageProcessor.from_pretrained(self.tmpdirname	,    **snake_case__  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  Optional[Any]  ):
							shutil.rmtree(self.tmpdirname  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  Optional[Any]  ):
							lowerCAmelCase__   = [np.random.randint(255	,    size=(3, 30, 400)	,    dtype=np.uinta  )]

							lowerCAmelCase__   = [Image.fromarray(np.moveaxis(snake_case__	,    0	,    -1  )  ) for x in image_inputs]

							return image_inputs




					def     _SCREAMING_SNAKE_CASE    (						self    :  List[Any]  ):
							lowerCAmelCase__   = self.get_tokenizer()
							lowerCAmelCase__   = self.get_rust_tokenizer()
							lowerCAmelCase__   = self.get_image_processor()

							lowerCAmelCase__   = CLIPProcessor(tokenizer=snake_case__	,    image_processor=snake_case__  )
							processor_slow.save_pretrained(self.tmpdirname  )
							lowerCAmelCase__   = CLIPProcessor.from_pretrained(self.tmpdirname	,    use_fast=snake_case__  )

							lowerCAmelCase__   = CLIPProcessor(tokenizer=snake_case__	,    image_processor=snake_case__  )
							processor_fast.save_pretrained(self.tmpdirname  )
							lowerCAmelCase__   = CLIPProcessor.from_pretrained(self.tmpdirname  )

							self.assertEqual(processor_slow.tokenizer.get_vocab()	,    tokenizer_slow.get_vocab()  )
							self.assertEqual(processor_fast.tokenizer.get_vocab()	,    tokenizer_fast.get_vocab()  )
							self.assertEqual(tokenizer_slow.get_vocab()	,    tokenizer_fast.get_vocab()  )
							self.assertIsInstance(processor_slow.tokenizer	,    snake_case__  )
							self.assertIsInstance(processor_fast.tokenizer	,    snake_case__  )

							self.assertEqual(processor_slow.image_processor.to_json_string()	,    image_processor.to_json_string()  )
							self.assertEqual(processor_fast.image_processor.to_json_string()	,    image_processor.to_json_string()  )
							self.assertIsInstance(processor_slow.image_processor	,    snake_case__  )
							self.assertIsInstance(processor_fast.image_processor	,    snake_case__  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  int  ):
							lowerCAmelCase__   = CLIPProcessor(tokenizer=self.get_tokenizer()	,    image_processor=self.get_image_processor()  )
							processor.save_pretrained(self.tmpdirname  )

							lowerCAmelCase__   = self.get_tokenizer(bos_token="""(BOS)"""	,    eos_token="""(EOS)"""  )
							lowerCAmelCase__   = self.get_image_processor(do_normalize=snake_case__	,    padding_value=1.0  )

							lowerCAmelCase__   = CLIPProcessor.from_pretrained(
							    self.tmpdirname	,    bos_token="""(BOS)"""	,    eos_token="""(EOS)"""	,    do_normalize=snake_case__	,    padding_value=1.0  )

							self.assertEqual(processor.tokenizer.get_vocab()	,    tokenizer_add_kwargs.get_vocab()  )
							self.assertIsInstance(processor.tokenizer	,    snake_case__  )

							self.assertEqual(processor.image_processor.to_json_string()	,    image_processor_add_kwargs.to_json_string()  )
							self.assertIsInstance(processor.image_processor	,    snake_case__  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  Optional[int]  ):
							lowerCAmelCase__   = self.get_image_processor()
							lowerCAmelCase__   = self.get_tokenizer()

							lowerCAmelCase__   = CLIPProcessor(tokenizer=snake_case__	,    image_processor=snake_case__  )

							lowerCAmelCase__   = self.prepare_image_inputs()

							lowerCAmelCase__   = image_processor(snake_case__	,    return_tensors="""np"""  )
							lowerCAmelCase__   = processor(images=snake_case__	,    return_tensors="""np"""  )

							for key in input_image_proc.keys():
									self.assertAlmostEqual(input_image_proc[key].sum()	,    input_processor[key].sum()	,    delta=1E-2  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  int  ):
							lowerCAmelCase__   = self.get_image_processor()
							lowerCAmelCase__   = self.get_tokenizer()

							lowerCAmelCase__   = CLIPProcessor(tokenizer=snake_case__	,    image_processor=snake_case__  )

							lowerCAmelCase__   = """lower newer"""

							lowerCAmelCase__   = processor(text=snake_case__  )

							lowerCAmelCase__   = tokenizer(snake_case__  )

							for key in encoded_tok.keys():
									self.assertListEqual(encoded_tok[key]	,    encoded_processor[key]  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  Optional[int]  ):
							lowerCAmelCase__   = self.get_image_processor()
							lowerCAmelCase__   = self.get_tokenizer()

							lowerCAmelCase__   = CLIPProcessor(tokenizer=snake_case__	,    image_processor=snake_case__  )

							lowerCAmelCase__   = """lower newer"""
							lowerCAmelCase__   = self.prepare_image_inputs()

							lowerCAmelCase__   = processor(text=snake_case__	,    images=snake_case__  )

							self.assertListEqual(list(inputs.keys()  )	,    ["""input_ids""", """attention_mask""", """pixel_values"""]  )

							# test if it raises when no input is passed
							with pytest.raises(snake_case__  ):
									processor()




					def     _SCREAMING_SNAKE_CASE    (						self    :  List[Any]  ):
							lowerCAmelCase__   = self.get_image_processor()
							lowerCAmelCase__   = self.get_tokenizer()

							lowerCAmelCase__   = CLIPProcessor(tokenizer=snake_case__	,    image_processor=snake_case__  )

							lowerCAmelCase__   = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

							lowerCAmelCase__   = processor.batch_decode(snake_case__  )
							lowerCAmelCase__   = tokenizer.batch_decode(snake_case__  )

							self.assertListEqual(snake_case__	,    snake_case__  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  Optional[int]  ):
							lowerCAmelCase__   = self.get_image_processor()
							lowerCAmelCase__   = self.get_tokenizer()

							lowerCAmelCase__   = CLIPProcessor(tokenizer=snake_case__	,    image_processor=snake_case__  )

							lowerCAmelCase__   = """lower newer"""
							lowerCAmelCase__   = self.prepare_image_inputs()

							lowerCAmelCase__   = processor(text=snake_case__	,    images=snake_case__  )

							self.assertListEqual(list(inputs.keys()  )	,    processor.model_input_names  )





"""simple docstring"""




from typing import Optional, Tuple

import jax
import jax.numpy as jnp
from flax import linen as nn
from flax.core.frozen_dict import FrozenDict
from transformers import CLIPConfig, FlaxPreTrainedModel
from transformers.models.clip.modeling_flax_clip import FlaxCLIPVisionModule







def 				_UpperCAmelCase		(							lowerCamelCase__      ,	lowerCamelCase__      ,	lowerCamelCase__=1e-12  ):





		"""simple docstring"""




		lowerCAmelCase__   = jnp.divide(emb_a.T      ,	jnp.clip(jnp.linalg.norm(lowerCamelCase__      ,	axis=1  )      ,	a_min=lowerCamelCase__  )  ).T
		lowerCAmelCase__   = jnp.divide(emb_a.T      ,	jnp.clip(jnp.linalg.norm(lowerCamelCase__      ,	axis=1  )      ,	a_min=lowerCamelCase__  )  ).T
		return jnp.matmul(lowerCamelCase__      ,	norm_emb_a.T  )

class    a_   (  nn.Module      ):
					UpperCamelCase_			:						CLIPConfig
					UpperCamelCase_			:						jnp.dtype      =     jnp.floataa




					def     _SCREAMING_SNAKE_CASE    (						self    :  Tuple  ):
							lowerCAmelCase__   = FlaxCLIPVisionModule(self.config.vision_config  )
							lowerCAmelCase__   = nn.Dense(self.config.projection_dim	,    use_bias=snake_case__	,    dtype=self.dtype  )

							lowerCAmelCase__   = self.param("""concept_embeds"""	,    jax.nn.initializers.ones	,    (17, self.config.projection_dim)  )
							lowerCAmelCase__   = self.param(
							    """special_care_embeds"""	,    jax.nn.initializers.ones	,    (3, self.config.projection_dim)  )

							lowerCAmelCase__   = self.param("""concept_embeds_weights"""	,    jax.nn.initializers.ones	,    (17,)  )
							lowerCAmelCase__   = self.param("""special_care_embeds_weights"""	,    jax.nn.initializers.ones	,    (3,)  )




					def __call__(						self    :  Optional[int]	,    snake_case__    :  int  ):
							lowerCAmelCase__   = self.vision_model(snake_case__  )[1]
							lowerCAmelCase__   = self.visual_projection(snake_case__  )

							lowerCAmelCase__   = jax_cosine_distance(snake_case__	,    self.special_care_embeds  )
							lowerCAmelCase__   = jax_cosine_distance(snake_case__	,    self.concept_embeds  )

							# increase this value to create a stronger `nfsw` filter
							# at the cost of increasing the possibility of filtering benign image inputs
							lowerCAmelCase__   = 0.0

							lowerCAmelCase__   = special_cos_dist - self.special_care_embeds_weights[None, :] + adjustment
							lowerCAmelCase__   = jnp.round(snake_case__	,    3  )
							lowerCAmelCase__   = jnp.any(special_scores > 0	,    axis=1	,    keepdims=snake_case__  )
							# Use a lower threshold if an image has any special care concept
							lowerCAmelCase__   = is_special_care * 0.01

							lowerCAmelCase__   = cos_dist - self.concept_embeds_weights[None, :] + special_adjustment
							lowerCAmelCase__   = jnp.round(snake_case__	,    3  )
							lowerCAmelCase__   = jnp.any(concept_scores > 0	,    axis=1  )

							return has_nsfw_concepts

class    a_   (  __UpperCamelCase      ):
					UpperCamelCase_			:						Any      =     CLIPConfig
					UpperCamelCase_			:						str      =     "clip_input"
					UpperCamelCase_			:						str      =     FlaxStableDiffusionSafetyCheckerModule




					def __init__(						self    :  Optional[int]	,    snake_case__    :  CLIPConfig	,    snake_case__    :  Optional[Tuple] = None	,    snake_case__    :  int = 0	,    snake_case__    :  jnp.dtype = jnp.floataa	,    snake_case__    :  bool = True	,    **snake_case__    :  str	,    ):
							if input_shape is None:
									lowerCAmelCase__   = (1, 224, 224, 3)
							lowerCAmelCase__   = self.module_class(config=snake_case__	,    dtype=snake_case__	,    **snake_case__  )
							super().__init__(snake_case__	,    snake_case__	,    input_shape=snake_case__	,    seed=snake_case__	,    dtype=snake_case__	,    _do_init=_do_init  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  Tuple	,    snake_case__    :  jax.random.KeyArray	,    snake_case__    :  Tuple	,    snake_case__    :  FrozenDict = None  ):
							# init input tensor
							lowerCAmelCase__   = jax.random.normal(snake_case__	,    snake_case__  )

							lowerCAmelCase__ ,       lowerCAmelCase__   = jax.random.split(snake_case__  )
							lowerCAmelCase__   = {"""params""": params_rng, """dropout""": dropout_rng}

							lowerCAmelCase__   = self.module.init(snake_case__	,    snake_case__  )["""params"""]

							return random_params




					def __call__(						self    :  Union[str, Any]	,    snake_case__    :  Union[str, Any]	,    snake_case__    :  dict = None	,    ):
							lowerCAmelCase__   = jnp.transpose(snake_case__	,    (0, 2, 3, 1)  )

							return self.module.apply(
							    {"""params""": params or self.params}	,    jnp.array(snake_case__	,    dtype=jnp.floataa  )	,    rngs={}	,    )




