code: 
  
  
  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				)
  
  
  
style_context: 
  
  
  from math import pi
  
  
  def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  float:
  						return degree / (180 / pi)
  
  
  if __name__ == "__main__":
  		from doctest import testmod
  
  		testmod()
  
  
  