




import flax.linen as nn
import jax
import jax.numpy as jnp





class 			lowerCamelCase_				( nn.Module   ):


 '''simple docstring'''







 lowercase_							       =       42
 lowercase_							       =       jnp.floataa



 def  lowerCAmelCase_    (				self    :						List[str]		):
       SCREAMING_SNAKE_CASE_      		=     nn.Conv(
           self.out_channels							,							kernel_size=(3, 3)							,							strides=(1, 1)							,							padding=((1, 1), (1, 1))							,							dtype=self.dtype							,							)




 def __call__(				self    :						str							,							_lowerCAmelCase    :						Dict		):
       SCREAMING_SNAKE_CASE_		,					SCREAMING_SNAKE_CASE_		,					SCREAMING_SNAKE_CASE_		,					SCREAMING_SNAKE_CASE_      		=     hidden_states.shape
       SCREAMING_SNAKE_CASE_      		=     jax.image.resize(
           _lowerCAmelCase							,							shape=(batch, height * 2, width * 2, channels)							,							method='nearest'							,							)
       SCREAMING_SNAKE_CASE_      		=     self.conv(_lowerCAmelCase		)
       return hidden_states





class 			lowerCamelCase_				( nn.Module   ):


 '''simple docstring'''







 lowercase_							       =       42
 lowercase_							       =       jnp.floataa



 def  lowerCAmelCase_    (				self    :						Optional[int]		):
       SCREAMING_SNAKE_CASE_      		=     nn.Conv(
           self.out_channels							,							kernel_size=(3, 3)							,							strides=(2, 2)							,							padding=((1, 1), (1, 1))							,							dtype=self.dtype							,							)




 def __call__(				self    :						Tuple							,							_lowerCAmelCase    :						int		):
       # pad = ((0, 0), (0, 1), (0, 1), (0, 0))  # pad height and width dim
       # hidden_states = jnp.pad(hidden_states, pad_width=pad)
       SCREAMING_SNAKE_CASE_      		=     self.conv(_lowerCAmelCase		)
       return hidden_states





class 			lowerCamelCase_				( nn.Module   ):


 '''simple docstring'''







 lowercase_							       =       42
 lowercase_							       =       None
 lowercase_							       =       0.0
 lowercase_							       =       None
 lowercase_							       =       jnp.floataa



 def  lowerCAmelCase_    (				self    :						Tuple		):
       SCREAMING_SNAKE_CASE_      		=     self.in_channels if self.out_channels is None else self.out_channels

       SCREAMING_SNAKE_CASE_      		=     nn.GroupNorm(num_groups=32							,							epsilon=1E-5		)
       SCREAMING_SNAKE_CASE_      		=     nn.Conv(
           _lowerCAmelCase							,							kernel_size=(3, 3)							,							strides=(1, 1)							,							padding=((1, 1), (1, 1))							,							dtype=self.dtype							,							)

       SCREAMING_SNAKE_CASE_      		=     nn.Dense(_lowerCAmelCase							,							dtype=self.dtype		)

       SCREAMING_SNAKE_CASE_      		=     nn.GroupNorm(num_groups=32							,							epsilon=1E-5		)
       SCREAMING_SNAKE_CASE_      		=     nn.Dropout(self.dropout_prob		)
       SCREAMING_SNAKE_CASE_      		=     nn.Conv(
           _lowerCAmelCase							,							kernel_size=(3, 3)							,							strides=(1, 1)							,							padding=((1, 1), (1, 1))							,							dtype=self.dtype							,							)

       SCREAMING_SNAKE_CASE_      		=     self.in_channels != out_channels if self.use_nin_shortcut is None else self.use_nin_shortcut

       SCREAMING_SNAKE_CASE_      		=     None
       if use_nin_shortcut:
             SCREAMING_SNAKE_CASE_      		=     nn.Conv(
                 _lowerCAmelCase							,							kernel_size=(1, 1)							,							strides=(1, 1)							,							padding='VALID'							,							dtype=self.dtype							,							)




 def __call__(				self    :						Union[str, Any]							,							_lowerCAmelCase    :						List[str]							,							_lowerCAmelCase    :						Optional[Any]							,							_lowerCAmelCase    :						List[Any]=True		):
       SCREAMING_SNAKE_CASE_      		=     hidden_states
       SCREAMING_SNAKE_CASE_      		=     self.norma(_lowerCAmelCase		)
       SCREAMING_SNAKE_CASE_      		=     nn.swish(_lowerCAmelCase		)
       SCREAMING_SNAKE_CASE_      		=     self.conva(_lowerCAmelCase		)

       SCREAMING_SNAKE_CASE_      		=     self.time_emb_proj(nn.swish(_lowerCAmelCase		)		)
       SCREAMING_SNAKE_CASE_      		=     jnp.expand_dims(jnp.expand_dims(_lowerCAmelCase							,							1		)							,							1		)
       SCREAMING_SNAKE_CASE_      		=     hidden_states + temb

       SCREAMING_SNAKE_CASE_      		=     self.norma(_lowerCAmelCase		)
       SCREAMING_SNAKE_CASE_      		=     nn.swish(_lowerCAmelCase		)
       SCREAMING_SNAKE_CASE_      		=     self.dropout(_lowerCAmelCase							,							_lowerCAmelCase		)
       SCREAMING_SNAKE_CASE_      		=     self.conva(_lowerCAmelCase		)

       if self.conv_shortcut is not None:
             SCREAMING_SNAKE_CASE_      		=     self.conv_shortcut(_lowerCAmelCase		)

       return hidden_states + residual





import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
   from .tokenization_fnet import FNetTokenizer
else:
   lowerCamelCase__					:  Optional[Any]      							=				None

lowerCamelCase__					:  List[str]      							=				logging.get_logger(__name__)
lowerCamelCase__					:  List[str]      							=				{'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'}

lowerCamelCase__					:  List[str]      							=				{
    'vocab_file': {
        'google/fnet-base': 'https://huggingface.co/google/fnet-base/resolve/main/spiece.model',
        'google/fnet-large': 'https://huggingface.co/google/fnet-large/resolve/main/spiece.model',
    },
    'tokenizer_file': {
        'google/fnet-base': 'https://huggingface.co/google/fnet-base/resolve/main/tokenizer.json',
        'google/fnet-large': 'https://huggingface.co/google/fnet-large/resolve/main/tokenizer.json',
    },
}

lowerCamelCase__					:  Optional[Any]      							=				{
    'google/fnet-base': 512,
    'google/fnet-large': 512,
}

lowerCamelCase__					:  List[Any]      							=				'▁'





class 			lowerCamelCase_				( _SCREAMING_SNAKE_CASE   ):


 '''simple docstring'''







 lowercase_							       =       VOCAB_FILES_NAMES
 lowercase_							       =       PRETRAINED_VOCAB_FILES_MAP
 lowercase_							       =       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 lowercase_							       =       ["input_ids", "token_type_ids"]
 lowercase_							       =       FNetTokenizer



 def __init__(				self    :						List[Any]							,							_lowerCAmelCase    :						Dict=None							,							_lowerCAmelCase    :						Dict=None							,							_lowerCAmelCase    :						List[str]=False							,							_lowerCAmelCase    :						Optional[Any]=True							,							_lowerCAmelCase    :						Tuple=True							,							_lowerCAmelCase    :						List[Any]="<unk>"							,							_lowerCAmelCase    :						Optional[Any]="[SEP]"							,							_lowerCAmelCase    :						Optional[Any]="<pad>"							,							_lowerCAmelCase    :						Optional[int]="[CLS]"							,							_lowerCAmelCase    :						Optional[Any]="[MASK]"							,							**_lowerCAmelCase    :						Any							,							):
       # Mask token behave like a normal word, i.e. include the space before it and
       # is included in the raw text, there should be a match in a non-normalized sentence.
       SCREAMING_SNAKE_CASE_      		=     (
           AddedToken(_lowerCAmelCase							,							lstrip=_lowerCAmelCase							,							rstrip=_lowerCAmelCase							,							normalized=_lowerCAmelCase		)
           if isinstance(_lowerCAmelCase							,							_lowerCAmelCase		)
           else mask_token
       )

       super().__init__(
           _lowerCAmelCase							,							tokenizer_file=_lowerCAmelCase							,							do_lower_case=_lowerCAmelCase							,							remove_space=_lowerCAmelCase							,							keep_accents=_lowerCAmelCase							,							unk_token=_lowerCAmelCase							,							sep_token=_lowerCAmelCase							,							pad_token=_lowerCAmelCase							,							cls_token=_lowerCAmelCase							,							mask_token=_lowerCAmelCase							,							**_lowerCAmelCase							,							)

       SCREAMING_SNAKE_CASE_      		=     do_lower_case
       SCREAMING_SNAKE_CASE_      		=     remove_space
       SCREAMING_SNAKE_CASE_      		=     keep_accents
       SCREAMING_SNAKE_CASE_      		=     vocab_file
       SCREAMING_SNAKE_CASE_      		=     False if not self.vocab_file else True



 def  lowerCAmelCase_    (				self    :						Any							,							_lowerCAmelCase    :						List[int]							,							_lowerCAmelCase    :						Optional[List[int]] = None		):
       SCREAMING_SNAKE_CASE_      		=     [self.sep_token_id]
       SCREAMING_SNAKE_CASE_      		=     [self.cls_token_id]
       if token_ids_a is None:
             return cls + token_ids_a + sep
       return cls + token_ids_a + sep + token_ids_a + sep



 def  lowerCAmelCase_    (				self    :						Optional[int]							,							_lowerCAmelCase    :						List[int]							,							_lowerCAmelCase    :						Optional[List[int]] = None		):
       SCREAMING_SNAKE_CASE_      		=     [self.sep_token_id]
       SCREAMING_SNAKE_CASE_      		=     [self.cls_token_id]

       if token_ids_a is None:
             return len(cls + token_ids_a + sep		) * [0]
       return len(cls + token_ids_a + sep		) * [0] + len(token_ids_a + sep		) * [1]




 def  lowerCAmelCase_    (				self    :						Optional[Any]							,							_lowerCAmelCase    :						str							,							_lowerCAmelCase    :						Optional[str] = None		):
       if not os.path.isdir(_lowerCAmelCase		):
             logger.error(F"Vocabulary path ({save_directory}) should be a directory"		)
             return
       SCREAMING_SNAKE_CASE_      		=     os.path.join(
           _lowerCAmelCase							,							(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']		)

       if os.path.abspath(self.vocab_file		) != os.path.abspath(_lowerCAmelCase		):
             copyfile(self.vocab_file							,							_lowerCAmelCase		)

       return (out_vocab_file,)