





import json
import multiprocessing
import os
import re
from collections import defaultdict

import torch
from accelerate import Accelerator
from accelerate.utils import set_seed
from arguments import HumanEvalArguments
from datasets import load_dataset, load_metric
from torch.utils.data import IterableDataset
from torch.utils.data.dataloader import DataLoader
from tqdm import tqdm

import transformers
from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser, StoppingCriteria, StoppingCriteriaList


_UpperCamelCase				=       ['''\nclass''', '''\ndef''', '''\n#''', '''\n@''', '''\nprint''', '''\nif''']




class  _lowerCamelCase       (			a			):



      """simple docstring"""






      def __init__(       self ,  UpperCAmelCase ,  UpperCAmelCase ,  UpperCAmelCase=None ,  UpperCAmelCase=1      )				->      List[Any]:






        '''simple docstring'''






        __snake_case      : Optional[Any]						=				tokenizer
        __snake_case      : Any						=				dataset
        __snake_case      : Optional[int]						=				len(UpperCAmelCase__      ) if n_tasks is None else n_tasks
        __snake_case      : List[Any]						=				n_copies







      def __iter__(       self      )				->      Tuple:






        '''simple docstring'''






        __snake_case      : Any						=				[]
        for task in range(self.n_tasks      ):
          # without strip, the model generate commented codes ...
          prompts.append(self.tokenizer.eos_token + self.dataset[task]["prompt"].strip()      )
        __snake_case      : Dict						=				self.tokenizer(UpperCAmelCase__ ,  padding=UpperCAmelCase__ ,  return_tensors="pt"      )
        for task in range(self.n_tasks      ):
          for _ in range(self.n_copies      ):
            yield {
                "ids": outputs.input_ids[task],
                "task_id": task,
                "input_len": outputs.attention_mask[task].sum(),
            }




class  _lowerCamelCase       (			a			):



      """simple docstring"""






      def __init__(       self ,  UpperCAmelCase ,  UpperCAmelCase ,  UpperCAmelCase      )				->      Optional[int]:






        '''simple docstring'''






        __snake_case      : str						=				start_length
        __snake_case      : List[str]						=				eof_strings
        __snake_case      : str						=				tokenizer







      def __call__(       self ,  UpperCAmelCase ,  UpperCAmelCase ,  **UpperCAmelCase      )				->      List[str]:






        '''simple docstring'''






        __snake_case      : Dict						=				self.tokenizer.batch_decode(input_ids[:, self.start_length :]      )
        __snake_case      : List[Any]						=				[]
        for decoded_generation in decoded_generations:
          done.append(any(stop_string in decoded_generation for stop_string in self.eof_strings      )      )
        return all(UpperCAmelCase__      )







def 					lowerCAmelCase__(		lowercase				:			List[Any] )       ->			int:
  __snake_case      : List[str]						=				re.split("(%s)" % "|".join(UpperCamelCase_ )      ,   UpperCamelCase_ )
  # last string should be ""
  return "".join(string_list[:-2] )







def 					lowerCAmelCase__(		lowercase				:			Dict      ,   lowercase				:			Dict      ,   lowercase				:			Tuple      ,   lowercase				:			Optional[Any]      ,   lowercase				:			Union[str, Any]      ,   lowercase				:			List[Any]=20      ,   **lowercase				:			int )       ->			int:
  __snake_case      : List[Any]						=				defaultdict(UpperCamelCase_ )  # dict of list of generated tokens
  for step, batch in tqdm(enumerate(UpperCamelCase_ ) ):
    with torch.no_grad():
      __snake_case      : Optional[Any]						=				batch["ids"].shape[-1]
      __snake_case      : int						=				accelerator.unwrap_model(UpperCamelCase_ ).generate(
          input_ids=batch["ids"][:, : batch["input_len"]]      ,   num_return_sequences=UpperCamelCase_      ,   **UpperCamelCase_ )
      # each task is generated batch_size times
      __snake_case      : Dict						=				batch["task_id"].repeat(UpperCamelCase_ )
      __snake_case      : List[str]						=				accelerator.pad_across_processes(
          UpperCamelCase_      ,   dim=1      ,   pad_index=tokenizer.pad_token_id )

      __snake_case			,      __snake_case      : Tuple						=				accelerator.gather((generated_tokens, generated_tasks) )
      __snake_case      : Tuple						=				generated_tokens.cpu().numpy()
      __snake_case      : int						=				generated_tasks.cpu().numpy()

      for task, generated_tokens in zip(UpperCamelCase_      ,   UpperCamelCase_ ):
        gen_token_dict[task].append(UpperCamelCase_ )

  __snake_case      : Dict						=				[[] for _ in range(UpperCamelCase_ )]
  for task, generated_tokens in gen_token_dict.items():
    for s in generated_tokens:
      __snake_case      : Optional[int]						=				tokenizer.decode(UpperCamelCase_      ,   skip_special_tokens=UpperCamelCase_      ,   clean_up_tokenization_spaces=UpperCamelCase_ )
      code_gens[task].append(remove_last_block(UpperCamelCase_ ) )
  return code_gens







def 					lowerCAmelCase__(		)       ->			Dict:
  __snake_case      : Any						=				HfArgumentParser(UpperCamelCase_ )
  __snake_case      : Any						=				parser.parse_args()

  transformers.logging.set_verbosity_error()
  # enables code execution in code_eval metric
  __snake_case      : Tuple						=				args.HF_ALLOW_CODE_EVAL
  # make sure tokenizer plays nice with multiprocessing
  __snake_case      : Optional[int]						=				"false"

  if args.num_workers is None:
    __snake_case      : Optional[int]						=				multiprocessing.cpu_count()

  # Use dataset load to feed to accelerate
  __snake_case      : str						=				Accelerator()
  set_seed(args.seed      ,   device_specific=UpperCamelCase_ )

  # Load model and tokenizer
  __snake_case      : str						=				AutoTokenizer.from_pretrained(args.model_ckpt )
  __snake_case      : Optional[Any]						=				tokenizer.eos_token
  __snake_case      : Union[str, Any]						=				AutoModelForCausalLM.from_pretrained(args.model_ckpt )

  # Generation settings
  __snake_case      : Dict						=				{
      "do_sample": args.do_sample,
      "temperature": args.temperature,
      "max_new_tokens": args.max_new_tokens,
      "top_p": args.top_p,
      "top_k": args.top_k,
      "stopping_criteria": StoppingCriteriaList([EndOfFunctionCriteria(0      ,   UpperCamelCase_      ,   UpperCamelCase_ )] ),
  }

  # Load evaluation dataset and metric
  __snake_case      : Tuple						=				load_dataset("openai_humaneval" )
  __snake_case      : List[str]						=				load_metric("code_eval" )

  __snake_case      : List[str]						=				args.num_tasks if args.num_tasks is not None else len(human_eval["test"] )
  __snake_case      : int						=				args.n_samples // args.batch_size

  __snake_case      : Optional[int]						=				TokenizedDataset(UpperCamelCase_      ,   human_eval["test"]      ,   n_copies=UpperCamelCase_      ,   n_tasks=UpperCamelCase_ )
  # do not confuse args.batch_size, which is actually the num_return_sequences
  __snake_case      : Any						=				DataLoader(UpperCamelCase_      ,   batch_size=1 )

  # Run a quick test to see if code evaluation is enabled
  try:
    __snake_case      : Dict						=				code_eval_metric.compute(references=[""]      ,   predictions=[[""]] )
  except ValueError as exception:
    print(
        "Code evaluation not enabled. Read the warning below carefully and then use `--HF_ALLOW_CODE_EVAL=\"1\"`"
        " flag to enable code evaluation." )
    raise exception

  __snake_case			,      __snake_case      : Tuple						=				accelerator.prepare(UpperCamelCase_      ,   UpperCamelCase_ )

  __snake_case      : Dict						=				complete_code(
      UpperCamelCase_      ,   UpperCamelCase_      ,   UpperCamelCase_      ,   UpperCamelCase_      ,   n_tasks=UpperCamelCase_      ,   batch_size=args.batch_size      ,   **UpperCamelCase_      ,   )

  if accelerator.is_main_process:
    __snake_case      : List[Any]						=				[]

    for task in tqdm(range(UpperCamelCase_ ) ):
      __snake_case      : Tuple						=				human_eval["test"][task]["test"]
      __snake_case      : Optional[Any]						=				f"""check({human_eval["test"][task]["entry_point"]})"""
      references.append("\n" + test_func + "\n" + entry_point )

    # Evaluate completions with "code_eval" metric
    __snake_case			,      __snake_case      : int						=				code_eval_metric.compute(
        references=UpperCamelCase_      ,   predictions=UpperCamelCase_      ,   num_workers=args.num_workers )
    print(f"""Results: {pass_at_k}""" )

    # Save results to json file
    with open(args.output_file      ,   "w" ) as fp:
      json.dump(UpperCamelCase_      ,   UpperCamelCase_ )


# For some reason the folliwng seems to be necessary sometimes for code_eval to work nice with multiprocessing
# https://stackoverflow.com/questions/60804599/python-multiprocessing-keeps-spawning-the-whole-script
if __name__ == "__main__":
     main()




"""simple docstring"""





import argparse
import json
import os
import re
import shutil

import torch

from transformers import BioGptConfig, BioGptForCausalLM
from transformers.models.biogpt.tokenization_biogpt import VOCAB_FILES_NAMES
from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE
from transformers.utils import WEIGHTS_NAME, logging


logging.set_verbosity_warning()

_a       =							2




class 					_lowerCAmelCase  :







 """simple docstring"""







 def __init__(			self							:			Dict,					*,  # begin keyword-only arguments
     UpperCAmelCase__							:			str="<s>",					UpperCAmelCase__							:			Tuple="<pad>",					UpperCAmelCase__							:			str="</s>",					UpperCAmelCase__							:			Optional[Any]="<unk>",					UpperCAmelCase__							:			List[Any]=None,					):
    __lowercase		,__lowercase		,__lowercase		,__lowercase								=						bos, unk, pad, eos
    __lowercase								=						[]
    __lowercase								=						[]
    __lowercase								=						{}
    __lowercase								=						self.add_symbol(UpperCAmelCase__	)
    __lowercase								=						self.add_symbol(UpperCAmelCase__	)
    __lowercase								=						self.add_symbol(UpperCAmelCase__	)
    __lowercase								=						self.add_symbol(UpperCAmelCase__	)
    if extra_special_symbols:
       for s in extra_special_symbols:
          self.add_symbol(UpperCAmelCase__	)
    __lowercase								=						len(self.symbols	)


 def __eq__(			self							:			List[str],					UpperCAmelCase__							:			Dict	):
    return self.indices == other.indices


 def __getitem__(			self							:			Optional[int],					UpperCAmelCase__							:			List[str]	):
    if idx < len(self.symbols	):
       return self.symbols[idx]
    return self.unk_word


 def __len__(			self							:			str	):
    return len(self.symbols	)


 def __contains__(			self							:			Any,					UpperCAmelCase__							:			Optional[Any]	):
    return sym in self.indices


 @classmethod
 def 					_lowercase (			cls							:			List[Any],					UpperCAmelCase__							:			Optional[Any]	):
    __lowercase								=						cls()
    d.add_from_file(UpperCAmelCase__	)
    return d


 def 					_lowercase (			self							:			Dict,					UpperCAmelCase__							:			Optional[Any],					UpperCAmelCase__							:			List[Any]=1,					UpperCAmelCase__							:			str=False	):
    if word in self.indices and not overwrite:
       __lowercase								=						self.indices[word]
       __lowercase								=						self.count[idx] + n
       return idx
    else:
       __lowercase								=						len(self.symbols	)
       __lowercase								=						idx
       self.symbols.append(UpperCAmelCase__	)
       self.count.append(UpperCAmelCase__	)
       return idx


 def 					_lowercase (			self							:			Any,					UpperCAmelCase__							:			str	):
    return 0



 def 					_lowercase (			self							:			Tuple,					UpperCAmelCase__							:			List[Any]	):
    if isinstance(UpperCAmelCase__,					UpperCAmelCase__	):
       try:
          with open(UpperCAmelCase__,					"r",					encoding="utf-8"	) as fd:
             self.add_from_file(UpperCAmelCase__	)
       except FileNotFoundError as fnfe:
          raise fnfe
       except UnicodeError:
          raise Exception("Incorrect encoding detected in {}, please rebuild the dataset".format(UpperCAmelCase__	)	)
       return

    __lowercase								=						f.readlines()
    __lowercase								=						self._load_meta(UpperCAmelCase__	)

    for line in lines[indices_start_line:]:
       try:
          __lowercase		,__lowercase								=						line.rstrip().rsplit(" ",					1	)
          if field == "#fairseq:overwrite":
             __lowercase								=						True
             __lowercase		,__lowercase								=						line.rsplit(" ",					1	)
          else:
             __lowercase								=						False
          __lowercase								=						int(UpperCAmelCase__	)
          __lowercase								=						line
          if word in self and not overwrite:
             raise RuntimeError(
                 "Duplicate word found when loading Dictionary: '{}'. "
                 "Duplicate words can overwrite earlier ones by adding the "
                 "#fairseq:overwrite flag at the end of the corresponding row "
                 "in the dictionary file. If using the Camembert model, please "
                 "download an updated copy of the model file.".format(UpperCAmelCase__	)	)
          self.add_symbol(UpperCAmelCase__,					n=UpperCAmelCase__,					overwrite=UpperCAmelCase__	)
       except ValueError:
          raise ValueError("Incorrect dictionary format, expected '<token> <cnt> [flags]'"	)







def   _A  (  UpperCamelCase_     :       int)	->						str:
   '''simple docstring'''


   __lowercase								=						dict((re.sub(r"@@$",			"",			UpperCamelCase_), v) if k.endswith("@@") else (re.sub(r"$",			"</w>",			UpperCamelCase_), v) for k, v in d.items())
   __lowercase								=						"<s> <pad> </s> <unk>".split()
   # restore the special tokens
   for k in keep_keys:
      del da[F"""{k}</w>"""]
      __lowercase								=						d[k]  # restore
   return da




def   _A  (  UpperCamelCase_     :       str,			UpperCamelCase_     :       str)	->						List[Any]:
   '''simple docstring'''


   if not os.path.exists(UpperCamelCase_):
      raise ValueError(F"""path {biogpt_checkpoint_path} does not exist!""")
   os.makedirs(UpperCamelCase_,			exist_ok=UpperCamelCase_)
   print(F"""Writing results to {pytorch_dump_folder_path}""")

   # handle various types of models

   __lowercase								=						os.path.join(UpperCamelCase_,			"checkpoint.pt")
   if not os.path.isfile(UpperCamelCase_):
      raise ValueError(F"""path to the file {checkpoint_file} does not exist!""")
   __lowercase								=						torch.load(UpperCamelCase_,			map_location="cpu")

   __lowercase								=						chkpt["cfg"]["model"]

   # dicts
   __lowercase								=						os.path.join(UpperCamelCase_,			"dict.txt")
   if not os.path.isfile(UpperCamelCase_):
      raise ValueError(F"""path to the file {dict_file} does not exist!""")
   __lowercase								=						Dictionary.load(UpperCamelCase_)
   __lowercase								=						rewrite_dict_keys(src_dict.indices)
   __lowercase								=						len(UpperCamelCase_)
   __lowercase								=						os.path.join(UpperCamelCase_,			VOCAB_FILES_NAMES["vocab_file"])
   print(F"""Generating {src_vocab_file} of {src_vocab_size} records""")
   with open(UpperCamelCase_,			"w",			encoding="utf-8") as f:
      f.write(json.dumps(UpperCamelCase_,			ensure_ascii=UpperCamelCase_,			indent=UpperCamelCase_))

   # merges_file (bpecodes)
   __lowercase								=						os.path.join(UpperCamelCase_,			"bpecodes")
   if not os.path.isfile(UpperCamelCase_):
      raise ValueError(F"""path to the file {bpecodes_file} does not exist!""")

   __lowercase								=						os.path.join(UpperCamelCase_,			VOCAB_FILES_NAMES["merges_file"])
   shutil.copyfile(UpperCamelCase_,			UpperCamelCase_)

   # model config
   __lowercase								=						os.path.join(UpperCamelCase_,			"config.json")

   __lowercase								=						{
       "activation_dropout": args["activation_dropout"],
       "architectures": ["BioGptForCausalLM"],
       "attention_probs_dropout_prob": args["attention_dropout"],
       "bos_token_id": 0,
       "eos_token_id": 2,
       "hidden_act": args["activation_fn"],
       "hidden_dropout_prob": args["dropout"],
       "hidden_size": args["decoder_embed_dim"],
       "initializer_range": 0.02,
       "intermediate_size": args["decoder_ffn_embed_dim"],
       "layer_norm_eps": 1E-12,
       "layerdrop": args["decoder_layerdrop"],
       "max_position_embeddings": args["max_target_positions"],
       "model_type": "biogpt",
       "num_attention_heads": args["decoder_attention_heads"],
       "num_hidden_layers": args["decoder_layers"],
       "pad_token_id": 1,
       "scale_embedding": not args["no_scale_embedding"],
       "tie_word_embeddings": args["share_decoder_input_output_embed"],
       "vocab_size": src_vocab_size,
   }

   # good hparam defaults to start with

   print(F"""Generating {biogpt_model_config_file}""")
   with open(UpperCamelCase_,			"w",			encoding="utf-8") as f:
      f.write(json.dumps(UpperCamelCase_,			ensure_ascii=UpperCamelCase_,			indent=UpperCamelCase_))

   # tokenizer config
   __lowercase								=						os.path.join(UpperCamelCase_,			UpperCamelCase_)

   __lowercase								=						{
       "bos_token": "<s>",
       "eos_token": "</s>",
       "model_max_length": 1024,
       "pad_token": "<pad>",
       "special_tokens_map_file": None,
       "tokenizer_class": "BioGptTokenizer",
       "unk_token": "<unk>",
   }

   print(F"""Generating {biogpt_tokenizer_config_file}""")
   with open(UpperCamelCase_,			"w",			encoding="utf-8") as f:
      f.write(json.dumps(UpperCamelCase_,			ensure_ascii=UpperCamelCase_,			indent=UpperCamelCase_))

   # model
   __lowercase								=						chkpt["model"]

   # remove unneeded keys
   __lowercase								=						[
       "decoder.version",
   ]
   for k in ignore_keys:
      model_state_dict.pop(UpperCamelCase_,			UpperCamelCase_)

   __lowercase								=						list(model_state_dict.keys())
   for layer_name in layer_names:
      if layer_name.endswith("output_projection.weight"):
         __lowercase								=						model_state_dict.pop(UpperCamelCase_)
      else:
         __lowercase								=						model_state_dict.pop(UpperCamelCase_)

   __lowercase								=						BioGptConfig.from_pretrained(UpperCamelCase_)
   __lowercase								=						BioGptForCausalLM(UpperCamelCase_)

   # check that it loads ok
   model_new.load_state_dict(UpperCamelCase_)

   # save
   __lowercase								=						os.path.join(UpperCamelCase_,			UpperCamelCase_)
   print(F"""Generating {pytorch_weights_dump_path}""")
   torch.save(UpperCamelCase_,			UpperCamelCase_)

   print("Conversion is done!")


if __name__ == "__main__":
   _a       =							argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '--biogpt_checkpoint_path',
       default=None,
       type=str,
       required=True,
       help=(
           'Path to the official PyTorch checkpoint file which is expected to reside in the dump dir with dicts,'
           ' bpecodes, etc.'
       ),
   )
   parser.add_argument(
       '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
   )
   _a       =							parser.parse_args()
   convert_biogpt_checkpoint_to_pytorch(args.biogpt_checkpoint_path, args.pytorch_dump_folder_path)




