
"""simple docstring"""





import json
import os
from datetime import date
from pathlib import Path

from tabulate import DataRow, TableFormat, tabulate


__magic_name__       =			TableFormat(
    lineabove=None,
    linebelowheader=None,
    linebetweenrows=None,
    linebelow=None,
    headerrow=DataRow("", "|", "|"),
    datarow=DataRow("", "|", "|"),
    padding=1,
    with_header_hide=None,
)


__magic_name__       =			[]
__magic_name__       =			[]

__magic_name__       =			{"type": "section", "text": {"type": "plain_text", "text": "No failed tests! 🤗", "emoji": True}}

__magic_name__       =			[
    {
        "type": "header",
        "text": {
            "type": "plain_text",
            "text": F"""🤗 Accelerate nightly {os.environ.get("TEST_TYPE", "")} test results""",
            "emoji": True,
        },
    }
]

__magic_name__       =			0
for log in Path().glob("*.log"):
							__magic_name__       =			0
							with open(log, "r") as f:
														for line in f:
																					__magic_name__       =			json.loads(line)
																					if line.get("nodeid", "") != "":
																												__magic_name__       =			line["nodeid"]
																												if line.get("duration", None) is not None:
																																			__magic_name__       =			F"""{line["duration"]:.4f}"""
																																			if line.get("outcome", "") == "failed":
																																										section_num_failed += 1
																																										failed.append([test, duration, log.name.split("_")[0]])
																																										total_num_failed += 1
							group_info.append([str(log), section_num_failed, failed])
							__magic_name__       =			[]
							log.unlink()

__magic_name__       =			""
__magic_name__       =			[]
if total_num_failed > 0:
							for name, num_failed, failed_tests in group_info:
														if num_failed > 0:
																					if num_failed == 1:
																												message += F"*{name[1:]}: {num_failed} failed test*\n"
																					else:
																												message += F"*{name[1:]}: {num_failed} failed tests*\n"
																					__magic_name__       =			[]
																					__magic_name__       =			{}
																					for test in failed_tests:
																												__magic_name__       =			test[0].split("::")
																												__magic_name__       =			data[0].split("/")[-1]
																												if data[0] not in filesafailed:
																																			__magic_name__       =			[data[1:]]
																												else:
																																			filesafailed[data[0]] += [data[1:]]
																												failed_table.append(data)

																					__magic_name__       =			[test[0] for test in failed_table]
																					__magic_name__       =			list(set(files))
																					# Count number of instances in failed_tests
																					__magic_name__       =			[]
																					for file in individual_files:
																												table.append([file, len(filesafailed[file])])

																					__magic_name__       =			tabulate(
																					    table,
																					    headers=["Test Location", "Num Failed"],
																					    tablefmt=hf_table_format,
																					    stralign="right",
																					)
																					message += F"\n```\n{failed_table}\n```"
																					all_filesafailed.append(filesafailed)
							if len(message) > 3000:
														__magic_name__       =			"Too many failed tests, please see the full report in the Action results."
														__magic_name__       =			len(err) + 10
														__magic_name__       =			message[: 3000 - offset] + F"""\n...\n```\n{err}"""
							print(F"""### {message}""")
else:
							__magic_name__       =			"No failed tests! 🤗"
							print(F"""## {message}""")
							payload.append(no_error_payload)

if os.environ.get("TEST_TYPE", "") != "":
							from slack_sdk import WebClient

							__magic_name__       =			WebClient(token=os.environ["SLACK_API_TOKEN"])
							if message != "No failed tests! 🤗":
														__magic_name__       =			{
														    "type": "section",
														    "text": {
														        "type": "mrkdwn",
														        "text": message,
														    },
														}
														payload.append(md_report)
														__magic_name__       =			{
														    "type": "section",
														    "text": {
														        "type": "mrkdwn",
														        "text": "*For more details:*",
														    },
														    "accessory": {
														        "type": "button",
														        "text": {
														            "type": "plain_text",
														            "text": "Check Action results",
														            "emoji": True,
														        },
														        "url": F"""https://github.com/{os.environ["GITHUB_REPOSITORY"]}/actions/runs/{os.environ["GITHUB_RUN_ID"]}""",
														    },
														}
														payload.append(action_button)
														__magic_name__       =			{
														    "type": "context",
														    "elements": [
														        {
														            "type": "plain_text",
														            "text": F"""Nightly {os.environ.get("TEST_TYPE")} test results for {date.today()}""",
														        }
														    ],
														}
														payload.append(date_report)
							__magic_name__       =			client.chat_postMessage(channel="#accelerate-ci-daily", text=message, blocks=payload)
							__magic_name__       =			response.data["ts"]
							for failed_file in all_filesafailed:
														for test_location, test_failures in failed_file.items():
																					# Keep only the first instance of the test name
																					__magic_name__       =			""
																					for i, row in enumerate(test_failures):
																												if row[0] != test_class:
																																			__magic_name__       =			row[0]
																												else:
																																			__magic_name__       =			""

																					__magic_name__       =			{
																					    "type": "section",
																					    "text": {
																					        "type": "mrkdwn",
																					        "text": F"""Test location: {test_location}\n```\n{tabulate(test_failures, headers=["Class", "Test"], tablefmt=hf_table_format, stralign="right")}\n```""",
																					    },
																					}

																					client.chat_postMessage(
																					    channel="#accelerate-ci-daily",
																					    thread_ts=ts,
																					    blocks=[payload],
																					)






"""simple docstring"""





import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
from ...utils import logging
from ..auto import CONFIG_MAPPING


__magic_name__       =			logging.get_logger(__name__)

__magic_name__       =			{
    "salesforce/blip2-opt-2.7b": "https://huggingface.co/salesforce/blip2-opt-2.7b/resolve/main/config.json",
}
class 						SCREAMING_SNAKE_CASE_ (						__a ):




		"""simple docstring"""





		__lowercase							:  Optional[Any]						   =		'''blip_2_vision_model'''




		def __init__(     self							,  lowerCAmelCase__=1_4_0_8							,  lowerCAmelCase__=6_1_4_4							,  lowerCAmelCase__=3_9							,  lowerCAmelCase__=1_6							,  lowerCAmelCase__=2_2_4							,  lowerCAmelCase__=1_4							,  lowerCAmelCase__="gelu"							,  lowerCAmelCase__=0.0_00_01							,  lowerCAmelCase__=0.0							,  lowerCAmelCase__=1E-10							,  lowerCAmelCase__=True							,  **lowerCAmelCase__							,  ):
				super().__init__(**lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = hidden_size
				__SCREAMING_SNAKE_CASE            = intermediate_size
				__SCREAMING_SNAKE_CASE            = num_hidden_layers
				__SCREAMING_SNAKE_CASE            = num_attention_heads
				__SCREAMING_SNAKE_CASE            = patch_size
				__SCREAMING_SNAKE_CASE            = image_size
				__SCREAMING_SNAKE_CASE            = initializer_range
				__SCREAMING_SNAKE_CASE            = attention_dropout
				__SCREAMING_SNAKE_CASE            = layer_norm_eps
				__SCREAMING_SNAKE_CASE            = hidden_act
				__SCREAMING_SNAKE_CASE            = qkv_bias




		@classmethod
		def 	snake_case_     (     cls							,  lowerCAmelCase__							,  **lowerCAmelCase__):
				cls._set_token_in_kwargs(lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = cls.get_config_dict(lowerCAmelCase__							,  **lowerCAmelCase__)

				# get the vision config dict if we are loading from Blip2Config
				if config_dict.get("""model_type""") == "blip-2":
						__SCREAMING_SNAKE_CASE            = config_dict["""vision_config"""]

				if "model_type" in config_dict and hasattr(cls							,  """model_type""") and config_dict["model_type"] != cls.model_type:
						logger.warning(
						    f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
						    f"{cls.model_type}. This is not supported for all configurations of models and can yield errors.")

				return cls.from_dict(lowerCAmelCase__							,  **lowerCAmelCase__)



class 						SCREAMING_SNAKE_CASE_ (						__a ):




		"""simple docstring"""





		__lowercase							:  Tuple						   =		'''blip_2_qformer'''




		def __init__(     self							,  lowerCAmelCase__=3_0_5_2_2							,  lowerCAmelCase__=7_6_8							,  lowerCAmelCase__=1_2							,  lowerCAmelCase__=1_2							,  lowerCAmelCase__=3_0_7_2							,  lowerCAmelCase__="gelu"							,  lowerCAmelCase__=0.1							,  lowerCAmelCase__=0.1							,  lowerCAmelCase__=5_1_2							,  lowerCAmelCase__=0.02							,  lowerCAmelCase__=1E-12							,  lowerCAmelCase__=0							,  lowerCAmelCase__="absolute"							,  lowerCAmelCase__=2							,  lowerCAmelCase__=1_4_0_8							,  **lowerCAmelCase__							,  ):
				super().__init__(pad_token_id=lowerCAmelCase__							,  **lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = vocab_size
				__SCREAMING_SNAKE_CASE            = hidden_size
				__SCREAMING_SNAKE_CASE            = num_hidden_layers
				__SCREAMING_SNAKE_CASE            = num_attention_heads
				__SCREAMING_SNAKE_CASE            = hidden_act
				__SCREAMING_SNAKE_CASE            = intermediate_size
				__SCREAMING_SNAKE_CASE            = hidden_dropout_prob
				__SCREAMING_SNAKE_CASE            = attention_probs_dropout_prob
				__SCREAMING_SNAKE_CASE            = max_position_embeddings
				__SCREAMING_SNAKE_CASE            = initializer_range
				__SCREAMING_SNAKE_CASE            = layer_norm_eps
				__SCREAMING_SNAKE_CASE            = position_embedding_type
				__SCREAMING_SNAKE_CASE            = cross_attention_frequency
				__SCREAMING_SNAKE_CASE            = encoder_hidden_size




		@classmethod
		def 	snake_case_     (     cls							,  lowerCAmelCase__							,  **lowerCAmelCase__):
				cls._set_token_in_kwargs(lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = cls.get_config_dict(lowerCAmelCase__							,  **lowerCAmelCase__)

				# get the qformer config dict if we are loading from Blip2Config
				if config_dict.get("""model_type""") == "blip-2":
						__SCREAMING_SNAKE_CASE            = config_dict["""qformer_config"""]

				if "model_type" in config_dict and hasattr(cls							,  """model_type""") and config_dict["model_type"] != cls.model_type:
						logger.warning(
						    f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
						    f"{cls.model_type}. This is not supported for all configurations of models and can yield errors.")

				return cls.from_dict(lowerCAmelCase__							,  **lowerCAmelCase__)



class 						SCREAMING_SNAKE_CASE_ (						__a ):




		"""simple docstring"""





		__lowercase							:  Optional[Any]						   =		'''blip-2'''
		__lowercase							:  Any						   =		True




		def __init__(     self							,  lowerCAmelCase__=None							,  lowerCAmelCase__=None							,  lowerCAmelCase__=None							,  lowerCAmelCase__=3_2							,  **lowerCAmelCase__):
				super().__init__(**lowerCAmelCase__)

				if vision_config is None:
						__SCREAMING_SNAKE_CASE            = {}
						logger.info("""vision_config is None. initializing the Blip2VisionConfig with default values.""")

				if qformer_config is None:
						__SCREAMING_SNAKE_CASE            = {}
						logger.info("""qformer_config is None. Initializing the Blip2QFormerConfig with default values.""")

				if text_config is None:
						__SCREAMING_SNAKE_CASE            = {}
						logger.info("""text_config is None. Initializing the text config with default values (`OPTConfig`).""")

				__SCREAMING_SNAKE_CASE            = BlipaVisionConfig(**lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = BlipaQFormerConfig(**lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = text_config["""model_type"""] if """model_type""" in text_config else """opt"""
				__SCREAMING_SNAKE_CASE            = CONFIG_MAPPING[text_model_type](**lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = self.text_config.tie_word_embeddings
				__SCREAMING_SNAKE_CASE            = self.text_config.is_encoder_decoder

				__SCREAMING_SNAKE_CASE            = num_query_tokens
				__SCREAMING_SNAKE_CASE            = self.vision_config.hidden_size
				__SCREAMING_SNAKE_CASE            = self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
				__SCREAMING_SNAKE_CASE            = 1.0
				__SCREAMING_SNAKE_CASE            = 0.02




		@classmethod
		def 	snake_case_     (     cls							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  **lowerCAmelCase__							,  ):
				return cls(
				    vision_config=vision_config.to_dict()							,  qformer_config=qformer_config.to_dict()							,  text_config=text_config.to_dict()							,  **lowerCAmelCase__							,  )




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = copy.deepcopy(self.__dict__)
				__SCREAMING_SNAKE_CASE            = self.vision_config.to_dict()
				__SCREAMING_SNAKE_CASE            = self.qformer_config.to_dict()
				__SCREAMING_SNAKE_CASE            = self.text_config.to_dict()
				__SCREAMING_SNAKE_CASE            = self.__class__.model_type
				return output




