

'''simple docstring'''



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


UpperCAmelCase :       Union[str, Any]			   =     get_tests_dir('fixtures/dummy_feature_extractor_config.json')
UpperCAmelCase :       List[Any]			   =     get_tests_dir('fixtures/vocab.json')
UpperCAmelCase :       Optional[Any]			   =     get_tests_dir('fixtures')







class 						lowerCAmelCase__   (      unittest.TestCase					):



 """simple docstring"""



 lowerCAmelCase__  					=      ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"]
 def       UpperCAmelCase__		(		self					:       Any			)  -> str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      0
 def       UpperCAmelCase__		(		self					:       str			)  -> List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h"""			)
      self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       List[str]			)  -> Union[str, Any]:


      """simple docstring"""




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

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

           __SCREAMING_SNAKE_CASE     =      AutoProcessor.from_pretrained(__SCREAMING_SNAKE_CASE			)

      self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       Tuple			)  -> Tuple:


      """simple docstring"""




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

           __SCREAMING_SNAKE_CASE     =      AutoProcessor.from_pretrained(__SCREAMING_SNAKE_CASE			)

      self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       Dict			)  -> Tuple:


      """simple docstring"""




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

           __SCREAMING_SNAKE_CASE     =      WavaVecaProcessor(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)

           # save in new folder
           processor.save_pretrained(__SCREAMING_SNAKE_CASE			)

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

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

           __SCREAMING_SNAKE_CASE     =      AutoProcessor.from_pretrained(__SCREAMING_SNAKE_CASE			)

      self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       Any			)  -> str:


      """simple docstring"""




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

           __SCREAMING_SNAKE_CASE     =      WavaVecaProcessor(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)

           # save in new folder
           processor.save_pretrained(__SCREAMING_SNAKE_CASE			)

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

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

           __SCREAMING_SNAKE_CASE     =      AutoProcessor.from_pretrained(__SCREAMING_SNAKE_CASE			)

      self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       List[str]			)  -> List[str]:


      """simple docstring"""




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

           __SCREAMING_SNAKE_CASE     =      AutoProcessor.from_pretrained(__SCREAMING_SNAKE_CASE			)

      self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       Union[str, Any]			)  -> Tuple:


      """simple docstring"""




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

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

      __SCREAMING_SNAKE_CASE     =      processor.feature_extractor
      self.assertTrue(feature_extractor.special_attribute_present			)
      self.assertEqual(feature_extractor.__class__.__name__					,							"""NewFeatureExtractor"""			)

      __SCREAMING_SNAKE_CASE     =      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
           __SCREAMING_SNAKE_CASE     =      AutoProcessor.from_pretrained(
               """hf-internal-testing/test_dynamic_processor"""					,							trust_remote_code=__SCREAMING_SNAKE_CASE					,							use_fast=__SCREAMING_SNAKE_CASE			)
           __SCREAMING_SNAKE_CASE     =      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					:       Optional[Any]			)  -> Any:


      """simple docstring"""




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

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

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

           __SCREAMING_SNAKE_CASE     =      CustomProcessor(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)

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

      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					:       List[str]			)  -> Tuple:


      """simple docstring"""




      class 						lowerCAmelCase__   (      a					):



       """simple docstring"""



       lowerCAmelCase__  					=      False







      class 						lowerCAmelCase__   (      a					):



       """simple docstring"""



       lowerCAmelCase__  					=      False







      class 						lowerCAmelCase__   (      a					):



       """simple docstring"""



       lowerCAmelCase__  					=      "AutoFeatureExtractor"
       lowerCAmelCase__  					=      "AutoTokenizer"
       lowerCAmelCase__  					=      False

      try:
           AutoConfig.register("""custom"""					,							__SCREAMING_SNAKE_CASE			)
           AutoFeatureExtractor.register(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
           AutoTokenizer.register(__SCREAMING_SNAKE_CASE					,							slow_tokenizer_class=__SCREAMING_SNAKE_CASE			)
           AutoProcessor.register(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
           # If remote code is not set, the default is to use local classes.
           __SCREAMING_SNAKE_CASE     =      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.
           __SCREAMING_SNAKE_CASE     =      AutoProcessor.from_pretrained(
               """hf-internal-testing/test_dynamic_processor"""					,							trust_remote_code=__SCREAMING_SNAKE_CASE			)
           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.
           __SCREAMING_SNAKE_CASE     =      AutoProcessor.from_pretrained(
               """hf-internal-testing/test_dynamic_processor"""					,							trust_remote_code=__SCREAMING_SNAKE_CASE			)
           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					:       Union[str, Any]			)  -> Tuple:


      """simple docstring"""




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


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


      """simple docstring"""




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







@is_staging_test
class 						lowerCAmelCase__   (      unittest.TestCase					):



 """simple docstring"""



 lowerCAmelCase__  					=      ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"]
 @classmethod
 def       UpperCAmelCase__		(		cls					:       Any			)  -> Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      TOKEN
      HfFolder.save_token(__SCREAMING_SNAKE_CASE			)
 @classmethod
 def       UpperCAmelCase__		(		cls					:       int			)  -> int:


      """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					:       Optional[int]			)  -> Union[str, Any]:


      """simple docstring"""




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

           __SCREAMING_SNAKE_CASE     =      WavaVecaProcessor.from_pretrained(f'{USER}/test-processor'			)
           for k, v in processor.feature_extractor.__dict__.items():
                self.assertEqual(__SCREAMING_SNAKE_CASE					,							getattr(new_processor.feature_extractor					,							__SCREAMING_SNAKE_CASE			)			)
           self.assertDictEqual(new_processor.tokenizer.get_vocab()					,							processor.tokenizer.get_vocab()			)
 def       UpperCAmelCase__		(		self					:       Dict			)  -> Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      WavaVecaProcessor.from_pretrained(__SCREAMING_SNAKE_CASE			)

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

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


 def       UpperCAmelCase__		(		self					:       Any			)  -> Tuple:


      """simple docstring"""




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

      __SCREAMING_SNAKE_CASE     =      CustomFeatureExtractor.from_pretrained(__SCREAMING_SNAKE_CASE			)

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

      __SCREAMING_SNAKE_CASE     =      CustomProcessor(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)

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

           # 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(__SCREAMING_SNAKE_CASE					,							"""tokenizer_config.json"""			)			) as f:
                __SCREAMING_SNAKE_CASE     =      json.load(__SCREAMING_SNAKE_CASE			)
           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(__SCREAMING_SNAKE_CASE					,							"""custom_feature_extraction.py"""			)			)			)
           self.assertTrue(os.path.isfile(os.path.join(__SCREAMING_SNAKE_CASE					,							"""custom_tokenization.py"""			)			)			)
           self.assertTrue(os.path.isfile(os.path.join(__SCREAMING_SNAKE_CASE					,							"""custom_processing.py"""			)			)			)

           repo.push_to_hub()

      __SCREAMING_SNAKE_CASE     =      AutoProcessor.from_pretrained(f'{USER}/test-dynamic-processor'					,							trust_remote_code=__SCREAMING_SNAKE_CASE			)
      # 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"""			)









'''simple docstring'''



from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


UpperCAmelCase :       Optional[int]			   =     logging.get_logger(__name__)

UpperCAmelCase :       str			   =     {
    'facebook/convnextv2-tiny-1k-224': 'https://huggingface.co/facebook/convnextv2-tiny-1k-224/resolve/main/config.json',
}







class 						lowerCAmelCase__   (      a ,					a					):



 """simple docstring"""



 lowerCAmelCase__  					=      "convnextv2"
 def __init__(		self					:       Any					,							__SCREAMING_SNAKE_CASE					:       int=3					,							__SCREAMING_SNAKE_CASE					:       Dict=4					,							__SCREAMING_SNAKE_CASE					:       List[Any]=4					,							__SCREAMING_SNAKE_CASE					:       Optional[int]=None					,							__SCREAMING_SNAKE_CASE					:       Dict=None					,							__SCREAMING_SNAKE_CASE					:       Optional[int]="gelu"					,							__SCREAMING_SNAKE_CASE					:       Union[str, Any]=0.02					,							__SCREAMING_SNAKE_CASE					:       Dict=1E-12					,							__SCREAMING_SNAKE_CASE					:       List[str]=0.0					,							__SCREAMING_SNAKE_CASE					:       Optional[Any]=224					,							__SCREAMING_SNAKE_CASE					:       Tuple=None					,							__SCREAMING_SNAKE_CASE					:       List[str]=None					,							**__SCREAMING_SNAKE_CASE					:       Union[str, Any]					,							)  -> Union[str, Any]:


      """simple docstring"""




      super().__init__(**__SCREAMING_SNAKE_CASE			)

      __SCREAMING_SNAKE_CASE     =      num_channels
      __SCREAMING_SNAKE_CASE     =      patch_size
      __SCREAMING_SNAKE_CASE     =      num_stages
      __SCREAMING_SNAKE_CASE     =      [96, 192, 384, 768] if hidden_sizes is None else hidden_sizes
      __SCREAMING_SNAKE_CASE     =      [3, 3, 9, 3] if depths is None else depths
      __SCREAMING_SNAKE_CASE     =      hidden_act
      __SCREAMING_SNAKE_CASE     =      initializer_range
      __SCREAMING_SNAKE_CASE     =      layer_norm_eps
      __SCREAMING_SNAKE_CASE     =      drop_path_rate
      __SCREAMING_SNAKE_CASE     =      image_size
      __SCREAMING_SNAKE_CASE     =      ["""stem"""] + [f'stage{idx}' for idx in range(1					,							len(self.depths			) + 1			)]
      __SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE     =      get_aligned_output_features_output_indices(
          out_features=__SCREAMING_SNAKE_CASE					,							out_indices=__SCREAMING_SNAKE_CASE					,							stage_names=self.stage_names			)






