
"""simple docstring"""




from typing import Any, Dict, Optional

import torch
import torch.nn.functional as F
from torch import nn

from ..utils import maybe_allow_in_graph
from .activations import get_activation
from .attention_processor import Attention
from .embeddings import CombinedTimestepLabelEmbeddings



@maybe_allow_in_graph
class 	lowerCAmelCase_						(nn.Module  ):


				"""simple docstring"""



				def __init__(self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__=0.0   ,       SCREAMING_SNAKE_CASE__ = None   ,       SCREAMING_SNAKE_CASE__ = "geglu"   ,       SCREAMING_SNAKE_CASE__ = None   ,       SCREAMING_SNAKE_CASE__ = False   ,       SCREAMING_SNAKE_CASE__ = False   ,       SCREAMING_SNAKE_CASE__ = False   ,       SCREAMING_SNAKE_CASE__ = False   ,       SCREAMING_SNAKE_CASE__ = True   ,       SCREAMING_SNAKE_CASE__ = "layer_norm"   ,       SCREAMING_SNAKE_CASE__ = False   ,       )					->		Optional[Any]:



											"""simple docstring"""




											super().__init__()
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   only_cross_attention

											SCREAMING_SNAKE_CASE__						:       List[Any]           =   (num_embeds_ada_norm is not None) and norm_type == """ada_norm_zero"""
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   (num_embeds_ada_norm is not None) and norm_type == """ada_norm"""

											if norm_type in ("ada_norm", "ada_norm_zero") and num_embeds_ada_norm is None:
																		raise ValueError(
																		    F'''`norm_type` is set to {norm_type}, but `num_embeds_ada_norm` is not defined. Please make sure to'''
																		    F''' define `num_embeds_ada_norm` if setting `norm_type` to {norm_type}.'''    )

											# Define 3 blocks. Each block has its own normalization layer.
											# 1. Self-Attn
											if self.use_ada_layer_norm:
																		SCREAMING_SNAKE_CASE__						:       int           =   AdaLayerNorm(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )
											elif self.use_ada_layer_norm_zero:
																		SCREAMING_SNAKE_CASE__						:       Tuple           =   AdaLayerNormZero(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )
											else:
																		SCREAMING_SNAKE_CASE__						:       Optional[int]           =   nn.LayerNorm(SCREAMING_SNAKE_CASE__   ,       elementwise_affine=SCREAMING_SNAKE_CASE__    )
											SCREAMING_SNAKE_CASE__						:       Dict           =   Attention(
											    query_dim=SCREAMING_SNAKE_CASE__   ,       heads=SCREAMING_SNAKE_CASE__   ,       dim_head=SCREAMING_SNAKE_CASE__   ,       dropout=SCREAMING_SNAKE_CASE__   ,       bias=SCREAMING_SNAKE_CASE__   ,       cross_attention_dim=cross_attention_dim if only_cross_attention else None   ,       upcast_attention=SCREAMING_SNAKE_CASE__   ,       )

											# 2. Cross-Attn
											if cross_attention_dim is not None or double_self_attention:
																		# We currently only use AdaLayerNormZero for self attention where there will only be one attention block.
																		# I.e. the number of returned modulation chunks from AdaLayerZero would not make sense if returned during
																		# the second cross attention block.
																		SCREAMING_SNAKE_CASE__						:       Any           =   (
																		    AdaLayerNorm(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )
																		    if self.use_ada_layer_norm
																		    else nn.LayerNorm(SCREAMING_SNAKE_CASE__   ,       elementwise_affine=SCREAMING_SNAKE_CASE__    )
																		)
																		SCREAMING_SNAKE_CASE__						:       Tuple           =   Attention(
																		    query_dim=SCREAMING_SNAKE_CASE__   ,       cross_attention_dim=cross_attention_dim if not double_self_attention else None   ,       heads=SCREAMING_SNAKE_CASE__   ,       dim_head=SCREAMING_SNAKE_CASE__   ,       dropout=SCREAMING_SNAKE_CASE__   ,       bias=SCREAMING_SNAKE_CASE__   ,       upcast_attention=SCREAMING_SNAKE_CASE__   ,       )  # is self-attn if encoder_hidden_states is none
											else:
																		SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   None
																		SCREAMING_SNAKE_CASE__						:       str           =   None

											# 3. Feed-forward
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   nn.LayerNorm(SCREAMING_SNAKE_CASE__   ,       elementwise_affine=SCREAMING_SNAKE_CASE__    )
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   FeedForward(SCREAMING_SNAKE_CASE__   ,       dropout=SCREAMING_SNAKE_CASE__   ,       activation_fn=SCREAMING_SNAKE_CASE__   ,       final_dropout=SCREAMING_SNAKE_CASE__    )

											# let chunk size default to None
											SCREAMING_SNAKE_CASE__						:       Tuple           =   None
											SCREAMING_SNAKE_CASE__						:       Dict           =   0



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   chunk_size
											SCREAMING_SNAKE_CASE__						:       str           =   dim



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__ = None   ,       SCREAMING_SNAKE_CASE__ = None   ,       SCREAMING_SNAKE_CASE__ = None   ,       SCREAMING_SNAKE_CASE__ = None   ,       SCREAMING_SNAKE_CASE__ = None   ,       SCREAMING_SNAKE_CASE__ = None   ,       )					->		Any:



											"""simple docstring"""




											if self.use_ada_layer_norm:
																		SCREAMING_SNAKE_CASE__						:       Any           =   self.norma(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )
											elif self.use_ada_layer_norm_zero:
																		SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   self.norma(
																		    SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       hidden_dtype=hidden_states.dtype    )
											else:
																		SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   self.norma(SCREAMING_SNAKE_CASE__    )

											SCREAMING_SNAKE_CASE__						:       int           =   cross_attention_kwargs if cross_attention_kwargs is not None else {}

											SCREAMING_SNAKE_CASE__						:       List[Any]           =   self.attna(
											    SCREAMING_SNAKE_CASE__   ,       encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None   ,       attention_mask=SCREAMING_SNAKE_CASE__   ,       **SCREAMING_SNAKE_CASE__   ,       )
											if self.use_ada_layer_norm_zero:
																		SCREAMING_SNAKE_CASE__						:       List[str]           =   gate_msa.unsqueeze(1    ) * attn_output
											SCREAMING_SNAKE_CASE__						:       Dict           =   attn_output + hidden_states

											# 2. Cross-Attention
											if self.attna is not None:
																		SCREAMING_SNAKE_CASE__						:       str           =   (
																		    self.norma(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    ) if self.use_ada_layer_norm else self.norma(SCREAMING_SNAKE_CASE__    )
																		)

																		SCREAMING_SNAKE_CASE__						:       List[str]           =   self.attna(
																		    SCREAMING_SNAKE_CASE__   ,       encoder_hidden_states=SCREAMING_SNAKE_CASE__   ,       attention_mask=SCREAMING_SNAKE_CASE__   ,       **SCREAMING_SNAKE_CASE__   ,       )
																		SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   attn_output + hidden_states

											# 3. Feed-forward
											SCREAMING_SNAKE_CASE__						:       Any           =   self.norma(SCREAMING_SNAKE_CASE__    )

											if self.use_ada_layer_norm_zero:
																		SCREAMING_SNAKE_CASE__						:       Optional[int]           =   norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None]

											if self._chunk_size is not None:
																		# "feed_forward_chunk_size" can be used to save memory
																		if norm_hidden_states.shape[self._chunk_dim] % self._chunk_size != 0:
																									raise ValueError(
																									    F'''`hidden_states` dimension to be chunked: {norm_hidden_states.shape[self._chunk_dim]} has to be divisible by chunk size: {self._chunk_size}. Make sure to set an appropriate `chunk_size` when calling `unet.enable_forward_chunking`.'''    )

																		SCREAMING_SNAKE_CASE__						:       List[str]           =   norm_hidden_states.shape[self._chunk_dim] // self._chunk_size
																		SCREAMING_SNAKE_CASE__						:       int           =   torch.cat(
																		    [self.ff(SCREAMING_SNAKE_CASE__    ) for hid_slice in norm_hidden_states.chunk(SCREAMING_SNAKE_CASE__   ,       dim=self._chunk_dim    )]   ,       dim=self._chunk_dim   ,       )
											else:
																		SCREAMING_SNAKE_CASE__						:       int           =   self.ff(SCREAMING_SNAKE_CASE__    )

											if self.use_ada_layer_norm_zero:
																		SCREAMING_SNAKE_CASE__						:       Tuple           =   gate_mlp.unsqueeze(1    ) * ff_output

											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   ff_output + hidden_states

											return hidden_states






class 	lowerCAmelCase_						(nn.Module  ):


				"""simple docstring"""



				def __init__(self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__ = None   ,       SCREAMING_SNAKE_CASE__ = 4   ,       SCREAMING_SNAKE_CASE__ = 0.0   ,       SCREAMING_SNAKE_CASE__ = "geglu"   ,       SCREAMING_SNAKE_CASE__ = False   ,       )					->		Tuple:



											"""simple docstring"""




											super().__init__()
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   int(dim * mult    )
											SCREAMING_SNAKE_CASE__						:       Tuple           =   dim_out if dim_out is not None else dim

											if activation_fn == "gelu":
																		SCREAMING_SNAKE_CASE__						:       str           =   GELU(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )
											if activation_fn == "gelu-approximate":
																		SCREAMING_SNAKE_CASE__						:       List[str]           =   GELU(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       approximate="""tanh"""    )
											elif activation_fn == "geglu":
																		SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   GEGLU(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )
											elif activation_fn == "geglu-approximate":
																		SCREAMING_SNAKE_CASE__						:       int           =   ApproximateGELU(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )

											SCREAMING_SNAKE_CASE__						:       Any           =   nn.ModuleList([]    )
											# project in
											self.net.append(SCREAMING_SNAKE_CASE__    )
											# project dropout
											self.net.append(nn.Dropout(SCREAMING_SNAKE_CASE__    )    )
											# project out
											self.net.append(nn.Linear(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )    )
											# FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout
											if final_dropout:
																		self.net.append(nn.Dropout(SCREAMING_SNAKE_CASE__    )    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__    )					->		Union[str, Any]:



											"""simple docstring"""




											for module in self.net:
																		SCREAMING_SNAKE_CASE__						:       Dict           =   module(SCREAMING_SNAKE_CASE__    )
											return hidden_states






class 	lowerCAmelCase_						(nn.Module  ):


				"""simple docstring"""



				def __init__(self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__ = "none"    )					->		List[Any]:



											"""simple docstring"""




											super().__init__()
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   nn.Linear(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )
											SCREAMING_SNAKE_CASE__						:       Any           =   approximate



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__    )					->		Optional[int]:



											"""simple docstring"""




											if gate.device.type != "mps":
																		return F.gelu(SCREAMING_SNAKE_CASE__   ,       approximate=self.approximate    )
											# mps: gelu is not implemented for float16
											return F.gelu(gate.to(dtype=torch.floataa    )   ,       approximate=self.approximate    ).to(dtype=gate.dtype    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__    )					->		str:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       str           =   self.proj(SCREAMING_SNAKE_CASE__    )
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   self.gelu(SCREAMING_SNAKE_CASE__    )
											return hidden_states






class 	lowerCAmelCase_						(nn.Module  ):


				"""simple docstring"""



				def __init__(self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		Dict:



											"""simple docstring"""




											super().__init__()
											SCREAMING_SNAKE_CASE__						:       Dict           =   nn.Linear(SCREAMING_SNAKE_CASE__   ,       dim_out * 2    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__    )					->		int:



											"""simple docstring"""




											if gate.device.type != "mps":
																		return F.gelu(SCREAMING_SNAKE_CASE__    )
											# mps: gelu is not implemented for float16
											return F.gelu(gate.to(dtype=torch.floataa    )    ).to(dtype=gate.dtype    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__    )					->		Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   self.proj(SCREAMING_SNAKE_CASE__    ).chunk(2   ,       dim=-1    )
											return hidden_states * self.gelu(SCREAMING_SNAKE_CASE__    )






class 	lowerCAmelCase_						(nn.Module  ):


				"""simple docstring"""



				def __init__(self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		List[Any]:



											"""simple docstring"""




											super().__init__()
											SCREAMING_SNAKE_CASE__						:       str           =   nn.Linear(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__    )					->		Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       int           =   self.proj(SCREAMING_SNAKE_CASE__    )
											return x * torch.sigmoid(1.702 * x    )






class 	lowerCAmelCase_						(nn.Module  ):


				"""simple docstring"""



				def __init__(self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		Optional[Any]:



											"""simple docstring"""




											super().__init__()
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   nn.Embedding(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )
											SCREAMING_SNAKE_CASE__						:       Dict           =   nn.SiLU()
											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   nn.Linear(SCREAMING_SNAKE_CASE__   ,       embedding_dim * 2    )
											SCREAMING_SNAKE_CASE__						:       List[str]           =   nn.LayerNorm(SCREAMING_SNAKE_CASE__   ,       elementwise_affine=SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		List[str]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       List[str]           =   self.linear(self.silu(self.emb(SCREAMING_SNAKE_CASE__    )    )    )
											SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__						:       int           =   torch.chunk(SCREAMING_SNAKE_CASE__   ,       2    )
											SCREAMING_SNAKE_CASE__						:       Dict           =   self.norm(SCREAMING_SNAKE_CASE__    ) * (1 + scale) + shift
											return x






class 	lowerCAmelCase_						(nn.Module  ):


				"""simple docstring"""



				def __init__(self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		int:



											"""simple docstring"""




											super().__init__()

											SCREAMING_SNAKE_CASE__						:       Any           =   CombinedTimestepLabelEmbeddings(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )

											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   nn.SiLU()
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   nn.Linear(SCREAMING_SNAKE_CASE__   ,       6 * embedding_dim   ,       bias=SCREAMING_SNAKE_CASE__    )
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   nn.LayerNorm(SCREAMING_SNAKE_CASE__   ,       elementwise_affine=SCREAMING_SNAKE_CASE__   ,       eps=1E-6    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__=None    )					->		Union[str, Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       int           =   self.linear(self.silu(self.emb(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       hidden_dtype=SCREAMING_SNAKE_CASE__    )    )    )
											SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__						:       int           =   emb.chunk(6   ,       dim=1    )
											SCREAMING_SNAKE_CASE__						:       Tuple           =   self.norm(SCREAMING_SNAKE_CASE__    ) * (1 + scale_msa[:, None]) + shift_msa[:, None]
											return x, gate_msa, shift_mlp, scale_mlp, gate_mlp






class 	lowerCAmelCase_						(nn.Module  ):


				"""simple docstring"""



				def __init__(self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__ = None   ,       SCREAMING_SNAKE_CASE__ = 1E-5    )					->		int:



											"""simple docstring"""




											super().__init__()
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   num_groups
											SCREAMING_SNAKE_CASE__						:       Any           =   eps

											if act_fn is None:
																		SCREAMING_SNAKE_CASE__						:       Any           =   None
											else:
																		SCREAMING_SNAKE_CASE__						:       Dict           =   get_activation(SCREAMING_SNAKE_CASE__    )

											SCREAMING_SNAKE_CASE__						:       List[Any]           =   nn.Linear(SCREAMING_SNAKE_CASE__   ,       out_dim * 2    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		Any:



											"""simple docstring"""




											if self.act:
																		SCREAMING_SNAKE_CASE__						:       Tuple           =   self.act(SCREAMING_SNAKE_CASE__    )
											SCREAMING_SNAKE_CASE__						:       Dict           =   self.linear(SCREAMING_SNAKE_CASE__    )
											SCREAMING_SNAKE_CASE__						:       Dict           =   emb[:, :, None, None]
											SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__						:       List[Any]           =   emb.chunk(2   ,       dim=1    )

											SCREAMING_SNAKE_CASE__						:       Dict           =   F.group_norm(SCREAMING_SNAKE_CASE__   ,       self.num_groups   ,       eps=self.eps    )
											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   x * (1 + scale) + shift
											return x








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      :    str		=					"<" 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      :    str		=					[
    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 			_lowercase :


       """simple docstring"""




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





       def __call__(   self							:			Any       ):


             '''simple docstring'''



             return self.pa_type





       def 						lowerCAmelCase     (   self							:			Optional[Any]					,      __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       ):
                   lowerCamelCase__		:				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 						lowerCAmelCase     (   self							:			Any					,      __lowerCamelCase							:			dict					,      __lowerCamelCase							:			List[Any]=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:
                   lowerCamelCase__		:				Union[str, Any]    =  {}

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





       def 						lowerCAmelCase     (   self							:			Dict       ):


             '''simple docstring'''



             from .features import Value

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





       def 						lowerCAmelCase     (   self							:			Optional[Any]					,      __lowerCamelCase							:			Union[pa.StringArray, pa.StructArray, pa.ListArray]       ):


             '''simple docstring'''



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





       def 						lowerCAmelCase     (   self							:			int					,      __lowerCamelCase							:			pa.StructArray       ):


             '''simple docstring'''



             @no_op_if_value_is_null
             def path_to_bytes(__lowerCamelCase							:			Union[str, Any]       ):
                   with xopen(__lowerCamelCase					,      "rb"       ) as f:
                         lowerCamelCase__		:				str    =  f.read()
                   return bytes_

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



def       lowercase_		(		):

      """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[str]    =  list(set(PIL.Image.OPEN.keys()						) & set(PIL.Image.SAVE.keys()						)						)
      return _IMAGE_COMPRESSION_FORMATS

def       lowercase_		(		_A			:    "PIL.Image.Image"						):

      """simple docstring"""




      lowerCamelCase__		:				Optional[Any]    =  BytesIO()
      if image.format in list_image_compression_formats():
            lowerCamelCase__		:				int    =  image.format
      else:
            lowerCamelCase__		:				int    =  "PNG" if image.mode in ["1", "L", "LA", "RGB", "RGBA"] else "TIFF"
      image.save(_A    ,					format=_A						)
      return buffer.getvalue()

def       lowercase_		(		_A			:    "PIL.Image.Image"						):

      """simple docstring"""




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

def       lowercase_		(		_A			:    np.ndarray						):

      """simple docstring"""




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

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

      lowerCamelCase__		:				Dict    =  None

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


def       lowercase_		(		_A			:    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__		:				int    =  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						):
                  lowerCamelCase__		:				Optional[Any]    =  no_op_if_value_is_null(_A						)
                  return [obj_to_image_dict_func(_A						) for obj in objs]
            elif isinstance(_A    ,					PIL.Image.Image						):
                  lowerCamelCase__		:				int    =  no_op_if_value_is_null(_A						)
                  return [obj_to_image_dict_func(_A						) for obj in objs]
            else:
                  return objs
      else:
            return objs


