





"""simple docstring"""




import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bert import BertTokenizer


A   : str			=				logging.get_logger(__name__)

A   : List[str]			=				{'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

A   : Any			=				{
    '''vocab_file''': {
        '''bert-base-uncased''': '''https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt''',
        '''bert-large-uncased''': '''https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt''',
        '''bert-base-cased''': '''https://huggingface.co/bert-base-cased/resolve/main/vocab.txt''',
        '''bert-large-cased''': '''https://huggingface.co/bert-large-cased/resolve/main/vocab.txt''',
        '''bert-base-multilingual-uncased''': (
            '''https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt'''
        ),
        '''bert-base-multilingual-cased''': '''https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt''',
        '''bert-base-chinese''': '''https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt''',
        '''bert-base-german-cased''': '''https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt''',
        '''bert-large-uncased-whole-word-masking''': (
            '''https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt'''
        ),
        '''bert-large-cased-whole-word-masking''': (
            '''https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt'''
        ),
        '''bert-large-uncased-whole-word-masking-finetuned-squad''': (
            '''https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'''
        ),
        '''bert-large-cased-whole-word-masking-finetuned-squad''': (
            '''https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'''
        ),
        '''bert-base-cased-finetuned-mrpc''': (
            '''https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt'''
        ),
        '''bert-base-german-dbmdz-cased''': '''https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt''',
        '''bert-base-german-dbmdz-uncased''': (
            '''https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt'''
        ),
        '''TurkuNLP/bert-base-finnish-cased-v1''': (
            '''https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt'''
        ),
        '''TurkuNLP/bert-base-finnish-uncased-v1''': (
            '''https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt'''
        ),
        '''wietsedv/bert-base-dutch-cased''': (
            '''https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''bert-base-uncased''': '''https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json''',
        '''bert-large-uncased''': '''https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json''',
        '''bert-base-cased''': '''https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json''',
        '''bert-large-cased''': '''https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json''',
        '''bert-base-multilingual-uncased''': (
            '''https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json'''
        ),
        '''bert-base-multilingual-cased''': (
            '''https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json'''
        ),
        '''bert-base-chinese''': '''https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json''',
        '''bert-base-german-cased''': '''https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json''',
        '''bert-large-uncased-whole-word-masking''': (
            '''https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json'''
        ),
        '''bert-large-cased-whole-word-masking''': (
            '''https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json'''
        ),
        '''bert-large-uncased-whole-word-masking-finetuned-squad''': (
            '''https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'''
        ),
        '''bert-large-cased-whole-word-masking-finetuned-squad''': (
            '''https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'''
        ),
        '''bert-base-cased-finetuned-mrpc''': (
            '''https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json'''
        ),
        '''bert-base-german-dbmdz-cased''': (
            '''https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json'''
        ),
        '''bert-base-german-dbmdz-uncased''': (
            '''https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json'''
        ),
        '''TurkuNLP/bert-base-finnish-cased-v1''': (
            '''https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json'''
        ),
        '''TurkuNLP/bert-base-finnish-uncased-v1''': (
            '''https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json'''
        ),
        '''wietsedv/bert-base-dutch-cased''': (
            '''https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json'''
        ),
    },
}

A   : Optional[int]			=				{
    '''bert-base-uncased''': 5_1_2,
    '''bert-large-uncased''': 5_1_2,
    '''bert-base-cased''': 5_1_2,
    '''bert-large-cased''': 5_1_2,
    '''bert-base-multilingual-uncased''': 5_1_2,
    '''bert-base-multilingual-cased''': 5_1_2,
    '''bert-base-chinese''': 5_1_2,
    '''bert-base-german-cased''': 5_1_2,
    '''bert-large-uncased-whole-word-masking''': 5_1_2,
    '''bert-large-cased-whole-word-masking''': 5_1_2,
    '''bert-large-uncased-whole-word-masking-finetuned-squad''': 5_1_2,
    '''bert-large-cased-whole-word-masking-finetuned-squad''': 5_1_2,
    '''bert-base-cased-finetuned-mrpc''': 5_1_2,
    '''bert-base-german-dbmdz-cased''': 5_1_2,
    '''bert-base-german-dbmdz-uncased''': 5_1_2,
    '''TurkuNLP/bert-base-finnish-cased-v1''': 5_1_2,
    '''TurkuNLP/bert-base-finnish-uncased-v1''': 5_1_2,
    '''wietsedv/bert-base-dutch-cased''': 5_1_2,
}

A   : Optional[Any]			=				{
    '''bert-base-uncased''': {'''do_lower_case''': True},
    '''bert-large-uncased''': {'''do_lower_case''': True},
    '''bert-base-cased''': {'''do_lower_case''': False},
    '''bert-large-cased''': {'''do_lower_case''': False},
    '''bert-base-multilingual-uncased''': {'''do_lower_case''': True},
    '''bert-base-multilingual-cased''': {'''do_lower_case''': False},
    '''bert-base-chinese''': {'''do_lower_case''': False},
    '''bert-base-german-cased''': {'''do_lower_case''': False},
    '''bert-large-uncased-whole-word-masking''': {'''do_lower_case''': True},
    '''bert-large-cased-whole-word-masking''': {'''do_lower_case''': False},
    '''bert-large-uncased-whole-word-masking-finetuned-squad''': {'''do_lower_case''': True},
    '''bert-large-cased-whole-word-masking-finetuned-squad''': {'''do_lower_case''': False},
    '''bert-base-cased-finetuned-mrpc''': {'''do_lower_case''': False},
    '''bert-base-german-dbmdz-cased''': {'''do_lower_case''': False},
    '''bert-base-german-dbmdz-uncased''': {'''do_lower_case''': True},
    '''TurkuNLP/bert-base-finnish-cased-v1''': {'''do_lower_case''': False},
    '''TurkuNLP/bert-base-finnish-uncased-v1''': {'''do_lower_case''': True},
    '''wietsedv/bert-base-dutch-cased''': {'''do_lower_case''': False},
}


class   A      (SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''




			__lowerCamelCase     :	Union[str, Any]          =   VOCAB_FILES_NAMES
			__lowerCamelCase     :	Optional[int]          =   PRETRAINED_VOCAB_FILES_MAP
			__lowerCamelCase     :	int          =   PRETRAINED_INIT_CONFIGURATION
			__lowerCamelCase     :	Tuple          =   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			__lowerCamelCase     :	int          =   BertTokenizer






			def __init__(      self       :   Optional[Any]							,     __lowerCAmelCase       :   List[Any]=None							,     __lowerCAmelCase       :   Union[str, Any]=None							,     __lowerCAmelCase       :   str=True							,     __lowerCAmelCase       :   Optional[int]="[UNK]"							,     __lowerCAmelCase       :   str="[SEP]"							,     __lowerCAmelCase       :   List[Any]="[PAD]"							,     __lowerCAmelCase       :   List[str]="[CLS]"							,     __lowerCAmelCase       :   List[Any]="[MASK]"							,     __lowerCAmelCase       :   int=True							,     __lowerCAmelCase       :   Union[str, Any]=None							,     **__lowerCAmelCase       :   List[Any]							,     )     ->     List[Any]:







					"""simple docstring"""






					super().__init__(
					    __lowerCAmelCase							,     tokenizer_file=__lowerCAmelCase							,     do_lower_case=__lowerCAmelCase							,     unk_token=__lowerCAmelCase							,     sep_token=__lowerCAmelCase							,     pad_token=__lowerCAmelCase							,     cls_token=__lowerCAmelCase							,     mask_token=__lowerCAmelCase							,     tokenize_chinese_chars=__lowerCAmelCase							,     strip_accents=__lowerCAmelCase							,     **__lowerCAmelCase							,     )

					A__  				=       json.loads(self.backend_tokenizer.normalizer.__getstate__()       )
					if (
					    normalizer_state.get("""lowercase"""							,     __lowerCAmelCase       ) != do_lower_case
					    or normalizer_state.get("""strip_accents"""							,     __lowerCAmelCase       ) != strip_accents
					    or normalizer_state.get("""handle_chinese_chars"""							,     __lowerCAmelCase       ) != tokenize_chinese_chars
					):
							A__  				=       getattr(__lowerCAmelCase							,     normalizer_state.pop("""type"""       )       )
							A__  				=       do_lower_case
							A__  				=       strip_accents
							A__  				=       tokenize_chinese_chars
							A__  				=       normalizer_class(**__lowerCAmelCase       )

					A__  				=       do_lower_case






			def        a_	(      self       :   List[str]							,     __lowerCAmelCase       :   Tuple							,     __lowerCAmelCase       :   Dict=None       )     ->     Union[str, Any]:







					"""simple docstring"""






					A__  				=       [self.cls_token_id] + token_ids_a + [self.sep_token_id]

					if token_ids_a:
							output += token_ids_a + [self.sep_token_id]

					return output






			def        a_	(      self       :   Union[str, Any]							,     __lowerCAmelCase       :   List[int]							,     __lowerCAmelCase       :   Optional[List[int]] = None       )     ->     List[int]:







					"""simple docstring"""






					A__  				=       [self.sep_token_id]
					A__  				=       [self.cls_token_id]
					if token_ids_a is None:
							return len(cls + token_ids_a + sep       ) * [0]
					return len(cls + token_ids_a + sep       ) * [0] + len(token_ids_a + sep       ) * [1]







			def        a_	(      self       :   List[str]							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   Optional[str] = None       )     ->     Tuple[str]:







					"""simple docstring"""






					A__  				=       self._tokenizer.model.save(__lowerCAmelCase							,     name=__lowerCAmelCase       )
					return tuple(__lowerCAmelCase       )










import argparse
import math
import traceback

import dateutil.parser as date_parser
import requests







def        __lowerCamelCase (							__a       :str   )		->    Optional[int]:






		"""simple docstring"""

		A__  				=       {}

		A__  				=       job["""started_at"""]
		A__  				=       job["""completed_at"""]

		A__  				=       date_parser.parse(__a   )
		A__  				=       date_parser.parse(__a   )

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

		A__  				=       start
		A__  				=       end
		A__  				=       duration_in_min

		return job_info







def        __lowerCamelCase (							__a       :Optional[Any]   ,					__a       :List[str]=None   )		->    List[Any]:






		"""simple docstring"""

		A__  				=       None
		if token is not None:
				A__  				=       {"""Accept""": """application/vnd.github+json""", """Authorization""": F'Bearer {token}'}

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

		try:
				job_time.update({job["""name"""]: extract_time_from_single_job(__a   ) for job in result["""jobs"""]}   )
				A__  				=       math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0   )

				for i in range(__a   ):
						A__  				=       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   : Optional[Any]			=				argparse.ArgumentParser()
					# Required parameters
					parser.add_argument('''--workflow_run_id''', type=str, required=True, help='''A GitHub Actions workflow run id.''')
					A   : Dict			=				parser.parse_args()

					A   : List[Any]			=				get_job_time(args.workflow_run_id)
					A   : int			=				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"]}''')



