


import logging
import os
import threading
import time


try:
    import warnings
except ImportError:
    a_ :Optional[int]  							=			None

try:
    import msvcrt
except ImportError:
    a_ :Optional[int]  							=			None

try:
    import fcntl
except ImportError:
    a_ :Optional[Any]  							=			None


# Backward compatibility
# ------------------------------------------------
try:
    TimeoutError
except NameError:
    a_ :List[str]  							=			OSError


# Data
# ------------------------------------------------
a_ :Any  							=			[
    '''Timeout''',
    '''BaseFileLock''',
    '''WindowsFileLock''',
    '''UnixFileLock''',
    '''SoftFileLock''',
    '''FileLock''',
]

a_ :Any  							=			'''3.0.12'''


a_ :Dict  							=			None




def    a   (							)	-> int:




      '''simple docstring'''

      global _logger
      SCREAMING_SNAKE_CASE__       :  Any						     =		_logger or logging.getLogger(__name__							)
      return _logger

class 							lowercase  (						a_			):







     def __init__(						self :						Tuple   ,   _lowercase :						List[Any]      ):
           SCREAMING_SNAKE_CASE__       :  List[Any]						     =		lock_file
           return None







     def __str__(						self :						Union[str, Any]      ):
           SCREAMING_SNAKE_CASE__       :  Dict						     =		f"""The file lock '{self.lock_file}' could not be acquired."""
           return temp




class 							lowercase  :







     def __init__(						self :						Optional[Any]   ,   _lowercase :						Any      ):
           SCREAMING_SNAKE_CASE__       :  Optional[Any]						     =		lock
           return None







     def __enter__(						self :						str      ):
           return self.lock







     def __exit__(						self :						Optional[int]   ,   _lowercase :						Union[str, Any]   ,   _lowercase :						List[str]   ,   _lowercase :						Optional[int]      ):
           self.lock.release()
           return None




class 							lowercase  :







     def __init__(						self :						List[str]   ,   _lowercase :						Union[str, Any]   ,   _lowercase :						List[Any]=-1   ,   _lowercase :						Any=None      ):
           SCREAMING_SNAKE_CASE__       :  Optional[Any]						     =		max_filename_length if max_filename_length is not None else 2_55
           # Hash the filename if it's too long
           SCREAMING_SNAKE_CASE__       :  int						     =		self.hash_filename_if_too_long(__UpperCamelCase   ,   __UpperCamelCase      )
           # The path to the lock file.
           SCREAMING_SNAKE_CASE__       :  List[str]						     =		lock_file

           # The file descriptor for the *_lock_file* as it is returned by the
           # os.open() function.
           # This file lock is only NOT None, if the object currently holds the
           # lock.
           SCREAMING_SNAKE_CASE__       :  Dict						     =		None

           # The default timeout value.
           SCREAMING_SNAKE_CASE__       :  Optional[int]						     =		timeout

           # We use this lock primarily for the lock counter.
           SCREAMING_SNAKE_CASE__       :  Optional[int]						     =		threading.Lock()

           # The lock counter is used for implementing the nested locking
           # mechanism. Whenever the lock is acquired, the counter is increased and
           # the lock is only released, when this value is 0 again.
           SCREAMING_SNAKE_CASE__       :  str						     =		0
           return None







     @property
     def 							lowercase__       (						self :						List[Any]      ):
           return self._lock_file







     @property
     def 							lowercase__       (						self :						Optional[int]      ):
           return self._timeout







     @timeout.setter
     def 							lowercase__       (						self :						Optional[Any]   ,   _lowercase :						int      ):
           SCREAMING_SNAKE_CASE__       :  Optional[int]						     =		float(__UpperCamelCase      )
           return None







     def 							lowercase__       (						self :						Dict      ):
           raise NotImplementedError()







     def 							lowercase__       (						self :						Dict      ):
           raise NotImplementedError()







     @property
     def 							lowercase__       (						self :						Any      ):
           return self._lock_file_fd is not None







     def 							lowercase__       (						self :						int   ,   _lowercase :						Tuple=None   ,   _lowercase :						Optional[int]=0.05      ):
           # Use the default timeout, if no timeout is provided.
           if timeout is None:
                 SCREAMING_SNAKE_CASE__       :  Dict						     =		self.timeout

           # Increment the number right at the beginning.
           # We can still undo it, if something fails.
           with self._thread_lock:
                 self._lock_counter += 1

           SCREAMING_SNAKE_CASE__       :  Optional[Any]						     =		id(self      )
           SCREAMING_SNAKE_CASE__       :  int						     =		self._lock_file
           SCREAMING_SNAKE_CASE__       :  Union[str, Any]						     =		time.time()
           try:
                 while True:
                       with self._thread_lock:
                             if not self.is_locked:
                                   logger().debug(f"""Attempting to acquire lock {lock_id} on {lock_filename}"""      )
                                   self._acquire()

                       if self.is_locked:
                             logger().debug(f"""Lock {lock_id} acquired on {lock_filename}"""      )
                             break
                       elif timeout >= 0 and time.time() - start_time > timeout:
                             logger().debug(f"""Timeout on acquiring lock {lock_id} on {lock_filename}"""      )
                             raise Timeout(self._lock_file      )
                       else:
                             logger().debug(
                                 f"""Lock {lock_id} not acquired on {lock_filename}, waiting {poll_intervall} seconds ..."""      )
                             time.sleep(__UpperCamelCase      )
           except:  # noqa
                 # Something did go wrong, so decrement the counter.
                 with self._thread_lock:
                       SCREAMING_SNAKE_CASE__       :  Any						     =		max(0   ,   self._lock_counter - 1      )

                 raise
           return _Acquire_ReturnProxy(lock=self      )







     def 							lowercase__       (						self :						str   ,   _lowercase :						Tuple=False      ):
           with self._thread_lock:
                 if self.is_locked:
                       self._lock_counter -= 1

                       if self._lock_counter == 0 or force:
                             SCREAMING_SNAKE_CASE__       :  int						     =		id(self      )
                             SCREAMING_SNAKE_CASE__       :  int						     =		self._lock_file

                             logger().debug(f"""Attempting to release lock {lock_id} on {lock_filename}"""      )
                             self._release()
                             SCREAMING_SNAKE_CASE__       :  Optional[Any]						     =		0
                             logger().debug(f"""Lock {lock_id} released on {lock_filename}"""      )

           return None







     def __enter__(						self :						str      ):
           self.acquire()
           return self







     def __exit__(						self :						Dict   ,   _lowercase :						Optional[int]   ,   _lowercase :						Dict   ,   _lowercase :						Union[str, Any]      ):
           self.release()
           return None







     def __del__(						self :						Optional[int]      ):
           self.release(force=__UpperCamelCase      )
           return None







     def 							lowercase__       (						self :						List[str]   ,   _lowercase :						str   ,   _lowercase :						List[Any]      ):
           SCREAMING_SNAKE_CASE__       :  int						     =		os.path.basename(__UpperCamelCase      )
           if len(__UpperCamelCase      ) > max_length and max_length > 0:
                 SCREAMING_SNAKE_CASE__       :  int						     =		os.path.dirname(__UpperCamelCase      )
                 SCREAMING_SNAKE_CASE__       :  Dict						     =		str(hash(__UpperCamelCase      )      )
                 SCREAMING_SNAKE_CASE__       :  Any						     =		filename[: max_length - len(__UpperCamelCase      ) - 8] + '''...''' + hashed_filename + '''.lock'''
                 return os.path.join(__UpperCamelCase   ,   __UpperCamelCase      )
           else:
                 return path




class 							lowercase  (						a_			):







     def __init__(						self :						Optional[int]   ,   _lowercase :						List[Any]   ,   _lowercase :						int=-1   ,   _lowercase :						str=None      ):
           from .file_utils import relative_to_absolute_path

           super().__init__(__UpperCamelCase   ,   timeout=__UpperCamelCase   ,   max_filename_length=__UpperCamelCase      )
           SCREAMING_SNAKE_CASE__       :  List[str]						     =		'''\\\\?\\''' + relative_to_absolute_path(self.lock_file      )







     def 							lowercase__       (						self :						List[Any]      ):
           SCREAMING_SNAKE_CASE__       :  Optional[int]						     =		os.O_RDWR | os.O_CREAT | os.O_TRUNC

           try:
                 SCREAMING_SNAKE_CASE__       :  List[Any]						     =		os.open(self._lock_file   ,   __UpperCamelCase      )
           except OSError:
                 pass
           else:
                 try:
                       msvcrt.locking(__UpperCamelCase   ,   msvcrt.LK_NBLCK   ,   1      )
                 except OSError:
                       os.close(__UpperCamelCase      )
                 else:
                       SCREAMING_SNAKE_CASE__       :  Any						     =		fd
           return None







     def 							lowercase__       (						self :						str      ):
           SCREAMING_SNAKE_CASE__       :  List[Any]						     =		self._lock_file_fd
           SCREAMING_SNAKE_CASE__       :  Tuple						     =		None
           msvcrt.locking(__UpperCamelCase   ,   msvcrt.LK_UNLCK   ,   1      )
           os.close(__UpperCamelCase      )

           try:
                 os.remove(self._lock_file      )
           # Probably another instance of the application
           # that acquired the file lock.
           except OSError:
                 pass
           return None




class 							lowercase  (						a_			):







     def __init__(						self :						Any   ,   _lowercase :						List[Any]   ,   _lowercase :						Union[str, Any]=-1   ,   _lowercase :						Dict=None      ):
           SCREAMING_SNAKE_CASE__       :  Dict						     =		os.statvfs(os.path.dirname(__UpperCamelCase      )      ).f_namemax
           super().__init__(__UpperCamelCase   ,   timeout=__UpperCamelCase   ,   max_filename_length=__UpperCamelCase      )







     def 							lowercase__       (						self :						Any      ):
           SCREAMING_SNAKE_CASE__       :  Optional[Any]						     =		os.O_RDWR | os.O_CREAT | os.O_TRUNC
           SCREAMING_SNAKE_CASE__       :  Tuple						     =		os.open(self._lock_file   ,   __UpperCamelCase      )

           try:
                 fcntl.flock(__UpperCamelCase   ,   fcntl.LOCK_EX | fcntl.LOCK_NB      )
           except OSError:
                 os.close(__UpperCamelCase      )
           else:
                 SCREAMING_SNAKE_CASE__       :  Union[str, Any]						     =		fd
           return None







     def 							lowercase__       (						self :						Any      ):
           # Do not remove the lockfile:
           #
           #   https://github.com/benediktschmitt/py-filelock/issues/31
           #   https://stackoverflow.com/questions/17708885/flock-removing-locked-file-without-race-condition
           SCREAMING_SNAKE_CASE__       :  List[str]						     =		self._lock_file_fd
           SCREAMING_SNAKE_CASE__       :  List[str]						     =		None
           fcntl.flock(__UpperCamelCase   ,   fcntl.LOCK_UN      )
           os.close(__UpperCamelCase      )
           return None




class 							lowercase  (						a_			):







     def 							lowercase__       (						self :						Any      ):
           SCREAMING_SNAKE_CASE__       :  Union[str, Any]						     =		os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_TRUNC
           try:
                 SCREAMING_SNAKE_CASE__       :  Dict						     =		os.open(self._lock_file   ,   __UpperCamelCase      )
           except OSError:
                 pass
           else:
                 SCREAMING_SNAKE_CASE__       :  int						     =		fd
           return None







     def 							lowercase__       (						self :						int      ):
           os.close(self._lock_file_fd      )
           SCREAMING_SNAKE_CASE__       :  Dict						     =		None

           try:
                 os.remove(self._lock_file      )
           # The file is already deleted and that's what we want.
           except OSError:
                 pass
           return None




a_ :str  							=			None

if msvcrt:
    a_ :List[Any]  							=			WindowsFileLock
elif fcntl:
    a_ :Tuple  							=			UnixFileLock
else:
    a_ :str  							=			SoftFileLock

    if warnings is not None:
        warnings.warn('only soft file lock is available')














from sklearn.metrics import fa_score

import datasets


lowerCamelCase      :       Union[str, Any]    =						'''
The F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:
F1 = 2 * (precision * recall) / (precision + recall)
'''


lowerCamelCase      :       Optional[Any]    =						'''
Args:
    predictions (`list` of `int`): Predicted labels.
    references (`list` of `int`): Ground truth labels.
    labels (`list` of `int`): The set of labels to include when `average` is not set to `\'binary\'`, and the order of the labels if `average` is `None`. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.
    pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.
    average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `\'binary\'`.

        - \'binary\': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.
        - \'micro\': Calculate metrics globally by counting the total true positives, false negatives and false positives.
        - \'macro\': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.
        - \'weighted\': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `\'macro\'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.
        - \'samples\': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).
    sample_weight (`list` of `float`): Sample weights Defaults to None.

Returns:
    f1 (`float` or `array` of `float`): F1 score or list of f1 scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher f1 scores are better.

Examples:

    Example 1-A simple binary example
        >>> f1_metric = datasets.load_metric("f1")
        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])
        >>> print(results)
        {\'f1\': 0.5}

    Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.
        >>> f1_metric = datasets.load_metric("f1")
        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)
        >>> print(round(results[\'f1\'], 2))
        0.67

    Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.
        >>> f1_metric = datasets.load_metric("f1")
        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])
        >>> print(round(results[\'f1\'], 2))
        0.35

    Example 4-A multiclass example, with different values for the `average` input.
        >>> predictions = [0, 2, 1, 0, 0, 1]
        >>> references = [0, 1, 2, 0, 1, 2]
        >>> results = f1_metric.compute(predictions=predictions, references=references, average="macro")
        >>> print(round(results[\'f1\'], 2))
        0.27
        >>> results = f1_metric.compute(predictions=predictions, references=references, average="micro")
        >>> print(round(results[\'f1\'], 2))
        0.33
        >>> results = f1_metric.compute(predictions=predictions, references=references, average="weighted")
        >>> print(round(results[\'f1\'], 2))
        0.27
        >>> results = f1_metric.compute(predictions=predictions, references=references, average=None)
        >>> print(results)
        {\'f1\': array([0.8, 0. , 0. ])}
'''


lowerCamelCase      :       Optional[Any]    =						'''
@article{scikit-learn,
    title={Scikit-learn: Machine Learning in {P}ython},
    author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
           and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
           and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
           Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
    journal={Journal of Machine Learning Research},
    volume={12},
    pages={2825--2830},
    year={2011}
}
'''



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


      def 			__UpperCAmelCase		(						self						)->						Tuple:
           return datasets.MetricInfo(
               description=_DESCRIPTION       ,    citation=_CITATION       ,    inputs_description=_KWARGS_DESCRIPTION       ,    features=datasets.Features(
                   {
                       "predictions": datasets.Sequence(datasets.Value("int32"						)						),
                       "references": datasets.Sequence(datasets.Value("int32"						)						),
                   }
                   if self.config_name == "multilabel"
                   else {
                       "predictions": datasets.Value("int32"						),
                       "references": datasets.Value("int32"						),
                   }						)       ,    reference_urls=["https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html"]       ,    )


      def 			__UpperCAmelCase		(						self       ,    __UpperCamelCase       ,    __UpperCamelCase       ,    __UpperCamelCase=None       ,    __UpperCamelCase=1       ,    __UpperCamelCase="binary"       ,    __UpperCamelCase=None						)->						Optional[int]:
           __lowerCAmelCase             =       fa_score(
               __UpperCamelCase       ,    __UpperCamelCase       ,    labels=__UpperCamelCase       ,    pos_label=__UpperCamelCase       ,    average=__UpperCamelCase       ,    sample_weight=__UpperCamelCase						)
           return {"f1": float(__UpperCamelCase						) if score.size == 1 else score}






