code: 
  
  
  
  import argparse
  import json
  
  import torch
  
  from diffusers import ScoreSdeVePipeline, ScoreSdeVeScheduler, UNetaDModel
  
  
  
  def  __a  (					lowerCAmelCase_     :      str    ,lowerCAmelCase_     :      Optional[int]       )   ->				Tuple:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						UpperCAmelCase_=     UNetaDModel(**_UpperCAmelCase       )
  						UpperCAmelCase_=     checkpoint["""all_modules.0.W"""].data
  						UpperCAmelCase_=     checkpoint["""all_modules.0.W"""].data
  						UpperCAmelCase_=     checkpoint["""all_modules.1.weight"""].data
  						UpperCAmelCase_=     checkpoint["""all_modules.1.bias"""].data
  
  						UpperCAmelCase_=     checkpoint["""all_modules.2.weight"""].data
  						UpperCAmelCase_=     checkpoint["""all_modules.2.bias"""].data
  
  						UpperCAmelCase_=     checkpoint["""all_modules.3.weight"""].data
  						UpperCAmelCase_=     checkpoint["""all_modules.3.bias"""].data
  
  						UpperCAmelCase_=     checkpoint[list(checkpoint.keys()       )[-4]].data
  						UpperCAmelCase_=     checkpoint[list(checkpoint.keys()       )[-3]].data
  						UpperCAmelCase_=     checkpoint[list(checkpoint.keys()       )[-2]].data
  						UpperCAmelCase_=     checkpoint[list(checkpoint.keys()       )[-1]].data
  
  						UpperCAmelCase_=     4
  
  						def set_attention_weights(lowerCAmelCase_     :      int    ,lowerCAmelCase_     :      Optional[Any]    ,lowerCAmelCase_     :      Tuple       ):
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.NIN_0.W"""].data.T
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.NIN_1.W"""].data.T
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.NIN_2.W"""].data.T
  
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.NIN_0.b"""].data
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.NIN_1.b"""].data
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.NIN_2.b"""].data
  
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.NIN_3.W"""].data.T
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.NIN_3.b"""].data
  
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.GroupNorm_0.weight"""].data
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.GroupNorm_0.bias"""].data
  
  						def set_resnet_weights(lowerCAmelCase_     :      int    ,lowerCAmelCase_     :      str    ,lowerCAmelCase_     :      Optional[Any]       ):
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.Conv_0.weight"""].data
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.Conv_0.bias"""].data
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.GroupNorm_0.weight"""].data
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.GroupNorm_0.bias"""].data
  
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.Conv_1.weight"""].data
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.Conv_1.bias"""].data
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.GroupNorm_1.weight"""].data
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.GroupNorm_1.bias"""].data
  
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.Dense_0.weight"""].data
  												UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.Dense_0.bias"""].data
  
  												if new_layer.in_channels != new_layer.out_channels or new_layer.up or new_layer.down:
  																		UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.Conv_2.weight"""].data
  																		UpperCAmelCase_=     old_checkpoint[F"""all_modules.{index}.Conv_2.bias"""].data
  
  						for i, block in enumerate(new_model_architecture.downsample_blocks       ):
  												UpperCAmelCase_=     hasattr(_UpperCAmelCase    ,"""attentions"""       )
  												for j in range(len(block.resnets       )       ):
  																		set_resnet_weights(block.resnets[j]    ,_UpperCAmelCase    ,_UpperCAmelCase       )
  																		module_index += 1
  																		if has_attentions:
  																								set_attention_weights(block.attentions[j]    ,_UpperCAmelCase    ,_UpperCAmelCase       )
  																								module_index += 1
  
  												if hasattr(_UpperCAmelCase    ,"""downsamplers"""       ) and block.downsamplers is not None:
  																		set_resnet_weights(block.resnet_down    ,_UpperCAmelCase    ,_UpperCAmelCase       )
  																		module_index += 1
  																		UpperCAmelCase_=     checkpoint[F"""all_modules.{module_index}.Conv_0.weight"""].data
  																		UpperCAmelCase_=     checkpoint[F"""all_modules.{module_index}.Conv_0.bias"""].data
  																		module_index += 1
  
  						set_resnet_weights(new_model_architecture.mid_block.resnets[0]    ,_UpperCAmelCase    ,_UpperCAmelCase       )
  						module_index += 1
  						set_attention_weights(new_model_architecture.mid_block.attentions[0]    ,_UpperCAmelCase    ,_UpperCAmelCase       )
  						module_index += 1
  						set_resnet_weights(new_model_architecture.mid_block.resnets[1]    ,_UpperCAmelCase    ,_UpperCAmelCase       )
  						module_index += 1
  
  						for i, block in enumerate(new_model_architecture.up_blocks       ):
  												UpperCAmelCase_=     hasattr(_UpperCAmelCase    ,"""attentions"""       )
  												for j in range(len(block.resnets       )       ):
  																		set_resnet_weights(block.resnets[j]    ,_UpperCAmelCase    ,_UpperCAmelCase       )
  																		module_index += 1
  												if has_attentions:
  																		set_attention_weights(
  																		    block.attentions[0]    ,_UpperCAmelCase    ,_UpperCAmelCase       )  # why can there only be a single attention layer for up?
  																		module_index += 1
  
  												if hasattr(_UpperCAmelCase    ,"""resnet_up"""       ) and block.resnet_up is not None:
  																		UpperCAmelCase_=     checkpoint[F"""all_modules.{module_index}.weight"""].data
  																		UpperCAmelCase_=     checkpoint[F"""all_modules.{module_index}.bias"""].data
  																		module_index += 1
  																		UpperCAmelCase_=     checkpoint[F"""all_modules.{module_index}.weight"""].data
  																		UpperCAmelCase_=     checkpoint[F"""all_modules.{module_index}.bias"""].data
  																		module_index += 1
  																		set_resnet_weights(block.resnet_up    ,_UpperCAmelCase    ,_UpperCAmelCase       )
  																		module_index += 1
  
  						UpperCAmelCase_=     checkpoint[F"""all_modules.{module_index}.weight"""].data
  						UpperCAmelCase_=     checkpoint[F"""all_modules.{module_index}.bias"""].data
  						module_index += 1
  						UpperCAmelCase_=     checkpoint[F"""all_modules.{module_index}.weight"""].data
  						UpperCAmelCase_=     checkpoint[F"""all_modules.{module_index}.bias"""].data
  
  						return new_model_architecture.state_dict()
  
  
  if __name__ == "__main__":
  						__A       					=		argparse.ArgumentParser()
  
  						parser.add_argument(
  						    '''--checkpoint_path''',
  						    default='''/Users/arthurzucker/Work/diffusers/ArthurZ/diffusion_pytorch_model.bin''',
  						    type=str,
  						    required=False,
  						    help='''Path to the checkpoint to convert.''',
  						)
  
  						parser.add_argument(
  						    '''--config_file''',
  						    default='''/Users/arthurzucker/Work/diffusers/ArthurZ/config.json''',
  						    type=str,
  						    required=False,
  						    help='''The config json file corresponding to the architecture.''',
  						)
  
  						parser.add_argument(
  						    '''--dump_path''',
  						    default='''/Users/arthurzucker/Work/diffusers/ArthurZ/diffusion_model_new.pt''',
  						    type=str,
  						    required=False,
  						    help='''Path to the output model.''',
  						)
  
  						__A       					=		parser.parse_args()
  
  						__A       					=		torch.load(args.checkpoint_path, map_location='''cpu''')
  
  						with open(args.config_file) as f:
  												__A       					=		json.loads(f.read())
  
  						__A       					=		convert_ncsnpp_checkpoint(
  						    checkpoint,
  						    config,
  						)
  
  						if "sde" in config:
  												del config["sde"]
  
  						__A       					=		UNetaDModel(**config)
  						model.load_state_dict(converted_checkpoint)
  
  						try:
  												__A       					=		ScoreSdeVeScheduler.from_config('''/'''.join(args.checkpoint_path.split('''/''')[:-1]))
  
  												__A       					=		ScoreSdeVePipeline(unet=model, scheduler=scheduler)
  												pipe.save_pretrained(args.dump_path)
  						except:  # noqa: E722
  												model.save_pretrained(args.dump_path)
  
  
  
  
  
style_context: 
  
  
  
  from math import radians as angle_to_radians
  from math import sin
  
  # Acceleration Constant on Earth (unit m/s^2)
  __A       					=		9.8_0_6_6_5
  
  
  
  def  __a  (					lowerCAmelCase_     :      float    ,lowerCAmelCase_     :      float       )   ->				None:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						if not isinstance(lowerCAmelCase_    ,(int, float)       ):
  												raise TypeError("""Invalid velocity. Should be a positive number."""       )
  
  						if not isinstance(lowerCAmelCase_    ,(int, float)       ):
  												raise TypeError("""Invalid angle. Range is 1-90 degrees."""       )
  
  						# Ensure valid angle
  						if angle > 90 or angle < 1:
  												raise ValueError("""Invalid angle. Range is 1-90 degrees."""       )
  
  						# Ensure valid velocity
  						if init_velocity < 0:
  												raise ValueError("""Invalid velocity. Should be a positive number."""       )
  
  
  
  def  __a  (					lowerCAmelCase_     :      float    ,lowerCAmelCase_     :      float       )   ->				float:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						check_args(lowerCAmelCase_    ,lowerCAmelCase_       )
  						UpperCAmelCase_=     angle_to_radians(2 * angle       )
  						return round(init_velocity**2 * sin(lowerCAmelCase_       ) / g    ,2       )
  
  
  
  def  __a  (					lowerCAmelCase_     :      float    ,lowerCAmelCase_     :      float       )   ->				float:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						check_args(lowerCAmelCase_    ,lowerCAmelCase_       )
  						UpperCAmelCase_=     angle_to_radians(lowerCAmelCase_       )
  						return round(init_velocity**2 * sin(lowerCAmelCase_       ) ** 2 / (2 * g)    ,2       )
  
  
  
  def  __a  (					lowerCAmelCase_     :      float    ,lowerCAmelCase_     :      float       )   ->				float:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						check_args(lowerCAmelCase_    ,lowerCAmelCase_       )
  						UpperCAmelCase_=     angle_to_radians(lowerCAmelCase_       )
  						return round(2 * init_velocity * sin(lowerCAmelCase_       ) / g    ,2       )
  
  
  
  def  __a  (					)   ->				None:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						UpperCAmelCase_,     UpperCAmelCase_=     25, 20
  						assert horizontal_distance(lowerCAmelCase_    ,lowerCAmelCase_       ) == 40.97
  						assert max_height(lowerCAmelCase_    ,lowerCAmelCase_       ) == 3.73
  						assert total_time(lowerCAmelCase_    ,lowerCAmelCase_       ) == 1.74
  
  
  if __name__ == "__main__":
  	from doctest import testmod
  
  	testmod()
  
  	# Get input from user
  	__A       					=		float(input('''Initial Velocity: ''').strip())
  
  	# Get input from user
  	__A       					=		float(input('''angle: ''').strip())
  
  	# Print results
  	print()
  	print('''Results: ''')
  	print(f'Horizontal Distance: {horizontal_distance(init_vel, angle)!s} [m]')
  	print(f'Maximum Height: {max_height(init_vel, angle)!s} [m]')
  	print(f'Total Time: {total_time(init_vel, angle)!s} [s]')
  
  
  
  
  