

"""simple docstring"""





import os
import unicodedata
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import SPIECE_UNDERLINE, logging


_a							=							logging.get_logger(__name__)

_a							=							{'vocab_file': 'spiece.model'}

_a							=							{
    'vocab_file': {
        'xlnet-base-cased': 'https://huggingface.co/xlnet-base-cased/resolve/main/spiece.model',
        'xlnet-large-cased': 'https://huggingface.co/xlnet-large-cased/resolve/main/spiece.model',
    }
}

_a							=							{
    'xlnet-base-cased': None,
    'xlnet-large-cased': None,
}

# Segments (not really needed)
_a							=							0
_a							=							1
_a							=							2
_a							=							3
_a							=							4




class  _lowerCAmelCase  (     lowercase       ):







 """simple docstring"""







 __UpperCAmelCase     : int       		=     VOCAB_FILES_NAMES
 __UpperCAmelCase     : List[Any]       		=     PRETRAINED_VOCAB_FILES_MAP
 __UpperCAmelCase     : List[str]       		=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 __UpperCAmelCase     : Optional[int]       		=     "left"


 def __init__(      self							:      Any, UpperCAmelCase__							:      Any, UpperCAmelCase__							:      List[str]=False, UpperCAmelCase__							:      Tuple=True, UpperCAmelCase__							:      Optional[int]=False, UpperCAmelCase__							:      str="<s>", UpperCAmelCase__							:      Any="</s>", UpperCAmelCase__							:      Union[str, Any]="<unk>", UpperCAmelCase__							:      str="<sep>", UpperCAmelCase__							:      Any="<pad>", UpperCAmelCase__							:      int="<cls>", UpperCAmelCase__							:      Optional[int]="<mask>", UpperCAmelCase__							:      Optional[int]=["<eop>", "<eod>"], UpperCAmelCase__							:      Optional[Dict[str, Any]] = None, **UpperCAmelCase__							:      List[str], ):
    # Mask token behave like a normal word, i.e. include the space before it
    __lowercase								=						AddedToken(UpperCAmelCase__, lstrip=UpperCAmelCase__, rstrip=UpperCAmelCase__     ) if isinstance(UpperCAmelCase__, UpperCAmelCase__     ) else mask_token

    __lowercase								=						{} if sp_model_kwargs is None else sp_model_kwargs

    super().__init__(
        do_lower_case=UpperCAmelCase__, remove_space=UpperCAmelCase__, keep_accents=UpperCAmelCase__, bos_token=UpperCAmelCase__, eos_token=UpperCAmelCase__, unk_token=UpperCAmelCase__, sep_token=UpperCAmelCase__, pad_token=UpperCAmelCase__, cls_token=UpperCAmelCase__, mask_token=UpperCAmelCase__, additional_special_tokens=UpperCAmelCase__, sp_model_kwargs=self.sp_model_kwargs, **UpperCAmelCase__, )

    __lowercase								=						3

    __lowercase								=						do_lower_case
    __lowercase								=						remove_space
    __lowercase								=						keep_accents
    __lowercase								=						vocab_file

    __lowercase								=						spm.SentencePieceProcessor(**self.sp_model_kwargs     )
    self.sp_model.Load(UpperCAmelCase__     )


 @property
 def  _lowercase			(      self							:      Union[str, Any]     ):
    return len(self.sp_model     )


 def  _lowercase			(      self							:      int     ):
    __lowercase								=						{self.convert_ids_to_tokens(UpperCAmelCase__     ): i for i in range(self.vocab_size     )}
    vocab.update(self.added_tokens_encoder     )
    return vocab


 def __getstate__(      self							:      List[Any]     ):
    __lowercase								=						self.__dict__.copy()
    __lowercase								=						None
    return state


 def __setstate__(      self							:      Optional[int], UpperCAmelCase__							:      Tuple     ):
    __lowercase								=						d

    # for backward compatibility
    if not hasattr(self, "sp_model_kwargs"     ):
       __lowercase								=						{}

    __lowercase								=						spm.SentencePieceProcessor(**self.sp_model_kwargs     )
    self.sp_model.Load(self.vocab_file     )


 def  _lowercase			(      self							:      Any, UpperCAmelCase__							:      int     ):
    if self.remove_space:
       __lowercase								=						" ".join(inputs.strip().split()     )
    else:
       __lowercase								=						inputs
    __lowercase								=						outputs.replace("``", "\""     ).replace("''", "\""     )

    if not self.keep_accents:
       __lowercase								=						unicodedata.normalize("NFKD", UpperCAmelCase__     )
       __lowercase								=						"".join([c for c in outputs if not unicodedata.combining(UpperCAmelCase__     )]     )
    if self.do_lower_case:
       __lowercase								=						outputs.lower()

    return outputs


 def  _lowercase			(      self							:      Union[str, Any], UpperCAmelCase__							:      str     ):
    __lowercase								=						self.preprocess_text(UpperCAmelCase__     )
    __lowercase								=						self.sp_model.encode(UpperCAmelCase__, out_type=UpperCAmelCase__     )
    __lowercase								=						[]
    for piece in pieces:
       if len(UpperCAmelCase__     ) > 1 and piece[-1] == str(","     ) and piece[-2].isdigit():
          __lowercase								=						self.sp_model.EncodeAsPieces(piece[:-1].replace(UpperCAmelCase__, ""     )     )
          if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
             if len(cur_pieces[0]     ) == 1:
                __lowercase								=						cur_pieces[1:]
             else:
                __lowercase								=						cur_pieces[0][1:]
          cur_pieces.append(piece[-1]     )
          new_pieces.extend(UpperCAmelCase__     )
       else:
          new_pieces.append(UpperCAmelCase__     )

    return new_pieces


 def  _lowercase			(      self							:      Any, UpperCAmelCase__							:      Optional[int]     ):
    return self.sp_model.PieceToId(UpperCAmelCase__     )


 def  _lowercase			(      self							:      Union[str, Any], UpperCAmelCase__							:      Tuple     ):
    return self.sp_model.IdToPiece(UpperCAmelCase__     )


 def  _lowercase			(      self							:      Dict, UpperCAmelCase__							:      List[str]     ):
    __lowercase								=						"".join(UpperCAmelCase__     ).replace(UpperCAmelCase__, " "     ).strip()
    return out_string


 def  _lowercase			(      self							:      List[str], UpperCAmelCase__							:      List[int], UpperCAmelCase__							:      bool = False, UpperCAmelCase__							:      bool = None, UpperCAmelCase__							:      bool = True, **UpperCAmelCase__							:      Union[str, Any], ):
    __lowercase								=						kwargs.pop("use_source_tokenizer", UpperCAmelCase__     )

    __lowercase								=						self.convert_ids_to_tokens(UpperCAmelCase__, skip_special_tokens=UpperCAmelCase__     )

    # To avoid mixing byte-level and unicode for byte-level BPT
    # we need to build string separately for added tokens and byte-level tokens
    # cf. https://github.com/huggingface/transformers/issues/1133
    __lowercase								=						[]
    __lowercase								=						[]
    for token in filtered_tokens:
       if skip_special_tokens and token in self.all_special_ids:
          continue
       if token in self.added_tokens_encoder:
          if current_sub_text:
             sub_texts.append(self.convert_tokens_to_string(UpperCAmelCase__     )     )
             __lowercase								=						[]
          sub_texts.append(UpperCAmelCase__     )
       else:
          current_sub_text.append(UpperCAmelCase__     )
    if current_sub_text:
       sub_texts.append(self.convert_tokens_to_string(UpperCAmelCase__     )     )

    # Mimic the behavior of the Rust tokenizer:
    # By default, there are no spaces between special tokens
    __lowercase								=						"".join(UpperCAmelCase__     )

    __lowercase								=						(
        clean_up_tokenization_spaces
        if clean_up_tokenization_spaces is not None
        else self.clean_up_tokenization_spaces
    )
    if clean_up_tokenization_spaces:
       __lowercase								=						self.clean_up_tokenization(UpperCAmelCase__     )
       return clean_text
    else:
       return text


 def  _lowercase			(      self							:      Dict, UpperCAmelCase__							:      List[int], UpperCAmelCase__							:      Optional[List[int]] = None     ):
    __lowercase								=						[self.sep_token_id]
    __lowercase								=						[self.cls_token_id]
    if token_ids_a is None:
       return token_ids_a + sep + cls
    return token_ids_a + sep + token_ids_a + sep + cls


 def  _lowercase			(      self							:      Any, UpperCAmelCase__							:      List[int], UpperCAmelCase__							:      Optional[List[int]] = None, UpperCAmelCase__							:      bool = False     ):

    if already_has_special_tokens:
       return super().get_special_tokens_mask(
           token_ids_a=UpperCAmelCase__, token_ids_a=UpperCAmelCase__, already_has_special_tokens=UpperCAmelCase__     )

    if token_ids_a is not None:
       return ([0] * len(UpperCAmelCase__     )) + [1] + ([0] * len(UpperCAmelCase__     )) + [1, 1]
    return ([0] * len(UpperCAmelCase__     )) + [1, 1]


 def  _lowercase			(      self							:      int, UpperCAmelCase__							:      List[int], UpperCAmelCase__							:      Optional[List[int]] = None     ):
    __lowercase								=						[self.sep_token_id]
    __lowercase								=						[2]

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



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

    if os.path.abspath(self.vocab_file     ) != os.path.abspath(UpperCAmelCase__     ) and os.path.isfile(self.vocab_file     ):
       copyfile(self.vocab_file, UpperCAmelCase__     )
    elif not os.path.isfile(self.vocab_file     ):
       with open(UpperCAmelCase__, "wb"     ) as fi:
          __lowercase								=						self.sp_model.serialized_model_proto()
          fi.write(UpperCAmelCase__     )

    return (out_vocab_file,)








"""simple docstring"""





from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
)




@flax.struct.dataclass
class  _lowerCAmelCase  (     lowercase       ):







 """simple docstring"""







 __UpperCAmelCase     : jnp.ndarray
 __UpperCAmelCase     : jnp.ndarray







class  _lowerCAmelCase  (     nn.Module       ):







 """simple docstring"""







 __UpperCAmelCase     : int
 __UpperCAmelCase     : Tuple[int]       		=     (1_6, 3_2, 9_6, 2_5_6)
 __UpperCAmelCase     : jnp.dtype       		=     jnp.floataa


 def  _lowercase			(      self							:      Union[str, Any]     ):
    __lowercase								=						nn.Conv(
        self.block_out_channels[0], kernel_size=(3, 3), padding=((1, 1), (1, 1)), dtype=self.dtype, )

    __lowercase								=						[]
    for i in range(len(self.block_out_channels     ) - 1     ):
       __lowercase								=						self.block_out_channels[i]
       __lowercase								=						self.block_out_channels[i + 1]
       __lowercase								=						nn.Conv(
           UpperCAmelCase__, kernel_size=(3, 3), padding=((1, 1), (1, 1)), dtype=self.dtype, )
       blocks.append(UpperCAmelCase__     )
       __lowercase								=						nn.Conv(
           UpperCAmelCase__, kernel_size=(3, 3), strides=(2, 2), padding=((1, 1), (1, 1)), dtype=self.dtype, )
       blocks.append(UpperCAmelCase__     )
    __lowercase								=						blocks

    __lowercase								=						nn.Conv(
        self.conditioning_embedding_channels, kernel_size=(3, 3), padding=((1, 1), (1, 1)), kernel_init=nn.initializers.zeros_init(), bias_init=nn.initializers.zeros_init(), dtype=self.dtype, )



 def __call__(      self							:      Any, UpperCAmelCase__							:      Union[str, Any]     ):
    __lowercase								=						self.conv_in(UpperCAmelCase__     )
    __lowercase								=						nn.silu(UpperCAmelCase__     )

    for block in self.blocks:
       __lowercase								=						block(UpperCAmelCase__     )
       __lowercase								=						nn.silu(UpperCAmelCase__     )

    __lowercase								=						self.conv_out(UpperCAmelCase__     )

    return embedding







@flax_register_to_config
class  _lowerCAmelCase  (     nn.Module					,lowercase					,lowercase       ):







 """simple docstring"""







 __UpperCAmelCase     : int       		=     3_2
 __UpperCAmelCase     : int       		=     4
 __UpperCAmelCase     : Tuple[str]       		=     (
     "CrossAttnDownBlock2D",
     "CrossAttnDownBlock2D",
     "CrossAttnDownBlock2D",
     "DownBlock2D",
 )
 __UpperCAmelCase     : Union[bool, Tuple[bool]]       		=     False
 __UpperCAmelCase     : Tuple[int]       		=     (3_2_0, 6_4_0, 1_2_8_0, 1_2_8_0)
 __UpperCAmelCase     : int       		=     2
 __UpperCAmelCase     : Union[int, Tuple[int]]       		=     8
 __UpperCAmelCase     : Optional[Union[int, Tuple[int]]]       		=     None
 __UpperCAmelCase     : int       		=     1_2_8_0
 __UpperCAmelCase     : float       		=     0.0
 __UpperCAmelCase     : bool       		=     False
 __UpperCAmelCase     : jnp.dtype       		=     jnp.floataa
 __UpperCAmelCase     : bool       		=     True
 __UpperCAmelCase     : int       		=     0
 __UpperCAmelCase     : str       		=     "rgb"
 __UpperCAmelCase     : Tuple[int]       		=     (1_6, 3_2, 9_6, 2_5_6)


 def  _lowercase			(      self							:      List[Any], UpperCAmelCase__							:      jax.random.KeyArray     ):
    # init input tensors
    __lowercase								=						(1, self.in_channels, self.sample_size, self.sample_size)
    __lowercase								=						jnp.zeros(UpperCAmelCase__, dtype=jnp.floataa     )
    __lowercase								=						jnp.ones((1,), dtype=jnp.intaa     )
    __lowercase								=						jnp.zeros((1, 1, self.cross_attention_dim), dtype=jnp.floataa     )
    __lowercase								=						(1, 3, self.sample_size * 8, self.sample_size * 8)
    __lowercase								=						jnp.zeros(UpperCAmelCase__, dtype=jnp.floataa     )

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

    return self.init(UpperCAmelCase__, UpperCAmelCase__, UpperCAmelCase__, UpperCAmelCase__, UpperCAmelCase__     )["params"]


 def  _lowercase			(      self							:      Union[str, Any]     ):
    __lowercase								=						self.block_out_channels
    __lowercase								=						block_out_channels[0] * 4

    # If `num_attention_heads` is not defined (which is the case for most models)
    # it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
    # The reason for this behavior is to correct for incorrectly named variables that were introduced
    # when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
    # Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
    # which is why we correct for the naming here.
    __lowercase								=						self.num_attention_heads or self.attention_head_dim

    # input
    __lowercase								=						nn.Conv(
        block_out_channels[0], kernel_size=(3, 3), strides=(1, 1), padding=((1, 1), (1, 1)), dtype=self.dtype, )

    # time
    __lowercase								=						FlaxTimesteps(
        block_out_channels[0], flip_sin_to_cos=self.flip_sin_to_cos, freq_shift=self.config.freq_shift     )
    __lowercase								=						FlaxTimestepEmbedding(UpperCAmelCase__, dtype=self.dtype     )

    __lowercase								=						FlaxControlNetConditioningEmbedding(
        conditioning_embedding_channels=block_out_channels[0], block_out_channels=self.conditioning_embedding_out_channels, )

    __lowercase								=						self.only_cross_attention
    if isinstance(UpperCAmelCase__, UpperCAmelCase__     ):
       __lowercase								=						(only_cross_attention,) * len(self.down_block_types     )

    if isinstance(UpperCAmelCase__, UpperCAmelCase__     ):
       __lowercase								=						(num_attention_heads,) * len(self.down_block_types     )

    # down
    __lowercase								=						[]
    __lowercase								=						[]

    __lowercase								=						block_out_channels[0]

    __lowercase								=						nn.Conv(
        UpperCAmelCase__, kernel_size=(1, 1), padding="VALID", kernel_init=nn.initializers.zeros_init(), bias_init=nn.initializers.zeros_init(), dtype=self.dtype, )
    controlnet_down_blocks.append(UpperCAmelCase__     )

    for i, down_block_type in enumerate(self.down_block_types     ):
       __lowercase								=						output_channel
       __lowercase								=						block_out_channels[i]
       __lowercase								=						i == len(UpperCAmelCase__     ) - 1

       if down_block_type == "CrossAttnDownBlock2D":
          __lowercase								=						FlaxCrossAttnDownBlockaD(
              in_channels=UpperCAmelCase__, out_channels=UpperCAmelCase__, dropout=self.dropout, num_layers=self.layers_per_block, num_attention_heads=num_attention_heads[i], add_downsample=not is_final_block, use_linear_projection=self.use_linear_projection, only_cross_attention=only_cross_attention[i], dtype=self.dtype, )
       else:
          __lowercase								=						FlaxDownBlockaD(
              in_channels=UpperCAmelCase__, out_channels=UpperCAmelCase__, dropout=self.dropout, num_layers=self.layers_per_block, add_downsample=not is_final_block, dtype=self.dtype, )

       down_blocks.append(UpperCAmelCase__     )

       for _ in range(self.layers_per_block     ):
          __lowercase								=						nn.Conv(
              UpperCAmelCase__, kernel_size=(1, 1), padding="VALID", kernel_init=nn.initializers.zeros_init(), bias_init=nn.initializers.zeros_init(), dtype=self.dtype, )
          controlnet_down_blocks.append(UpperCAmelCase__     )

       if not is_final_block:
          __lowercase								=						nn.Conv(
              UpperCAmelCase__, kernel_size=(1, 1), padding="VALID", kernel_init=nn.initializers.zeros_init(), bias_init=nn.initializers.zeros_init(), dtype=self.dtype, )
          controlnet_down_blocks.append(UpperCAmelCase__     )

    __lowercase								=						down_blocks
    __lowercase								=						controlnet_down_blocks

    # mid
    __lowercase								=						block_out_channels[-1]
    __lowercase								=						FlaxUNetMidBlockaDCrossAttn(
        in_channels=UpperCAmelCase__, dropout=self.dropout, num_attention_heads=num_attention_heads[-1], use_linear_projection=self.use_linear_projection, dtype=self.dtype, )

    __lowercase								=						nn.Conv(
        UpperCAmelCase__, kernel_size=(1, 1), padding="VALID", kernel_init=nn.initializers.zeros_init(), bias_init=nn.initializers.zeros_init(), dtype=self.dtype, )



 def __call__(      self							:      str, UpperCAmelCase__							:      Union[str, Any], UpperCAmelCase__							:      List[Any], UpperCAmelCase__							:      Tuple, UpperCAmelCase__							:      List[str], UpperCAmelCase__							:      float = 1.0, UpperCAmelCase__							:      bool = True, UpperCAmelCase__							:      bool = False, ):
    __lowercase								=						self.controlnet_conditioning_channel_order
    if channel_order == "bgr":
       __lowercase								=						jnp.flip(UpperCAmelCase__, axis=1     )

    # 1. time
    if not isinstance(UpperCAmelCase__, jnp.ndarray     ):
       __lowercase								=						jnp.array([timesteps], dtype=jnp.intaa     )
    elif isinstance(UpperCAmelCase__, jnp.ndarray     ) and len(timesteps.shape     ) == 0:
       __lowercase								=						timesteps.astype(dtype=jnp.floataa     )
       __lowercase								=						jnp.expand_dims(UpperCAmelCase__, 0     )

    __lowercase								=						self.time_proj(UpperCAmelCase__     )
    __lowercase								=						self.time_embedding(UpperCAmelCase__     )

    # 2. pre-process
    __lowercase								=						jnp.transpose(UpperCAmelCase__, (0, 2, 3, 1)     )
    __lowercase								=						self.conv_in(UpperCAmelCase__     )

    __lowercase								=						jnp.transpose(UpperCAmelCase__, (0, 2, 3, 1)     )
    __lowercase								=						self.controlnet_cond_embedding(UpperCAmelCase__     )
    sample += controlnet_cond

    # 3. down
    __lowercase								=						(sample,)
    for down_block in self.down_blocks:
       if isinstance(UpperCAmelCase__, UpperCAmelCase__     ):
          __lowercase		,__lowercase								=						down_block(UpperCAmelCase__, UpperCAmelCase__, UpperCAmelCase__, deterministic=not train     )
       else:
          __lowercase		,__lowercase								=						down_block(UpperCAmelCase__, UpperCAmelCase__, deterministic=not train     )
       down_block_res_samples += res_samples

    # 4. mid
    __lowercase								=						self.mid_block(UpperCAmelCase__, UpperCAmelCase__, UpperCAmelCase__, deterministic=not train     )

    # 5. contronet blocks
    __lowercase								=						()
    for down_block_res_sample, controlnet_block in zip(UpperCAmelCase__, self.controlnet_down_blocks     ):
       __lowercase								=						controlnet_block(UpperCAmelCase__     )
       controlnet_down_block_res_samples += (down_block_res_sample,)

    __lowercase								=						controlnet_down_block_res_samples

    __lowercase								=						self.controlnet_mid_block(UpperCAmelCase__     )

    # 6. scaling
    __lowercase								=						[sample * conditioning_scale for sample in down_block_res_samples]
    mid_block_res_sample *= conditioning_scale

    if not return_dict:
       return (down_block_res_samples, mid_block_res_sample)

    return FlaxControlNetOutput(
        down_block_res_samples=UpperCAmelCase__, mid_block_res_sample=UpperCAmelCase__     )




