





'''simple docstring'''




import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    Pipeline,
    ZeroShotClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
__SCREAMING_SNAKE_CASE     :List[Any]       =				{'''LayoutLMv2Config''', '''LayoutLMv3Config'''}







@is_pipeline_test
class   A_	(  unittest.TestCase			):
 _lowerCamelCase  : str           =							MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
 _lowerCamelCase  : Dict           =							TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

 if model_mapping is not None:
  _lowerCamelCase  : int           =							{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
 if tf_model_mapping is not None:
  _lowerCamelCase  : Any           =							{
      config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
  }




 def      lowercase	(					self       :    Tuple	,			snake_case_       :    List[str]	,			snake_case_       :    Optional[Any]	,			snake_case_       :    Union[str, Any]    ):
      _UpperCAmelCase     							=   ZeroShotClassificationPipeline(
          model=snake_case_	,			tokenizer=snake_case_	,			candidate_labels=["polics", "health"]    )
      return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]




 def      lowercase	(					self       :    int	,			snake_case_       :    Tuple	,			snake_case_       :    Optional[int]    ):
      _UpperCAmelCase     							=   classifier("Who are you voting for in 2020?"	,			candidate_labels="politics"    )
      self.assertEqual(snake_case_	,			{"sequence": ANY(snake_case_    ), "labels": [ANY(snake_case_    )], "scores": [ANY(snake_case_    )]}    )

      # No kwarg
      _UpperCAmelCase     							=   classifier("Who are you voting for in 2020?"	,			["politics"]    )
      self.assertEqual(snake_case_	,			{"sequence": ANY(snake_case_    ), "labels": [ANY(snake_case_    )], "scores": [ANY(snake_case_    )]}    )

      _UpperCAmelCase     							=   classifier("Who are you voting for in 2020?"	,			candidate_labels=["politics"]    )
      self.assertEqual(snake_case_	,			{"sequence": ANY(snake_case_    ), "labels": [ANY(snake_case_    )], "scores": [ANY(snake_case_    )]}    )

      _UpperCAmelCase     							=   classifier("Who are you voting for in 2020?"	,			candidate_labels="politics, public health"    )
      self.assertEqual(
          snake_case_	,			{"sequence": ANY(snake_case_    ), "labels": [ANY(snake_case_    ), ANY(snake_case_    )], "scores": [ANY(snake_case_    ), ANY(snake_case_    )]}    )
      self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]    )    )	,			1.0    )

      _UpperCAmelCase     							=   classifier("Who are you voting for in 2020?"	,			candidate_labels=["politics", "public health"]    )
      self.assertEqual(
          snake_case_	,			{"sequence": ANY(snake_case_    ), "labels": [ANY(snake_case_    ), ANY(snake_case_    )], "scores": [ANY(snake_case_    ), ANY(snake_case_    )]}    )
      self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]    )    )	,			1.0    )

      _UpperCAmelCase     							=   classifier(
          "Who are you voting for in 2020?"	,			candidate_labels="politics"	,			hypothesis_template="This text is about {}"    )
      self.assertEqual(snake_case_	,			{"sequence": ANY(snake_case_    ), "labels": [ANY(snake_case_    )], "scores": [ANY(snake_case_    )]}    )

      # https://github.com/huggingface/transformers/issues/13846
      _UpperCAmelCase     							=   classifier(["I am happy"]	,			["positive", "negative"]    )
      self.assertEqual(
          snake_case_	,			[
              {"sequence": ANY(snake_case_    ), "labels": [ANY(snake_case_    ), ANY(snake_case_    )], "scores": [ANY(snake_case_    ), ANY(snake_case_    )]}
              for i in range(1    )
          ]	,			)
      _UpperCAmelCase     							=   classifier(["I am happy", "I am sad"]	,			["positive", "negative"]    )
      self.assertEqual(
          snake_case_	,			[
              {"sequence": ANY(snake_case_    ), "labels": [ANY(snake_case_    ), ANY(snake_case_    )], "scores": [ANY(snake_case_    ), ANY(snake_case_    )]}
              for i in range(2    )
          ]	,			)

      with self.assertRaises(snake_case_    ):
           classifier(""	,			candidate_labels="politics"    )

      with self.assertRaises(snake_case_    ):
           classifier(snake_case_	,			candidate_labels="politics"    )

      with self.assertRaises(snake_case_    ):
           classifier("Who are you voting for in 2020?"	,			candidate_labels=""    )

      with self.assertRaises(snake_case_    ):
           classifier("Who are you voting for in 2020?"	,			candidate_labels=snake_case_    )

      with self.assertRaises(snake_case_    ):
           classifier(
               "Who are you voting for in 2020?"	,			candidate_labels="politics"	,			hypothesis_template="Not formatting template"	,			)

      with self.assertRaises(snake_case_    ):
           classifier(
               "Who are you voting for in 2020?"	,			candidate_labels="politics"	,			hypothesis_template=snake_case_	,			)

      self.run_entailment_id(snake_case_    )




 def      lowercase	(					self       :    str	,			snake_case_       :    Pipeline    ):
      _UpperCAmelCase     							=   zero_shot_classifier.model.config
      _UpperCAmelCase     							=   config.labelaid
      _UpperCAmelCase     							=   zero_shot_classifier.entailment_id

      _UpperCAmelCase     							=   {"LABEL_0": 0, "LABEL_1": 1, "LABEL_2": 2}
      self.assertEqual(zero_shot_classifier.entailment_id	,			-1    )

      _UpperCAmelCase     							=   {"entailment": 0, "neutral": 1, "contradiction": 2}
      self.assertEqual(zero_shot_classifier.entailment_id	,			0    )

      _UpperCAmelCase     							=   {"ENTAIL": 0, "NON-ENTAIL": 1}
      self.assertEqual(zero_shot_classifier.entailment_id	,			0    )

      _UpperCAmelCase     							=   {"ENTAIL": 2, "NEUTRAL": 1, "CONTR": 0}
      self.assertEqual(zero_shot_classifier.entailment_id	,			2    )

      _UpperCAmelCase     							=   original_labelaid
      self.assertEqual(snake_case_	,			zero_shot_classifier.entailment_id    )




 @require_torch
 def      lowercase	(					self       :    Optional[Any]    ):
      _UpperCAmelCase     							=   pipeline(
          "zero-shot-classification"	,			model="sshleifer/tiny-distilbert-base-cased-distilled-squad"	,			framework="pt"	,			)
      # There was a regression in 4.10 for this
      # Adding a test so we don't make the mistake again.
      # https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499
      zero_shot_classifier(
          "Who are you voting for in 2020?" * 1_0_0	,			candidate_labels=["politics", "public health", "science"]    )




 @require_torch
 def      lowercase	(					self       :    Dict    ):
      _UpperCAmelCase     							=   pipeline(
          "zero-shot-classification"	,			model="sshleifer/tiny-distilbert-base-cased-distilled-squad"	,			framework="pt"	,			)
      _UpperCAmelCase     							=   zero_shot_classifier(
          "Who are you voting for in 2020?"	,			candidate_labels=["politics", "public health", "science"]    )

      self.assertEqual(
          nested_simplify(snake_case_    )	,			{
              "sequence": "Who are you voting for in 2020?",
              "labels": ["science", "public health", "politics"],
              "scores": [0.3_3_3, 0.3_3_3, 0.3_3_3],
          }	,			)




 @require_tf
 def      lowercase	(					self       :    str    ):
      _UpperCAmelCase     							=   pipeline(
          "zero-shot-classification"	,			model="sshleifer/tiny-distilbert-base-cased-distilled-squad"	,			framework="tf"	,			)
      _UpperCAmelCase     							=   zero_shot_classifier(
          "Who are you voting for in 2020?"	,			candidate_labels=["politics", "public health", "science"]    )

      self.assertEqual(
          nested_simplify(snake_case_    )	,			{
              "sequence": "Who are you voting for in 2020?",
              "labels": ["science", "public health", "politics"],
              "scores": [0.3_3_3, 0.3_3_3, 0.3_3_3],
          }	,			)




 @slow
 @require_torch
 def      lowercase	(					self       :    List[str]    ):
      _UpperCAmelCase     							=   pipeline("zero-shot-classification"	,			model="roberta-large-mnli"	,			framework="pt"    )
      _UpperCAmelCase     							=   zero_shot_classifier(
          "Who are you voting for in 2020?"	,			candidate_labels=["politics", "public health", "science"]    )

      self.assertEqual(
          nested_simplify(snake_case_    )	,			{
              "sequence": "Who are you voting for in 2020?",
              "labels": ["politics", "public health", "science"],
              "scores": [0.9_7_6, 0.0_1_5, 0.0_0_9],
          }	,			)
      _UpperCAmelCase     							=   zero_shot_classifier(
          "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
          " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
          " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
          " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
          " machine translation tasks show these models to be superior in quality while being more parallelizable"
          " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
          " English-to-German translation task, improving over the existing best results, including ensembles by"
          " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
          " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
          " fraction of the training costs of the best models from the literature. We show that the Transformer"
          " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
          " large and limited training data."	,			candidate_labels=["machine learning", "statistics", "translation", "vision"]	,			multi_label=snake_case_	,			)
      self.assertEqual(
          nested_simplify(snake_case_    )	,			{
              "sequence": (
                  "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
                  " networks in an encoder-decoder configuration. The best performing models also connect the"
                  " encoder and decoder through an attention mechanism. We propose a new simple network"
                  " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
                  " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
                  " superior in quality while being more parallelizable and requiring significantly less time to"
                  " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
                  " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
                  " English-to-French translation task, our model establishes a new single-model state-of-the-art"
                  " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
                  " costs of the best models from the literature. We show that the Transformer generalizes well to"
                  " other tasks by applying it successfully to English constituency parsing both with large and"
                  " limited training data."
              ),
              "labels": ["translation", "machine learning", "vision", "statistics"],
              "scores": [0.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
          }	,			)




 @slow
 @require_tf
 def      lowercase	(					self       :    Tuple    ):
      _UpperCAmelCase     							=   pipeline("zero-shot-classification"	,			model="roberta-large-mnli"	,			framework="tf"    )
      _UpperCAmelCase     							=   zero_shot_classifier(
          "Who are you voting for in 2020?"	,			candidate_labels=["politics", "public health", "science"]    )

      self.assertEqual(
          nested_simplify(snake_case_    )	,			{
              "sequence": "Who are you voting for in 2020?",
              "labels": ["politics", "public health", "science"],
              "scores": [0.9_7_6, 0.0_1_5, 0.0_0_9],
          }	,			)
      _UpperCAmelCase     							=   zero_shot_classifier(
          "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
          " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
          " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
          " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
          " machine translation tasks show these models to be superior in quality while being more parallelizable"
          " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
          " English-to-German translation task, improving over the existing best results, including ensembles by"
          " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
          " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
          " fraction of the training costs of the best models from the literature. We show that the Transformer"
          " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
          " large and limited training data."	,			candidate_labels=["machine learning", "statistics", "translation", "vision"]	,			multi_label=snake_case_	,			)
      self.assertEqual(
          nested_simplify(snake_case_    )	,			{
              "sequence": (
                  "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
                  " networks in an encoder-decoder configuration. The best performing models also connect the"
                  " encoder and decoder through an attention mechanism. We propose a new simple network"
                  " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
                  " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
                  " superior in quality while being more parallelizable and requiring significantly less time to"
                  " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
                  " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
                  " English-to-French translation task, our model establishes a new single-model state-of-the-art"
                  " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
                  " costs of the best models from the literature. We show that the Transformer generalizes well to"
                  " other tasks by applying it successfully to English constituency parsing both with large and"
                  " limited training data."
              ),
              "labels": ["translation", "machine learning", "vision", "statistics"],
              "scores": [0.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
          }	,			)











'''simple docstring'''




import os
from datetime import datetime as dt

from github import Github


__SCREAMING_SNAKE_CASE     :str       =				[
    '''good first issue''',
    '''feature request''',
    '''wip''',
]
def 	UpperCAmelCase_							(					)		->       Optional[Any]:


     '''simple docstring'''



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

     for issue in open_issues:
          _UpperCAmelCase     							=   sorted([comment for comment in issue.get_comments()]			,     key=lambda __lowercase       : i.created_at			,     reverse=__lowercase       )
          _UpperCAmelCase     							=   comments[0] if len(__lowercase       ) > 0 else None
          _UpperCAmelCase     							=   dt.utcnow()
          _UpperCAmelCase     							=   (current_time - issue.updated_at).days
          _UpperCAmelCase     							=   (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 >= 30
              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 > 23
              and days_since_creation >= 30
              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()




