





import os
import re
import sys
import traceback
import warnings
from pathlib import Path
from typing import Dict, Optional, Union
from uuid import uuida

from huggingface_hub import HfFolder, ModelCard, ModelCardData, hf_hub_download, whoami
from huggingface_hub.file_download import REGEX_COMMIT_HASH
from huggingface_hub.utils import (
    EntryNotFoundError,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    is_jinja_available,
)
from packaging import version
from requests import HTTPError

from .. import __version__
from .constants import (
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    SAFETENSORS_WEIGHTS_NAME,
    WEIGHTS_NAME,
)
from .import_utils import (
    ENV_VARS_TRUE_VALUES,
    _flax_version,
    _jax_version,
    _onnxruntime_version,
    _torch_version,
    is_flax_available,
    is_onnx_available,
    is_torch_available,
)
from .logging import get_logger


__UpperCAmelCase	:       Dict        =							get_logger(__name__)


__UpperCAmelCase	:       Optional[Any]        =							Path(__file__).parent / "model_card_template.md"
__UpperCAmelCase	:       int        =							uuida().hex
__UpperCAmelCase	:       Optional[Any]        =							os.getenv("HF_HUB_OFFLINE", "").upper() in ENV_VARS_TRUE_VALUES
__UpperCAmelCase	:       Optional[Any]        =							os.getenv("DISABLE_TELEMETRY", "").upper() in ENV_VARS_TRUE_VALUES
__UpperCAmelCase	:       Union[str, Any]        =							HUGGINGFACE_CO_RESOLVE_ENDPOINT + "/api/telemetry/"







def       A__							(   SCREAMING_SNAKE_CASE__ = None)       ->   str:
  __snake_case:						int			  =						F'''diffusers/{__version__}; python/{sys.version.split()[0]}; session_id/{SESSION_ID}'''
  if DISABLE_TELEMETRY or HF_HUB_OFFLINE:
    return ua + "; telemetry/off"
  if is_torch_available():
    ua += F'''; torch/{_torch_version}'''
  if is_flax_available():
    ua += F'''; jax/{_jax_version}'''
    ua += F'''; flax/{_flax_version}'''
  if is_onnx_available():
    ua += F'''; onnxruntime/{_onnxruntime_version}'''
  # CI will set this value to True
  if os.environ.get("""DIFFUSERS_IS_CI""" , """""").upper() in ENV_VARS_TRUE_VALUES:
    ua += "; is_ci/true"
  if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__):
    ua += "; " + "; ".join(F'''{k}/{v}''' for k, v in user_agent.items())
  elif isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__):
    ua += "; " + user_agent
  return ua







def       A__							(   SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = None , SCREAMING_SNAKE_CASE__ = None)       ->   List[Any]:
  if token is None:
    __snake_case:						List[Any]			  =						HfFolder.get_token()
  if organization is None:
    __snake_case:						List[Any]			  =						whoami(SCREAMING_SNAKE_CASE__)["""name"""]
    return F'''{username}/{model_id}'''
  else:
    return F'''{organization}/{model_id}'''







def       A__							(   SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)       ->   List[str]:
  if not is_jinja_available():
    raise ValueError(
        """Modelcard rendering is based on Jinja templates."""
        """ Please make sure to have `jinja` installed before using `create_model_card`."""
        """ To install it, please run `pip install Jinja2`.""")

  if hasattr(SCREAMING_SNAKE_CASE__ , """local_rank""") and args.local_rank not in [-1, 0]:
    return

  __snake_case:						Tuple			  =						args.hub_token if hasattr(SCREAMING_SNAKE_CASE__ , """hub_token""") else None
  __snake_case:						Optional[Any]			  =						get_full_repo_name(SCREAMING_SNAKE_CASE__ , token=SCREAMING_SNAKE_CASE__)

  __snake_case:						Tuple			  =						ModelCard.from_template(
      card_data=ModelCardData(  # Card metadata object that will be converted to YAML block
          language="""en""" , license="""apache-2.0""" , library_name="""diffusers""" , tags=[] , datasets=args.dataset_name , metrics=[] , ) , template_path=SCREAMING_SNAKE_CASE__ , model_name=SCREAMING_SNAKE_CASE__ , repo_name=SCREAMING_SNAKE_CASE__ , dataset_name=args.dataset_name if hasattr(SCREAMING_SNAKE_CASE__ , """dataset_name""") else None , learning_rate=args.learning_rate , train_batch_size=args.train_batch_size , eval_batch_size=args.eval_batch_size , gradient_accumulation_steps=(
          args.gradient_accumulation_steps if hasattr(SCREAMING_SNAKE_CASE__ , """gradient_accumulation_steps""") else None
      ) , adam_betaa=args.adam_betaa if hasattr(SCREAMING_SNAKE_CASE__ , """adam_beta1""") else None , adam_betaa=args.adam_betaa if hasattr(SCREAMING_SNAKE_CASE__ , """adam_beta2""") else None , adam_weight_decay=args.adam_weight_decay if hasattr(SCREAMING_SNAKE_CASE__ , """adam_weight_decay""") else None , adam_epsilon=args.adam_epsilon if hasattr(SCREAMING_SNAKE_CASE__ , """adam_epsilon""") else None , lr_scheduler=args.lr_scheduler if hasattr(SCREAMING_SNAKE_CASE__ , """lr_scheduler""") else None , lr_warmup_steps=args.lr_warmup_steps if hasattr(SCREAMING_SNAKE_CASE__ , """lr_warmup_steps""") else None , ema_inv_gamma=args.ema_inv_gamma if hasattr(SCREAMING_SNAKE_CASE__ , """ema_inv_gamma""") else None , ema_power=args.ema_power if hasattr(SCREAMING_SNAKE_CASE__ , """ema_power""") else None , ema_max_decay=args.ema_max_decay if hasattr(SCREAMING_SNAKE_CASE__ , """ema_max_decay""") else None , mixed_precision=args.mixed_precision , )

  __snake_case:						str			  =						os.path.join(args.output_dir , """README.md""")
  model_card.save(SCREAMING_SNAKE_CASE__)







def       A__							(   SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = None)       ->   Optional[int]:
  if resolved_file is None or commit_hash is not None:
    return commit_hash
  __snake_case:						List[str]			  =						str(Path(SCREAMING_SNAKE_CASE__).as_posix())
  __snake_case:						Optional[int]			  =						re.search(r"""snapshots/([^/]+)/""" , SCREAMING_SNAKE_CASE__)
  if search is None:
    return None
  __snake_case:						Tuple			  =						search.groups()[0]
  return commit_hash if REGEX_COMMIT_HASH.match(SCREAMING_SNAKE_CASE__) else None


# Old default cache path, potentially to be migrated.
# This logic was more or less taken from `transformers`, with the following differences:
# - Diffusers doesn't use custom environment variables to specify the cache path.
# - There is no need to migrate the cache format, just move the files to the new location.
__UpperCAmelCase	:       Tuple        =							os.path.expanduser(
    os.getenv("HF_HOME", os.path.join(os.getenv("XDG_CACHE_HOME", "~/.cache"), "huggingface"))
)
__UpperCAmelCase	:       int        =							os.path.join(hf_cache_home, "diffusers")







def       A__							(   SCREAMING_SNAKE_CASE__ = None , SCREAMING_SNAKE_CASE__ = None)       ->   None:
  if new_cache_dir is None:
    __snake_case:						List[Any]			  =						DIFFUSERS_CACHE
  if old_cache_dir is None:
    __snake_case:						Dict			  =						old_diffusers_cache

  __snake_case:						str			  =						Path(SCREAMING_SNAKE_CASE__).expanduser()
  __snake_case:						List[str]			  =						Path(SCREAMING_SNAKE_CASE__).expanduser()
  for old_blob_path in old_cache_dir.glob("""**/blobs/*"""):
    if old_blob_path.is_file() and not old_blob_path.is_symlink():
      __snake_case:						Optional[Any]			  =						new_cache_dir / old_blob_path.relative_to(SCREAMING_SNAKE_CASE__)
      new_blob_path.parent.mkdir(parents=SCREAMING_SNAKE_CASE__ , exist_ok=SCREAMING_SNAKE_CASE__)
      os.replace(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)
      try:
        os.symlink(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)
      except OSError:
        logger.warning(
            """Could not create symlink between old cache and new cache. If you use an older version of diffusers again, files will be re-downloaded.""")
  # At this point, old_cache_dir contains symlinks to the new cache (it can still be used).


__UpperCAmelCase	:       Optional[Any]        =							os.path.join(DIFFUSERS_CACHE, "version_diffusers_cache.txt")
if not os.path.isfile(cache_version_file):
      __UpperCAmelCase	:       Tuple        =							0
else:
      with open(cache_version_file) as f:
            try:
                  __UpperCAmelCase	:       Optional[int]        =							int(f.read())
            except ValueError:
                  __UpperCAmelCase	:       Dict        =							0

if cache_version < 1:
      __UpperCAmelCase	:       Tuple        =							os.path.isdir(old_diffusers_cache) and len(os.listdir(old_diffusers_cache)) > 0
      if old_cache_is_not_empty:
            logger.warning(
                "The cache for model files in Diffusers v0.14.0 has moved to a new location. Moving your "
                "existing cached models. This is a one-time operation, you can interrupt it or run it "
                "later by calling `diffusers.utils.hub_utils.move_cache()`."
            )
            try:
                  move_cache()
            except Exception as e:
                  __UpperCAmelCase	:       List[Any]        =							"\n".join(traceback.format_tb(e.__traceback__))
                  logger.error(
                      f'There was a problem when trying to move your cache:\n\n{trace}\n{e.__class__.__name__}: {e}\n\nPlease '
                      "file an issue at https://github.com/huggingface/diffusers/issues/new/choose, copy paste this whole "
                      "message and we will do our best to help."
                  )

if cache_version < 1:
      try:
            os.makedirs(DIFFUSERS_CACHE, exist_ok=True)
            with open(cache_version_file, "w") as f:
                  f.write("1")
      except Exception:
            logger.warning(
                f'There was a problem when trying to write in your cache folder ({DIFFUSERS_CACHE}). Please, ensure '
                "the directory exists and can be written to."
            )







def       A__							(   SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = None)       ->   str:
  if variant is not None:
    __snake_case:						List[Any]			  =						weights_name.split(""".""")
    __snake_case:						str			  =						splits[:-1] + [variant] + splits[-1:]
    __snake_case:						Optional[int]			  =						""".""".join(SCREAMING_SNAKE_CASE__)

  return weights_name







def       A__							(   SCREAMING_SNAKE_CASE__ , *,
    SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None , )       ->   Dict:
  __snake_case:						Union[str, Any]			  =						str(SCREAMING_SNAKE_CASE__)
  if os.path.isfile(SCREAMING_SNAKE_CASE__):
    return pretrained_model_name_or_path
  elif os.path.isdir(SCREAMING_SNAKE_CASE__):
    if os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)):
      # Load from a PyTorch checkpoint
      __snake_case:						List[Any]			  =						os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)
      return model_file
    elif subfolder is not None and os.path.isfile(
        os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)):
      __snake_case:						List[Any]			  =						os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)
      return model_file
    else:
      raise EnvironmentError(
          F'''Error no file named {weights_name} found in directory {pretrained_model_name_or_path}.''')
  else:
    # 1. First check if deprecated way of loading from branches is used
    if (
        revision in DEPRECATED_REVISION_ARGS
        and (weights_name == WEIGHTS_NAME or weights_name == SAFETENSORS_WEIGHTS_NAME)
        and version.parse(version.parse(SCREAMING_SNAKE_CASE__).base_version) >= version.parse("""0.20.0""")
    ):
      try:
        __snake_case:						str			  =						hf_hub_download(
            SCREAMING_SNAKE_CASE__ , filename=_add_variant(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__) , cache_dir=SCREAMING_SNAKE_CASE__ , force_download=SCREAMING_SNAKE_CASE__ , proxies=SCREAMING_SNAKE_CASE__ , resume_download=SCREAMING_SNAKE_CASE__ , local_files_only=SCREAMING_SNAKE_CASE__ , use_auth_token=SCREAMING_SNAKE_CASE__ , user_agent=SCREAMING_SNAKE_CASE__ , subfolder=SCREAMING_SNAKE_CASE__ , revision=revision or commit_hash , )
        warnings.warn(
            F'''Loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'` is deprecated. Loading instead from `revision=\'main\'` with `variant={revision}`. Loading model variants via `revision=\'{revision}\'` will be removed in diffusers v1. Please use `variant=\'{revision}\'` instead.''' , SCREAMING_SNAKE_CASE__ , )
        return model_file
      except:  # noqa: E722
        warnings.warn(
            F'''You are loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'`. This behavior is deprecated and will be removed in diffusers v1. One should use `variant=\'{revision}\'` instead. However, it appears that {pretrained_model_name_or_path} currently does not have a {_add_variant(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)} file in the \'main\' branch of {pretrained_model_name_or_path}. \n The Diffusers team and community would be very grateful if you could open an issue: https://github.com/huggingface/diffusers/issues/new with the title \'{pretrained_model_name_or_path} is missing {_add_variant(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)}\' so that the correct variant file can be added.''' , SCREAMING_SNAKE_CASE__ , )
    try:
      # 2. Load model file as usual
      __snake_case:						str			  =						hf_hub_download(
          SCREAMING_SNAKE_CASE__ , filename=SCREAMING_SNAKE_CASE__ , cache_dir=SCREAMING_SNAKE_CASE__ , force_download=SCREAMING_SNAKE_CASE__ , proxies=SCREAMING_SNAKE_CASE__ , resume_download=SCREAMING_SNAKE_CASE__ , local_files_only=SCREAMING_SNAKE_CASE__ , use_auth_token=SCREAMING_SNAKE_CASE__ , user_agent=SCREAMING_SNAKE_CASE__ , subfolder=SCREAMING_SNAKE_CASE__ , revision=revision or commit_hash , )
      return model_file

    except RepositoryNotFoundError:
      raise EnvironmentError(
          F'''{pretrained_model_name_or_path} is not a local folder and is not a valid model identifier '''
          """listed on 'https://huggingface.co/models'\nIf this is a private repository, make sure to pass a """
          """token having permission to this repo with `use_auth_token` or log in with `huggingface-cli """
          """login`.""")
    except RevisionNotFoundError:
      raise EnvironmentError(
          F'''{revision} is not a valid git identifier (branch name, tag name or commit id) that exists for '''
          """this model name. Check the model page at """
          F'''\'https://huggingface.co/{pretrained_model_name_or_path}\' for available revisions.''')
    except EntryNotFoundError:
      raise EnvironmentError(
          F'''{pretrained_model_name_or_path} does not appear to have a file named {weights_name}.''')
    except HTTPError as err:
      raise EnvironmentError(
          F'''There was a specific connection error when trying to load {pretrained_model_name_or_path}:\n{err}''')
    except ValueError:
      raise EnvironmentError(
          F'''We couldn\'t connect to \'{HUGGINGFACE_CO_RESOLVE_ENDPOINT}\' to load this model, couldn\'t find it'''
          F''' in the cached files and it looks like {pretrained_model_name_or_path} is not the path to a'''
          F''' directory containing a file named {weights_name} or'''
          """ \nCheckout your internet connection or see how to run the library in"""
          """ offline mode at 'https://huggingface.co/docs/diffusers/installation#offline-mode'.""")
    except EnvironmentError:
      raise EnvironmentError(
          F'''Can\'t load the model for \'{pretrained_model_name_or_path}\'. If you were trying to load it from '''
          """'https://huggingface.co/models', make sure you don't have a local directory with the same name. """
          F'''Otherwise, make sure \'{pretrained_model_name_or_path}\' is the correct path to a directory '''
          F'''containing a file named {weights_name}''')













import inspect
import unittest

from transformers import MobileViTConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import MobileViTForImageClassification, MobileViTForSemanticSegmentation, MobileViTModel
      from transformers.models.mobilevit.modeling_mobilevit import MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
      from PIL import Image

      from transformers import MobileViTImageProcessor







class    __snake_case	(							__lowerCamelCase      ):





       '''simple docstring'''







       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Optional[int]			  =						self.config_class(**self.inputs_dict		)
         self.parent.assertTrue(hasattr(A							,    """hidden_sizes"""		)		)
         self.parent.assertTrue(hasattr(A							,    """neck_hidden_sizes"""		)		)
         self.parent.assertTrue(hasattr(A							,    """num_attention_heads"""		)		)







class    __snake_case	:





       '''simple docstring'''







       def __init__(  self			:   int							,    A			:   str							,    A			:   Dict=13							,    A			:   str=32							,    A			:   Any=2							,    A			:   Optional[Any]=3							,    A			:   str=640							,    A			:   Tuple=4							,    A			:   Dict="silu"							,    A			:   List[Any]=3							,    A			:   Any=32							,    A			:   Any=0.1							,    A			:   int=0.1							,    A			:   Dict=0.1							,    A			:   Optional[Any]=0.02							,    A			:   List[Any]=True							,    A			:   Tuple=True							,    A			:   Any=10							,    A			:   Optional[int]=None							,    ):
         __snake_case:						List[Any]			  =						parent
         __snake_case:						Dict			  =						batch_size
         __snake_case:						int			  =						image_size
         __snake_case:						Tuple			  =						patch_size
         __snake_case:						Tuple			  =						num_channels
         __snake_case:						str			  =						last_hidden_size
         __snake_case:						Dict			  =						num_attention_heads
         __snake_case:						Dict			  =						hidden_act
         __snake_case:						Tuple			  =						conv_kernel_size
         __snake_case:						List[str]			  =						output_stride
         __snake_case:						List[str]			  =						hidden_dropout_prob
         __snake_case:						Optional[Any]			  =						attention_probs_dropout_prob
         __snake_case:						int			  =						classifier_dropout_prob
         __snake_case:						List[Any]			  =						use_labels
         __snake_case:						Union[str, Any]			  =						is_training
         __snake_case:						Union[str, Any]			  =						num_labels
         __snake_case:						str			  =						initializer_range
         __snake_case:						List[Any]			  =						scope




       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						Union[str, Any]			  =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

         __snake_case:						Tuple			  =						None
         __snake_case:						Any			  =						None
         if self.use_labels:
           __snake_case:						Union[str, Any]			  =						ids_tensor([self.batch_size]							,    self.num_labels		)
           __snake_case:						str			  =						ids_tensor([self.batch_size, self.image_size, self.image_size]							,    self.num_labels		)

         __snake_case:						Any			  =						self.get_config()

         return config, pixel_values, labels, pixel_labels




       def 							UpperCAmelCase__			(  self			:   int		):
         return MobileViTConfig(
             image_size=self.image_size							,    patch_size=self.patch_size							,    num_channels=self.num_channels							,    num_attention_heads=self.num_attention_heads							,    hidden_act=self.hidden_act							,    conv_kernel_size=self.conv_kernel_size							,    output_stride=self.output_stride							,    hidden_dropout_prob=self.hidden_dropout_prob							,    attention_probs_dropout_prob=self.attention_probs_dropout_prob							,    classifier_dropout_prob=self.classifier_dropout_prob							,    initializer_range=self.initializer_range							,    )




       def 							UpperCAmelCase__			(  self			:   str							,    A			:   Optional[Any]							,    A			:   Any							,    A			:   Any							,    A			:   Union[str, Any]		):
         __snake_case:						List[Any]			  =						MobileViTModel(config=A		)
         model.to(A		)
         model.eval()
         __snake_case:						int			  =						model(A		)
         self.parent.assertEqual(
             result.last_hidden_state.shape							,    (
                 self.batch_size,
                 self.last_hidden_size,
                 self.image_size // self.output_stride,
                 self.image_size // self.output_stride,
             )							,    )




       def 							UpperCAmelCase__			(  self			:   str							,    A			:   List[Any]							,    A			:   Any							,    A			:   Any							,    A			:   int		):
         __snake_case:						str			  =						self.num_labels
         __snake_case:						Optional[int]			  =						MobileViTForImageClassification(A		)
         model.to(A		)
         model.eval()
         __snake_case:						Union[str, Any]			  =						model(A							,    labels=A		)
         self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.num_labels)		)




       def 							UpperCAmelCase__			(  self			:   Optional[int]							,    A			:   str							,    A			:   Optional[Any]							,    A			:   int							,    A			:   str		):
         __snake_case:						List[Any]			  =						self.num_labels
         __snake_case:						Dict			  =						MobileViTForSemanticSegmentation(A		)
         model.to(A		)
         model.eval()
         __snake_case:						Union[str, Any]			  =						model(A		)
         self.parent.assertEqual(
             result.logits.shape							,    (
                 self.batch_size,
                 self.num_labels,
                 self.image_size // self.output_stride,
                 self.image_size // self.output_stride,
             )							,    )
         __snake_case:						Tuple			  =						model(A							,    labels=A		)
         self.parent.assertEqual(
             result.logits.shape							,    (
                 self.batch_size,
                 self.num_labels,
                 self.image_size // self.output_stride,
                 self.image_size // self.output_stride,
             )							,    )






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Tuple			  =						self.prepare_config_and_inputs()
         __snake_case  ,       __snake_case  ,       __snake_case  ,       __snake_case:						Any			  =						config_and_inputs
         __snake_case:						Optional[int]			  =						{"""pixel_values""": pixel_values}
         return config, inputs_dict







@require_torch
class    __snake_case	(							__lowerCamelCase       ,      __lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					(
           (MobileViTModel, MobileViTForImageClassification, MobileViTForSemanticSegmentation)
           if is_torch_available()
           else ()
       )
       lowerCAmelCase__						=					(
           {
               """feature-extraction""": MobileViTModel,
               """image-classification""": MobileViTForImageClassification,
               """image-segmentation""": MobileViTForSemanticSegmentation,
           }
           if is_torch_available()
           else {}
       )

       lowerCAmelCase__						=					False
       lowerCAmelCase__						=					False
       lowerCAmelCase__						=					False
       lowerCAmelCase__						=					False




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case:						List[Any]			  =						MobileViTModelTester(self		)
         __snake_case:						str			  =						MobileViTConfigTester(self							,    config_class=A							,    has_text_modality=A		)




       def 							UpperCAmelCase__			(  self			:   str		):
         self.config_tester.run_common_tests()




       @unittest.skip(reason="""MobileViT does not use inputs_embeds"""		)
       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         pass




       @unittest.skip(reason="""MobileViT does not support input and output embeddings"""		)
       def 							UpperCAmelCase__			(  self			:   Dict		):
         pass




       @unittest.skip(reason="""MobileViT does not output attentions"""		)
       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         pass




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case  ,       __snake_case:						Dict			  =						self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           __snake_case:						Optional[Any]			  =						model_class(A		)
           __snake_case:						int			  =						inspect.signature(model.forward		)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           __snake_case:						Optional[int]			  =						[*signature.parameters.keys()]

           __snake_case:						List[Any]			  =						["""pixel_values"""]
           self.assertListEqual(arg_names[:1]							,    A		)




       @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""		)
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         pass




       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[Any]			  =						self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A		)




       def 							UpperCAmelCase__			(  self			:   Dict		):
         def check_hidden_states_output(A			:   List[Any]							,    A			:   int							,    A			:   Tuple		):
           __snake_case:						List[str]			  =						model_class(A		)
           model.to(A		)
           model.eval()

           with torch.no_grad():
             __snake_case:						str			  =						model(**self._prepare_for_class(A							,    A		)		)

           __snake_case:						Optional[int]			  =						outputs.hidden_states

           __snake_case:						Any			  =						5
           self.assertEqual(len(A		)							,    A		)

           # MobileViT's feature maps are of shape (batch_size, num_channels, height, width)
           # with the width and height being successively divided by 2.
           __snake_case:						Union[str, Any]			  =						2
           for i in range(len(A		)		):
             self.assertListEqual(
                 list(hidden_states[i].shape[-2:]		)							,    [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]							,    )
             divisor *= 2

           self.assertEqual(self.model_tester.output_stride							,    divisor // 2		)

         __snake_case  ,       __snake_case:						List[Any]			  =						self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           __snake_case:						Optional[Any]			  =						True
           check_hidden_states_output(A							,    A							,    A		)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           __snake_case:						Dict			  =						True

           check_hidden_states_output(A							,    A							,    A		)




       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case:						Optional[Any]			  =						self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*A		)




       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						Optional[int]			  =						self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_semantic_segmentation(*A		)






       @slow
       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         for model_name in MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           __snake_case:						List[Any]			  =						MobileViTModel.from_pretrained(A		)
           self.assertIsNotNone(A		)







def       A__							(   )       ->   Optional[int]:
  __snake_case:						Optional[Any]			  =						Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""")
  return image







@require_torch
@require_vision
class    __snake_case	(							unittest.TestCase      ):





       '''simple docstring'''







       @cached_property
       def 							UpperCAmelCase__			(  self			:   Dict		):
         return MobileViTImageProcessor.from_pretrained("""apple/mobilevit-xx-small"""		) if is_vision_available() else None




       @slow
       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						Tuple			  =						MobileViTForImageClassification.from_pretrained("""apple/mobilevit-xx-small"""		).to(A		)

         __snake_case:						str			  =						self.default_image_processor
         __snake_case:						Optional[Any]			  =						prepare_img()
         __snake_case:						List[Any]			  =						image_processor(images=A							,    return_tensors="""pt"""		).to(A		)

         # forward pass
         with torch.no_grad():
           __snake_case:						Dict			  =						model(**A		)

         # verify the logits
         __snake_case:						List[str]			  =						torch.Size((1, 1_000)		)
         self.assertEqual(outputs.logits.shape							,    A		)

         __snake_case:						Union[str, Any]			  =						torch.tensor([-1.9364, -1.2327, -0.4653]		).to(A		)

         self.assertTrue(torch.allclose(outputs.logits[0, :3]							,    A							,    atol=1E-4		)		)




       @slow
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         __snake_case:						Tuple			  =						MobileViTForSemanticSegmentation.from_pretrained("""apple/deeplabv3-mobilevit-xx-small"""		)
         __snake_case:						List[str]			  =						model.to(A		)

         __snake_case:						Dict			  =						MobileViTImageProcessor.from_pretrained("""apple/deeplabv3-mobilevit-xx-small"""		)

         __snake_case:						List[Any]			  =						prepare_img()
         __snake_case:						List[str]			  =						image_processor(images=A							,    return_tensors="""pt"""		).to(A		)

         # forward pass
         with torch.no_grad():
           __snake_case:						List[Any]			  =						model(**A		)
         __snake_case:						Optional[int]			  =						outputs.logits

         # verify the logits
         __snake_case:						Dict			  =						torch.Size((1, 21, 32, 32)		)
         self.assertEqual(logits.shape							,    A		)

         __snake_case:						Optional[int]			  =						torch.tensor(
             [
                 [[6.9713, 6.9786, 7.2422], [7.2893, 7.2825, 7.4446], [7.6580, 7.8797, 7.9420]],
                 [[-10.6869, -10.3250, -10.3471], [-10.4228, -9.9868, -9.7132], [-11.0405, -11.0221, -10.7318]],
                 [[-3.3089, -2.8539, -2.6740], [-3.2706, -2.5621, -2.5108], [-3.2534, -2.6615, -2.6651]],
             ]							,    device=A							,    )

         self.assertTrue(torch.allclose(logits[0, :3, :3, :3]							,    A							,    atol=1E-4		)		)






       @slow
       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						int			  =						MobileViTForSemanticSegmentation.from_pretrained("""apple/deeplabv3-mobilevit-xx-small"""		)
         __snake_case:						str			  =						model.to(A		)

         __snake_case:						Optional[Any]			  =						MobileViTImageProcessor.from_pretrained("""apple/deeplabv3-mobilevit-xx-small"""		)

         __snake_case:						List[str]			  =						prepare_img()
         __snake_case:						Optional[int]			  =						image_processor(images=A							,    return_tensors="""pt"""		).to(A		)

         # forward pass
         with torch.no_grad():
           __snake_case:						Dict			  =						model(**A		)

         __snake_case:						List[Any]			  =						outputs.logits.detach().cpu()

         __snake_case:						List[str]			  =						image_processor.post_process_semantic_segmentation(outputs=A							,    target_sizes=[(50, 60)]		)
         __snake_case:						str			  =						torch.Size((50, 60)		)
         self.assertEqual(segmentation[0].shape							,    A		)

         __snake_case:						int			  =						image_processor.post_process_semantic_segmentation(outputs=A		)
         __snake_case:						Tuple			  =						torch.Size((32, 32)		)
         self.assertEqual(segmentation[0].shape							,    A		)






