




'''simple docstring'''


import torch
import torch.nn as nn
from transformers import CLIPConfig, CLIPVisionModel, PreTrainedModel

from ...utils import logging


_snake_case				:				List[Any]       							=		logging.get_logger(__name__)
def 		snake_case_   (UpperCamelCase	:  Optional[Any]			,						UpperCamelCase	:  Dict				):





							'''simple docstring'''


							_a     					=    nn.functional.normalize(UpperCamelCase				)
							_a     					=    nn.functional.normalize(UpperCamelCase				)
							return torch.mm(UpperCamelCase			,						normalized_text_embeds.t()				)

class       A   (		_a   ):
							lowercase_          =    CLIPConfig

							lowercase_          =    ['CLIPEncoderLayer']







							def __init__(  self	:  Optional[Any]							,      lowerCAmelCase_	:  CLIPConfig )      ->							Optional[Any]:


														"""simple docstring"""


														super().__init__(lowerCAmelCase_ )

														_a     					=    CLIPVisionModel(config.vision_config )
														_a     					=    nn.Linear(config.vision_config.hidden_size							,      config.projection_dim							,      bias=lowerCAmelCase_ )

														_a     					=    nn.Parameter(torch.ones(17							,      config.projection_dim )							,      requires_grad=lowerCAmelCase_ )
														_a     					=    nn.Parameter(torch.ones(3							,      config.projection_dim )							,      requires_grad=lowerCAmelCase_ )

														_a     					=    nn.Parameter(torch.ones(17 )							,      requires_grad=lowerCAmelCase_ )
														_a     					=    nn.Parameter(torch.ones(3 )							,      requires_grad=lowerCAmelCase_ )







							@torch.no_grad()
							def        __lowerCAmelCase      (  self	:  Dict							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  Tuple )      ->							str:


														"""simple docstring"""


														_a     					=    self.vision_model(lowerCAmelCase_ )[1]  # pooled_output
														_a     					=    self.visual_projection(lowerCAmelCase_ )

														# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
														_a     					=    cosine_distance(lowerCAmelCase_							,      self.special_care_embeds ).cpu().float().numpy()
														_a     					=    cosine_distance(lowerCAmelCase_							,      self.concept_embeds ).cpu().float().numpy()

														_a     					=    []
														_a     					=    image_embeds.shape[0]
														for i in range(lowerCAmelCase_ ):
																					_a     					=    {'''special_scores''': {}, '''special_care''': [], '''concept_scores''': {}, '''bad_concepts''': []}

																					# increase this value to create a stronger `nfsw` filter
																					# at the cost of increasing the possibility of filtering benign images
																					_a     					=    0.0

																					for concept_idx in range(len(special_cos_dist[0] ) ):
																												_a     					=    special_cos_dist[i][concept_idx]
																												_a     					=    self.special_care_embeds_weights[concept_idx].item()
																												_a     					=    round(concept_cos - concept_threshold + adjustment							,      3 )
																												if result_img["special_scores"][concept_idx] > 0:
																																			result_img["special_care"].append({concept_idx, result_img['''special_scores'''][concept_idx]} )
																																			_a     					=    0.0_1

																					for concept_idx in range(len(cos_dist[0] ) ):
																												_a     					=    cos_dist[i][concept_idx]
																												_a     					=    self.concept_embeds_weights[concept_idx].item()
																												_a     					=    round(concept_cos - concept_threshold + adjustment							,      3 )
																												if result_img["concept_scores"][concept_idx] > 0:
																																			result_img["bad_concepts"].append(lowerCAmelCase_ )

																					result.append(lowerCAmelCase_ )

														_a     					=    [len(res['''bad_concepts'''] ) > 0 for res in result]

														return images, has_nsfw_concepts







							@torch.no_grad()
							def        __lowerCAmelCase      (  self	:  List[Any]							,      lowerCAmelCase_	:  torch.FloatTensor							,      lowerCAmelCase_	:  torch.FloatTensor )      ->							List[Any]:


														"""simple docstring"""


														_a     					=    self.vision_model(lowerCAmelCase_ )[1]  # pooled_output
														_a     					=    self.visual_projection(lowerCAmelCase_ )

														_a     					=    cosine_distance(lowerCAmelCase_							,      self.special_care_embeds )
														_a     					=    cosine_distance(lowerCAmelCase_							,      self.concept_embeds )

														# increase this value to create a stronger `nsfw` filter
														# at the cost of increasing the possibility of filtering benign images
														_a     					=    0.0

														_a     					=    special_cos_dist - self.special_care_embeds_weights + adjustment
														# special_scores = special_scores.round(decimals=3)
														_a     					=    torch.any(special_scores > 0							,      dim=1 )
														_a     					=    special_care * 0.0_1
														_a     					=    special_adjustment.unsqueeze(1 ).expand(-1							,      cos_dist.shape[1] )

														_a     					=    (cos_dist - self.concept_embeds_weights) + special_adjustment
														# concept_scores = concept_scores.round(decimals=3)
														_a     					=    torch.any(concept_scores > 0							,      dim=1 )

														return images, has_nsfw_concepts







'''simple docstring'''


import argparse
import math
import traceback

import dateutil.parser as date_parser
import requests
def 		snake_case_   (UpperCamelCase	:  Dict				):





							'''simple docstring'''


							_a     					=    {}

							_a     					=    job['''started_at''']
							_a     					=    job['''completed_at''']

							_a     					=    date_parser.parse(UpperCamelCase				)
							_a     					=    date_parser.parse(UpperCamelCase				)

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

							_a     					=    start
							_a     					=    end
							_a     					=    duration_in_min

							return job_info
def 		snake_case_   (UpperCamelCase	:  int			,						UpperCamelCase	:  int=None				):





							'''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(UpperCamelCase			,						headers=UpperCamelCase				).json()
							_a     					=    {}

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

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

				_snake_case				:				int       							=		get_job_time(args.workflow_run_id)
				_snake_case				:				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']}''')

