






'''simple docstring'''
import argparse
import os
import pickle
import sys

import torch

from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils
from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

# We do this to be able to load python 2 datasets pickles
# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
a_					=	data_utils.TransfoXLTokenizer
a_					=	data_utils.TransfoXLCorpus
a_					=	data_utils
a_					=	data_utils





def 	_a(					UpperCamelCase__			:  str,		UpperCamelCase__			:  Optional[Any],		UpperCamelCase__			:  Optional[Any],		UpperCamelCase__			:  Optional[Any]							):




						'''simple docstring'''






						if transfo_xl_dataset_file:
												# Convert a pre-processed corpus (see original TensorFlow repo)
												with open(_UpperCamelCase,		'''rb'''							) as fp:
																		SCREAMING_SNAKE_CASE__       :			Optional[int]													=pickle.load(_UpperCamelCase,		encoding='''latin1'''							)
												# Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
												SCREAMING_SNAKE_CASE__       :			Tuple													=pytorch_dump_folder_path + '''/''' + VOCAB_FILES_NAMES['''pretrained_vocab_file''']
												print(f"Save vocabulary to {pytorch_vocab_dump_path}"							)
												SCREAMING_SNAKE_CASE__       :			List[Any]													=corpus.vocab.__dict__
												torch.save(_UpperCamelCase,		_UpperCamelCase							)

												SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=corpus.__dict__
												corpus_dict_no_vocab.pop('''vocab''',		_UpperCamelCase							)
												SCREAMING_SNAKE_CASE__       :			List[Any]													=pytorch_dump_folder_path + '''/''' + CORPUS_NAME
												print(f"Save dataset to {pytorch_dataset_dump_path}"							)
												torch.save(_UpperCamelCase,		_UpperCamelCase							)

						if tf_checkpoint_path:
												# Convert a pre-trained TensorFlow model
												SCREAMING_SNAKE_CASE__       :			Any													=os.path.abspath(_UpperCamelCase							)
												SCREAMING_SNAKE_CASE__       :			int													=os.path.abspath(_UpperCamelCase							)

												print(f"Converting Transformer XL checkpoint from {tf_path} with config at {config_path}."							)
												# Initialise PyTorch model
												if transfo_xl_config_file == "":
																		SCREAMING_SNAKE_CASE__       :			Optional[int]													=TransfoXLConfig()
												else:
																		SCREAMING_SNAKE_CASE__       :			List[str]													=TransfoXLConfig.from_json_file(_UpperCamelCase							)
												print(f"Building PyTorch model from configuration: {config}"							)
												SCREAMING_SNAKE_CASE__       :			Optional[Any]													=TransfoXLLMHeadModel(_UpperCamelCase							)

												SCREAMING_SNAKE_CASE__       :			List[Any]													=load_tf_weights_in_transfo_xl(_UpperCamelCase,		_UpperCamelCase,		_UpperCamelCase							)
												# Save pytorch-model
												SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=os.path.join(_UpperCamelCase,		_UpperCamelCase							)
												SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=os.path.join(_UpperCamelCase,		_UpperCamelCase							)
												print(f"Save PyTorch model to {os.path.abspath(_UpperCamelCase							)}"							)
												torch.save(model.state_dict(),		_UpperCamelCase							)
												print(f"Save configuration file to {os.path.abspath(_UpperCamelCase							)}"							)
												with open(_UpperCamelCase,		'''w''',		encoding='''utf-8'''							) as f:
																		f.write(config.to_json_string()							)


if __name__ == "__main__":
		a_					=	argparse.ArgumentParser()
		parser.add_argument(
		    '--pytorch_dump_folder_path',
		    default=None,
		    type=str,
		    required=True,
		    help='Path to the folder to store the PyTorch model or dataset/vocab.',
		)
		parser.add_argument(
		    '--tf_checkpoint_path',
		    default='',
		    type=str,
		    help='An optional path to a TensorFlow checkpoint path to be converted.',
		)
		parser.add_argument(
		    '--transfo_xl_config_file',
		    default='',
		    type=str,
		    help=(
		        'An optional config json file corresponding to the pre-trained BERT model. \n'
		        'This specifies the model architecture.'
		    ),
		)
		parser.add_argument(
		    '--transfo_xl_dataset_file',
		    default='',
		    type=str,
		    help='An optional dataset file to be converted in a vocabulary.',
		)
		a_					=	parser.parse_args()
		convert_transfo_xl_checkpoint_to_pytorch(
		    args.tf_checkpoint_path,
		    args.transfo_xl_config_file,
		    args.pytorch_dump_folder_path,
		    args.transfo_xl_dataset_file,
		)







'''simple docstring'''
from datetime import datetime as dt
import os

from github import Github


a_					=	[
    'good first issue',
    'good second issue',
    'good difficult issue',
    'feature request',
    'new model',
    'wip',
]





def 	_a(					):




      '''simple docstring'''






      SCREAMING_SNAKE_CASE__       :			List[str]													=Github(os.environ['''GITHUB_TOKEN''']							)
      SCREAMING_SNAKE_CASE__       :			List[Any]													=g.get_repo('''huggingface/transformers'''							)
      SCREAMING_SNAKE_CASE__       :			List[Any]													=repo.get_issues(state='''open'''							)

      for issue in open_issues:
            SCREAMING_SNAKE_CASE__       :			List[Any]													=sorted([comment for comment in issue.get_comments()],		key=lambda UpperCamelCase__							: i.created_at,		reverse=UpperCamelCase__							)
            SCREAMING_SNAKE_CASE__       :			Dict													=comments[0] if len(UpperCamelCase__							) > 0 else None
            if (
                last_comment is not None
                and last_comment.user.login == "github-actions[bot]"
                and (dt.utcnow() - issue.updated_at).days > 7
                and (dt.utcnow() - issue.created_at).days >= 3_0
                and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()							)
            ):
                  # print(f"Would close issue {issue.number} since it has been 7 days of inactivity since bot mention.")
                  issue.edit(state='''closed'''							)
            elif (
                (dt.utcnow() - issue.updated_at).days > 2_3
                and (dt.utcnow() - issue.created_at).days >= 3_0
                and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()							)
            ):
                  # print(f"Would add stale comment to {issue.number}")
                  issue.create_comment(
                      '''This issue has been automatically marked as stale because it has not had '''
                      '''recent activity. If you think this still needs to be addressed '''
                      '''please comment on this thread.\n\nPlease note that issues that do not follow the '''
                      '''[contributing guidelines](https://github.com/huggingface/transformers/blob/main/CONTRIBUTING.md) '''
                      '''are likely to be ignored.'''							)


if __name__ == "__main__":
  main()