

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

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

from transformers import (
    AlbertTokenizer,
    AutoTokenizer,
    BertTokenizer,
    BertTokenizerFast,
    GPTaTokenizerFast,
    is_tokenizers_available,
)
from transformers.testing_utils import TOKEN, USER, is_staging_test, require_tokenizers
from transformers.tokenization_utils import Trie


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

from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
	from test_module.custom_tokenization_fast import CustomTokenizerFast



class     A__(unittest.TestCase				):
						"""simple docstring"""






						def        UpperCamelCase__ (  self  )			->      Union[str, Any]:
									a_		:		Dict      				=      mock.Mock()
									a_		:		str      				=      500
									a_		:		List[str]      				=      {}
									a_		:		List[Any]      				=      HTTPError
									a_		:		str      				=      {}

									# Download this model to make sure it's in the cache.
									a_		:		Tuple      				=      BertTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""  )

									# Under the mock environment we get a 500 error when trying to reach the tokenizer.
									with mock.patch("""requests.Session.request"""   ,	return_value=_lowercase  ) as mock_head:
												a_		:		Dict      				=      BertTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""  )
												# This check we did call the fake head request
												mock_head.assert_called()





						@require_tokenizers
						def        UpperCamelCase__ (  self  )			->      Dict:
									a_		:		str      				=      mock.Mock()
									a_		:		Optional[Any]      				=      500
									a_		:		str      				=      {}
									a_		:		Tuple      				=      HTTPError
									a_		:		str      				=      {}

									# Download this model to make sure it's in the cache.
									a_		:		str      				=      GPTaTokenizerFast.from_pretrained("""gpt2"""  )

									# Under the mock environment we get a 500 error when trying to reach the tokenizer.
									with mock.patch("""requests.Session.request"""   ,	return_value=_lowercase  ) as mock_head:
												a_		:		Union[str, Any]      				=      GPTaTokenizerFast.from_pretrained("""gpt2"""  )
												# This check we did call the fake head request
												mock_head.assert_called()





						def        UpperCamelCase__ (  self  )			->      Any:






									try:
												a_		:		Dict      				=      tempfile.mktemp()
												with open(_lowercase   ,	"""wb"""  ) as f:
															http_get("""https://huggingface.co/albert-base-v1/resolve/main/spiece.model"""   ,	_lowercase  )

												a_		:		List[str]      				=      AlbertTokenizer.from_pretrained(_lowercase  )
									finally:
												os.remove(_lowercase  )

									# Supporting this legacy load introduced a weird bug where the tokenizer would load local files if they are in
									# the current folder and have the right name.
									if os.path.isfile("""tokenizer.json"""  ):
												# We skip the test if the user has a `tokenizer.json` in this folder to avoid deleting it.
												return
									try:
												with open("""tokenizer.json"""   ,	"""wb"""  ) as f:
															http_get("""https://huggingface.co/hf-internal-testing/tiny-random-bert/blob/main/tokenizer.json"""   ,	_lowercase  )
												a_		:		List[Any]      				=      AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""  )
												# The tiny random BERT has a vocab size of 1024, tiny gpt2 as a vocab size of 1000
												self.assertEqual(tokenizer.vocab_size   ,	1_000  )
												# Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file.

									finally:
												os.remove("""tokenizer.json"""  )





						def        UpperCamelCase__ (  self  )			->      Any:
									a_		:		int      				=      AlbertTokenizer.from_pretrained("""https://huggingface.co/albert-base-v1/resolve/main/spiece.model"""  )







@is_staging_test
class     A__(unittest.TestCase				):
						"""simple docstring"""






						_A  :							int     =       ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''bla''', '''blou''']





						@classmethod
						def        UpperCamelCase__ (  cls  )			->      Optional[int]:
									a_		:		List[str]      				=      TOKEN
									HfFolder.save_token(_lowercase  )





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






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

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

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





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






									with tempfile.TemporaryDirectory() as tmp_dir:
												a_		:		str      				=      os.path.join(_lowercase   ,	"""vocab.txt"""  )
												with open(_lowercase   ,	"""w"""   ,	encoding="""utf-8"""  ) as vocab_writer:
															vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens]  )  )
												a_		:		List[Any]      				=      BertTokenizer(_lowercase  )

									tokenizer.push_to_hub("""test-tokenizer"""   ,	use_auth_token=self._token  )
									a_		:		Optional[Any]      				=      BertTokenizer.from_pretrained(F'''{USER}/test-tokenizer'''  )
									self.assertDictEqual(new_tokenizer.vocab   ,	tokenizer.vocab  )

									# Reset repo
									delete_repo(token=self._token   ,	repo_id="""test-tokenizer"""  )

									# Push to hub via save_pretrained
									with tempfile.TemporaryDirectory() as tmp_dir:
												tokenizer.save_pretrained(_lowercase   ,	repo_id="""test-tokenizer"""   ,	push_to_hub=_lowercase   ,	use_auth_token=self._token  )

									a_		:		int      				=      BertTokenizer.from_pretrained(F'''{USER}/test-tokenizer'''  )
									self.assertDictEqual(new_tokenizer.vocab   ,	tokenizer.vocab  )





						def        UpperCamelCase__ (  self  )			->      Any:






									with tempfile.TemporaryDirectory() as tmp_dir:
												a_		:		Union[str, Any]      				=      os.path.join(_lowercase   ,	"""vocab.txt"""  )
												with open(_lowercase   ,	"""w"""   ,	encoding="""utf-8"""  ) as vocab_writer:
															vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens]  )  )
												a_		:		Optional[int]      				=      BertTokenizer(_lowercase  )

									tokenizer.push_to_hub("""valid_org/test-tokenizer-org"""   ,	use_auth_token=self._token  )
									a_		:		List[Any]      				=      BertTokenizer.from_pretrained("""valid_org/test-tokenizer-org"""  )
									self.assertDictEqual(new_tokenizer.vocab   ,	tokenizer.vocab  )

									# Reset repo
									delete_repo(token=self._token   ,	repo_id="""valid_org/test-tokenizer-org"""  )

									# Push to hub via save_pretrained
									with tempfile.TemporaryDirectory() as tmp_dir:
												tokenizer.save_pretrained(
												    _lowercase   ,	repo_id="""valid_org/test-tokenizer-org"""   ,	push_to_hub=_lowercase   ,	use_auth_token=self._token  )

									a_		:		str      				=      BertTokenizer.from_pretrained("""valid_org/test-tokenizer-org"""  )
									self.assertDictEqual(new_tokenizer.vocab   ,	tokenizer.vocab  )





						@require_tokenizers
						def        UpperCamelCase__ (  self  )			->      str:
									CustomTokenizer.register_for_auto_class()
									with tempfile.TemporaryDirectory() as tmp_dir:
												a_		:		List[Any]      				=      os.path.join(_lowercase   ,	"""vocab.txt"""  )
												with open(_lowercase   ,	"""w"""   ,	encoding="""utf-8"""  ) as vocab_writer:
															vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens]  )  )
												a_		:		Optional[int]      				=      CustomTokenizer(_lowercase  )

									# No fast custom tokenizer
									tokenizer.push_to_hub("""test-dynamic-tokenizer"""   ,	use_auth_token=self._token  )

									a_		:		Dict      				=      AutoTokenizer.from_pretrained(F'''{USER}/test-dynamic-tokenizer'''   ,	trust_remote_code=_lowercase  )
									# Can't make an isinstance check because the new_model.config is from the CustomTokenizer class of a dynamic module
									self.assertEqual(tokenizer.__class__.__name__   ,	"""CustomTokenizer"""  )

									# Fast and slow custom tokenizer
									CustomTokenizerFast.register_for_auto_class()
									with tempfile.TemporaryDirectory() as tmp_dir:
												a_		:		Optional[Any]      				=      os.path.join(_lowercase   ,	"""vocab.txt"""  )
												with open(_lowercase   ,	"""w"""   ,	encoding="""utf-8"""  ) as vocab_writer:
															vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens]  )  )

												a_		:		str      				=      BertTokenizerFast.from_pretrained(_lowercase  )
												bert_tokenizer.save_pretrained(_lowercase  )
												a_		:		Any      				=      CustomTokenizerFast.from_pretrained(_lowercase  )

									tokenizer.push_to_hub("""test-dynamic-tokenizer"""   ,	use_auth_token=self._token  )

									a_		:		Union[str, Any]      				=      AutoTokenizer.from_pretrained(F'''{USER}/test-dynamic-tokenizer'''   ,	trust_remote_code=_lowercase  )
									# Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
									self.assertEqual(tokenizer.__class__.__name__   ,	"""CustomTokenizerFast"""  )
									a_		:		str      				=      AutoTokenizer.from_pretrained(
									    F'''{USER}/test-dynamic-tokenizer'''   ,	use_fast=_lowercase   ,	trust_remote_code=_lowercase  )
									# Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
									self.assertEqual(tokenizer.__class__.__name__   ,	"""CustomTokenizer"""  )







class     A__(unittest.TestCase				):
						"""simple docstring"""






						def        UpperCamelCase__ (  self  )			->      Dict:
									a_		:		Optional[Any]      				=      Trie()
									trie.add("""Hello 友達"""  )
									self.assertEqual(trie.data   ,	{"""H""": {"""e""": {"""l""": {"""l""": {"""o""": {""" """: {"""友""": {"""達""": {"""""": 1}}}}}}}}}  )
									trie.add("""Hello"""  )
									trie.data
									self.assertEqual(trie.data   ,	{"""H""": {"""e""": {"""l""": {"""l""": {"""o""": {"""""": 1, """ """: {"""友""": {"""達""": {"""""": 1}}}}}}}}}  )





						def        UpperCamelCase__ (  self  )			->      List[str]:
									a_		:		List[str]      				=      Trie()
									self.assertEqual(trie.split("""[CLS] This is a extra_id_100"""  )   ,	["""[CLS] This is a extra_id_100"""]  )
									trie.add("""[CLS]"""  )
									trie.add("""extra_id_1"""  )
									trie.add("""extra_id_100"""  )
									self.assertEqual(trie.split("""[CLS] This is a extra_id_100"""  )   ,	["""[CLS]""", """ This is a """, """extra_id_100"""]  )





						def        UpperCamelCase__ (  self  )			->      Tuple:
									a_		:		Dict      				=      Trie()
									trie.add("""A"""  )
									self.assertEqual(trie.split("""ABC"""  )   ,	["""A""", """BC"""]  )
									self.assertEqual(trie.split("""BCA"""  )   ,	["""BC""", """A"""]  )





						def        UpperCamelCase__ (  self  )			->      Dict:
									a_		:		List[Any]      				=      Trie()
									trie.add("""TOKEN]"""  )
									trie.add("""[SPECIAL_TOKEN]"""  )
									self.assertEqual(trie.split("""This is something [SPECIAL_TOKEN]"""  )   ,	["""This is something """, """[SPECIAL_TOKEN]"""]  )





						def        UpperCamelCase__ (  self  )			->      List[str]:
									a_		:		str      				=      Trie()
									trie.add("""A"""  )
									trie.add("""P"""  )
									trie.add("""[SPECIAL_TOKEN]"""  )
									self.assertEqual(trie.split("""This is something [SPECIAL_TOKEN]"""  )   ,	["""This is something """, """[SPECIAL_TOKEN]"""]  )





						def        UpperCamelCase__ (  self  )			->      Union[str, Any]:
									a_		:		Any      				=      Trie()
									trie.add("""AB"""  )
									trie.add("""B"""  )
									trie.add("""C"""  )
									self.assertEqual(trie.split("""ABC"""  )   ,	["""AB""", """C"""]  )





						def        UpperCamelCase__ (  self  )			->      Any:
									a_		:		List[str]      				=      Trie()
									trie.add("""ABC"""  )
									trie.add("""B"""  )
									trie.add("""CD"""  )
									self.assertEqual(trie.split("""ABCD"""  )   ,	["""ABC""", """D"""]  )





						def        UpperCamelCase__ (  self  )			->      Optional[int]:
									a_		:		Tuple      				=      Trie()
									a_		:		Optional[int]      				=      trie.cut_text("""ABC"""   ,	[0, 0, 2, 1, 2, 3]  )
									self.assertEqual(_lowercase   ,	["""AB""", """C"""]  )




'''simple docstring'''




from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available
from .timesteps import (
    fastaa_timesteps,
    smartaa_timesteps,
    smartaa_timesteps,
    smartaaa_timesteps,
    smartaaa_timesteps,
    superaa_timesteps,
    superaa_timesteps,
    superaaa_timesteps,
)





@dataclass
class  A				(							__snake_case						):
     __magic_name__						=		42
     __magic_name__						=		42
     __magic_name__						=		42


try:
      if not (is_transformers_available() and is_torch_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
      from .pipeline_if import IFPipeline
      from .pipeline_if_imgaimg import IFImgaImgPipeline
      from .pipeline_if_imgaimg_superresolution import IFImgaImgSuperResolutionPipeline
      from .pipeline_if_inpainting import IFInpaintingPipeline
      from .pipeline_if_inpainting_superresolution import IFInpaintingSuperResolutionPipeline
      from .pipeline_if_superresolution import IFSuperResolutionPipeline
      from .safety_checker import IFSafetyChecker
      from .watermark import IFWatermarker




