





from scipy.stats import pearsonr

import datasets


_lowerCAmelCase							:					Optional[int]		    =		'''
Pearson correlation coefficient and p-value for testing non-correlation.
The Pearson correlation coefficient measures the linear relationship between two datasets. The calculation of the p-value relies on the assumption that each dataset is normally distributed. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact linear relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases.
The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets.
'''


_lowerCAmelCase							:					Tuple		    =		'''
Args:
    predictions (`list` of `int`): Predicted class labels, as returned by a model.
    references (`list` of `int`): Ground truth labels.
    return_pvalue (`boolean`): If `True`, returns the p-value, along with the correlation coefficient. If `False`, returns only the correlation coefficient. Defaults to `False`.

Returns:
    pearsonr (`float`): Pearson correlation coefficient. Minimum possible value is -1. Maximum possible value is 1. Values of 1 and -1 indicate exact linear positive and negative relationships, respectively. A value of 0 implies no correlation.
    p-value (`float`): P-value, which roughly indicates the probability of an The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate higher probabilities.

Examples:

    Example 1-A simple example using only predictions and references.
        >>> pearsonr_metric = datasets.load_metric("pearsonr")
        >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5])
        >>> print(round(results[\'pearsonr\'], 2))
        -0.74

    Example 2-The same as Example 1, but that also returns the `p-value`.
        >>> pearsonr_metric = datasets.load_metric("pearsonr")
        >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5], return_pvalue=True)
        >>> print(sorted(list(results.keys())))
        [\'p-value\', \'pearsonr\']
        >>> print(round(results[\'pearsonr\'], 2))
        -0.74
        >>> print(round(results[\'p-value\'], 2))
        0.15
'''


_lowerCAmelCase							:					List[Any]		    =		'''
@article{2020SciPy-NMeth,
author  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and
      Haberland, Matt and Reddy, Tyler and Cournapeau, David and
      Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and
      Bright, Jonathan and {van der Walt}, St{\'e}fan J. and
      Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and
      Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and
      Kern, Robert and Larson, Eric and Carey, C J and
      Polat, Ilhan and Feng, Yu and Moore, Eric W. and
      {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and
      Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and
      Harris, Charles R. and Archibald, Anne M. and
      Ribeiro, Antonio H. and Pedregosa, Fabian and
      {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},
title   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific
      Computing in Python}},
journal = {Nature Methods},
year    = {2020},
volume  = {17},
pages   = {261--272},
adsurl  = {https://rdcu.be/b08Wh},
doi = {10.1038/s41592-019-0686-2},
}
'''


@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION			, _KWARGS_DESCRIPTION							)
class     __magic_name__     (							datasets.Metric							):





     """simple docstring"""



     def   SCREAMING_SNAKE_CASE						(							self				:List[str]     ):





        '''simple docstring'''




        return datasets.MetricInfo(
            description=_DESCRIPTION	,					citation=_CITATION	,					inputs_description=_KWARGS_DESCRIPTION	,					features=datasets.Features(
                {
                    "predictions": datasets.Value("float"     ),
                    "references": datasets.Value("float"     ),
                }     )	,					reference_urls=["https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html"]	,					)





     def   SCREAMING_SNAKE_CASE						(							self				:Dict	,					snake_case				:Optional[Any]	,					snake_case				:List[str]	,					snake_case				:Union[str, Any]=False     ):





        '''simple docstring'''




        if return_pvalue:
           A_    : Optional[Any]								=	pearsonr(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )
           return {"pearsonr": results[0], "p-value": results[1]}
        else:
           return {"pearsonr": float(pearsonr(SCREAMING_SNAKE_CASE_	,					SCREAMING_SNAKE_CASE_     )[0]     )}





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


__UpperCAmelCase          =       None
__UpperCAmelCase          =       '''<''' 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
__UpperCAmelCase          =       [
    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_		:
       UpperCAmelCase__				:					bool        =  True
       UpperCAmelCase__				:					Optional[str]        =  None
       # Automatically constructed
       UpperCAmelCase__				:					ClassVar[str]        =  "PIL.Image.Image"
       UpperCAmelCase__				:					ClassVar[Any]        =  pa.struct({"bytes": pa.binary(), "path": pa.string()}							)
       UpperCAmelCase__				:					str        =  field(default="Image"       ,    init=a__       ,    repr=a__							)
       def __call__(			self       )     ->		Any:
          return self.pa_type
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_       )     ->		dict:
          if config.PIL_AVAILABLE:
             import PIL.Image
          else:
             raise ImportError('To support encoding images, please install \'Pillow\'.'       )

          if isinstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       ):
             UpperCamelCase    :  Optional[int]							=	np.array(SCREAMING_SNAKE_CASE_       )

          if isinstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       ):
             return {"path": value, "bytes": None}
          elif isinstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       ):
             return {"path": None, "bytes": value}
          elif isinstance(SCREAMING_SNAKE_CASE_,			np.ndarray       ):
             # convert the image array to PNG/TIFF bytes
             return encode_np_array(SCREAMING_SNAKE_CASE_       )
          elif isinstance(SCREAMING_SNAKE_CASE_,			PIL.Image.Image       ):
             # convert the PIL image to bytes (default format is PNG/TIFF)
             return encode_pil_image(SCREAMING_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,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_=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:
             UpperCamelCase    :  Any							=	{}

          UpperCamelCase	,     UpperCamelCase    :  Union[str, 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(SCREAMING_SNAKE_CASE_       ):
                   UpperCamelCase    :  int							=	PIL.Image.open(SCREAMING_SNAKE_CASE_       )
                else:
                   UpperCamelCase    :  int							=	path.split('::'       )[-1]
                   try:
                      UpperCamelCase    :  Optional[Any]							=	string_to_dict(SCREAMING_SNAKE_CASE_,			config.HUB_DATASETS_URL       )['repo_id']
                      UpperCamelCase    :  str							=	token_per_repo_id.get(SCREAMING_SNAKE_CASE_       )
                   except ValueError:
                      UpperCamelCase    :  Tuple							=	None
                   with xopen(SCREAMING_SNAKE_CASE_,			'rb',			use_auth_token=SCREAMING_SNAKE_CASE_       ) as f:
                      UpperCamelCase    :  Optional[int]							=	BytesIO(f.read()       )
                   UpperCamelCase    :  int							=	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 					snake_case_       (			self       )     ->		Union["FeatureType", Dict[str, "FeatureType"]]:
          from .features import Value

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






       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_       )     ->		pa.StructArray:

          @no_op_if_value_is_null
          def path_to_bytes(SCREAMING_SNAKE_CASE_       ):
             with xopen(SCREAMING_SNAKE_CASE_,			'rb'       ) as f:
                UpperCamelCase    :  Optional[int]							=	f.read()
             return bytes_

          UpperCamelCase    :  Union[str, 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(SCREAMING_SNAKE_CASE_       ) if path is not None else None for path in storage.field('path'       ).to_pylist()],			type=pa.string(),			)
          UpperCamelCase    :  int							=	pa.StructArray.from_arrays([bytes_array, path_array],			['bytes', 'path'],			mask=bytes_array.is_null()       )
          return array_cast(SCREAMING_SNAKE_CASE_,			self.pa_type       )






def 		UpperCamelCase	(   )	->     List[str]:
   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 		UpperCamelCase	(   snake_case__       :    "PIL.Image.Image"	)	->     bytes:
   UpperCamelCase    :  Any							=	BytesIO()
   if image.format in list_image_compression_formats():
      UpperCamelCase    :  Tuple							=	image.format
   else:
      UpperCamelCase    :  List[str]							=	'PNG' if image.mode in ['1', 'L', 'LA', 'RGB', 'RGBA'] else 'TIFF'
   image.save(snake_case__       ,     format=snake_case__	)
   return buffer.getvalue()
def 		UpperCamelCase	(   snake_case__       :    "PIL.Image.Image"	)	->     dict:
   if hasattr(snake_case__       ,     'filename'	) and image.filename != "":
      return {"path": image.filename, "bytes": None}
   else:
      return {"path": None, "bytes": image_to_bytes(snake_case__	)}
def 		UpperCamelCase	(   snake_case__       :    np.ndarray	)	->     dict:
   if config.PIL_AVAILABLE:
      import PIL.Image
   else:
      raise ImportError('To support encoding images, please install \'Pillow\'.'	)

   UpperCamelCase    :  Union[str, Any]							=	array.dtype
   UpperCamelCase    :  List[Any]							=	dtype.byteorder if dtype.byteorder != '=' else _NATIVE_BYTEORDER
   UpperCamelCase    :  Optional[Any]							=	dtype.kind
   UpperCamelCase    :  Any							=	dtype.itemsize

   UpperCamelCase    :  int							=	None

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


def 		UpperCamelCase	(   snake_case__       :    Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]]	)	->     List[dict]:
   if config.PIL_AVAILABLE:
      import PIL.Image
   else:
      raise ImportError('To support encoding images, please install \'Pillow\'.'	)

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



