


import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotConfig, is_flax_available
from transformers.testing_utils import jax_device, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
    import os

    # The slow tests are often failing with OOM error on GPU
    # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
    # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
    A   :					List[Any]	=      "platform"

    import jax
    import jax.numpy as jnp

    from transformers import BlenderbotTokenizer
    from transformers.models.blenderbot.modeling_flax_blenderbot import (
        FlaxBlenderbotForConditionalGeneration,
        FlaxBlenderbotModel,
        shift_tokens_right,
    )

def    lowercase_	(	_A    :					List[str]					,      _A    :					Any					,      _A    :					Union[str, Any]=None					,      _A    :					Tuple=None					,      _A    :					Union[str, Any]=None					,      _A    :					List[str]=None					,      _A    :					str=None					,      _A    :					Dict=None					,      ):

      """simple docstring"""




      if attention_mask is None:
            lowerCamelCase__	:       Optional[Any]					=						np.where(input_ids != config.pad_token_id					,      1					,      0		)
      if decoder_attention_mask is None:
            lowerCamelCase__	:       Union[str, Any]					=						np.where(decoder_input_ids != config.pad_token_id					,      1					,      0		)
      if head_mask is None:
            lowerCamelCase__	:       Dict					=						np.ones((config.encoder_layers, config.encoder_attention_heads)		)
      if decoder_head_mask is None:
            lowerCamelCase__	:       str					=						np.ones((config.decoder_layers, config.decoder_attention_heads)		)
      if cross_attn_head_mask is None:
            lowerCamelCase__	:       List[str]					=						np.ones((config.decoder_layers, config.decoder_attention_heads)		)
      return {
          "input_ids": input_ids,
          "decoder_input_ids": decoder_input_ids,
          "attention_mask": attention_mask,
          "decoder_attention_mask": attention_mask,
      }







class     _lowercase				:


       """simple docstring"""




       def __init__(     self							:    List[Any]      ,   __lowerCamelCase							:    List[Any]      ,   __lowerCamelCase							:    Union[str, Any]=13      ,   __lowerCamelCase							:    Optional[int]=7      ,   __lowerCamelCase							:    str=True      ,   __lowerCamelCase							:    List[Any]=False      ,   __lowerCamelCase							:    Dict=99      ,   __lowerCamelCase							:    List[Any]=16      ,   __lowerCamelCase							:    str=2      ,   __lowerCamelCase							:    Union[str, Any]=4      ,   __lowerCamelCase							:    str=4      ,   __lowerCamelCase							:    int="gelu"      ,   __lowerCamelCase							:    List[Any]=0.1      ,   __lowerCamelCase							:    Optional[Any]=0.1      ,   __lowerCamelCase							:    Union[str, Any]=32      ,   __lowerCamelCase							:    Optional[Any]=2      ,   __lowerCamelCase							:    Any=1      ,   __lowerCamelCase							:    List[Any]=0      ,   __lowerCamelCase							:    Any=0.0_2      ,   ):


             '''simple docstring'''



             lowerCamelCase__	:       List[str]					=						parent
             lowerCamelCase__	:       int					=						batch_size
             lowerCamelCase__	:       Tuple					=						seq_length
             lowerCamelCase__	:       Tuple					=						is_training
             lowerCamelCase__	:       Dict					=						use_labels
             lowerCamelCase__	:       Dict					=						vocab_size
             lowerCamelCase__	:       Any					=						hidden_size
             lowerCamelCase__	:       Tuple					=						num_hidden_layers
             lowerCamelCase__	:       Tuple					=						num_attention_heads
             lowerCamelCase__	:       Optional[Any]					=						intermediate_size
             lowerCamelCase__	:       str					=						hidden_act
             lowerCamelCase__	:       Any					=						hidden_dropout_prob
             lowerCamelCase__	:       Dict					=						attention_probs_dropout_prob
             lowerCamelCase__	:       Optional[int]					=						max_position_embeddings
             lowerCamelCase__	:       int					=						eos_token_id
             lowerCamelCase__	:       Tuple					=						pad_token_id
             lowerCamelCase__	:       Union[str, Any]					=						bos_token_id
             lowerCamelCase__	:       List[str]					=						initializer_range





       def 		lowerCAmelCase  (     self							:    List[str] ):


             '''simple docstring'''



             lowerCamelCase__	:       Dict					=						np.clip(ids_tensor([self.batch_size, self.seq_length - 1]      ,   self.vocab_size )      ,   3      ,   self.vocab_size )
             lowerCamelCase__	:       Tuple					=						np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)      ,   dtype=np.intaa ))      ,   -1 )

             lowerCamelCase__	:       int					=						shift_tokens_right(__lowerCamelCase      ,   1      ,   2 )

             lowerCamelCase__	:       Tuple					=						BlenderbotConfig(
                 vocab_size=self.vocab_size      ,   d_model=self.hidden_size      ,   encoder_layers=self.num_hidden_layers      ,   decoder_layers=self.num_hidden_layers      ,   encoder_attention_heads=self.num_attention_heads      ,   decoder_attention_heads=self.num_attention_heads      ,   encoder_ffn_dim=self.intermediate_size      ,   decoder_ffn_dim=self.intermediate_size      ,   dropout=self.hidden_dropout_prob      ,   attention_dropout=self.attention_probs_dropout_prob      ,   max_position_embeddings=self.max_position_embeddings      ,   eos_token_id=self.eos_token_id      ,   bos_token_id=self.bos_token_id      ,   pad_token_id=self.pad_token_id      ,   initializer_range=self.initializer_range      ,   use_cache=__lowerCamelCase      ,   )
             lowerCamelCase__	:       Tuple					=						prepare_blenderbot_inputs_dict(__lowerCamelCase      ,   __lowerCamelCase      ,   __lowerCamelCase )
             return config, inputs_dict





       def 		lowerCAmelCase  (     self							:    Union[str, Any] ):


             '''simple docstring'''



             lowerCamelCase__					,     lowerCamelCase__	:       int					=						self.prepare_config_and_inputs()
             return config, inputs_dict





       def 		lowerCAmelCase  (     self							:    Tuple      ,   __lowerCamelCase							:    Tuple      ,   __lowerCamelCase							:    Tuple      ,   __lowerCamelCase							:    Tuple ):


             '''simple docstring'''



             lowerCamelCase__	:       Any					=						20
             lowerCamelCase__	:       Any					=						model_class_name(__lowerCamelCase )

             lowerCamelCase__	:       Tuple					=						model.encode(inputs_dict["input_ids"] )

             lowerCamelCase__					,     lowerCamelCase__	:       int					=						(
                 inputs_dict["decoder_input_ids"],
                 inputs_dict["decoder_attention_mask"],
             )

             lowerCamelCase__	:       str					=						model.init_cache(decoder_input_ids.shape[0]      ,   __lowerCamelCase      ,   __lowerCamelCase )
             lowerCamelCase__	:       List[Any]					=						jnp.ones((decoder_input_ids.shape[0], max_decoder_length)      ,   dtype="i4" )

             lowerCamelCase__	:       Dict					=						jnp.broadcast_to(
                 jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :]      ,   (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)      ,   )
             lowerCamelCase__	:       Dict					=						model.decode(
                 decoder_input_ids[:, :-1]      ,   __lowerCamelCase      ,   decoder_attention_mask=__lowerCamelCase      ,   past_key_values=__lowerCamelCase      ,   decoder_position_ids=__lowerCamelCase      ,   )

             lowerCamelCase__	:       str					=						jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]      ,   dtype="i4" )
             lowerCamelCase__	:       Union[str, Any]					=						model.decode(
                 decoder_input_ids[:, -1:]      ,   __lowerCamelCase      ,   decoder_attention_mask=__lowerCamelCase      ,   past_key_values=outputs_cache.past_key_values      ,   decoder_position_ids=__lowerCamelCase      ,   )

             lowerCamelCase__	:       Dict					=						model.decode(__lowerCamelCase      ,   __lowerCamelCase )

             lowerCamelCase__	:       str					=						np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) )
             self.parent.assertTrue(diff < 1E-3      ,   msg=f"Max diff is {diff}" )





       def 		lowerCAmelCase  (     self							:    List[str]      ,   __lowerCamelCase							:    Optional[int]      ,   __lowerCamelCase							:    Any      ,   __lowerCamelCase							:    Optional[Any] ):


             '''simple docstring'''



             lowerCamelCase__	:       List[Any]					=						20
             lowerCamelCase__	:       Optional[int]					=						model_class_name(__lowerCamelCase )

             lowerCamelCase__	:       List[str]					=						model.encode(inputs_dict["input_ids"] )

             lowerCamelCase__					,     lowerCamelCase__	:       int					=						(
                 inputs_dict["decoder_input_ids"],
                 inputs_dict["decoder_attention_mask"],
             )

             lowerCamelCase__	:       Optional[Any]					=						jnp.concatenate(
                 [
                     decoder_attention_mask,
                     jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1]) ),
                 ]      ,   axis=-1      ,   )

             lowerCamelCase__	:       Tuple					=						model.init_cache(decoder_input_ids.shape[0]      ,   __lowerCamelCase      ,   __lowerCamelCase )
             lowerCamelCase__	:       Dict					=						jnp.broadcast_to(
                 jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :]      ,   (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)      ,   )

             lowerCamelCase__	:       Optional[int]					=						model.decode(
                 decoder_input_ids[:, :-1]      ,   __lowerCamelCase      ,   decoder_attention_mask=__lowerCamelCase      ,   past_key_values=__lowerCamelCase      ,   decoder_position_ids=__lowerCamelCase      ,   )
             lowerCamelCase__	:       Dict					=						jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]      ,   dtype="i4" )
             lowerCamelCase__	:       Dict					=						model.decode(
                 decoder_input_ids[:, -1:]      ,   __lowerCamelCase      ,   past_key_values=outputs_cache.past_key_values      ,   decoder_attention_mask=__lowerCamelCase      ,   decoder_position_ids=__lowerCamelCase      ,   )

             lowerCamelCase__	:       Dict					=						model.decode(__lowerCamelCase      ,   __lowerCamelCase      ,   decoder_attention_mask=__lowerCamelCase )

             lowerCamelCase__	:       Tuple					=						np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) )
             self.parent.assertTrue(diff < 1E-3      ,   msg=f"Max diff is {diff}" )







@require_flax
class     _lowercase				(							unittest.TestCase):


       """simple docstring"""




       A__      		=    99





       def 		lowerCAmelCase  (     self							:    Optional[Any] ):


             '''simple docstring'''



             lowerCamelCase__	:       Optional[Any]					=						np.array(
                 [
                     [71, 82, 18, 33, 46, 91, 2],
                     [68, 34, 26, 58, 30, 82, 2],
                     [5, 97, 17, 39, 94, 40, 2],
                     [76, 83, 94, 25, 70, 78, 2],
                     [87, 59, 41, 35, 48, 66, 2],
                     [55, 13, 16, 58, 5, 2, 1],  # note padding
                     [64, 27, 31, 51, 12, 75, 2],
                     [52, 64, 86, 17, 83, 39, 2],
                     [48, 61, 9, 24, 71, 82, 2],
                     [26, 1, 60, 48, 22, 13, 2],
                     [21, 5, 62, 28, 14, 76, 2],
                     [45, 98, 37, 86, 59, 48, 2],
                     [70, 70, 50, 9, 28, 0, 2],
                 ]      ,   dtype=np.intaa      ,   )

             lowerCamelCase__	:       Optional[Any]					=						input_ids.shape[0]
             lowerCamelCase__	:       str					=						BlenderbotConfig(
                 vocab_size=self.vocab_size      ,   d_model=24      ,   encoder_layers=2      ,   decoder_layers=2      ,   encoder_attention_heads=2      ,   decoder_attention_heads=2      ,   encoder_ffn_dim=32      ,   decoder_ffn_dim=32      ,   max_position_embeddings=48      ,   eos_token_id=2      ,   pad_token_id=1      ,   bos_token_id=0      ,   )
             return config, input_ids, batch_size





       def 		lowerCAmelCase  (     self							:    Tuple ):


             '''simple docstring'''



             lowerCamelCase__					,     lowerCamelCase__					,     lowerCamelCase__	:       List[str]					=						self._get_config_and_data()
             lowerCamelCase__	:       Optional[Any]					=						FlaxBlenderbotForConditionalGeneration(__lowerCamelCase )
             lowerCamelCase__	:       Any					=						lm_model(input_ids=__lowerCamelCase )
             lowerCamelCase__	:       str					=						(batch_size, input_ids.shape[1], config.vocab_size)
             self.assertEqual(outputs["logits"].shape      ,   __lowerCamelCase )





       def 		lowerCAmelCase  (     self							:    Tuple ):


             '''simple docstring'''



             lowerCamelCase__	:       str					=						BlenderbotConfig(
                 vocab_size=self.vocab_size      ,   d_model=14      ,   encoder_layers=2      ,   decoder_layers=2      ,   encoder_attention_heads=2      ,   decoder_attention_heads=2      ,   encoder_ffn_dim=8      ,   decoder_ffn_dim=8      ,   max_position_embeddings=48      ,   )
             lowerCamelCase__	:       Optional[int]					=						FlaxBlenderbotForConditionalGeneration(__lowerCamelCase )
             lowerCamelCase__	:       str					=						np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]      ,   dtype=np.intaa )
             lowerCamelCase__	:       List[str]					=						np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]      ,   dtype=np.intaa )
             lowerCamelCase__	:       int					=						lm_model(input_ids=__lowerCamelCase      ,   decoder_input_ids=__lowerCamelCase )
             lowerCamelCase__	:       List[Any]					=						(*summary.shape, config.vocab_size)
             self.assertEqual(outputs["logits"].shape      ,   __lowerCamelCase )





       def 		lowerCAmelCase  (     self							:    Optional[int] ):


             '''simple docstring'''



             lowerCamelCase__	:       int					=						np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]      ,   dtype=np.intaa )
             lowerCamelCase__	:       int					=						shift_tokens_right(__lowerCamelCase      ,   1      ,   2 )
             lowerCamelCase__	:       List[Any]					=						np.equal(__lowerCamelCase      ,   1 ).astype(np.floataa ).sum()
             lowerCamelCase__	:       Dict					=						np.equal(__lowerCamelCase      ,   1 ).astype(np.floataa ).sum()
             self.assertEqual(shifted.shape      ,   input_ids.shape )
             self.assertEqual(__lowerCamelCase      ,   n_pad_before - 1 )
             self.assertTrue(np.equal(shifted[:, 0]      ,   2 ).all() )







@require_flax
class     _lowercase				(							lowercase__							,						unittest.TestCase							,						lowercase__):


       """simple docstring"""




       A__      		=    True
       A__      		=    (
           (
               FlaxBlenderbotModel,
               FlaxBlenderbotForConditionalGeneration,
           )
           if is_flax_available()
           else ()
       )
       A__      		=    (FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else ()





       def 		lowerCAmelCase  (     self							:    Optional[Any] ):


             '''simple docstring'''



             lowerCamelCase__	:       int					=						FlaxBlenderbotModelTester(self )





       def 		lowerCAmelCase  (     self							:    Dict ):


             '''simple docstring'''



             lowerCamelCase__					,     lowerCamelCase__	:       Union[str, Any]					=						self.model_tester.prepare_config_and_inputs()
             for model_class in self.all_model_classes:
                   self.model_tester.check_use_cache_forward(__lowerCamelCase      ,   __lowerCamelCase      ,   __lowerCamelCase )





       def 		lowerCAmelCase  (     self							:    List[Any] ):


             '''simple docstring'''



             lowerCamelCase__					,     lowerCamelCase__	:       int					=						self.model_tester.prepare_config_and_inputs()
             for model_class in self.all_model_classes:
                   self.model_tester.check_use_cache_forward_with_attn_mask(__lowerCamelCase      ,   __lowerCamelCase      ,   __lowerCamelCase )





       def 		lowerCAmelCase  (     self							:    Optional[int] ):


             '''simple docstring'''



             lowerCamelCase__					,     lowerCamelCase__	:       Union[str, Any]					=						self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   with self.subTest(model_class.__name__ ):
                         lowerCamelCase__	:       Any					=						self._prepare_for_class(__lowerCamelCase      ,   __lowerCamelCase )
                         lowerCamelCase__	:       Union[str, Any]					=						model_class(__lowerCamelCase )

                         @jax.jit
                         def encode_jitted(__lowerCamelCase							:    List[str]      ,   __lowerCamelCase							:    Tuple=None      ,   **__lowerCamelCase							:    int ):
                               return model.encode(input_ids=__lowerCamelCase      ,   attention_mask=__lowerCamelCase )

                         with self.subTest("JIT Enabled" ):
                               lowerCamelCase__	:       Optional[Any]					=						encode_jitted(**__lowerCamelCase ).to_tuple()

                         with self.subTest("JIT Disabled" ):
                               with jax.disable_jit():
                                     lowerCamelCase__	:       List[Any]					=						encode_jitted(**__lowerCamelCase ).to_tuple()

                         self.assertEqual(len(__lowerCamelCase )      ,   len(__lowerCamelCase ) )
                         for jitted_output, output in zip(__lowerCamelCase      ,   __lowerCamelCase ):
                               self.assertEqual(jitted_output.shape      ,   output.shape )





       def 		lowerCAmelCase  (     self							:    Optional[int] ):


             '''simple docstring'''



             lowerCamelCase__					,     lowerCamelCase__	:       Dict					=						self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   with self.subTest(model_class.__name__ ):
                         lowerCamelCase__	:       Union[str, Any]					=						model_class(__lowerCamelCase )
                         lowerCamelCase__	:       str					=						model.encode(inputs_dict["input_ids"]      ,   inputs_dict["attention_mask"] )

                         lowerCamelCase__	:       List[Any]					=						{
                             "decoder_input_ids": inputs_dict["decoder_input_ids"],
                             "decoder_attention_mask": inputs_dict["decoder_attention_mask"],
                             "encoder_outputs": encoder_outputs,
                         }

                         @jax.jit
                         def decode_jitted(__lowerCamelCase							:    Dict      ,   __lowerCamelCase							:    Any      ,   __lowerCamelCase							:    str ):
                               return model.decode(
                                   decoder_input_ids=__lowerCamelCase      ,   decoder_attention_mask=__lowerCamelCase      ,   encoder_outputs=__lowerCamelCase      ,   )

                         with self.subTest("JIT Enabled" ):
                               lowerCamelCase__	:       Optional[int]					=						decode_jitted(**__lowerCamelCase ).to_tuple()

                         with self.subTest("JIT Disabled" ):
                               with jax.disable_jit():
                                     lowerCamelCase__	:       Any					=						decode_jitted(**__lowerCamelCase ).to_tuple()

                         self.assertEqual(len(__lowerCamelCase )      ,   len(__lowerCamelCase ) )
                         for jitted_output, output in zip(__lowerCamelCase      ,   __lowerCamelCase ):
                               self.assertEqual(jitted_output.shape      ,   output.shape )





       @slow
       def 		lowerCAmelCase  (     self							:    Any ):


             '''simple docstring'''



             for model_class_name in self.all_model_classes:
                   lowerCamelCase__	:       str					=						model_class_name.from_pretrained("facebook/blenderbot-400M-distill" )
                   # FlaxBlenderbotForSequenceClassification expects eos token in input_ids
                   lowerCamelCase__	:       int					=						np.ones((1, 1) ) * model.config.eos_token_id
                   lowerCamelCase__	:       Optional[int]					=						model(__lowerCamelCase )
                   self.assertIsNotNone(__lowerCamelCase )





       @unittest.skipUnless(jax_device != "cpu"      ,   "3B test too slow on CPU." )
       @slow
       def 		lowerCAmelCase  (     self							:    List[Any] ):


             '''simple docstring'''



             lowerCamelCase__	:       List[Any]					=						{"num_beams": 1, "early_stopping": True, "min_length": 15, "max_length": 25}
             lowerCamelCase__	:       Any					=						{"skip_special_tokens": True, "clean_up_tokenization_spaces": True}

             lowerCamelCase__	:       Dict					=						FlaxBlenderbotForConditionalGeneration.from_pretrained("facebook/blenderbot-3B"      ,   from_pt=__lowerCamelCase )
             lowerCamelCase__	:       Dict					=						BlenderbotTokenizer.from_pretrained("facebook/blenderbot-3B" )

             lowerCamelCase__	:       Dict					=						["Sam"]
             lowerCamelCase__	:       List[Any]					=						tokenizer(__lowerCamelCase      ,   return_tensors="jax" )

             lowerCamelCase__	:       Any					=						model.generate(**__lowerCamelCase      ,   **__lowerCamelCase )
             lowerCamelCase__	:       List[Any]					=						"Sam is a great name. It means \"sun\" in Gaelic."

             lowerCamelCase__	:       int					=						tokenizer.batch_decode(__lowerCamelCase      ,   **__lowerCamelCase )
             assert generated_txt[0].strip() == tgt_text






import os
from datetime import datetime as dt

from github import Github


A   :					Union[str, Any]	=      [
    "good first issue",
    "good second issue",
    "good difficult issue",
    "enhancement",
    "new pipeline/model",
    "new scheduler",
    "wip",
]

def    lowercase_	(	):

      """simple docstring"""




      lowerCamelCase__	:       Optional[int]					=						Github(os.environ["GITHUB_TOKEN"]		)
      lowerCamelCase__	:       str					=						g.get_repo("huggingface/diffusers"		)
      lowerCamelCase__	:       Optional[int]					=						repo.get_issues(state="open"		)

      for issue in open_issues:
            lowerCamelCase__	:       str					=						sorted(issue.get_comments()					,      key=lambda _A		: i.created_at					,      reverse=_A		)
            lowerCamelCase__	:       str					=						comments[0] if len(_A		) > 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 >= 30
                and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()		)
            ):
                  # Closes the issue after 7 days of inactivity since the Stalebot notification.
                  issue.edit(state="closed"		)
            elif (
                "stale" in issue.get_labels()
                and last_comment is not None
                and last_comment.user.login != "github-actions[bot]"
            ):
                  # Opens the issue if someone other than Stalebot commented.
                  issue.edit(state="open"		)
                  issue.remove_from_labels("stale"		)
            elif (
                (dt.utcnow() - issue.updated_at).days > 23
                and (dt.utcnow() - issue.created_at).days >= 30
                and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()		)
            ):
                  # Post a Stalebot notification after 23 days of inactivity.
                  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/diffusers/blob/main/CONTRIBUTING.md) "
                      "are likely to be ignored."		)
                  issue.add_to_labels("stale"		)


if __name__ == "__main__":
    main()


