


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							(      lowercase__    ,       lowercase__    ,       lowercase__=1e-12      ):
						__SCREAMING_SNAKE_CASE						:     int					=		jnp.divide(emb_a.T    ,       jnp.clip(jnp.linalg.norm(lowercase__    ,       axis=1      )    ,       a_min=lowercase__      )      ).T
						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		jnp.divide(emb_a.T    ,       jnp.clip(jnp.linalg.norm(lowercase__    ,       axis=1      )    ,       a_min=lowercase__      )      ).T
						return jnp.matmul(lowercase__    ,       norm_emb_a.T      )
class        _lowercase      (			nn.Module       ):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE__				:			CLIPConfig
				SCREAMING_SNAKE_CASE__				:			jnp.dtype						=		jnp.floataa


				def 		__magic_name__(       self			:str	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     Tuple					=		FlaxCLIPVisionModule(self.config.vision_config	)
										__SCREAMING_SNAKE_CASE						:     str					=		nn.Dense(self.config.projection_dim			,			use_bias=lowerCAmelCase__			,			dtype=self.dtype	)

										__SCREAMING_SNAKE_CASE						:     List[str]					=		self.param('''concept_embeds'''			,			jax.nn.initializers.ones			,			(17, self.config.projection_dim)	)
										__SCREAMING_SNAKE_CASE						:     Tuple					=		self.param(
										    '''special_care_embeds'''			,			jax.nn.initializers.ones			,			(3, self.config.projection_dim)	)

										__SCREAMING_SNAKE_CASE						:     str					=		self.param('''concept_embeds_weights'''			,			jax.nn.initializers.ones			,			(17,)	)
										__SCREAMING_SNAKE_CASE						:     Dict					=		self.param('''special_care_embeds_weights'''			,			jax.nn.initializers.ones			,			(3,)	)



				def __call__(       self			:Any			,			lowerCAmelCase__			:str	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		self.vision_model(lowerCAmelCase__	)[1]
										__SCREAMING_SNAKE_CASE						:     Any					=		self.visual_projection(lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Tuple					=		jax_cosine_distance(lowerCAmelCase__			,			self.special_care_embeds	)
										__SCREAMING_SNAKE_CASE						:     Any					=		jax_cosine_distance(lowerCAmelCase__			,			self.concept_embeds	)

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

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

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

										return has_nsfw_concepts




class        _lowercase      (			A__       ):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE__				:			int						=		CLIPConfig
				SCREAMING_SNAKE_CASE__				:			int						=		'''clip_input'''
				SCREAMING_SNAKE_CASE__				:			Union[str, Any]						=		FlaxStableDiffusionSafetyCheckerModule


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


				def 		__magic_name__(       self			:Optional[int]			,			lowerCAmelCase__			:jax.random.KeyArray			,			lowerCAmelCase__			:Tuple			,			lowerCAmelCase__			:FrozenDict = None	)		->			FrozenDict:
										# init input tensor
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		jax.random.normal(lowerCAmelCase__			,			lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE			,			__SCREAMING_SNAKE_CASE						:     Dict					=		jax.random.split(lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     int					=		{'''params''': params_rng, '''dropout''': dropout_rng}

										__SCREAMING_SNAKE_CASE						:     Dict					=		self.module.init(lowerCAmelCase__			,			lowerCAmelCase__	)['''params''']

										return random_params



				def __call__(       self			:Dict			,			lowerCAmelCase__			:List[Any]			,			lowerCAmelCase__			:dict = None			,			)		->			Tuple:
										__SCREAMING_SNAKE_CASE						:     List[str]					=		jnp.transpose(lowerCAmelCase__			,			(0, 2, 3, 1)	)

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




import unittest

from transformers.testing_utils import require_bsa
from transformers.utils import is_bsa_available

from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin


if is_bsa_available():
						from transformers import MarkupLMFeatureExtractor
class        _lowercase      (			unittest.TestCase       ):






				'''simple docstring'''



				def __init__(       self			:Optional[Any]			,			lowerCAmelCase__			:Optional[Any]	)		->			str:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		parent



				def 		__magic_name__(       self			:List[Any]	)		->			Tuple:
										return {}




def        _UpperCamelCase							(      ):
						__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		'''<HTML>

    <HEAD>
    <TITLE>sample document</TITLE>
    </HEAD>

    <BODY BGCOLOR="FFFFFF">
    <HR>
    <a href="http://google.com">Goog</a>
    <H1>This is one header</H1>
    <H2>This is a another Header</H2>
    <P>Travel from
        <P>
        <B>SFO to JFK</B>
        <BR>
        <B><I>on May 2, 2015 at 2:00 pm. For details go to confirm.com </I></B>
        <HR>
        <div style="color:#0000FF">
            <h3>Traveler <b> name </b> is
            <p> John Doe </p>
        </div>'''

						__SCREAMING_SNAKE_CASE						:     str					=		'''
    <!DOCTYPE html>
    <html>
    <body>

    <h1>My First Heading</h1>
    <p>My first paragraph.</p>

    </body>
    </html>
    '''

						return [html_string_a, html_string_a]
@require_bsa
class        _lowercase      (			A__						,			unittest.TestCase       ):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE__				:			Optional[int]						=		MarkupLMFeatureExtractor if is_bsa_available() else None


				def 		__magic_name__(       self			:int	)		->			Optional[Any]:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		MarkupLMFeatureExtractionTester(self	)


				@property
				def 		__magic_name__(       self			:Any	)		->			Optional[Any]:
										return self.feature_extract_tester.prepare_feat_extract_dict()



				def 		__magic_name__(       self			:Optional[int]	)		->			Any:
										# Initialize feature_extractor
										__SCREAMING_SNAKE_CASE						:     int					=		self.feature_extraction_class()

										# Test not batched input
										__SCREAMING_SNAKE_CASE						:     Tuple					=		get_html_strings()[0]
										__SCREAMING_SNAKE_CASE						:     Dict					=		feature_extractor(lowerCAmelCase__	)

										# fmt: off
										__SCREAMING_SNAKE_CASE						:     str					=		[['''sample document''', '''Goog''', '''This is one header''', '''This is a another Header''', '''Travel from''', '''SFO to JFK''', '''on May 2, 2015 at 2:00 pm. For details go to confirm.com''', '''Traveler''', '''name''', '''is''', '''John Doe''']]
										__SCREAMING_SNAKE_CASE						:     List[str]					=		[['''/html/head/title''', '''/html/body/a''', '''/html/body/h1''', '''/html/body/h2''', '''/html/body/p''', '''/html/body/p/p/b[1]''', '''/html/body/p/p/b[2]/i''', '''/html/body/p/p/div/h3''', '''/html/body/p/p/div/h3/b''', '''/html/body/p/p/div/h3''', '''/html/body/p/p/div/h3/p''']]
										# fmt: on

										self.assertEqual(encoding.nodes			,			lowerCAmelCase__	)
										self.assertEqual(encoding.xpaths			,			lowerCAmelCase__	)

										# Test batched
										__SCREAMING_SNAKE_CASE						:     Tuple					=		get_html_strings()
										__SCREAMING_SNAKE_CASE						:     Dict					=		feature_extractor(lowerCAmelCase__	)

										# fmt: off
										__SCREAMING_SNAKE_CASE						:     int					=		expected_nodes + [['''My First Heading''', '''My first paragraph.''']]
										__SCREAMING_SNAKE_CASE						:     str					=		expected_xpaths + [['''/html/body/h1''', '''/html/body/p''']]

										self.assertEqual(len(encoding.nodes	)			,			2	)
										self.assertEqual(len(encoding.xpaths	)			,			2	)

										self.assertEqual(encoding.nodes			,			lowerCAmelCase__	)
										self.assertEqual(encoding.xpaths			,			lowerCAmelCase__	)
