

"""simple docstring"""





import json
from typing import TYPE_CHECKING, List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_blenderbot import BlenderbotTokenizer


if TYPE_CHECKING:
   from transformers.pipelines.conversational import Conversation

_a							=							logging.get_logger(__name__)


_a							=							{
    '''vocab_file''': '''vocab.json''',
    '''merges_file''': '''merges.txt''',
    '''tokenizer_config_file''': '''tokenizer_config.json''',
}

_a							=							{
    '''vocab_file''': {'''facebook/blenderbot-3B''': '''https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json'''},
    '''merges_file''': {'''facebook/blenderbot-3B''': '''https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt'''},
    '''tokenizer_config_file''': {
        '''facebook/blenderbot-3B''': '''https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json'''
    },
}

_a							=							{'''facebook/blenderbot-3B''': 1_28}




class  _lowerCAmelCase  (     a__       ):







 """simple docstring"""







 __UpperCAmelCase     : Optional[Any]       		=     VOCAB_FILES_NAMES
 __UpperCAmelCase     : Optional[int]       		=     PRETRAINED_VOCAB_FILES_MAP
 __UpperCAmelCase     : Optional[Any]       		=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 __UpperCAmelCase     : Optional[int]       		=     ['input_ids', 'attention_mask']
 __UpperCAmelCase     : Union[str, Any]       		=     BlenderbotTokenizer


 def __init__(      self							:      List[Any], UpperCAmelCase__							:      Dict=None, UpperCAmelCase__							:      str=None, UpperCAmelCase__							:      int=None, UpperCAmelCase__							:      Union[str, Any]="replace", UpperCAmelCase__							:      int="<s>", UpperCAmelCase__							:      Optional[Any]="</s>", UpperCAmelCase__							:      Optional[int]="</s>", UpperCAmelCase__							:      Any="<s>", UpperCAmelCase__							:      Optional[int]="<unk>", UpperCAmelCase__							:      List[Any]="<pad>", UpperCAmelCase__							:      Dict="<mask>", UpperCAmelCase__							:      Tuple=False, UpperCAmelCase__							:      List[Any]=True, **UpperCAmelCase__							:      Any, ):
    super().__init__(
        _lowerCamelCase, _lowerCamelCase, tokenizer_file=_lowerCamelCase, errors=_lowerCamelCase, bos_token=_lowerCamelCase, eos_token=_lowerCamelCase, sep_token=_lowerCamelCase, cls_token=_lowerCamelCase, unk_token=_lowerCamelCase, pad_token=_lowerCamelCase, mask_token=_lowerCamelCase, add_prefix_space=_lowerCamelCase, trim_offsets=_lowerCamelCase, **_lowerCamelCase, )

    __lowercase								=						json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()     )
    if pre_tok_state.get("add_prefix_space", _lowerCamelCase     ) != add_prefix_space:
       __lowercase								=						getattr(_lowerCamelCase, pre_tok_state.pop("type"     )     )
       __lowercase								=						add_prefix_space
       __lowercase								=						pre_tok_class(**_lowerCamelCase     )

    __lowercase								=						add_prefix_space

    __lowercase								=						'''post_processor'''
    __lowercase								=						getattr(self.backend_tokenizer, _lowerCamelCase, _lowerCamelCase     )
    if tokenizer_component_instance:
       __lowercase								=						json.loads(tokenizer_component_instance.__getstate__()     )

       # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
       if "sep" in state:
          __lowercase								=						tuple(state["sep"]     )
       if "cls" in state:
          __lowercase								=						tuple(state["cls"]     )

       __lowercase								=						False

       if state.get("add_prefix_space", _lowerCamelCase     ) != add_prefix_space:
          __lowercase								=						add_prefix_space
          __lowercase								=						True

       if state.get("trim_offsets", _lowerCamelCase     ) != trim_offsets:
          __lowercase								=						trim_offsets
          __lowercase								=						True

       if changes_to_apply:
          __lowercase								=						getattr(_lowerCamelCase, state.pop("type"     )     )
          __lowercase								=						component_class(**_lowerCamelCase     )
          setattr(self.backend_tokenizer, _lowerCamelCase, _lowerCamelCase     )


 @property
 # Copied from transformers.models.roberta.tokenization_roberta_fast.RobertaTokenizerFast.mask_token with Roberta->Blenderbot, RoBERTa->Blenderbot
 def  _lowercase			(      self							:      int     ):
    if self._mask_token is None:
       if self.verbose:
          logger.error("Using mask_token, but it is not set yet."     )
       return None
    return str(self._mask_token     )


 @mask_token.setter
 def  _lowercase			(      self							:      Optional[int], UpperCAmelCase__							:      Tuple     ):
    __lowercase								=						AddedToken(_lowerCamelCase, lstrip=_lowerCamelCase, rstrip=_lowerCamelCase     ) if isinstance(_lowerCamelCase, _lowerCamelCase     ) else value
    __lowercase								=						value


 def  _lowercase			(      self							:      Optional[int], *UpperCAmelCase__							:      Union[str, Any], **UpperCAmelCase__							:      List[str]     ):
    __lowercase								=						kwargs.get("is_split_into_words", _lowerCamelCase     )
    assert self.add_prefix_space or not is_split_into_words, (
        F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
        "to use it with pretokenized inputs."
    )

    return super()._batch_encode_plus(*_lowerCamelCase, **_lowerCamelCase     )


 def  _lowercase			(      self							:      Any, *UpperCAmelCase__							:      List[Any], **UpperCAmelCase__							:      List[Any]     ):
    __lowercase								=						kwargs.get("is_split_into_words", _lowerCamelCase     )

    assert self.add_prefix_space or not is_split_into_words, (
        F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
        "to use it with pretokenized inputs."
    )

    return super()._encode_plus(*_lowerCamelCase, **_lowerCamelCase     )


 def  _lowercase			(      self							:      str, UpperCAmelCase__							:      Optional[Any], UpperCAmelCase__							:      List[str] = None     ):
    __lowercase								=						self._tokenizer.model.save(_lowerCamelCase, name=_lowerCamelCase     )
    return tuple(_lowerCamelCase     )


 def  _lowercase			(      self							:      List[str], UpperCAmelCase__							:      Union[str, Any], UpperCAmelCase__							:      Union[str, Any] = None     ):
    __lowercase								=						[self.sep_token_id]
    __lowercase								=						[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 + sep + token_ids_a + sep     ) * [0]


 def  _lowercase			(      self							:      Dict, UpperCAmelCase__							:      str, UpperCAmelCase__							:      str = None     ):
    return token_ids_a + [self.eos_token_id]



 def  _lowercase			(      self							:      Tuple, UpperCAmelCase__							:      Optional[Any]     ):
    __lowercase								=						[]
    for is_user, text in conversation.iter_texts():
       if is_user:
          # We need to space prefix as it's being done within blenderbot
          inputs.append(" " + text     )
       else:
          # Generated responses should contain them already.
          inputs.append(_lowerCamelCase     )

    __lowercase								=						'''  '''.join(_lowerCamelCase     )
    __lowercase								=						self.encode(_lowerCamelCase     )
    if len(_lowerCamelCase     ) > self.model_max_length:
       __lowercase								=						input_ids[-self.model_max_length :]
       logger.warning(F"""Trimmed input from conversation as it was longer than {self.model_max_length} tokens."""     )
    return input_ids








"""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__     )




