
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 							a__					(							snake_case       ,			snake_case							):





  """simple docstring"""
  __SCREAMING_SNAKE_CASE      :	Tuple					=		XCLIPTextConfig()

  # derive patch size from model name
  __SCREAMING_SNAKE_CASE      :	Tuple					=		model_name.find('''patch'''							)
  __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		int(model_name[start_idx + len('''patch'''							) : start_idx + len('''patch'''							) + 2]							)
  __SCREAMING_SNAKE_CASE      :	Tuple					=		XCLIPVisionConfig(patch_size=snake_case       ,			num_frames=snake_case							)

  if "large" in model_name:
    __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		768
    __SCREAMING_SNAKE_CASE      :	Optional[int]					=		3_072
    __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		12

    __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		1_024
    __SCREAMING_SNAKE_CASE      :	int					=		4_096
    __SCREAMING_SNAKE_CASE      :	Tuple					=		16
    __SCREAMING_SNAKE_CASE      :	Optional[int]					=		24
    __SCREAMING_SNAKE_CASE      :	Optional[int]					=		768
    __SCREAMING_SNAKE_CASE      :	Optional[int]					=		3_072

  if model_name == "xclip-large-patch14-16-frames":
    __SCREAMING_SNAKE_CASE      :	Any					=		336

  __SCREAMING_SNAKE_CASE      :	Any					=		XCLIPConfig.from_text_vision_configs(snake_case       ,			snake_case							)

  if "large" in model_name:
    __SCREAMING_SNAKE_CASE      :	Any					=		768

  return config


def 							a__					(							snake_case							):





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

  return name


def 							a__					(							snake_case       ,			snake_case							):





  """simple docstring"""
  for key in orig_state_dict.copy().keys():
    __SCREAMING_SNAKE_CASE      :	Tuple					=		orig_state_dict.pop(snake_case							)

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

  return orig_state_dict


def 							a__					(							snake_case							):





  """simple docstring"""
  if num_frames == 8:
    __SCREAMING_SNAKE_CASE      :	List[Any]					=		'''eating_spaghetti_8_frames.npy'''
  elif num_frames == 16:
    __SCREAMING_SNAKE_CASE      :	Tuple					=		'''eating_spaghetti.npy'''
  elif num_frames == 32:
    __SCREAMING_SNAKE_CASE      :	Dict					=		'''eating_spaghetti_32_frames.npy'''
  __SCREAMING_SNAKE_CASE      :	List[str]					=		hf_hub_download(
      repo_id='''hf-internal-testing/spaghetti-video'''       ,			filename=snake_case       ,			repo_type='''dataset'''       ,			)
  __SCREAMING_SNAKE_CASE      :	int					=		np.load(snake_case							)
  return list(snake_case							)


def 							a__					(							snake_case       ,			snake_case=None       ,			snake_case=False							):





  """simple docstring"""
  __SCREAMING_SNAKE_CASE      :	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''',
  }

  __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		model_to_url[model_name]
  __SCREAMING_SNAKE_CASE      :	Any					=		8
  if "16-frames" in model_name:
    __SCREAMING_SNAKE_CASE      :	Optional[int]					=		16
  elif "shot" in model_name:
    __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		32

  __SCREAMING_SNAKE_CASE      :	List[str]					=		get_xclip_config(snake_case       ,			snake_case							)
  __SCREAMING_SNAKE_CASE      :	Tuple					=		XCLIPModel(snake_case							)
  model.eval()

  if "drive" in checkpoint_url:
    __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		'''pytorch_model.bin'''
    gdown.cached_download(snake_case       ,			snake_case       ,			quiet=snake_case							)
    __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		torch.load(snake_case       ,			map_location='''cpu'''							)['''model''']
  else:
    __SCREAMING_SNAKE_CASE      :	str					=		torch.hub.load_state_dict_from_url(snake_case							)['''model''']

  __SCREAMING_SNAKE_CASE      :	List[Any]					=		convert_state_dict(snake_case       ,			snake_case							)

  __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		XCLIPModel(snake_case							)
  __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE      :	Any					=		model.load_state_dict(snake_case       ,			strict=snake_case							)
  assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
  model.eval()

  __SCREAMING_SNAKE_CASE      :	Any					=		336 if model_name == '''xclip-large-patch14-16-frames''' else 224
  __SCREAMING_SNAKE_CASE      :	str					=		VideoMAEImageProcessor(size=snake_case							)
  __SCREAMING_SNAKE_CASE      :	int					=		CLIPTokenizer.from_pretrained('''openai/clip-vit-base-patch32'''							)
  __SCREAMING_SNAKE_CASE      :	Optional[int]					=		CLIPTokenizerFast.from_pretrained('''openai/clip-vit-base-patch32'''							)
  __SCREAMING_SNAKE_CASE      :	List[Any]					=		XCLIPProcessor(image_processor=snake_case       ,			tokenizer=snake_case							)

  __SCREAMING_SNAKE_CASE      :	Dict					=		prepare_video(snake_case							)
  __SCREAMING_SNAKE_CASE      :	List[str]					=		processor(
      text=['''playing sports''', '''eating spaghetti''', '''go shopping''']       ,			videos=snake_case       ,			return_tensors='''pt'''       ,			padding=snake_case							)

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

  with torch.no_grad():
    __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		model(**snake_case							)

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

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


if __name__ == "__main__":
   lowercase_ 				=			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."""
   )

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








'''simple docstring'''
import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
 from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
 from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
 from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


UpperCamelCase__			=      DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

UpperCamelCase__			=      'main'
# Default branch name
UpperCamelCase__			=      'f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'
# One particular commit (not the top of `main`)
UpperCamelCase__			=      'aaaaaaa'
# This commit does not exist, so we should 404.

UpperCamelCase__			=      'd9e9f15bc825e4b2c9249e9578f884bbcb5e3684'
# Sha-1 of config.json on the top of `main`, for checking purposes
UpperCamelCase__			=      '4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'




@contextlib.contextmanager
def 		__SCREAMING_SNAKE_CASE       (	):


   """simple docstring"""




   print("Welcome!"				)
   yield
   print("Bye!"				)




@contextlib.contextmanager
def 		__SCREAMING_SNAKE_CASE       (	):


   """simple docstring"""




   print("Bonjour!"				)
   yield
   print("Au revoir!"				)


class 							_UpperCAmelCase    (		unittest.TestCase      ):




    def 					lowerCAmelCase__					(      self	:							int      ):






       '''simple docstring'''






       assert transformers.__spec__ is not None
       assert importlib.util.find_spec("transformers"      ) is not None


class 							_UpperCAmelCase    (		unittest.TestCase      ):




    @unittest.mock.patch("sys.stdout"	,  new_callable=io.StringIO      )
    def 					lowerCAmelCase__					(      self	:							str	,  a	:							List[str]      ):






       '''simple docstring'''






       with ContextManagers([]      ):
          print("Transformers are awesome!"      )
       # The print statement adds a new line at the end of the output
       self.assertEqual(mock_stdout.getvalue()	,  "Transformers are awesome!\n"      )




    @unittest.mock.patch("sys.stdout"	,  new_callable=io.StringIO      )
    def 					lowerCAmelCase__					(      self	:							List[str]	,  a	:							Optional[int]      ):






       '''simple docstring'''






       with ContextManagers([context_en()]      ):
          print("Transformers are awesome!"      )
       # The output should be wrapped with an English welcome and goodbye
       self.assertEqual(mock_stdout.getvalue()	,  "Welcome!\nTransformers are awesome!\nBye!\n"      )




    @unittest.mock.patch("sys.stdout"	,  new_callable=io.StringIO      )
    def 					lowerCAmelCase__					(      self	:							Tuple	,  a	:							List[Any]      ):






       '''simple docstring'''






       with ContextManagers([context_fr(), context_en()]      ):
          print("Transformers are awesome!"      )
       # The output should be wrapped with an English and French welcome and goodbye
       self.assertEqual(mock_stdout.getvalue()	,  "Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n"      )




    @require_torch
    def 					lowerCAmelCase__					(      self	:							Tuple      ):






       '''simple docstring'''






       self.assertEqual(find_labels(a      )	,  ["labels"]      )
       self.assertEqual(find_labels(a      )	,  ["labels", "next_sentence_label"]      )
       self.assertEqual(find_labels(a      )	,  ["start_positions", "end_positions"]      )


       class 							_UpperCAmelCase    (		snake_case      ):
           pass


       self.assertEqual(find_labels(a      )	,  ["labels"]      )




    @require_tf
    def 					lowerCAmelCase__					(      self	:							int      ):






       '''simple docstring'''






       self.assertEqual(find_labels(a      )	,  ["labels"]      )
       self.assertEqual(find_labels(a      )	,  ["labels", "next_sentence_label"]      )
       self.assertEqual(find_labels(a      )	,  ["start_positions", "end_positions"]      )


       class 							_UpperCAmelCase    (		snake_case      ):
           pass


       self.assertEqual(find_labels(a      )	,  ["labels"]      )





    @require_flax
    def 					lowerCAmelCase__					(      self	:							str      ):






       '''simple docstring'''






       self.assertEqual(find_labels(a      )	,  []      )
       self.assertEqual(find_labels(a      )	,  []      )
       self.assertEqual(find_labels(a      )	,  []      )


       class 							_UpperCAmelCase    (		snake_case      ):
           pass


       self.assertEqual(find_labels(a      )	,  []      )




