
import os
from datetime import datetime as dt

from github import Github


UpperCamelCase_   	=	[
    "good first issue",
    "feature request",
    "wip",
]






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	__lowerCAmelCase         =							Github(os.environ["GITHUB_TOKEN"]  )
	__lowerCAmelCase         =							g.get_repo("huggingface/accelerate"  )
	__lowerCAmelCase         =							repo.get_issues(state="open"  )

	for issue in open_issues:
		__lowerCAmelCase         =							sorted([comment for comment in issue.get_comments()]			,							key=lambda UpperCamelCase  : i.created_at			,							reverse=lowerCamelCase_  )
		__lowerCAmelCase         =							comments[0] if len(lowerCamelCase_  ) > 0 else None
		__lowerCAmelCase         =							dt.utcnow()
		__lowerCAmelCase         =							(current_time - issue.updated_at).days
		__lowerCAmelCase         =							(current_time - issue.created_at).days
		if (
		    last_comment is not None
		    and last_comment.user.login == "github-actions[bot]"
		    and days_since_updated > 7
		    and days_since_creation >= 3_0
		    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()  )
		):
			# Close issue since it has been 7 days of inactivity since bot mention.
			issue.edit(state="closed"  )
		elif (
		    days_since_updated > 2_3
		    and days_since_creation >= 3_0
		    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()  )
		):
			# Add stale comment
			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/accelerate/blob/main/CONTRIBUTING.md) "
			    "are likely to be ignored."  )


if __name__ == "__main__":
					main()








import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
					import torch

					from transformers.generation import DisjunctiveConstraint

@require_torch
class       a		(   unittest.TestCase					):







							def       UpperCAmelCase__					(						self  :  Optional[int] ):
								"""simple docstring"""







								__lowerCAmelCase         =							[[1, 2, 4], [1, 2, 3, 4]]
								__lowerCAmelCase         =							DisjunctiveConstraint(snake_case__ )
								self.assertTrue(isinstance(dc.token_ids      ,				snake_case__ ) )

								with self.assertRaises(snake_case__ ):
									DisjunctiveConstraint(torch.LongTensor([[1, 2, 4], [1, 2, 3]] ) )

								with self.assertRaises(snake_case__ ):
									DisjunctiveConstraint([torch.LongTensor([1, 2, 4] ), torch.LongTensor([1, 2, 3, 4, 5] )] )







							def       UpperCAmelCase__					(						self  :  Tuple ):
								"""simple docstring"""







								__lowerCAmelCase         =							[[1, 2], [1, 2, 3, 4]]

								with self.assertRaises(snake_case__ ):
									DisjunctiveConstraint(snake_case__ )  # fails here







							def       UpperCAmelCase__					(						self  :  Union[str, Any] ):
								"""simple docstring"""







								__lowerCAmelCase         =							[[1, 2, 3], [1, 2, 4]]

								__lowerCAmelCase         =							DisjunctiveConstraint(snake_case__ )

								__lowerCAmelCase   ,						__lowerCAmelCase   ,						__lowerCAmelCase         =							dc.update(1 )
								__lowerCAmelCase         =							stepped is True and completed is False and reset is False
								self.assertTrue(snake_case__ )
								self.assertTrue(not dc.completed )
								self.assertTrue(dc.current_seq == [1] )

								__lowerCAmelCase   ,						__lowerCAmelCase   ,						__lowerCAmelCase         =							dc.update(2 )
								__lowerCAmelCase         =							stepped is True and completed is False and reset is False
								self.assertTrue(snake_case__ )
								self.assertTrue(not dc.completed )
								self.assertTrue(dc.current_seq == [1, 2] )

								__lowerCAmelCase   ,						__lowerCAmelCase   ,						__lowerCAmelCase         =							dc.update(3 )
								__lowerCAmelCase         =							stepped is True and completed is True and reset is False
								self.assertTrue(snake_case__ )
								self.assertTrue(dc.completed )  # Completed!
								self.assertTrue(dc.current_seq == [1, 2, 3] )







							def       UpperCAmelCase__					(						self  :  Optional[Any] ):
								"""simple docstring"""







								__lowerCAmelCase         =							[[1, 2, 3], [1, 2, 4, 5], [1, 2, 5]]

								__lowerCAmelCase         =							DisjunctiveConstraint(snake_case__ )

								__lowerCAmelCase   ,						__lowerCAmelCase   ,						__lowerCAmelCase         =							dc.update(1 )
								self.assertTrue(not dc.completed )
								self.assertTrue(dc.current_seq == [1] )

								__lowerCAmelCase   ,						__lowerCAmelCase   ,						__lowerCAmelCase         =							dc.update(2 )
								self.assertTrue(not dc.completed )
								self.assertTrue(dc.current_seq == [1, 2] )

								__lowerCAmelCase   ,						__lowerCAmelCase   ,						__lowerCAmelCase         =							dc.update(4 )
								self.assertTrue(not dc.completed )
								self.assertTrue(dc.current_seq == [1, 2, 4] )

								__lowerCAmelCase   ,						__lowerCAmelCase   ,						__lowerCAmelCase         =							dc.update(5 )
								self.assertTrue(dc.completed )  # Completed!
								self.assertTrue(dc.current_seq == [1, 2, 4, 5] )

								dc.reset()

								__lowerCAmelCase   ,						__lowerCAmelCase   ,						__lowerCAmelCase         =							dc.update(1 )
								self.assertTrue(not dc.completed )
								self.assertTrue(dc.remaining() == 3 )
								self.assertTrue(dc.current_seq == [1] )

								__lowerCAmelCase   ,						__lowerCAmelCase   ,						__lowerCAmelCase         =							dc.update(2 )
								self.assertTrue(not dc.completed )
								self.assertTrue(dc.remaining() == 2 )
								self.assertTrue(dc.current_seq == [1, 2] )

								__lowerCAmelCase   ,						__lowerCAmelCase   ,						__lowerCAmelCase         =							dc.update(5 )
								self.assertTrue(dc.completed )  # Completed!
								self.assertTrue(dc.remaining() == 0 )
								self.assertTrue(dc.current_seq == [1, 2, 5] )






