




'''simple docstring'''







import json
import os
import shutil
import tempfile
import unittest

from transformers import BatchEncoding, CanineTokenizer
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.tokenization_utils import AddedToken
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


class     _a						(			__a							,							unittest.TestCase				):
       __a       :  List[Any]            =      CanineTokenizer
       __a       :  List[Any]            =      False
       def 					A   (			self		:			int       ):



           '''simple docstring'''

           super().setUp()
           UpperCAmelCase     =	CanineTokenizer()
           tokenizer.save_pretrained(self.tmpdirname       )
       @cached_property
       def 					A   (			self		:			List[str]       ):



           '''simple docstring'''

           return CanineTokenizer.from_pretrained('''google/canine-s'''       )
       def 					A   (			self		:			str     ,       **lowercase		:			Tuple       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.tokenizer_class.from_pretrained(self.tmpdirname     ,       **lowercase       )
           UpperCAmelCase     =	1_024
           return tokenizer
       @require_torch
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.canine_tokenizer
           UpperCAmelCase     =	['''Life is like a box of chocolates.''', '''You never know what you\'re gonna get.''']
           # fmt: off
           UpperCAmelCase     =	[57_344, 76, 105, 102, 101, 32, 105, 115, 32, 108, 105, 107, 101, 32, 97, 32, 98, 111, 120, 32, 111, 102, 32, 99, 104, 111, 99, 111, 108, 97, 116, 101, 115, 46, 57_345, 0, 0, 0, 0]
           # fmt: on
           UpperCAmelCase     =	tokenizer(lowercase     ,       padding=lowercase     ,       return_tensors='''pt'''       )
           self.assertIsInstance(lowercase     ,       lowercase       )

           UpperCAmelCase     =	list(batch.input_ids.numpy()[0]       )

           self.assertListEqual(lowercase     ,       lowercase       )

           self.assertEqual((2, 39)     ,       batch.input_ids.shape       )
           self.assertEqual((2, 39)     ,       batch.attention_mask.shape       )
       @require_torch
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.canine_tokenizer
           UpperCAmelCase     =	['''Once there was a man.''', '''He wrote a test in HuggingFace Tranformers.''']
           UpperCAmelCase     =	tokenizer(lowercase     ,       padding=lowercase     ,       return_tensors='''pt'''       )
           # check if input_ids, attention_mask and token_type_ids are returned
           self.assertIn('''input_ids'''     ,       lowercase       )
           self.assertIn('''attention_mask'''     ,       lowercase       )
           self.assertIn('''token_type_ids'''     ,       lowercase       )
       @require_torch
       def 					A   (			self		:			Any       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.canine_tokenizer
           UpperCAmelCase     =	[
               '''What\'s the weater?''',
               '''It\'s about 25 degrees.''',
           ]
           UpperCAmelCase     =	tokenizer(
               text_target=lowercase     ,       max_length=32     ,       padding='''max_length'''     ,       truncation=lowercase     ,       return_tensors='''pt'''       )
           self.assertEqual(32     ,       targets['''input_ids'''].shape[1]       )
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_tokenizers()
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"       ):
                   self.assertNotEqual(tokenizer.model_max_length     ,       42       )

        # Now let's start the test
           UpperCAmelCase     =	self.get_tokenizers()
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"       ):
                   # Isolate this from the other tests because we save additional tokens/etc
                   UpperCAmelCase     =	tempfile.mkdtemp()

                   UpperCAmelCase     =	''' He is very happy, UNwant\u00E9d,running'''
                   UpperCAmelCase     =	tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )
                   tokenizer.save_pretrained(lowercase       )

                   UpperCAmelCase     =	tokenizer.__class__.from_pretrained(lowercase       )
                   UpperCAmelCase     =	after_tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )
                   self.assertListEqual(lowercase     ,       lowercase       )

                   shutil.rmtree(lowercase       )

           UpperCAmelCase     =	self.get_tokenizers(model_max_length=42       )
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"       ):
                   # Isolate this from the other tests because we save additional tokens/etc
                   UpperCAmelCase     =	tempfile.mkdtemp()

                   UpperCAmelCase     =	''' He is very happy, UNwant\u00E9d,running'''

                   UpperCAmelCase     =	tokenizer.additional_special_tokens

                   # We can add a new special token for Canine as follows:
                   UpperCAmelCase     =	chr(0Xe0_07       )
                   additional_special_tokens.append(lowercase       )
                   tokenizer.add_special_tokens({'''additional_special_tokens''': additional_special_tokens}       )
                   UpperCAmelCase     =	tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )
                   tokenizer.save_pretrained(lowercase       )

                   UpperCAmelCase     =	tokenizer.__class__.from_pretrained(lowercase       )
                   UpperCAmelCase     =	after_tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )
                   self.assertListEqual(lowercase     ,       lowercase       )
                   self.assertIn(lowercase     ,       after_tokenizer.additional_special_tokens       )
                   self.assertEqual(after_tokenizer.model_max_length     ,       42       )

                   UpperCAmelCase     =	tokenizer.__class__.from_pretrained(lowercase     ,       model_max_length=43       )
                   self.assertEqual(tokenizer.model_max_length     ,       43       )

                   shutil.rmtree(lowercase       )
       def 					A   (			self		:			List[str]       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_tokenizers(do_lower_case=lowercase       )
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"       ):
                   UpperCAmelCase ,  UpperCAmelCase     =	self.get_clean_sequence(lowercase       )

                   # a special token for Canine can be defined as follows:
                   UpperCAmelCase     =	0Xe0_05
                   UpperCAmelCase     =	chr(lowercase       )

                   tokenizer.add_special_tokens({'''cls_token''': special_token}       )
                   UpperCAmelCase     =	tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )
                   self.assertEqual(len(lowercase       )     ,       1       )

                   UpperCAmelCase     =	tokenizer.decode(ids + encoded_special_token     ,       clean_up_tokenization_spaces=lowercase       )
                   UpperCAmelCase     =	tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )

                   UpperCAmelCase     =	tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )
                   UpperCAmelCase     =	tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )
                   self.assertEqual(lowercase     ,       input_encoded + special_token_id       )

                   UpperCAmelCase     =	tokenizer.decode(lowercase     ,       skip_special_tokens=lowercase       )
                   self.assertTrue(special_token not in decoded       )
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_tokenizers(do_lower_case=lowercase       )
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"       ):
                   UpperCAmelCase     =	chr(0Xe0_05       )
                   UpperCAmelCase     =	chr(0Xe0_06       )

                   # `add_tokens` method stores special tokens only in `tokenizer.unique_no_split_tokens`. (in tokenization_utils.py)
                   tokenizer.add_tokens([SPECIAL_TOKEN_1]     ,       special_tokens=lowercase       )
                   # `add_special_tokens` method stores special tokens in `tokenizer.additional_special_tokens`,
                   # which also occur in `tokenizer.all_special_tokens`. (in tokenization_utils_base.py)
                   tokenizer.add_special_tokens({'''additional_special_tokens''': [SPECIAL_TOKEN_2]}       )

                   UpperCAmelCase     =	tokenizer.tokenize(lowercase       )
                   UpperCAmelCase     =	tokenizer.tokenize(lowercase       )

                   self.assertEqual(len(lowercase       )     ,       1       )
                   self.assertEqual(len(lowercase       )     ,       1       )
                   self.assertEqual(token_a[0]     ,       lowercase       )
                   self.assertEqual(token_a[0]     ,       lowercase       )
       @require_tokenizers
       def 					A   (			self		:			int       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_tokenizers(do_lower_case=lowercase       )
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"       ):
                   # a special token for Canine can be defined as follows:
                   UpperCAmelCase     =	0Xe0_06
                   UpperCAmelCase     =	chr(lowercase       )

                   UpperCAmelCase     =	AddedToken(lowercase     ,       lstrip=lowercase       )
                   tokenizer.add_special_tokens({'''additional_special_tokens''': [new_token]}       )

                   with tempfile.TemporaryDirectory() as tmp_dir_name:
                       tokenizer.save_pretrained(lowercase       )
                       tokenizer.from_pretrained(lowercase       )
       def 					A   (			self		:			Any       ):



           '''simple docstring'''

           UpperCAmelCase     =	[]
           if self.test_slow_tokenizer:
               tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())       )

           if self.test_rust_tokenizer:
               tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())       )

           for tokenizer_class, tokenizer_utils in tokenizer_list:
               with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer_utils.save_pretrained(lowercase       )

                   with open(os.path.join(lowercase     ,       '''special_tokens_map.json'''       )     ,       encoding='''utf-8'''       ) as json_file:
                       UpperCAmelCase     =	json.load(lowercase       )

                   with open(os.path.join(lowercase     ,       '''tokenizer_config.json'''       )     ,       encoding='''utf-8'''       ) as json_file:
                       UpperCAmelCase     =	json.load(lowercase       )

                   # a special token for Canine can be defined as follows:
                   UpperCAmelCase     =	0Xe0_06
                   UpperCAmelCase     =	chr(lowercase       )

                   UpperCAmelCase     =	[new_token_a]
                   UpperCAmelCase     =	[new_token_a]

                   with open(os.path.join(lowercase     ,       '''special_tokens_map.json'''       )     ,       '''w'''     ,       encoding='''utf-8'''       ) as outfile:
                       json.dump(lowercase     ,       lowercase       )
                   with open(os.path.join(lowercase     ,       '''tokenizer_config.json'''       )     ,       '''w'''     ,       encoding='''utf-8'''       ) as outfile:
                       json.dump(lowercase     ,       lowercase       )

                   # the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
                   # into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
                   # "special_tokens_map.json" files
                   UpperCAmelCase     =	tokenizer_class.from_pretrained(lowercase     ,       extra_ids=0       )
                   self.assertIn(lowercase     ,       tokenizer_without_change_in_init.additional_special_tokens       )
                   # self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
                   self.assertEqual(
                       [new_token_a]     ,       tokenizer_without_change_in_init.convert_ids_to_tokens(
                           tokenizer_without_change_in_init.convert_tokens_to_ids([new_token_a]       )       )     ,       )

                   UpperCAmelCase     =	0Xe0_07
                   UpperCAmelCase     =	chr(lowercase       )
                   # Now we test that we can change the value of additional_special_tokens in the from_pretrained
                   UpperCAmelCase     =	[AddedToken(lowercase     ,       lstrip=lowercase       )]
                   UpperCAmelCase     =	tokenizer_class.from_pretrained(
                       lowercase     ,       additional_special_tokens=lowercase     ,       extra_ids=0       )

                   self.assertIn(lowercase     ,       tokenizer.additional_special_tokens       )
                   # self.assertIn(new_token_2,tokenizer.get_vocab()) # ByT5Tokenization no vocab
                   self.assertEqual(
                       [new_token_a]     ,       tokenizer.convert_ids_to_tokens(tokenizer.convert_tokens_to_ids([new_token_a]       )       )       )
       @require_tokenizers
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_tokenizers(do_lower_case=lowercase       )
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"       ):
                   UpperCAmelCase     =	'''hello world'''
                   if self.space_between_special_tokens:
                       UpperCAmelCase     =	'''[CLS] hello world [SEP]'''
                   else:
                       UpperCAmelCase     =	input
                   UpperCAmelCase     =	tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )
                   UpperCAmelCase     =	tokenizer.decode(lowercase     ,       spaces_between_special_tokens=self.space_between_special_tokens       )
                   self.assertIn(lowercase     ,       [output, output.lower()]       )
       def 					A   (			self		:			str       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_tokenizers()
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"       ):
                   UpperCAmelCase     =	[
                       '''bos_token''',
                       '''eos_token''',
                       '''unk_token''',
                       '''sep_token''',
                       '''pad_token''',
                       '''cls_token''',
                       '''mask_token''',
                   ]

           UpperCAmelCase     =	'''a'''
           UpperCAmelCase     =	ord(lowercase       )

           for attr in attributes_list:
               setattr(lowercase     ,       attr + '''_id'''     ,       lowercase       )
               self.assertEqual(getattr(lowercase     ,       lowercase       )     ,       lowercase       )
               self.assertEqual(getattr(lowercase     ,       attr + '''_id'''       )     ,       lowercase       )

               setattr(lowercase     ,       attr + '''_id'''     ,       lowercase       )
               self.assertEqual(getattr(lowercase     ,       lowercase       )     ,       lowercase       )
               self.assertEqual(getattr(lowercase     ,       attr + '''_id'''       )     ,       lowercase       )

           setattr(lowercase     ,       '''additional_special_tokens_ids'''     ,       []       )
           self.assertListEqual(getattr(lowercase     ,       '''additional_special_tokens'''       )     ,       []       )
           self.assertListEqual(getattr(lowercase     ,       '''additional_special_tokens_ids'''       )     ,       []       )

           UpperCAmelCase     =	0Xe0_06
           UpperCAmelCase     =	chr(lowercase       )
           setattr(lowercase     ,       '''additional_special_tokens_ids'''     ,       [additional_special_token_id]       )
           self.assertListEqual(getattr(lowercase     ,       '''additional_special_tokens'''       )     ,       [additional_special_token]       )
           self.assertListEqual(getattr(lowercase     ,       '''additional_special_tokens_ids'''       )     ,       [additional_special_token_id]       )
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           pass
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           pass
       def 					A   (			self		:			str       ):



           '''simple docstring'''

           pass
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           pass
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           pass
       def 					A   (			self		:			Dict       ):



           '''simple docstring'''

           pass
       def 					A   (			self		:			int       ):



           '''simple docstring'''

           pass







       def 					A   (			self		:			Any       ):



           '''simple docstring'''

           pass










'''simple docstring'''







import argparse
import math
import traceback

import dateutil.parser as date_parser
import requests





def 		snake_case_							(_a			:							List[str]  ):
    UpperCAmelCase     =	{}

    UpperCAmelCase     =	job['''started_at''']
    UpperCAmelCase     =	job['''completed_at''']

    UpperCAmelCase     =	date_parser.parse(_a  )
    UpperCAmelCase     =	date_parser.parse(_a  )

    UpperCAmelCase     =	round((end_datetime - start_datetime).total_seconds() / 60.0  )

    UpperCAmelCase     =	start
    UpperCAmelCase     =	end
    UpperCAmelCase     =	duration_in_min

    return job_info





def 		snake_case_							(_a			:							str					,     _a			:							List[str]=None  ):
    UpperCAmelCase     =	None
    if token is not None:
        UpperCAmelCase     =	{'''Accept''': '''application/vnd.github+json''', '''Authorization''': F"Bearer {token}"}

    UpperCAmelCase     =	F"https://api.github.com/repos/huggingface/transformers/actions/runs/{workflow_run_id}/jobs?per_page=100"
    UpperCAmelCase     =	requests.get(_a					,     headers=_a  ).json()
    UpperCAmelCase     =	{}

    try:
        job_time.update({job['''name''']: extract_time_from_single_job(_a  ) 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}"					,     headers=_a  ).json()
            job_time.update({job['''name''']: extract_time_from_single_job(_a  ) for job in result['''jobs''']}  )

        return job_time
    except Exception:
        print(F"Unknown error, could not fetch links:\n{traceback.format_exc()}"  )

    return {}


if __name__ == "__main__":
   A									=argparse.ArgumentParser()
   # Required parameters
   parser.add_argument('--workflow_run_id', type=str, required=True, help='A GitHub Actions workflow run id.')
   A									=parser.parse_args()

   A									=get_job_time(args.workflow_run_id)
   A									=dict(sorted(job_time.items(), key=lambda item: item[1]["duration"], reverse=True))

   for k, v in job_time.items():
      print(f"""{k}: {v["duration"]}""")




