





"""simple docstring"""
import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all image processors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


__UpperCamelCase     :						Any						       =  logging.get_logger(__name__)

__UpperCamelCase     :						List[str]						       =  OrderedDict(
    [
        ('''align''', '''EfficientNetImageProcessor'''),
        ('''beit''', '''BeitImageProcessor'''),
        ('''bit''', '''BitImageProcessor'''),
        ('''blip''', '''BlipImageProcessor'''),
        ('''blip-2''', '''BlipImageProcessor'''),
        ('''bridgetower''', '''BridgeTowerImageProcessor'''),
        ('''chinese_clip''', '''ChineseCLIPImageProcessor'''),
        ('''clip''', '''CLIPImageProcessor'''),
        ('''clipseg''', '''ViTImageProcessor'''),
        ('''conditional_detr''', '''ConditionalDetrImageProcessor'''),
        ('''convnext''', '''ConvNextImageProcessor'''),
        ('''convnextv2''', '''ConvNextImageProcessor'''),
        ('''cvt''', '''ConvNextImageProcessor'''),
        ('''data2vec-vision''', '''BeitImageProcessor'''),
        ('''deformable_detr''', '''DeformableDetrImageProcessor'''),
        ('''deit''', '''DeiTImageProcessor'''),
        ('''deta''', '''DetaImageProcessor'''),
        ('''detr''', '''DetrImageProcessor'''),
        ('''dinat''', '''ViTImageProcessor'''),
        ('''donut-swin''', '''DonutImageProcessor'''),
        ('''dpt''', '''DPTImageProcessor'''),
        ('''efficientformer''', '''EfficientFormerImageProcessor'''),
        ('''efficientnet''', '''EfficientNetImageProcessor'''),
        ('''flava''', '''FlavaImageProcessor'''),
        ('''focalnet''', '''BitImageProcessor'''),
        ('''git''', '''CLIPImageProcessor'''),
        ('''glpn''', '''GLPNImageProcessor'''),
        ('''groupvit''', '''CLIPImageProcessor'''),
        ('''imagegpt''', '''ImageGPTImageProcessor'''),
        ('''instructblip''', '''BlipImageProcessor'''),
        ('''layoutlmv2''', '''LayoutLMv2ImageProcessor'''),
        ('''layoutlmv3''', '''LayoutLMv3ImageProcessor'''),
        ('''levit''', '''LevitImageProcessor'''),
        ('''mask2former''', '''Mask2FormerImageProcessor'''),
        ('''maskformer''', '''MaskFormerImageProcessor'''),
        ('''mgp-str''', '''ViTImageProcessor'''),
        ('''mobilenet_v1''', '''MobileNetV1ImageProcessor'''),
        ('''mobilenet_v2''', '''MobileNetV2ImageProcessor'''),
        ('''mobilevit''', '''MobileViTImageProcessor'''),
        ('''mobilevit''', '''MobileViTImageProcessor'''),
        ('''mobilevitv2''', '''MobileViTImageProcessor'''),
        ('''nat''', '''ViTImageProcessor'''),
        ('''oneformer''', '''OneFormerImageProcessor'''),
        ('''owlvit''', '''OwlViTImageProcessor'''),
        ('''perceiver''', '''PerceiverImageProcessor'''),
        ('''pix2struct''', '''Pix2StructImageProcessor'''),
        ('''poolformer''', '''PoolFormerImageProcessor'''),
        ('''regnet''', '''ConvNextImageProcessor'''),
        ('''resnet''', '''ConvNextImageProcessor'''),
        ('''sam''', '''SamImageProcessor'''),
        ('''segformer''', '''SegformerImageProcessor'''),
        ('''swiftformer''', '''ViTImageProcessor'''),
        ('''swin''', '''ViTImageProcessor'''),
        ('''swin2sr''', '''Swin2SRImageProcessor'''),
        ('''swinv2''', '''ViTImageProcessor'''),
        ('''table-transformer''', '''DetrImageProcessor'''),
        ('''timesformer''', '''VideoMAEImageProcessor'''),
        ('''tvlt''', '''TvltImageProcessor'''),
        ('''upernet''', '''SegformerImageProcessor'''),
        ('''van''', '''ConvNextImageProcessor'''),
        ('''videomae''', '''VideoMAEImageProcessor'''),
        ('''vilt''', '''ViltImageProcessor'''),
        ('''vit''', '''ViTImageProcessor'''),
        ('''vit_hybrid''', '''ViTHybridImageProcessor'''),
        ('''vit_mae''', '''ViTImageProcessor'''),
        ('''vit_msn''', '''ViTImageProcessor'''),
        ('''xclip''', '''CLIPImageProcessor'''),
        ('''yolos''', '''YolosImageProcessor'''),
    ]
)

__UpperCamelCase     :						Optional[int]						       =  _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)

def 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    str			):
 for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
  if class_name in extractors:
   lowerCAmelCase    				= model_type_to_module_name(_UpperCAmelCase			)

   lowerCAmelCase    				= importlib.import_module(F'.{module_name}'  ,     'transformers.models'			)
   try:
    return getattr(_UpperCAmelCase  ,     _UpperCAmelCase			)
   except AttributeError:
    continue

 for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
  if getattr(_UpperCAmelCase  ,     '__name__'  ,     _UpperCAmelCase			) == class_name:
   return extractor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
 lowerCAmelCase    				= importlib.import_module('transformers'			)
 if hasattr(_UpperCAmelCase  ,     _UpperCAmelCase			):
  return getattr(_UpperCAmelCase  ,     _UpperCAmelCase			)

 return None

def 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    Union[str, os.PathLike]  ,     _UpperCAmelCase					:    Optional[Union[str, os.PathLike]] = None  ,     _UpperCAmelCase					:    bool = False  ,     _UpperCAmelCase					:    bool = False  ,     _UpperCAmelCase					:    Optional[Dict[str, str]] = None  ,     _UpperCAmelCase					:    Optional[Union[bool, str]] = None  ,     _UpperCAmelCase					:    Optional[str] = None  ,     _UpperCAmelCase					:    bool = False  ,     **_UpperCAmelCase					:    List[Any]  ,     ):
 lowerCAmelCase    				= get_file_from_repo(
     _UpperCAmelCase  ,     _UpperCAmelCase  ,     cache_dir=_UpperCAmelCase  ,     force_download=_UpperCAmelCase  ,     resume_download=_UpperCAmelCase  ,     proxies=_UpperCAmelCase  ,     use_auth_token=_UpperCAmelCase  ,     revision=_UpperCAmelCase  ,     local_files_only=_UpperCAmelCase  ,     )
 if resolved_config_file is None:
  logger.info(
      'Could not locate the image processor configuration file, will try to use the model config instead.'			)
  return {}

 with open(_UpperCAmelCase  ,     encoding='utf-8'			) as reader:
  return json.load(_UpperCAmelCase			)







class       a							:



 def __init__(     self     ):







  """simple docstring"""






  raise EnvironmentError(
      'AutoImageProcessor is designed to be instantiated '
      'using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.'     )



 @classmethod
 @replace_list_option_in_docstrings(_snake_case     )
 def    UpperCamelCase__  (     cls				,       _snake_case				,       **_snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= kwargs.pop('config'				,       _snake_case     )
  lowerCAmelCase    				= kwargs.pop('trust_remote_code'				,       _snake_case     )
  lowerCAmelCase    				= True

  lowerCAmelCase				,lowerCAmelCase    				= ImageProcessingMixin.get_image_processor_dict(_snake_case				,       **_snake_case     )
  lowerCAmelCase    				= config_dict.get('image_processor_type'				,       _snake_case     )
  lowerCAmelCase    				= None
  if "AutoImageProcessor" in config_dict.get('auto_map'				,       {}     ):
   lowerCAmelCase    				= config_dict['auto_map']['AutoImageProcessor']

  # If we still don't have the image processor class, check if we're loading from a previous feature extractor config
  # and if so, infer the image processor class from there.
  if image_processor_class is None and image_processor_auto_map is None:
   lowerCAmelCase    				= config_dict.pop('feature_extractor_type'				,       _snake_case     )
   if feature_extractor_class is not None:
    logger.warning(
        'Could not find image processor class in the image processor config or the model config. Loading'
        ' based on pattern matching with the model\'s feature extractor configuration.'     )
    lowerCAmelCase    				= feature_extractor_class.replace('FeatureExtractor'				,       'ImageProcessor'     )
   if "AutoFeatureExtractor" in config_dict.get('auto_map'				,       {}     ):
    lowerCAmelCase    				= config_dict['auto_map']['AutoFeatureExtractor']
    lowerCAmelCase    				= feature_extractor_auto_map.replace('FeatureExtractor'				,       'ImageProcessor'     )
    logger.warning(
        'Could not find image processor auto map in the image processor config or the model config.'
        ' Loading based on pattern matching with the model\'s feature extractor configuration.'     )

        # If we don't find the image processor class in the image processor config, let's try the model config.
  if image_processor_class is None and image_processor_auto_map is None:
   if not isinstance(_snake_case				,       _snake_case     ):
    lowerCAmelCase    				= AutoConfig.from_pretrained(_snake_case				,       **_snake_case     )
   # It could be in `config.image_processor_type``
   lowerCAmelCase    				= getattr(_snake_case				,       'image_processor_type'				,       _snake_case     )
   if hasattr(_snake_case				,       'auto_map'     ) and "AutoImageProcessor" in config.auto_map:
    lowerCAmelCase    				= config.auto_map['AutoImageProcessor']

  if image_processor_class is not None:
   lowerCAmelCase    				= image_processor_class_from_name(_snake_case     )

  lowerCAmelCase    				= image_processor_auto_map is not None
  lowerCAmelCase    				= image_processor_class is not None or type(_snake_case     ) in IMAGE_PROCESSOR_MAPPING
  lowerCAmelCase    				= resolve_trust_remote_code(
      _snake_case				,       _snake_case				,       _snake_case				,       _snake_case     )

  if has_remote_code and trust_remote_code:
   lowerCAmelCase    				= get_class_from_dynamic_module(
       _snake_case				,       _snake_case				,       **_snake_case     )
   lowerCAmelCase    				= kwargs.pop('code_revision'				,       _snake_case     )
   if os.path.isdir(_snake_case     ):
    image_processor_class.register_for_auto_class()
   return image_processor_class.from_dict(_snake_case				,       **_snake_case     )
  elif image_processor_class is not None:
   return image_processor_class.from_dict(_snake_case				,       **_snake_case     )
  # Last try: we use the IMAGE_PROCESSOR_MAPPING.
  elif type(_snake_case     ) in IMAGE_PROCESSOR_MAPPING:
   lowerCAmelCase    				= IMAGE_PROCESSOR_MAPPING[type(_snake_case     )]
   return image_processor_class.from_dict(_snake_case				,       **_snake_case     )

  raise ValueError(
      F'Unrecognized image processor in {pretrained_model_name_or_path}. Should have a '
      F'`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following '
      F'`model_type` keys in its {CONFIG_NAME}: {", ".join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys()     )}'     )



 @staticmethod
 def    UpperCamelCase__  (     _snake_case				,       _snake_case     ):







  """simple docstring"""






  IMAGE_PROCESSOR_MAPPING.register(_snake_case				,       _snake_case     )












"""simple docstring"""
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 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    Any			):
 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    				= 126
  lowerCAmelCase    				= 7
  lowerCAmelCase    				= 255.0
  lowerCAmelCase    				= ''

 return config

def 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    Tuple  ,     _UpperCAmelCase					:    Union[str, Any]			):
 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 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    Any  ,     _UpperCAmelCase					:    Dict			):
 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 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    Tuple  ,     _UpperCAmelCase					:    Optional[Any]  ,     _UpperCAmelCase					:    Tuple			):
 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    				= 126 if 'Jpeg' in checkpoint_url else 256
 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, 512, 512]			)
  lowerCAmelCase    				= torch.tensor(
      [[-0.7087, -0.7138, -0.6721], [-0.8340, -0.8095, -0.7298], [-0.9149, -0.8414, -0.7940]]			)
 elif "Swin2SR_ClassicalSR_X4_64" in checkpoint_url:
  lowerCAmelCase    				= torch.Size([1, 3, 1024, 1024]			)
  lowerCAmelCase    				= torch.tensor(
      [[-0.7775, -0.8105, -0.8933], [-0.7764, -0.8356, -0.9225], [-0.7976, -0.8686, -0.9579]]			)
 elif "Swin2SR_CompressedSR_X4_48" in checkpoint_url:
  # TODO values didn't match exactly here
  lowerCAmelCase    				= torch.Size([1, 3, 1024, 1024]			)
  lowerCAmelCase    				= torch.tensor(
      [[-0.8035, -0.7504, -0.7491], [-0.8538, -0.8124, -0.7782], [-0.8804, -0.8651, -0.8493]]			)
 elif "Swin2SR_Lightweight_X2_64" in checkpoint_url:
  lowerCAmelCase    				= torch.Size([1, 3, 512, 512]			)
  lowerCAmelCase    				= torch.tensor(
      [[-0.7669, -0.8662, -0.8767], [-0.8810, -0.9962, -0.9820], [-0.9340, -1.0322, -1.1149]]			)
 elif "Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR" in checkpoint_url:
  lowerCAmelCase    				= torch.Size([1, 3, 1024, 1024]			)
  lowerCAmelCase    				= torch.tensor(
      [[-0.5238, -0.5557, -0.6321], [-0.6016, -0.5903, -0.6391], [-0.6244, -0.6334, -0.6889]]			)

 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__":
       __UpperCamelCase     :						Any						       =  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.''')

       __UpperCamelCase     :						Optional[int]						       =  parser.parse_args()
       convert_swinasr_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)





