



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


snake_case__					:     Optional[List[str]]    		=   None
snake_case__					:     Optional[Any]    		=   """<""" 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
snake_case__					:     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   _A   :


						'''simple docstring'''





						_snake_case			:     bool      							=      True
						_snake_case			:     Optional[str]      							=      None
						# Automatically constructed
						_snake_case			:     ClassVar[str]      							=      "PIL.Image.Image"
						_snake_case			:     ClassVar[Any]      							=      pa.struct({"""bytes""": pa.binary(), """path""": pa.string()}	)
						_snake_case			:     str      							=      field(default="""Image"""  ,						init=_snake_case  ,						repr=_snake_case	)



						def __call__(	self	:							Union[str, Any]	):






							'''simple docstring'''



							return self.pa_type



						def     _snake_case	(	self	:							Optional[int]							,      lowerCamelCase	:							List[Any]	):






							'''simple docstring'''



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

							if isinstance(snake_case_							,      snake_case_	):
								__lowercase		       =			np.array(snake_case_	)

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

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



						def     _snake_case	(	self	:							str	):






							'''simple docstring'''



							from .features import Value

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



						def     _snake_case	(	self	:							Tuple							,      lowerCamelCase	:							int	):






							'''simple docstring'''



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



						def     _snake_case	(	self	:							Any							,      lowerCamelCase	:							List[Any]	):






							'''simple docstring'''



							@no_op_if_value_is_null
							def path_to_bytes(lowerCamelCase	:							Dict	):
								with xopen(snake_case_							,      "rb"	) as f:
									__lowercase		       =			f.read()
								return bytes_

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



def    snake_case_				(    ):







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



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			BytesIO()
	if image.format in list_image_compression_formats():
		__lowercase		       =			image.format
	else:
		__lowercase		       =			"PNG" if image.mode in ["1", "L", "LA", "RGB", "RGBA"] else "TIFF"
	image.save(_SCREAMING_SNAKE_CASE  ,	format=_SCREAMING_SNAKE_CASE   )
	return buffer.getvalue()



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):







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



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):







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

	__lowercase		       =			array.dtype
	__lowercase		       =			dtype.byteorder if dtype.byteorder != "=" else _NATIVE_BYTEORDER
	__lowercase		       =			dtype.kind
	__lowercase		       =			dtype.itemsize

	__lowercase		       =			None

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



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):







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

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








import copy
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 ..auto import CONFIG_MAPPING


snake_case__					:     int    		=   logging.get_logger(__name__)

snake_case__					:     Optional[int]    		=   {
    """microsoft/conditional-detr-resnet-50""": (
        """https://huggingface.co/microsoft/conditional-detr-resnet-50/resolve/main/config.json"""
    ),
}

class   _A   ( _lowercase	):


						'''simple docstring'''





						_snake_case			:     Dict      							=      """conditional_detr"""
						_snake_case			:     Union[str, Any]      							=      ["""past_key_values"""]
						_snake_case			:     Optional[int]      							=      {
						    """hidden_size""": """d_model""",
						    """num_attention_heads""": """encoder_attention_heads""",
						}



						def __init__(	self	:							Optional[Any]							,      lowerCamelCase	:							int=True							,      lowerCamelCase	:							Tuple=None							,      lowerCamelCase	:							Optional[int]=3							,      lowerCamelCase	:							Optional[int]=300							,      lowerCamelCase	:							List[Any]=6							,      lowerCamelCase	:							str=2_048							,      lowerCamelCase	:							Any=8							,      lowerCamelCase	:							List[str]=6							,      lowerCamelCase	:							Any=2_048							,      lowerCamelCase	:							List[Any]=8							,      lowerCamelCase	:							Optional[Any]=0.0							,      lowerCamelCase	:							List[str]=0.0							,      lowerCamelCase	:							List[Any]=True							,      lowerCamelCase	:							str="relu"							,      lowerCamelCase	:							int=256							,      lowerCamelCase	:							Dict=0.1							,      lowerCamelCase	:							Optional[Any]=0.0							,      lowerCamelCase	:							Dict=0.0							,      lowerCamelCase	:							Tuple=0.02							,      lowerCamelCase	:							int=1.0							,      lowerCamelCase	:							Tuple=False							,      lowerCamelCase	:							List[str]="sine"							,      lowerCamelCase	:							List[Any]="resnet50"							,      lowerCamelCase	:							Any=True							,      lowerCamelCase	:							Any=False							,      lowerCamelCase	:							List[Any]=2							,      lowerCamelCase	:							List[Any]=5							,      lowerCamelCase	:							str=2							,      lowerCamelCase	:							Dict=1							,      lowerCamelCase	:							List[str]=1							,      lowerCamelCase	:							Union[str, Any]=2							,      lowerCamelCase	:							Dict=5							,      lowerCamelCase	:							List[Any]=2							,      lowerCamelCase	:							Tuple=0.25							,      **lowerCamelCase	:							List[str]							,      ):






							'''simple docstring'''



							if backbone_config is not None and use_timm_backbone:
								raise ValueError("You can't specify both `backbone_config` and `use_timm_backbone`."	)

							if not use_timm_backbone:
								if backbone_config is None:
									logger.info("`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."	)
									__lowercase		       =			CONFIG_MAPPING["resnet"](out_features=["stage4"]	)
								elif isinstance(lowerCamelCase							,      lowerCamelCase	):
									__lowercase		       =			backbone_config.get("model_type"	)
									__lowercase		       =			CONFIG_MAPPING[backbone_model_type]
									__lowercase		       =			config_class.from_dict(lowerCamelCase	)

							__lowercase		       =			use_timm_backbone
							__lowercase		       =			backbone_config
							__lowercase		       =			num_channels
							__lowercase		       =			num_queries
							__lowercase		       =			d_model
							__lowercase		       =			encoder_ffn_dim
							__lowercase		       =			encoder_layers
							__lowercase		       =			encoder_attention_heads
							__lowercase		       =			decoder_ffn_dim
							__lowercase		       =			decoder_layers
							__lowercase		       =			decoder_attention_heads
							__lowercase		       =			dropout
							__lowercase		       =			attention_dropout
							__lowercase		       =			activation_dropout
							__lowercase		       =			activation_function
							__lowercase		       =			init_std
							__lowercase		       =			init_xavier_std
							__lowercase		       =			encoder_layerdrop
							__lowercase		       =			decoder_layerdrop
							__lowercase		       =			encoder_layers
							__lowercase		       =			auxiliary_loss
							__lowercase		       =			position_embedding_type
							__lowercase		       =			backbone
							__lowercase		       =			use_pretrained_backbone
							__lowercase		       =			dilation
							# Hungarian matcher
							__lowercase		       =			class_cost
							__lowercase		       =			bbox_cost
							__lowercase		       =			giou_cost
							# Loss coefficients
							__lowercase		       =			mask_loss_coefficient
							__lowercase		       =			dice_loss_coefficient
							__lowercase		       =			cls_loss_coefficient
							__lowercase		       =			bbox_loss_coefficient
							__lowercase		       =			giou_loss_coefficient
							__lowercase		       =			focal_alpha
							super().__init__(is_encoder_decoder=lowerCamelCase							,      **lowerCamelCase	)



						@property
						def     _snake_case	(	self	:							Tuple	):






							'''simple docstring'''



							return self.encoder_attention_heads



						@property
						def     _snake_case	(	self	:							str	):






							'''simple docstring'''



							return self.d_model



						def     _snake_case	(	self	:							int	):






							'''simple docstring'''



							__lowercase		       =			copy.deepcopy(self.__dict__	)
							if self.backbone_config is not None:
								__lowercase		       =			self.backbone_config.to_dict()
							__lowercase		       =			self.__class__.model_type
							return output

class   _A   ( _lowercase	):


						'''simple docstring'''





						_snake_case			:     Any      							=      version.parse("""1.11"""	)



						@property
						def     _snake_case	(	self	:							Tuple	):






							'''simple docstring'''



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



						@property
						def     _snake_case	(	self	:							Any	):






							'''simple docstring'''



							return 1e-5



						@property
						def     _snake_case	(	self	:							Optional[Any]	):






							'''simple docstring'''



							return 12



