




import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin





@require_tokenizers
class 			lowerCamelCase_				( _SCREAMING_SNAKE_CASE			,  unittest.TestCase   ):


 '''simple docstring'''







 lowercase_							       =       CLIPTokenizer
 lowercase_							       =       CLIPTokenizerFast
 lowercase_							       =       True
 lowercase_							       =       {}
 lowercase_							       =       False



 def  lowerCAmelCase_    (				self    :						Optional[Any]		):
       super().setUp()

       # fmt: off
       SCREAMING_SNAKE_CASE_      		=     ['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
       SCREAMING_SNAKE_CASE_      		=     dict(zip(_lowerCAmelCase							,							range(len(_lowerCAmelCase		)		)		)		)
       SCREAMING_SNAKE_CASE_      		=     ['#version: 0.2', 'l o', 'lo w</w>', 'e r</w>']
       SCREAMING_SNAKE_CASE_      		=     {'unk_token': '<unk>'}

       SCREAMING_SNAKE_CASE_      		=     os.path.join(self.tmpdirname							,							VOCAB_FILES_NAMES['vocab_file']		)
       SCREAMING_SNAKE_CASE_      		=     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		)		)



 def  lowerCAmelCase_    (				self    :						str							,							**_lowerCAmelCase    :						Optional[Any]		):
       kwargs.update(self.special_tokens_map		)
       return CLIPTokenizer.from_pretrained(self.tmpdirname							,							**_lowerCAmelCase		)



 def  lowerCAmelCase_    (				self    :						Tuple							,							**_lowerCAmelCase    :						int		):
       kwargs.update(self.special_tokens_map		)
       return CLIPTokenizerFast.from_pretrained(self.tmpdirname							,							**_lowerCAmelCase		)



 def  lowerCAmelCase_    (				self    :						int							,							_lowerCAmelCase    :						List[Any]		):
       SCREAMING_SNAKE_CASE_      		=     'lower newer'
       SCREAMING_SNAKE_CASE_      		=     'lower newer'
       return input_text, output_text



 def  lowerCAmelCase_    (				self    :						str		):
       SCREAMING_SNAKE_CASE_      		=     CLIPTokenizer(self.vocab_file							,							self.merges_file							,							**self.special_tokens_map		)
       SCREAMING_SNAKE_CASE_      		=     'lower newer'
       SCREAMING_SNAKE_CASE_      		=     ['lo', 'w', 'er</w>', 'n', 'e', 'w', 'er</w>']
       SCREAMING_SNAKE_CASE_      		=     tokenizer.tokenize(_lowerCAmelCase		)
       self.assertListEqual(_lowerCAmelCase							,							_lowerCAmelCase		)

       SCREAMING_SNAKE_CASE_      		=     tokens + [tokenizer.unk_token]
       SCREAMING_SNAKE_CASE_      		=     [10, 2, 16, 9, 3, 2, 16, 20]
       self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCAmelCase		)							,							_lowerCAmelCase		)



 @require_ftfy
 def  lowerCAmelCase_    (				self    :						Dict		):
       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"		):
                   SCREAMING_SNAKE_CASE_      		=     self.tokenizer_class.from_pretrained(_lowerCAmelCase							,							**_lowerCAmelCase		)
                   SCREAMING_SNAKE_CASE_      		=     self.rust_tokenizer_class.from_pretrained(_lowerCAmelCase							,							**_lowerCAmelCase		)

                   SCREAMING_SNAKE_CASE_      		=     'A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d.'
                   SCREAMING_SNAKE_CASE_      		=     tokenizer_s.tokenize(_lowerCAmelCase		)
                   SCREAMING_SNAKE_CASE_      		=     tokenizer_r.tokenize(_lowerCAmelCase		)

                   self.assertListEqual(_lowerCAmelCase							,							_lowerCAmelCase		)

                   # Test that the tokenization is identical on an example containing a character (Latin Small Letter A
                   # with Tilde) encoded in 2 different ways
                   SCREAMING_SNAKE_CASE_      		=     'xa\u0303y' + ' ' + 'x\xe3y'
                   SCREAMING_SNAKE_CASE_      		=     tokenizer_s.tokenize(_lowerCAmelCase		)
                   SCREAMING_SNAKE_CASE_      		=     tokenizer_r.tokenize(_lowerCAmelCase		)

                   self.assertListEqual(_lowerCAmelCase							,							_lowerCAmelCase		)

                   # Test that the tokenization is identical on unicode of space type
                   SCREAMING_SNAKE_CASE_      		=     [
                       '\u0009',  # (horizontal tab, '\t')
                       '\u000B',  # (vertical tab)
                       '\u000C',  # (form feed)
                       '\u0020',  # (space, ' ')
                       '\u200E',  # (left-to-right mark):w
                       '\u200F',  # (right-to-left mark)
                   ]
                   for unicode_seq in spaces_unicodes:
                         SCREAMING_SNAKE_CASE_      		=     tokenizer_s.tokenize(_lowerCAmelCase		)
                         SCREAMING_SNAKE_CASE_      		=     tokenizer_r.tokenize(_lowerCAmelCase		)

                         self.assertListEqual(_lowerCAmelCase							,							_lowerCAmelCase		)

                   # Test that the tokenization is identical on unicode of line break type
                   SCREAMING_SNAKE_CASE_      		=     [
                       '\u000A',  # (line feed, '\n')
                       '\r\n',  # (carriage return and line feed, '\r\n')
                       '\u000D',  # (carriage return, '\r')
                       '\r',  # (carriage return, '\r')
                       '\u000D',  # (carriage return, '\r')
                       '\u2028',  # (line separator)
                       '\u2029',  # (paragraph separator)
                       # "\u0085", # (next line)
                   ]

                   # The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
                   # it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
                   # space (and thus into an empty list).

                   for unicode_seq in line_break_unicodes:
                         SCREAMING_SNAKE_CASE_      		=     tokenizer_s.tokenize(_lowerCAmelCase		)
                         SCREAMING_SNAKE_CASE_      		=     tokenizer_r.tokenize(_lowerCAmelCase		)

                         self.assertListEqual(_lowerCAmelCase							,							_lowerCAmelCase		)



 def  lowerCAmelCase_    (				self    :						Optional[int]		):
       # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space`
       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"		):
                   SCREAMING_SNAKE_CASE_      		=     'hello'  # `hello` is a token in the vocabulary of `pretrained_name`
                   SCREAMING_SNAKE_CASE_      		=     F"{text_of_1_token} {text_of_1_token}"

                   SCREAMING_SNAKE_CASE_      		=     self.rust_tokenizer_class.from_pretrained(
                       _lowerCAmelCase							,							use_fast=_lowerCAmelCase							,							)
                   SCREAMING_SNAKE_CASE_      		=     tokenizer_r(_lowerCAmelCase							,							return_offsets_mapping=_lowerCAmelCase							,							add_special_tokens=_lowerCAmelCase		)
                   self.assertEqual(encoding.offset_mapping[0]							,							(0, len(_lowerCAmelCase		))		)
                   self.assertEqual(
                       encoding.offset_mapping[1]							,							(len(_lowerCAmelCase		) + 1, len(_lowerCAmelCase		) + 1 + len(_lowerCAmelCase		))							,							)

                   SCREAMING_SNAKE_CASE_      		=     F" {text}"

                   SCREAMING_SNAKE_CASE_      		=     self.rust_tokenizer_class.from_pretrained(
                       _lowerCAmelCase							,							use_fast=_lowerCAmelCase							,							)
                   SCREAMING_SNAKE_CASE_      		=     tokenizer_r(_lowerCAmelCase							,							return_offsets_mapping=_lowerCAmelCase							,							add_special_tokens=_lowerCAmelCase		)
                   self.assertEqual(encoding.offset_mapping[0]							,							(1, 1 + len(_lowerCAmelCase		))		)
                   self.assertEqual(
                       encoding.offset_mapping[1]							,							(1 + len(_lowerCAmelCase		) + 1, 1 + len(_lowerCAmelCase		) + 1 + len(_lowerCAmelCase		))							,							)



 def  lowerCAmelCase_    (				self    :						Optional[int]		):
       # Test related to the breaking change introduced in transformers v4.17.0
       # We need to check that an error in raised when the user try to load a previous version of the tokenizer.
       with self.assertRaises(_lowerCAmelCase		) as context:
             self.rust_tokenizer_class.from_pretrained('robot-test/old-clip-tokenizer'		)

       self.assertTrue(
           context.exception.args[0].startswith(
               'The `backend_tokenizer` provided does not match the expected format.'		)		)



 @require_ftfy
 def  lowerCAmelCase_    (				self    :						Dict		):
       super().test_tokenization_python_rust_equals()




 def  lowerCAmelCase_    (				self    :						Any		):
       # CLIP always lower cases letters
       pass



import unittest

from huggingface_hub import hf_hub_download

from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor
from transformers.pipelines import VideoClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_decord,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
)

from .test_pipelines_common import ANY



@is_pipeline_test
@require_torch_or_tf
@require_vision
@require_decord
class 				A       (			unittest.TestCase				):
					'''simple docstring'''






					A__     =					MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING

					def     lowerCamelCase__	(self       :		List[str] ,   _UpperCAmelCase       :		List[str] ,   _UpperCAmelCase       :		Dict ,   _UpperCAmelCase       :		Tuple						)		->  Tuple:




							"""simple docstring"""


							lowercase__	     =						hf_hub_download(
							    repo_id="""nateraw/video-demo""" ,   filename="""archery.mp4""" ,   repo_type="""dataset"""						)
							lowercase__	     =						VideoClassificationPipeline(model=_UpperCAmelCase ,   image_processor=_UpperCAmelCase ,   top_k=2						)
							lowercase__	     =						[
							    example_video_filepath,
							    """https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4""",
							]
							return video_classifier, examples

					def     lowerCamelCase__	(self       :		List[str] ,   _UpperCAmelCase       :		Union[str, Any] ,   _UpperCAmelCase       :		Tuple						)		->  List[Any]:




							"""simple docstring"""


							for example in examples:
									lowercase__	     =						video_classifier(_UpperCAmelCase						)

									self.assertEqual(
									    _UpperCAmelCase ,   [
									        {"""score""": ANY(_UpperCAmelCase						), """label""": ANY(_UpperCAmelCase						)},
									        {"""score""": ANY(_UpperCAmelCase						), """label""": ANY(_UpperCAmelCase						)},
									    ] ,   )

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




							"""simple docstring"""


							lowercase__	     =						"""hf-internal-testing/tiny-random-VideoMAEForVideoClassification"""
							lowercase__	     =						VideoMAEFeatureExtractor(
							    size={"""shortest_edge""": 10} ,   crop_size={"""height""": 10, """width""": 10}						)
							lowercase__	     =						pipeline(
							    """video-classification""" ,   model=_UpperCAmelCase ,   feature_extractor=_UpperCAmelCase ,   frame_sampling_rate=4						)

							lowercase__	     =						hf_hub_download(repo_id="""nateraw/video-demo""" ,   filename="""archery.mp4""" ,   repo_type="""dataset"""						)
							lowercase__	     =						video_classifier(_UpperCAmelCase ,   top_k=2						)
							self.assertEqual(
							    nested_simplify(_UpperCAmelCase ,   decimals=4						) ,   [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}] ,   )

							lowercase__	     =						video_classifier(
							    [
							        video_file_path,
							        video_file_path,
							    ] ,   top_k=2 ,   )
							self.assertEqual(
							    nested_simplify(_UpperCAmelCase ,   decimals=4						) ,   [
							        [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}],
							        [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}],
							    ] ,   )


					@require_tf
					def     lowerCamelCase__	(self       :		Any						)		->  Union[str, Any]:




							"""simple docstring"""


							pass

