





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


A__:    Optional[List[str]]  	=	None
A__:    Dict  	=	'''<''' 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
A__:    Any  	=	[
    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:			Dict					):
          '''simple docstring'''


          return self.pa_type






      def 			UpperCAmelCase_       (		self:			List[str]	,    __lowerCamelCase:			Union[str, bytes, dict, np.ndarray, "PIL.Image.Image"]					):
          '''simple docstring'''


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

          if isinstance(__lowerCamelCase	,    __lowerCamelCase					):
              UpperCamelCase__:	List[str]					=     np.array(__lowerCamelCase					)

          if isinstance(__lowerCamelCase	,    __lowerCamelCase					):
              return {"path": value, "bytes": None}
          elif isinstance(__lowerCamelCase	,    __lowerCamelCase					):
              return {"path": None, "bytes": value}
          elif isinstance(__lowerCamelCase	,    np.ndarray					):
              # convert the image array to PNG/TIFF bytes
              return encode_np_array(__lowerCamelCase					)
          elif isinstance(__lowerCamelCase	,    PIL.Image.Image					):
              # convert the PIL image to bytes (default format is PNG/TIFF)
              return encode_pil_image(__lowerCamelCase					)
          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 			UpperCAmelCase_       (		self:			Optional[Any]	,    __lowerCamelCase:			dict	,    __lowerCamelCase:			int=None					):
          '''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:
              UpperCamelCase__:	Tuple					=     {}

          UpperCamelCase__				, UpperCamelCase__:	int					=     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(__lowerCamelCase					):
                      UpperCamelCase__:	str					=     PIL.Image.open(__lowerCamelCase					)
                  else:
                      UpperCamelCase__:	List[Any]					=     path.split("::"					)[-1]
                      try:
                          UpperCamelCase__:	int					=     string_to_dict(__lowerCamelCase	,    config.HUB_DATASETS_URL					)["repo_id"]
                          UpperCamelCase__:	Tuple					=     token_per_repo_id.get(__lowerCamelCase					)
                      except ValueError:
                          UpperCamelCase__:	Tuple					=     None
                      with xopen(__lowerCamelCase	,    "rb"	,    use_auth_token=__lowerCamelCase					) as f:
                          UpperCamelCase__:	Optional[Any]					=     BytesIO(f.read()					)
                      UpperCamelCase__:	List[Any]					=     PIL.Image.open(bytes_					)
          else:
              UpperCamelCase__:	Optional[int]					=     PIL.Image.open(BytesIO(bytes_					)					)
          image.load()  # to avoid "Too many open files" errors
          return image






      def 			UpperCAmelCase_       (		self:			Tuple					):
          '''simple docstring'''


          from .features import Value

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






      def 			UpperCAmelCase_       (		self:			str	,    __lowerCamelCase:			Union[pa.StringArray, pa.StructArray, pa.ListArray]					):
          '''simple docstring'''


          if pa.types.is_string(storage.type					):
              UpperCamelCase__:	Optional[Any]					=     pa.array([None] * len(__lowerCamelCase					)	,    type=pa.binary()					)
              UpperCamelCase__:	Dict					=     pa.StructArray.from_arrays([bytes_array, storage]	,    ["bytes", "path"]	,    mask=storage.is_null()					)
          elif pa.types.is_binary(storage.type					):
              UpperCamelCase__:	Any					=     pa.array([None] * len(__lowerCamelCase					)	,    type=pa.string()					)
              UpperCamelCase__:	Union[str, Any]					=     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:
                  UpperCamelCase__:	Optional[int]					=     storage.field("bytes"					)
              else:
                  UpperCamelCase__:	Dict					=     pa.array([None] * len(__lowerCamelCase					)	,    type=pa.binary()					)
              if storage.type.get_field_index("path"					) >= 0:
                  UpperCamelCase__:	List[Any]					=     storage.field("path"					)
              else:
                  UpperCamelCase__:	Tuple					=     pa.array([None] * len(__lowerCamelCase					)	,    type=pa.string()					)
              UpperCamelCase__:	str					=     pa.StructArray.from_arrays([bytes_array, path_array]	,    ["bytes", "path"]	,    mask=storage.is_null()					)
          elif pa.types.is_list(storage.type					):
              UpperCamelCase__:	List[Any]					=     pa.array(
                  [encode_np_array(np.array(__lowerCamelCase					)					)["bytes"] if arr is not None else None for arr in storage.to_pylist()]	,    type=pa.binary()	,    )
              UpperCamelCase__:	str					=     pa.array([None] * len(__lowerCamelCase					)	,    type=pa.string()					)
              UpperCamelCase__:	int					=     pa.StructArray.from_arrays(
                  [bytes_array, path_array]	,    ["bytes", "path"]	,    mask=bytes_array.is_null()					)
          return array_cast(__lowerCamelCase	,    self.pa_type					)






      def 			UpperCAmelCase_       (		self:			List[str]	,    __lowerCamelCase:			pa.StructArray					):
          '''simple docstring'''


          @no_op_if_value_is_null
          def path_to_bytes(__lowerCamelCase:			int					):
              with xopen(__lowerCamelCase	,    "rb"					) as f:
                  UpperCamelCase__:	int					=     f.read()
              return bytes_

          UpperCamelCase__:	Any					=     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()	,    )
          UpperCamelCase__:	Any					=     pa.array(
              [os.path.basename(__lowerCamelCase					) if path is not None else None for path in storage.field("path"					).to_pylist()]	,    type=pa.string()	,    )
          UpperCamelCase__:	Union[str, Any]					=     pa.StructArray.from_arrays([bytes_array, path_array]	,    ["bytes", "path"]	,    mask=bytes_array.is_null()					)
          return array_cast(__lowerCamelCase	,    self.pa_type					)



def 				lowerCAmelCase_ (							):
    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()
        UpperCamelCase__:	Dict					=     list(set(PIL.Image.OPEN.keys()) & set(PIL.Image.SAVE.keys()))
    return _IMAGE_COMPRESSION_FORMATS



def 				lowerCAmelCase_ (							A_):
    UpperCamelCase__:	Tuple					=     BytesIO()
    if image.format in list_image_compression_formats():
        UpperCamelCase__:	str					=     image.format
    else:
        UpperCamelCase__:	Optional[int]					=     "PNG" if image.mode in ["1", "L", "LA", "RGB", "RGBA"] else "TIFF"
    image.save(A_    ,format=A_)
    return buffer.getvalue()



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



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

    UpperCamelCase__:	Dict					=     array.dtype
    UpperCamelCase__:	Optional[int]					=     dtype.byteorder if dtype.byteorder != "=" else _NATIVE_BYTEORDER
    UpperCamelCase__:	List[Any]					=     dtype.kind
    UpperCamelCase__:	List[str]					=     dtype.itemsize

    UpperCamelCase__:	Tuple					=     None

    # Multi-channel array case (only np.dtype("|u1") is allowed)
    if array.shape[2:]:
        UpperCamelCase__:	str					=     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:
        UpperCamelCase__:	str					=     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:
            UpperCamelCase__:	Optional[int]					=     dtype_byteorder + dtype_kind + str(A_)
            UpperCamelCase__:	List[str]					=     np.dtype(A_)
            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}")
    UpperCamelCase__:	List[str]					=     PIL.Image.fromarray(array.astype(A_))
    return {"path": None, "bytes": image_to_bytes(A_)}




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

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








from collections import OrderedDict
from typing import Mapping

from packaging import version

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


A__:    Tuple  	=	logging.get_logger(__name__)

A__:    List[Any]  	=	{
    '''microsoft/swin-tiny-patch4-window7-224''': (
        '''https://huggingface.co/microsoft/swin-tiny-patch4-window7-224/resolve/main/config.json'''
    ),
    # See all Swin models at https://huggingface.co/models?filter=swin
}




class        _a    (    UpperCamelCase__						,			UpperCamelCase__):

      """simple docstring"""


      UpperCamelCase__  		=       """swin"""

      UpperCamelCase__  		=       {
          """num_attention_heads""": """num_heads""",
          """num_hidden_layers""": """num_layers""",
      }






      def __init__(		self:			Any	,    __lowerCamelCase:			Optional[Any]=224	,    __lowerCamelCase:			List[Any]=4	,    __lowerCamelCase:			Any=3	,    __lowerCamelCase:			Dict=96	,    __lowerCamelCase:			List[str]=[2, 2, 6, 2]	,    __lowerCamelCase:			int=[3, 6, 12, 24]	,    __lowerCamelCase:			str=7	,    __lowerCamelCase:			Union[str, Any]=4.0	,    __lowerCamelCase:			Union[str, Any]=True	,    __lowerCamelCase:			List[str]=0.0	,    __lowerCamelCase:			Union[str, Any]=0.0	,    __lowerCamelCase:			List[str]=0.1	,    __lowerCamelCase:			Union[str, Any]="gelu"	,    __lowerCamelCase:			List[str]=False	,    __lowerCamelCase:			Any=0.02	,    __lowerCamelCase:			Any=1e-5	,    __lowerCamelCase:			Optional[Any]=32	,    __lowerCamelCase:			Tuple=None	,    __lowerCamelCase:			int=None	,    **__lowerCamelCase:			int	,    ):
          '''simple docstring'''


          super().__init__(**__lowerCamelCase					)

          UpperCamelCase__:	List[Any]					=     image_size
          UpperCamelCase__:	str					=     patch_size
          UpperCamelCase__:	Optional[int]					=     num_channels
          UpperCamelCase__:	Dict					=     embed_dim
          UpperCamelCase__:	int					=     depths
          UpperCamelCase__:	List[str]					=     len(__lowerCamelCase					)
          UpperCamelCase__:	List[Any]					=     num_heads
          UpperCamelCase__:	Union[str, Any]					=     window_size
          UpperCamelCase__:	Dict					=     mlp_ratio
          UpperCamelCase__:	List[Any]					=     qkv_bias
          UpperCamelCase__:	Union[str, Any]					=     hidden_dropout_prob
          UpperCamelCase__:	int					=     attention_probs_dropout_prob
          UpperCamelCase__:	str					=     drop_path_rate
          UpperCamelCase__:	str					=     hidden_act
          UpperCamelCase__:	Any					=     use_absolute_embeddings
          UpperCamelCase__:	Union[str, Any]					=     layer_norm_eps
          UpperCamelCase__:	Tuple					=     initializer_range
          UpperCamelCase__:	Tuple					=     encoder_stride
          # we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
          # this indicates the channel dimension after the last stage of the model
          UpperCamelCase__:	Any					=     int(embed_dim * 2 ** (len(__lowerCamelCase					) - 1)					)
          UpperCamelCase__:	str					=     ["stem"] + [F"stage{idx}" for idx in range(1	,    len(__lowerCamelCase					) + 1					)]
          UpperCamelCase__				, UpperCamelCase__:	List[str]					=     get_aligned_output_features_output_indices(
              out_features=__lowerCamelCase	,    out_indices=__lowerCamelCase	,    stage_names=self.stage_names					)




class        _a    (    UpperCamelCase__):

      """simple docstring"""


      UpperCamelCase__  		=       version.parse("""1.11""")






      @property
      def 			UpperCAmelCase_       (		self:			List[Any]					):
          '''simple docstring'''


          return OrderedDict(
              [
                  ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
              ]					)






      @property
      def 			UpperCAmelCase_       (		self:			Union[str, Any]					):
          '''simple docstring'''


          return 1e-4

