



"""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       _snake_case						(						UpperCamelCase						:		Optional[int]			,		UpperCamelCase						:		Optional[Any]			,		UpperCamelCase						:		List[str]=1e-1_2						):
 UpperCAmelCase	:					Optional[int]	=	jnp.divide(emb_a.T			,		jnp.clip(jnp.linalg.norm(UpperCamelCase			,		axis=1						)			,		a_min=UpperCamelCase						)						).T
 UpperCAmelCase	:					List[Any]	=	jnp.divide(emb_a.T			,		jnp.clip(jnp.linalg.norm(UpperCamelCase			,		axis=1						)			,		a_min=UpperCamelCase						)						).T
 return jnp.matmul(UpperCamelCase			,		norm_emb_a.T						)



class       SCREAMING_SNAKE_CASE__  (					nn.Module ):
   __lowerCAmelCase  :   CLIPConfig
   __lowerCAmelCase  :   jnp.dtype						=						jnp.floataa

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      str:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	FlaxCLIPVisionModule(self.config.vision_config						)
    UpperCAmelCase	:					Dict	=	nn.Dense(self.config.projection_dim      ,     use_bias=_SCREAMING_SNAKE_CASE      ,     dtype=self.dtype						)

    UpperCAmelCase	:					Optional[int]	=	self.param("""concept_embeds"""      ,     jax.nn.initializers.ones      ,     (17, self.config.projection_dim)						)
    UpperCAmelCase	:					int	=	self.param(
        """special_care_embeds"""      ,     jax.nn.initializers.ones      ,     (3, self.config.projection_dim)						)

    UpperCAmelCase	:					Optional[int]	=	self.param("""concept_embeds_weights"""      ,     jax.nn.initializers.ones      ,     (17,)						)
    UpperCAmelCase	:					Any	=	self.param("""special_care_embeds_weights"""      ,     jax.nn.initializers.ones      ,     (3,)						)




   def __call__(   self      ,     _SCREAMING_SNAKE_CASE						)  ->      Optional[int]:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	self.vision_model(_SCREAMING_SNAKE_CASE						)[1]
    UpperCAmelCase	:					Optional[int]	=	self.visual_projection(_SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	:					List[str]	=	jax_cosine_distance(_SCREAMING_SNAKE_CASE      ,     self.special_care_embeds						)
    UpperCAmelCase	:					Optional[Any]	=	jax_cosine_distance(_SCREAMING_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
    UpperCAmelCase	:					int	=	0.0

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

    UpperCAmelCase	:					Optional[Any]	=	cos_dist - self.concept_embeds_weights[None, :] + special_adjustment
    UpperCAmelCase	:					Optional[int]	=	jnp.round(_SCREAMING_SNAKE_CASE      ,     3						)
    UpperCAmelCase	:					Optional[int]	=	jnp.any(concept_scores > 0      ,     axis=1						)

    return has_nsfw_concepts



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__ ):
   __lowerCAmelCase  :   Dict						=						CLIPConfig
   __lowerCAmelCase  :   Optional[int]						=						'clip_input'
   __lowerCAmelCase  :   Optional[Any]						=						FlaxStableDiffusionSafetyCheckerModule

   def __init__(   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = 0      ,     _SCREAMING_SNAKE_CASE = jnp.floataa      ,     _SCREAMING_SNAKE_CASE = True      ,     **_SCREAMING_SNAKE_CASE      ,     )  ->      str:





    '''simple docstring'''




    if input_shape is None:
     UpperCAmelCase	:					Any	=	(1, 224, 224, 3)
    UpperCAmelCase	:					Optional[int]	=	self.module_class(config=_SCREAMING_SNAKE_CASE      ,     dtype=_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE						)
    super().__init__(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     input_shape=_SCREAMING_SNAKE_CASE      ,     seed=_SCREAMING_SNAKE_CASE      ,     dtype=_SCREAMING_SNAKE_CASE      ,     _do_init=_do_init						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None						)  ->      FrozenDict:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	jax.random.normal(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	,		UpperCAmelCase	:					Dict	=	jax.random.split(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					str	=	{"""params""": params_rng, """dropout""": dropout_rng}

    UpperCAmelCase	:					Union[str, Any]	=	self.module.init(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)["""params"""]

    return random_params




   def __call__(   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None      ,     )  ->      Union[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	jnp.transpose(_SCREAMING_SNAKE_CASE      ,     (0, 2, 3, 1)						)

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





"""simple docstring"""
import os
from typing import List, Optional, Union

from ...tokenization_utils import PreTrainedTokenizer
from ...tokenization_utils_base import AddedToken
from ...utils import logging


A:   str								=		logging.get_logger(__name__)

A:   List[Any]								=		{"vocab_file": "vocab.txt"}

A:   List[str]								=		{
    "vocab_file": {
        "facebook/esm2_t6_8M_UR50D": "https://huggingface.co/facebook/esm2_t6_8M_UR50D/resolve/main/vocab.txt",
        "facebook/esm2_t12_35M_UR50D": "https://huggingface.co/facebook/esm2_t12_35M_UR50D/resolve/main/vocab.txt",
    },
}

A:   Dict								=		{
    "facebook/esm2_t6_8M_UR50D": 1_0_2_4,
    "facebook/esm2_t12_35M_UR50D": 1_0_2_4,
}

def       _snake_case						(						UpperCamelCase						:		int						):
 with open(UpperCamelCase			,		"""r"""						) as f:
  UpperCAmelCase	:					int	=	f.read().splitlines()
  return [l.strip() for l in lines]



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__ ):
   __lowerCAmelCase  :   Union[str, Any]						=						VOCAB_FILES_NAMES
   __lowerCAmelCase  :   Dict						=						PRETRAINED_VOCAB_FILES_MAP
   __lowerCAmelCase  :   List[Any]						=						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   __lowerCAmelCase  :   str						=						['input_ids', 'attention_mask']

   def __init__(   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE="<unk>"      ,     _SCREAMING_SNAKE_CASE="<cls>"      ,     _SCREAMING_SNAKE_CASE="<pad>"      ,     _SCREAMING_SNAKE_CASE="<mask>"      ,     _SCREAMING_SNAKE_CASE="<eos>"      ,     **_SCREAMING_SNAKE_CASE      ,     )  ->      Any:





    '''simple docstring'''




    super().__init__(**_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Optional[Any]	=	load_vocab_file(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Optional[Any]	=	dict(enumerate(self.all_tokens						)						)
    UpperCAmelCase	:					List[str]	=	{tok: ind for ind, tok in enumerate(self.all_tokens						)}
    UpperCAmelCase	:					Any	=	unk_token
    UpperCAmelCase	:					str	=	cls_token
    UpperCAmelCase	:					int	=	pad_token
    UpperCAmelCase	:					Tuple	=	mask_token
    UpperCAmelCase	:					str	=	eos_token
    UpperCAmelCase	:					List[str]	=	self.all_tokens
    self._create_trie(self.unique_no_split_tokens						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE						)  ->      str:





    '''simple docstring'''




    return self._id_to_token.get(_SCREAMING_SNAKE_CASE      ,     self.unk_token						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE						)  ->      int:





    '''simple docstring'''




    return self._token_to_id.get(_SCREAMING_SNAKE_CASE      ,     self._token_to_id.get(self.unk_token						)						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE						)  ->      Optional[Any]:





    '''simple docstring'''




    return text.split()

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE=False						)  ->      Union[str, Any]:





    '''simple docstring'''




    return len(self._id_to_token						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Dict:





    '''simple docstring'''




    return {token: i for i, token in enumerate(self.all_tokens						)}

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE						)  ->      int:





    '''simple docstring'''




    return self._token_to_id.get(_SCREAMING_SNAKE_CASE      ,     self._token_to_id.get(self.unk_token						)						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE						)  ->      str:





    '''simple docstring'''




    return self._id_to_token.get(_SCREAMING_SNAKE_CASE      ,     self.unk_token						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None						)  ->      List[int]:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	[self.cls_token_id]
    UpperCAmelCase	:					Tuple	=	[self.eos_token_id]  # No sep token in ESM vocabulary
    if token_ids_a is None:
     if self.eos_token_id is None:
      return cls + token_ids_a
     else:
      return cls + token_ids_a + sep
    elif self.eos_token_id is None:
     raise ValueError("""Cannot tokenize multiple sequences when EOS token is not set!"""						)
    return cls + token_ids_a + sep + token_ids_a + sep  # Multiple inputs always have an EOS token

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = False						)  ->      List[int]:





    '''simple docstring'''




    if already_has_special_tokens:
     if token_ids_a is not None:
      raise ValueError(
          """You should not supply a second sequence if the provided sequence of """
          """ids is already formatted with special tokens for the model."""						)

     return [1 if token in self.all_special_ids else 0 for token in token_ids_a]
    UpperCAmelCase	:					str	=	[1] + ([0] * len(_SCREAMING_SNAKE_CASE						)) + [1]
    if token_ids_a is not None:
     mask += [0] * len(_SCREAMING_SNAKE_CASE						) + [1]
    return mask

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)  ->      Optional[int]:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	os.path.join(_SCREAMING_SNAKE_CASE      ,     (filename_prefix + """-""" if filename_prefix else """""") + """vocab.txt"""						)
    with open(_SCREAMING_SNAKE_CASE      ,     """w"""						) as f:
     f.write("""\n""".join(self.all_tokens						)						)
    return (vocab_file,)

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





    '''simple docstring'''




    return self.get_vocab_size(with_added_tokens=_SCREAMING_SNAKE_CASE						)




   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = False						)  ->      int:





    '''simple docstring'''




    return super()._add_tokens(_SCREAMING_SNAKE_CASE      ,     special_tokens=_SCREAMING_SNAKE_CASE						)
