



'''simple docstring'''




import argparse
import json
import logging
import os
import sys
from unittest.mock import patch

from transformers.testing_utils import TestCasePlus, get_gpu_count, slow


a     :    Dict 						=					[
    os.path.join(os.path.dirname(__file__), dirname)
    for dirname in [
        'text-classification',
        'language-modeling',
        'summarization',
        'token-classification',
        'question-answering',
    ]
]
sys.path.extend(SRC_DIRS)


if SRC_DIRS is not None:
							import run_clm_flax
							import run_flax_glue
							import run_flax_ner
							import run_mlm_flax
							import run_qa
							import run_summarization_flax
							import run_ta_mlm_flax


logging.basicConfig(level=logging.DEBUG)

a     :    Optional[Any] 						=					logging.getLogger()



def    __lowerCamelCase						(      )   ->    Optional[Any]:
							UpperCAmelCase  :	Optional[Any]							  =	argparse.ArgumentParser()
							parser.add_argument("""-f"""	)
							UpperCAmelCase  :	Tuple							  =	parser.parse_args()
							return args.f



def    __lowerCamelCase						(      _lowercase			,       _lowercase="eval"	)   ->    Dict:
							UpperCAmelCase  :	List[Any]							  =	os.path.join(lowercase_			,       F'''{split}_results.json'''	)
							if os.path.exists(lowercase_	):
														with open(lowercase_			,       """r"""	) as f:
																					return json.load(lowercase_	)
							raise ValueError(F'''can\'t find {path}'''	)


a     :    str 						=					logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)


class     UpperCamelCase_				(							__magic_name__    ):





	def 				_lowercase(						self					)    ->    Any:
								UpperCAmelCase  :	Tuple							  =	self.get_auto_remove_tmp_dir()
								UpperCAmelCase  :	str							  =	f'''
            run_glue.py
            --model_name_or_path distilbert-base-uncased
            --output_dir {tmp_dir}
            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv
            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --learning_rate=1e-4
            --eval_steps=2
            --warmup_steps=2
            --seed=42
            --max_seq_length=128
            '''.split()

								with patch.object(A__	,	"""argv"""	,	A__					):
															run_flax_glue.main()
															UpperCAmelCase  :	Tuple							  =	get_results(A__					)
															self.assertGreaterEqual(result["""eval_accuracy"""]	,	0.7_5					)





	@slow
	def 				_lowercase(						self					)    ->    str:
								UpperCAmelCase  :	List[str]							  =	self.get_auto_remove_tmp_dir()
								UpperCAmelCase  :	Tuple							  =	f'''
            run_clm_flax.py
            --model_name_or_path distilgpt2
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --do_train
            --do_eval
            --block_size 128
            --per_device_train_batch_size 4
            --per_device_eval_batch_size 4
            --num_train_epochs 2
            --logging_steps 2 --eval_steps 2
            --output_dir {tmp_dir}
            --overwrite_output_dir
            '''.split()

								with patch.object(A__	,	"""argv"""	,	A__					):
															run_clm_flax.main()
															UpperCAmelCase  :	int							  =	get_results(A__					)
															self.assertLess(result["""eval_perplexity"""]	,	100					)





	@slow
	def 				_lowercase(						self					)    ->    Union[str, Any]:
								UpperCAmelCase  :	Tuple							  =	self.get_auto_remove_tmp_dir()
								UpperCAmelCase  :	Union[str, Any]							  =	f'''
            run_summarization.py
            --model_name_or_path t5-small
            --train_file tests/fixtures/tests_samples/xsum/sample.json
            --validation_file tests/fixtures/tests_samples/xsum/sample.json
            --test_file tests/fixtures/tests_samples/xsum/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --num_train_epochs=3
            --warmup_steps=8
            --do_train
            --do_eval
            --do_predict
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --predict_with_generate
        '''.split()

								with patch.object(A__	,	"""argv"""	,	A__					):
															run_summarization_flax.main()
															UpperCAmelCase  :	List[Any]							  =	get_results(A__	,	split="""test"""					)
															self.assertGreaterEqual(result["""test_rouge1"""]	,	10					)
															self.assertGreaterEqual(result["""test_rouge2"""]	,	2					)
															self.assertGreaterEqual(result["""test_rougeL"""]	,	7					)
															self.assertGreaterEqual(result["""test_rougeLsum"""]	,	7					)





	@slow
	def 				_lowercase(						self					)    ->    Dict:
								UpperCAmelCase  :	int							  =	self.get_auto_remove_tmp_dir()
								UpperCAmelCase  :	int							  =	f'''
            run_mlm.py
            --model_name_or_path distilroberta-base
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --max_seq_length 128
            --per_device_train_batch_size 4
            --per_device_eval_batch_size 4
            --logging_steps 2 --eval_steps 2
            --do_train
            --do_eval
            --num_train_epochs=1
        '''.split()

								with patch.object(A__	,	"""argv"""	,	A__					):
															run_mlm_flax.main()
															UpperCAmelCase  :	str							  =	get_results(A__					)
															self.assertLess(result["""eval_perplexity"""]	,	42					)





	@slow
	def 				_lowercase(						self					)    ->    Union[str, Any]:
								UpperCAmelCase  :	List[str]							  =	self.get_auto_remove_tmp_dir()
								UpperCAmelCase  :	Union[str, Any]							  =	f'''
            run_t5_mlm_flax.py
            --model_name_or_path t5-small
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --do_train
            --do_eval
            --max_seq_length 128
            --per_device_train_batch_size 4
            --per_device_eval_batch_size 4
            --num_train_epochs 2
            --logging_steps 2 --eval_steps 2
            --output_dir {tmp_dir}
            --overwrite_output_dir
            '''.split()

								with patch.object(A__	,	"""argv"""	,	A__					):
															run_ta_mlm_flax.main()
															UpperCAmelCase  :	str							  =	get_results(A__					)
															self.assertGreaterEqual(result["""eval_accuracy"""]	,	0.4_2					)





	@slow
	def 				_lowercase(						self					)    ->    Dict:
								# with so little data distributed training needs more epochs to get the score on par with 0/1 gpu
								UpperCAmelCase  :	Any							  =	7 if get_gpu_count() > 1 else 2

								UpperCAmelCase  :	List[Any]							  =	self.get_auto_remove_tmp_dir()
								UpperCAmelCase  :	int							  =	f'''
            run_flax_ner.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/conll/sample.json
            --validation_file tests/fixtures/tests_samples/conll/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --do_train
            --do_eval
            --warmup_steps=2
            --learning_rate=2e-4
            --logging_steps 2 --eval_steps 2
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=2
            --num_train_epochs={epochs}
            --seed 7
        '''.split()

								with patch.object(A__	,	"""argv"""	,	A__					):
															run_flax_ner.main()
															UpperCAmelCase  :	Union[str, Any]							  =	get_results(A__					)
															self.assertGreaterEqual(result["""eval_accuracy"""]	,	0.7_5					)
															self.assertGreaterEqual(result["""eval_f1"""]	,	0.3					)






	@slow
	def 				_lowercase(						self					)    ->    List[Any]:
								UpperCAmelCase  :	Optional[Any]							  =	self.get_auto_remove_tmp_dir()
								UpperCAmelCase  :	Tuple							  =	f'''
            run_qa.py
            --model_name_or_path bert-base-uncased
            --version_2_with_negative
            --train_file tests/fixtures/tests_samples/SQUAD/sample.json
            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --num_train_epochs=3
            --warmup_steps=2
            --do_train
            --do_eval
            --logging_steps 2 --eval_steps 2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
        '''.split()

								with patch.object(A__	,	"""argv"""	,	A__					):
															run_qa.main()
															UpperCAmelCase  :	Tuple							  =	get_results(A__					)
															self.assertGreaterEqual(result["""eval_f1"""]	,	30					)
															self.assertGreaterEqual(result["""eval_exact"""]	,	30					)






'''simple docstring'''




from datetime import datetime as dt
import os

from github import Github


a     :    int      						=					[
    """good first issue""",
    """good second issue""",
    """good difficult issue""",
    """feature request""",
    """new model""",
    """wip""",
]



def    __lowerCamelCase						(      )   ->    Dict:
							UpperCAmelCase  :	str							  =	Github(os.environ["""GITHUB_TOKEN"""]	)
							UpperCAmelCase  :	Dict							  =	g.get_repo("""huggingface/transformers"""	)
							UpperCAmelCase  :	int							  =	repo.get_issues(state="""open"""	)

							for issue in open_issues:
														UpperCAmelCase  :	Optional[int]							  =	sorted([comment for comment in issue.get_comments()]			,       key=lambda _lowercase	: i.created_at			,       reverse=_lowercase	)
														UpperCAmelCase  :	Any							  =	comments[0] if len(_lowercase	) > 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()

