






from __future__ import annotations





def 					snake_case	(  lowerCamelCase					,	lowerCamelCase       ):




	'''simple docstring'''







	if b == 0:
		return (1, 0)
	((__lowercase)							,    (__lowercase))   							=	extended_euclid(lowerCamelCase					,	a % b       )
	__lowercase   							=	a // b
	return (y, x - k * y)





def 					snake_case	(  lowerCamelCase					,	lowerCamelCase					,	lowerCamelCase					,	lowerCamelCase       ):




	'''simple docstring'''







	((__lowercase)							,    (__lowercase))   							=	extended_euclid(lowerCamelCase					,	lowerCamelCase       )
	__lowercase   							=	na * na
	__lowercase   							=	ra * x * na + ra * y * na
	return (n % m + m) % m





def 					snake_case	(  lowerCamelCase					,	lowerCamelCase       ):




	'''simple docstring'''







	((__lowercase)							,    (__lowercase))   							=	extended_euclid(lowerCamelCase					,	lowerCamelCase       )
	if b < 0:
		__lowercase   							=	(b % n + n) % n
	return b





def 					snake_case	(  lowerCamelCase					,	lowerCamelCase					,	lowerCamelCase					,	lowerCamelCase       ):




	'''simple docstring'''







	__lowercase							,    __lowercase   							=	invert_modulo(lowerCamelCase					,	lowerCamelCase       ), invert_modulo(lowerCamelCase					,	lowerCamelCase       )
	__lowercase   							=	na * na
	__lowercase   							=	ra * x * na + ra * y * na
	return (n % m + m) % m


if __name__ == "__main__":
						from doctest import testmod

						testmod(name="""chinese_remainder_theorem""", verbose=True)
						testmod(name="""chinese_remainder_theorem2""", verbose=True)
						testmod(name="""invert_modulo""", verbose=True)
						testmod(name="""extended_euclid""", verbose=True)








'''simple docstring'''

from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, apply_forward_hook
from .modeling_utils import ModelMixin
from .vae import Decoder, DecoderOutput, Encoder, VectorQuantizer






@dataclass
class   UpperCAmelCase      (			UpperCamelCase__							):
 __lowercase  						=							42






class   UpperCAmelCase      (			UpperCamelCase__     ,			UpperCamelCase__							):
 @register_to_config
 def __init__(							self :Tuple		,			lowercase_ :int = 3		,			lowercase_ :int = 3		,			lowercase_ :Tuple[str] = ("DownEncoderBlock2D",)		,			lowercase_ :Tuple[str] = ("UpDecoderBlock2D",)		,			lowercase_ :Tuple[int] = (64,)		,			lowercase_ :int = 1		,			lowercase_ :str = "silu"		,			lowercase_ :int = 3		,			lowercase_ :int = 32		,			lowercase_ :int = 2_56		,			lowercase_ :int = 32		,			lowercase_ :Optional[int] = None		,			lowercase_ :float = 0.1_8_2_1_5		,			lowercase_ :str = "group"		,			)->				Optional[int]:
     super().__init__()

     # pass init params to Encoder
     A__							=     Encoder(
         in_channels=lowercase_		,			out_channels=lowercase_		,			down_block_types=lowercase_		,			block_out_channels=lowercase_		,			layers_per_block=lowercase_		,			act_fn=lowercase_		,			norm_num_groups=lowercase_		,			double_z=lowercase_		,			)

     A__							=     vq_embed_dim if vq_embed_dim is not None else latent_channels

     A__							=     nn.Convad(lowercase_		,			lowercase_		,			1				)
     A__							=     VectorQuantizer(lowercase_		,			lowercase_		,			beta=0.2_5		,			remap=lowercase_		,			sane_index_shape=lowercase_				)
     A__							=     nn.Convad(lowercase_		,			lowercase_		,			1				)

     # pass init params to Decoder
     A__							=     Decoder(
         in_channels=lowercase_		,			out_channels=lowercase_		,			up_block_types=lowercase_		,			block_out_channels=lowercase_		,			layers_per_block=lowercase_		,			act_fn=lowercase_		,			norm_num_groups=lowercase_		,			norm_type=lowercase_		,			)
 @apply_forward_hook
 def 	UpperCAmelCase_				(							self :str		,			lowercase_ :torch.FloatTensor		,			lowercase_ :bool = True				)->				VQEncoderOutput:
     A__							=     self.encoder(lowercase_				)
     A__							=     self.quant_conv(lowercase_				)

     if not return_dict:
         return (h,)

     return VQEncoderOutput(latents=lowercase_				)
 @apply_forward_hook
 def 	UpperCAmelCase_				(							self :Dict		,			lowercase_ :torch.FloatTensor		,			lowercase_ :bool = False		,			lowercase_ :bool = True				)->				Union[DecoderOutput, torch.FloatTensor]:
     # also go through quantization layer
     if not force_not_quantize:
         A__,      A__,      A__							=     self.quantize(lowercase_				)
     else:
         A__							=     h
     A__							=     self.post_quant_conv(lowercase_				)
     A__							=     self.decoder(lowercase_		,			quant if self.config.norm_type == "spatial" else None				)

     if not return_dict:
         return (dec,)

     return DecoderOutput(sample=lowercase_				)



 def 	UpperCAmelCase_				(							self :str		,			lowercase_ :torch.FloatTensor		,			lowercase_ :bool = True				)->				Union[DecoderOutput, torch.FloatTensor]:
     A__							=     sample
     A__							=     self.encode(lowercase_				).latents
     A__							=     self.decode(lowercase_				).sample

     if not return_dict:
         return (dec,)

     return DecoderOutput(sample=lowercase_				)



