




"""simple docstring"""






from typing import Any, Dict, Optional

import torch
import torch.nn.functional as F
from torch import nn

from ..utils import maybe_allow_in_graph
from .activations import get_activation
from .attention_processor import Attention
from .embeddings import CombinedTimestepLabelEmbeddings






@maybe_allow_in_graph
class lowerCAmelCase__      (	nn.Module		):






			'''simple docstring'''



			def __init__(    self    , lowercase    , lowercase    , lowercase    , lowercase=0.0    , lowercase = None    , lowercase = "geglu"    , lowercase = None    , lowercase = False    , lowercase = False    , lowercase = False    , lowercase = False    , lowercase = True    , lowercase = "layer_norm"    , lowercase = False    , ):
							super().__init__()
							_lowerCamelCase	:     List[Any]       =       only_cross_attention

							_lowerCamelCase	:     Optional[Any]       =       (num_embeds_ada_norm is not None) and norm_type == 'ada_norm_zero'
							_lowerCamelCase	:     Any       =       (num_embeds_ada_norm is not None) and norm_type == 'ada_norm'

							if norm_type in ("ada_norm", "ada_norm_zero") and num_embeds_ada_norm is None:
											raise ValueError(
											    F'''`norm_type` is set to {norm_type}, but `num_embeds_ada_norm` is not defined. Please make sure to'''
											    F''' define `num_embeds_ada_norm` if setting `norm_type` to {norm_type}.'''    )

							# Define 3 blocks. Each block has its own normalization layer.
							# 1. Self-Attn
							if self.use_ada_layer_norm:
											_lowerCamelCase	:     Dict       =       AdaLayerNorm(lowercase    , lowercase    )
							elif self.use_ada_layer_norm_zero:
											_lowerCamelCase	:     Tuple       =       AdaLayerNormZero(lowercase    , lowercase    )
							else:
											_lowerCamelCase	:     Dict       =       nn.LayerNorm(lowercase    , elementwise_affine=lowercase    )
							_lowerCamelCase	:     Any       =       Attention(
							    query_dim=lowercase    , heads=lowercase    , dim_head=lowercase    , dropout=lowercase    , bias=lowercase    , cross_attention_dim=cross_attention_dim if only_cross_attention else None    , upcast_attention=lowercase    , )

							# 2. Cross-Attn
							if cross_attention_dim is not None or double_self_attention:
											# We currently only use AdaLayerNormZero for self attention where there will only be one attention block.
											# I.e. the number of returned modulation chunks from AdaLayerZero would not make sense if returned during
											# the second cross attention block.
											_lowerCamelCase	:     Any       =       (
											    AdaLayerNorm(lowercase    , lowercase    )
											    if self.use_ada_layer_norm
											    else nn.LayerNorm(lowercase    , elementwise_affine=lowercase    )
											)
											_lowerCamelCase	:     List[Any]       =       Attention(
											    query_dim=lowercase    , cross_attention_dim=cross_attention_dim if not double_self_attention else None    , heads=lowercase    , dim_head=lowercase    , dropout=lowercase    , bias=lowercase    , upcast_attention=lowercase    , )  # is self-attn if encoder_hidden_states is none
							else:
											_lowerCamelCase	:     List[Any]       =       None
											_lowerCamelCase	:     Union[str, Any]       =       None

							# 3. Feed-forward
							_lowerCamelCase	:     Optional[int]       =       nn.LayerNorm(lowercase    , elementwise_affine=lowercase    )
							_lowerCamelCase	:     Tuple       =       FeedForward(lowercase    , dropout=lowercase    , activation_fn=lowercase    , final_dropout=lowercase    )

							# let chunk size default to None
							_lowerCamelCase	:     str       =       None
							_lowerCamelCase	:     Optional[Any]       =       0
			def    A_       (    self    , lowercase    , lowercase    ):
							# Sets chunk feed-forward
							_lowerCamelCase	:     Tuple       =       chunk_size
							_lowerCamelCase	:     Tuple       =       dim






			def    A_       (    self    , lowercase    , lowercase = None    , lowercase = None    , lowercase = None    , lowercase = None    , lowercase = None    , lowercase = None    , ):
							# Notice that normalization is always applied before the real computation in the following blocks.
							# 1. Self-Attention
							if self.use_ada_layer_norm:
											_lowerCamelCase	:     Optional[Any]       =       self.norma(lowercase    , lowercase    )
							elif self.use_ada_layer_norm_zero:
											_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase	:     Optional[int]       =       self.norma(
											    lowercase    , lowercase    , lowercase    , hidden_dtype=hidden_states.dtype    )
							else:
											_lowerCamelCase	:     Optional[int]       =       self.norma(lowercase    )

							_lowerCamelCase	:     List[Any]       =       cross_attention_kwargs if cross_attention_kwargs is not None else {}

							_lowerCamelCase	:     List[Any]       =       self.attna(
							    lowercase    , encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None    , attention_mask=lowercase    , **lowercase    , )
							if self.use_ada_layer_norm_zero:
											_lowerCamelCase	:     Union[str, Any]       =       gate_msa.unsqueeze(1    ) * attn_output
							_lowerCamelCase	:     str       =       attn_output + hidden_states

							# 2. Cross-Attention
							if self.attna is not None:
											_lowerCamelCase	:     Optional[Any]       =       (
											    self.norma(lowercase    , lowercase    ) if self.use_ada_layer_norm else self.norma(lowercase    )
											)

											_lowerCamelCase	:     str       =       self.attna(
											    lowercase    , encoder_hidden_states=lowercase    , attention_mask=lowercase    , **lowercase    , )
											_lowerCamelCase	:     List[str]       =       attn_output + hidden_states

							# 3. Feed-forward
							_lowerCamelCase	:     Union[str, Any]       =       self.norma(lowercase    )

							if self.use_ada_layer_norm_zero:
											_lowerCamelCase	:     Optional[Any]       =       norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None]

							if self._chunk_size is not None:
											# "feed_forward_chunk_size" can be used to save memory
											if norm_hidden_states.shape[self._chunk_dim] % self._chunk_size != 0:
															raise ValueError(
															    F'''`hidden_states` dimension to be chunked: {norm_hidden_states.shape[self._chunk_dim]} has to be divisible by chunk size: {self._chunk_size}. Make sure to set an appropriate `chunk_size` when calling `unet.enable_forward_chunking`.'''    )

											_lowerCamelCase	:     Union[str, Any]       =       norm_hidden_states.shape[self._chunk_dim] // self._chunk_size
											_lowerCamelCase	:     Optional[int]       =       torch.cat(
											    [self.ff(lowercase    ) for hid_slice in norm_hidden_states.chunk(lowercase    , dim=self._chunk_dim    )]    , dim=self._chunk_dim    , )
							else:
											_lowerCamelCase	:     Dict       =       self.ff(lowercase    )

							if self.use_ada_layer_norm_zero:
											_lowerCamelCase	:     List[Any]       =       gate_mlp.unsqueeze(1    ) * ff_output

							_lowerCamelCase	:     Tuple       =       ff_output + hidden_states

							return hidden_states






class lowerCAmelCase__      (	nn.Module		):






			'''simple docstring'''



			def __init__(    self    , lowercase    , lowercase = None    , lowercase = 4    , lowercase = 0.0    , lowercase = "geglu"    , lowercase = False    , ):
							super().__init__()
							_lowerCamelCase	:     Any       =       int(dim * mult    )
							_lowerCamelCase	:     Union[str, Any]       =       dim_out if dim_out is not None else dim

							if activation_fn == "gelu":
											_lowerCamelCase	:     Optional[int]       =       GELU(lowercase    , lowercase    )
							if activation_fn == "gelu-approximate":
											_lowerCamelCase	:     Any       =       GELU(lowercase    , lowercase    , approximate='tanh'    )
							elif activation_fn == "geglu":
											_lowerCamelCase	:     List[Any]       =       GEGLU(lowercase    , lowercase    )
							elif activation_fn == "geglu-approximate":
											_lowerCamelCase	:     Tuple       =       ApproximateGELU(lowercase    , lowercase    )

							_lowerCamelCase	:     List[str]       =       nn.ModuleList([]    )
							# project in
							self.net.append(lowercase    )
							# project dropout
							self.net.append(nn.Dropout(lowercase    )    )
							# project out
							self.net.append(nn.Linear(lowercase    , lowercase    )    )
							# FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout
							if final_dropout:
											self.net.append(nn.Dropout(lowercase    )    )






			def    A_       (    self    , lowercase    ):
							for module in self.net:
											_lowerCamelCase	:     List[Any]       =       module(lowercase    )
							return hidden_states






class lowerCAmelCase__      (	nn.Module		):






			'''simple docstring'''



			def __init__(    self    , lowercase    , lowercase    , lowercase = "none"    ):
							super().__init__()
							_lowerCamelCase	:     Tuple       =       nn.Linear(lowercase    , lowercase    )
							_lowerCamelCase	:     Optional[int]       =       approximate
			def    A_       (    self    , lowercase    ):
							if gate.device.type != "mps":
											return F.gelu(lowercase    , approximate=self.approximate    )
							# mps: gelu is not implemented for float16
							return F.gelu(gate.to(dtype=torch.floataa    )    , approximate=self.approximate    ).to(dtype=gate.dtype    )






			def    A_       (    self    , lowercase    ):
							_lowerCamelCase	:     List[str]       =       self.proj(lowercase    )
							_lowerCamelCase	:     Tuple       =       self.gelu(lowercase    )
							return hidden_states






class lowerCAmelCase__      (	nn.Module		):






			'''simple docstring'''



			def __init__(    self    , lowercase    , lowercase    ):
							super().__init__()
							_lowerCamelCase	:     List[str]       =       nn.Linear(lowercase    , dim_out * 2    )
			def    A_       (    self    , lowercase    ):
							if gate.device.type != "mps":
											return F.gelu(lowercase    )
							# mps: gelu is not implemented for float16
							return F.gelu(gate.to(dtype=torch.floataa    )    ).to(dtype=gate.dtype    )






			def    A_       (    self    , lowercase    ):
							_lowerCamelCase,					_lowerCamelCase	:     List[str]       =       self.proj(lowercase    ).chunk(2    , dim=-1    )
							return hidden_states * self.gelu(lowercase    )






class lowerCAmelCase__      (	nn.Module		):






			'''simple docstring'''



			def __init__(    self    , lowercase    , lowercase    ):
							super().__init__()
							_lowerCamelCase	:     Union[str, Any]       =       nn.Linear(lowercase    , lowercase    )






			def    A_       (    self    , lowercase    ):
							_lowerCamelCase	:     Dict       =       self.proj(lowercase    )
							return x * torch.sigmoid(1.7_02 * x    )






class lowerCAmelCase__      (	nn.Module		):






			'''simple docstring'''



			def __init__(    self    , lowercase    , lowercase    ):
							super().__init__()
							_lowerCamelCase	:     Optional[Any]       =       nn.Embedding(lowercase    , lowercase    )
							_lowerCamelCase	:     Optional[Any]       =       nn.SiLU()
							_lowerCamelCase	:     Optional[int]       =       nn.Linear(lowercase    , embedding_dim * 2    )
							_lowerCamelCase	:     Tuple       =       nn.LayerNorm(lowercase    , elementwise_affine=lowercase    )






			def    A_       (    self    , lowercase    , lowercase    ):
							_lowerCamelCase	:     Optional[int]       =       self.linear(self.silu(self.emb(lowercase    )    )    )
							_lowerCamelCase,					_lowerCamelCase	:     Optional[int]       =       torch.chunk(lowercase    , 2    )
							_lowerCamelCase	:     Union[str, Any]       =       self.norm(lowercase    ) * (1 + scale) + shift
							return x






class lowerCAmelCase__      (	nn.Module		):






			'''simple docstring'''



			def __init__(    self    , lowercase    , lowercase    ):
							super().__init__()

							_lowerCamelCase	:     Optional[int]       =       CombinedTimestepLabelEmbeddings(lowercase    , lowercase    )

							_lowerCamelCase	:     Optional[int]       =       nn.SiLU()
							_lowerCamelCase	:     List[str]       =       nn.Linear(lowercase    , 6 * embedding_dim    , bias=lowercase    )
							_lowerCamelCase	:     str       =       nn.LayerNorm(lowercase    , elementwise_affine=lowercase    , eps=1E-6    )






			def    A_       (    self    , lowercase    , lowercase    , lowercase    , lowercase=None    ):
							_lowerCamelCase	:     Dict       =       self.linear(self.silu(self.emb(lowercase    , lowercase    , hidden_dtype=lowercase    )    )    )
							_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase	:     List[Any]       =       emb.chunk(6    , dim=1    )
							_lowerCamelCase	:     Dict       =       self.norm(lowercase    ) * (1 + scale_msa[:, None]) + shift_msa[:, None]
							return x, gate_msa, shift_mlp, scale_mlp, gate_mlp






class lowerCAmelCase__      (	nn.Module		):






			'''simple docstring'''



			def __init__(    self    , lowercase    , lowercase    , lowercase    , lowercase = None    , lowercase = 1E-5    ):
							super().__init__()
							_lowerCamelCase	:     Tuple       =       num_groups
							_lowerCamelCase	:     str       =       eps

							if act_fn is None:
											_lowerCamelCase	:     int       =       None
							else:
											_lowerCamelCase	:     Union[str, Any]       =       get_activation(lowercase    )

							_lowerCamelCase	:     List[str]       =       nn.Linear(lowercase    , out_dim * 2    )






			def    A_       (    self    , lowercase    , lowercase    ):
							if self.act:
											_lowerCamelCase	:     Tuple       =       self.act(lowercase    )
							_lowerCamelCase	:     str       =       self.linear(lowercase    )
							_lowerCamelCase	:     List[str]       =       emb[:, :, None, None]
							_lowerCamelCase,					_lowerCamelCase	:     Optional[Any]       =       emb.chunk(2    , dim=1    )

							_lowerCamelCase	:     Any       =       F.group_norm(lowercase    , self.num_groups    , eps=self.eps    )
							_lowerCamelCase	:     Any       =       x * (1 + scale) + shift
							return x





"""simple docstring"""






import itertools
import json
import os
import unittest

from transformers import AddedToken, RobertaTokenizer, RobertaTokenizerFast
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class lowerCAmelCase__      (	lowercase,      unittest.TestCase		):






			'''simple docstring'''



			lowerCamelCase__ =     RobertaTokenizer
			lowerCamelCase__ =     RobertaTokenizerFast
			lowerCamelCase__ =     True
			lowerCamelCase__ =     {"""cls_token""": """<s>"""}
			def    A_       (    self    ):
							super().setUp()

							# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
							_lowerCamelCase	:     Optional[Any]       =       [
							    'l',
							    'o',
							    'w',
							    'e',
							    'r',
							    's',
							    't',
							    'i',
							    'd',
							    'n',
							    '\u0120',
							    '\u0120l',
							    '\u0120n',
							    '\u0120lo',
							    '\u0120low',
							    'er',
							    '\u0120lowest',
							    '\u0120newer',
							    '\u0120wider',
							    '<unk>',
							]
							_lowerCamelCase	:     Optional[int]       =       dict(zip(lowercase    , range(len(lowercase    )    )    )    )
							_lowerCamelCase	:     Optional[int]       =       ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
							_lowerCamelCase	:     Optional[Any]       =       {'unk_token': '<unk>'}

							_lowerCamelCase	:     Optional[int]       =       os.path.join(self.tmpdirname    , VOCAB_FILES_NAMES['vocab_file']    )
							_lowerCamelCase	:     Optional[Any]       =       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(lowercase    ) + '\n'    )
							with open(self.merges_file    , 'w'    , encoding='utf-8'    ) as fp:
											fp.write('\n'.join(lowercase    )    )
			def    A_       (    self    , **lowercase    ):
							kwargs.update(self.special_tokens_map    )
							return self.tokenizer_class.from_pretrained(self.tmpdirname    , **lowercase    )
			def    A_       (    self    , **lowercase    ):
							kwargs.update(self.special_tokens_map    )
							return RobertaTokenizerFast.from_pretrained(self.tmpdirname    , **lowercase    )
			def    A_       (    self    , lowercase    ):
							_lowerCamelCase	:     Any       =       'lower newer'
							_lowerCamelCase	:     Union[str, Any]       =       'lower newer'
							return input_text, output_text
			def    A_       (    self    ):
							_lowerCamelCase	:     Dict       =       self.tokenizer_class(self.vocab_file    , self.merges_file    , **self.special_tokens_map    )
							_lowerCamelCase	:     List[str]       =       'lower newer'
							_lowerCamelCase	:     Tuple       =       ['l', 'o', 'w', 'er', '\u0120', 'n', 'e', 'w', 'er']
							_lowerCamelCase	:     List[str]       =       tokenizer.tokenize(lowercase    )  # , add_prefix_space=True)
							self.assertListEqual(lowercase    , lowercase    )

							_lowerCamelCase	:     List[Any]       =       tokens + [tokenizer.unk_token]
							_lowerCamelCase	:     str       =       [0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
							self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase    )    , lowercase    )
			def    A_       (    self    ):
							_lowerCamelCase	:     Union[str, Any]       =       self.get_tokenizer()

							self.assertListEqual(tokenizer.encode('Hello world!'    , add_special_tokens=lowercase    )    , [0, 31414, 232, 328, 2]    )
							self.assertListEqual(
							    tokenizer.encode('Hello world! cécé herlolip 418'    , add_special_tokens=lowercase    )    , [0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]    , )
			@slow
			def    A_       (    self    ):
							_lowerCamelCase	:     Dict       =       self.tokenizer_class.from_pretrained('roberta-base'    )

							_lowerCamelCase	:     Tuple       =       tokenizer.encode('sequence builders'    , add_special_tokens=lowercase    )
							_lowerCamelCase	:     int       =       tokenizer.encode('multi-sequence build'    , add_special_tokens=lowercase    )

							_lowerCamelCase	:     List[Any]       =       tokenizer.encode(
							    'sequence builders'    , add_special_tokens=lowercase    , add_prefix_space=lowercase    )
							_lowerCamelCase	:     List[str]       =       tokenizer.encode(
							    'sequence builders'    , 'multi-sequence build'    , add_special_tokens=lowercase    , add_prefix_space=lowercase    )

							_lowerCamelCase	:     Dict       =       tokenizer.build_inputs_with_special_tokens(lowercase    )
							_lowerCamelCase	:     Optional[int]       =       tokenizer.build_inputs_with_special_tokens(lowercase    , lowercase    )

							assert encoded_sentence == encoded_text_from_decode
							assert encoded_pair == encoded_pair_from_decode
			def    A_       (    self    ):
							_lowerCamelCase	:     Tuple       =       self.get_tokenizer()

							_lowerCamelCase	:     str       =       'Encode this sequence.'
							_lowerCamelCase	:     Optional[int]       =       tokenizer.byte_encoder[' '.encode('utf-8'    )[0]]

							# Testing encoder arguments
							_lowerCamelCase	:     Optional[int]       =       tokenizer.encode(lowercase    , add_special_tokens=lowercase    , add_prefix_space=lowercase    )
							_lowerCamelCase	:     Union[str, Any]       =       tokenizer.convert_ids_to_tokens(encoded[0]    )[0]
							self.assertNotEqual(lowercase    , lowercase    )

							_lowerCamelCase	:     List[str]       =       tokenizer.encode(lowercase    , add_special_tokens=lowercase    , add_prefix_space=lowercase    )
							_lowerCamelCase	:     List[Any]       =       tokenizer.convert_ids_to_tokens(encoded[0]    )[0]
							self.assertEqual(lowercase    , lowercase    )

							tokenizer.add_special_tokens({'bos_token': '<s>'}    )
							_lowerCamelCase	:     Optional[Any]       =       tokenizer.encode(lowercase    , add_special_tokens=lowercase    )
							_lowerCamelCase	:     Union[str, Any]       =       tokenizer.convert_ids_to_tokens(encoded[1]    )[0]
							self.assertNotEqual(lowercase    , lowercase    )

							# Testing spaces after special tokens
							_lowerCamelCase	:     List[Any]       =       '<mask>'
							tokenizer.add_special_tokens(
							    {'mask_token': AddedToken(lowercase    , lstrip=lowercase    , rstrip=lowercase    )}    )  # mask token has a left space
							_lowerCamelCase	:     List[str]       =       tokenizer.convert_tokens_to_ids(lowercase    )

							_lowerCamelCase	:     Optional[int]       =       'Encode <mask> sequence'
							_lowerCamelCase	:     int       =       'Encode <mask>sequence'

							_lowerCamelCase	:     str       =       tokenizer.encode(lowercase    )
							_lowerCamelCase	:     Tuple       =       encoded.index(lowercase    )
							_lowerCamelCase	:     int       =       tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]    )[0]
							self.assertEqual(lowercase    , lowercase    )

							_lowerCamelCase	:     Any       =       tokenizer.encode(lowercase    )
							_lowerCamelCase	:     Union[str, Any]       =       encoded.index(lowercase    )
							_lowerCamelCase	:     int       =       tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]    )[0]
							self.assertNotEqual(lowercase    , lowercase    )
			def    A_       (    self    ):
							pass
			def    A_       (    self    ):
							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
															_lowerCamelCase	:     Optional[Any]       =       self.rust_tokenizer_class.from_pretrained(lowercase    , **lowercase    )
															_lowerCamelCase	:     Dict       =       self.tokenizer_class.from_pretrained(lowercase    , **lowercase    )
															_lowerCamelCase	:     List[str]       =       'A, <mask> AllenNLP sentence.'
															_lowerCamelCase	:     List[Any]       =       tokenizer_r.encode_plus(lowercase    , add_special_tokens=lowercase    , return_token_type_ids=lowercase    )
															_lowerCamelCase	:     Union[str, Any]       =       tokenizer_p.encode_plus(lowercase    , add_special_tokens=lowercase    , return_token_type_ids=lowercase    )

															# token_type_ids should put 0 everywhere
															self.assertEqual(sum(tokens_r['token_type_ids']    )    , sum(tokens_p['token_type_ids']    )    )

															# attention_mask should put 1 everywhere, so sum over length should be 1
															self.assertEqual(
															    sum(tokens_r['attention_mask']    ) / len(tokens_r['attention_mask']    )    , sum(tokens_p['attention_mask']    ) / len(tokens_p['attention_mask']    )    , )

															_lowerCamelCase	:     List[Any]       =       tokenizer_r.convert_ids_to_tokens(tokens_r['input_ids']    )
															_lowerCamelCase	:     Tuple       =       tokenizer_p.convert_ids_to_tokens(tokens_p['input_ids']    )

															# Rust correctly handles the space before the mask while python doesnt
															self.assertSequenceEqual(tokens_p['input_ids']    , [0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2]    )
															self.assertSequenceEqual(tokens_r['input_ids']    , [0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2]    )

															self.assertSequenceEqual(
															    lowercase    , ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']    )
															self.assertSequenceEqual(
															    lowercase    , ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']    )
			def    A_       (    self    ):
							for trim_offsets, add_prefix_space in itertools.product([True, False]    , repeat=2    ):
											_lowerCamelCase	:     Union[str, Any]       =       self.rust_tokenizer_class.from_pretrained(
											    self.tmpdirname    , use_fast=lowercase    , add_prefix_space=lowercase    , trim_offsets=lowercase    )

											_lowerCamelCase	:     Optional[int]       =       json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()    )
											_lowerCamelCase	:     Dict       =       json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()    )

											self.assertEqual(pre_tokenizer_state['add_prefix_space']    , lowercase    )

											self.assertEqual(post_processor_state['add_prefix_space']    , lowercase    )
											self.assertEqual(post_processor_state['trim_offsets']    , lowercase    )






			def    A_       (    self    ):
							# Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space` and
							# `trim_offsets`
							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
															_lowerCamelCase	:     Dict       =       'hello'  # `hello` is a token in the vocabulary of `pretrained_name`
															_lowerCamelCase	:     Tuple       =       F'''{text_of_1_token} {text_of_1_token}'''

															_lowerCamelCase	:     Dict       =       self.rust_tokenizer_class.from_pretrained(
															    lowercase    , use_fast=lowercase    , add_prefix_space=lowercase    , trim_offsets=lowercase    )
															_lowerCamelCase	:     List[Any]       =       tokenizer_r(lowercase    , return_offsets_mapping=lowercase    , add_special_tokens=lowercase    )
															self.assertEqual(encoding.offset_mapping[0]    , (0, len(lowercase    ))    )
															self.assertEqual(
															    encoding.offset_mapping[1]    , (len(lowercase    ) + 1, len(lowercase    ) + 1 + len(lowercase    ))    , )

															_lowerCamelCase	:     int       =       self.rust_tokenizer_class.from_pretrained(
															    lowercase    , use_fast=lowercase    , add_prefix_space=lowercase    , trim_offsets=lowercase    )
															_lowerCamelCase	:     Union[str, Any]       =       tokenizer_r(lowercase    , return_offsets_mapping=lowercase    , add_special_tokens=lowercase    )
															self.assertEqual(encoding.offset_mapping[0]    , (0, len(lowercase    ))    )
															self.assertEqual(
															    encoding.offset_mapping[1]    , (len(lowercase    ) + 1, len(lowercase    ) + 1 + len(lowercase    ))    , )

															_lowerCamelCase	:     Union[str, Any]       =       self.rust_tokenizer_class.from_pretrained(
															    lowercase    , use_fast=lowercase    , add_prefix_space=lowercase    , trim_offsets=lowercase    )
															_lowerCamelCase	:     List[str]       =       tokenizer_r(lowercase    , return_offsets_mapping=lowercase    , add_special_tokens=lowercase    )
															self.assertEqual(encoding.offset_mapping[0]    , (0, len(lowercase    ))    )
															self.assertEqual(
															    encoding.offset_mapping[1]    , (len(lowercase    ), len(lowercase    ) + 1 + len(lowercase    ))    , )

															_lowerCamelCase	:     Dict       =       self.rust_tokenizer_class.from_pretrained(
															    lowercase    , use_fast=lowercase    , add_prefix_space=lowercase    , trim_offsets=lowercase    )
															_lowerCamelCase	:     int       =       tokenizer_r(lowercase    , return_offsets_mapping=lowercase    , add_special_tokens=lowercase    )
															self.assertEqual(encoding.offset_mapping[0]    , (0, len(lowercase    ))    )
															self.assertEqual(
															    encoding.offset_mapping[1]    , (len(lowercase    ), len(lowercase    ) + 1 + len(lowercase    ))    , )

															_lowerCamelCase	:     int       =       F''' {text}'''

															# tokenizer_r = self.rust_tokenizer_class.from_pretrained(
															#     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
															# )
															# encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
															# self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
															# self.assertEqual(
															#     encoding.offset_mapping[1],
															#     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
															# )

															_lowerCamelCase	:     Optional[Any]       =       self.rust_tokenizer_class.from_pretrained(
															    lowercase    , use_fast=lowercase    , add_prefix_space=lowercase    , trim_offsets=lowercase    )
															_lowerCamelCase	:     Optional[int]       =       tokenizer_r(lowercase    , return_offsets_mapping=lowercase    , add_special_tokens=lowercase    )
															self.assertEqual(encoding.offset_mapping[0]    , (1, 1 + len(lowercase    ))    )
															self.assertEqual(
															    encoding.offset_mapping[1]    , (1 + len(lowercase    ) + 1, 1 + len(lowercase    ) + 1 + len(lowercase    ))    , )

															_lowerCamelCase	:     Optional[int]       =       self.rust_tokenizer_class.from_pretrained(
															    lowercase    , use_fast=lowercase    , add_prefix_space=lowercase    , trim_offsets=lowercase    )
															_lowerCamelCase	:     Union[str, Any]       =       tokenizer_r(lowercase    , return_offsets_mapping=lowercase    , add_special_tokens=lowercase    )
															self.assertEqual(encoding.offset_mapping[0]    , (0, 1 + len(lowercase    ))    )
															self.assertEqual(
															    encoding.offset_mapping[1]    , (1 + len(lowercase    ), 1 + len(lowercase    ) + 1 + len(lowercase    ))    , )

															_lowerCamelCase	:     Union[str, Any]       =       self.rust_tokenizer_class.from_pretrained(
															    lowercase    , use_fast=lowercase    , add_prefix_space=lowercase    , trim_offsets=lowercase    )
															_lowerCamelCase	:     Optional[Any]       =       tokenizer_r(lowercase    , return_offsets_mapping=lowercase    , add_special_tokens=lowercase    )
															self.assertEqual(encoding.offset_mapping[0]    , (0, 1 + len(lowercase    ))    )
															self.assertEqual(
															    encoding.offset_mapping[1]    , (1 + len(lowercase    ), 1 + len(lowercase    ) + 1 + len(lowercase    ))    , )