






'''simple docstring'''



import argparse

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    CLIPTokenizer,
    CLIPTokenizerFast,
    VideoMAEImageProcessor,
    XCLIPConfig,
    XCLIPModel,
    XCLIPProcessor,
    XCLIPTextConfig,
    XCLIPVisionConfig,
)


def 							lowercase_				(    __A :       Any					,      __A :       str			)       ->      List[Any]:



 """simple docstring"""




 lowercase					:   List[str]				  =XCLIPTextConfig()

 # derive patch size from model name
 lowercase					:   List[str]				  =model_name.find('''patch'''			)
 lowercase					:   Any				  =int(model_name[start_idx + len('''patch'''			) : start_idx + len('''patch'''			) + 2]			)
 lowercase					:   Dict				  =XCLIPVisionConfig(patch_size=__A					,      num_frames=__A			)

 if "large" in model_name:
  lowercase					:   Any				  =7_6_8
  lowercase					:   Optional[Any]				  =3_0_7_2
  lowercase					:   Union[str, Any]				  =1_2

  lowercase					:   str				  =1_0_2_4
  lowercase					:   Any				  =4_0_9_6
  lowercase					:   List[Any]				  =1_6
  lowercase					:   Optional[int]				  =2_4
  lowercase					:   Optional[Any]				  =7_6_8
  lowercase					:   str				  =3_0_7_2

 if model_name == "xclip-large-patch14-16-frames":
  lowercase					:   Tuple				  =3_3_6

 lowercase					:   Tuple				  =XCLIPConfig.from_text_vision_configs(__A					,      __A			)

 if "large" in model_name:
  lowercase					:   Dict				  =7_6_8

 return config


def 							lowercase_				(    __A :       str			)       ->      Dict:



 """simple docstring"""




 if name == "token_embedding.weight":
  lowercase					:   List[Any]				  =name.replace('''token_embedding.weight'''					,      '''text_model.embeddings.token_embedding.weight'''			)
 if name == "positional_embedding":
  lowercase					:   Tuple				  =name.replace('''positional_embedding'''					,      '''text_model.embeddings.position_embedding.weight'''			)
 if "ln_1" in name:
  lowercase					:   Optional[int]				  =name.replace('''ln_1'''					,      '''layer_norm1'''			)
 if "ln_2" in name:
  lowercase					:   int				  =name.replace('''ln_2'''					,      '''layer_norm2'''			)
 if "c_fc" in name:
  lowercase					:   Tuple				  =name.replace('''c_fc'''					,      '''fc1'''			)
 if "c_proj" in name:
  lowercase					:   Tuple				  =name.replace('''c_proj'''					,      '''fc2'''			)
 if name.startswith('''transformer.resblocks'''			):
  lowercase					:   Tuple				  =name.replace('''transformer.resblocks'''					,      '''text_model.encoder.layers'''			)
 if "attn.out_proj" in name and "message" not in name:
  lowercase					:   Optional[Any]				  =name.replace('''attn.out_proj'''					,      '''self_attn.out_proj'''			)
 if "ln_final" in name:
  lowercase					:   str				  =name.replace('''ln_final'''					,      '''text_model.final_layer_norm'''			)
 # visual encoder
 if name == "visual.class_embedding":
  lowercase					:   str				  =name.replace('''visual.class_embedding'''					,      '''vision_model.embeddings.class_embedding'''			)
 if name == "visual.positional_embedding":
  lowercase					:   Tuple				  =name.replace('''visual.positional_embedding'''					,      '''vision_model.embeddings.position_embedding.weight'''			)
 if name.startswith('''visual.transformer.resblocks'''			):
  lowercase					:   Tuple				  =name.replace('''visual.transformer.resblocks'''					,      '''vision_model.encoder.layers'''			)
 if "visual.conv1" in name:
  lowercase					:   Optional[int]				  =name.replace('''visual.conv1'''					,      '''vision_model.embeddings.patch_embedding'''			)
 if "visual.ln_pre" in name:
  lowercase					:   int				  =name.replace('''visual.ln_pre'''					,      '''vision_model.pre_layernorm'''			)
 if "visual.ln_post" in name:
  lowercase					:   Tuple				  =name.replace('''visual.ln_post'''					,      '''vision_model.post_layernorm'''			)
 if "visual.proj" in name:
  lowercase					:   str				  =name.replace('''visual.proj'''					,      '''visual_projection.weight'''			)
 if "text_projection" in name:
  lowercase					:   Tuple				  =name.replace('''text_projection'''					,      '''text_projection.weight'''			)
 # things on top
 if "prompts_visual_proj" in name:
  lowercase					:   List[Any]				  =name.replace('''prompts_visual_proj'''					,      '''prompts_visual_projection'''			)
 if "prompts_visual_ln" in name:
  lowercase					:   Tuple				  =name.replace('''prompts_visual_ln'''					,      '''prompts_visual_layernorm'''			)
 # mit
 if name == "mit.positional_embedding":
  lowercase					:   Optional[int]				  =name.replace('''positional'''					,      '''position'''			)
 if name.startswith('''mit.resblocks'''			):
  lowercase					:   int				  =name.replace('''mit.resblocks'''					,      '''mit.encoder.layers'''			)
 # prompts generator
 if name.startswith('''prompts_generator.norm'''			):
  lowercase					:   Union[str, Any]				  =name.replace('''prompts_generator.norm'''					,      '''prompts_generator.layernorm'''			)

 return name


def 							lowercase_				(    __A :       Optional[int]					,      __A :       Tuple			)       ->      Dict:



 """simple docstring"""




 for key in orig_state_dict.copy().keys():
  lowercase					:   Union[str, Any]				  =orig_state_dict.pop(__A			)

  if "attn.in_proj" in key:
   lowercase					:   int				  =key.split('''.'''			)
   if key.startswith('''visual'''			):
    lowercase					:   Dict				  =key_split[3]
    lowercase					:   List[str]				  =config.vision_config.hidden_size
    if "message_attn" in key:
     if "weight" in key:
      lowercase					:   List[str]				  =val[
          :dim, :
      ]
      lowercase					:   List[str]				  =val[
          dim : dim * 2, :
      ]
      lowercase					:   Optional[Any]				  =val[
          -dim:, :
      ]
     else:
      lowercase					:   List[str]				  =val[
          :dim
      ]
      lowercase					:   Dict				  =val[
          dim : dim * 2
      ]
      lowercase					:   Any				  =val[
          -dim:
      ]
    else:
     if "weight" in key:
      lowercase					:   Optional[Any]				  =val[
          :dim, :
      ]
      lowercase					:   Union[str, Any]				  =val[
          dim : dim * 2, :
      ]
      lowercase					:   int				  =val[
          -dim:, :
      ]
     else:
      lowercase					:   Optional[Any]				  =val[:dim]
      lowercase					:   Tuple				  =val[
          dim : dim * 2
      ]
      lowercase					:   List[Any]				  =val[-dim:]
   elif key.startswith('''mit'''			):
    lowercase					:   str				  =key_split[2]
    lowercase					:   Dict				  =config.vision_config.mit_hidden_size
    if "weight" in key:
     lowercase					:   Any				  =val[:dim, :]
     lowercase					:   Optional[int]				  =val[dim : dim * 2, :]
     lowercase					:   Tuple				  =val[-dim:, :]
    else:
     lowercase					:   List[Any]				  =val[:dim]
     lowercase					:   int				  =val[dim : dim * 2]
     lowercase					:   Union[str, Any]				  =val[-dim:]
   else:
    lowercase					:   Dict				  =key_split[2]
    lowercase					:   str				  =config.text_config.hidden_size
    if "weight" in key:
     lowercase					:   Union[str, Any]				  =val[:dim, :]
     lowercase					:   Optional[Any]				  =val[
         dim : dim * 2, :
     ]
     lowercase					:   List[Any]				  =val[-dim:, :]
    else:
     lowercase					:   Dict				  =val[:dim]
     lowercase					:   List[Any]				  =val[
         dim : dim * 2
     ]
     lowercase					:   List[Any]				  =val[-dim:]
  else:
   lowercase					:   Optional[int]				  =rename_key(__A			)
   if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
    lowercase					:   List[str]				  =val.T
   lowercase					:   Optional[int]				  =val

 return orig_state_dict


def 							lowercase_				(    __A :       Optional[Any]			)       ->      List[Any]:



 """simple docstring"""




 if num_frames == 8:
  lowercase					:   Union[str, Any]				  ='''eating_spaghetti_8_frames.npy'''
 elif num_frames == 1_6:
  lowercase					:   Union[str, Any]				  ='''eating_spaghetti.npy'''
 elif num_frames == 3_2:
  lowercase					:   Any				  ='''eating_spaghetti_32_frames.npy'''
 lowercase					:   List[Any]				  =hf_hub_download(
     repo_id='''hf-internal-testing/spaghetti-video'''					,      filename=__A					,      repo_type='''dataset'''					,      )
 lowercase					:   int				  =np.load(__A			)
 return list(__A			)


def 							lowercase_				(    __A :       Optional[int]					,      __A :       int=None					,      __A :       Any=False			)       ->      int:



 """simple docstring"""




 lowercase					:   Dict				  ={
     # fully supervised kinetics-400 checkpoints
     '''xclip-base-patch32''': '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_8.pth''',
     '''xclip-base-patch32-16-frames''': (
         '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_16.pth'''
     ),
     '''xclip-base-patch16''': '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_8.pth''',
     '''xclip-base-patch16-16-frames''': (
         '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_16.pth'''
     ),
     '''xclip-large-patch14''': '''https://drive.google.com/u/0/uc?id=1NUOImq0o5DlQTST17iIP3vG7DgmHQuCx&amp;export=download&amp;confirm=t&amp;uuid=b26caedc-88e2-473e-830a-9d158b653cdb''',
     '''xclip-large-patch14-16-frames''': '''https://drive.google.com/u/0/uc?id=1FOYgnJc097OJ4lGwtRCCydQyVPJEOH7d&amp;export=download&amp;confirm=t&amp;uuid=538fa810-e671-4050-b385-9a623f89804f''',
     # fully supervised kinetics-600 checkpoints
     '''xclip-base-patch16-kinetics-600''': (
         '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_8.pth'''
     ),
     '''xclip-base-patch16-kinetics-600-16-frames''': (
         '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_16.pth'''
     ),
     '''xclip-large-patch14-kinetics-600''': '''https://drive.google.com/u/0/uc?id=1FV8C1INuM91sLAN4ImjzePLIlpMSihwV&amp;export=download&amp;confirm=t&amp;uuid=141d4977-4a65-44ae-864f-4b0c19f838be''',
     # few shot
     '''xclip-base-patch16-hmdb-2-shot''': (
         '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_2.pth'''
     ),
     '''xclip-base-patch16-hmdb-4-shot''': (
         '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_4.pth'''
     ),
     '''xclip-base-patch16-hmdb-8-shot''': (
         '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_8.pth'''
     ),
     '''xclip-base-patch16-hmdb-16-shot''': (
         '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_16.pth'''
     ),
     '''xclip-base-patch16-ucf-2-shot''': (
         '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_2.pth'''
     ),
     '''xclip-base-patch16-ucf-4-shot''': (
         '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_4.pth'''
     ),
     '''xclip-base-patch16-ucf-8-shot''': (
         '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_8.pth'''
     ),
     '''xclip-base-patch16-ucf-16-shot''': (
         '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_16.pth'''
     ),
     # zero shot
     '''xclip-base-patch16-zero-shot''': '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/zero.pth''',
 }

 lowercase					:   int				  =model_to_url[model_name]
 lowercase					:   int				  =8
 if "16-frames" in model_name:
  lowercase					:   Optional[Any]				  =1_6
 elif "shot" in model_name:
  lowercase					:   int				  =3_2

 lowercase					:   List[str]				  =get_xclip_config(__A					,      __A			)
 lowercase					:   Union[str, Any]				  =XCLIPModel(__A			)
 model.eval()

 if "drive" in checkpoint_url:
  lowercase					:   Optional[int]				  ='''pytorch_model.bin'''
  gdown.cached_download(__A					,      __A					,      quiet=__A			)
  lowercase					:   Optional[int]				  =torch.load(__A					,      map_location='''cpu'''			)['''model''']
 else:
  lowercase					:   Any				  =torch.hub.load_state_dict_from_url(__A			)['''model''']

 lowercase					:   str				  =convert_state_dict(__A					,      __A			)

 lowercase					:   Optional[int]				  =XCLIPModel(__A			)
 lowercase  ,		lowercase					:   List[Any]				  =model.load_state_dict(__A					,      strict=__A			)
 assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
 model.eval()

 lowercase					:   Any				  =3_3_6 if model_name == '''xclip-large-patch14-16-frames''' else 2_2_4
 lowercase					:   str				  =VideoMAEImageProcessor(size=__A			)
 lowercase					:   Dict				  =CLIPTokenizer.from_pretrained('''openai/clip-vit-base-patch32'''			)
 lowercase					:   int				  =CLIPTokenizerFast.from_pretrained('''openai/clip-vit-base-patch32'''			)
 lowercase					:   str				  =XCLIPProcessor(image_processor=__A					,      tokenizer=__A			)

 lowercase					:   str				  =prepare_video(__A			)
 lowercase					:   Optional[Any]				  =processor(
     text=['''playing sports''', '''eating spaghetti''', '''go shopping''']					,      videos=__A					,      return_tensors='''pt'''					,      padding=__A			)

 print('''Shape of pixel values:'''					,      inputs.pixel_values.shape			)

 with torch.no_grad():
  lowercase					:   Tuple				  =model(**__A			)

 # Verify outputs
 lowercase					:   str				  =outputs.logits_per_video
 lowercase					:   Optional[Any]				  =logits_per_video.softmax(dim=1			)
 print('''Probs:'''					,      __A			)
 # kinetics-400
 if model_name == "xclip-base-patch32":
  lowercase					:   Any				  =torch.tensor([[0.0019, 0.9951, 0.0030]]			)
 elif model_name == "xclip-base-patch32-16-frames":
  lowercase					:   Union[str, Any]				  =torch.tensor([[7.0999E-04, 9.9883E-01, 4.5580E-04]]			)
 elif model_name == "xclip-base-patch16":
  lowercase					:   Optional[Any]				  =torch.tensor([[0.0083, 0.9681, 0.0236]]			)
 elif model_name == "xclip-base-patch16-16-frames":
  lowercase					:   Optional[int]				  =torch.tensor([[7.6937E-04, 9.9728E-01, 1.9473E-03]]			)
 elif model_name == "xclip-large-patch14":
  lowercase					:   Tuple				  =torch.tensor([[0.0062, 0.9864, 0.0075]]			)
 elif model_name == "xclip-large-patch14-16-frames":
  lowercase					:   List[str]				  =torch.tensor([[3.3877E-04, 9.9937E-01, 2.8888E-04]]			)
 # kinetics-600
 elif model_name == "xclip-base-patch16-kinetics-600":
  lowercase					:   int				  =torch.tensor([[0.0555, 0.8914, 0.0531]]			)
 elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
  lowercase					:   Tuple				  =torch.tensor([[3.8554E-04, 9.9929E-01, 3.2754E-04]]			)
 elif model_name == "xclip-large-patch14-kinetics-600":
  lowercase					:   Tuple				  =torch.tensor([[0.0036, 0.9920, 0.0045]]			)
 # few shot
 elif model_name == "xclip-base-patch16-hmdb-2-shot":
  lowercase					:   int				  =torch.tensor([[7.1890E-06, 9.9994E-01, 5.6559E-05]]			)
 elif model_name == "xclip-base-patch16-hmdb-4-shot":
  lowercase					:   Union[str, Any]				  =torch.tensor([[1.0320E-05, 9.9993E-01, 6.2435E-05]]			)
 elif model_name == "xclip-base-patch16-hmdb-8-shot":
  lowercase					:   str				  =torch.tensor([[4.1377E-06, 9.9990E-01, 9.8386E-05]]			)
 elif model_name == "xclip-base-patch16-hmdb-16-shot":
  lowercase					:   Optional[int]				  =torch.tensor([[4.1347E-05, 9.9962E-01, 3.3411E-04]]			)
 elif model_name == "xclip-base-patch16-ucf-2-shot":
  lowercase					:   Optional[Any]				  =torch.tensor([[8.5857E-05, 9.9928E-01, 6.3291E-04]]			)
 elif model_name == "xclip-base-patch16-ucf-4-shot":
  lowercase					:   str				  =torch.tensor([[8.5857E-05, 9.9928E-01, 6.3291E-04]]			)
 elif model_name == "xclip-base-patch16-ucf-8-shot":
  lowercase					:   List[Any]				  =torch.tensor([[0.0027, 0.9904, 0.0070]]			)
 elif model_name == "xclip-base-patch16-ucf-16-shot":
  lowercase					:   str				  =torch.tensor([[9.8219E-04, 9.9593E-01, 3.0863E-03]]			)
 # zero shot
 elif model_name == "xclip-base-patch16-zero-shot":
  lowercase					:   Dict				  =torch.tensor([[3.5082E-04, 9.9785E-01, 1.7966E-03]]			)
 else:
  raise ValueError(F'Model name {model_name} not supported'			)
 assert torch.allclose(__A					,      __A					,      atol=1E-3			)
 print('''Looks ok!'''			)

 if pytorch_dump_folder_path is not None:
  print(F'Saving model {model_name} to {pytorch_dump_folder_path}'			)
  model.save_pretrained(__A			)

 if push_to_hub:
  print('''Pushing model, processor and slow tokenizer files to the hub...'''			)
  model.push_to_hub(__A					,      organization='''nielsr'''			)
  processor.push_to_hub(__A					,      organization='''nielsr'''			)
  slow_tokenizer.push_to_hub(__A					,      organization='''nielsr'''			)


if __name__ == "__main__":
      SCREAMING_SNAKE_CASE						=	argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          '--model_name',
          default='xclip-base-patch32',
          type=str,
          help='Name of the model.',
      )
      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 or not to push the converted model to the 🤗 hub.'
      )

      SCREAMING_SNAKE_CASE						=	parser.parse_args()
      convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)











'''simple docstring'''



import subprocess
import sys

from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch
class UpperCAmelCase_					(    __A				):




      """simple docstring"""




      @require_torch
      def 				A__      ( self			:		Tuple		)  ->  Optional[int]:


       '''simple docstring'''

       lowercase					:   Any				  ='''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        '''

       lowercase					:   Optional[int]				  ='''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
        '''

       lowercase					:   Any				  ='''
import socket
def offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")
socket.socket = offline_socket
        '''

       # Force fetching the files so that we can use the cache
       lowercase					:   Tuple				  ='''hf-internal-testing/tiny-random-bert'''
       BertConfig.from_pretrained(UpperCAmelCase		)
       BertModel.from_pretrained(UpperCAmelCase		)
       BertTokenizer.from_pretrained(UpperCAmelCase		)
       pipeline(task='''fill-mask'''     ,      model=UpperCAmelCase		)

       # baseline - just load from_pretrained with normal network
       lowercase					:   List[str]				  =[sys.executable, '''-c''', '''\n'''.join([load, run, mock]		)]

       # should succeed
       lowercase					:   Tuple				  =self.get_env()
       # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
       lowercase					:   Optional[Any]				  ='''1'''
       lowercase					:   Any				  =subprocess.run(UpperCAmelCase     ,      env=UpperCAmelCase     ,      check=UpperCAmelCase     ,      capture_output=UpperCAmelCase		)
       self.assertEqual(result.returncode     ,      0     ,      result.stderr		)
       self.assertIn('''success'''     ,      result.stdout.decode()		)






      @require_torch
      def 				A__      ( self			:		str		)  ->  List[str]:


       '''simple docstring'''

       lowercase					:   str				  ='''
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        '''

       lowercase					:   Optional[Any]				  ='''
mname = "hf-internal-testing/tiny-random-bert"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task="fill-mask", model=mname)
print("success")
        '''

       lowercase					:   Optional[int]				  ='''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")
socket.socket = offline_socket
        '''

       # Force fetching the files so that we can use the cache
       lowercase					:   Optional[Any]				  ='''hf-internal-testing/tiny-random-bert'''
       BertConfig.from_pretrained(UpperCAmelCase		)
       BertModel.from_pretrained(UpperCAmelCase		)
       BertTokenizer.from_pretrained(UpperCAmelCase		)
       pipeline(task='''fill-mask'''     ,      model=UpperCAmelCase		)

       # baseline - just load from_pretrained with normal network
       lowercase					:   Optional[Any]				  =[sys.executable, '''-c''', '''\n'''.join([load, run, mock]		)]

       # should succeed
       lowercase					:   str				  =self.get_env()
       lowercase					:   Any				  =subprocess.run(UpperCAmelCase     ,      env=UpperCAmelCase     ,      check=UpperCAmelCase     ,      capture_output=UpperCAmelCase		)
       self.assertEqual(result.returncode     ,      0     ,      result.stderr		)
       self.assertIn('''success'''     ,      result.stdout.decode()		)






      @require_torch
      def 				A__      ( self			:		Any		)  ->  Optional[Any]:


       '''simple docstring'''

       lowercase					:   Optional[Any]				  ='''
from transformers import BertConfig, BertModel, BertTokenizer
        '''

       lowercase					:   List[Any]				  ='''
mname = "hf-internal-testing/tiny-random-bert-sharded"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
print("success")
        '''

       lowercase					:   int				  ='''
import socket
def offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")
socket.socket = offline_socket
        '''

       # baseline - just load from_pretrained with normal network
       lowercase					:   Tuple				  =[sys.executable, '''-c''', '''\n'''.join([load, run]		)]

       # should succeed
       lowercase					:   Optional[Any]				  =self.get_env()
       lowercase					:   List[Any]				  =subprocess.run(UpperCAmelCase     ,      env=UpperCAmelCase     ,      check=UpperCAmelCase     ,      capture_output=UpperCAmelCase		)
       self.assertEqual(result.returncode     ,      0     ,      result.stderr		)
       self.assertIn('''success'''     ,      result.stdout.decode()		)

       # next emulate no network
       lowercase					:   Tuple				  =[sys.executable, '''-c''', '''\n'''.join([load, mock, run]		)]

       # Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
       # env["TRANSFORMERS_OFFLINE"] = "0"
       # result = subprocess.run(cmd, env=env, check=False, capture_output=True)
       # self.assertEqual(result.returncode, 1, result.stderr)

       # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
       lowercase					:   Any				  ='''1'''
       lowercase					:   Optional[Any]				  =subprocess.run(UpperCAmelCase     ,      env=UpperCAmelCase     ,      check=UpperCAmelCase     ,      capture_output=UpperCAmelCase		)
       self.assertEqual(result.returncode     ,      0     ,      result.stderr		)
       self.assertIn('''success'''     ,      result.stdout.decode()		)






      @require_torch
      def 				A__      ( self			:		Tuple		)  ->  Optional[int]:


       '''simple docstring'''

       lowercase					:   Optional[int]				  ='''
from transformers import pipeline
        '''
       lowercase					:   List[Any]				  ='''
mname = "hf-internal-testing/tiny-random-bert"
pipe = pipeline(model=mname)
        '''

       lowercase					:   Tuple				  ='''
import socket
def offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")
socket.socket = offline_socket
        '''
       lowercase					:   Tuple				  =self.get_env()
       lowercase					:   Optional[int]				  ='''1'''
       lowercase					:   Union[str, Any]				  =[sys.executable, '''-c''', '''\n'''.join([load, mock, run]		)]
       lowercase					:   Dict				  =subprocess.run(UpperCAmelCase     ,      env=UpperCAmelCase     ,      check=UpperCAmelCase     ,      capture_output=UpperCAmelCase		)
       self.assertEqual(result.returncode     ,      1     ,      result.stderr		)
       self.assertIn(
           '''You cannot infer task automatically within `pipeline` when using offline mode'''     ,      result.stderr.decode().replace('''\n'''     ,      ''''''		)     ,      )






      @require_torch
      def 				A__      ( self			:		int		)  ->  Optional[int]:


       '''simple docstring'''

       lowercase					:   List[str]				  ='''
from transformers import AutoModel
        '''
       lowercase					:   Dict				  ='''
mname = "hf-internal-testing/test_dynamic_model"
AutoModel.from_pretrained(mname, trust_remote_code=True)
print("success")
        '''

       # baseline - just load from_pretrained with normal network
       lowercase					:   Dict				  =[sys.executable, '''-c''', '''\n'''.join([load, run]		)]

       # should succeed
       lowercase					:   Optional[Any]				  =self.get_env()
       lowercase					:   int				  =subprocess.run(UpperCAmelCase     ,      env=UpperCAmelCase     ,      check=UpperCAmelCase     ,      capture_output=UpperCAmelCase		)
       self.assertEqual(result.returncode     ,      0     ,      result.stderr		)
       self.assertIn('''success'''     ,      result.stdout.decode()		)

       # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
       lowercase					:   List[str]				  ='''1'''
       lowercase					:   List[Any]				  =subprocess.run(UpperCAmelCase     ,      env=UpperCAmelCase     ,      check=UpperCAmelCase     ,      capture_output=UpperCAmelCase		)
       self.assertEqual(result.returncode     ,      0     ,      result.stderr		)
       self.assertIn('''success'''     ,      result.stdout.decode()		)



