


from typing import List, Optional, Tuple, Union

from . import logging
from .import_utils import is_torch_available, is_torch_version


if is_torch_available():
					import torch

lowercase_								=    logging.get_logger(__name__)  # pylint: disable=invalid-name

try:
					from torch._dynamo import allow_in_graph as maybe_allow_in_graph
except (ImportError, ModuleNotFoundError):


					def 							SCREAMING_SNAKE_CASE					(  cls				)    ->  Dict:
											return cls


def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase							,     _UpperCAmelCase = None							,     _UpperCAmelCase = None							,     _UpperCAmelCase = None							,     _UpperCAmelCase = None							,     )    ->  Union[str, Any]:
						_a     =			device
						_a     =			shape[0]

						_a     =			layout or torch.strided
						_a     =			device or torch.device('cpu'				)

						if generator is not None:
												_a     =			generator.device.type if not isinstance(lowercase__							,     lowercase__				) else generator[0].device.type
												if gen_device_type != device.type and gen_device_type == "cpu":
																		_a     =			'cpu'
																		if device != "mps":
																								logger.info(
																								    f"""The passed generator was created on \'cpu\' even though a tensor on {device} was expected."""
																								    f""" Tensors will be created on \'cpu\' and then moved to {device}. Note that one can probably"""
																								    f""" slighly speed up this function by passing a generator that was created on the {device} device."""				)
												elif gen_device_type != device.type and gen_device_type == "cuda":
																		raise ValueError(f"""Cannot generate a {device} tensor from a generator of type {gen_device_type}."""				)

						if isinstance(lowercase__							,     lowercase__				):
												_a     =			(1,) + shape[1:]
												_a     =			[
												    torch.randn(lowercase__							,     generator=generator[i]							,     device=lowercase__							,     dtype=lowercase__							,     layout=lowercase__				)
												    for i in range(lowercase__				)
												]
												_a     =			torch.cat(lowercase__							,     dim=0				).to(lowercase__				)
						else:
												_a     =			torch.randn(lowercase__							,     generator=lowercase__							,     device=lowercase__							,     dtype=lowercase__							,     layout=lowercase__				).to(lowercase__				)

						return latents






def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  Tuple:
						if is_torch_version('<'							,     '2.0.0'				) or not hasattr(lowercase__							,     '_dynamo'				):
												return False
						return isinstance(lowercase__							,     torch._dynamo.eval_frame.OptimizedModule				)






from math import pi


def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  float:
						return degree / (180 / pi)


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

		testmod()


