
"""simple docstring"""


from __future__ import annotations

from collections import deque




class  __lowerCamelCase  :




				def __init__(				self							,						UpperCAmelCase   ):
							lowerCamelCase_					=  []
							self.adlist.append(
							    {'''value''': '''''', '''next_states''': [], '''fail_state''': 0, '''output''': []}   )

							for keyword in keywords:
										self.add_keyword(UpperCAmelCase   )
							self.set_fail_transitions()




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase							,						UpperCAmelCase   ):







							for state in self.adlist[current_state]["next_states"]:
										if char == self.adlist[state]["value"]:
													return state
							return None




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase   ):
							lowerCamelCase_					=  0
							for character in keyword:
										lowerCamelCase_					=  self.find_next_state(UpperCAmelCase							,						UpperCAmelCase   )
										if next_state is None:
													self.adlist.append(
													    {
													        '''value''': character,
													        '''next_states''': [],
													        '''fail_state''': 0,
													        '''output''': [],
													    }   )
													self.adlist[current_state]["next_states"].append(len(self.adlist   ) - 1   )
													lowerCamelCase_					=  len(self.adlist   ) - 1
										else:
													lowerCamelCase_					=  next_state
							self.adlist[current_state]["output"].append(UpperCAmelCase   )




				def        UpperCAmelCase__						(				self   ):
							lowerCamelCase_					=  deque()
							for node in self.adlist[0]["next_states"]:
										q.append(UpperCAmelCase   )
										lowerCamelCase_					=  0
							while q:
										lowerCamelCase_					=  q.popleft()
										for child in self.adlist[r]["next_states"]:
													q.append(UpperCAmelCase   )
													lowerCamelCase_					=  self.adlist[r]['fail_state']
													while (
													    self.find_next_state(UpperCAmelCase							,						self.adlist[child]['''value''']   ) is None
													    and state != 0
													):
																lowerCamelCase_					=  self.adlist[state]['fail_state']
													lowerCamelCase_					=  self.find_next_state(
													    UpperCAmelCase							,						self.adlist[child]['''value''']   )
													if self.adlist[child]["fail_state"] is None:
																lowerCamelCase_					=  0
													lowerCamelCase_					=  (
													    self.adlist[child]['output']
													    + self.adlist[self.adlist[child]['fail_state']]['output']
													)





				def        UpperCAmelCase__						(				self							,						UpperCAmelCase   ):
							lowerCamelCase_					=  {}  # returns a dict with keywords and list of its occurrences
							lowerCamelCase_					=  0
							for i in range(len(UpperCAmelCase   )   ):
										while (
										    self.find_next_state(UpperCAmelCase							,						string[i]   ) is None
										    and current_state != 0
										):
													lowerCamelCase_					=  self.adlist[current_state]['fail_state']
										lowerCamelCase_					=  self.find_next_state(UpperCAmelCase							,						string[i]   )
										if next_state is None:
													lowerCamelCase_					=  0
										else:
													lowerCamelCase_					=  next_state
													for key in self.adlist[current_state]["output"]:
																if key not in result:
																			lowerCamelCase_					=  []
																result[key].append(i - len(UpperCAmelCase   ) + 1   )
							return result


if __name__ == "__main__":
						import doctest

						doctest.testmod()









'''simple docstring'''



import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

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

from transformers import AutoImageProcessor, ViTImageProcessor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


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

from test_module.custom_image_processing import CustomImageProcessor  # noqa E402


UpperCamelCase_    	=				get_tests_dir("fixtures")






class 							_a				(			unittest.TestCase ):





       '''simple docstring'''






       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						mock.Mock()
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						500
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						{}
             SCREAMING_SNAKE_CASE   :      Any    					=						HTTPError
             SCREAMING_SNAKE_CASE   :      Any    					=						{}

             # Download this model to make sure it's in the cache.
             SCREAMING_SNAKE_CASE   :      str    					=						ViTImageProcessor.from_pretrained('hf-internal-testing/tiny-random-vit'  )
             # Under the mock environment we get a 500 error when trying to reach the model.
             with mock.patch('requests.Session.request',							return_value=A  ) as mock_head:
                   SCREAMING_SNAKE_CASE   :      List[Any]    					=						ViTImageProcessor.from_pretrained('hf-internal-testing/tiny-random-vit'  )
                   # This check we did call the fake head request
                   mock_head.assert_called()







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Tuple    					=						ViTImageProcessor.from_pretrained(
                 'https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             with self.assertRaises(A  ):
                   # config is in subfolder, the following should not work without specifying the subfolder
                   SCREAMING_SNAKE_CASE   :      str    					=						AutoImageProcessor.from_pretrained('hf-internal-testing/stable-diffusion-all-variants'  )

             SCREAMING_SNAKE_CASE   :      Dict    					=						AutoImageProcessor.from_pretrained(
                 'hf-internal-testing/stable-diffusion-all-variants',							subfolder='feature_extractor'  )

             self.assertIsNotNone(A  )






@is_staging_test
class 							_a				(			unittest.TestCase ):





       '''simple docstring'''






       @classmethod
       def        UpperCamelCase_							(      cls  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Tuple    					=						TOKEN
             HfFolder.save_token(A  )







       @classmethod
       def        UpperCamelCase_							(      cls  ):







             '''simple docstring'''







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

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

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







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						ViTImageProcessor.from_pretrained(A  )
             image_processor.push_to_hub('test-image-processor',							use_auth_token=self._token  )

             SCREAMING_SNAKE_CASE   :      int    					=						ViTImageProcessor.from_pretrained(F"{USER}/test-image-processor"  )
             for k, v in image_processor.__dict__.items():
                   self.assertEqual(A,							getattr(A,							A  )  )

             # Reset repo
             delete_repo(token=self._token,							repo_id='test-image-processor'  )

             # Push to hub via save_pretrained
             with tempfile.TemporaryDirectory() as tmp_dir:
                   image_processor.save_pretrained(
                       A,							repo_id='test-image-processor',							push_to_hub=A,							use_auth_token=self._token  )

             SCREAMING_SNAKE_CASE   :      List[str]    					=						ViTImageProcessor.from_pretrained(F"{USER}/test-image-processor"  )
             for k, v in image_processor.__dict__.items():
                   self.assertEqual(A,							getattr(A,							A  )  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[Any]    					=						ViTImageProcessor.from_pretrained(A  )
             image_processor.push_to_hub('valid_org/test-image-processor',							use_auth_token=self._token  )

             SCREAMING_SNAKE_CASE   :      str    					=						ViTImageProcessor.from_pretrained('valid_org/test-image-processor'  )
             for k, v in image_processor.__dict__.items():
                   self.assertEqual(A,							getattr(A,							A  )  )

             # Reset repo
             delete_repo(token=self._token,							repo_id='valid_org/test-image-processor'  )

             # Push to hub via save_pretrained
             with tempfile.TemporaryDirectory() as tmp_dir:
                   image_processor.save_pretrained(
                       A,							repo_id='valid_org/test-image-processor-org',							push_to_hub=A,							use_auth_token=self._token  )

             SCREAMING_SNAKE_CASE   :      Dict    					=						ViTImageProcessor.from_pretrained('valid_org/test-image-processor-org'  )
             for k, v in image_processor.__dict__.items():
                   self.assertEqual(A,							getattr(A,							A  )  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             CustomImageProcessor.register_for_auto_class()
             SCREAMING_SNAKE_CASE   :      Tuple    					=						CustomImageProcessor.from_pretrained(A  )

             image_processor.push_to_hub('test-dynamic-image-processor',							use_auth_token=self._token  )

             # This has added the proper auto_map field to the config
             self.assertDictEqual(
                 image_processor.auto_map,							{'AutoImageProcessor': 'custom_image_processing.CustomImageProcessor'},							)

             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						AutoImageProcessor.from_pretrained(
                 F"{USER}/test-dynamic-image-processor",							trust_remote_code=A  )
             # Can't make an isinstance check because the new_image_processor is from the CustomImageProcessor class of a dynamic module
             self.assertEqual(new_image_processor.__class__.__name__,							'CustomImageProcessor'  )


