




"""simple docstring"""


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

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


A_      =    logging.get_logger(__name__)

A_      =    '''▁'''

A_      =    {'''vocab_file''': '''sentencepiece.bpe.model'''}

A_      =    {
    '''vocab_file''': {
        '''facebook/xglm-564M''': '''https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model''',
    }
}

A_      =    {
    '''facebook/xglm-564M''': 20_48,
}






class  lowercase(					__a			):







 '''simple docstring'''





 lowercase__			 = VOCAB_FILES_NAMES
 lowercase__			 = PRETRAINED_VOCAB_FILES_MAP
 lowercase__			 = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 lowercase__			 = ["input_ids", "attention_mask"]


 def __init__(    self:		List[str],				a_:		Any,				a_:		Union[str, Any]="<s>",				a_:		int="</s>",				a_:		Optional[Any]="</s>",				a_:		str="<s>",				a_:		Union[str, Any]="<unk>",				a_:		Optional[Any]="<pad>",				a_:		Optional[Dict[str, Any]] = None,				**a_:		Any,				):




   '''simple docstring'''



   _snake_case							:		Optional[int]								=  {} if sp_model_kwargs is None else sp_model_kwargs

   # Compatibility with the original tokenizer
   _snake_case							:		Optional[Any]								=  7
   _snake_case							:		Union[str, Any]								=  [f"<madeupword{i}>" for i in range(self.num_madeup_words		)]

   _snake_case							:		Dict								=  kwargs.get("""additional_special_tokens""",				[]		)
   kwargs["additional_special_tokens"] += [
       word for word in madeup_words if word not in kwargs["additional_special_tokens"]
   ]

   super().__init__(
       bos_token=a_,				eos_token=a_,				unk_token=a_,				sep_token=a_,				cls_token=a_,				pad_token=a_,				sp_model_kwargs=self.sp_model_kwargs,				**a_,				)

   _snake_case							:		Tuple								=  spm.SentencePieceProcessor(**self.sp_model_kwargs		)
   self.sp_model.Load(str(a_		)		)
   _snake_case							:		int								=  vocab_file

   # Original fairseq vocab and spm vocab must be "aligned":
   # Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
   # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
   # fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
   # spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

   # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
   _snake_case							:		Any								=  1

   # Mimic fairseq token-to-id alignment for the first 4 token
   _snake_case							:		Optional[Any]								=  {"""<s>""": 0, """<pad>""": 1, """</s>""": 2, """<unk>""": 3}

   _snake_case							:		Optional[int]								=  len(self.sp_model		)
   _snake_case							:		Dict								=  {f"<madeupword{i}>": sp_size + i + self.fairseq_offset for i in range(self.num_madeup_words		)}
   self.fairseq_tokens_to_ids.update(a_		)

   _snake_case							:		Dict								=  {v: k for k, v in self.fairseq_tokens_to_ids.items()}


 def __getstate__(    self:		Optional[int]		):




   '''simple docstring'''



   _snake_case							:		Union[str, Any]								=  self.__dict__.copy()
   _snake_case							:		List[str]								=  None
   _snake_case							:		List[Any]								=  self.sp_model.serialized_model_proto()
   return state


 def __setstate__(    self:		Any,				a_:		str		):




   '''simple docstring'''



   _snake_case							:		Optional[int]								=  d

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

   _snake_case							:		str								=  spm.SentencePieceProcessor(**self.sp_model_kwargs		)
   self.sp_model.LoadFromSerializedProto(self.sp_model_proto		)


 def 			UpperCamelCase_       (    self:		Optional[int],				a_:		List[int],				a_:		Optional[List[int]] = None		):




   '''simple docstring'''



   if token_ids_a is None:
     return [self.sep_token_id] + token_ids_a
   _snake_case							:		Any								=  [self.sep_token_id]
   return sep + token_ids_a + sep + sep + token_ids_a


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




   '''simple docstring'''



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

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


 def 			UpperCamelCase_       (    self:		Tuple,				a_:		List[int],				a_:		Optional[List[int]] = None		):




   '''simple docstring'''



   _snake_case							:		Union[str, Any]								=  [self.sep_token_id]

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


 @property
 def 			UpperCamelCase_       (    self:		Union[str, Any]		):




   '''simple docstring'''



   return len(self.sp_model		) + self.fairseq_offset + self.num_madeup_words


 def 			UpperCamelCase_       (    self:		Optional[int]		):




   '''simple docstring'''



   _snake_case							:		Optional[Any]								=  {self.convert_ids_to_tokens(a_		): i for i in range(self.vocab_size		)}
   vocab.update(self.added_tokens_encoder		)
   return vocab


 def 			UpperCamelCase_       (    self:		Union[str, Any],				a_:		str		):




   '''simple docstring'''



   return self.sp_model.encode(a_,				out_type=a_		)


 def 			UpperCamelCase_       (    self:		Any,				a_:		Union[str, Any]		):




   '''simple docstring'''



   if token in self.fairseq_tokens_to_ids:
     return self.fairseq_tokens_to_ids[token]
   _snake_case							:		int								=  self.sp_model.PieceToId(a_		)

   # Need to return unknown token if the SP model returned 0
   return spm_id + self.fairseq_offset if spm_id else self.unk_token_id


 def 			UpperCamelCase_       (    self:		Optional[Any],				a_:		Dict		):




   '''simple docstring'''



   if index in self.fairseq_ids_to_tokens:
     return self.fairseq_ids_to_tokens[index]
   return self.sp_model.IdToPiece(index - self.fairseq_offset		)


 def 			UpperCamelCase_       (    self:		List[str],				a_:		str		):




   '''simple docstring'''



   _snake_case							:		Any								=  """""".join(a_		).replace(a_,				""" """		).strip()
   return out_string


 def 			UpperCamelCase_       (    self:		Dict,				a_:		str,				a_:		Optional[str] = None		):




   '''simple docstring'''



   if not os.path.isdir(a_		):
     logger.error(f"Vocabulary path ({save_directory}) should be a directory"		)
     return
   _snake_case							:		Tuple								=  os.path.join(
       a_,				(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]		)

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

   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  lowercase(					__a			):







 '''simple docstring'''





 lowercase__			 = 42
 lowercase__			 = 42







class  lowercase(					nn.Module			):







 '''simple docstring'''





 lowercase__			 = 42
 lowercase__			 = (16, 32, 96, 2_56)
 lowercase__			 = jnp.floataa


 def 			UpperCamelCase_       (    self:		Optional[int]		):




   '''simple docstring'''



   _snake_case							:		List[str]								=  nn.Conv(
       self.block_out_channels[0],				kernel_size=(3, 3),				padding=((1, 1), (1, 1)),				dtype=self.dtype,				)

   _snake_case							:		int								=  []
   for i in range(len(self.block_out_channels		) - 1		):
     _snake_case							:		int								=  self.block_out_channels[i]
     _snake_case							:		Tuple								=  self.block_out_channels[i + 1]
     _snake_case							:		Dict								=  nn.Conv(
         a_,				kernel_size=(3, 3),				padding=((1, 1), (1, 1)),				dtype=self.dtype,				)
     blocks.append(a_		)
     _snake_case							:		List[Any]								=  nn.Conv(
         a_,				kernel_size=(3, 3),				strides=(2, 2),				padding=((1, 1), (1, 1)),				dtype=self.dtype,				)
     blocks.append(a_		)
   _snake_case							:		Any								=  blocks

   _snake_case							:		Optional[Any]								=  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:		Optional[Any],				a_:		Optional[Any]		):




   '''simple docstring'''



   _snake_case							:		int								=  self.conv_in(a_		)
   _snake_case							:		Optional[int]								=  nn.silu(a_		)

   for block in self.blocks:
     _snake_case							:		Tuple								=  block(a_		)
     _snake_case							:		int								=  nn.silu(a_		)

   _snake_case							:		Optional[int]								=  self.conv_out(a_		)

   return embedding







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







 '''simple docstring'''





 lowercase__			 = 32
 lowercase__			 = 4
 lowercase__			 = (
     "CrossAttnDownBlock2D",
     "CrossAttnDownBlock2D",
     "CrossAttnDownBlock2D",
     "DownBlock2D",
 )
 lowercase__			 = False
 lowercase__			 = (3_20, 6_40, 12_80, 12_80)
 lowercase__			 = 2
 lowercase__			 = 8
 lowercase__			 = None
 lowercase__			 = 12_80
 lowercase__			 = 0.0
 lowercase__			 = False
 lowercase__			 = jnp.floataa
 lowercase__			 = True
 lowercase__			 = 0
 lowercase__			 = "rgb"
 lowercase__			 = (16, 32, 96, 2_56)


 def 			UpperCamelCase_       (    self:		int,				a_:		jax.random.KeyArray		):




   '''simple docstring'''



   _snake_case							:		str								=  (1, self.in_channels, self.sample_size, self.sample_size)
   _snake_case							:		Optional[Any]								=  jnp.zeros(a_,				dtype=jnp.floataa		)
   _snake_case							:		List[str]								=  jnp.ones((1,),				dtype=jnp.intaa		)
   _snake_case							:		List[Any]								=  jnp.zeros((1, 1, self.cross_attention_dim),				dtype=jnp.floataa		)
   _snake_case							:		Any								=  (1, 3, self.sample_size * 8, self.sample_size * 8)
   _snake_case							:		Optional[int]								=  jnp.zeros(a_,				dtype=jnp.floataa		)

   _snake_case		, _snake_case							:		Tuple								=  jax.random.split(a_		)
   _snake_case							:		str								=  {"""params""": params_rng, """dropout""": dropout_rng}

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


 def 			UpperCamelCase_       (    self:		Any		):




   '''simple docstring'''



   _snake_case							:		Optional[int]								=  self.block_out_channels
   _snake_case							:		Optional[int]								=  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.
   _snake_case							:		int								=  self.num_attention_heads or self.attention_head_dim

   # input
   _snake_case							:		Union[str, Any]								=  nn.Conv(
       block_out_channels[0],				kernel_size=(3, 3),				strides=(1, 1),				padding=((1, 1), (1, 1)),				dtype=self.dtype,				)

   # time
   _snake_case							:		int								=  FlaxTimesteps(
       block_out_channels[0],				flip_sin_to_cos=self.flip_sin_to_cos,				freq_shift=self.config.freq_shift		)
   _snake_case							:		Any								=  FlaxTimestepEmbedding(a_,				dtype=self.dtype		)

   _snake_case							:		Optional[Any]								=  FlaxControlNetConditioningEmbedding(
       conditioning_embedding_channels=block_out_channels[0],				block_out_channels=self.conditioning_embedding_out_channels,				)

   _snake_case							:		List[str]								=  self.only_cross_attention
   if isinstance(a_,				a_		):
     _snake_case							:		List[Any]								=  (only_cross_attention,) * len(self.down_block_types		)

   if isinstance(a_,				a_		):
     _snake_case							:		Optional[Any]								=  (num_attention_heads,) * len(self.down_block_types		)

   # down
   _snake_case							:		List[str]								=  []
   _snake_case							:		Tuple								=  []

   _snake_case							:		int								=  block_out_channels[0]

   _snake_case							:		Optional[Any]								=  nn.Conv(
       a_,				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(a_		)

   for i, down_block_type in enumerate(self.down_block_types		):
     _snake_case							:		List[Any]								=  output_channel
     _snake_case							:		Any								=  block_out_channels[i]
     _snake_case							:		List[str]								=  i == len(a_		) - 1

     if down_block_type == "CrossAttnDownBlock2D":
       _snake_case							:		Optional[int]								=  FlaxCrossAttnDownBlockaD(
           in_channels=a_,				out_channels=a_,				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:
       _snake_case							:		List[Any]								=  FlaxDownBlockaD(
           in_channels=a_,				out_channels=a_,				dropout=self.dropout,				num_layers=self.layers_per_block,				add_downsample=not is_final_block,				dtype=self.dtype,				)

     down_blocks.append(a_		)

     for _ in range(self.layers_per_block		):
       _snake_case							:		List[Any]								=  nn.Conv(
           a_,				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(a_		)

     if not is_final_block:
       _snake_case							:		List[Any]								=  nn.Conv(
           a_,				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(a_		)

   _snake_case							:		str								=  down_blocks
   _snake_case							:		Union[str, Any]								=  controlnet_down_blocks

   # mid
   _snake_case							:		Tuple								=  block_out_channels[-1]
   _snake_case							:		Optional[int]								=  FlaxUNetMidBlockaDCrossAttn(
       in_channels=a_,				dropout=self.dropout,				num_attention_heads=num_attention_heads[-1],				use_linear_projection=self.use_linear_projection,				dtype=self.dtype,				)

   _snake_case							:		Tuple								=  nn.Conv(
       a_,				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,				a_:		Any,				a_:		Tuple,				a_:		Any,				a_:		int,				a_:		float = 1.0,				a_:		bool = True,				a_:		bool = False,				):




   '''simple docstring'''



   _snake_case							:		Dict								=  self.controlnet_conditioning_channel_order
   if channel_order == "bgr":
     _snake_case							:		List[Any]								=  jnp.flip(a_,				axis=1		)

   # 1. time
   if not isinstance(a_,				jnp.ndarray		):
     _snake_case							:		Any								=  jnp.array([timesteps],				dtype=jnp.intaa		)
   elif isinstance(a_,				jnp.ndarray		) and len(timesteps.shape		) == 0:
     _snake_case							:		Union[str, Any]								=  timesteps.astype(dtype=jnp.floataa		)
     _snake_case							:		List[str]								=  jnp.expand_dims(a_,				0		)

   _snake_case							:		List[str]								=  self.time_proj(a_		)
   _snake_case							:		str								=  self.time_embedding(a_		)

   # 2. pre-process
   _snake_case							:		List[str]								=  jnp.transpose(a_,				(0, 2, 3, 1)		)
   _snake_case							:		List[Any]								=  self.conv_in(a_		)

   _snake_case							:		Union[str, Any]								=  jnp.transpose(a_,				(0, 2, 3, 1)		)
   _snake_case							:		Any								=  self.controlnet_cond_embedding(a_		)
   sample += controlnet_cond

   # 3. down
   _snake_case							:		List[str]								=  (sample,)
   for down_block in self.down_blocks:
     if isinstance(a_,				a_		):
       _snake_case		, _snake_case							:		Optional[Any]								=  down_block(a_,				a_,				a_,				deterministic=not train		)
     else:
       _snake_case		, _snake_case							:		Dict								=  down_block(a_,				a_,				deterministic=not train		)
     down_block_res_samples += res_samples

   # 4. mid
   _snake_case							:		Dict								=  self.mid_block(a_,				a_,				a_,				deterministic=not train		)

   # 5. contronet blocks
   _snake_case							:		Tuple								=  ()
   for down_block_res_sample, controlnet_block in zip(a_,				self.controlnet_down_blocks		):
     _snake_case							:		Any								=  controlnet_block(a_		)
     controlnet_down_block_res_samples += (down_block_res_sample,)

   _snake_case							:		List[Any]								=  controlnet_down_block_res_samples

   _snake_case							:		int								=  self.controlnet_mid_block(a_		)

   # 6. scaling
   _snake_case							:		int								=  [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=a_,				mid_block_res_sample=a_		)


