

'''simple docstring'''







import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
__lowerCamelCase									=     logging.get_logger(__name__)
def    UpperCAmelCase__     (   UpperCAmelCase__					)      ->      int:
       A_						       =   SwinConfig(
           embed_dim=1_92,							depths=(2, 2, 18, 2),							num_heads=(6, 12, 24, 48),							window_size=12,							out_features=["""stage2""", """stage3""", """stage4"""],							)

       A_						       =   DetaConfig(
           backbone_config=UpperCAmelCase__,							num_queries=9_00,							encoder_ffn_dim=20_48,							decoder_ffn_dim=20_48,							num_feature_levels=5,							assign_first_stage=UpperCAmelCase__,							with_box_refine=UpperCAmelCase__,							two_stage=UpperCAmelCase__,							)

       # set labels
       A_						       =   """huggingface/label-files"""
       if "o365" in model_name:
              A_						       =   3_66
              A_						       =   """object365-id2label.json"""
       else:
              A_						       =   91
              A_						       =   """coco-detection-id2label.json"""

       A_						       =   num_labels
       A_						       =   json.load(open(cached_download(hf_hub_url(UpperCAmelCase__,							UpperCAmelCase__,							repo_type="""dataset"""					)					),							"""r"""					)					)
       A_						       =   {int(UpperCAmelCase__					): v for k, v in idalabel.items()}
       A_						       =   idalabel
       A_						       =   {v: k for k, v in idalabel.items()}

       return config
def    UpperCAmelCase__     (   UpperCAmelCase__					)      ->      Optional[Any]:
       A_						       =   []

       # stem
       # fmt: off
       rename_keys.append(("""backbone.0.body.patch_embed.proj.weight""", """model.backbone.model.embeddings.patch_embeddings.projection.weight""")					)
       rename_keys.append(("""backbone.0.body.patch_embed.proj.bias""", """model.backbone.model.embeddings.patch_embeddings.projection.bias""")					)
       rename_keys.append(("""backbone.0.body.patch_embed.norm.weight""", """model.backbone.model.embeddings.norm.weight""")					)
       rename_keys.append(("""backbone.0.body.patch_embed.norm.bias""", """model.backbone.model.embeddings.norm.bias""")					)
       # stages
       for i in range(len(config.backbone_config.depths					)					):
              for j in range(config.backbone_config.depths[i]					):
                     rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.norm1.weight''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.norm1.bias''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.norm2.weight''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.norm2.bias''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias''', F'''model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias''')					)

              if i < 3:
                     rename_keys.append((F'''backbone.0.body.layers.{i}.downsample.reduction.weight''', F'''model.backbone.model.encoder.layers.{i}.downsample.reduction.weight''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.downsample.norm.weight''', F'''model.backbone.model.encoder.layers.{i}.downsample.norm.weight''')					)
                     rename_keys.append((F'''backbone.0.body.layers.{i}.downsample.norm.bias''', F'''model.backbone.model.encoder.layers.{i}.downsample.norm.bias''')					)

       rename_keys.append(("""backbone.0.body.norm1.weight""", """model.backbone.model.hidden_states_norms.stage2.weight""")					)
       rename_keys.append(("""backbone.0.body.norm1.bias""", """model.backbone.model.hidden_states_norms.stage2.bias""")					)
       rename_keys.append(("""backbone.0.body.norm2.weight""", """model.backbone.model.hidden_states_norms.stage3.weight""")					)
       rename_keys.append(("""backbone.0.body.norm2.bias""", """model.backbone.model.hidden_states_norms.stage3.bias""")					)
       rename_keys.append(("""backbone.0.body.norm3.weight""", """model.backbone.model.hidden_states_norms.stage4.weight""")					)
       rename_keys.append(("""backbone.0.body.norm3.bias""", """model.backbone.model.hidden_states_norms.stage4.bias""")					)

       # transformer encoder
       for i in range(config.encoder_layers					):
              rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight''', F'''model.encoder.layers.{i}.self_attn.sampling_offsets.weight''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias''', F'''model.encoder.layers.{i}.self_attn.sampling_offsets.bias''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.attention_weights.weight''', F'''model.encoder.layers.{i}.self_attn.attention_weights.weight''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.attention_weights.bias''', F'''model.encoder.layers.{i}.self_attn.attention_weights.bias''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.value_proj.weight''', F'''model.encoder.layers.{i}.self_attn.value_proj.weight''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.value_proj.bias''', F'''model.encoder.layers.{i}.self_attn.value_proj.bias''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.output_proj.weight''', F'''model.encoder.layers.{i}.self_attn.output_proj.weight''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.output_proj.bias''', F'''model.encoder.layers.{i}.self_attn.output_proj.bias''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.norm1.weight''', F'''model.encoder.layers.{i}.self_attn_layer_norm.weight''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.norm1.bias''', F'''model.encoder.layers.{i}.self_attn_layer_norm.bias''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.linear1.weight''', F'''model.encoder.layers.{i}.fc1.weight''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.linear1.bias''', F'''model.encoder.layers.{i}.fc1.bias''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.linear2.weight''', F'''model.encoder.layers.{i}.fc2.weight''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.linear2.bias''', F'''model.encoder.layers.{i}.fc2.bias''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.norm2.weight''', F'''model.encoder.layers.{i}.final_layer_norm.weight''')					)
              rename_keys.append((F'''transformer.encoder.layers.{i}.norm2.bias''', F'''model.encoder.layers.{i}.final_layer_norm.bias''')					)

       # transformer decoder
       for i in range(config.decoder_layers					):
              rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight''', F'''model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias''', F'''model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.attention_weights.weight''', F'''model.decoder.layers.{i}.encoder_attn.attention_weights.weight''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.attention_weights.bias''', F'''model.decoder.layers.{i}.encoder_attn.attention_weights.bias''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.value_proj.weight''', F'''model.decoder.layers.{i}.encoder_attn.value_proj.weight''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.value_proj.bias''', F'''model.decoder.layers.{i}.encoder_attn.value_proj.bias''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.output_proj.weight''', F'''model.decoder.layers.{i}.encoder_attn.output_proj.weight''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.output_proj.bias''', F'''model.decoder.layers.{i}.encoder_attn.output_proj.bias''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.norm1.weight''', F'''model.decoder.layers.{i}.encoder_attn_layer_norm.weight''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.norm1.bias''', F'''model.decoder.layers.{i}.encoder_attn_layer_norm.bias''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.self_attn.out_proj.weight''', F'''model.decoder.layers.{i}.self_attn.out_proj.weight''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.self_attn.out_proj.bias''', F'''model.decoder.layers.{i}.self_attn.out_proj.bias''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.norm2.weight''', F'''model.decoder.layers.{i}.self_attn_layer_norm.weight''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.norm2.bias''', F'''model.decoder.layers.{i}.self_attn_layer_norm.bias''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.linear1.weight''', F'''model.decoder.layers.{i}.fc1.weight''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.linear1.bias''', F'''model.decoder.layers.{i}.fc1.bias''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.linear2.weight''', F'''model.decoder.layers.{i}.fc2.weight''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.linear2.bias''', F'''model.decoder.layers.{i}.fc2.bias''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.norm3.weight''', F'''model.decoder.layers.{i}.final_layer_norm.weight''')					)
              rename_keys.append((F'''transformer.decoder.layers.{i}.norm3.bias''', F'''model.decoder.layers.{i}.final_layer_norm.bias''')					)

       # fmt: on

       return rename_keys
def    UpperCAmelCase__     (   UpperCAmelCase__,							UpperCAmelCase__,							UpperCAmelCase__					)      ->      Union[str, Any]:
       A_						       =   dct.pop(UpperCAmelCase__					)
       A_						       =   val
def    UpperCAmelCase__     (   UpperCAmelCase__,							UpperCAmelCase__					)      ->      Tuple:
       A_						       =   [int(backbone_config.embed_dim * 2**i					) for i in range(len(backbone_config.depths					)					)]
       for i in range(len(backbone_config.depths					)					):
              A_						       =   num_features[i]
              for j in range(backbone_config.depths[i]					):
                     # fmt: off
                     # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
                     A_						       =   state_dict.pop(F'''backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight'''					)
                     A_						       =   state_dict.pop(F'''backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias'''					)
                     # next, add query, keys and values (in that order) to the state dict
                     A_						       =   in_proj_weight[:dim, :]
                     A_						       =   in_proj_bias[: dim]
                     A_						       =   in_proj_weight[
                         dim : dim * 2, :
                     ]
                     A_						       =   in_proj_bias[
                         dim : dim * 2
                     ]
                     A_						       =   in_proj_weight[
                         -dim :, :
                     ]
                     A_						       =   in_proj_bias[-dim :]
                     # fmt: on
def    UpperCAmelCase__     (   UpperCAmelCase__,							UpperCAmelCase__					)      ->      Dict:
       # transformer decoder self-attention layers
       A_						       =   config.d_model
       for i in range(config.decoder_layers					):
              # read in weights + bias of input projection layer of self-attention
              A_						       =   state_dict.pop(F'''transformer.decoder.layers.{i}.self_attn.in_proj_weight'''					)
              A_						       =   state_dict.pop(F'''transformer.decoder.layers.{i}.self_attn.in_proj_bias'''					)
              # next, add query, keys and values (in that order) to the state dict
              A_						       =   in_proj_weight[:hidden_size, :]
              A_						       =   in_proj_bias[:hidden_size]
              A_						       =   in_proj_weight[
                  hidden_size : hidden_size * 2, :
              ]
              A_						       =   in_proj_bias[hidden_size : hidden_size * 2]
              A_						       =   in_proj_weight[-hidden_size:, :]
              A_						       =   in_proj_bias[-hidden_size:]
def    UpperCAmelCase__     (   )      ->      Optional[Any]:
       A_						       =   """http://images.cocodataset.org/val2017/000000039769.jpg"""
       A_						       =   Image.open(requests.get(UpperCAmelCase__,							stream=UpperCAmelCase__					).raw					)

       return im
@torch.no_grad()
def    UpperCAmelCase__     (   UpperCAmelCase__,							UpperCAmelCase__,							UpperCAmelCase__					)      ->      Optional[int]:
       A_						       =   get_deta_config(UpperCAmelCase__					)

       # load original state dict
       if model_name == "deta-swin-large":
              A_						       =   hf_hub_download(repo_id="""nielsr/deta-checkpoints""",							filename="""adet_swin_ft.pth"""					)
       elif model_name == "deta-swin-large-o365":
              A_						       =   hf_hub_download(repo_id="""jozhang97/deta-swin-l-o365""",							filename="""deta_swin_pt_o365.pth"""					)
       else:
              raise ValueError(F'''Model name {model_name} not supported'''					)

       A_						       =   torch.load(UpperCAmelCase__,							map_location="""cpu"""					)["""model"""]

       # original state dict
       for name, param in state_dict.items():
              print(UpperCAmelCase__,							param.shape					)

       # rename keys
       A_						       =   create_rename_keys(UpperCAmelCase__					)
       for src, dest in rename_keys:
              rename_key(UpperCAmelCase__,							UpperCAmelCase__,							UpperCAmelCase__					)
       read_in_swin_q_k_v(UpperCAmelCase__,							config.backbone_config					)
       read_in_decoder_q_k_v(UpperCAmelCase__,							UpperCAmelCase__					)

       # fix some prefixes
       for key in state_dict.copy().keys():
              if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
                     A_						       =   state_dict.pop(UpperCAmelCase__					)
                     A_						       =   val
              if "input_proj" in key:
                     A_						       =   state_dict.pop(UpperCAmelCase__					)
                     A_						       =   val
              if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
                     A_						       =   state_dict.pop(UpperCAmelCase__					)
                     A_						       =   val

    # finally, create HuggingFace model and load state dict
       A_						       =   DetaForObjectDetection(UpperCAmelCase__					)
       model.load_state_dict(UpperCAmelCase__					)
       model.eval()

       A_						       =   """cuda""" if torch.cuda.is_available() else """cpu"""
       model.to(UpperCAmelCase__					)

       # load image processor
       A_						       =   DetaImageProcessor(format="""coco_detection"""					)

       # verify our conversion on image
       A_						       =   prepare_img()
       A_						       =   processor(images=UpperCAmelCase__,							return_tensors="""pt"""					)
       A_						       =   encoding["""pixel_values"""]
       A_						       =   model(pixel_values.to(UpperCAmelCase__					)					)

       # verify logits
       print("""Logits:""",							outputs.logits[0, :3, :3]					)
       print("""Boxes:""",							outputs.pred_boxes[0, :3, :3]					)
       if model_name == "deta-swin-large":
              A_						       =   torch.tensor(
                  [[-7.6_308, -2.8_485, -5.3_737], [-7.2_037, -4.5_505, -4.8_027], [-7.2_943, -4.2_611, -4.6_617]]					)
              A_						       =   torch.tensor([[0.4_987, 0.4_969, 0.9_999], [0.2_549, 0.5_498, 0.4_805], [0.5_498, 0.2_757, 0.0_569]]					)
       elif model_name == "deta-swin-large-o365":
              A_						       =   torch.tensor(
                  [[-8.0_122, -3.5_720, -4.9_717], [-8.1_547, -3.6_886, -4.6_389], [-7.6_610, -3.6_194, -5.0_134]]					)
              A_						       =   torch.tensor([[0.2_523, 0.5_549, 0.4_881], [0.7_715, 0.4_149, 0.4_601], [0.5_503, 0.2_753, 0.0_575]]					)
       assert torch.allclose(outputs.logits[0, :3, :3],							expected_logits.to(UpperCAmelCase__					),							atol=1e-4					)
       assert torch.allclose(outputs.pred_boxes[0, :3, :3],							expected_boxes.to(UpperCAmelCase__					),							atol=1e-4					)
       print("""Everything ok!"""					)

       if pytorch_dump_folder_path:
              # Save model and processor
              logger.info(F'''Saving PyTorch model and processor to {pytorch_dump_folder_path}...'''					)
              Path(UpperCAmelCase__					).mkdir(exist_ok=UpperCAmelCase__					)
              model.save_pretrained(UpperCAmelCase__					)
              processor.save_pretrained(UpperCAmelCase__					)

       # Push to hub
       if push_to_hub:
              print("""Pushing model and processor to hub..."""					)
              model.push_to_hub(F'''jozhang97/{model_name}'''					)
              processor.push_to_hub(F'''jozhang97/{model_name}'''					)


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

      parser.add_argument(
          '''--model_name''',
          type=str,
          default='''deta-swin-large''',
          choices=['''deta-swin-large''', '''deta-swin-large-o365'''],
          help='''Name of the model you\'d like to convert.''',
      )
      parser.add_argument(
          '''--pytorch_dump_folder_path''',
          default=None,
          type=str,
          help='''Path to the folder to output PyTorch model.''',
      )
      parser.add_argument(
          '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
      )
      __lowerCamelCase									=     parser.parse_args()
      convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)



'''simple docstring'''







import csv

import tweepy

# Twitter API credentials
__lowerCamelCase									=     ''''''
__lowerCamelCase									=     ''''''
__lowerCamelCase									=     ''''''
__lowerCamelCase									=     ''''''
def    UpperCAmelCase__     (   UpperCAmelCase__					)      ->      None:
       # authorize twitter, initialize tweepy
       A_						       =   tweepy.OAuthHandler(UpperCAmelCase__,							UpperCAmelCase__					)
       auth.set_access_token(UpperCAmelCase__,							UpperCAmelCase__					)
       A_						       =   tweepy.API(UpperCAmelCase__					)

       # initialize a list to hold all the tweepy Tweets
       A_						       =   []

       # make initial request for most recent tweets (200 is the maximum allowed count)
       A_						       =   api.user_timeline(screen_name=UpperCAmelCase__,							count=2_00					)

       # save most recent tweets
       alltweets.extend(UpperCAmelCase__					)

       # save the id of the oldest tweet less one
       A_						       =   alltweets[-1].id - 1

       # keep grabbing tweets until there are no tweets left to grab
       while len(UpperCAmelCase__					) > 0:
              print(F'''getting tweets before {oldest}'''					)

              # all subsequent requests use the max_id param to prevent duplicates
              A_						       =   api.user_timeline(
                  screen_name=UpperCAmelCase__,							count=2_00,							max_id=UpperCAmelCase__					)

              # save most recent tweets
              alltweets.extend(UpperCAmelCase__					)

              # update the id of the oldest tweet less one
              A_						       =   alltweets[-1].id - 1

              print(F'''...{len(UpperCAmelCase__					)} tweets downloaded so far'''					)

       # transform the tweepy tweets into a 2D array that will populate the csv
       A_						       =   [[tweet.id_str, tweet.created_at, tweet.text] for tweet in alltweets]

       # write the csv
       with open(F'''new_{screen_name}_tweets.csv''',							"""w"""					) as f:
              A_						       =   csv.writer(UpperCAmelCase__					)
              writer.writerow(["""id""", """created_at""", """text"""]					)
              writer.writerows(UpperCAmelCase__					)


if __name__ == "__main__":
      # pass in the username of the account you want to download
      get_all_tweets('''FirePing32''')
