



import os
import sys
import unittest


lowercase_	       =			os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, '''utils'''))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
lowercase_	       =			os.path.join(git_repo_path, '''src''', '''transformers''')

lowercase_	       =			'\n{0} = None\n'

lowercase_	       =			'\nclass {0}(metaclass=DummyObject):\n    _backends = {1}\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, {1})\n'


lowercase_	       =			'\ndef {0}(*args, **kwargs):\n    requires_backends({0}, {1})\n'






class 						__a (     unittest.TestCase				):



 def 		UpperCamelCase							(						self							:    str)->							Optional[Any]:
      __lowerCAmelCase	   =find_backend("""    _import_structure[\"models.albert\"].append(\"AlbertTokenizerFast\")""")
      self.assertIsNone(UpperCamelCase__)

      __lowerCAmelCase	   =find_backend("""    if not is_tokenizers_available():""")
      self.assertEqual(UpperCamelCase__				,	"""tokenizers""")

      __lowerCAmelCase	   =find_backend("""    if not is_tensorflow_text_available():""")
      self.assertEqual(UpperCamelCase__				,	"""tensorflow_text""")

      __lowerCAmelCase	   =find_backend("""    if not (is_sentencepiece_available() and is_tokenizers_available()):""")
      self.assertEqual(UpperCamelCase__				,	"""sentencepiece_and_tokenizers""")

      __lowerCAmelCase	   =find_backend(
          """    if not (is_sentencepiece_available() and is_tensorflow_text_available()):""")
      self.assertEqual(UpperCamelCase__				,	"""sentencepiece_and_tensorflow_text""")

      __lowerCAmelCase	   =find_backend(
          """    if not (is_sentencepiece_available() and is_tokenizers_available() and is_vision_available()):""")
      self.assertEqual(UpperCamelCase__				,	"""sentencepiece_and_tokenizers_and_vision""")



 def 		UpperCamelCase							(						self							:    Union[str, Any])->							Tuple:
      __lowerCAmelCase	   =read_init()
      # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
      self.assertIn("""torch"""				,	UpperCamelCase__)
      self.assertIn("""tensorflow_text"""				,	UpperCamelCase__)
      self.assertIn("""sentencepiece_and_tokenizers"""				,	UpperCamelCase__)

      # Likewise, we can't assert on the exact content of a key
      self.assertIn("""BertModel"""				,	objects["""torch"""])
      self.assertIn("""TFBertModel"""				,	objects["""tf"""])
      self.assertIn("""FlaxBertModel"""				,	objects["""flax"""])
      self.assertIn("""BertModel"""				,	objects["""torch"""])
      self.assertIn("""TFBertTokenizer"""				,	objects["""tensorflow_text"""])
      self.assertIn("""convert_slow_tokenizer"""				,	objects["""sentencepiece_and_tokenizers"""])



 def 		UpperCamelCase							(						self							:    Optional[Any])->							Optional[Any]:
      __lowerCAmelCase	   =create_dummy_object("""CONSTANT"""				,	"""\'torch\'""")
      self.assertEqual(UpperCamelCase__				,	"""\nCONSTANT = None\n""")

      __lowerCAmelCase	   =create_dummy_object("""function"""				,	"""\'torch\'""")
      self.assertEqual(
          UpperCamelCase__				,	"""\ndef function(*args, **kwargs):\n    requires_backends(function, \'torch\')\n""")

      __lowerCAmelCase	   ='''
class FakeClass(metaclass=DummyObject):
    _backends = \'torch\'

    def __init__(self, *args, **kwargs):
        requires_backends(self, \'torch\')
'''
      __lowerCAmelCase	   =create_dummy_object("""FakeClass"""				,	"""\'torch\'""")
      self.assertEqual(UpperCamelCase__				,	UpperCamelCase__)



 def 		UpperCamelCase							(						self							:    List[Any])->							Union[str, Any]:
      __lowerCAmelCase	   ='''# This file is autogenerated by the command `make fix-copies`, do not edit.
from ..utils import DummyObject, requires_backends


CONSTANT = None


def function(*args, **kwargs):
    requires_backends(function, ["torch"])


class FakeClass(metaclass=DummyObject):
    _backends = ["torch"]

    def __init__(self, *args, **kwargs):
        requires_backends(self, ["torch"])
'''
      __lowerCAmelCase	   =create_dummy_files({"""torch""": ["""CONSTANT""", """function""", """FakeClass"""]})
      self.assertEqual(dummy_files["""torch"""]				,	UpperCamelCase__)









import warnings

from ...utils import logging
from .image_processing_poolformer import PoolFormerImageProcessor


lowercase_	       =			logging.get_logger(__name__)






class 						__a (     SCREAMING_SNAKE_CASE				):



	def __init__(						self							:    Optional[Any]				,	*snake_case_							:    List[str]				,	**snake_case_							:    Union[str, Any])->							None:
						warnings.warn(
						    """The class PoolFormerFeatureExtractor is deprecated and will be removed in version 5 of Transformers."""
						    """ Please use PoolFormerImageProcessor instead."""				,	snake_case_				,	)
						super().__init__(*snake_case_				,	**snake_case_)




