



'''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,
    FlaxCrossAttnUpBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
    FlaxUpBlockaD,
)


@flax.struct.dataclass
class 	a__     (				_lowercase	):
	__magic_name__		:    jnp.ndarray



@flax_register_to_config
class 	a__     (				nn.Module,			_lowercase,			_lowercase	):
	__magic_name__		:    int	    =     32
	__magic_name__		:    int	    =     4
	__magic_name__		:    int	    =     4
	__magic_name__		:    Tuple[str]	    =     (
	    "CrossAttnDownBlock2D",
	    "CrossAttnDownBlock2D",
	    "CrossAttnDownBlock2D",
	    "DownBlock2D",
	)
	__magic_name__		:    Tuple[str]	    =     ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")
	__magic_name__		:    Union[bool, Tuple[bool]]	    =     False
	__magic_name__		:    Tuple[int]	    =     (3_20, 6_40, 12_80, 12_80)
	__magic_name__		:    int	    =     2
	__magic_name__		:    Union[int, Tuple[int]]	    =     8
	__magic_name__		:    Optional[Union[int, Tuple[int]]]	    =     None
	__magic_name__		:    int	    =     12_80
	__magic_name__		:    float	    =     0.0
	__magic_name__		:    bool	    =     False
	__magic_name__		:    jnp.dtype	    =     jnp.floataa
	__magic_name__		:    bool	    =     True
	__magic_name__		:    int	    =     0
	__magic_name__		:    bool	    =     False


	def 				lowercase__  (self : Tuple,					__UpperCAmelCase : jax.random.KeyArray      )     ->			FrozenDict:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						Any      					= (1, self.in_channels, self.sample_size, self.sample_size)
					SCREAMING_SNAKE_CASE  :						List[str]      					= jnp.zeros(__UpperCAmelCase,					dtype=jnp.floataa      )
					SCREAMING_SNAKE_CASE  :						str      					= jnp.ones((1,),					dtype=jnp.intaa      )
					SCREAMING_SNAKE_CASE  :						List[str]      					= jnp.zeros((1, 1, self.cross_attention_dim),					dtype=jnp.floataa      )

					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= jax.random.split(__UpperCAmelCase      )
					SCREAMING_SNAKE_CASE  :						Tuple      					= {'''params''': params_rng, '''dropout''': dropout_rng}

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


	def 				lowercase__  (self : int      )     ->			Union[str, Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						int      					= self.block_out_channels
					SCREAMING_SNAKE_CASE  :						List[str]      					= block_out_channels[0] * 4

					if self.num_attention_heads is not None:
									raise ValueError(
									    '''At the moment it is not possible to define the number of attention heads via `num_attention_heads` because of a naming issue as described in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131. Passing `num_attention_heads` will only be supported in diffusers v0.19.'''      )

					# 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.
					SCREAMING_SNAKE_CASE  :						Dict      					= self.num_attention_heads or self.attention_head_dim

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

					# time
					SCREAMING_SNAKE_CASE  :						str      					= FlaxTimesteps(
					    block_out_channels[0],					flip_sin_to_cos=self.flip_sin_to_cos,					freq_shift=self.config.freq_shift      )
					SCREAMING_SNAKE_CASE  :						Any      					= FlaxTimestepEmbedding(__UpperCAmelCase,					dtype=self.dtype      )

					SCREAMING_SNAKE_CASE  :						List[Any]      					= self.only_cross_attention
					if isinstance(__UpperCAmelCase,					__UpperCAmelCase      ):
									SCREAMING_SNAKE_CASE  :						Optional[int]      					= (only_cross_attention,) * len(self.down_block_types      )

					if isinstance(__UpperCAmelCase,					__UpperCAmelCase      ):
									SCREAMING_SNAKE_CASE  :						str      					= (num_attention_heads,) * len(self.down_block_types      )

					# down
					SCREAMING_SNAKE_CASE  :						List[str]      					= []
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= block_out_channels[0]
					for i, down_block_type in enumerate(self.down_block_types      ):
									SCREAMING_SNAKE_CASE  :						int      					= output_channel
									SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= block_out_channels[i]
									SCREAMING_SNAKE_CASE  :						str      					= i == len(__UpperCAmelCase      ) - 1

									if down_block_type == "CrossAttnDownBlock2D":
													SCREAMING_SNAKE_CASE  :						List[Any]      					= 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],					use_memory_efficient_attention=self.use_memory_efficient_attention,					dtype=self.dtype,					)
									else:
													SCREAMING_SNAKE_CASE  :						Optional[Any]      					= 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      )
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= down_blocks

					# mid
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= FlaxUNetMidBlockaDCrossAttn(
					    in_channels=block_out_channels[-1],					dropout=self.dropout,					num_attention_heads=num_attention_heads[-1],					use_linear_projection=self.use_linear_projection,					use_memory_efficient_attention=self.use_memory_efficient_attention,					dtype=self.dtype,					)

					# up
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= []
					SCREAMING_SNAKE_CASE  :						Any      					= list(reversed(__UpperCAmelCase      )      )
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= list(reversed(__UpperCAmelCase      )      )
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= list(reversed(__UpperCAmelCase      )      )
					SCREAMING_SNAKE_CASE  :						Any      					= reversed_block_out_channels[0]
					for i, up_block_type in enumerate(self.up_block_types      ):
									SCREAMING_SNAKE_CASE  :						Dict      					= output_channel
									SCREAMING_SNAKE_CASE  :						int      					= reversed_block_out_channels[i]
									SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= reversed_block_out_channels[min(i + 1,					len(__UpperCAmelCase      ) - 1      )]

									SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= i == len(__UpperCAmelCase      ) - 1

									if up_block_type == "CrossAttnUpBlock2D":
													SCREAMING_SNAKE_CASE  :						Optional[int]      					= FlaxCrossAttnUpBlockaD(
													    in_channels=__UpperCAmelCase,					out_channels=__UpperCAmelCase,					prev_output_channel=__UpperCAmelCase,					num_layers=self.layers_per_block + 1,					num_attention_heads=reversed_num_attention_heads[i],					add_upsample=not is_final_block,					dropout=self.dropout,					use_linear_projection=self.use_linear_projection,					only_cross_attention=only_cross_attention[i],					use_memory_efficient_attention=self.use_memory_efficient_attention,					dtype=self.dtype,					)
									else:
													SCREAMING_SNAKE_CASE  :						str      					= FlaxUpBlockaD(
													    in_channels=__UpperCAmelCase,					out_channels=__UpperCAmelCase,					prev_output_channel=__UpperCAmelCase,					num_layers=self.layers_per_block + 1,					add_upsample=not is_final_block,					dropout=self.dropout,					dtype=self.dtype,					)

									up_blocks.append(__UpperCAmelCase      )
									SCREAMING_SNAKE_CASE  :						int      					= output_channel
					SCREAMING_SNAKE_CASE  :						Tuple      					= up_blocks

					# out
					SCREAMING_SNAKE_CASE  :						int      					= nn.GroupNorm(num_groups=32,					epsilon=1e-5      )
					SCREAMING_SNAKE_CASE  :						List[Any]      					= nn.Conv(
					    self.out_channels,					kernel_size=(3, 3),					strides=(1, 1),					padding=((1, 1), (1, 1)),					dtype=self.dtype,					)






	def __call__(self : str,					__UpperCAmelCase : str,					__UpperCAmelCase : Union[str, Any],					__UpperCAmelCase : List[Any],					__UpperCAmelCase : List[str]=None,					__UpperCAmelCase : Optional[int]=None,					__UpperCAmelCase : bool = True,					__UpperCAmelCase : bool = False,					)     ->			Union[FlaxUNetaDConditionOutput, Tuple]:

					"""simple docstring"""

					if not isinstance(__UpperCAmelCase,					jnp.ndarray      ):
									SCREAMING_SNAKE_CASE  :						List[str]      					= jnp.array([timesteps],					dtype=jnp.intaa      )
					elif isinstance(__UpperCAmelCase,					jnp.ndarray      ) and len(timesteps.shape      ) == 0:
									SCREAMING_SNAKE_CASE  :						str      					= timesteps.astype(dtype=jnp.floataa      )
									SCREAMING_SNAKE_CASE  :						List[Any]      					= jnp.expand_dims(__UpperCAmelCase,					0      )

					SCREAMING_SNAKE_CASE  :						Dict      					= self.time_proj(__UpperCAmelCase      )
					SCREAMING_SNAKE_CASE  :						Dict      					= self.time_embedding(__UpperCAmelCase      )

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

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

					if down_block_additional_residuals is not None:
									SCREAMING_SNAKE_CASE  :						Optional[Any]      					= ()

									for down_block_res_sample, down_block_additional_residual in zip(
									    __UpperCAmelCase,					__UpperCAmelCase      ):
													down_block_res_sample += down_block_additional_residual
													new_down_block_res_samples += (down_block_res_sample,)

									SCREAMING_SNAKE_CASE  :						str      					= new_down_block_res_samples

					# 4. mid
					SCREAMING_SNAKE_CASE  :						List[Any]      					= self.mid_block(__UpperCAmelCase,					__UpperCAmelCase,					__UpperCAmelCase,					deterministic=not train      )

					if mid_block_additional_residual is not None:
									sample += mid_block_additional_residual

					# 5. up
					for up_block in self.up_blocks:
									SCREAMING_SNAKE_CASE  :						Optional[Any]      					= down_block_res_samples[-(self.layers_per_block + 1) :]
									SCREAMING_SNAKE_CASE  :						Optional[Any]      					= down_block_res_samples[: -(self.layers_per_block + 1)]
									if isinstance(__UpperCAmelCase,					__UpperCAmelCase      ):
													SCREAMING_SNAKE_CASE  :						str      					= up_block(
													    __UpperCAmelCase,					temb=__UpperCAmelCase,					encoder_hidden_states=__UpperCAmelCase,					res_hidden_states_tuple=__UpperCAmelCase,					deterministic=not train,					)
									else:
													SCREAMING_SNAKE_CASE  :						Dict      					= up_block(__UpperCAmelCase,					temb=__UpperCAmelCase,					res_hidden_states_tuple=__UpperCAmelCase,					deterministic=not train      )

        # 6. post-process
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= self.conv_norm_out(__UpperCAmelCase      )
					SCREAMING_SNAKE_CASE  :						str      					= nn.silu(__UpperCAmelCase      )
					SCREAMING_SNAKE_CASE  :						Any      					= self.conv_out(__UpperCAmelCase      )
					SCREAMING_SNAKE_CASE  :						Dict      					= jnp.transpose(__UpperCAmelCase,					(0, 3, 1, 2)      )

					if not return_dict:
									return (sample,)

					return FlaxUNetaDConditionOutput(sample=__UpperCAmelCase      )









'''simple docstring'''

from ..utils import DummyObject, requires_backends


class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    List[Any]	    =     ["sentencepiece"]


	def __init__(self : Optional[Any],					*__UpperCAmelCase : List[Any],					**__UpperCAmelCase : List[Any]      )     ->			Optional[int]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Tuple	    =     ["sentencepiece"]


	def __init__(self : Optional[int],					*__UpperCAmelCase : int,					**__UpperCAmelCase : List[str]      )     ->			int:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Optional[int]	    =     ["sentencepiece"]


	def __init__(self : List[str],					*__UpperCAmelCase : str,					**__UpperCAmelCase : List[Any]      )     ->			str:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Optional[int]	    =     ["sentencepiece"]


	def __init__(self : Optional[int],					*__UpperCAmelCase : str,					**__UpperCAmelCase : Optional[Any]      )     ->			List[Any]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    List[str]	    =     ["sentencepiece"]


	def __init__(self : Tuple,					*__UpperCAmelCase : Union[str, Any],					**__UpperCAmelCase : Tuple      )     ->			Any:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Union[str, Any]	    =     ["sentencepiece"]


	def __init__(self : List[Any],					*__UpperCAmelCase : List[Any],					**__UpperCAmelCase : Optional[Any]      )     ->			str:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    int	    =     ["sentencepiece"]


	def __init__(self : Tuple,					*__UpperCAmelCase : int,					**__UpperCAmelCase : Any      )     ->			Union[str, Any]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    str	    =     ["sentencepiece"]


	def __init__(self : int,					*__UpperCAmelCase : Optional[Any],					**__UpperCAmelCase : Tuple      )     ->			Optional[Any]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    str	    =     ["sentencepiece"]


	def __init__(self : Tuple,					*__UpperCAmelCase : Optional[Any],					**__UpperCAmelCase : Tuple      )     ->			Dict:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    List[Any]	    =     ["sentencepiece"]


	def __init__(self : Tuple,					*__UpperCAmelCase : Optional[int],					**__UpperCAmelCase : Tuple      )     ->			int:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Tuple	    =     ["sentencepiece"]


	def __init__(self : List[Any],					*__UpperCAmelCase : Optional[int],					**__UpperCAmelCase : Optional[int]      )     ->			Union[str, Any]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    int	    =     ["sentencepiece"]


	def __init__(self : str,					*__UpperCAmelCase : str,					**__UpperCAmelCase : str      )     ->			Optional[int]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    List[str]	    =     ["sentencepiece"]


	def __init__(self : int,					*__UpperCAmelCase : List[str],					**__UpperCAmelCase : str      )     ->			Union[str, Any]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    str	    =     ["sentencepiece"]


	def __init__(self : Tuple,					*__UpperCAmelCase : Tuple,					**__UpperCAmelCase : str      )     ->			List[Any]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Any	    =     ["sentencepiece"]


	def __init__(self : Dict,					*__UpperCAmelCase : Optional[int],					**__UpperCAmelCase : List[str]      )     ->			Optional[Any]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Optional[int]	    =     ["sentencepiece"]


	def __init__(self : str,					*__UpperCAmelCase : Optional[int],					**__UpperCAmelCase : Tuple      )     ->			Dict:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Optional[Any]	    =     ["sentencepiece"]


	def __init__(self : Union[str, Any],					*__UpperCAmelCase : int,					**__UpperCAmelCase : str      )     ->			Optional[int]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Optional[int]	    =     ["sentencepiece"]


	def __init__(self : Any,					*__UpperCAmelCase : str,					**__UpperCAmelCase : List[Any]      )     ->			Optional[int]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Optional[int]	    =     ["sentencepiece"]


	def __init__(self : List[Any],					*__UpperCAmelCase : Union[str, Any],					**__UpperCAmelCase : List[Any]      )     ->			List[Any]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Optional[int]	    =     ["sentencepiece"]


	def __init__(self : Dict,					*__UpperCAmelCase : Optional[Any],					**__UpperCAmelCase : str      )     ->			List[Any]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    List[Any]	    =     ["sentencepiece"]


	def __init__(self : List[Any],					*__UpperCAmelCase : Any,					**__UpperCAmelCase : str      )     ->			int:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    str	    =     ["sentencepiece"]


	def __init__(self : Optional[int],					*__UpperCAmelCase : str,					**__UpperCAmelCase : Tuple      )     ->			Any:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Optional[int]	    =     ["sentencepiece"]


	def __init__(self : Union[str, Any],					*__UpperCAmelCase : Dict,					**__UpperCAmelCase : Optional[int]      )     ->			Tuple:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Tuple	    =     ["sentencepiece"]


	def __init__(self : List[str],					*__UpperCAmelCase : Union[str, Any],					**__UpperCAmelCase : Dict      )     ->			List[str]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Any	    =     ["sentencepiece"]


	def __init__(self : int,					*__UpperCAmelCase : Union[str, Any],					**__UpperCAmelCase : Optional[Any]      )     ->			Union[str, Any]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    List[Any]	    =     ["sentencepiece"]


	def __init__(self : Union[str, Any],					*__UpperCAmelCase : Tuple,					**__UpperCAmelCase : List[str]      )     ->			Optional[int]:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Any	    =     ["sentencepiece"]


	def __init__(self : Optional[int],					*__UpperCAmelCase : str,					**__UpperCAmelCase : str      )     ->			str:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    int	    =     ["sentencepiece"]


	def __init__(self : Dict,					*__UpperCAmelCase : Any,					**__UpperCAmelCase : List[str]      )     ->			Dict:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Optional[Any]	    =     ["sentencepiece"]


	def __init__(self : List[Any],					*__UpperCAmelCase : Optional[Any],					**__UpperCAmelCase : int      )     ->			Any:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    int	    =     ["sentencepiece"]


	def __init__(self : Tuple,					*__UpperCAmelCase : Optional[Any],					**__UpperCAmelCase : int      )     ->			int:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    List[Any]	    =     ["sentencepiece"]


	def __init__(self : Optional[int],					*__UpperCAmelCase : str,					**__UpperCAmelCase : List[str]      )     ->			str:

					"""simple docstring"""

					requires_backends(self,					['''sentencepiece''']      )




