






"""simple docstring"""





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

import datasets


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

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

UpperCamelCase_	:				str										= """
Compute IndicGLUE evaluation metric associated to each IndicGLUE dataset.
Args:
    predictions: list of predictions to score (as int64),
        except for 'cvit-mkb-clsr' where each prediction is a vector (of float32).
    references: list of ground truth labels corresponding to the predictions (as int64),
        except for 'cvit-mkb-clsr' where each reference is a vector (of float32).
Returns: depending on the IndicGLUE subset, one or several of:
    \"accuracy\": Accuracy
    \"f1\": F1 score
    \"precision\": Precision@10
Examples:

    >>> 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\"]
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}

    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'wiki-ner')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0, 'f1': 1.0}

    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'cvit-mkb-clsr')
    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]
    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]
    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'precision@10': 1.0}

"""



def     __lowercase					(    a :				Tuple       ,		a :				Dict ):
      return float((preds == labels).mean() )



def     __lowercase					(    a :				str       ,		a :				Tuple ):
      __snake_case      :    List[str]  			=simple_accuracy(a       ,		a )
      __snake_case      :    Any  			=float(fa_score(y_true=a       ,		y_pred=a ) )
      return {
          "accuracy": acc,
          "f1": fa,
      }



def     __lowercase					(    a :				Optional[Any]       ,		a :				Any ):
      __snake_case      :    str  			=np.array(a )
      __snake_case      :    Optional[int]  			=np.array(a )
      __snake_case      :    Dict  			=en_sentvecs.shape[0]

      # mean centering
      __snake_case      :    List[Any]  			=en_sentvecs - np.mean(a       ,		axis=0 )
      __snake_case      :    Dict  			=in_sentvecs - np.mean(a       ,		axis=0 )

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


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


      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            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 _UpperCamelCase						(    self				:	int							,   a				:	Union[str, Any]							,   a				:	Any						):





            """simple docstring"""







            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

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

UpperCamelCase_	:				Tuple										= {"""UserAgent""": UserAgent().random}



def     __lowercase					(    a :				str )					->					dict:
      __snake_case      :    Union[str, Any]  			=script.contents[0]
      __snake_case      :    List[str]  			=json.loads(data[data.find('''{"config"''' ) : -1] )
      return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]


class      _lowercase :


      def __init__(    self				:	int							,   a				:	Dict						):





            """simple docstring"""







            __snake_case      :    Dict  			=f'''https://www.instagram.com/{username}/'''
            __snake_case      :    str  			=self.get_json()


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





            """simple docstring"""







            __snake_case      :    List[str]  			=requests.get(self.url							,   headers=a						).text
            __snake_case      :    int  			=BeautifulSoup(a							,   '''html.parser'''						).find_all('''script'''						)
            try:
                  return extract_user_profile(scripts[4]						)
            except (json.decoder.JSONDecodeError, KeyError):
                  return extract_user_profile(scripts[3]						)


      def __repr__(    self				:	int						):





            """simple docstring"""







            return f'''{self.__class__.__name__}(\'{self.username}\')'''


      def __str__(    self				:	Any						):





            """simple docstring"""







            return f'''{self.fullname} ({self.username}) is {self.biography}'''


      @property
      def _UpperCamelCase						(    self				:	Union[str, Any]						):





            """simple docstring"""







            return self.user_data["username"]


      @property
      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            return self.user_data["full_name"]


      @property
      def _UpperCamelCase						(    self				:	List[Any]						):





            """simple docstring"""







            return self.user_data["biography"]


      @property
      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            return self.user_data["business_email"]


      @property
      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            return self.user_data["external_url"]


      @property
      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            return self.user_data["edge_followed_by"]["count"]


      @property
      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            return self.user_data["edge_follow"]["count"]


      @property
      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            return self.user_data["edge_owner_to_timeline_media"]["count"]


      @property
      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            return self.user_data["profile_pic_url_hd"]


      @property
      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            return self.user_data["is_verified"]







      @property
      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            return self.user_data["is_private"]



def     __lowercase					(    a :				str = "github" )					->					None:
      import os

      if os.environ.get('''CI''' ):
            return  # test failing on GitHub Actions
      __snake_case      :    Union[str, Any]  			=InstagramUser(a )
      assert instagram_user.user_data
      assert isinstance(instagram_user.user_data       ,		a )
      assert instagram_user.username == username
      if username != "github":
            return
      assert instagram_user.fullname == "GitHub"
      assert instagram_user.biography == "Built for developers."
      assert instagram_user.number_of_posts > 150
      assert instagram_user.number_of_followers > 120_000
      assert instagram_user.number_of_followings > 15
      assert instagram_user.email == "support@github.com"
      assert instagram_user.website == "https://github.com/readme"
      assert instagram_user.profile_picture_url.startswith('''https://instagram.''' )
      assert instagram_user.is_verified is True
      assert instagram_user.is_private is False


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    UpperCamelCase_	:				Optional[int]										= InstagramUser("""github""")
    print(instagram_user)
    print(F'''{instagram_user.number_of_posts = }''')
    print(F'''{instagram_user.number_of_followers = }''')
    print(F'''{instagram_user.number_of_followings = }''')
    print(F'''{instagram_user.email = }''')
    print(F'''{instagram_user.website = }''')
    print(F'''{instagram_user.profile_picture_url = }''')
    print(F'''{instagram_user.is_verified = }''')
    print(F'''{instagram_user.is_private = }''')


