




'''simple docstring'''




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

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


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

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
     from test_module.custom_tokenization_fast import CustomTokenizerFast


class     __UpperCamelCase			(					unittest.TestCase							):






       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=0






       @slow
       def 	lowercase__	(				self    ):



              """simple docstring"""







              for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
                     lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase    )
                     self.assertIsNotNone(lowerCAmelCase    )
                     self.assertIsInstance(lowerCAmelCase,						(BertTokenizer, BertTokenizerFast)    )
                     self.assertGreater(len(lowerCAmelCase    ),						0    )

              for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
                     lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase    )
                     self.assertIsNotNone(lowerCAmelCase    )
                     self.assertIsInstance(lowerCAmelCase,						(GPTaTokenizer, GPTaTokenizerFast)    )
                     self.assertGreater(len(lowerCAmelCase    ),						0    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase    )
              self.assertIsInstance(lowerCAmelCase,						(BertTokenizer, BertTokenizerFast)    )
              self.assertEqual(tokenizer.vocab_size,						12    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase    )
              self.assertIsInstance(lowerCAmelCase,						(RobertaTokenizer, RobertaTokenizerFast)    )
              self.assertEqual(tokenizer.vocab_size,						20    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=AutoConfig.from_pretrained(lowerCAmelCase    )
              self.assertIsInstance(lowerCAmelCase,						lowerCAmelCase    )
              # Check that tokenizer_type ≠ model_type
              lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase,						config=lowerCAmelCase    )
              self.assertIsInstance(lowerCAmelCase,						(BertTokenizer, BertTokenizerFast)    )
              self.assertEqual(tokenizer.vocab_size,						12    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              with tempfile.TemporaryDirectory() as tmp_dir:
                     shutil.copy('''./tests/fixtures/vocab.txt''',						os.path.join(lowerCAmelCase,						'''vocab.txt'''    )    )

                     lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase,						tokenizer_type='''bert''',						use_fast=lowerCAmelCase    )
                     self.assertIsInstance(lowerCAmelCase,						lowerCAmelCase    )

              with tempfile.TemporaryDirectory() as tmp_dir:
                     shutil.copy('''./tests/fixtures/vocab.json''',						os.path.join(lowerCAmelCase,						'''vocab.json'''    )    )
                     shutil.copy('''./tests/fixtures/merges.txt''',						os.path.join(lowerCAmelCase,						'''merges.txt'''    )    )

                     lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase,						tokenizer_type='''gpt2''',						use_fast=lowerCAmelCase    )
                     self.assertIsInstance(lowerCAmelCase,						lowerCAmelCase    )






       @require_tokenizers
       def 	lowercase__	(				self    ):



              """simple docstring"""







              with tempfile.TemporaryDirectory() as tmp_dir:
                     shutil.copy('''./tests/fixtures/vocab.txt''',						os.path.join(lowerCAmelCase,						'''vocab.txt'''    )    )

                     lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase,						tokenizer_type='''bert'''    )
                     self.assertIsInstance(lowerCAmelCase,						lowerCAmelCase    )

              with tempfile.TemporaryDirectory() as tmp_dir:
                     shutil.copy('''./tests/fixtures/vocab.json''',						os.path.join(lowerCAmelCase,						'''vocab.json'''    )    )
                     shutil.copy('''./tests/fixtures/merges.txt''',						os.path.join(lowerCAmelCase,						'''merges.txt'''    )    )

                     lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase,						tokenizer_type='''gpt2'''    )
                     self.assertIsInstance(lowerCAmelCase,						lowerCAmelCase    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              with pytest.raises(lowerCAmelCase    ):
                     AutoTokenizer.from_pretrained('''./''',						tokenizer_type='''xxx'''    )






       @require_tokenizers
       def 	lowercase__	(				self    ):



              """simple docstring"""







              for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
                     lowerCamelCase_				=tokenizer_class.from_pretrained('''wietsedv/bert-base-dutch-cased'''    )
                     self.assertIsInstance(lowerCAmelCase,						(BertTokenizer, BertTokenizerFast)    )

                     if isinstance(lowerCAmelCase,						lowerCAmelCase    ):
                            self.assertEqual(tokenizer.basic_tokenizer.do_lower_case,						lowerCAmelCase    )
                     else:
                            self.assertEqual(tokenizer.do_lower_case,						lowerCAmelCase    )

                     self.assertEqual(tokenizer.model_max_length,						512    )






       @require_tokenizers
       def 	lowercase__	(				self    ):



              """simple docstring"""







              for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
                     with self.assertRaisesRegex(
                         lowerCAmelCase,						'''julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier''',						):
                            lowerCamelCase_				=tokenizer_class.from_pretrained('''julien-c/herlolip-not-exists'''    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=TOKENIZER_MAPPING.values()
              lowerCamelCase_				=[]

              for slow_tok, fast_tok in tokenizers:
                     if slow_tok is not None:
                            tokenizer_names.append(slow_tok.__name__    )

                     if fast_tok is not None:
                            tokenizer_names.append(fast_tok.__name__    )

              for tokenizer_name in tokenizer_names:
                     # must find the right class
                     tokenizer_class_from_name(lowerCAmelCase    )






       @require_tokenizers
       def 	lowercase__	(				self    ):



              """simple docstring"""







              self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased''',						use_fast=lowerCAmelCase    ),						lowerCAmelCase    )
              self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''    ),						lowerCAmelCase    )






       @require_tokenizers
       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=AutoTokenizer.from_pretrained('''distilbert-base-uncased''',						do_lower_case=lowerCAmelCase    )
              lowerCamelCase_				='''Hello, world. How are you?'''
              lowerCamelCase_				=tokenizer.tokenize(lowerCAmelCase    )
              self.assertEqual('''[UNK]''',						tokens[0]    )

              lowerCamelCase_				=AutoTokenizer.from_pretrained('''microsoft/mpnet-base''',						do_lower_case=lowerCAmelCase    )
              lowerCamelCase_				=tokenizer.tokenize(lowerCAmelCase    )
              self.assertEqual('''[UNK]''',						tokens[0]    )






       @require_tokenizers
       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config'''    )
              self.assertEqual(type(lowerCAmelCase    ),						lowerCAmelCase    )
              self.assertEqual(tokenizer.model_max_length,						512    )
              self.assertEqual(tokenizer.vocab_size,						30_000    )
              self.assertEqual(tokenizer.unk_token,						'''[UNK]'''    )
              self.assertEqual(tokenizer.padding_side,						'''right'''    )
              self.assertEqual(tokenizer.truncation_side,						'''right'''    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase    )
              self.assertIsInstance(lowerCAmelCase,						(BertTokenizer, BertTokenizerFast)    )
              with tempfile.TemporaryDirectory() as tmp_dir:
                     tokenizer.save_pretrained(lowerCAmelCase    )
                     lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase    )

              self.assertIsInstance(lowerCAmelCase,						tokenizer.__class__    )
              self.assertEqual(tokenizera.vocab_size,						12    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=AutoTokenizer.from_pretrained('''ctrl'''    )
              # There is no fast CTRL so this always gives us a slow tokenizer.
              self.assertIsInstance(lowerCAmelCase,						lowerCAmelCase    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=get_tokenizer_config('''bert-base-cased'''    )
              lowerCamelCase_				=config.pop('''_commit_hash''',						lowerCAmelCase    )
              # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
              self.assertEqual(lowerCAmelCase,						{'''do_lower_case''': False}    )

              # This model does not have a tokenizer_config so we get back an empty dict.
              lowerCamelCase_				=get_tokenizer_config(lowerCAmelCase    )
              self.assertDictEqual(lowerCAmelCase,						{}    )

              # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
              lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase    )
              with tempfile.TemporaryDirectory() as tmp_dir:
                     tokenizer.save_pretrained(lowerCAmelCase    )
                     lowerCamelCase_				=get_tokenizer_config(lowerCAmelCase    )

              # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
              self.assertEqual(config['''tokenizer_class'''],						'''BertTokenizer'''    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              try:
                     AutoConfig.register('''custom''',						lowerCAmelCase    )

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

                     lowerCamelCase_				=CustomTokenizer.from_pretrained(lowerCAmelCase    )
                     with tempfile.TemporaryDirectory() as tmp_dir:
                            tokenizer.save_pretrained(lowerCAmelCase    )

                            lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase    )
                            self.assertIsInstance(lowerCAmelCase,						lowerCAmelCase    )

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






       @require_tokenizers
       def 	lowercase__	(				self    ):



              """simple docstring"""







              try:
                     AutoConfig.register('''custom''',						lowerCAmelCase    )

                     # Can register in two steps
                     AutoTokenizer.register(lowerCAmelCase,						slow_tokenizer_class=lowerCAmelCase    )
                     self.assertEqual(TOKENIZER_MAPPING[CustomConfig],						(CustomTokenizer, None)    )
                     AutoTokenizer.register(lowerCAmelCase,						fast_tokenizer_class=lowerCAmelCase    )
                     self.assertEqual(TOKENIZER_MAPPING[CustomConfig],						(CustomTokenizer, CustomTokenizerFast)    )

                     del TOKENIZER_MAPPING._extra_content[CustomConfig]
                     # Can register in one step
                     AutoTokenizer.register(
                         lowerCAmelCase,						slow_tokenizer_class=lowerCAmelCase,						fast_tokenizer_class=lowerCAmelCase    )
                     self.assertEqual(TOKENIZER_MAPPING[CustomConfig],						(CustomTokenizer, CustomTokenizerFast)    )

                     # Trying to register something existing in the Transformers library will raise an error
                     with self.assertRaises(lowerCAmelCase    ):
                            AutoTokenizer.register(lowerCAmelCase,						fast_tokenizer_class=lowerCAmelCase    )

                     # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
                     # and that model does not have a tokenizer.json
                     with tempfile.TemporaryDirectory() as tmp_dir:
                            lowerCamelCase_				=BertTokenizerFast.from_pretrained(lowerCAmelCase    )
                            bert_tokenizer.save_pretrained(lowerCAmelCase    )
                            lowerCamelCase_				=CustomTokenizerFast.from_pretrained(lowerCAmelCase    )

                     with tempfile.TemporaryDirectory() as tmp_dir:
                            tokenizer.save_pretrained(lowerCAmelCase    )

                            lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase    )
                            self.assertIsInstance(lowerCAmelCase,						lowerCAmelCase    )

                            lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase,						use_fast=lowerCAmelCase    )
                            self.assertIsInstance(lowerCAmelCase,						lowerCAmelCase    )

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






       def 	lowercase__	(				self    ):



              """simple docstring"""







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

              lowerCamelCase_				=AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer''',						trust_remote_code=lowerCAmelCase    )
              self.assertTrue(tokenizer.special_attribute_present    )
              # Test tokenizer can be reloaded.
              with tempfile.TemporaryDirectory() as tmp_dir:
                     tokenizer.save_pretrained(lowerCAmelCase    )
                     lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase,						trust_remote_code=lowerCAmelCase    )
              self.assertTrue(reloaded_tokenizer.special_attribute_present    )

              if is_tokenizers_available():
                     self.assertEqual(tokenizer.__class__.__name__,						'''NewTokenizerFast'''    )
                     self.assertEqual(reloaded_tokenizer.__class__.__name__,						'''NewTokenizerFast'''    )

                     # Test we can also load the slow version
                     lowerCamelCase_				=AutoTokenizer.from_pretrained(
                         '''hf-internal-testing/test_dynamic_tokenizer''',						trust_remote_code=lowerCAmelCase,						use_fast=lowerCAmelCase    )
                     self.assertTrue(tokenizer.special_attribute_present    )
                     self.assertEqual(tokenizer.__class__.__name__,						'''NewTokenizer'''    )
                     # Test tokenizer can be reloaded.
                     with tempfile.TemporaryDirectory() as tmp_dir:
                            tokenizer.save_pretrained(lowerCAmelCase    )
                            lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase,						trust_remote_code=lowerCAmelCase,						use_fast=lowerCAmelCase    )
                     self.assertEqual(reloaded_tokenizer.__class__.__name__,						'''NewTokenizer'''    )
                     self.assertTrue(reloaded_tokenizer.special_attribute_present    )
              else:
                     self.assertEqual(tokenizer.__class__.__name__,						'''NewTokenizer'''    )
                     self.assertEqual(reloaded_tokenizer.__class__.__name__,						'''NewTokenizer'''    )






       @require_tokenizers
       def 	lowercase__	(				self    ):



              """simple docstring"""







              class     __UpperCamelCase			(					lowerCamelCase__							):
                     lowercase      :       Optional[Any] 		=False





              class     __UpperCamelCase			(					lowerCamelCase__							):
                     lowercase      :       str 		=NewTokenizer
                     lowercase      :       Optional[int] 		=False

              try:
                     AutoConfig.register('''custom''',						lowerCAmelCase    )
                     AutoTokenizer.register(lowerCAmelCase,						slow_tokenizer_class=lowerCAmelCase    )
                     AutoTokenizer.register(lowerCAmelCase,						fast_tokenizer_class=lowerCAmelCase    )
                     # If remote code is not set, the default is to use local
                     lowerCamelCase_				=AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''    )
                     self.assertEqual(tokenizer.__class__.__name__,						'''NewTokenizerFast'''    )
                     self.assertFalse(tokenizer.special_attribute_present    )
                     lowerCamelCase_				=AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer''',						use_fast=lowerCAmelCase    )
                     self.assertEqual(tokenizer.__class__.__name__,						'''NewTokenizer'''    )
                     self.assertFalse(tokenizer.special_attribute_present    )

                     # If remote code is disabled, we load the local one.
                     lowerCamelCase_				=AutoTokenizer.from_pretrained(
                         '''hf-internal-testing/test_dynamic_tokenizer''',						trust_remote_code=lowerCAmelCase    )
                     self.assertEqual(tokenizer.__class__.__name__,						'''NewTokenizerFast'''    )
                     self.assertFalse(tokenizer.special_attribute_present    )
                     lowerCamelCase_				=AutoTokenizer.from_pretrained(
                         '''hf-internal-testing/test_dynamic_tokenizer''',						trust_remote_code=lowerCAmelCase,						use_fast=lowerCAmelCase    )
                     self.assertEqual(tokenizer.__class__.__name__,						'''NewTokenizer'''    )
                     self.assertFalse(tokenizer.special_attribute_present    )

                     # If remote is enabled, we load from the Hub
                     lowerCamelCase_				=AutoTokenizer.from_pretrained(
                         '''hf-internal-testing/test_dynamic_tokenizer''',						trust_remote_code=lowerCAmelCase    )
                     self.assertEqual(tokenizer.__class__.__name__,						'''NewTokenizerFast'''    )
                     self.assertTrue(tokenizer.special_attribute_present    )
                     lowerCamelCase_				=AutoTokenizer.from_pretrained(
                         '''hf-internal-testing/test_dynamic_tokenizer''',						trust_remote_code=lowerCAmelCase,						use_fast=lowerCAmelCase    )
                     self.assertEqual(tokenizer.__class__.__name__,						'''NewTokenizer'''    )
                     self.assertTrue(tokenizer.special_attribute_present    )

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






       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=AutoTokenizer.from_pretrained(
                  '''hf-internal-testing/test_dynamic_tokenizer_legacy''',						trust_remote_code=lowerCAmelCase    )
              self.assertTrue(tokenizer.special_attribute_present    )
              if is_tokenizers_available():
                     self.assertEqual(tokenizer.__class__.__name__,						'''NewTokenizerFast'''    )

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






       def 	lowercase__	(				self    ):



              """simple docstring"""







              with self.assertRaisesRegex(
                  lowerCAmelCase,						'''bert-base is not a local folder and is not a valid model identifier'''    ):
                     lowerCamelCase_				=AutoTokenizer.from_pretrained('''bert-base'''    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              with self.assertRaisesRegex(
                  lowerCAmelCase,						R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''    ):
                     lowerCamelCase_				=AutoTokenizer.from_pretrained(lowerCAmelCase,						revision='''aaaaaa'''    )






       def 	lowercase__	(				self    ):



              """simple docstring"""







              lowerCamelCase_				=AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''    )
              with RequestCounter() as counter:
                     lowerCamelCase_				=AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''    )
                     self.assertEqual(counter.get_request_count,						0    )
                     self.assertEqual(counter.head_request_count,						1    )
                     self.assertEqual(counter.other_request_count,						0    )










'''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 	_snake_case(			UpperCAmelCase      ):
 __snake_case:							Union[List[PIL.Image.Image], np.ndarray]
 __snake_case:							Optional[List[bool]]
 __snake_case:							Optional[List[bool]]


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


