code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  import numpy as np
  import torch
  import torch.nn as nn
  from transformers import CLIPConfig, CLIPVisionModel, PreTrainedModel
  
  from ...utils import logging
  
  
  _lowerCamelCase				:	List[str]				    =       logging.get_logger(__name__)
  
  
  
  
  def    __a (     UpperCAmelCase       ,			UpperCAmelCase    )      ->Optional[int]:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	A							  =      nn.functional.normalize(UpperCAmelCase    )
  	A							  =      nn.functional.normalize(UpperCAmelCase    )
  	return torch.mm(UpperCAmelCase       ,			normalized_text_embeds.t()    )
  
  
  
  class 							__UpperCAmelCase  (       A__						):
  
  
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowerCAmelCase 				=    CLIPConfig
  
  		__lowerCAmelCase 				=    ['''CLIPEncoderLayer''']
  
  
  
  
  
  
  
  		def __init__(self						:      List[str]      ,      _lowerCAmelCase						:      CLIPConfig      ):
  			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        A     (self						:      Optional[Any]      ,      _lowerCAmelCase						:      int      ,      _lowerCAmelCase						:      Dict      ):
  			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.01
  
  				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]
  
  			for idx, has_nsfw_concept in enumerate(_lowerCAmelCase      ):
  				if has_nsfw_concept:
  					if torch.is_tensor(_lowerCAmelCase      ) or torch.is_tensor(images[0]      ):
  						A							  =      torch.zeros_like(images[idx]      )  # black image
  					else:
  						A							  =      np.zeros(images[idx].shape      )  # black image
  
  			if any(_lowerCAmelCase      ):
  				logger.warning(
  				    """Potential NSFW content was detected in one or more images. A black image will be returned instead."""
  				    """ Try again with a different prompt and/or seed."""      )
  
  			return images, has_nsfw_concepts
  
  
  
  
  
  
  
  		@torch.no_grad()
  		def        A     (self						:      Tuple      ,      _lowerCAmelCase						:      torch.FloatTensor      ,      _lowerCAmelCase						:      torch.FloatTensor      ):
  			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.01
  			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      )
  
  			A							  =      0.0  # black image
  
  			return images, has_nsfw_concepts
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  import hashlib
  import importlib.util
  import json
  import os
  import pathlib
  from types import ModuleType
  
  import pytest
  import requests
  
  _lowerCamelCase				:	Optional[Any]				    =       pathlib.Path.cwd().joinpath('project_euler')
  _lowerCamelCase				:	Optional[int]				    =       pathlib.Path.cwd().joinpath(
      'scripts', 'project_euler_answers.json'
  )
  
  with open(PROJECT_EULER_ANSWERS_PATH) as file_handle:
  				_lowerCamelCase				:	dict[str, str]				    =       json.load(file_handle)
  
  
  
  
  def    __a (     UpperCAmelCase    )      ->ModuleType:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	A							  =      importlib.util.spec_from_file_location(file_path.name       ,			str(UpperCAmelCase    )    )
  	A							  =      importlib.util.module_from_spec(UpperCAmelCase    )  # type: ignore
  	spec.loader.exec_module(UpperCAmelCase    )  # type: ignore
  	return module
  
  
  
  
  def    __a (     )      ->list[pathlib.Path]:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	A							  =      []
  	for problem_dir_path in PROJECT_EULER_DIR_PATH.iterdir():
  		if problem_dir_path.is_file() or problem_dir_path.name.startswith("""_"""    ):
  			continue
  		for file_path in problem_dir_path.iterdir():
  			if file_path.suffix != ".py" or file_path.name.startswith(("""_""", """test""")    ):
  				continue
  			solution_file_paths.append(UpperCAmelCase    )
  	return solution_file_paths
  
  
  
  
  def    __a (     )      ->str:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	with open(os.environ["""GITHUB_EVENT_PATH"""]    ) as file:
  		A							  =      json.load(UpperCAmelCase    )
  	return event["pull_request"]["url"] + "/files"
  
  
  
  
  def    __a (     )      ->list[pathlib.Path]:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	A							  =      []
  	A							  =      {
  	    """Accept""": """application/vnd.github.v3+json""",
  	    """Authorization""": """token """ + os.environ["""GITHUB_TOKEN"""],
  	}
  	A							  =      requests.get(get_files_url()       ,			headers=UpperCAmelCase    ).json()
  	for file in files:
  		A							  =      pathlib.Path.cwd().joinpath(file["""filename"""]    )
  		if (
  		    filepath.suffix != ".py"
  		    or filepath.name.startswith(("""_""", """test""")    )
  		    or not filepath.name.startswith("""sol"""    )
  		):
  			continue
  		solution_file_paths.append(UpperCAmelCase    )
  	return solution_file_paths
  
  
  
  
  def    __a (     )      ->list[pathlib.Path]:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	if os.environ.get("""CI"""    ) and os.environ.get("""GITHUB_EVENT_NAME"""    ) == "pull_request":
  		# Return only if there are any, otherwise default to all solutions
  		if filepaths := added_solution_file_path():
  			return filepaths
  	return all_solution_file_paths()
  
  
  
  
  @pytest.mark.parametrize(
      """solution_path"""       ,			collect_solution_file_paths()       ,			ids=lambda UpperCAmelCase    : f"""{path.parent.name}/{path.name}"""       ,			)
  def    __a (     UpperCAmelCase    )      ->None:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	A							  =      solution_path.parent.name[8:].zfill(3    )
  	A							  =      PROBLEM_ANSWERS[problem_number]
  	A							  =      convert_path_to_module(UpperCAmelCase    )
  	A							  =      str(solution_module.solution()    )  # type: ignore
  	A							  =      hashlib.shaaaa(answer.encode()    ).hexdigest()
  	assert (
  	    answer == expected
  	), f"""Expected solution to {problem_number} to have hash {expected}, got {answer}"""
  
  