
'''simple docstring'''
import argparse
import math
import traceback

import dateutil.parser as date_parser
import requests






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE				):
							_snake_case       =  {}

							_snake_case       =  job["""started_at"""]
							_snake_case       =  job["""completed_at"""]

							_snake_case       =  date_parser.parse(_SCREAMING_SNAKE_CASE				)
							_snake_case       =  date_parser.parse(_SCREAMING_SNAKE_CASE				)

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

							_snake_case       =  start
							_snake_case       =  end
							_snake_case       =  duration_in_min

							return job_info






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE							, _SCREAMING_SNAKE_CASE=None				):
							_snake_case       =  None
							if token is not None:
														_snake_case       =  {"""Accept""": """application/vnd.github+json""", """Authorization""": f"""Bearer {token}"""}

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

							try:
														job_time.update({job["""name"""]: extract_time_from_single_job(_SCREAMING_SNAKE_CASE				) for job in result["""jobs"""]}				)
														_snake_case       =  math.ceil((result["""total_count"""] - 100) / 100				)

														for i in range(_SCREAMING_SNAKE_CASE				):
																					_snake_case       =  requests.get(url + f"""&page={i + 2}"""							, headers=_SCREAMING_SNAKE_CASE				).json()
																					job_time.update({job["""name"""]: extract_time_from_single_job(_SCREAMING_SNAKE_CASE				) 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__":
				__lowerCAmelCase												=	argparse.ArgumentParser()
				# Required parameters
				parser.add_argument('--workflow_run_id', type=str, required=True, help='A GitHub Actions workflow run id.')
				__lowerCAmelCase												=	parser.parse_args()

				__lowerCAmelCase												=	get_job_time(args.workflow_run_id)
				__lowerCAmelCase												=	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"]}''')

'''simple docstring'''
from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


__lowerCAmelCase												=	logging.get_logger(__name__)

__lowerCAmelCase												=	{
    'shi-labs/nat-mini-in1k-224': 'https://huggingface.co/shi-labs/nat-mini-in1k-224/resolve/main/config.json',
    # See all Nat models at https://huggingface.co/models?filter=nat
}


class       _lowerCAmelCase   (   __snake_case					,							__snake_case				):







							'''simple docstring'''

							lowerCAmelCase_ 						=						"nat"

							lowerCAmelCase_ 						=						{
							    "num_attention_heads": "num_heads",
							    "num_hidden_layers": "num_layers",
							}

							def __init__(self  ,  UpperCAmelCase=4  ,  UpperCAmelCase=3  ,  UpperCAmelCase=64  ,  UpperCAmelCase=[3, 4, 6, 5]  ,  UpperCAmelCase=[2, 4, 8, 16]  ,  UpperCAmelCase=7  ,  UpperCAmelCase=3.0  ,  UpperCAmelCase=True  ,  UpperCAmelCase=0.0  ,  UpperCAmelCase=0.0  ,  UpperCAmelCase=0.1  ,  UpperCAmelCase="gelu"  ,  UpperCAmelCase=0.02  ,  UpperCAmelCase=1e-5  ,  UpperCAmelCase=0.0  ,  UpperCAmelCase=None  ,  UpperCAmelCase=None  ,  **UpperCAmelCase  ,  )					->       str:
														super().__init__(**UpperCAmelCase  )

														_snake_case       =  patch_size
														_snake_case       =  num_channels
														_snake_case       =  embed_dim
														_snake_case       =  depths
														_snake_case       =  len(UpperCAmelCase  )
														_snake_case       =  num_heads
														_snake_case       =  kernel_size
														_snake_case       =  mlp_ratio
														_snake_case       =  qkv_bias
														_snake_case       =  hidden_dropout_prob
														_snake_case       =  attention_probs_dropout_prob
														_snake_case       =  drop_path_rate
														_snake_case       =  hidden_act
														_snake_case       =  layer_norm_eps
														_snake_case       =  initializer_range
														# we set the hidden_size attribute in order to make Nat work with VisionEncoderDecoderModel
														# this indicates the channel dimension after the last stage of the model
														_snake_case       =  int(embed_dim * 2 ** (len(UpperCAmelCase  ) - 1)  )
														_snake_case       =  layer_scale_init_value
														_snake_case       =  ["""stem"""] + [f"""stage{idx}""" for idx in range(1  ,  len(UpperCAmelCase  ) + 1  )]
														_snake_case,							_snake_case       =  get_aligned_output_features_output_indices(
														    out_features=UpperCAmelCase  ,  out_indices=UpperCAmelCase  ,  stage_names=self.stage_names  )