"""simple docstring"""



import numpy as np
from scipy.spatial.distance import cdist
from sklearn.metrics import fa_score

import datasets


__lowercase		:		int														=							"\\n    @inproceedings{kakwani2020indicnlpsuite,\n    title={{IndicNLPSuite: Monolingual Corpora, Evaluation Benchmarks and Pre-trained Multilingual Language Models for Indian Languages}},\n    author={Divyanshu Kakwani and Anoop Kunchukuttan and Satish Golla and Gokul N.C. and Avik Bhattacharyya and Mitesh M. Khapra and Pratyush Kumar},\n    year={2020},\n    booktitle={Findings of EMNLP},\n}\n"

__lowercase		:		List[Any]														=							"\\n    IndicGLUE is a natural language understanding benchmark for Indian languages. It contains a wide\n    variety of tasks and covers 11 major Indian languages - as, bn, gu, hi, kn, ml, mr, or, pa, ta, te.\n"

__lowercase		:		Optional[Any]														=							"\nCompute IndicGLUE evaluation metric associated to each IndicGLUE dataset.\nArgs:\n    predictions: list of predictions to score (as int64),\n        except for 'cvit-mkb-clsr' where each prediction is a vector (of float32).\n    references: list of ground truth labels corresponding to the predictions (as int64),\n        except for 'cvit-mkb-clsr' where each reference is a vector (of float32).\nReturns: depending on the IndicGLUE subset, one or several of:\n    \"accuracy\": Accuracy\n    \"f1\": F1 score\n    \"precision\": Precision@10\nExamples:\n\n    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'wnli')  # 'wnli' or any of [\"copa\", \"sna\", \"csqa\", \"wstp\", \"inltkh\", \"bbca\", \"iitp-mr\", \"iitp-pr\", \"actsa-sc\", \"md\"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'wiki-ner')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0, 'f1': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'cvit-mkb-clsr')\n    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'precision@10': 1.0}\n\n"





def    SCREAMING_SNAKE_CASE       (     snake_case,      snake_case):
     return float((preds == labels).mean())





def    SCREAMING_SNAKE_CASE       (     snake_case,      snake_case):
     __snake_case				=							simple_accuracy(snake_case,      snake_case)
     __snake_case				=							float(fa_score(y_true=snake_case,      y_pred=snake_case))
     return {
         "accuracy": acc,
         "f1": fa,
     }





def    SCREAMING_SNAKE_CASE       (     snake_case,      snake_case):
     __snake_case				=							np.array(snake_case)
     __snake_case				=							np.array(snake_case)
     __snake_case				=							en_sentvecs.shape[0]

     # mean centering
     __snake_case				=							en_sentvecs - np.mean(snake_case,      axis=0)
     __snake_case				=							in_sentvecs - np.mean(snake_case,      axis=0)

     __snake_case				=							cdist(snake_case,      snake_case,      '''cosine''')
     __snake_case				=							np.array(range(snake_case))
     __snake_case				=							sim.argsort(axis=1)[:, :10]
     __snake_case				=							np.any(preds == actual[:, None],      axis=1)
     return float(matches.mean())




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




    """simple docstring"""




    def  lowercase					(		self							:     str    )    ->       List[str]:
         if self.config_name not in [
             "wnli",
             "copa",
             "sna",
             "csqa",
             "wstp",
             "inltkh",
             "bbca",
             "cvit-mkb-clsr",
             "iitp-mr",
             "iitp-pr",
             "actsa-sc",
             "md",
             "wiki-ner",
         ]:
              raise KeyError(
                  '''You should supply a configuration name selected in '''
                  '''["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", '''
                  '''"cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", '''
                  '''"wiki-ner"]'''    )
         return datasets.MetricInfo(
             description=_DESCRIPTION	,      citation=_CITATION	,      inputs_description=_KWARGS_DESCRIPTION	,      features=datasets.Features(
                 {
                     '''predictions''': datasets.Value('''int64'''    )
                     if self.config_name != '''cvit-mkb-clsr'''
                     else datasets.Sequence(datasets.Value('''float32'''    )    ),
                     '''references''': datasets.Value('''int64'''    )
                     if self.config_name != '''cvit-mkb-clsr'''
                     else datasets.Sequence(datasets.Value('''float32'''    )    ),
                 }    )	,      codebase_urls=[]	,      reference_urls=[]	,      format='''numpy''' if self.config_name != '''cvit-mkb-clsr''' else None	,      )







    def  lowercase					(		self							:     Optional[int]	,      A_							:     Optional[Any]	,      A_							:     Optional[int]    )    ->       List[Any]:
         if self.config_name == "cvit-mkb-clsr":
              return {"precision@10": precision_at_aa(A_	,      A_    )}
         elif self.config_name in ["wiki-ner"]:
              return acc_and_fa(A_	,      A_    )
         elif self.config_name in [
             "wnli",
             "copa",
             "sna",
             "csqa",
             "wstp",
             "inltkh",
             "bbca",
             "iitp-mr",
             "iitp-pr",
             "actsa-sc",
             "md",
         ]:
              return {"accuracy": simple_accuracy(A_	,      A_    )}
         else:
              raise KeyError(
                  '''You should supply a configuration name selected in '''
                  '''["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", '''
                  '''"cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", '''
                  '''"wiki-ner"]'''    )
"""simple docstring"""



from __future__ import annotations

from collections.abc import Iterator
from typing import Any



class      _A	:




    """simple docstring"""




    def __init__(		self							:     Tuple	,      A_							:     Any    )    ->       Union[str, Any]:
         __snake_case				=							data
         __snake_case				=							None






class      _A	:




    """simple docstring"""




    def __init__(		self							:     Union[str, Any]    )    ->       List[Any]:
         __snake_case				=							None
         __snake_case				=							None
    def __iter__(		self							:     Optional[Any]    )    ->       Iterator[Any]:
         __snake_case				=							self.head
         while self.head:
              yield node.data
              __snake_case				=							node.next
              if node == self.head:
                   break
    def __len__(		self							:     List[Any]    )    ->       int:
         return sum(1 for _ in self    )
    def __repr__(		self							:     Optional[int]    )    ->       Union[str, Any]:
         return "->".join(str(A_    ) for item in iter(self    )    )
    def  lowercase					(		self							:     int	,      A_							:     Any    )    ->       None:
         self.insert_nth(len(self    )	,      A_    )
    def  lowercase					(		self							:     List[str]	,      A_							:     Any    )    ->       None:
         self.insert_nth(0	,      A_    )
    def  lowercase					(		self							:     List[Any]	,      A_							:     int	,      A_							:     Any    )    ->       None:
         if index < 0 or index > len(self    ):
              raise IndexError('''list index out of range.'''    )
         __snake_case				=							Node(A_    )
         if self.head is None:
              __snake_case				=							new_node  # first node points itself
              __snake_case				=							__snake_case				=							new_node
         elif index == 0:  # insert at head
              __snake_case				=							self.head
              __snake_case				=							__snake_case				=							new_node
         else:
              __snake_case				=							self.head
              for _ in range(index - 1    ):
                   __snake_case				=							temp.next
              __snake_case				=							temp.next
              __snake_case				=							new_node
              if index == len(self    ) - 1:  # insert at tail
                   __snake_case				=							new_node
    def  lowercase					(		self							:     int    )    ->       str:
         return self.delete_nth(0    )
    def  lowercase					(		self							:     List[Any]    )    ->       Any:
         return self.delete_nth(len(self    ) - 1    )
    def  lowercase					(		self							:     List[str]	,      A_							:     int = 0    )    ->       Any:
         if not 0 <= index < len(self    ):
              raise IndexError('''list index out of range.'''    )
         __snake_case				=							self.head
         if self.head == self.tail:  # just one node
              __snake_case				=							__snake_case				=							None
         elif index == 0:  # delete head node
              __snake_case				=							self.tail.next.next
              __snake_case				=							self.head.next
         else:
              __snake_case				=							self.head
              for _ in range(index - 1    ):
                   __snake_case				=							temp.next
              __snake_case				=							temp.next
              __snake_case				=							temp.next.next
              if index == len(self    ) - 1:  # delete at tail
                   __snake_case				=							temp
         return delete_node.data







    def  lowercase					(		self							:     Dict    )    ->       bool:
         return len(self    ) == 0






def    SCREAMING_SNAKE_CASE       (     ):
     __snake_case				=							CircularLinkedList()
     assert len(snake_case) == 0
     assert circular_linked_list.is_empty() is True
     assert str(snake_case) == ""

     try:
          circular_linked_list.delete_front()
          raise AssertionError  # This should not happen
     except IndexError:
          assert True  # This should happen

     try:
          circular_linked_list.delete_tail()
          raise AssertionError  # This should not happen
     except IndexError:
          assert True  # This should happen

     try:
          circular_linked_list.delete_nth(-1)
          raise AssertionError
     except IndexError:
          assert True

     try:
          circular_linked_list.delete_nth(0)
          raise AssertionError
     except IndexError:
          assert True

     assert circular_linked_list.is_empty() is True
     for i in range(5):
          assert len(snake_case) == i
          circular_linked_list.insert_nth(snake_case,      i + 1)
     assert str(snake_case) == "->".join(str(snake_case) for i in range(1,      6))

     circular_linked_list.insert_tail(6)
     assert str(snake_case) == "->".join(str(snake_case) for i in range(1,      7))
     circular_linked_list.insert_head(0)
     assert str(snake_case) == "->".join(str(snake_case) for i in range(0,      7))

     assert circular_linked_list.delete_front() == 0
     assert circular_linked_list.delete_tail() == 6
     assert str(snake_case) == "->".join(str(snake_case) for i in range(1,      6))
     assert circular_linked_list.delete_nth(2) == 3

     circular_linked_list.insert_nth(2,      3)
     assert str(snake_case) == "->".join(str(snake_case) for i in range(1,      6))

     assert circular_linked_list.is_empty() is False


if __name__ == "__main__":
       import doctest

       doctest.testmod()