




'''simple docstring'''





from dataclasses import dataclass, field
from typing import Optional

from transformers import AutoConfig, AutoImageProcessor, AutoTokenizer, FlaxVisionEncoderDecoderModel, HfArgumentParser






@dataclass
class  __magic_name__						:
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							Union[str, Any]	      =					field(
				    metadata={"help": "The output directory where the model will be written."}    ,  )
				SCREAMING_SNAKE_CASE__					:							str	      =					field(
				    metadata={
				        "help": (
				            "The encoder model checkpoint for weights initialization."
				            "Don't set if you want to train an encoder model from scratch."
				        )
				    }    ,  )
				SCREAMING_SNAKE_CASE__					:							str	      =					field(
				    metadata={
				        "help": (
				            "The decoder model checkpoint for weights initialization."
				            "Don't set if you want to train a decoder model from scratch."
				        )
				    }    ,  )
				SCREAMING_SNAKE_CASE__					:							Any	      =					field(
				    default=UpperCAmelCase_    ,  metadata={"help": "Pretrained encoder config name or path if not the same as encoder_model_name"})
				SCREAMING_SNAKE_CASE__					:							Dict	      =					field(
				    default=UpperCAmelCase_    ,  metadata={"help": "Pretrained decoder config name or path if not the same as decoder_model_name"})






def 			a   ():
							SCREAMING_SNAKE_CASE_   	=    HfArgumentParser((ModelArguments,)     )
							((SCREAMING_SNAKE_CASE_ )	,	 )   	=    parser.parse_args_into_dataclasses()

							# Load pretrained model and tokenizer

							# Use explicit specified encoder config
							if model_args.encoder_config_name:
														SCREAMING_SNAKE_CASE_   	=    AutoConfig.from_pretrained(model_args.encoder_config_name     )
							# Use pretrained encoder model's config
							else:
														SCREAMING_SNAKE_CASE_   	=    AutoConfig.from_pretrained(model_args.encoder_model_name_or_path     )

							# Use explicit specified decoder config
							if model_args.decoder_config_name:
														SCREAMING_SNAKE_CASE_   	=    AutoConfig.from_pretrained(model_args.decoder_config_name     )
							# Use pretrained decoder model's config
							else:
														SCREAMING_SNAKE_CASE_   	=    AutoConfig.from_pretrained(model_args.decoder_model_name_or_path     )

							# necessary for `from_encoder_decoder_pretrained` when `decoder_config` is passed
							SCREAMING_SNAKE_CASE_   	=    True
							SCREAMING_SNAKE_CASE_   	=    True

							SCREAMING_SNAKE_CASE_   	=    FlaxVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
							    encoder_pretrained_model_name_or_path=model_args.encoder_model_name_or_path  ,    decoder_pretrained_model_name_or_path=model_args.decoder_model_name_or_path  ,    encoder_config=UpperCamelCase__  ,    decoder_config=UpperCamelCase__  ,    )

							# GPT2 only has bos/eos tokens but not decoder_start/pad tokens
							SCREAMING_SNAKE_CASE_   	=    decoder_config.decoder_start_token_id
							SCREAMING_SNAKE_CASE_   	=    decoder_config.pad_token_id
							if decoder_start_token_id is None:
														SCREAMING_SNAKE_CASE_   	=    decoder_config.bos_token_id
							if pad_token_id is None:
														SCREAMING_SNAKE_CASE_   	=    decoder_config.eos_token_id

							# This is necessary to make Flax's generate() work
							SCREAMING_SNAKE_CASE_   	=    decoder_config.eos_token_id
							SCREAMING_SNAKE_CASE_   	=    decoder_start_token_id
							SCREAMING_SNAKE_CASE_   	=    pad_token_id

							SCREAMING_SNAKE_CASE_   	=    AutoImageProcessor.from_pretrained(model_args.encoder_model_name_or_path     )

							SCREAMING_SNAKE_CASE_   	=    AutoTokenizer.from_pretrained(model_args.decoder_model_name_or_path     )
							SCREAMING_SNAKE_CASE_   	=    tokenizer.convert_ids_to_tokens(model.config.pad_token_id     )

							model.save_pretrained(model_args.output_dir     )
							image_processor.save_pretrained(model_args.output_dir     )
							tokenizer.save_pretrained(model_args.output_dir     )


if __name__ == "__main__":
			main()








import requests

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase     ):
							SCREAMING_SNAKE_CASE_   	=    {'''Content-Type''': '''application/json'''}
							SCREAMING_SNAKE_CASE_   	=    requests.post(_lowerCAmelCase  ,    json={'''text''': message_body}  ,    headers=_lowerCAmelCase     )
							if response.status_code != 2_0_0:
														SCREAMING_SNAKE_CASE_   	=    (
														    '''Request to slack returned an error '''
														    F"{response.status_code}, the response is:\n{response.text}"
														)
														raise ValueError(_lowerCAmelCase     )


if __name__ == "__main__":
			# Set the slack url to the one provided by Slack when you create the webhook at
			# https://my.slack.com/services/new/incoming-webhook/
			send_slack_message("""<YOUR MESSAGE BODY>""", """<SLACK CHANNEL URL>""")


