




import os
import sys
import warnings
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen
from ..table import array_cast
from ..utils.file_utils import is_local_path
from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
 import PIL.Image

 from .features import FeatureType


lowerCamelCase									=     None
lowerCamelCase									=     "<" if sys.byteorder == "little" else ">"
# Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image
lowerCamelCase									=     [
    np.dtype("|b1"),
    np.dtype("|u1"),
    np.dtype("<u2"),
    np.dtype(">u2"),
    np.dtype("<i2"),
    np.dtype(">i2"),
    np.dtype("<u4"),
    np.dtype(">u4"),
    np.dtype("<i4"),
    np.dtype(">i4"),
    np.dtype("<f4"),
    np.dtype(">f4"),
    np.dtype("<f8"),
    np.dtype(">f8"),
]







@dataclass
class 						A:



 '''simple docstring'''


 UpperCamelCase		     =		True
 UpperCamelCase		     =		None
 # Automatically constructed
 UpperCamelCase		     =		'''PIL.Image.Image'''
 UpperCamelCase		     =		pa.struct({'''bytes''': pa.binary(), '''path''': pa.string()}     )
 UpperCamelCase		     =		field(default='''Image'''							,   init=UpperCamelCase							,   repr=UpperCamelCase     )

 def __call__(       self      :						str						)     ->			Optional[int]:

       """simple docstring"""






       return self.pa_type

 def        a__				(       self      :						Optional[Any]		,							A_      :						Union[str, bytes, dict, np.ndarray, "PIL.Image.Image"]						)     ->			dict:

       """simple docstring"""






       if config.PIL_AVAILABLE:
             import PIL.Image
       else:
             raise ImportError('To support encoding images, please install \'Pillow\'.'						)

       if isinstance(A_		,							A_						):
             lowerCamelCase_	  =					np.array(A_						)

       if isinstance(A_		,							A_						):
             return {"path": value, "bytes": None}
       elif isinstance(A_		,							A_						):
             return {"path": None, "bytes": value}
       elif isinstance(A_		,							np.ndarray						):
             # convert the image array to PNG/TIFF bytes
             return encode_np_array(A_						)
       elif isinstance(A_		,							PIL.Image.Image						):
             # convert the PIL image to bytes (default format is PNG/TIFF)
             return encode_pil_image(A_						)
       elif value.get('path'						) is not None and os.path.isfile(value['path']						):
             # we set "bytes": None to not duplicate the data if they're already available locally
             return {"bytes": None, "path": value.get('path'						)}
       elif value.get('bytes'						) is not None or value.get('path'						) is not None:
             # store the image bytes, and path is used to infer the image format using the file extension
             return {"bytes": value.get('bytes'						), "path": value.get('path'						)}
       else:
             raise ValueError(
                 f"""An image sample should have one of 'path' or 'bytes' but they are missing or None in {value}."""						)

 def        a__				(       self      :						Optional[int]		,							A_      :						dict		,							A_      :						Dict=None						)     ->			"PIL.Image.Image":

       """simple docstring"""






       if not self.decode:
             raise RuntimeError('Decoding is disabled for this feature. Please use Image(decode=True) instead.'						)

       if config.PIL_AVAILABLE:
             import PIL.Image
       else:
             raise ImportError('To support decoding images, please install \'Pillow\'.'						)

       if token_per_repo_id is None:
             lowerCamelCase_	  =					{}

       lowerCamelCase_  ,       lowerCamelCase_	  =					value['path'], value['bytes']
       if bytes_ is None:
             if path is None:
                   raise ValueError(f"""An image should have one of 'path' or 'bytes' but both are None in {value}."""						)
             else:
                   if is_local_path(A_						):
                         lowerCamelCase_	  =					PIL.Image.open(A_						)
                   else:
                         lowerCamelCase_	  =					path.split('::'						)[-1]
                         try:
                               lowerCamelCase_	  =					string_to_dict(A_		,							config.HUB_DATASETS_URL						)['repo_id']
                               lowerCamelCase_	  =					token_per_repo_id.get(A_						)
                         except ValueError:
                               lowerCamelCase_	  =					None
                         with xopen(A_		,							'rb'		,							use_auth_token=A_						) as f:
                               lowerCamelCase_	  =					BytesIO(f.read()						)
                         lowerCamelCase_	  =					PIL.Image.open(bytes_						)
       else:
             lowerCamelCase_	  =					PIL.Image.open(BytesIO(bytes_						)						)
       image.load()  # to avoid "Too many open files" errors
       return image

 def        a__				(       self      :						int						)     ->			Union["FeatureType", Dict[str, "FeatureType"]]:

       """simple docstring"""






       from .features import Value

       return (
           self
           if self.decode
           else {
               "bytes": Value('binary'						),
               "path": Value('string'						),
           }
       )

 def        a__				(       self      :						Optional[int]		,							A_      :						Union[pa.StringArray, pa.StructArray, pa.ListArray]						)     ->			pa.StructArray:

       """simple docstring"""






       if pa.types.is_string(storage.type						):
             lowerCamelCase_	  =					pa.array([None] * len(A_						)		,							type=pa.binary()						)
             lowerCamelCase_	  =					pa.StructArray.from_arrays([bytes_array, storage]		,							['bytes', 'path']		,							mask=storage.is_null()						)
       elif pa.types.is_binary(storage.type						):
             lowerCamelCase_	  =					pa.array([None] * len(A_						)		,							type=pa.string()						)
             lowerCamelCase_	  =					pa.StructArray.from_arrays([storage, path_array]		,							['bytes', 'path']		,							mask=storage.is_null()						)
       elif pa.types.is_struct(storage.type						):
             if storage.type.get_field_index('bytes'						) >= 0:
                   lowerCamelCase_	  =					storage.field('bytes'						)
             else:
                   lowerCamelCase_	  =					pa.array([None] * len(A_						)		,							type=pa.binary()						)
             if storage.type.get_field_index('path'						) >= 0:
                   lowerCamelCase_	  =					storage.field('path'						)
             else:
                   lowerCamelCase_	  =					pa.array([None] * len(A_						)		,							type=pa.string()						)
             lowerCamelCase_	  =					pa.StructArray.from_arrays([bytes_array, path_array]		,							['bytes', 'path']		,							mask=storage.is_null()						)
       elif pa.types.is_list(storage.type						):
             lowerCamelCase_	  =					pa.array(
                 [encode_np_array(np.array(A_						)						)['bytes'] if arr is not None else None for arr in storage.to_pylist()]		,							type=pa.binary()		,							)
             lowerCamelCase_	  =					pa.array([None] * len(A_						)		,							type=pa.string()						)
             lowerCamelCase_	  =					pa.StructArray.from_arrays(
                 [bytes_array, path_array]		,							['bytes', 'path']		,							mask=bytes_array.is_null()						)
       return array_cast(A_		,							self.pa_type						)





 def        a__				(       self      :						str		,							A_      :						pa.StructArray						)     ->			pa.StructArray:

       """simple docstring"""






       @no_op_if_value_is_null
       def path_to_bytes(A_      :						List[Any]						):
             with xopen(A_		,							'rb'						) as f:
                   lowerCamelCase_	  =					f.read()
             return bytes_

       lowerCamelCase_	  =					pa.array(
           [
               (path_to_bytes(x['path']						) if x['bytes'] is None else x['bytes']) if x is not None else None
               for x in storage.to_pylist()
           ]		,							type=pa.binary()		,							)
       lowerCamelCase_	  =					pa.array(
           [os.path.basename(A_						) if path is not None else None for path in storage.field('path'						).to_pylist()]		,							type=pa.string()		,							)
       lowerCamelCase_	  =					pa.StructArray.from_arrays([bytes_array, path_array]		,							['bytes', 'path']		,							mask=bytes_array.is_null()						)
       return array_cast(A_		,							self.pa_type						)

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      if config.PIL_AVAILABLE:
            import PIL.Image
      else:
            raise ImportError('To support encoding images, please install \'Pillow\'.'  )

      global _IMAGE_COMPRESSION_FORMATS
      if _IMAGE_COMPRESSION_FORMATS is None:
            PIL.Image.init()
            lowerCamelCase_	  =					list(set(PIL.Image.OPEN.keys()  ) & set(PIL.Image.SAVE.keys()  )  )
      return _IMAGE_COMPRESSION_FORMATS

def     _SCREAMING_SNAKE_CASE    (							lowercase			: "PIL.Image.Image"  ):


      '''simple docstring'''



      lowerCamelCase_	  =					BytesIO()
      if image.format in list_image_compression_formats():
            lowerCamelCase_	  =					image.format
      else:
            lowerCamelCase_	  =					'PNG' if image.mode in ['1', 'L', 'LA', 'RGB', 'RGBA'] else 'TIFF'
      image.save(lowercase			,							format=lowercase  )
      return buffer.getvalue()

def     _SCREAMING_SNAKE_CASE    (							lowercase			: "PIL.Image.Image"  ):


      '''simple docstring'''



      if hasattr(lowercase			,							'filename'  ) and image.filename != "":
            return {"path": image.filename, "bytes": None}
      else:
            return {"path": None, "bytes": image_to_bytes(lowercase  )}

def     _SCREAMING_SNAKE_CASE    (							lowercase			: np.ndarray  ):


      '''simple docstring'''



      if config.PIL_AVAILABLE:
            import PIL.Image
      else:
            raise ImportError('To support encoding images, please install \'Pillow\'.'  )

      lowerCamelCase_	  =					array.dtype
      lowerCamelCase_	  =					dtype.byteorder if dtype.byteorder != '=' else _NATIVE_BYTEORDER
      lowerCamelCase_	  =					dtype.kind
      lowerCamelCase_	  =					dtype.itemsize

      lowerCamelCase_	  =					None

      # Multi-channel array case (only np.dtype("|u1") is allowed)
      if array.shape[2:]:
            lowerCamelCase_	  =					np.dtype('|u1'  )
            if dtype_kind not in ["u", "i"]:
                  raise TypeError(
                      f"""Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays."""  )
            if dtype is not dest_dtype:
                  warnings.warn(f"""Downcasting array dtype {dtype} to {dest_dtype} to be compatible with 'Pillow'"""  )
    # Exact match
      elif dtype in _VALID_IMAGE_ARRAY_DTPYES:
            lowerCamelCase_	  =					dtype
      else:  # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually)
            while dtype_itemsize >= 1:
                  lowerCamelCase_	  =					dtype_byteorder + dtype_kind + str(lowercase  )
                  lowerCamelCase_	  =					np.dtype(lowercase  )
                  if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES:
                        warnings.warn(f"""Downcasting array dtype {dtype} to {dest_dtype} to be compatible with 'Pillow'"""  )
                        break
                  else:
                        dtype_itemsize //= 2

      if dest_dtype is None:
            raise TypeError(
                f"""Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}"""  )
      lowerCamelCase_	  =					PIL.Image.fromarray(array.astype(lowercase  )  )
      return {"path": None, "bytes": image_to_bytes(lowercase  )}






def     _SCREAMING_SNAKE_CASE    (							lowercase			: Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]]  ):


      '''simple docstring'''



      if config.PIL_AVAILABLE:
            import PIL.Image
      else:
            raise ImportError('To support encoding images, please install \'Pillow\'.'  )

      if objs:
            lowerCamelCase_  ,       lowerCamelCase_	  =					first_non_null_value(lowercase  )
            if isinstance(lowercase			,							lowercase  ):
                  return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs]
            if isinstance(lowercase			,							np.ndarray  ):
                  lowerCamelCase_	  =					no_op_if_value_is_null(lowercase  )
                  return [obj_to_image_dict_func(lowercase  ) for obj in objs]
            elif isinstance(lowercase			,							PIL.Image.Image  ):
                  lowerCamelCase_	  =					no_op_if_value_is_null(lowercase  )
                  return [obj_to_image_dict_func(lowercase  ) for obj in objs]
            else:
                  return objs
      else:
            return objs









import collections
import inspect
import unittest

from transformers import FocalNetConfig
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_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch
 from torch import nn

 from transformers import (
     FocalNetBackbone,
     FocalNetForImageClassification,
     FocalNetForMaskedImageModeling,
     FocalNetModel,
 )
 from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor







class 						A:



 '''simple docstring'''


 def __init__(       self      :						Optional[Any]		,							A_      :						Union[str, Any]		,							A_      :						str=13		,							A_      :						List[Any]=32		,							A_      :						Tuple=2		,							A_      :						Dict=3		,							A_      :						Union[str, Any]=16		,							A_      :						List[str]=[32, 64, 128]		,							A_      :						Optional[Any]=[1, 2, 1]		,							A_      :						Tuple=[2, 2, 4]		,							A_      :						Dict=2		,							A_      :						Optional[Any]=2.0		,							A_      :						List[str]=True		,							A_      :						Dict=0.0		,							A_      :						List[str]=0.0		,							A_      :						Optional[int]=0.1		,							A_      :						str="gelu"		,							A_      :						Optional[Any]=False		,							A_      :						Any=True		,							A_      :						Optional[Any]=0.02		,							A_      :						Dict=1E-5		,							A_      :						int=True		,							A_      :						Optional[int]=None		,							A_      :						List[str]=True		,							A_      :						Tuple=10		,							A_      :						Any=8		,							A_      :						Dict=["stage1", "stage2"]		,							A_      :						Optional[Any]=[1, 2]		,							)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_	  =					parent
       lowerCamelCase_	  =					batch_size
       lowerCamelCase_	  =					image_size
       lowerCamelCase_	  =					patch_size
       lowerCamelCase_	  =					num_channels
       lowerCamelCase_	  =					embed_dim
       lowerCamelCase_	  =					hidden_sizes
       lowerCamelCase_	  =					depths
       lowerCamelCase_	  =					num_heads
       lowerCamelCase_	  =					window_size
       lowerCamelCase_	  =					mlp_ratio
       lowerCamelCase_	  =					qkv_bias
       lowerCamelCase_	  =					hidden_dropout_prob
       lowerCamelCase_	  =					attention_probs_dropout_prob
       lowerCamelCase_	  =					drop_path_rate
       lowerCamelCase_	  =					hidden_act
       lowerCamelCase_	  =					use_absolute_embeddings
       lowerCamelCase_	  =					patch_norm
       lowerCamelCase_	  =					layer_norm_eps
       lowerCamelCase_	  =					initializer_range
       lowerCamelCase_	  =					is_training
       lowerCamelCase_	  =					scope
       lowerCamelCase_	  =					use_labels
       lowerCamelCase_	  =					type_sequence_label_size
       lowerCamelCase_	  =					encoder_stride
       lowerCamelCase_	  =					out_features
       lowerCamelCase_	  =					out_indices

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

       """simple docstring"""






       lowerCamelCase_	  =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

       lowerCamelCase_	  =					None
       if self.use_labels:
             lowerCamelCase_	  =					ids_tensor([self.batch_size]		,							self.type_sequence_label_size						)

       lowerCamelCase_	  =					self.get_config()

       return config, pixel_values, labels

 def        a__				(       self      :						List[Any]						)     ->			Any:

       """simple docstring"""






       return FocalNetConfig(
           image_size=self.image_size		,							patch_size=self.patch_size		,							num_channels=self.num_channels		,							embed_dim=self.embed_dim		,							hidden_sizes=self.hidden_sizes		,							depths=self.depths		,							num_heads=self.num_heads		,							window_size=self.window_size		,							mlp_ratio=self.mlp_ratio		,							qkv_bias=self.qkv_bias		,							hidden_dropout_prob=self.hidden_dropout_prob		,							attention_probs_dropout_prob=self.attention_probs_dropout_prob		,							drop_path_rate=self.drop_path_rate		,							hidden_act=self.hidden_act		,							use_absolute_embeddings=self.use_absolute_embeddings		,							path_norm=self.patch_norm		,							layer_norm_eps=self.layer_norm_eps		,							initializer_range=self.initializer_range		,							encoder_stride=self.encoder_stride		,							out_features=self.out_features		,							out_indices=self.out_indices		,							)

 def        a__				(       self      :						Union[str, Any]		,							A_      :						Dict		,							A_      :						int		,							A_      :						Optional[int]						)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_	  =					FocalNetModel(config=A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_						)

       lowerCamelCase_	  =					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths						) - 1))
       lowerCamelCase_	  =					int(config.embed_dim * 2 ** (len(config.depths						) - 1)						)

       self.parent.assertEqual(result.last_hidden_state.shape		,							(self.batch_size, expected_seq_len, expected_dim)						)

 def        a__				(       self      :						Tuple		,							A_      :						List[str]		,							A_      :						Optional[int]		,							A_      :						Optional[Any]						)     ->			Dict:

       """simple docstring"""






       lowerCamelCase_	  =					FocalNetBackbone(config=A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_						)

       # verify feature maps
       self.parent.assertEqual(len(result.feature_maps						)		,							len(config.out_features						)						)
       self.parent.assertListEqual(list(result.feature_maps[0].shape						)		,							[self.batch_size, self.image_size, 8, 8]						)

       # verify channels
       self.parent.assertEqual(len(model.channels						)		,							len(config.out_features						)						)
       self.parent.assertListEqual(model.channels		,							config.hidden_sizes[:-1]						)

       # verify backbone works with out_features=None
       lowerCamelCase_	  =					None
       lowerCamelCase_	  =					FocalNetBackbone(config=A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_						)

       # verify feature maps
       self.parent.assertEqual(len(result.feature_maps						)		,							1						)
       self.parent.assertListEqual(list(result.feature_maps[0].shape						)		,							[self.batch_size, self.image_size * 2, 4, 4]						)

       # verify channels
       self.parent.assertEqual(len(model.channels						)		,							1						)
       self.parent.assertListEqual(model.channels		,							[config.hidden_sizes[-1]]						)

 def        a__				(       self      :						int		,							A_      :						Optional[Any]		,							A_      :						Optional[int]		,							A_      :						Any						)     ->			Any:

       """simple docstring"""






       lowerCamelCase_	  =					FocalNetForMaskedImageModeling(config=A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_						)
       self.parent.assertEqual(
           result.reconstruction.shape		,							(self.batch_size, self.num_channels, self.image_size, self.image_size)						)

       # test greyscale images
       lowerCamelCase_	  =					1
       lowerCamelCase_	  =					FocalNetForMaskedImageModeling(A_						)
       model.to(A_						)
       model.eval()

       lowerCamelCase_	  =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
       lowerCamelCase_	  =					model(A_						)
       self.parent.assertEqual(result.reconstruction.shape		,							(self.batch_size, 1, self.image_size, self.image_size)						)

 def        a__				(       self      :						Tuple		,							A_      :						List[Any]		,							A_      :						int		,							A_      :						Dict						)     ->			Union[str, Any]:

       """simple docstring"""






       lowerCamelCase_	  =					self.type_sequence_label_size
       lowerCamelCase_	  =					FocalNetForImageClassification(A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_		,							labels=A_						)
       self.parent.assertEqual(result.logits.shape		,							(self.batch_size, self.type_sequence_label_size)						)

       # test greyscale images
       lowerCamelCase_	  =					1
       lowerCamelCase_	  =					FocalNetForImageClassification(A_						)
       model.to(A_						)
       model.eval()

       lowerCamelCase_	  =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
       lowerCamelCase_	  =					model(A_						)
       self.parent.assertEqual(result.logits.shape		,							(self.batch_size, self.type_sequence_label_size)						)





 def        a__				(       self      :						int						)     ->			Optional[Any]:

       """simple docstring"""






       lowerCamelCase_	  =					self.prepare_config_and_inputs()

       lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_	  =					config_and_inputs
       lowerCamelCase_	  =					{'pixel_values': pixel_values}
       return config, inputs_dict







@require_torch
class 						A(		UpperCamelCase							,   UpperCamelCase							,   unittest.TestCase     ):



 '''simple docstring'''


 UpperCamelCase		     =		(
     (
         FocalNetModel,
         FocalNetForImageClassification,
         FocalNetForMaskedImageModeling,
         FocalNetBackbone,
     )
     if is_torch_available()
     else ()
 )
 UpperCamelCase		     =		(
     {'''feature-extraction''': FocalNetModel, '''image-classification''': FocalNetForImageClassification}
     if is_torch_available()
     else {}
 )
 UpperCamelCase		     =		False

 UpperCamelCase		     =		False
 UpperCamelCase		     =		False
 UpperCamelCase		     =		False
 UpperCamelCase		     =		False

 def        a__				(       self      :						List[Any]						)     ->			Dict:

       """simple docstring"""






       lowerCamelCase_	  =					FocalNetModelTester(self						)
       lowerCamelCase_	  =					ConfigTester(self		,							config_class=A_		,							embed_dim=37		,							has_text_modality=A_						)

 def        a__				(       self      :						Dict						)     ->			Union[str, Any]:

       """simple docstring"""






       self.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()

 def        a__				(       self      :						Any						)     ->			Optional[int]:

       """simple docstring"""






       return

 def        a__				(       self      :						Union[str, Any]						)     ->			Optional[Any]:

       """simple docstring"""






       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*A_						)

 def        a__				(       self      :						Union[str, Any]						)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*A_						)

 def        a__				(       self      :						Dict						)     ->			int:

       """simple docstring"""






       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*A_						)

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

       """simple docstring"""






       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*A_						)

 @unittest.skip(reason='FocalNet does not use inputs_embeds'						)
 def        a__				(       self      :						int						)     ->			int:

       """simple docstring"""






       pass

 @unittest.skip(reason='FocalNet does not use feedforward chunking'						)
 def        a__				(       self      :						Tuple						)     ->			List[str]:

       """simple docstring"""






       pass

 def        a__				(       self      :						Union[str, Any]						)     ->			Dict:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes[:-1]:
             lowerCamelCase_	  =					model_class(A_						)
             self.assertIsInstance(model.get_input_embeddings()		,							(nn.Module)						)
             lowerCamelCase_	  =					model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(A_		,							nn.Linear						)						)

 def        a__				(       self      :						Any						)     ->			Optional[int]:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes[:-1]:
             lowerCamelCase_	  =					model_class(A_						)
             lowerCamelCase_	  =					inspect.signature(model.forward						)
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             lowerCamelCase_	  =					[*signature.parameters.keys()]

             lowerCamelCase_	  =					['pixel_values']
             self.assertListEqual(arg_names[:1]		,							A_						)

 def        a__				(       self      :						int		,							A_      :						List[Any]		,							A_      :						int		,							A_      :						Dict		,							A_      :						Dict						)     ->			List[Any]:

       """simple docstring"""






       lowerCamelCase_	  =					model_class(A_						)
       model.to(A_						)
       model.eval()

       with torch.no_grad():
             lowerCamelCase_	  =					model(**self._prepare_for_class(A_		,							A_						)						)

       lowerCamelCase_	  =					outputs.hidden_states

       lowerCamelCase_	  =					getattr(
           self.model_tester		,							'expected_num_hidden_layers'		,							len(self.model_tester.depths						) + 1						)
       self.assertEqual(len(A_						)		,							A_						)

       # FocalNet has a different seq_length
       lowerCamelCase_	  =					(
           config.patch_size
           if isinstance(config.patch_size		,							collections.abc.Iterable						)
           else (config.patch_size, config.patch_size)
       )

       lowerCamelCase_	  =					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

       self.assertListEqual(
           list(hidden_states[0].shape[-2:]						)		,							[num_patches, self.model_tester.embed_dim]		,							)

       lowerCamelCase_	  =					outputs.reshaped_hidden_states
       self.assertEqual(len(A_						)		,							A_						)

       lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_	  =					reshaped_hidden_states[0].shape
       lowerCamelCase_	  =					(
           reshaped_hidden_states[0].view(A_		,							A_		,							height * width						).permute(0		,							2		,							1						)
       )
       self.assertListEqual(
           list(reshaped_hidden_states.shape[-2:]						)		,							[num_patches, self.model_tester.embed_dim]		,							)

 def        a__				(       self      :						Optional[int]						)     ->			List[Any]:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()

       lowerCamelCase_	  =					(
           self.model_tester.image_size
           if isinstance(self.model_tester.image_size		,							collections.abc.Iterable						)
           else (self.model_tester.image_size, self.model_tester.image_size)
       )

       for model_class in self.all_model_classes[:-1]:
             lowerCamelCase_	  =					True
             self.check_hidden_states_output(A_		,							A_		,							A_		,							A_						)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             lowerCamelCase_	  =					True

             self.check_hidden_states_output(A_		,							A_		,							A_		,							A_						)

 def        a__				(       self      :						List[str]						)     ->			Dict:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()
       lowerCamelCase_	  =					3

       lowerCamelCase_	  =					(
           self.model_tester.image_size
           if isinstance(self.model_tester.image_size		,							collections.abc.Iterable						)
           else (self.model_tester.image_size, self.model_tester.image_size)
       )
       lowerCamelCase_	  =					(
           config.patch_size
           if isinstance(config.patch_size		,							collections.abc.Iterable						)
           else (config.patch_size, config.patch_size)
       )

       lowerCamelCase_	  =					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
       lowerCamelCase_	  =					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

       for model_class in self.all_model_classes[:-1]:
             lowerCamelCase_	  =					True
             self.check_hidden_states_output(A_		,							A_		,							A_		,							(padded_height, padded_width)						)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             lowerCamelCase_	  =					True
             self.check_hidden_states_output(A_		,							A_		,							A_		,							(padded_height, padded_width)						)

 @slow
 def        a__				(       self      :						str						)     ->			Optional[Any]:

       """simple docstring"""






       for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowerCamelCase_	  =					FocalNetModel.from_pretrained(A_						)
             self.assertIsNotNone(A_						)





 def        a__				(       self      :						List[Any]						)     ->			Tuple:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()

       lowerCamelCase_	  =					_config_zero_init(A_						)
       for model_class in self.all_model_classes:
             lowerCamelCase_	  =					model_class(config=A_						)
             for name, param in model.named_parameters():
                   if "embeddings" not in name and param.requires_grad:
                         self.assertIn(
                             ((param.data.mean() * 1E9).round() / 1E9).item()		,							[0.0, 1.0]		,							msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""		,							)







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



 '''simple docstring'''


 @cached_property
 def        a__				(       self      :						List[str]						)     ->			Optional[int]:

       """simple docstring"""






       return AutoImageProcessor.from_pretrained('microsoft/focalnet-tiny'						) if is_vision_available() else None





 @slow
 def        a__				(       self      :						Tuple						)     ->			Any:

       """simple docstring"""






       lowerCamelCase_	  =					FocalNetForImageClassification.from_pretrained('microsoft/focalnet-tiny'						).to(A_						)
       lowerCamelCase_	  =					self.default_image_processor

       lowerCamelCase_	  =					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'						)
       lowerCamelCase_	  =					image_processor(images=A_		,							return_tensors='pt'						).to(A_						)

       # forward pass
       with torch.no_grad():
             lowerCamelCase_	  =					model(**A_						)

       # verify the logits
       lowerCamelCase_	  =					torch.Size((1, 1000)						)
       self.assertEqual(outputs.logits.shape		,							A_						)
       lowerCamelCase_	  =					torch.tensor([0.2166, -0.4368, 0.2191]						).to(A_						)
       self.assertTrue(torch.allclose(outputs.logits[0, :3]		,							A_		,							atol=1E-4						)						)
       self.assertTrue(outputs.logits.argmax(dim=-1						).item()		,							281						)







@require_torch
class 						A(		UpperCamelCase							,   unittest.TestCase     ):



 '''simple docstring'''


 UpperCamelCase		     =		(FocalNetBackbone,) if is_torch_available() else ()
 UpperCamelCase		     =		FocalNetConfig

 UpperCamelCase		     =		False

 def        a__				(       self      :						List[str]						)     ->			Tuple:

       """simple docstring"""






       lowerCamelCase_	  =					FocalNetModelTester(self						)



