

"""simple docstring"""




import argparse

import torch

from diffusers import UNetaDConditionModel
def 					lowerCAmelCase  (   __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase=None							,      __UpperCamelCase=None							,      __UpperCamelCase=None ):
 '''simple docstring'''





 assert isinstance(__UpperCamelCase							,      __UpperCamelCase ), "Paths should be a list of dicts containing 'old' and 'new' keys."

 # Splits the attention layers into three variables.
 if attention_paths_to_split is not None:
  for path, path_map in attention_paths_to_split.items():
   UpperCAmelCase__   :					str   				=   old_checkpoint[path]
   UpperCAmelCase__   :					str   				=   old_tensor.shape[0] // 3

   UpperCAmelCase__   :					Any   				=   (-1, channels) if len(old_tensor.shape ) == 3 else (-1)

   UpperCAmelCase__   :					Tuple   				=   old_tensor.shape[0] // config["""num_head_channels"""] // 3

   UpperCAmelCase__   :					List[Any]   				=   old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:] )
   UpperCAmelCase__				, UpperCAmelCase__				, UpperCAmelCase__   :					List[Any]   				=   old_tensor.split(channels // num_heads							,      dim=1 )

   UpperCAmelCase__   :					List[str]   				=   query.reshape(__UpperCamelCase )
   UpperCAmelCase__   :					Dict   				=   key.reshape(__UpperCamelCase )
   UpperCAmelCase__   :					List[str]   				=   value.reshape(__UpperCamelCase )

 for path in paths:
  UpperCAmelCase__   :					Optional[Any]   				=   path["""new"""]

  # These have already been assigned
  if attention_paths_to_split is not None and new_path in attention_paths_to_split:
   continue

  if additional_replacements is not None:
   for replacement in additional_replacements:
    UpperCAmelCase__   :					Tuple   				=   new_path.replace(replacement["""old"""]							,      replacement["""new"""] )

        # proj_attn.weight has to be converted from conv 1D to linear
  UpperCAmelCase__   :					List[str]   				=   old_checkpoint[path["""old"""]]
  UpperCAmelCase__   :					List[str]   				=   ["""proj_attn.weight"""]
  UpperCAmelCase__   :					Tuple   				=   ["""proj_out.weight""", """proj_in.weight"""]
  if any(k in new_path for k in names ):
   UpperCAmelCase__   :					Any   				=   weight[:, :, 0]
  elif any(k in new_path for k in names_a ) and len(weight.shape ) > 2 and ".attentions." not in new_path:
   UpperCAmelCase__   :					Dict   				=   weight[:, :, 0]
  else:
   UpperCAmelCase__   :					List[Any]   				=   weight
def 					lowerCAmelCase  (   __UpperCamelCase							,      __UpperCamelCase=0 ):
 '''simple docstring'''





 UpperCAmelCase__   :					Tuple   				=   []
 for old_item in old_list:
  UpperCAmelCase__   :					Tuple   				=   old_item

  #         new_item = new_item.replace('norm.weight', 'group_norm.weight')
  #         new_item = new_item.replace('norm.bias', 'group_norm.bias')

  #         new_item = new_item.replace('proj_out.weight', 'proj_attn.weight')
  #         new_item = new_item.replace('proj_out.bias', 'proj_attn.bias')

  #         new_item = shave_segments(new_item, n_shave_prefix_segments=n_shave_prefix_segments)

  mapping.append({"""old""": old_item, """new""": new_item} )

 return mapping
def 					lowerCAmelCase  (   __UpperCamelCase							,      __UpperCamelCase=1 ):
 '''simple docstring'''





 if n_shave_prefix_segments >= 0:
  return ".".join(path.split(""".""" )[n_shave_prefix_segments:] )
 else:
  return ".".join(path.split(""".""" )[:n_shave_prefix_segments] )
def 					lowerCAmelCase  (   __UpperCamelCase							,      __UpperCamelCase=0 ):
 '''simple docstring'''





 UpperCAmelCase__   :					Union[str, Any]   				=   []
 for old_item in old_list:
  mapping.append({"""old""": old_item, """new""": old_item} )

 return mapping
def 					lowerCAmelCase  (   __UpperCamelCase							,      __UpperCamelCase=0 ):
 '''simple docstring'''





 UpperCAmelCase__   :					Union[str, Any]   				=   []
 for old_item in old_list:
  UpperCAmelCase__   :					Any   				=   old_item.replace("""in_layers.0"""							,      """norm1""" )
  UpperCAmelCase__   :					List[str]   				=   new_item.replace("""in_layers.2"""							,      """conv1""" )

  UpperCAmelCase__   :					List[str]   				=   new_item.replace("""out_layers.0"""							,      """norm2""" )
  UpperCAmelCase__   :					Tuple   				=   new_item.replace("""out_layers.3"""							,      """conv2""" )

  UpperCAmelCase__   :					Any   				=   new_item.replace("""emb_layers.1"""							,      """time_emb_proj""" )
  UpperCAmelCase__   :					Dict   				=   new_item.replace("""skip_connection"""							,      """conv_shortcut""" )

  UpperCAmelCase__   :					Optional[Any]   				=   shave_segments(__UpperCamelCase							,      n_shave_prefix_segments=__UpperCamelCase )

  if "temopral_conv" not in old_item:
   mapping.append({"""old""": old_item, """new""": new_item} )

 return mapping
def 					lowerCAmelCase  (   __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase=None							,      __UpperCamelCase=False ):
 '''simple docstring'''





 UpperCAmelCase__   :					Any   				=   {}
 UpperCAmelCase__   :					List[Any]   				=   list(checkpoint.keys() )

 UpperCAmelCase__   :					Dict   				=   """model.diffusion_model."""

 # at least a 100 parameters have to start with `model_ema` in order for the checkpoint to be EMA
 if sum(k.startswith("""model_ema""" ) for k in keys ) > 100 and extract_ema:
  print(F"Checkpoint {path} has both EMA and non-EMA weights." )
  print(
      """In this conversion only the EMA weights are extracted. If you want to instead extract the non-EMA"""
      """ weights (useful to continue fine-tuning), please make sure to remove the `--extract_ema` flag.""" )
  for key in keys:
   if key.startswith("""model.diffusion_model""" ):
    UpperCAmelCase__   :					List[Any]   				=   """model_ema.""" + """""".join(key.split(""".""" )[1:] )
    UpperCAmelCase__   :					Dict   				=   checkpoint.pop(__UpperCamelCase )
 else:
  if sum(k.startswith("""model_ema""" ) for k in keys ) > 100:
   print(
       """In this conversion only the non-EMA weights are extracted. If you want to instead extract the EMA"""
       """ weights (usually better for inference), please make sure to add the `--extract_ema` flag.""" )

  for key in keys:
   UpperCAmelCase__   :					Optional[Any]   				=   checkpoint.pop(__UpperCamelCase )

 UpperCAmelCase__   :					Dict   				=   {}

 UpperCAmelCase__   :					Optional[Any]   				=   unet_state_dict["""time_embed.0.weight"""]
 UpperCAmelCase__   :					Tuple   				=   unet_state_dict["""time_embed.0.bias"""]
 UpperCAmelCase__   :					Any   				=   unet_state_dict["""time_embed.2.weight"""]
 UpperCAmelCase__   :					int   				=   unet_state_dict["""time_embed.2.bias"""]

 if config["class_embed_type"] is None:
  # No parameters to port
  ...
 elif config["class_embed_type"] == "timestep" or config["class_embed_type"] == "projection":
  UpperCAmelCase__   :					Any   				=   unet_state_dict["""label_emb.0.0.weight"""]
  UpperCAmelCase__   :					Tuple   				=   unet_state_dict["""label_emb.0.0.bias"""]
  UpperCAmelCase__   :					int   				=   unet_state_dict["""label_emb.0.2.weight"""]
  UpperCAmelCase__   :					List[Any]   				=   unet_state_dict["""label_emb.0.2.bias"""]
 else:
  raise NotImplementedError(F"Not implemented `class_embed_type`: {config['class_embed_type']}" )

 UpperCAmelCase__   :					Optional[int]   				=   unet_state_dict["""input_blocks.0.0.weight"""]
 UpperCAmelCase__   :					List[str]   				=   unet_state_dict["""input_blocks.0.0.bias"""]

 UpperCAmelCase__   :					Optional[Any]   				=   [v for v in unet_state_dict if v.startswith("""input_blocks.0.1""" )]
 UpperCAmelCase__   :					Optional[int]   				=   renew_attention_paths(__UpperCamelCase )
 UpperCAmelCase__   :					Dict   				=   {"""old""": """input_blocks.0.1""", """new""": """transformer_in"""}
 assign_to_checkpoint(__UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      additional_replacements=[meta_path]							,      config=__UpperCamelCase )

 UpperCAmelCase__   :					Optional[int]   				=   unet_state_dict["""out.0.weight"""]
 UpperCAmelCase__   :					List[str]   				=   unet_state_dict["""out.0.bias"""]
 UpperCAmelCase__   :					Optional[Any]   				=   unet_state_dict["""out.2.weight"""]
 UpperCAmelCase__   :					int   				=   unet_state_dict["""out.2.bias"""]

 # Retrieves the keys for the input blocks only
 UpperCAmelCase__   :					Any   				=   len({""".""".join(layer.split(""".""" )[:2] ) for layer in unet_state_dict if """input_blocks""" in layer} )
 UpperCAmelCase__   :					int   				=   {
     layer_id: [key for key in unet_state_dict if F"input_blocks.{layer_id}" in key]
     for layer_id in range(__UpperCamelCase )
 }

 # Retrieves the keys for the middle blocks only
 UpperCAmelCase__   :					Dict   				=   len({""".""".join(layer.split(""".""" )[:2] ) for layer in unet_state_dict if """middle_block""" in layer} )
 UpperCAmelCase__   :					Optional[Any]   				=   {
     layer_id: [key for key in unet_state_dict if F"middle_block.{layer_id}" in key]
     for layer_id in range(__UpperCamelCase )
 }

 # Retrieves the keys for the output blocks only
 UpperCAmelCase__   :					str   				=   len({""".""".join(layer.split(""".""" )[:2] ) for layer in unet_state_dict if """output_blocks""" in layer} )
 UpperCAmelCase__   :					List[Any]   				=   {
     layer_id: [key for key in unet_state_dict if F"output_blocks.{layer_id}" in key]
     for layer_id in range(__UpperCamelCase )
 }

 for i in range(1							,      __UpperCamelCase ):
  UpperCAmelCase__   :					Dict   				=   (i - 1) // (config["""layers_per_block"""] + 1)
  UpperCAmelCase__   :					List[Any]   				=   (i - 1) % (config["""layers_per_block"""] + 1)

  UpperCAmelCase__   :					List[Any]   				=   [
      key for key in input_blocks[i] if F"input_blocks.{i}.0" in key and F"input_blocks.{i}.0.op" not in key
  ]
  UpperCAmelCase__   :					List[Any]   				=   [key for key in input_blocks[i] if F"input_blocks.{i}.1" in key]
  UpperCAmelCase__   :					List[str]   				=   [key for key in input_blocks[i] if F"input_blocks.{i}.2" in key]

  if F"input_blocks.{i}.op.weight" in unet_state_dict:
   UpperCAmelCase__   :					Tuple   				=   unet_state_dict.pop(
       F"input_blocks.{i}.op.weight" )
   UpperCAmelCase__   :					Tuple   				=   unet_state_dict.pop(
       F"input_blocks.{i}.op.bias" )

  UpperCAmelCase__   :					int   				=   renew_resnet_paths(__UpperCamelCase )
  UpperCAmelCase__   :					List[Any]   				=   {"""old""": F"input_blocks.{i}.0", """new""": F"down_blocks.{block_id}.resnets.{layer_in_block_id}"}
  assign_to_checkpoint(
      __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      additional_replacements=[meta_path]							,      config=__UpperCamelCase )

  UpperCAmelCase__   :					Any   				=   [key for key in resnets if """temopral_conv""" in key]
  UpperCAmelCase__   :					str   				=   renew_temp_conv_paths(__UpperCamelCase )
  UpperCAmelCase__   :					Union[str, Any]   				=   {
      """old""": F"input_blocks.{i}.0.temopral_conv",
      """new""": F"down_blocks.{block_id}.temp_convs.{layer_in_block_id}",
  }
  assign_to_checkpoint(
      __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      additional_replacements=[meta_path]							,      config=__UpperCamelCase )

  if len(__UpperCamelCase ):
   UpperCAmelCase__   :					List[Any]   				=   renew_attention_paths(__UpperCamelCase )
   UpperCAmelCase__   :					str   				=   {"""old""": F"input_blocks.{i}.1", """new""": F"down_blocks.{block_id}.attentions.{layer_in_block_id}"}
   assign_to_checkpoint(
       __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      additional_replacements=[meta_path]							,      config=__UpperCamelCase )

  if len(__UpperCamelCase ):
   UpperCAmelCase__   :					str   				=   renew_attention_paths(__UpperCamelCase )
   UpperCAmelCase__   :					int   				=   {
       """old""": F"input_blocks.{i}.2",
       """new""": F"down_blocks.{block_id}.temp_attentions.{layer_in_block_id}",
   }
   assign_to_checkpoint(
       __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      additional_replacements=[meta_path]							,      config=__UpperCamelCase )

 UpperCAmelCase__   :					Union[str, Any]   				=   middle_blocks[0]
 UpperCAmelCase__   :					Optional[int]   				=   [key for key in resnet_a if """temopral_conv""" in key]
 UpperCAmelCase__   :					Union[str, Any]   				=   middle_blocks[1]
 UpperCAmelCase__   :					List[str]   				=   middle_blocks[2]
 UpperCAmelCase__   :					Union[str, Any]   				=   middle_blocks[3]
 UpperCAmelCase__   :					Optional[Any]   				=   [key for key in resnet_a if """temopral_conv""" in key]

 UpperCAmelCase__   :					Optional[int]   				=   renew_resnet_paths(__UpperCamelCase )
 UpperCAmelCase__   :					Optional[int]   				=   {"""old""": """middle_block.0""", """new""": """mid_block.resnets.0"""}
 assign_to_checkpoint(
     __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      config=__UpperCamelCase							,      additional_replacements=[meta_path] )

 UpperCAmelCase__   :					List[str]   				=   renew_temp_conv_paths(__UpperCamelCase )
 UpperCAmelCase__   :					Optional[int]   				=   {"""old""": """middle_block.0.temopral_conv""", """new""": """mid_block.temp_convs.0"""}
 assign_to_checkpoint(
     __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      config=__UpperCamelCase							,      additional_replacements=[meta_path] )

 UpperCAmelCase__   :					str   				=   renew_resnet_paths(__UpperCamelCase )
 UpperCAmelCase__   :					Tuple   				=   {"""old""": """middle_block.3""", """new""": """mid_block.resnets.1"""}
 assign_to_checkpoint(
     __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      config=__UpperCamelCase							,      additional_replacements=[meta_path] )

 UpperCAmelCase__   :					List[Any]   				=   renew_temp_conv_paths(__UpperCamelCase )
 UpperCAmelCase__   :					Dict   				=   {"""old""": """middle_block.3.temopral_conv""", """new""": """mid_block.temp_convs.1"""}
 assign_to_checkpoint(
     __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      config=__UpperCamelCase							,      additional_replacements=[meta_path] )

 UpperCAmelCase__   :					List[Any]   				=   renew_attention_paths(__UpperCamelCase )
 UpperCAmelCase__   :					Optional[int]   				=   {"""old""": """middle_block.1""", """new""": """mid_block.attentions.0"""}
 assign_to_checkpoint(
     __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      additional_replacements=[meta_path]							,      config=__UpperCamelCase )

 UpperCAmelCase__   :					Any   				=   renew_attention_paths(__UpperCamelCase )
 UpperCAmelCase__   :					str   				=   {"""old""": """middle_block.2""", """new""": """mid_block.temp_attentions.0"""}
 assign_to_checkpoint(
     __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      additional_replacements=[meta_path]							,      config=__UpperCamelCase )

 for i in range(__UpperCamelCase ):
  UpperCAmelCase__   :					int   				=   i // (config["""layers_per_block"""] + 1)
  UpperCAmelCase__   :					Optional[Any]   				=   i % (config["""layers_per_block"""] + 1)
  UpperCAmelCase__   :					Optional[int]   				=   [shave_segments(__UpperCamelCase							,      2 ) for name in output_blocks[i]]
  UpperCAmelCase__   :					str   				=   {}

  for layer in output_block_layers:
   UpperCAmelCase__				, UpperCAmelCase__   :					Optional[int]   				=   layer.split(""".""" )[0], shave_segments(__UpperCamelCase							,      1 )
   if layer_id in output_block_list:
    output_block_list[layer_id].append(__UpperCamelCase )
   else:
    UpperCAmelCase__   :					Dict   				=   [layer_name]

  if len(__UpperCamelCase ) > 1:
   UpperCAmelCase__   :					Optional[int]   				=   [key for key in output_blocks[i] if F"output_blocks.{i}.0" in key]
   UpperCAmelCase__   :					List[str]   				=   [key for key in output_blocks[i] if F"output_blocks.{i}.1" in key]
   UpperCAmelCase__   :					Union[str, Any]   				=   [key for key in output_blocks[i] if F"output_blocks.{i}.2" in key]

   UpperCAmelCase__   :					Tuple   				=   renew_resnet_paths(__UpperCamelCase )
   UpperCAmelCase__   :					str   				=   renew_resnet_paths(__UpperCamelCase )

   UpperCAmelCase__   :					List[Any]   				=   {"""old""": F"output_blocks.{i}.0", """new""": F"up_blocks.{block_id}.resnets.{layer_in_block_id}"}
   assign_to_checkpoint(
       __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      additional_replacements=[meta_path]							,      config=__UpperCamelCase )

   UpperCAmelCase__   :					str   				=   [key for key in resnets if """temopral_conv""" in key]
   UpperCAmelCase__   :					Optional[int]   				=   renew_temp_conv_paths(__UpperCamelCase )
   UpperCAmelCase__   :					Union[str, Any]   				=   {
       """old""": F"output_blocks.{i}.0.temopral_conv",
       """new""": F"up_blocks.{block_id}.temp_convs.{layer_in_block_id}",
   }
   assign_to_checkpoint(
       __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      additional_replacements=[meta_path]							,      config=__UpperCamelCase )

   UpperCAmelCase__   :					Dict   				=   {k: sorted(__UpperCamelCase ) for k, v in output_block_list.items()}
   if ["conv.bias", "conv.weight"] in output_block_list.values():
    UpperCAmelCase__   :					List[str]   				=   list(output_block_list.values() ).index(["""conv.bias""", """conv.weight"""] )
    UpperCAmelCase__   :					Tuple   				=   unet_state_dict[
        F"output_blocks.{i}.{index}.conv.weight"
    ]
    UpperCAmelCase__   :					Tuple   				=   unet_state_dict[
        F"output_blocks.{i}.{index}.conv.bias"
    ]

    # Clear attentions as they have been attributed above.
    if len(__UpperCamelCase ) == 2:
     UpperCAmelCase__   :					List[str]   				=   []

   if len(__UpperCamelCase ):
    UpperCAmelCase__   :					Any   				=   renew_attention_paths(__UpperCamelCase )
    UpperCAmelCase__   :					int   				=   {
        """old""": F"output_blocks.{i}.1",
        """new""": F"up_blocks.{block_id}.attentions.{layer_in_block_id}",
    }
    assign_to_checkpoint(
        __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      additional_replacements=[meta_path]							,      config=__UpperCamelCase )

   if len(__UpperCamelCase ):
    UpperCAmelCase__   :					List[str]   				=   renew_attention_paths(__UpperCamelCase )
    UpperCAmelCase__   :					List[Any]   				=   {
        """old""": F"output_blocks.{i}.2",
        """new""": F"up_blocks.{block_id}.temp_attentions.{layer_in_block_id}",
    }
    assign_to_checkpoint(
        __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      additional_replacements=[meta_path]							,      config=__UpperCamelCase )
  else:
   UpperCAmelCase__   :					int   				=   renew_resnet_paths(__UpperCamelCase							,      n_shave_prefix_segments=1 )
   for path in resnet_0_paths:
    UpperCAmelCase__   :					Optional[Any]   				=   """.""".join(["""output_blocks""", str(__UpperCamelCase ), path["""old"""]] )
    UpperCAmelCase__   :					Union[str, Any]   				=   """.""".join(["""up_blocks""", str(__UpperCamelCase ), """resnets""", str(__UpperCamelCase ), path["""new"""]] )
    UpperCAmelCase__   :					int   				=   unet_state_dict[old_path]

   UpperCAmelCase__   :					Union[str, Any]   				=   [l for l in output_block_layers if """temopral_conv""" in l]
   for path in temopral_conv_paths:
    UpperCAmelCase__   :					Dict   				=   path.split("""temopral_conv.""" )[-1]
    UpperCAmelCase__   :					Union[str, Any]   				=   """.""".join(["""output_blocks""", str(__UpperCamelCase ), str(__UpperCamelCase ), """temopral_conv""", pruned_path] )
    UpperCAmelCase__   :					Optional[int]   				=   """.""".join(["""up_blocks""", str(__UpperCamelCase ), """temp_convs""", str(__UpperCamelCase ), pruned_path] )
    UpperCAmelCase__   :					Union[str, Any]   				=   unet_state_dict[old_path]

 return new_checkpoint


if __name__ == "__main__":
      __UpperCAmelCase	=			argparse.ArgumentParser()

      parser.add_argument(
          '--checkpoint_path', default=None, type=str, required=True, help='Path to the checkpoint to convert.'
      )
      parser.add_argument('--dump_path', default=None, type=str, required=True, help='Path to the output model.')
      __UpperCAmelCase	=			parser.parse_args()

      __UpperCAmelCase	=			torch.load(args.checkpoint_path, map_location='cpu')
      __UpperCAmelCase	=			UNetaDConditionModel()

      __UpperCAmelCase	=			convert_ldm_unet_checkpoint(unet_checkpoint, unet.config)

      __UpperCAmelCase	=			set(unet.state_dict().keys()) - set(converted_ckpt.keys())
      __UpperCAmelCase	=			set(converted_ckpt.keys()) - set(unet.state_dict().keys())

      assert len(diff_a) == len(diff_a) == 0, "Converted weights don't match"

      # load state_dict
      unet.load_state_dict(converted_ckpt)

      unet.save_pretrained(args.dump_path)

      # -- finish converting the unet --








"""simple docstring"""




import hashlib
import importlib.util
import json
import os
import pathlib
from types import ModuleType

import pytest
import requests

__UpperCAmelCase	=			pathlib.Path.cwd().joinpath('project_euler')
__UpperCAmelCase	=			pathlib.Path.cwd().joinpath(
    'scripts', 'project_euler_answers.json'
)

with open(PROJECT_EULER_ANSWERS_PATH) as file_handle:
      __UpperCAmelCase	=			json.load(file_handle)
def 					lowerCAmelCase  (   __UpperCamelCase ):
 '''simple docstring'''





 UpperCAmelCase__   :					Dict   				=   importlib.util.spec_from_file_location(file_path.name							,      str(__UpperCamelCase ) )
 UpperCAmelCase__   :					Optional[Any]   				=   importlib.util.module_from_spec(__UpperCamelCase )  # type: ignore
 spec.loader.exec_module(__UpperCamelCase )  # type: ignore
 return module
def 					lowerCAmelCase  (   ):
 '''simple docstring'''





 UpperCAmelCase__   :					Dict   				=   []
 for problem_dir_path in PROJECT_EULER_DIR_PATH.iterdir():
  if problem_dir_path.is_file() or problem_dir_path.name.startswith("""_""" ):
   continue
  for file_path in problem_dir_path.iterdir():
   if file_path.suffix != ".py" or file_path.name.startswith(("""_""", """test""") ):
    continue
   solution_file_paths.append(__UpperCamelCase )
 return solution_file_paths
def 					lowerCAmelCase  (   ):
 '''simple docstring'''





 with open(os.environ["""GITHUB_EVENT_PATH"""] ) as file:
  UpperCAmelCase__   :					List[Any]   				=   json.load(__UpperCamelCase )
 return event["pull_request"]["url"] + "/files"
def 					lowerCAmelCase  (   ):
 '''simple docstring'''





 UpperCAmelCase__   :					Tuple   				=   []
 UpperCAmelCase__   :					List[str]   				=   {
     """Accept""": """application/vnd.github.v3+json""",
     """Authorization""": """token """ + os.environ["""GITHUB_TOKEN"""],
 }
 UpperCAmelCase__   :					Tuple   				=   requests.get(get_files_url()							,      headers=__UpperCamelCase ).json()
 for file in files:
  UpperCAmelCase__   :					List[str]   				=   pathlib.Path.cwd().joinpath(file["""filename"""] )
  if (
      filepath.suffix != ".py"
      or filepath.name.startswith(("""_""", """test""") )
      or not filepath.name.startswith("""sol""" )
  ):
   continue
  solution_file_paths.append(__UpperCamelCase )
 return solution_file_paths
def 					lowerCAmelCase  (   ):
 '''simple docstring'''





 if os.environ.get("""CI""" ) and os.environ.get("""GITHUB_EVENT_NAME""" ) == "pull_request":
  # Return only if there are any, otherwise default to all solutions
  if filepaths := added_solution_file_path():
   return filepaths
 return all_solution_file_paths()




@pytest.mark.parametrize(
    """solution_path"""							,      collect_solution_file_paths()							,      ids=lambda __UpperCamelCase : F"{path.parent.name}/{path.name}"							,      )
def 					lowerCAmelCase  (   __UpperCamelCase ):
 '''simple docstring'''





 UpperCAmelCase__   :					str   				=   solution_path.parent.name[8:].zfill(3 )
 UpperCAmelCase__   :					str   				=   PROBLEM_ANSWERS[problem_number]
 UpperCAmelCase__   :					int   				=   convert_path_to_module(__UpperCamelCase )
 UpperCAmelCase__   :					str   				=   str(solution_module.solution() )  # type: ignore
 UpperCAmelCase__   :					Optional[Any]   				=   hashlib.shaaaa(answer.encode() ).hexdigest()
 assert (
     answer == expected
 ), F"Expected solution to {problem_number} to have hash {expected}, got {answer}"





