






from datetime import datetime as dt
import os

from github import Github


__magic_name__:					Optional[Any]							=     [
    "good first issue",
    "good second issue",
    "good difficult issue",
    "feature request",
    "new model",
    "wip",
]

def    UpperCamelCase						(	):






						"""simple docstring"""







						__magic_name__      :       Optional[int]       						= Github(os.environ["""GITHUB_TOKEN"""]			)
						__magic_name__      :       Tuple       						= g.get_repo("""huggingface/transformers"""			)
						__magic_name__      :       List[str]       						= repo.get_issues(state="""open"""			)

						for issue in open_issues:
												__magic_name__      :       Optional[int]       						= sorted([comment for comment in issue.get_comments()],   key=lambda _A			: i.created_at,   reverse=_A			)
												__magic_name__      :       str       						= comments[0] if len(_A			) > 0 else None
												if (
												    last_comment is not None
												    and last_comment.user.login == "github-actions[bot]"
												    and (dt.utcnow() - issue.updated_at).days > 7
												    and (dt.utcnow() - issue.created_at).days >= 30
												    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()			)
												):
																		# print(f"Would close issue {issue.number} since it has been 7 days of inactivity since bot mention.")
																		issue.edit(state="""closed"""			)
												elif (
												    (dt.utcnow() - issue.updated_at).days > 23
												    and (dt.utcnow() - issue.created_at).days >= 30
												    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()			)
												):
																		# print(f"Would add stale comment to {issue.number}")
																		issue.create_comment(
																		    """This issue has been automatically marked as stale because it has not had """
																		    """recent activity. If you think this still needs to be addressed """
																		    """please comment on this thread.\n\nPlease note that issues that do not follow the """
																		    """[contributing guidelines](https://github.com/huggingface/transformers/blob/main/CONTRIBUTING.md) """
																		    """are likely to be ignored."""			)


if __name__ == "__main__":
		main()








import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip 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 OwlViTImageProcessor, OwlViTProcessor





@require_vision
class 	snake_case__ (							unittest.TestCase				):
	def       __magic_name__    (    self			)							->				int:
							__magic_name__      :       List[str]       						= tempfile.mkdtemp()

							# fmt: off
							__magic_name__      :       Union[str, Any]       						= ["""""", """l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """lo""", """l</w>""", """w</w>""", """r</w>""", """t</w>""", """low</w>""", """er</w>""", """lowest</w>""", """newer</w>""", """wider""", """<unk>""", """<|startoftext|>""", """<|endoftext|>"""]
							# fmt: on
							__magic_name__      :       Any       						= dict(zip(lowerCAmelCase__      ,       range(len(lowerCAmelCase__			)			)			)			)
							__magic_name__      :       int       						= ["""#version: 0.2""", """l o""", """lo w</w>""", """e r</w>""", """"""]
							__magic_name__      :       Any       						= {"""unk_token""": """<unk>"""}

							__magic_name__      :       Optional[Any]       						= os.path.join(self.tmpdirname      ,       VOCAB_FILES_NAMES["""vocab_file"""]			)
							__magic_name__      :       Optional[int]       						= os.path.join(self.tmpdirname      ,       VOCAB_FILES_NAMES["""merges_file"""]			)
							with open(self.vocab_file      ,       """w"""      ,       encoding="""utf-8"""			) as fp:
													fp.write(json.dumps(lowerCAmelCase__			) + """\n"""			)
							with open(self.merges_file      ,       """w"""      ,       encoding="""utf-8"""			) as fp:
													fp.write("""\n""".join(lowerCAmelCase__			)			)

							__magic_name__      :       int       						= {
							    """do_resize""": True,
							    """size""": 20,
							    """do_center_crop""": True,
							    """crop_size""": 18,
							    """do_normalize""": True,
							    """image_mean""": [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
							    """image_std""": [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
							}
							__magic_name__      :       List[str]       						= os.path.join(self.tmpdirname      ,       lowerCAmelCase__			)
							with open(self.image_processor_file      ,       """w"""      ,       encoding="""utf-8"""			) as fp:
													json.dump(lowerCAmelCase__      ,       lowerCAmelCase__			)
	def       __magic_name__    (    self      ,       **lowerCAmelCase__			)							->				List[str]:
							return CLIPTokenizer.from_pretrained(self.tmpdirname      ,       pad_token="""!"""      ,       **lowerCAmelCase__			)
	def       __magic_name__    (    self      ,       **lowerCAmelCase__			)							->				Any:
							return CLIPTokenizerFast.from_pretrained(self.tmpdirname      ,       pad_token="""!"""      ,       **lowerCAmelCase__			)
	def       __magic_name__    (    self      ,       **lowerCAmelCase__			)							->				Optional[Any]:
							return OwlViTImageProcessor.from_pretrained(self.tmpdirname      ,       **lowerCAmelCase__			)
	def       __magic_name__    (    self			)							->				int:
							shutil.rmtree(self.tmpdirname			)
	def       __magic_name__    (    self			)							->				int:
							__magic_name__      :       str       						= [np.random.randint(2_55      ,       size=(3, 30, 4_00)      ,       dtype=np.uinta			)]

							__magic_name__      :       Any       						= [Image.fromarray(np.moveaxis(lowerCAmelCase__      ,       0      ,       -1			)			) for x in image_inputs]

							return image_inputs
	def       __magic_name__    (    self			)							->				Union[str, Any]:
							__magic_name__      :       Any       						= self.get_tokenizer()
							__magic_name__      :       str       						= self.get_rust_tokenizer()
							__magic_name__      :       Tuple       						= self.get_image_processor()

							__magic_name__      :       List[str]       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)
							processor_slow.save_pretrained(self.tmpdirname			)
							__magic_name__      :       Optional[int]       						= OwlViTProcessor.from_pretrained(self.tmpdirname      ,       use_fast=lowerCAmelCase__			)

							__magic_name__      :       int       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)
							processor_fast.save_pretrained(self.tmpdirname			)
							__magic_name__      :       List[Any]       						= OwlViTProcessor.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       __magic_name__    (    self			)							->				Optional[int]:
							__magic_name__      :       Optional[Any]       						= OwlViTProcessor(tokenizer=self.get_tokenizer()      ,       image_processor=self.get_image_processor()			)
							processor.save_pretrained(self.tmpdirname			)

							__magic_name__      :       str       						= self.get_tokenizer(bos_token="""(BOS)"""      ,       eos_token="""(EOS)"""			)
							__magic_name__      :       Any       						= self.get_image_processor(do_normalize=lowerCAmelCase__			)

							__magic_name__      :       Tuple       						= OwlViTProcessor.from_pretrained(
							    self.tmpdirname      ,       bos_token="""(BOS)"""      ,       eos_token="""(EOS)"""      ,       do_normalize=lowerCAmelCase__			)

							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       __magic_name__    (    self			)							->				Dict:
							__magic_name__      :       int       						= self.get_image_processor()
							__magic_name__      :       int       						= self.get_tokenizer()

							__magic_name__      :       Union[str, Any]       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)

							__magic_name__      :       Dict       						= self.prepare_image_inputs()

							__magic_name__      :       Any       						= image_processor(lowerCAmelCase__      ,       return_tensors="""np"""			)
							__magic_name__      :       str       						= processor(images=lowerCAmelCase__      ,       return_tensors="""np"""			)

							for key in input_image_proc.keys():
													self.assertAlmostEqual(input_image_proc[key].sum()      ,       input_processor[key].sum()      ,       delta=1e-2			)
	def       __magic_name__    (    self			)							->				Tuple:
							__magic_name__      :       Union[str, Any]       						= self.get_image_processor()
							__magic_name__      :       int       						= self.get_tokenizer()

							__magic_name__      :       int       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)

							__magic_name__      :       Optional[int]       						= """lower newer"""

							__magic_name__      :       Tuple       						= processor(text=lowerCAmelCase__      ,       return_tensors="""np"""			)

							__magic_name__      :       Optional[int]       						= tokenizer(lowerCAmelCase__      ,       return_tensors="""np"""			)

							for key in encoded_tok.keys():
													self.assertListEqual(encoded_tok[key][0].tolist()      ,       encoded_processor[key][0].tolist()			)
	def       __magic_name__    (    self			)							->				Tuple:
							__magic_name__      :       Tuple       						= self.get_image_processor()
							__magic_name__      :       Union[str, Any]       						= self.get_tokenizer()

							__magic_name__      :       List[str]       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)

							__magic_name__      :       Any       						= """lower newer"""
							__magic_name__      :       Union[str, Any]       						= self.prepare_image_inputs()

							__magic_name__      :       int       						= processor(text=lowerCAmelCase__      ,       images=lowerCAmelCase__			)

							self.assertListEqual(list(inputs.keys()			)      ,       ["""input_ids""", """attention_mask""", """pixel_values"""]			)

							# test if it raises when no input is passed
							with pytest.raises(lowerCAmelCase__			):
													processor()
	def       __magic_name__    (    self			)							->				Optional[Any]:
							__magic_name__      :       Dict       						= """google/owlvit-base-patch32"""
							__magic_name__      :       int       						= OwlViTProcessor.from_pretrained(lowerCAmelCase__			)

							__magic_name__      :       List[Any]       						= ["""cat""", """nasa badge"""]
							__magic_name__      :       Any       						= processor(text=lowerCAmelCase__			)

							__magic_name__      :       Dict       						= 16
							self.assertListEqual(list(inputs.keys()			)      ,       ["""input_ids""", """attention_mask"""]			)
							self.assertEqual(inputs["""input_ids"""].shape      ,       (2, seq_length)			)

							# test if it raises when no input is passed
							with pytest.raises(lowerCAmelCase__			):
													processor()
	def       __magic_name__    (    self			)							->				List[Any]:
							__magic_name__      :       List[str]       						= """google/owlvit-base-patch32"""
							__magic_name__      :       Optional[Any]       						= OwlViTProcessor.from_pretrained(lowerCAmelCase__			)

							__magic_name__      :       Tuple       						= [["""cat""", """nasa badge"""], ["""person"""]]
							__magic_name__      :       Tuple       						= processor(text=lowerCAmelCase__			)

							__magic_name__      :       str       						= 16
							__magic_name__      :       str       						= len(lowerCAmelCase__			)
							__magic_name__      :       int       						= max([len(lowerCAmelCase__			) for texts in input_texts]			)

							self.assertListEqual(list(inputs.keys()			)      ,       ["""input_ids""", """attention_mask"""]			)
							self.assertEqual(inputs["""input_ids"""].shape      ,       (batch_size * num_max_text_queries, seq_length)			)

							# test if it raises when no input is passed
							with pytest.raises(lowerCAmelCase__			):
													processor()
	def       __magic_name__    (    self			)							->				Any:
							__magic_name__      :       Optional[int]       						= """google/owlvit-base-patch32"""
							__magic_name__      :       Any       						= OwlViTProcessor.from_pretrained(lowerCAmelCase__			)

							__magic_name__      :       str       						= ["""cat""", """nasa badge"""]
							__magic_name__      :       List[str]       						= processor(text=lowerCAmelCase__			)

							__magic_name__      :       List[Any]       						= 16
							__magic_name__      :       Any       						= inputs["""input_ids"""]
							__magic_name__      :       Optional[Any]       						= [
							    [4_94_06, 23_68, 4_94_07, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
							    [4_94_06, 68_41, 1_13_01, 4_94_07, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
							]

							self.assertListEqual(list(inputs.keys()			)      ,       ["""input_ids""", """attention_mask"""]			)
							self.assertEqual(inputs["""input_ids"""].shape      ,       (2, seq_length)			)
							self.assertListEqual(list(input_ids[0]			)      ,       predicted_ids[0]			)
							self.assertListEqual(list(input_ids[1]			)      ,       predicted_ids[1]			)
	def       __magic_name__    (    self			)							->				Tuple:
							__magic_name__      :       List[str]       						= self.get_image_processor()
							__magic_name__      :       Dict       						= self.get_tokenizer()

							__magic_name__      :       Tuple       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)

							__magic_name__      :       Tuple       						= self.prepare_image_inputs()
							__magic_name__      :       List[Any]       						= self.prepare_image_inputs()

							__magic_name__      :       List[str]       						= processor(images=lowerCAmelCase__      ,       query_images=lowerCAmelCase__			)

							self.assertListEqual(list(inputs.keys()			)      ,       ["""query_pixel_values""", """pixel_values"""]			)

							# test if it raises when no input is passed
							with pytest.raises(lowerCAmelCase__			):
													processor()







	def       __magic_name__    (    self			)							->				Any:
							__magic_name__      :       Optional[Any]       						= self.get_image_processor()
							__magic_name__      :       List[Any]       						= self.get_tokenizer()

							__magic_name__      :       Tuple       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)

							__magic_name__      :       Union[str, Any]       						= [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

							__magic_name__      :       Optional[Any]       						= processor.batch_decode(lowerCAmelCase__			)
							__magic_name__      :       Optional[int]       						= tokenizer.batch_decode(lowerCAmelCase__			)

							self.assertListEqual(lowerCAmelCase__      ,       lowerCAmelCase__			)
