




"""simple docstring"""




import argparse
import json
import math
import os
import time
import traceback
import zipfile
from collections import Counter

import requests







def      __UpperCAmelCase     ( __UpperCamelCase	,				__UpperCamelCase=None	):
			__lowercase			:  Optional[Any]								=       None
			if token is not None:
						__lowercase			:  Tuple								=       {'''Accept''': '''application/vnd.github+json''', '''Authorization''': f"""Bearer {token}"""}

			__lowercase			:  List[str]								=       f"""https://api.github.com/repos/huggingface/transformers/actions/runs/{workflow_run_id}/jobs?per_page=100"""
			__lowercase			:  Optional[Any]								=       requests.get(__UpperCamelCase	,				headers=__UpperCamelCase	).json()
			__lowercase			:  Optional[Any]								=       {}

			try:
						job_links.update({job['''name''']: job['''html_url'''] for job in result['''jobs''']}	)
						__lowercase			:  Dict								=       math.ceil((result['''total_count'''] - 1_00) / 1_00	)

						for i in range(__UpperCamelCase	):
									__lowercase			:  str								=       requests.get(url + f"""&page={i + 2}"""	,				headers=__UpperCamelCase	).json()
									job_links.update({job['''name''']: job['''html_url'''] for job in result['''jobs''']}	)

						return job_links
			except Exception:
						print(f"""Unknown error, could not fetch links:\n{traceback.format_exc()}"""	)

			return {}







def      __UpperCAmelCase     ( __UpperCamelCase	,				__UpperCamelCase=None	):
			__lowercase			:  Any								=       None
			if token is not None:
						__lowercase			:  Optional[Any]								=       {'''Accept''': '''application/vnd.github+json''', '''Authorization''': f"""Bearer {token}"""}

			__lowercase			:  int								=       f"""https://api.github.com/repos/huggingface/transformers/actions/runs/{worflow_run_id}/artifacts?per_page=100"""
			__lowercase			:  List[Any]								=       requests.get(__UpperCamelCase	,				headers=__UpperCamelCase	).json()
			__lowercase			:  Union[str, Any]								=       {}

			try:
						artifacts.update({artifact['''name''']: artifact['''archive_download_url'''] for artifact in result['''artifacts''']}	)
						__lowercase			:  Dict								=       math.ceil((result['''total_count'''] - 1_00) / 1_00	)

						for i in range(__UpperCamelCase	):
									__lowercase			:  Dict								=       requests.get(url + f"""&page={i + 2}"""	,				headers=__UpperCamelCase	).json()
									artifacts.update({artifact['''name''']: artifact['''archive_download_url'''] for artifact in result['''artifacts''']}	)

						return artifacts
			except Exception:
						print(f"""Unknown error, could not fetch links:\n{traceback.format_exc()}"""	)

			return {}







def      __UpperCAmelCase     ( __UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase	):
			__lowercase			:  Optional[int]								=       None
			if token is not None:
						__lowercase			:  Union[str, Any]								=       {'''Accept''': '''application/vnd.github+json''', '''Authorization''': f"""Bearer {token}"""}

			__lowercase			:  Any								=       requests.get(__UpperCamelCase	,				headers=__UpperCamelCase	,				allow_redirects=__UpperCamelCase	)
			__lowercase			:  Optional[int]								=       result.headers['''Location''']
			__lowercase			:  List[str]								=       requests.get(__UpperCamelCase	,				allow_redirects=__UpperCamelCase	)
			__lowercase			:  List[str]								=       os.path.join(__UpperCamelCase	,				f"""{artifact_name}.zip"""	)
			with open(__UpperCamelCase	,				'''wb'''	) as fp:
						fp.write(response.content	)







def      __UpperCAmelCase     ( __UpperCamelCase	,				__UpperCamelCase=None	):
			__lowercase			:  Any								=       []
			__lowercase			:  List[Any]								=       []
			__lowercase			:  Dict								=       None

			with zipfile.ZipFile(__UpperCamelCase	) as z:
						for filename in z.namelist():
									if not os.path.isdir(__UpperCamelCase	):
												# read the file
												if filename in ["failures_line.txt", "summary_short.txt", "job_name.txt"]:
															with z.open(__UpperCamelCase	) as f:
																		for line in f:
																					__lowercase			:  Optional[Any]								=       line.decode('''UTF-8'''	).strip()
																					if filename == "failures_line.txt":
																								try:
																											# `error_line` is the place where `error` occurs
																											__lowercase			:  Any								=       line[: line.index(''': '''	)]
																											__lowercase			:  str								=       line[line.index(''': '''	) + len(''': '''	) :]
																											errors.append([error_line, error]	)
																								except Exception:
																											# skip un-related lines
																											pass
																					elif filename == "summary_short.txt" and line.startswith('''FAILED '''	):
																								# `test` is the test method that failed
																								__lowercase			:  Dict								=       line[len('''FAILED '''	) :]
																								failed_tests.append(__UpperCamelCase	)
																					elif filename == "job_name.txt":
																								__lowercase			:  int								=       line

			if len(__UpperCamelCase	) != len(__UpperCamelCase	):
						raise ValueError(
						    f"""`errors` and `failed_tests` should have the same number of elements. Got {len(__UpperCamelCase	)} for `errors` """
						    f"""and {len(__UpperCamelCase	)} for `failed_tests` instead. The test reports in {artifact_zip_path} have some"""
						    ''' problem.'''	)

			__lowercase			:  List[str]								=       None
			if job_name and job_links:
						__lowercase			:  Optional[Any]								=       job_links.get(__UpperCamelCase	,				__UpperCamelCase	)

			# A list with elements of the form (line of error, error, failed test)
			__lowercase			:  Any								=       [x + [y] + [job_link] for x, y in zip(__UpperCamelCase	,				__UpperCamelCase	)]

			return result







def      __UpperCAmelCase     ( __UpperCamelCase	,				__UpperCamelCase=None	):
			__lowercase			:  Tuple								=       []

			__lowercase			:  Tuple								=       [os.path.join(__UpperCamelCase	,				__UpperCamelCase	) for p in os.listdir(__UpperCamelCase	) if p.endswith('''.zip'''	)]
			for p in paths:
						errors.extend(get_errors_from_single_artifact(__UpperCamelCase	,				job_links=__UpperCamelCase	)	)

			return errors







def      __UpperCAmelCase     ( __UpperCamelCase	,				__UpperCamelCase=None	):
			__lowercase			:  str								=       Counter()
			counter.update([x[1] for x in logs]	)
			__lowercase			:  Dict								=       counter.most_common()
			__lowercase			:  Optional[int]								=       {}
			for error, count in counts:
						if error_filter is None or error not in error_filter:
									__lowercase			:  Tuple								=       {'''count''': count, '''failed_tests''': [(x[2], x[0]) for x in logs if x[1] == error]}

			__lowercase			:  Tuple								=       dict(sorted(r.items()	,				key=lambda __UpperCamelCase	: item[1]["count"]	,				reverse=__UpperCamelCase	)	)
			return r







def      __UpperCAmelCase     ( __UpperCamelCase	):
			__lowercase			:  int								=       test.split('''::'''	)[0]
			if test.startswith('''tests/models/'''	):
						__lowercase			:  Optional[Any]								=       test.split('''/'''	)[2]
			else:
						__lowercase			:  List[Any]								=       None

			return test







def      __UpperCAmelCase     ( __UpperCamelCase	,				__UpperCamelCase=None	):
			__lowercase			:  Dict								=       [(x[0], x[1], get_model(x[2]	)) for x in logs]
			__lowercase			:  List[str]								=       [x for x in logs if x[2] is not None]
			__lowercase			:  Dict								=       {x[2] for x in logs}

			__lowercase			:  Union[str, Any]								=       {}
			for test in tests:
						__lowercase			:  Optional[int]								=       Counter()
						# count by errors in `test`
						counter.update([x[1] for x in logs if x[2] == test]	)
						__lowercase			:  List[str]								=       counter.most_common()
						__lowercase			:  Any								=       {error: count for error, count in counts if (error_filter is None or error not in error_filter)}
						__lowercase			:  Optional[Any]								=       sum(error_counts.values()	)
						if n_errors > 0:
									__lowercase			:  Optional[Any]								=       {'''count''': n_errors, '''errors''': error_counts}

			__lowercase			:  List[Any]								=       dict(sorted(r.items()	,				key=lambda __UpperCamelCase	: item[1]["count"]	,				reverse=__UpperCamelCase	)	)
			return r







def      __UpperCAmelCase     ( __UpperCamelCase	):
			__lowercase			:  Union[str, Any]								=       '''| no. | error | status |'''
			__lowercase			:  Dict								=       '''|-:|:-|:-|'''
			__lowercase			:  int								=       [header, sep]
			for error in reduced_by_error:
						__lowercase			:  int								=       reduced_by_error[error]['''count''']
						__lowercase			:  Union[str, Any]								=       f"""| {count} | {error[:1_00]} |  |"""
						lines.append(__UpperCamelCase	)

			return "\n".join(__UpperCamelCase	)







def      __UpperCAmelCase     ( __UpperCamelCase	):
			__lowercase			:  str								=       '''| model | no. of errors | major error | count |'''
			__lowercase			:  Dict								=       '''|-:|-:|-:|-:|'''
			__lowercase			:  int								=       [header, sep]
			for model in reduced_by_model:
						__lowercase			:  Union[str, Any]								=       reduced_by_model[model]['''count''']
						__lowercase			,__lowercase			:  Tuple								=       list(reduced_by_model[model]['''errors'''].items()	)[0]
						__lowercase			:  Tuple								=       f"""| {model} | {count} | {error[:60]} | {_count} |"""
						lines.append(__UpperCamelCase	)

			return "\n".join(__UpperCamelCase	)


if __name__ == "__main__":
			a_        =       argparse.ArgumentParser()
			# Required parameters
			parser.add_argument('--workflow_run_id', type=str, required=True, help='A GitHub Actions workflow run id.')
			parser.add_argument(
			    '--output_dir',
			    type=str,
			    required=True,
			    help='Where to store the downloaded artifacts and other result files.',
			)
			parser.add_argument('--token', default=None, type=str, help='A token that has actions:read permission.')
			a_        =       parser.parse_args()

			os.makedirs(args.output_dir, exist_ok=True)

			a_        =       get_job_links(args.workflow_run_id, token=args.token)
			a_        =       {}
			# To deal with `workflow_call` event, where a job name is the combination of the job names in the caller and callee.
			# For example, `PyTorch 1.11 / Model tests (models/albert, single-gpu)`.
			if _job_links:
						for k, v in _job_links.items():
									# This is how GitHub actions combine job names.
									if " / " in k:
												a_        =       k.find(' / ')
												a_        =       k[index + len(' / ') :]
									a_        =       v
			with open(os.path.join(args.output_dir, 'job_links.json'), 'w', encoding='UTF-8') as fp:
						json.dump(job_links, fp, ensure_ascii=False, indent=4)

			a_        =       get_artifacts_links(args.workflow_run_id, token=args.token)
			with open(os.path.join(args.output_dir, 'artifacts.json'), 'w', encoding='UTF-8') as fp:
						json.dump(artifacts, fp, ensure_ascii=False, indent=4)

			for idx, (name, url) in enumerate(artifacts.items()):
						download_artifact(name, url, args.output_dir, args.token)
						# Be gentle to GitHub
						time.sleep(1)

			a_        =       get_all_errors(args.output_dir, job_links=job_links)

			# `e[1]` is the error
			a_        =       Counter()
			counter.update([e[1] for e in errors])

			# print the top 30 most common test errors
			a_        =       counter.most_common(3_0)
			for item in most_common:
						print(item)

			with open(os.path.join(args.output_dir, 'errors.json'), 'w', encoding='UTF-8') as fp:
						json.dump(errors, fp, ensure_ascii=False, indent=4)

			a_        =       reduce_by_error(errors)
			a_        =       reduce_by_model(errors)

			a_        =       make_github_table(reduced_by_error)
			a_        =       make_github_table_per_model(reduced_by_model)

			with open(os.path.join(args.output_dir, 'reduced_by_error.txt'), 'w', encoding='UTF-8') as fp:
						fp.write(sa)
			with open(os.path.join(args.output_dir, 'reduced_by_model.txt'), 'w', encoding='UTF-8') as fp:
						fp.write(sa)








import argparse

import requests
import torch
from PIL import Image
from torchvision.transforms import Compose, Normalize, Resize, ToTensor

from transformers import SwinaSRConfig, SwinaSRForImageSuperResolution, SwinaSRImageProcessor





def 		a__      (		_UpperCamelCase      :			List[str]				):
   __lowerCamelCase    				=     SwinaSRConfig()

   if "Swin2SR_ClassicalSR_X4_64" in checkpoint_url:
      __lowerCamelCase    				=     4
   elif "Swin2SR_CompressedSR_X4_48" in checkpoint_url:
      __lowerCamelCase    				=     4
      __lowerCamelCase    				=     48
      __lowerCamelCase    				=     '''pixelshuffle_aux'''
   elif "Swin2SR_Lightweight_X2_64" in checkpoint_url:
      __lowerCamelCase    				=     [6, 6, 6, 6]
      __lowerCamelCase    				=     60
      __lowerCamelCase    				=     [6, 6, 6, 6]
      __lowerCamelCase    				=     '''pixelshuffledirect'''
   elif "Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR" in checkpoint_url:
      __lowerCamelCase    				=     4
      __lowerCamelCase    				=     '''nearest+conv'''
   elif "Swin2SR_Jpeg_dynamic" in checkpoint_url:
      __lowerCamelCase    				=     1
      __lowerCamelCase    				=     1
      __lowerCamelCase    				=     1_26
      __lowerCamelCase    				=     7
      __lowerCamelCase    				=     255.0
      __lowerCamelCase    				=     ''''''

   return config





def 		a__      (		_UpperCamelCase      :			List[Any]			,_UpperCamelCase      :			List[str]				):
   if "patch_embed.proj" in name and "layers" not in name:
      __lowerCamelCase    				=     name.replace('''patch_embed.proj'''			,'''embeddings.patch_embeddings.projection'''				)
   if "patch_embed.norm" in name:
      __lowerCamelCase    				=     name.replace('''patch_embed.norm'''			,'''embeddings.patch_embeddings.layernorm'''				)
   if "layers" in name:
      __lowerCamelCase    				=     name.replace('''layers'''			,'''encoder.stages'''				)
   if "residual_group.blocks" in name:
      __lowerCamelCase    				=     name.replace('''residual_group.blocks'''			,'''layers'''				)
   if "attn.proj" in name:
      __lowerCamelCase    				=     name.replace('''attn.proj'''			,'''attention.output.dense'''				)
   if "attn" in name:
      __lowerCamelCase    				=     name.replace('''attn'''			,'''attention.self'''				)
   if "norm1" in name:
      __lowerCamelCase    				=     name.replace('''norm1'''			,'''layernorm_before'''				)
   if "norm2" in name:
      __lowerCamelCase    				=     name.replace('''norm2'''			,'''layernorm_after'''				)
   if "mlp.fc1" in name:
      __lowerCamelCase    				=     name.replace('''mlp.fc1'''			,'''intermediate.dense'''				)
   if "mlp.fc2" in name:
      __lowerCamelCase    				=     name.replace('''mlp.fc2'''			,'''output.dense'''				)
   if "q_bias" in name:
      __lowerCamelCase    				=     name.replace('''q_bias'''			,'''query.bias'''				)
   if "k_bias" in name:
      __lowerCamelCase    				=     name.replace('''k_bias'''			,'''key.bias'''				)
   if "v_bias" in name:
      __lowerCamelCase    				=     name.replace('''v_bias'''			,'''value.bias'''				)
   if "cpb_mlp" in name:
      __lowerCamelCase    				=     name.replace('''cpb_mlp'''			,'''continuous_position_bias_mlp'''				)
   if "patch_embed.proj" in name:
      __lowerCamelCase    				=     name.replace('''patch_embed.proj'''			,'''patch_embed.projection'''				)

   if name == "norm.weight":
      __lowerCamelCase    				=     '''layernorm.weight'''
   if name == "norm.bias":
      __lowerCamelCase    				=     '''layernorm.bias'''

   if "conv_first" in name:
      __lowerCamelCase    				=     name.replace('''conv_first'''			,'''first_convolution'''				)

   if (
       "upsample" in name
       or "conv_before_upsample" in name
       or "conv_bicubic" in name
       or "conv_up" in name
       or "conv_hr" in name
       or "conv_last" in name
       or "aux" in name
   ):
      # heads
      if "conv_last" in name:
         __lowerCamelCase    				=     name.replace('''conv_last'''			,'''final_convolution'''				)
      if config.upsampler in ["pixelshuffle", "pixelshuffle_aux", "nearest+conv"]:
         if "conv_before_upsample.0" in name:
            __lowerCamelCase    				=     name.replace('''conv_before_upsample.0'''			,'''conv_before_upsample'''				)
         if "upsample.0" in name:
            __lowerCamelCase    				=     name.replace('''upsample.0'''			,'''upsample.convolution_0'''				)
         if "upsample.2" in name:
            __lowerCamelCase    				=     name.replace('''upsample.2'''			,'''upsample.convolution_1'''				)
         __lowerCamelCase    				=     '''upsample.''' + name
      elif config.upsampler == "pixelshuffledirect":
         __lowerCamelCase    				=     name.replace('''upsample.0.weight'''			,'''upsample.conv.weight'''				)
         __lowerCamelCase    				=     name.replace('''upsample.0.bias'''			,'''upsample.conv.bias'''				)
      else:
         pass
   else:
      __lowerCamelCase    				=     '''swin2sr.''' + name

   return name





def 		a__      (		_UpperCamelCase      :			List[Any]			,_UpperCamelCase      :			Union[str, Any]				):
   for key in orig_state_dict.copy().keys():
      __lowerCamelCase    				=     orig_state_dict.pop(_UpperCamelCase				)

      if "qkv" in key:
         __lowerCamelCase    				=     key.split('''.'''				)
         __lowerCamelCase    				=     int(key_split[1]				)
         __lowerCamelCase    				=     int(key_split[4]				)
         __lowerCamelCase    				=     config.embed_dim

         if "weight" in key:
            __lowerCamelCase    				=     val[:dim, :]
            __lowerCamelCase    				=     val[dim : dim * 2, :]
            __lowerCamelCase    				=     val[-dim:, :]
         else:
            __lowerCamelCase    				=     val[:dim]
            __lowerCamelCase    				=     val[dim : dim * 2]
            __lowerCamelCase    				=     val[-dim:]
         pass
      else:
         __lowerCamelCase    				=     val

   return orig_state_dict





def 		a__      (		_UpperCamelCase      :			str			,_UpperCamelCase      :			int			,_UpperCamelCase      :			Any				):
   __lowerCamelCase    				=     get_config(_UpperCamelCase				)
   __lowerCamelCase    				=     SwinaSRForImageSuperResolution(_UpperCamelCase				)
   model.eval()

   __lowerCamelCase    				=     torch.hub.load_state_dict_from_url(_UpperCamelCase			,map_location='''cpu'''				)
   __lowerCamelCase    				=     convert_state_dict(_UpperCamelCase			,_UpperCamelCase				)
   __lowerCamelCase				,__lowerCamelCase    				=     model.load_state_dict(_UpperCamelCase			,strict=_UpperCamelCase				)

   if len(_UpperCamelCase				) > 0:
      raise ValueError('''Missing keys when converting: {}'''.format(_UpperCamelCase				)				)
   for key in unexpected_keys:
      if not ("relative_position_index" in key or "relative_coords_table" in key or "self_mask" in key):
         raise ValueError(F"""Unexpected key {key} in state_dict"""				)

    # verify values
   __lowerCamelCase    				=     '''https://github.com/mv-lab/swin2sr/blob/main/testsets/real-inputs/shanghai.jpg?raw=true'''
   __lowerCamelCase    				=     Image.open(requests.get(_UpperCamelCase			,stream=_UpperCamelCase				).raw				).convert('''RGB'''				)
   __lowerCamelCase    				=     SwinaSRImageProcessor()
   # pixel_values = processor(image, return_tensors="pt").pixel_values

   __lowerCamelCase    				=     1_26 if '''Jpeg''' in checkpoint_url else 2_56
   __lowerCamelCase    				=     Compose(
       [
           Resize((image_size, image_size)				),
           ToTensor(),
           Normalize(mean=[0.485, 0.456, 0.406]			,std=[0.229, 0.224, 0.225]				),
       ]				)
   __lowerCamelCase    				=     transforms(_UpperCamelCase				).unsqueeze(0				)

   if config.num_channels == 1:
      __lowerCamelCase    				=     pixel_values[:, 0, :, :].unsqueeze(1				)

   __lowerCamelCase    				=     model(_UpperCamelCase				)

   # assert values
   if "Swin2SR_ClassicalSR_X2_64" in checkpoint_url:
      __lowerCamelCase    				=     torch.Size([1, 3, 5_12, 5_12]				)
      __lowerCamelCase    				=     torch.tensor(
          [[-0.7_087, -0.7_138, -0.6_721], [-0.8_340, -0.8_095, -0.7_298], [-0.9_149, -0.8_414, -0.7_940]]				)
   elif "Swin2SR_ClassicalSR_X4_64" in checkpoint_url:
      __lowerCamelCase    				=     torch.Size([1, 3, 10_24, 10_24]				)
      __lowerCamelCase    				=     torch.tensor(
          [[-0.7_775, -0.8_105, -0.8_933], [-0.7_764, -0.8_356, -0.9_225], [-0.7_976, -0.8_686, -0.9_579]]				)
   elif "Swin2SR_CompressedSR_X4_48" in checkpoint_url:
      # TODO values didn't match exactly here
      __lowerCamelCase    				=     torch.Size([1, 3, 10_24, 10_24]				)
      __lowerCamelCase    				=     torch.tensor(
          [[-0.8_035, -0.7_504, -0.7_491], [-0.8_538, -0.8_124, -0.7_782], [-0.8_804, -0.8_651, -0.8_493]]				)
   elif "Swin2SR_Lightweight_X2_64" in checkpoint_url:
      __lowerCamelCase    				=     torch.Size([1, 3, 5_12, 5_12]				)
      __lowerCamelCase    				=     torch.tensor(
          [[-0.7_669, -0.8_662, -0.8_767], [-0.8_810, -0.9_962, -0.9_820], [-0.9_340, -1.0_322, -1.1_149]]				)
   elif "Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR" in checkpoint_url:
      __lowerCamelCase    				=     torch.Size([1, 3, 10_24, 10_24]				)
      __lowerCamelCase    				=     torch.tensor(
          [[-0.5_238, -0.5_557, -0.6_321], [-0.6_016, -0.5_903, -0.6_391], [-0.6_244, -0.6_334, -0.6_889]]				)

   assert (
       outputs.reconstruction.shape == expected_shape
   ), F"""Shape of reconstruction should be {expected_shape}, but is {outputs.reconstruction.shape}"""
   assert torch.allclose(outputs.reconstruction[0, 0, :3, :3]			,_UpperCamelCase			,atol=1e-3				)
   print('''Looks ok!'''				)

   __lowerCamelCase    				=     {
       '''https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_ClassicalSR_X2_64.pth''': (
           '''swin2SR-classical-sr-x2-64'''
       ),
       '''https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_ClassicalSR_X4_64.pth''': (
           '''swin2SR-classical-sr-x4-64'''
       ),
       '''https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_CompressedSR_X4_48.pth''': (
           '''swin2SR-compressed-sr-x4-48'''
       ),
       '''https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_Lightweight_X2_64.pth''': (
           '''swin2SR-lightweight-x2-64'''
       ),
       '''https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR.pth''': (
           '''swin2SR-realworld-sr-x4-64-bsrgan-psnr'''
       ),
   }
   __lowerCamelCase    				=     url_to_name[checkpoint_url]

   if pytorch_dump_folder_path is not None:
      print(F"""Saving model {model_name} to {pytorch_dump_folder_path}"""				)
      model.save_pretrained(_UpperCamelCase				)
      print(F"""Saving image processor to {pytorch_dump_folder_path}"""				)
      processor.save_pretrained(_UpperCamelCase				)

   if push_to_hub:
      model.push_to_hub(F"""caidas/{model_name}"""				)
      processor.push_to_hub(F"""caidas/{model_name}"""				)


if __name__ == "__main__":
  a_								=       argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      """--checkpoint_url""",
      default="""https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_ClassicalSR_X2_64.pth""",
      type=str,
      help="""URL of the original Swin2SR checkpoint you'd like to convert.""",
  )
  parser.add_argument(
      """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
  )
  parser.add_argument("""--push_to_hub""", action="""store_true""", help="""Whether to push the converted model to the hub.""")

  a_								=       parser.parse_args()
  convert_swinasr_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)






