


"""simple docstring"""
from typing import Dict, Optional, Tuple

import torch






def 						lowercase				(	_snake_case		: torch.Tensor	)	->torch.Tensor:
	"""simple docstring"""





	__snake_case      :		str         =							boundaries[1] - boundaries[0]
	__snake_case      :		Union[str, Any]         =							boundaries + step / 2
	__snake_case      :		Dict         =							torch.cat([bin_centers, (bin_centers[-1] + step).unsqueeze(-1	)]	,  dim=0	)
	return bin_centers






def 						lowercase				(	_snake_case		: torch.Tensor	,  _snake_case		: torch.Tensor	,  )	->Tuple[torch.Tensor, torch.Tensor]:
	"""simple docstring"""





	__snake_case      :		Optional[int]         =							_calculate_bin_centers(_snake_case	)
	return (
	    torch.sum(aligned_distance_error_probs * bin_centers	,  dim=-1	),
	    bin_centers[-1],
	)






def 						lowercase				(	_snake_case		: torch.Tensor	,  _snake_case		: int = 31	,  _snake_case		: int = 64	,  **_snake_case		: Optional[Any]	,  )	->Dict[str, torch.Tensor]:
	"""simple docstring"""





	__snake_case      :		Optional[Any]         =							torch.linspace(0	,  _snake_case	,  steps=(no_bins - 1)	,  device=logits.device	)

	__snake_case      :		Optional[Any]         =							torch.nn.functional.softmax(_snake_case	,  dim=-1	)
	__snake_case      ,				__snake_case      :		List[Any]         =							_calculate_expected_aligned_error(
	    alignment_confidence_breaks=_snake_case	,  aligned_distance_error_probs=_snake_case	,  )

	return {
	    "aligned_confidence_probs": aligned_confidence_probs,
	    "predicted_aligned_error": predicted_aligned_error,
	    "max_predicted_aligned_error": max_predicted_aligned_error,
	}






def 						lowercase				(	_snake_case		: torch.Tensor	,  _snake_case		: Optional[torch.Tensor] = None	,  _snake_case		: int = 31	,  _snake_case		: int = 64	,  _snake_case		: float = 1e-8	,  **_snake_case		: Tuple	,  )	->torch.Tensor:
	"""simple docstring"""





	if residue_weights is None:
		__snake_case      :		str         =							logits.new_ones(logits.shape[-2]	)

	__snake_case      :		List[Any]         =							torch.linspace(0	,  _snake_case	,  steps=(no_bins - 1)	,  device=logits.device	)

	__snake_case      :		Optional[Any]         =							_calculate_bin_centers(_snake_case	)
	torch.sum(_snake_case	)
	__snake_case      :		str         =							logits.shape[-2]
	__snake_case      :		Optional[Any]         =							max(_snake_case	,  19	)

	__snake_case      :		int         =							1.24 * (clipped_n - 15) ** (1.0 / 3) - 1.8

	__snake_case      :		List[Any]         =							torch.nn.functional.softmax(_snake_case	,  dim=-1	)

	__snake_case      :		Optional[int]         =							1.0 / (1 + (bin_centers**2) / (da**2))
	__snake_case      :		int         =							torch.sum(probs * tm_per_bin	,  dim=-1	)

	__snake_case      :		Optional[int]         =							residue_weights / (eps + residue_weights.sum())
	__snake_case      :		Any         =							torch.sum(predicted_tm_term * normed_residue_mask	,  dim=-1	)

	__snake_case      :		List[Any]         =							per_alignment * residue_weights

	__snake_case      :		int         =							(weighted == torch.max(_snake_case	)).nonzero()[0]
	return per_alignment[tuple(_snake_case	)]









"""simple docstring"""
import unittest

from diffusers import __version__
from diffusers.utils import deprecate



class      _UpperCAmelCase					(				unittest.TestCase							):






		'''simple docstring'''

		lowerCamelCase__           ='.'.join([str(int(__version__.split('.'							)[0]							) + 1							)] + __version__.split('.'							)[1:]							)
		lowerCamelCase__           ='0.0.1'



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		int         =							{'''deprecated_arg''': 4}

			with self.assertWarns(a_   ) as warning:
				__snake_case      :		Union[str, Any]         =							deprecate('''deprecated_arg'''							,			self.higher_version							,			'''message'''							,			take_from=a_   )

			assert output == 4
			assert (
			    str(warning.warning   )
			    == f"""The `deprecated_arg` argument is deprecated and will be removed in version {self.higher_version}."""
			    " message"
			)



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Tuple         =							{'''deprecated_arg''': 4}

			with self.assertWarns(a_   ) as warning:
				__snake_case      :		Dict         =							deprecate(('''deprecated_arg''', self.higher_version, '''message''')							,			take_from=a_   )

			assert output == 4
			assert (
			    str(warning.warning   )
			    == f"""The `deprecated_arg` argument is deprecated and will be removed in version {self.higher_version}."""
			    " message"
			)



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Union[str, Any]         =							{'''deprecated_arg_1''': 4, '''deprecated_arg_2''': 8}
			with self.assertWarns(a_   ) as warning:
				__snake_case      ,				__snake_case      :		List[Any]         =							deprecate(
				    ('''deprecated_arg_1''', self.higher_version, '''Hey''')							,			('''deprecated_arg_2''', self.higher_version, '''Hey''')							,			take_from=a_							,			)
			assert output_a == 4
			assert output_a == 8
			assert (
			    str(warning.warnings[0].message   )
			    == "The `deprecated_arg_1` argument is deprecated and will be removed in version"
			    f""" {self.higher_version}. Hey"""
			)
			assert (
			    str(warning.warnings[1].message   )
			    == "The `deprecated_arg_2` argument is deprecated and will be removed in version"
			    f""" {self.higher_version}. Hey"""
			)



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		int         =							{'''deprecated_arg''': 4}

			with self.assertRaises(a_   ) as error:
				deprecate(('''wrong_arg''', self.higher_version, '''message''')							,			take_from=a_   )

			assert "test_deprecate_function_incorrect_arg in" in str(error.exception   )
			assert "line" in str(error.exception   )
			assert "got an unexpected keyword argument `deprecated_arg`" in str(error.exception   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			with self.assertWarns(a_   ) as warning:
				deprecate(('''deprecated_arg''', self.higher_version, '''message''')   )

			assert (
			    str(warning.warning   )
			    == f"""`deprecated_arg` is deprecated and will be removed in version {self.higher_version}. message"""
			)



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			with self.assertWarns(a_   ) as warning:
				deprecate(
				    ('''deprecated_arg_1''', self.higher_version, '''Hey''')							,			('''deprecated_arg_2''', self.higher_version, '''Hey''')							,			)
			assert (
			    str(warning.warnings[0].message   )
			    == f"""`deprecated_arg_1` is deprecated and will be removed in version {self.higher_version}. Hey"""
			)
			assert (
			    str(warning.warnings[1].message   )
			    == f"""`deprecated_arg_2` is deprecated and will be removed in version {self.higher_version}. Hey"""
			)



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			class      _UpperCAmelCase					:






					'''simple docstring'''

					lowerCamelCase__           =5

			with self.assertWarns(a_   ) as warning:
				__snake_case      :		List[Any]         =							deprecate(('''arg''', self.higher_version, '''message''')							,			take_from=Args()   )

			assert arg == 5
			assert (
			    str(warning.warning   )
			    == f"""The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message"""
			)



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			class      _UpperCAmelCase					:






					'''simple docstring'''

					lowerCamelCase__           =5
					lowerCamelCase__           =7

			with self.assertWarns(a_   ) as warning:
				__snake_case      ,				__snake_case      :		List[str]         =							deprecate(
				    ('''arg''', self.higher_version, '''message''')							,			('''foo''', self.higher_version, '''message''')							,			('''does not exist''', self.higher_version, '''message''')							,			take_from=Args()							,			)

			assert arg_a == 5
			assert arg_a == 7
			assert (
			    str(warning.warning   )
			    == f"""The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message"""
			)
			assert (
			    str(warning.warnings[0].message   )
			    == f"""The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message"""
			)
			assert (
			    str(warning.warnings[1].message   )
			    == f"""The `foo` attribute is deprecated and will be removed in version {self.higher_version}. message"""
			)



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		str         =							{'''deprecated_arg''': 4}

			with self.assertRaises(a_   ) as error:
				deprecate(('''wrong_arg''', self.lower_version, '''message''')							,			take_from=a_   )

			assert (
			    str(error.exception   )
			    == "The deprecation tuple ('wrong_arg', '0.0.1', 'message') should be removed since diffusers' version"
			    f""" {__version__} is >= {self.lower_version}"""
			)



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			with self.assertWarns(a_   ) as warning:
				deprecate(('''deprecated_arg''', self.higher_version, '''This message is better!!!''')							,			standard_warn=a_   )

			assert str(warning.warning   ) == "This message is better!!!"



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			with self.assertWarns(a_   ) as warning:
				deprecate(('''deprecated_arg''', self.higher_version, '''This message is better!!!''')							,			standard_warn=a_   )
			assert str(warning.warning   ) == "This message is better!!!"
			assert "diffusers/tests/others/test_utils.py" in warning.filename





