



import json
import os
import sys
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from huggingface_hub import HfFolder, Repository, create_repo, delete_repo
from requests.exceptions import HTTPError

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoProcessor,
    AutoTokenizer,
    BertTokenizer,
    ProcessorMixin,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
)
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test
from transformers.tokenization_utils import TOKENIZER_CONFIG_FILE
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_tokenizers_available


sys.path.append(str(Path(__file__).parent.parent.parent.parent / "utils"))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402
from test_module.custom_processing import CustomProcessor  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


a__      :				Dict   	=			get_tests_dir("fixtures/dummy_feature_extractor_config.json")
a__      :				Optional[Any]   	=			get_tests_dir("fixtures/vocab.json")
a__      :				List[Any]   	=			get_tests_dir("fixtures")



class       UpperCAmelCase__(							unittest.TestCase	):

			'''simple docstring'''




			A    :  Optional[int]       				=    ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"]


			def 			UpperCAmelCase		(						self  :			Optional[int])	->				Tuple:




									"""simple docstring"""

									lowercase__     =  0


			def 			UpperCAmelCase		(						self  :			List[str])	->				List[Any]:




									"""simple docstring"""

									lowercase__     =  AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h')
									self.assertIsInstance(lowerCAmelCase			,				lowerCAmelCase)


			def 			UpperCAmelCase		(						self  :			Optional[Any])	->				Union[str, Any]:




									"""simple docstring"""

									with tempfile.TemporaryDirectory() as tmpdirname:
															lowercase__     =  WavaVecaConfig()
															lowercase__     =  AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h')

															# save in new folder
															model_config.save_pretrained(lowerCAmelCase)
															processor.save_pretrained(lowerCAmelCase)

															lowercase__     =  AutoProcessor.from_pretrained(lowerCAmelCase)

									self.assertIsInstance(lowerCAmelCase			,				lowerCAmelCase)


			def 			UpperCAmelCase		(						self  :			Union[str, Any])	->				Optional[int]:




									"""simple docstring"""

									with tempfile.TemporaryDirectory() as tmpdirname:
															# copy relevant files
															copyfile(lowerCAmelCase			,				os.path.join(lowerCAmelCase			,				lowerCAmelCase))
															copyfile(lowerCAmelCase			,				os.path.join(lowerCAmelCase			,				'vocab.json'))

															lowercase__     =  AutoProcessor.from_pretrained(lowerCAmelCase)

									self.assertIsInstance(lowerCAmelCase			,				lowerCAmelCase)


			def 			UpperCAmelCase		(						self  :			List[str])	->				List[str]:




									"""simple docstring"""

									with tempfile.TemporaryDirectory() as tmpdirname:
															lowercase__     =  WavaVecaFeatureExtractor()
															lowercase__     =  AutoTokenizer.from_pretrained('facebook/wav2vec2-base-960h')

															lowercase__     =  WavaVecaProcessor(lowerCAmelCase			,				lowerCAmelCase)

															# save in new folder
															processor.save_pretrained(lowerCAmelCase)

															# drop `processor_class` in tokenizer
															with open(os.path.join(lowerCAmelCase			,				lowerCAmelCase)			,				'r') as f:
																					lowercase__     =  json.load(lowerCAmelCase)
																					config_dict.pop('processor_class')

															with open(os.path.join(lowerCAmelCase			,				lowerCAmelCase)			,				'w') as f:
																					f.write(json.dumps(lowerCAmelCase))

															lowercase__     =  AutoProcessor.from_pretrained(lowerCAmelCase)

									self.assertIsInstance(lowerCAmelCase			,				lowerCAmelCase)


			def 			UpperCAmelCase		(						self  :			Optional[int])	->				Dict:




									"""simple docstring"""

									with tempfile.TemporaryDirectory() as tmpdirname:
															lowercase__     =  WavaVecaFeatureExtractor()
															lowercase__     =  AutoTokenizer.from_pretrained('facebook/wav2vec2-base-960h')

															lowercase__     =  WavaVecaProcessor(lowerCAmelCase			,				lowerCAmelCase)

															# save in new folder
															processor.save_pretrained(lowerCAmelCase)

															# drop `processor_class` in feature extractor
															with open(os.path.join(lowerCAmelCase			,				lowerCAmelCase)			,				'r') as f:
																					lowercase__     =  json.load(lowerCAmelCase)
																					config_dict.pop('processor_class')

															with open(os.path.join(lowerCAmelCase			,				lowerCAmelCase)			,				'w') as f:
																					f.write(json.dumps(lowerCAmelCase))

															lowercase__     =  AutoProcessor.from_pretrained(lowerCAmelCase)

									self.assertIsInstance(lowerCAmelCase			,				lowerCAmelCase)


			def 			UpperCAmelCase		(						self  :			Dict)	->				Optional[Any]:




									"""simple docstring"""

									with tempfile.TemporaryDirectory() as tmpdirname:
															lowercase__     =  WavaVecaConfig(processor_class='Wav2Vec2Processor')
															model_config.save_pretrained(lowerCAmelCase)
															# copy relevant files
															copyfile(lowerCAmelCase			,				os.path.join(lowerCAmelCase			,				'vocab.json'))
															# create emtpy sample processor
															with open(os.path.join(lowerCAmelCase			,				lowerCAmelCase)			,				'w') as f:
																					f.write('{}')

															lowercase__     =  AutoProcessor.from_pretrained(lowerCAmelCase)

									self.assertIsInstance(lowerCAmelCase			,				lowerCAmelCase)


			def 			UpperCAmelCase		(						self  :			List[Any])	->				int:




									"""simple docstring"""

									with self.assertRaises(lowerCAmelCase):
															lowercase__     =  AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor')
									# If remote code is disabled, we can't load this config.
									with self.assertRaises(lowerCAmelCase):
															lowercase__     =  AutoProcessor.from_pretrained(
															    'hf-internal-testing/test_dynamic_processor'			,				trust_remote_code=lowerCAmelCase)

									lowercase__     =  AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor'			,				trust_remote_code=lowerCAmelCase)
									self.assertTrue(processor.special_attribute_present)
									self.assertEqual(processor.__class__.__name__			,				'NewProcessor')

									lowercase__     =  processor.feature_extractor
									self.assertTrue(feature_extractor.special_attribute_present)
									self.assertEqual(feature_extractor.__class__.__name__			,				'NewFeatureExtractor')

									lowercase__     =  processor.tokenizer
									self.assertTrue(tokenizer.special_attribute_present)
									if is_tokenizers_available():
															self.assertEqual(tokenizer.__class__.__name__			,				'NewTokenizerFast')

															# Test we can also load the slow version
															lowercase__     =  AutoProcessor.from_pretrained(
															    'hf-internal-testing/test_dynamic_processor'			,				trust_remote_code=lowerCAmelCase			,				use_fast=lowerCAmelCase)
															lowercase__     =  new_processor.tokenizer
															self.assertTrue(new_tokenizer.special_attribute_present)
															self.assertEqual(new_tokenizer.__class__.__name__			,				'NewTokenizer')
									else:
															self.assertEqual(tokenizer.__class__.__name__			,				'NewTokenizer')


			def 			UpperCAmelCase		(						self  :			Any)	->				Union[str, Any]:




									"""simple docstring"""

									try:
															AutoConfig.register('custom'			,				lowerCAmelCase)
															AutoFeatureExtractor.register(lowerCAmelCase			,				lowerCAmelCase)
															AutoTokenizer.register(lowerCAmelCase			,				slow_tokenizer_class=lowerCAmelCase)
															AutoProcessor.register(lowerCAmelCase			,				lowerCAmelCase)
															# Trying to register something existing in the Transformers library will raise an error
															with self.assertRaises(lowerCAmelCase):
																					AutoProcessor.register(lowerCAmelCase			,				lowerCAmelCase)

															# Now that the config is registered, it can be used as any other config with the auto-API
															lowercase__     =  CustomFeatureExtractor.from_pretrained(lowerCAmelCase)

															with tempfile.TemporaryDirectory() as tmp_dir:
																					lowercase__     =  os.path.join(lowerCAmelCase			,				'vocab.txt')
																					with open(lowerCAmelCase			,				'w'			,				encoding='utf-8') as vocab_writer:
																											vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]))
																					lowercase__     =  CustomTokenizer(lowerCAmelCase)

															lowercase__     =  CustomProcessor(lowerCAmelCase			,				lowerCAmelCase)

															with tempfile.TemporaryDirectory() as tmp_dir:
																					processor.save_pretrained(lowerCAmelCase)
																					lowercase__     =  AutoProcessor.from_pretrained(lowerCAmelCase)
																					self.assertIsInstance(lowerCAmelCase			,				lowerCAmelCase)

									finally:
															if "custom" in CONFIG_MAPPING._extra_content:
																					del CONFIG_MAPPING._extra_content["custom"]
															if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
																					del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
															if CustomConfig in TOKENIZER_MAPPING._extra_content:
																					del TOKENIZER_MAPPING._extra_content[CustomConfig]
															if CustomConfig in PROCESSOR_MAPPING._extra_content:
																					del PROCESSOR_MAPPING._extra_content[CustomConfig]


			def 			UpperCAmelCase		(						self  :			str)	->				Optional[int]:




									"""simple docstring"""

									class       UpperCAmelCase__(							lowerCamelCase	):

												'''simple docstring'''




												A    :  str       				=    False



									class       UpperCAmelCase__(							lowerCamelCase	):

												'''simple docstring'''




												A    :  Tuple       				=    False



									class       UpperCAmelCase__(							lowerCamelCase	):

												'''simple docstring'''




												A    :  Any       				=    "AutoFeatureExtractor"
												A    :  Any       				=    "AutoTokenizer"
												A    :  Union[str, Any]       				=    False

									try:
															AutoConfig.register('custom'			,				lowerCAmelCase)
															AutoFeatureExtractor.register(lowerCAmelCase			,				lowerCAmelCase)
															AutoTokenizer.register(lowerCAmelCase			,				slow_tokenizer_class=lowerCAmelCase)
															AutoProcessor.register(lowerCAmelCase			,				lowerCAmelCase)
															# If remote code is not set, the default is to use local classes.
															lowercase__     =  AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor')
															self.assertEqual(processor.__class__.__name__			,				'NewProcessor')
															self.assertFalse(processor.special_attribute_present)
															self.assertFalse(processor.feature_extractor.special_attribute_present)
															self.assertFalse(processor.tokenizer.special_attribute_present)

															# If remote code is disabled, we load the local ones.
															lowercase__     =  AutoProcessor.from_pretrained(
															    'hf-internal-testing/test_dynamic_processor'			,				trust_remote_code=lowerCAmelCase)
															self.assertEqual(processor.__class__.__name__			,				'NewProcessor')
															self.assertFalse(processor.special_attribute_present)
															self.assertFalse(processor.feature_extractor.special_attribute_present)
															self.assertFalse(processor.tokenizer.special_attribute_present)

															# If remote is enabled, we load from the Hub.
															lowercase__     =  AutoProcessor.from_pretrained(
															    'hf-internal-testing/test_dynamic_processor'			,				trust_remote_code=lowerCAmelCase)
															self.assertEqual(processor.__class__.__name__			,				'NewProcessor')
															self.assertTrue(processor.special_attribute_present)
															self.assertTrue(processor.feature_extractor.special_attribute_present)
															self.assertTrue(processor.tokenizer.special_attribute_present)

									finally:
															if "custom" in CONFIG_MAPPING._extra_content:
																					del CONFIG_MAPPING._extra_content["custom"]
															if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
																					del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
															if CustomConfig in TOKENIZER_MAPPING._extra_content:
																					del TOKENIZER_MAPPING._extra_content[CustomConfig]
															if CustomConfig in PROCESSOR_MAPPING._extra_content:
																					del PROCESSOR_MAPPING._extra_content[CustomConfig]


			def 			UpperCAmelCase		(						self  :			str)	->				Optional[int]:




									"""simple docstring"""

									lowercase__     =  AutoProcessor.from_pretrained('hf-internal-testing/tiny-random-bert')
									self.assertEqual(processor.__class__.__name__			,				'BertTokenizerFast')



			def 			UpperCAmelCase		(						self  :			List[Any])	->				Dict:




									"""simple docstring"""

									lowercase__     =  AutoProcessor.from_pretrained('hf-internal-testing/tiny-random-convnext')
									self.assertEqual(processor.__class__.__name__			,				'ConvNextImageProcessor')



@is_staging_test
class       UpperCAmelCase__(							unittest.TestCase	):

			'''simple docstring'''




			A    :  List[str]       				=    ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"]


			@classmethod
			def 			UpperCAmelCase		(						cls  :			Union[str, Any])	->				List[str]:




									"""simple docstring"""

									lowercase__     =  TOKEN
									HfFolder.save_token(lowerCAmelCase)


			@classmethod
			def 			UpperCAmelCase		(						cls  :			Dict)	->				List[str]:




									"""simple docstring"""

									try:
															delete_repo(token=cls._token			,				repo_id='test-processor')
									except HTTPError:
															pass

									try:
															delete_repo(token=cls._token			,				repo_id='valid_org/test-processor-org')
									except HTTPError:
															pass

									try:
															delete_repo(token=cls._token			,				repo_id='test-dynamic-processor')
									except HTTPError:
															pass


			def 			UpperCAmelCase		(						self  :			str)	->				List[str]:




									"""simple docstring"""

									lowercase__     =  WavaVecaProcessor.from_pretrained(lowerCAmelCase)
									with tempfile.TemporaryDirectory() as tmp_dir:
															processor.save_pretrained(
															    os.path.join(lowerCAmelCase			,				'test-processor')			,				push_to_hub=lowerCAmelCase			,				use_auth_token=self._token)

															lowercase__     =  WavaVecaProcessor.from_pretrained(f'''{USER}/test-processor''')
															for k, v in processor.feature_extractor.__dict__.items():
																					self.assertEqual(lowerCAmelCase			,				getattr(new_processor.feature_extractor			,				lowerCAmelCase))
															self.assertDictEqual(new_processor.tokenizer.get_vocab()			,				processor.tokenizer.get_vocab())


			def 			UpperCAmelCase		(						self  :			Union[str, Any])	->				Union[str, Any]:




									"""simple docstring"""

									lowercase__     =  WavaVecaProcessor.from_pretrained(lowerCAmelCase)

									with tempfile.TemporaryDirectory() as tmp_dir:
															processor.save_pretrained(
															    os.path.join(lowerCAmelCase			,				'test-processor-org')			,				push_to_hub=lowerCAmelCase			,				use_auth_token=self._token			,				organization='valid_org'			,				)

															lowercase__     =  WavaVecaProcessor.from_pretrained('valid_org/test-processor-org')
															for k, v in processor.feature_extractor.__dict__.items():
																					self.assertEqual(lowerCAmelCase			,				getattr(new_processor.feature_extractor			,				lowerCAmelCase))
															self.assertDictEqual(new_processor.tokenizer.get_vocab()			,				processor.tokenizer.get_vocab())



			def 			UpperCAmelCase		(						self  :			List[Any])	->				Optional[Any]:




									"""simple docstring"""

									CustomFeatureExtractor.register_for_auto_class()
									CustomTokenizer.register_for_auto_class()
									CustomProcessor.register_for_auto_class()

									lowercase__     =  CustomFeatureExtractor.from_pretrained(lowerCAmelCase)

									with tempfile.TemporaryDirectory() as tmp_dir:
															lowercase__     =  os.path.join(lowerCAmelCase			,				'vocab.txt')
															with open(lowerCAmelCase			,				'w'			,				encoding='utf-8') as vocab_writer:
																					vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]))
															lowercase__     =  CustomTokenizer(lowerCAmelCase)

									lowercase__     =  CustomProcessor(lowerCAmelCase			,				lowerCAmelCase)

									with tempfile.TemporaryDirectory() as tmp_dir:
															create_repo(f'''{USER}/test-dynamic-processor'''			,				token=self._token)
															lowercase__     =  Repository(lowerCAmelCase			,				clone_from=f'''{USER}/test-dynamic-processor'''			,				token=self._token)
															processor.save_pretrained(lowerCAmelCase)

															# This has added the proper auto_map field to the feature extractor config
															self.assertDictEqual(
															    processor.feature_extractor.auto_map			,				{
															        'AutoFeatureExtractor': 'custom_feature_extraction.CustomFeatureExtractor',
															        'AutoProcessor': 'custom_processing.CustomProcessor',
															    }			,				)

															# This has added the proper auto_map field to the tokenizer config
															with open(os.path.join(lowerCAmelCase			,				'tokenizer_config.json')) as f:
																					lowercase__     =  json.load(lowerCAmelCase)
															self.assertDictEqual(
															    tokenizer_config['auto_map']			,				{
															        'AutoTokenizer': ['custom_tokenization.CustomTokenizer', None],
															        'AutoProcessor': 'custom_processing.CustomProcessor',
															    }			,				)

															# The code has been copied from fixtures
															self.assertTrue(os.path.isfile(os.path.join(lowerCAmelCase			,				'custom_feature_extraction.py')))
															self.assertTrue(os.path.isfile(os.path.join(lowerCAmelCase			,				'custom_tokenization.py')))
															self.assertTrue(os.path.isfile(os.path.join(lowerCAmelCase			,				'custom_processing.py')))

															repo.push_to_hub()

									lowercase__     =  AutoProcessor.from_pretrained(f'''{USER}/test-dynamic-processor'''			,				trust_remote_code=lowerCAmelCase)
									# Can't make an isinstance check because the new_processor is from the CustomProcessor class of a dynamic module
									self.assertEqual(new_processor.__class__.__name__			,				'CustomProcessor')





import cva
import numpy as np



class       UpperCAmelCase__:

   '''simple docstring'''




   def __init__(						self  :			Union[str, Any]			,				lowerCAmelCase  :			float			,				lowerCAmelCase  :			int)	->				Dict:




         """simple docstring"""

         if k in (0.04, 0.06):
               lowercase__     =  k
               lowercase__     =  window_size
         else:
               raise ValueError('invalid k value')


   def __str__(						self  :			Tuple)	->				str:




         """simple docstring"""

         return str(self.k)



   def 			UpperCAmelCase		(						self  :			Union[str, Any]			,				lowerCAmelCase  :			str)	->				tuple[cva.Mat, list[list[int]]]:




         """simple docstring"""

         lowercase__     =  cva.imread(lowerCAmelCase			,				0)
         lowercase__,	lowercase__     =  img.shape
         lowercase__     =  []
         lowercase__     =  img.copy()
         lowercase__     =  cva.cvtColor(lowerCAmelCase			,				cva.COLOR_GRAY2RGB)
         lowercase__,	lowercase__     =  np.gradient(lowerCAmelCase)
         lowercase__     =  dx**2
         lowercase__     =  dy**2
         lowercase__     =  dx * dy
         lowercase__     =  0.04
         lowercase__     =  self.window_size // 2
         for y in range(lowerCAmelCase			,				h - offset):
               for x in range(lowerCAmelCase			,				w - offset):
                     lowercase__     =  ixx[
                         y - offset : y + offset + 1, x - offset : x + offset + 1
                     ].sum()
                     lowercase__     =  iyy[
                         y - offset : y + offset + 1, x - offset : x + offset + 1
                     ].sum()
                     lowercase__     =  ixy[
                         y - offset : y + offset + 1, x - offset : x + offset + 1
                     ].sum()

                     lowercase__     =  (wxx * wyy) - (wxy**2)
                     lowercase__     =  wxx + wyy
                     lowercase__     =  det - k * (trace**2)
                     # Can change the value
                     if r > 0.5:
                           corner_list.append([x, y, r])
                           color_img.itemset((y, x, 0)			,				0)
                           color_img.itemset((y, x, 1)			,				0)
                           color_img.itemset((y, x, 2)			,				2_55)
         return color_img, corner_list


if __name__ == "__main__":
       a__      :				Dict   	=			HarrisCorner(0.0_4, 3)
       a__	,		a__      :				Dict   	=			edge_detect.detect("path_to_image")
       cva.imwrite("detect.png", color_img)
