code: 
  
  import subprocess
  from argparse import ArgumentParser
  from typing import List, Union
  
  from huggingface_hub.hf_api import HfFolder, create_repo, whoami
  from requests.exceptions import HTTPError
  
  from . import BaseTransformersCLICommand
  
  class __UpperCamelCase    (							_a		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					@staticmethod
  					def       _UpperCAmelCase						(							lowerCamelCase__	):
  						UpperCAmelCase__:  Union[str, Any]		       =   parser.add_parser("login"							,			help="Log in using the same credentials as on huggingface.co"	)
  						login_parser.set_defaults(func=lambda lowerCamelCase__	: LoginCommand(lowerCamelCase__	)	)
  						UpperCAmelCase__:  List[str]		       =   parser.add_parser("whoami"							,			help="Find out which huggingface.co account you are logged in as."	)
  						whoami_parser.set_defaults(func=lambda lowerCamelCase__	: WhoamiCommand(lowerCamelCase__	)	)
  						UpperCAmelCase__:  Optional[int]		       =   parser.add_parser("logout"							,			help="Log out"	)
  						logout_parser.set_defaults(func=lambda lowerCamelCase__	: LogoutCommand(lowerCamelCase__	)	)
  
  						# new system: git-based repo system
  						UpperCAmelCase__:  List[str]		       =   parser.add_parser(
  						    "repo"							,			help="Deprecated: use `huggingface-cli` instead. Commands to interact with your huggingface.co repos."							,			)
  						UpperCAmelCase__:  int		       =   repo_parser.add_subparsers(
  						    help="Deprecated: use `huggingface-cli` instead. huggingface.co repos related commands"	)
  						UpperCAmelCase__:  List[Any]		       =   repo_subparsers.add_parser(
  						    "create"							,			help="Deprecated: use `huggingface-cli` instead. Create a new repo on huggingface.co"	)
  						repo_create_parser.add_argument(
  						    "name"							,			type=lowerCamelCase__							,			help="Name for your model's repo. Will be namespaced under your username to build the model id."							,			)
  						repo_create_parser.add_argument("--organization"							,			type=lowerCamelCase__							,			help="Optional: organization namespace."	)
  						repo_create_parser.add_argument("-y"							,			"--yes"							,			action="store_true"							,			help="Optional: answer Yes to the prompt"	)
  						repo_create_parser.set_defaults(func=lambda lowerCamelCase__	: RepoCreateCommand(lowerCamelCase__	)	)
  
  class __UpperCamelCase    :
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					__magic_name__     			=      "\u001b[1m"
  					__magic_name__     			=      "\u001b[31m"
  					__magic_name__     			=      "\u001b[90m"
  					__magic_name__     			=      "\u001b[0m"
  
  
  
  
  
  					@classmethod
  					def       _UpperCAmelCase						(							cls							,			lowerCamelCase__	):
  						return F"{cls._bold}{s}{cls._reset}"
  
  
  
  
  
  					@classmethod
  					def       _UpperCAmelCase						(							cls							,			lowerCamelCase__	):
  						return F"{cls._bold}{cls._red}{s}{cls._reset}"
  
  
  
  
  
  					@classmethod
  					def       _UpperCAmelCase						(							cls							,			lowerCamelCase__	):
  						return F"{cls._gray}{s}{cls._reset}"
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  int		       =   [max(len(str(SCREAMING_SNAKE_CASE			)			) for x in col			) for col in zip(*SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)]
  	UpperCAmelCase__:  List[str]		       =   ("{{:{}}} " * len(SCREAMING_SNAKE_CASE			)).format(*SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  str		       =   []
  	lines.append(row_format.format(*SCREAMING_SNAKE_CASE			)			)
  	lines.append(row_format.format(*["-" * w for w in col_widths]			)			)
  	for row in rows:
  		lines.append(row_format.format(*SCREAMING_SNAKE_CASE			)			)
  	return "\n".join(SCREAMING_SNAKE_CASE			)
  
  class __UpperCamelCase    :
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					def __init__(							self							,			lowerCamelCase__	):
  						UpperCAmelCase__:  str		       =   args
  
  class __UpperCamelCase    (							_a		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						print(
  						    ANSI.red(
  						        "ERROR! `huggingface-cli login` uses an outdated login mechanism "
  						        "that is not compatible with the Hugging Face Hub backend anymore. "
  						        "Please use `huggingface-cli login instead."	)	)
  
  class __UpperCamelCase    (							_a		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						print(
  						    ANSI.red(
  						        "WARNING! `transformers-cli whoami` is deprecated and will be removed in v5. Please use "
  						        "`huggingface-cli whoami` instead."	)	)
  						UpperCAmelCase__:  Tuple		       =   HfFolder.get_token()
  						if token is None:
  							print("Not logged in"	)
  							exit()
  						try:
  							UpperCAmelCase__       ,	UpperCAmelCase__:  Dict		       =   whoami(lowerCamelCase__	)
  							print(lowerCamelCase__	)
  							if orgs:
  								print(ANSI.bold("orgs: "	)							,			",".join(lowerCamelCase__	)	)
  						except HTTPError as e:
  							print(lowerCamelCase__	)
  							print(ANSI.red(e.response.text	)	)
  							exit(1	)
  
  class __UpperCamelCase    (							_a		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						print(
  						    ANSI.red(
  						        "ERROR! `transformers-cli logout` uses an outdated logout mechanism "
  						        "that is not compatible with the Hugging Face Hub backend anymore. "
  						        "Please use `huggingface-cli logout instead."	)	)
  
  class __UpperCamelCase    (							_a		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						print(
  						    ANSI.red(
  						        "WARNING! Managing repositories through transformers-cli is deprecated. "
  						        "Please use `huggingface-cli` instead."	)	)
  						UpperCAmelCase__:  Union[str, Any]		       =   HfFolder.get_token()
  						if token is None:
  							print("Not logged in"	)
  							exit(1	)
  						try:
  							UpperCAmelCase__:  str		       =   subprocess.check_output(["git", "--version"]	).decode("utf-8"	)
  							print(ANSI.gray(stdout.strip()	)	)
  						except FileNotFoundError:
  							print("Looks like you do not have git installed, please install."	)
  
  						try:
  							UpperCAmelCase__:  List[Any]		       =   subprocess.check_output(["git-lfs", "--version"]	).decode("utf-8"	)
  							print(ANSI.gray(stdout.strip()	)	)
  						except FileNotFoundError:
  							print(
  							    ANSI.red(
  							        "Looks like you do not have git-lfs installed, please install."
  							        " You can install from https://git-lfs.github.com/."
  							        " Then run `git lfs install` (you only have to do this once)."	)	)
  						print(""	)
  
  						UpperCAmelCase__       ,	UpperCAmelCase__:  str		       =   whoami(lowerCamelCase__	)
  						UpperCAmelCase__:  Optional[Any]		       =   self.args.organization if self.args.organization is not None else user
  						UpperCAmelCase__:  Union[str, Any]		       =   F"{namespace}/{self.args.name}"
  						print(F"You are about to create {ANSI.bold(lowerCamelCase__	)}"	)
  
  						if not self.args.yes:
  							UpperCAmelCase__:  str		       =   input("Proceed? [Y/n] "	).lower()
  							if not (choice == "" or choice == "y" or choice == "yes"):
  								print("Abort"	)
  								exit()
  						try:
  							UpperCAmelCase__:  Dict		       =   create_repo(lowerCamelCase__							,			name=self.args.name							,			organization=self.args.organization	)
  						except HTTPError as e:
  							print(lowerCamelCase__	)
  							print(ANSI.red(e.response.text	)	)
  							exit(1	)
  						print("\nYour repo now lives at:"	)
  						print(F"  {ANSI.bold(lowerCamelCase__	)}"	)
  						print("\nYou can clone it locally with the command below, and commit/push as usual."	)
  						print(F"\n  git clone {url}"	)
  						print(""	)
style_context: 
  
  import json
  import os
  import random
  import shutil
  import tempfile
  import unittest
  
  import numpy as np
  import pytest
  
  from transformers import BertTokenizer, BertTokenizerFast
  from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
  from transformers.testing_utils import require_vision
  from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available
  
  
  if is_vision_available():
  					from PIL import Image
  
  					from transformers import FlavaImageProcessor, FlavaProcessor
  					from transformers.models.flava.image_processing_flava import (
  					    FLAVA_CODEBOOK_MEAN,
  					    FLAVA_CODEBOOK_STD,
  					    FLAVA_IMAGE_MEAN,
  					    FLAVA_IMAGE_STD,
  					)
  
  @require_vision
  class __UpperCamelCase    (							unittest.TestCase		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Optional[int]		       =   tempfile.mkdtemp()
  
  						# fmt: off
  						UpperCAmelCase__:  Optional[Any]		       =   ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "want", "##want", "##ed", "wa", "un", "runn", "##ing", ",", "low", "lowest"]
  						# fmt: on
  						UpperCAmelCase__:  str		       =   os.path.join(self.tmpdirname							,			VOCAB_FILES_NAMES["vocab_file"]	)
  
  						with open(self.vocab_file							,			"w"							,			encoding="utf-8"	) as fp:
  							fp.write("".join([x + "\n" for x in vocab_tokens]	)	)
  
  						UpperCAmelCase__:  Tuple		       =   {
  						    "image_mean": FLAVA_IMAGE_MEAN,
  						    "image_std": FLAVA_IMAGE_STD,
  						    "do_normalize": True,
  						    "do_resize": True,
  						    "size": 2_2_4,
  						    "do_center_crop": True,
  						    "crop_size": 2_2_4,
  						    "input_size_patches": 1_4,
  						    "total_mask_patches": 7_5,
  						    "mask_group_max_patches": None,
  						    "mask_group_min_patches": 1_6,
  						    "mask_group_min_aspect_ratio": 0.3,
  						    "mask_group_max_aspect_ratio": None,
  						    "codebook_do_resize": True,
  						    "codebook_size": 1_1_2,
  						    "codebook_do_center_crop": True,
  						    "codebook_crop_size": 1_1_2,
  						    "codebook_do_map_pixels": True,
  						    "codebook_do_normalize": True,
  						    "codebook_image_mean": FLAVA_CODEBOOK_MEAN,
  						    "codebook_image_std": FLAVA_CODEBOOK_STD,
  						}
  
  						UpperCAmelCase__:  Tuple		       =   os.path.join(self.tmpdirname							,			lowerCamelCase__	)
  						with open(self.image_processor_file							,			"w"							,			encoding="utf-8"	) as fp:
  							json.dump(lowerCamelCase__							,			lowerCamelCase__	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self							,			**lowerCamelCase__	):
  						return BertTokenizer.from_pretrained(self.tmpdirname							,			**lowerCamelCase__	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self							,			**lowerCamelCase__	):
  						return BertTokenizerFast.from_pretrained(self.tmpdirname							,			**lowerCamelCase__	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self							,			**lowerCamelCase__	):
  						return FlavaImageProcessor.from_pretrained(self.tmpdirname							,			**lowerCamelCase__	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						shutil.rmtree(self.tmpdirname	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Dict		       =   [np.random.randint(2_5_5							,			size=(3, 3_0, 4_0_0)							,			dtype=np.uinta	)]
  
  						UpperCAmelCase__:  Any		       =   [Image.fromarray(np.moveaxis(lowerCamelCase__							,			0							,			-1	)	) for x in image_inputs]
  
  						return image_inputs
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  int		       =   self.get_tokenizer()
  						UpperCAmelCase__:  Any		       =   self.get_rust_tokenizer()
  						UpperCAmelCase__:  List[Any]		       =   self.get_image_processor()
  
  						UpperCAmelCase__:  Tuple		       =   FlavaProcessor(tokenizer=lowerCamelCase__							,			image_processor=lowerCamelCase__	)
  						processor_slow.save_pretrained(self.tmpdirname	)
  						UpperCAmelCase__:  Dict		       =   FlavaProcessor.from_pretrained(self.tmpdirname							,			use_fast=lowerCamelCase__	)
  
  						UpperCAmelCase__:  Union[str, Any]		       =   FlavaProcessor(tokenizer=lowerCamelCase__							,			image_processor=lowerCamelCase__	)
  						processor_fast.save_pretrained(self.tmpdirname	)
  						UpperCAmelCase__:  int		       =   FlavaProcessor.from_pretrained(self.tmpdirname	)
  
  						self.assertEqual(processor_slow.tokenizer.get_vocab()							,			tokenizer_slow.get_vocab()	)
  						self.assertEqual(processor_fast.tokenizer.get_vocab()							,			tokenizer_fast.get_vocab()	)
  						self.assertEqual(tokenizer_slow.get_vocab()							,			tokenizer_fast.get_vocab()	)
  						self.assertIsInstance(processor_slow.tokenizer							,			lowerCamelCase__	)
  						self.assertIsInstance(processor_fast.tokenizer							,			lowerCamelCase__	)
  
  						self.assertEqual(processor_slow.image_processor.to_json_string()							,			image_processor.to_json_string()	)
  						self.assertEqual(processor_fast.image_processor.to_json_string()							,			image_processor.to_json_string()	)
  						self.assertIsInstance(processor_slow.image_processor							,			lowerCamelCase__	)
  						self.assertIsInstance(processor_fast.image_processor							,			lowerCamelCase__	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Any		       =   FlavaProcessor(tokenizer=self.get_tokenizer()							,			image_processor=self.get_image_processor()	)
  						processor.save_pretrained(self.tmpdirname	)
  
  						UpperCAmelCase__:  Any		       =   self.get_tokenizer(bos_token="(BOS)"							,			eos_token="(EOS)"	)
  						UpperCAmelCase__:  str		       =   self.get_image_processor(do_normalize=lowerCamelCase__							,			padding_value=1.0	)
  
  						UpperCAmelCase__:  str		       =   FlavaProcessor.from_pretrained(
  						    self.tmpdirname							,			bos_token="(BOS)"							,			eos_token="(EOS)"							,			do_normalize=lowerCamelCase__							,			padding_value=1.0	)
  
  						self.assertEqual(processor.tokenizer.get_vocab()							,			tokenizer_add_kwargs.get_vocab()	)
  						self.assertIsInstance(processor.tokenizer							,			lowerCamelCase__	)
  
  						self.assertEqual(processor.image_processor.to_json_string()							,			image_processor_add_kwargs.to_json_string()	)
  						self.assertIsInstance(processor.image_processor							,			lowerCamelCase__	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  int		       =   self.get_image_processor()
  						UpperCAmelCase__:  Optional[Any]		       =   self.get_tokenizer()
  
  						UpperCAmelCase__:  Optional[Any]		       =   FlavaProcessor(tokenizer=lowerCamelCase__							,			image_processor=lowerCamelCase__	)
  
  						UpperCAmelCase__:  Optional[int]		       =   self.prepare_image_inputs()
  
  						UpperCAmelCase__:  Tuple		       =   image_processor(lowerCamelCase__							,			return_tensors="np"	)
  						UpperCAmelCase__:  str		       =   processor(images=lowerCamelCase__							,			return_tensors="np"	)
  
  						for key in input_feat_extract.keys():
  							self.assertAlmostEqual(input_feat_extract[key].sum()							,			input_processor[key].sum()							,			delta=1e-2	)
  
  						# With rest of the args
  						random.seed(1_2_3_4	)
  						UpperCAmelCase__:  Optional[int]		       =   image_processor(
  						    lowerCamelCase__							,			return_image_mask=lowerCamelCase__							,			return_codebook_pixels=lowerCamelCase__							,			return_tensors="np"	)
  						random.seed(1_2_3_4	)
  						UpperCAmelCase__:  Tuple		       =   processor(
  						    images=lowerCamelCase__							,			return_image_mask=lowerCamelCase__							,			return_codebook_pixels=lowerCamelCase__							,			return_tensors="np"	)
  
  						for key in input_feat_extract.keys():
  							self.assertAlmostEqual(input_feat_extract[key].sum()							,			input_processor[key].sum()							,			delta=1e-2	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Dict		       =   self.get_image_processor()
  						UpperCAmelCase__:  str		       =   self.get_tokenizer()
  
  						UpperCAmelCase__:  List[str]		       =   FlavaProcessor(tokenizer=lowerCamelCase__							,			image_processor=lowerCamelCase__	)
  
  						UpperCAmelCase__:  Union[str, Any]		       =   "lower newer"
  
  						UpperCAmelCase__:  Optional[Any]		       =   processor(text=lowerCamelCase__	)
  
  						UpperCAmelCase__:  Optional[Any]		       =   tokenizer(lowerCamelCase__	)
  
  						for key in encoded_tok.keys():
  							self.assertListEqual(encoded_tok[key]							,			encoded_processor[key]	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  List[Any]		       =   self.get_image_processor()
  						UpperCAmelCase__:  int		       =   self.get_tokenizer()
  
  						UpperCAmelCase__:  str		       =   FlavaProcessor(tokenizer=lowerCamelCase__							,			image_processor=lowerCamelCase__	)
  
  						UpperCAmelCase__:  Any		       =   "lower newer"
  						UpperCAmelCase__:  Any		       =   self.prepare_image_inputs()
  
  						UpperCAmelCase__:  Optional[int]		       =   processor(text=lowerCamelCase__							,			images=lowerCamelCase__	)
  
  						self.assertListEqual(list(inputs.keys()	)							,			["input_ids", "token_type_ids", "attention_mask", "pixel_values"]	)
  
  						# add extra args
  						UpperCAmelCase__:  str		       =   processor(text=lowerCamelCase__							,			images=lowerCamelCase__							,			return_codebook_pixels=lowerCamelCase__							,			return_image_mask=lowerCamelCase__	)
  
  						self.assertListEqual(
  						    list(inputs.keys()	)							,			[
  						        "input_ids",
  						        "token_type_ids",
  						        "attention_mask",
  						        "pixel_values",
  						        "codebook_pixel_values",
  						        "bool_masked_pos",
  						    ]							,			)
  
  						# test if it raises when no input is passed
  						with pytest.raises(lowerCamelCase__	):
  							processor()
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Optional[Any]		       =   self.get_image_processor()
  						UpperCAmelCase__:  List[Any]		       =   self.get_tokenizer()
  
  						UpperCAmelCase__:  Any		       =   FlavaProcessor(tokenizer=lowerCamelCase__							,			image_processor=lowerCamelCase__	)
  
  						UpperCAmelCase__:  List[Any]		       =   [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
  						UpperCAmelCase__:  str		       =   processor.batch_decode(lowerCamelCase__	)
  						UpperCAmelCase__:  Dict		       =   tokenizer.batch_decode(lowerCamelCase__	)
  
  						self.assertListEqual(lowerCamelCase__							,			lowerCamelCase__	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  List[str]		       =   self.get_image_processor()
  						UpperCAmelCase__:  Dict		       =   self.get_tokenizer()
  
  						UpperCAmelCase__:  Tuple		       =   FlavaProcessor(tokenizer=lowerCamelCase__							,			image_processor=lowerCamelCase__	)
  
  						UpperCAmelCase__:  Optional[Any]		       =   "lower newer"
  						UpperCAmelCase__:  Dict		       =   self.prepare_image_inputs()
  
  						UpperCAmelCase__:  int		       =   processor(text=lowerCamelCase__							,			images=lowerCamelCase__	)
  
  						self.assertListEqual(list(inputs.keys()	)							,			processor.model_input_names	)