



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


__SCREAMING_SNAKE_CASE           =  None
__SCREAMING_SNAKE_CASE           =  """<""" 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
__SCREAMING_SNAKE_CASE           =  [
    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 	lowerCamelCase_    :






						'''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=_A						,repr=_A						)







						def __call__(	self      :			str )      ->				Union[str, Any]:
									return self.pa_type







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Tuple	,	__lowerCamelCase      :			Union[str, bytes, dict, np.ndarray, "PIL.Image.Image"] )      ->				dict:
									if config.PIL_AVAILABLE:
												import PIL.Image
									else:
												raise ImportError("To support encoding images, please install 'Pillow'." )

									if isinstance(__lowerCamelCase	,	__lowerCamelCase ):
												A							:					Tuple              =						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 			SCREAMING_SNAKE_CASE__		(	self      :			Any	,	__lowerCamelCase      :			dict	,	__lowerCamelCase      :			int=None )      ->				"PIL.Image.Image":
									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:
												A							:					List[Any]              =						{}

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







						def 			SCREAMING_SNAKE_CASE__		(	self      :			str )      ->				Union["FeatureType", Dict[str, "FeatureType"]]:
									from .features import Value

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







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







						def 			SCREAMING_SNAKE_CASE__		(	self      :			List[Any]	,	__lowerCamelCase      :			pa.StructArray )      ->				pa.StructArray:

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

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







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




def 	UpperCAmelCase   (						_lowerCamelCase    ):
			A							:					int              =						BytesIO()
			if image.format in list_image_compression_formats():
						A							:					str              =						image.format
			else:
						A							:					List[Any]              =						"PNG" if image.mode in ["1", "L", "LA", "RGB", "RGBA"] else "TIFF"
			image.save(_lowerCamelCase ,    format=_lowerCamelCase    )
			return buffer.getvalue()




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




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

			A							:					Tuple              =						array.dtype
			A							:					Union[str, Any]              =						dtype.byteorder if dtype.byteorder != "=" else _NATIVE_BYTEORDER
			A							:					Union[str, Any]              =						dtype.kind
			A							:					List[Any]              =						dtype.itemsize

			A							:					int              =						None

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






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

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










import time
import warnings
from abc import ABC
from copy import deepcopy
from typing import Optional

import torch

from ..utils import add_start_docstrings, logging


__SCREAMING_SNAKE_CASE           =  logging.get_logger(__name__)


__SCREAMING_SNAKE_CASE           =  r"""
    Args:
        input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
            Indices of input sequence tokens in the vocabulary.

            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
            [`PreTrainedTokenizer.__call__`] for details.

            [What are input IDs?](../glossary#input-ids)
        scores (`torch.FloatTensor` of shape `(batch_size, config.vocab_size)`):
            Prediction scores of a language modeling head. These can be scores for each vocabulary token before SoftMax
            or scores for each vocabulary token after SoftMax.
        kwargs (`Dict[str, Any]`, *optional*):
            Additional stopping criteria specific kwargs.

    Return:
        `bool`. `False` indicates we should continue, `True` indicates we should stop.

"""

class 	lowerCamelCase_    ( _A						):






						'''simple docstring'''







						@add_start_docstrings(__lowerCamelCase )
						def __call__(	self      :			Optional[int]	,	__lowerCamelCase      :			torch.LongTensor	,	__lowerCamelCase      :			torch.FloatTensor	,	**__lowerCamelCase      :			Optional[Any] )      ->				bool:
									raise NotImplementedError("StoppingCriteria needs to be subclassed" )







class 	lowerCamelCase_    ( _A						):






						'''simple docstring'''







						def __init__(	self      :			List[str]	,	__lowerCamelCase      :			int	,	__lowerCamelCase      :			Optional[int] = None )      ->				List[Any]:
									A							:					str              =						max_length
									A							:					Optional[int]              =						max_position_embeddings







						@add_start_docstrings(__lowerCamelCase )
						def __call__(	self      :			List[str]	,	__lowerCamelCase      :			torch.LongTensor	,	__lowerCamelCase      :			torch.FloatTensor	,	**__lowerCamelCase      :			Any )      ->				bool:
									A							:					List[Any]              =						input_ids.shape[-1]
									A							:					Any              =						cur_len >= self.max_length
									if self.max_position_embeddings is not None and not is_done and cur_len >= self.max_position_embeddings:
												logger.warning_once(
												    "This is a friendly reminder - the current text generation call will exceed the model's predefined "
												    F"""maximum length ({self.max_position_embeddings}). Depending on the model, you may observe """
												    "exceptions, performance degradation, or nothing at all." )
									return is_done







class 	lowerCamelCase_    ( _A						):






						'''simple docstring'''







						def __init__(	self      :			Optional[Any]	,	__lowerCamelCase      :			int	,	__lowerCamelCase      :			int )      ->				List[Any]:
									warnings.warn(
									    "The class `MaxNewTokensCriteria` is deprecated. "
									    F"""Please use `MaxLengthCriteria(max_length={start_length + max_new_tokens})` """
									    "with `max_length = start_length + max_new_tokens` instead."	,	__lowerCamelCase	,	)
									A							:					str              =						start_length
									A							:					Optional[Any]              =						max_new_tokens
									A							:					Dict              =						start_length + max_new_tokens







						@add_start_docstrings(__lowerCamelCase )
						def __call__(	self      :			int	,	__lowerCamelCase      :			torch.LongTensor	,	__lowerCamelCase      :			torch.FloatTensor	,	**__lowerCamelCase      :			Tuple )      ->				bool:
									return input_ids.shape[-1] >= self.max_length







class 	lowerCamelCase_    ( _A						):






						'''simple docstring'''







						def __init__(	self      :			Optional[int]	,	__lowerCamelCase      :			float	,	__lowerCamelCase      :			Optional[float] = None )      ->				List[Any]:
									A							:					str              =						max_time
									A							:					Dict              =						time.time() if initial_timestamp is None else initial_timestamp







						@add_start_docstrings(__lowerCamelCase )
						def __call__(	self      :			Any	,	__lowerCamelCase      :			torch.LongTensor	,	__lowerCamelCase      :			torch.FloatTensor	,	**__lowerCamelCase      :			Tuple )      ->				bool:
									return time.time() - self.initial_timestamp > self.max_time







class 	lowerCamelCase_    ( _A						):






						'''simple docstring'''







						@add_start_docstrings(__lowerCamelCase )
						def __call__(	self      :			Union[str, Any]	,	__lowerCamelCase      :			torch.LongTensor	,	__lowerCamelCase      :			torch.FloatTensor	,	**__lowerCamelCase      :			int )      ->				bool:
									return any(criteria(__lowerCamelCase	,	__lowerCamelCase ) for criteria in self )







						@property
						def 			SCREAMING_SNAKE_CASE__		(	self      :			List[str] )      ->				Optional[int]:
									for stopping_criterium in self:
												if isinstance(__lowerCamelCase	,	__lowerCamelCase ):
															return stopping_criterium.max_length
												elif isinstance(__lowerCamelCase	,	__lowerCamelCase ):
															return stopping_criterium.max_length
									return None







def 	UpperCAmelCase   (						_lowerCamelCase ,    _lowerCamelCase    ):
			A							:					Optional[int]              =						stopping_criteria.max_length
			A							:					Any              =						deepcopy(_lowerCamelCase    )
			if stopping_max_length is not None and stopping_max_length != max_length:
						warnings.warn("You set different `max_length` for stopping criteria and `max_length` parameter" ,    _lowerCamelCase    )
			elif stopping_max_length is None:
						new_stopping_criteria.append(MaxLengthCriteria(max_length=_lowerCamelCase    )    )
			return new_stopping_criteria