




'''simple docstring'''







import collections
import json
import math
import os
import re
import time
from fnmatch import fnmatch
from typing import Dict

import requests
from slack_sdk import WebClient


A     =WebClient(token=os.environ['CI_SLACK_BOT_TOKEN'])





def 						snake_case_							(_a	:							Tuple     ):
    UpperCAmelCase			       =		test_results.split(''' '''     )

    UpperCAmelCase			       =		0
    UpperCAmelCase			       =		0

    # When the output is short enough, the output is surrounded by = signs: "== OUTPUT =="
    # When it is too long, those signs are not present.
    UpperCAmelCase			       =		expressions[-2] if '''=''' in expressions[-1] else expressions[-1]

    for i, expression in enumerate(_a     ):
        if "failed" in expression:
            failed += int(expressions[i - 1]     )
        if "passed" in expression:
            success += int(expressions[i - 1]     )

    return failed, success, time_spent





def 						snake_case_							(_a	:							Optional[int]     ):
    UpperCAmelCase			       =		{}
    UpperCAmelCase			       =		None
    UpperCAmelCase			       =		False
    for line in failures_short_lines.split('''\n'''     ):
        if re.search(R'''_ \[doctest\]'''    ,   _a     ):
            UpperCAmelCase			       =		True
            UpperCAmelCase			       =		line.split(''' '''     )[2]
        elif in_error and not line.split(''' '''     )[0].isdigit():
            UpperCAmelCase			       =		line
            UpperCAmelCase			       =		False

    return failures


class 			_a  :
       def __init__(	self						:	Dict   ,				lowercase						:	str   ,				lowercase						:	Dict				):



           '''simple docstring'''

           UpperCAmelCase			       =		title

           UpperCAmelCase			       =		doc_test_results['''time_spent'''].split(''','''				)[0]
           UpperCAmelCase			       =		doc_test_results['''success''']
           UpperCAmelCase			       =		doc_test_results['''failures''']
           UpperCAmelCase			       =		self.n_success + self.n_failures

           # Failures and success of the modeling tests
           UpperCAmelCase			       =		doc_test_results
       @property
       def     A      (	self						:	Any				):



           '''simple docstring'''

           UpperCAmelCase			       =		[self._time_spent]
           UpperCAmelCase			       =		0

           for time in time_spent:
               UpperCAmelCase			       =		time.split(''':'''				)

               # Time can be formatted as xx:xx:xx, as .xx, or as x.xx if the time spent was less than a minute.
               if len(lowercase				) == 1:
                   UpperCAmelCase			       =		[0, 0, time_parts[0]]

               UpperCAmelCase       ,     UpperCAmelCase       ,     UpperCAmelCase			       =		int(time_parts[0]				), int(time_parts[1]				), float(time_parts[2]				)
               total_secs += hours * 3_600 + minutes * 60 + seconds

           UpperCAmelCase       ,     UpperCAmelCase       ,     UpperCAmelCase			       =		total_secs // 3_600, (total_secs % 3_600) // 60, total_secs % 60
           return f"{int(lowercase				)}h{int(lowercase				)}m{int(lowercase				)}s"
       @property
       def     A      (	self						:	int				):



           '''simple docstring'''

           return {"type": "header", "text": {"type": "plain_text", "text": self.title}}
       @property
       def     A      (	self						:	Union[str, Any]				):



           '''simple docstring'''

           return {
               "type": "section",
               "text": {
                   "type": "plain_text",
                   "text": f"🌞 There were no failures: all {self.n_tests} tests passed. The suite ran in {self.time}.",
                   "emoji": True,
               },
               "accessory": {
                   "type": "button",
                   "text": {"type": "plain_text", "text": "Check Action results", "emoji": True},
                   "url": f"https://github.com/huggingface/transformers/actions/runs/{os.environ['GITHUB_RUN_ID']}",
               },
           }
       @property
       def     A      (	self						:	int				):



           '''simple docstring'''

           return {
               "type": "section",
               "text": {
                   "type": "plain_text",
                   "text": (
                       f"There were {self.n_failures} failures, out of {self.n_tests} tests.\nThe suite ran in"
                       f" {self.time}."
                   ),
                   "emoji": True,
               },
               "accessory": {
                   "type": "button",
                   "text": {"type": "plain_text", "text": "Check Action results", "emoji": True},
                   "url": f"https://github.com/huggingface/transformers/actions/runs/{os.environ['GITHUB_RUN_ID']}",
               },
           }
       @property
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           UpperCAmelCase			       =		40
           UpperCAmelCase			       =		{k: v['''failed'''] for k, v in doc_test_results.items() if isinstance(lowercase   ,				lowercase				)}

           UpperCAmelCase			       =		''''''
           for category, failures in category_failures.items():
               if len(lowercase				) == 0:
                   continue

               if report != "":
                   report += "\n\n"

               report += f"*{category} failures*:".ljust(line_length // 2				).rjust(line_length // 2				) + "\n"
               report += "`"
               report += "`\n`".join(lowercase				)
               report += "`"

           return {
               "type": "section",
               "text": {
                   "type": "mrkdwn",
                   "text": f"The following examples had failures:\n\n\n{report}\n",
               },
           }
       @property
       def     A      (	self						:	Any				):



           '''simple docstring'''

           UpperCAmelCase			       =		[self.header]

           if self.n_failures > 0:
               blocks.append(self.failures				)

           if self.n_failures > 0:
               blocks.extend([self.category_failures]				)

           if self.n_failures == 0:
               blocks.append(self.no_failures				)

           return json.dumps(lowercase				)
       @staticmethod
       def     A      (	):



           '''simple docstring'''

           UpperCAmelCase			       =		[
               {
                   '''type''': '''section''',
                   '''text''': {
                       '''type''': '''plain_text''',
                       '''text''': '''There was an issue running the tests.''',
                   },
                   '''accessory''': {
                       '''type''': '''button''',
                       '''text''': {'''type''': '''plain_text''', '''text''': '''Check Action results''', '''emoji''': True},
                       '''url''': f"https://github.com/huggingface/transformers/actions/runs/{os.environ['GITHUB_RUN_ID']}",
                   },
               }
           ]

           print('''Sending the following payload'''				)
           print(json.dumps({'''blocks''': json.loads(lowercase				)}				)				)

           client.chat_postMessage(
               channel=os.environ['''CI_SLACK_CHANNEL_ID_DAILY''']   ,				text='''There was an issue running the tests.'''   ,				blocks=lowercase   ,				)
       def     A      (	self						:	Optional[Any]				):



           '''simple docstring'''

           print('''Sending the following payload'''				)
           print(json.dumps({'''blocks''': json.loads(self.payload				)}				)				)

           UpperCAmelCase			       =		f"{self.n_failures} failures out of {self.n_tests} tests," if self.n_failures else '''All tests passed.'''

           UpperCAmelCase			       =		client.chat_postMessage(
               channel=os.environ['''CI_SLACK_CHANNEL_ID_DAILY''']   ,				blocks=self.payload   ,				text=lowercase   ,				)
       def     A      (	self						:	Optional[int]   ,				lowercase						:	Any   ,				lowercase						:	Any   ,				lowercase						:	Union[str, Any]   ,				lowercase						:	List[str]				):



           '''simple docstring'''

           UpperCAmelCase			       =		''''''
           for key, value in failures.items():
               UpperCAmelCase			       =		value[:200] + ''' [Truncated]''' if len(lowercase				) > 250 else value
               failures_text += f"*{key}*\n_{value}_\n\n"

           UpperCAmelCase			       =		job_name
           UpperCAmelCase			       =		{'''type''': '''section''', '''text''': {'''type''': '''mrkdwn''', '''text''': text}}

           if job_link is not None:
               UpperCAmelCase			       =		{
                   '''type''': '''button''',
                   '''text''': {'''type''': '''plain_text''', '''text''': '''GitHub Action job''', '''emoji''': True},
                   '''url''': job_link,
               }

           return [
               {"type": "header", "text": {"type": "plain_text", "text": title.upper(), "emoji": True}},
               content,
               {"type": "section", "text": {"type": "mrkdwn", "text": failures_text}},
           ]







       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           if self.thread_ts is None:
               raise ValueError('''Can only post reply if a post has been made.'''				)

           UpperCAmelCase			       =		self.doc_test_results.pop('''job_link'''				)
           self.doc_test_results.pop('''failures'''				)
           self.doc_test_results.pop('''success'''				)
           self.doc_test_results.pop('''time_spent'''				)

           UpperCAmelCase			       =		sorted(self.doc_test_results.items()   ,				key=lambda lowercase				: t[0]				)
           for job, job_result in sorted_dict:
               if len(job_result['''failures''']				):
                   UpperCAmelCase			       =		f"*Num failures* :{len(job_result['failed']				)} \n"
                   UpperCAmelCase			       =		job_result['''failures''']
                   UpperCAmelCase			       =		self.get_reply_blocks(lowercase   ,				lowercase   ,				lowercase   ,				text=lowercase				)

                   print('''Sending the following reply'''				)
                   print(json.dumps({'''blocks''': blocks}				)				)

                   client.chat_postMessage(
                       channel=os.environ['''CI_SLACK_CHANNEL_ID_DAILY''']   ,				text=f"Results for {job}"   ,				blocks=lowercase   ,				thread_ts=self.thread_ts['''ts''']   ,				)

                   time.sleep(1				)






def 						snake_case_							():
    UpperCAmelCase			       =		os.environ['''GITHUB_RUN_ID''']
    UpperCAmelCase			       =		F"https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100"
    UpperCAmelCase			       =		requests.get(_a     ).json()
    UpperCAmelCase			       =		{}

    try:
        jobs.update({job['''name''']: job['''html_url'''] for job in result['''jobs''']}     )
        UpperCAmelCase			       =		math.ceil((result['''total_count'''] - 1_0_0) / 1_0_0     )

        for i in range(_a     ):
            UpperCAmelCase			       =		requests.get(url + F"&page={i + 2}"     ).json()
            jobs.update({job['''name''']: job['''html_url'''] for job in result['''jobs''']}     )

        return jobs
    except Exception as e:
        print('''Unknown error, could not fetch links.'''    ,   _a     )

    return {}





def 						snake_case_							(_a	:							str     ):
    UpperCAmelCase			       =		{}

    if os.path.exists(_a     ):
        UpperCAmelCase			       =		os.listdir(_a     )
        for file in files:
            try:
                with open(os.path.join(_a    ,   _a     )    ,   encoding='''utf-8'''     ) as f:
                    UpperCAmelCase			       =		f.read()
            except UnicodeDecodeError as e:
                raise ValueError(F"Could not open {os.path.join(_a    ,   _a     )}."     ) from e

    return _artifact





def 						snake_case_							():


    class 			_a  :
           def __init__(	self						:	Any   ,				lowercase						:	str				):



               '''simple docstring'''

               UpperCAmelCase			       =		name
               UpperCAmelCase			       =		[]
           def __str__(	self						:	Tuple				):



               '''simple docstring'''

               return self.name







           def     A      (	self						:	List[Any]   ,				lowercase						:	str				):



               '''simple docstring'''

               self.paths.append({'''name''': self.name, '''path''': path}				)






    UpperCAmelCase			       =		{}

    UpperCAmelCase			       =		filter(os.path.isdir    ,   os.listdir()     )
    for directory in directories:
        UpperCAmelCase			       =		directory
        if artifact_name not in _available_artifacts:
            UpperCAmelCase			       =		Artifact(_a     )

            _available_artifacts[artifact_name].add_path(_a     )

    return _available_artifacts


if __name__ == "__main__":
   A     =get_job_links()
   A     =retrieve_available_artifacts()

   A     =collections.OrderedDict(
       [
           ('*.py', 'API Examples'),
           ('*.md', 'MD Examples'),
       ]
   )

   # This dict will contain all the information relative to each doc test category:
   # - failed: list of failed tests
   # - failures: dict in the format 'test': 'error_message'
   A     ={
       v: {
           'failed': [],
           'failures': {},
       }
       for v in docs.values()
   }

   # Link to the GitHub Action job
   A     =github_actions_job_links.get('run_doctests')

   A     =available_artifacts['doc_tests_gpu_test_reports'].paths[0]
   A     =retrieve_artifact(artifact_path['name'])
   if "stats" in artifact:
      A    ,      A    ,      A     =handle_test_results(artifact['stats'])
      A     =failed
      A     =success
      A     =time_spent[1:-1] + ', '

      A     =extract_first_line_failure(artifact['failures_short'])
      for line in artifact["summary_short"].split('\n'):
         if re.search('FAILED', line):
            A     =line.replace('FAILED ', '')
            A     =line.split()[0].replace('\n', '')

            if "::" in line:
               A    ,      A     =line.split('::')
            else:
               A    ,      A     =line, line

            for file_regex in docs.keys():
               if fnmatch(file_path, file_regex):
                  A     =docs[file_regex]
                  doc_test_results[category]["failed"].append(test)

                  A     =all_failures[test] if test in all_failures else 'N/A'
                  A     =failure
                  break

   A     =Message('🤗 Results of the doc tests.', doc_test_results)
   message.post()
   message.post_reply()







"""simple docstring"""





from scipy.stats import spearmanr

import datasets


_a       =							'\nThe Spearman rank-order correlation coefficient is a measure of the\nrelationship between two datasets. Like other correlation coefficients,\nthis one varies between -1 and +1 with 0 implying no correlation.\nPositive correlations imply that as data in dataset x increases, so\ndoes data in dataset y. Negative correlations imply that as x increases,\ny decreases. Correlations of -1 or +1 imply an exact monotonic relationship.\n\nUnlike the Pearson correlation, the Spearman correlation does not\nassume that both datasets are normally distributed.\n\nThe p-value roughly indicates the probability of an uncorrelated system\nproducing datasets that have a Spearman correlation at least as extreme\nas the one computed from these datasets. The p-values are not entirely\nreliable but are probably reasonable for datasets larger than 500 or so.\n'

_a       =							'\nArgs:\n    predictions (`List[float]`): Predicted labels, as returned by a model.\n    references (`List[float]`): Ground truth labels.\n    return_pvalue (`bool`): If `True`, returns the p-value. If `False`, returns\n            only the spearmanr score. Defaults to `False`.\nReturns:\n    spearmanr (`float`): Spearman correlation coefficient.\n    p-value (`float`): p-value. **Note**: is only returned if `return_pvalue=True` is input.\nExamples:\n    Example 1:\n        >>> spearmanr_metric = datasets.load_metric("spearmanr")\n        >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5], predictions=[10, 9, 2.5, 6, 4])\n        >>> print(results)\n        {\'spearmanr\': -0.7}\n\n    Example 2:\n        >>> spearmanr_metric = datasets.load_metric("spearmanr")\n        >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5],\n        ...                                     predictions=[10, 9, 2.5, 6, 4],\n        ...                                     return_pvalue=True)\n        >>> print(results[\'spearmanr\'])\n        -0.7\n        >>> print(round(results[\'spearmanr_pvalue\'], 2))\n        0.19\n'

_a       =							r'\\n@book{kokoska2000crc,\n  title={CRC standard probability and statistics tables and formulae},\n  author={Kokoska, Stephen and Zwillinger, Daniel},\n  year={2000},\n  publisher={Crc Press}\n}\n@article{2020SciPy-NMeth,\n  author  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and\n            Haberland, Matt and Reddy, Tyler and Cournapeau, David and\n            Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and\n            Bright, Jonathan and {van der Walt}, St{\'e}fan J. and\n            Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and\n            Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and\n            Kern, Robert and Larson, Eric and Carey, C J and\n            Polat, {\.I}lhan and Feng, Yu and Moore, Eric W. and\n            {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and\n            Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and\n            Harris, Charles R. and Archibald, Anne M. and\n            Ribeiro, Ant{\^o}nio H. and Pedregosa, Fabian and\n            {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},\n  title   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific\n            Computing in Python}},\n  journal = {Nature Methods},\n  year    = {2020},\n  volume  = {17},\n  pages   = {261--272},\n  adsurl  = {https://rdcu.be/b08Wh},\n  doi     = {10.1038/s41592-019-0686-2},\n}\n'




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







 """simple docstring"""







 def 					_lowercase (			self							:			Dict	):
    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.spearmanr.html"],					)



 def 					_lowercase (			self							:			Optional[Any],					UpperCAmelCase__							:			Optional[int],					UpperCAmelCase__							:			List[str],					UpperCAmelCase__							:			Optional[int]=False	):
    __lowercase								=						spearmanr(UpperCAmelCase__,					UpperCAmelCase__	)
    if return_pvalue:
       return {"spearmanr": results[0], "spearmanr_pvalue": results[1]}
    else:
       return {"spearmanr": results[0]}




