
import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


_A       =					logging.get_logger(__name__)





class      _lowerCAmelCase (     __a	):
				_lowercase      		='''speech-encoder-decoder'''
				_lowercase      		=True




				def __init__( self    ,    **_UpperCamelCase					)    ->				List[Any]:
							super().__init__(**_UpperCamelCase					)
							if "encoder" not in kwargs or "decoder" not in kwargs:
										raise ValueError(
										    f"""A configuraton of type {self.model_type} cannot be instantiated because not both `encoder` and"""
										    f""" `decoder` sub-configurations are passed, but only {kwargs}"""					)

							lowerCAmelCase_      =     kwargs.pop("encoder"					)
							lowerCAmelCase_      =     encoder_config.pop("model_type"					)
							lowerCAmelCase_      =     kwargs.pop("decoder"					)
							lowerCAmelCase_      =     decoder_config.pop("model_type"					)

							lowerCAmelCase_      =     AutoConfig.for_model(_UpperCamelCase    ,    **_UpperCamelCase					)
							lowerCAmelCase_      =     AutoConfig.for_model(_UpperCamelCase    ,    **_UpperCamelCase					)
							lowerCAmelCase_      =     True




				@classmethod
				def 					__a						( cls    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    **_UpperCamelCase					)    ->				PretrainedConfig:
							logger.info("Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config"					)
							lowerCAmelCase_      =     True
							lowerCAmelCase_      =     True

							return cls(encoder=encoder_config.to_dict()    ,    decoder=decoder_config.to_dict()    ,    **_UpperCamelCase					)




				def 					__a						( self					)    ->				List[Any]:
							lowerCAmelCase_      =     copy.deepcopy(self.__dict__					)
							lowerCAmelCase_      =     self.encoder.to_dict()
							lowerCAmelCase_      =     self.decoder.to_dict()
							lowerCAmelCase_      =     self.__class__.model_type
							return output





from __future__ import annotations






def        lowerCamelCase__    (    __lowerCAmelCase  :  int   ,							__lowerCAmelCase  :  int   ,							__lowerCAmelCase  :  int    ):




			"""simple docstring"""


			assert n > 1 and a > 0 and greatest_common_divisor(__lowerCAmelCase   ,							__lowerCAmelCase    ) == 1
			((lowerCAmelCase_)     ,  (lowerCAmelCase_)     ,  (lowerCAmelCase_))      =     extended_gcd(__lowerCAmelCase   ,							__lowerCAmelCase    )  # Implemented below
			lowerCAmelCase_      =     (b * s) % n
			return x






def        lowerCamelCase__    (    __lowerCAmelCase  :  int   ,							__lowerCAmelCase  :  int    ):




			"""simple docstring"""


			((lowerCAmelCase_)     ,  (lowerCAmelCase_))      =     extended_euclid(__lowerCAmelCase   ,							__lowerCAmelCase    )  # Implemented below
			if b < 0:
						lowerCAmelCase_      =     (b % n + n) % n
			return b






def        lowerCamelCase__    (    __lowerCAmelCase  :  int   ,							__lowerCAmelCase  :  int   ,							__lowerCAmelCase  :  int    ):




			"""simple docstring"""


			lowerCAmelCase_      =     invert_modulo(__lowerCAmelCase   ,							__lowerCAmelCase    )
			lowerCAmelCase_      =     (b * s) % n
			return x






def        lowerCamelCase__    (    __lowerCAmelCase  :  int   ,							__lowerCAmelCase  :  int    ):




			"""simple docstring"""


			assert a >= 0 and b >= 0

			if b == 0:
						lowerCAmelCase_     ,  lowerCAmelCase_     ,  lowerCAmelCase_      =     a, 1, 0
			else:
						((lowerCAmelCase_)     ,  (lowerCAmelCase_)     ,  (lowerCAmelCase_))      =     extended_gcd(__lowerCAmelCase   ,							a % b    )
						lowerCAmelCase_      =     q
						lowerCAmelCase_      =     p - q * (a // b)

			assert a % d == 0 and b % d == 0
			assert d == a * x + b * y

			return (d, x, y)






def        lowerCamelCase__    (    __lowerCAmelCase  :  int   ,							__lowerCAmelCase  :  int    ):




			"""simple docstring"""


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






def        lowerCamelCase__    (    __lowerCAmelCase  :  int   ,							__lowerCAmelCase  :  int    ):




			"""simple docstring"""


			if a < b:
						lowerCAmelCase_     ,  lowerCAmelCase_      =     b, a

			while a % b != 0:
						lowerCAmelCase_     ,  lowerCAmelCase_      =     b, a % b

			return b


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

			testmod(name="modular_division", verbose=True)
			testmod(name="modular_division2", verbose=True)
			testmod(name="invert_modulo", verbose=True)
			testmod(name="extended_gcd", verbose=True)
			testmod(name="extended_euclid", verbose=True)
			testmod(name="greatest_common_divisor", verbose=True)



