




'''simple docstring'''






from __future__ import annotations

import unittest

from transformers import CTRLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers.models.ctrl.modeling_tf_ctrl import (
          TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFCTRLForSequenceClassification,
          TFCTRLLMHeadModel,
          TFCTRLModel,
      )






class 					lowercase_			(	lowerCAmelCase_       ):





     def __init__(    self    :				Union[str, Any]    ,       __lowerCamelCase    :				Optional[int]    ,       ):
           snake_case__					:      List[Any]  			=						parent
           snake_case__					:      List[Any]  			=						13
           snake_case__					:      Optional[int]  			=						7
           snake_case__					:      Any  			=						True
           snake_case__					:      str  			=						True
           snake_case__					:      int  			=						True
           snake_case__					:      Any  			=						True
           snake_case__					:      Optional[Any]  			=						True
           snake_case__					:      Optional[int]  			=						99
           snake_case__					:      Optional[int]  			=						32
           snake_case__					:      List[str]  			=						2
           snake_case__					:      str  			=						4
           snake_case__					:      Optional[int]  			=						37
           snake_case__					:      Union[str, Any]  			=						'gelu'
           snake_case__					:      List[str]  			=						0.1
           snake_case__					:      List[str]  			=						0.1
           snake_case__					:      Tuple  			=						512
           snake_case__					:      Any  			=						16
           snake_case__					:      Optional[Any]  			=						2
           snake_case__					:      Any  			=						0.0_2
           snake_case__					:      int  			=						3
           snake_case__					:      Union[str, Any]  			=						4
           snake_case__					:      Optional[int]  			=						None
           snake_case__					:      Any  			=						self.vocab_size - 1





     def  _lowerCAmelCase			(    self    :				List[Any] ):
           snake_case__					:      Dict  			=						ids_tensor([self.batch_size, self.seq_length]    ,       self.vocab_size )

           snake_case__					:      Any  			=						None
           if self.use_input_mask:
                 snake_case__					:      Optional[int]  			=						random_attention_mask([self.batch_size, self.seq_length] )

           snake_case__					:      Any  			=						None
           if self.use_token_type_ids:
                 snake_case__					:      List[str]  			=						ids_tensor([self.batch_size, self.seq_length]    ,       self.type_vocab_size )

           snake_case__					:      Tuple  			=						None
           if self.use_mc_token_ids:
                 snake_case__					:      Union[str, Any]  			=						ids_tensor([self.batch_size, self.num_choices]    ,       self.seq_length )

           snake_case__					:      List[str]  			=						None
           snake_case__					:      List[Any]  			=						None
           snake_case__					:      List[str]  			=						None
           if self.use_labels:
                 snake_case__					:      Dict  			=						ids_tensor([self.batch_size]    ,       self.type_sequence_label_size )
                 snake_case__					:      List[Any]  			=						ids_tensor([self.batch_size, self.seq_length]    ,       self.num_labels )
                 snake_case__					:      Optional[Any]  			=						ids_tensor([self.batch_size]    ,       self.num_choices )

           snake_case__					:      Dict  			=						CTRLConfig(
               vocab_size=self.vocab_size    ,       n_embd=self.hidden_size    ,       n_layer=self.num_hidden_layers    ,       n_head=self.num_attention_heads    ,       n_positions=self.max_position_embeddings    ,       pad_token_id=self.pad_token_id    ,       )

           snake_case__					:      Union[str, Any]  			=						ids_tensor([self.num_hidden_layers, self.num_attention_heads]    ,       2 )

           return (
               config,
               input_ids,
               input_mask,
               head_mask,
               token_type_ids,
               mc_token_ids,
               sequence_labels,
               token_labels,
               choice_labels,
           )





     def  _lowerCAmelCase			(    self    :				List[Any]    ,       __lowerCamelCase    :				List[Any]    ,       __lowerCamelCase    :				List[Any]    ,       __lowerCamelCase    :				Union[str, Any]    ,       __lowerCamelCase    :				Optional[Any]    ,       __lowerCamelCase    :				Tuple    ,       *__lowerCamelCase    :				Optional[int] ):
           snake_case__					:      Optional[Any]  			=						TFCTRLModel(config=__lowerCamelCase )
           snake_case__					:      List[str]  			=						{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
           snake_case__					:      Tuple  			=						model(__lowerCamelCase )

           snake_case__					:      List[str]  			=						[input_ids, None, input_mask]  # None is the input for 'past'
           snake_case__					:      Union[str, Any]  			=						model(__lowerCamelCase )

           snake_case__					:      Dict  			=						model(__lowerCamelCase )

           self.parent.assertEqual(result.last_hidden_state.shape    ,       (self.batch_size, self.seq_length, self.hidden_size) )





     def  _lowerCAmelCase			(    self    :				Optional[Any]    ,       __lowerCamelCase    :				List[str]    ,       __lowerCamelCase    :				Any    ,       __lowerCamelCase    :				Optional[Any]    ,       __lowerCamelCase    :				Any    ,       __lowerCamelCase    :				int    ,       *__lowerCamelCase    :				Any ):
           snake_case__					:      int  			=						TFCTRLLMHeadModel(config=__lowerCamelCase )
           snake_case__					:      List[str]  			=						{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
           snake_case__					:      Union[str, Any]  			=						model(__lowerCamelCase )
           self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.seq_length, self.vocab_size) )





     def  _lowerCAmelCase			(    self    :				Dict    ,       __lowerCamelCase    :				Any    ,       __lowerCamelCase    :				List[Any]    ,       __lowerCamelCase    :				str    ,       __lowerCamelCase    :				Optional[int]    ,       __lowerCamelCase    :				str    ,       *__lowerCamelCase    :				Optional[int] ):
           snake_case__					:      List[Any]  			=						self.num_labels
           snake_case__					:      str  			=						ids_tensor([self.batch_size]    ,       self.type_sequence_label_size )
           snake_case__					:      Any  			=						{
               'input_ids': input_ids,
               'token_type_ids': token_type_ids,
               'labels': sequence_labels,
           }
           snake_case__					:      Dict  			=						TFCTRLForSequenceClassification(__lowerCamelCase )
           snake_case__					:      Union[str, Any]  			=						model(__lowerCamelCase )
           self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.num_labels) )





     def  _lowerCAmelCase			(    self    :				List[Any] ):
           snake_case__					:      List[str]  			=						self.prepare_config_and_inputs()

           (
               (
               snake_case__
           )			,       (
               snake_case__
           )			,       (
               snake_case__
           )			,       (
               snake_case__
           )			,       (
               snake_case__
           )			,       (
               snake_case__
           )			,       (
               snake_case__
           )			,       (
               snake_case__
           )			,       (
               snake_case__
           )			,       
           )					:      int  			=						config_and_inputs

           snake_case__					:      Tuple  			=						{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
           return config, inputs_dict






@require_tf
class 					lowercase_			(	lowerCAmelCase_	,					lowerCAmelCase_	,					unittest.TestCase       ):
     A_       							= (TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
     A_       							= (TFCTRLLMHeadModel,) if is_tf_available() else ()
     A_       							= (
         {
             "feature-extraction": TFCTRLModel,
             "text-classification": TFCTRLForSequenceClassification,
             "text-generation": TFCTRLLMHeadModel,
             "zero-shot": TFCTRLForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     A_       							= False
     A_       							= False





     def  _lowerCAmelCase			(    self    :				int    ,       __lowerCamelCase    :				Tuple    ,       __lowerCamelCase    :				Tuple    ,       __lowerCamelCase    :				Dict    ,       __lowerCamelCase    :				str    ,       __lowerCamelCase    :				List[str] ):
           if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
                 # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
                 # `CTRLConfig` was never used in pipeline tests, either because of a missing checkpoint or because a tiny
                 # config could not be created.
                 return True

           return False





     def  _lowerCAmelCase			(    self    :				Optional[int] ):
           snake_case__					:      List[Any]  			=						TFCTRLModelTester(self )
           snake_case__					:      Tuple  			=						ConfigTester(self    ,       config_class=__lowerCamelCase    ,       n_embd=37 )





     def  _lowerCAmelCase			(    self    :				Union[str, Any] ):
           self.config_tester.run_common_tests()





     def  _lowerCAmelCase			(    self    :				Any ):
           snake_case__					:      Optional[Any]  			=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_ctrl_model(*__lowerCamelCase )





     def  _lowerCAmelCase			(    self    :				Any ):
           snake_case__					:      str  			=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_ctrl_lm_head(*__lowerCamelCase )





     def  _lowerCAmelCase			(    self    :				Optional[int] ):
           snake_case__					:      Any  			=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_ctrl_for_sequence_classification(*__lowerCamelCase )





     def  _lowerCAmelCase			(    self    :				List[str] ):
           snake_case__			,       snake_case__					:      str  			=						self.model_tester.prepare_config_and_inputs_for_common()
           snake_case__					:      Optional[Any]  			=						[TFCTRLLMHeadModel]
           snake_case__					:      Optional[int]  			=						[TFCTRLForSequenceClassification]

           for model_class in self.all_model_classes:
                 snake_case__					:      Dict  			=						model_class(__lowerCamelCase )
                 model.build()  # may be needed for the get_bias() call below
                 assert isinstance(model.get_input_embeddings()    ,       tf.keras.layers.Layer )

                 if model_class in list_lm_models:
                       snake_case__					:      List[str]  			=						model.get_output_embeddings()
                       assert isinstance(__lowerCamelCase    ,       tf.keras.layers.Layer )
                       snake_case__					:      Any  			=						model.get_bias()
                       assert isinstance(__lowerCamelCase    ,       __lowerCamelCase )
                       for k, v in name.items():
                             assert isinstance(__lowerCamelCase    ,       tf.Variable )
                 elif model_class in list_other_models_with_output_ebd:
                       snake_case__					:      Any  			=						model.get_output_embeddings()
                       assert isinstance(__lowerCamelCase    ,       tf.keras.layers.Layer )
                       snake_case__					:      int  			=						model.get_bias()
                       assert name is None
                 else:
                       snake_case__					:      Tuple  			=						model.get_output_embeddings()
                       assert x is None
                       snake_case__					:      Optional[int]  			=						model.get_bias()
                       assert name is None





     @slow
     def  _lowerCAmelCase			(    self    :				Any ):
           for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 snake_case__					:      List[str]  			=						TFCTRLModel.from_pretrained(__lowerCamelCase )
                 self.assertIsNotNone(__lowerCamelCase )






@require_tf
class 					lowercase_			(	unittest.TestCase       ):





     @slow
     def  _lowerCAmelCase			(    self    :				Tuple ):
           snake_case__					:      str  			=						TFCTRLLMHeadModel.from_pretrained('ctrl' )
           snake_case__					:      List[Any]  			=						tf.convert_to_tensor([[11859, 0, 1611, 8]]    ,       dtype=tf.intaa )  # Legal the president is
           snake_case__					:      Optional[Any]  			=						[
               11859,
               0,
               1611,
               8,
               5,
               150,
               26449,
               2,
               19,
               348,
               469,
               3,
               2595,
               48,
               20740,
               246533,
               246533,
               19,
               30,
               5,
           ]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

           snake_case__					:      List[Any]  			=						model.generate(__lowerCamelCase    ,       do_sample=__lowerCamelCase )
           self.assertListEqual(output_ids[0].numpy().tolist()    ,       __lowerCamelCase )






'''simple docstring'''






import argparse
import logging
import os
import sys
from collections import namedtuple

import torch
from modeling_bertabs import BertAbs, build_predictor
from torch.utils.data import DataLoader, SequentialSampler
from tqdm import tqdm

from transformers import BertTokenizer

from .utils_summarization import (
    CNNDMDataset,
    build_mask,
    compute_token_type_ids,
    encode_for_summarization,
    truncate_or_pad,
)


A_ 			=		logging.getLogger(__name__)
logging.basicConfig(stream=sys.stdout, level=logging.INFO)


A_ 			=		namedtuple("Batch", ["document_names", "batch_size", "src", "segs", "mask_src", "tgt_str"])






def 		UpperCamelCase__			(		__SCREAMING_SNAKE_CASE		)						->      Dict:
      snake_case__					:      Dict  			=						BertTokenizer.from_pretrained('bert-base-uncased'							,			do_lower_case=__SCREAMING_SNAKE_CASE		)
      snake_case__					:      List[Any]  			=						BertAbs.from_pretrained('remi/bertabs-finetuned-extractive-abstractive-summarization'		)
      model.to(args.device		)
      model.eval()

      snake_case__					:      Optional[int]  			=						{
          'BOS': tokenizer.vocab['[unused0]'],
          'EOS': tokenizer.vocab['[unused1]'],
          'PAD': tokenizer.vocab['[PAD]'],
      }

      if args.compute_rouge:
            snake_case__					:      Any  			=						[]
            snake_case__					:      Any  			=						[]

            import nltk
            import rouge

            nltk.download('punkt'		)
            snake_case__					:      str  			=						rouge.Rouge(
                metrics=['rouge-n', 'rouge-l']							,			max_n=2							,			limit_length=__SCREAMING_SNAKE_CASE							,			length_limit=args.beam_size							,			length_limit_type='words'							,			apply_avg=__SCREAMING_SNAKE_CASE							,			apply_best=__SCREAMING_SNAKE_CASE							,			alpha=0.5							,			weight_factor=1.2							,			stemming=__SCREAMING_SNAKE_CASE							,			)

      # these (unused) arguments are defined to keep the compatibility
      # with the legacy code and will be deleted in a next iteration.
      snake_case__					:      List[Any]  			=						''
      snake_case__					:      int  			=						''

      snake_case__					:      str  			=						build_data_iterator(__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE		)
      snake_case__					:      Optional[Any]  			=						build_predictor(__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE		)

      logger.info('***** Running evaluation *****'		)
      logger.info('  Number examples = %d'							,			len(data_iterator.dataset		)		)
      logger.info('  Batch size = %d'							,			args.batch_size		)
      logger.info(''		)
      logger.info('***** Beam Search parameters *****'		)
      logger.info('  Beam size = %d'							,			args.beam_size		)
      logger.info('  Minimum length = %d'							,			args.min_length		)
      logger.info('  Maximum length = %d'							,			args.max_length		)
      logger.info('  Alpha (length penalty) = %.2f'							,			args.alpha		)
      logger.info('  Trigrams %s be blocked'							,			('will' if args.block_trigram else 'will NOT')		)

      for batch in tqdm(__SCREAMING_SNAKE_CASE		):
            snake_case__					:      Dict  			=						predictor.translate_batch(__SCREAMING_SNAKE_CASE		)
            snake_case__					:      Optional[Any]  			=						predictor.from_batch(__SCREAMING_SNAKE_CASE		)
            snake_case__					:      Union[str, Any]  			=						[format_summary(__SCREAMING_SNAKE_CASE		) for t in translations]
            save_summaries(__SCREAMING_SNAKE_CASE							,			args.summaries_output_dir							,			batch.document_names		)

            if args.compute_rouge:
                  reference_summaries += batch.tgt_str
                  generated_summaries += summaries

      if args.compute_rouge:
            snake_case__					:      int  			=						rouge_evaluator.get_scores(__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE		)
            snake_case__					:      str  			=						format_rouge_scores(__SCREAMING_SNAKE_CASE		)
            save_rouge_scores(__SCREAMING_SNAKE_CASE		)
            print(__SCREAMING_SNAKE_CASE		)






def 		UpperCamelCase__			(		__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE		)						->      Optional[int]:
      for summary, document_name in zip(__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE		):
            # Prepare the summary file's name
            if "." in document_name:
                  snake_case__					:      str  			=						'.'.join(document_name.split('.'		)[:-1]		)
                  snake_case__					:      Optional[int]  			=						document_name.split('.'		)[-1]
                  snake_case__					:      Tuple  			=						bare_document_name + '_summary.' + extension
            else:
                  snake_case__					:      Union[str, Any]  			=						document_name + '_summary'

            snake_case__					:      Union[str, Any]  			=						os.path.join(__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE		)
            with open(__SCREAMING_SNAKE_CASE							,			'w'		) as output:
                  output.write(__SCREAMING_SNAKE_CASE		)






def 		UpperCamelCase__			(		__SCREAMING_SNAKE_CASE		)						->      List[Any]:
      snake_case__			,       snake_case__			,       snake_case__					:      Any  			=						translation
      snake_case__					:      Any  			=						(
          raw_summary.replace('[unused0]'							,			''		)
          .replace('[unused3]'							,			''		)
          .replace('[PAD]'							,			''		)
          .replace('[unused1]'							,			''		)
          .replace(r' +'							,			' '		)
          .replace(' [unused2] '							,			'. '		)
          .replace('[unused2]'							,			''		)
          .strip()
      )

      return summary






def 		UpperCamelCase__			(		__SCREAMING_SNAKE_CASE		)						->      Optional[int]:
      return """\n
****** ROUGE SCORES ******

** ROUGE 1
F1        >> {:.3f}
Precision >> {:.3f}
Recall    >> {:.3f}

** ROUGE 2
F1        >> {:.3f}
Precision >> {:.3f}
Recall    >> {:.3f}

** ROUGE L
F1        >> {:.3f}
Precision >> {:.3f}
Recall    >> {:.3f}""".format(
          scores['rouge-1']['f']							,			scores['rouge-1']['p']							,			scores['rouge-1']['r']							,			scores['rouge-2']['f']							,			scores['rouge-2']['p']							,			scores['rouge-2']['r']							,			scores['rouge-l']['f']							,			scores['rouge-l']['p']							,			scores['rouge-l']['r']							,			)






def 		UpperCamelCase__			(		__SCREAMING_SNAKE_CASE		)						->      Optional[Any]:
      with open('rouge_scores.txt'							,			'w'		) as output:
            output.write(__SCREAMING_SNAKE_CASE		)






def 		UpperCamelCase__			(		__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE		)						->      Any:
      snake_case__					:      Optional[Any]  			=						load_and_cache_examples(__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE		)
      snake_case__					:      Union[str, Any]  			=						SequentialSampler(__SCREAMING_SNAKE_CASE		)

      def collate_fn(__SCREAMING_SNAKE_CASE		):
            return collate(__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE							,			block_size=512							,			device=args.device		)

      snake_case__					:      List[Any]  			=						DataLoader(
          __SCREAMING_SNAKE_CASE							,			sampler=__SCREAMING_SNAKE_CASE							,			batch_size=args.batch_size							,			collate_fn=__SCREAMING_SNAKE_CASE							,			)

      return iterator






def 		UpperCamelCase__			(		__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE		)						->      Dict:
      snake_case__					:      Any  			=						CNNDMDataset(args.documents_dir		)
      return dataset






def 		UpperCamelCase__			(		__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE		)						->      List[Any]:
      snake_case__					:      Optional[int]  			=						[x for x in data if not len(x[1]		) == 0]  # remove empty_files
      snake_case__					:      List[str]  			=						[name for name, _, _ in data]
      snake_case__					:      List[str]  			=						[' '.join(__SCREAMING_SNAKE_CASE		) for _, _, summary_list in data]

      snake_case__					:      int  			=						[encode_for_summarization(__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE		) for _, story, summary in data]
      snake_case__					:      str  			=						torch.tensor(
          [truncate_or_pad(__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE							,			tokenizer.pad_token_id		) for story, _ in encoded_text]		)
      snake_case__					:      Any  			=						compute_token_type_ids(__SCREAMING_SNAKE_CASE							,			tokenizer.cls_token_id		)
      snake_case__					:      List[str]  			=						build_mask(__SCREAMING_SNAKE_CASE							,			tokenizer.pad_token_id		)

      snake_case__					:      int  			=						Batch(
          document_names=__SCREAMING_SNAKE_CASE							,			batch_size=len(__SCREAMING_SNAKE_CASE		)							,			src=encoded_stories.to(__SCREAMING_SNAKE_CASE		)							,			segs=encoder_token_type_ids.to(__SCREAMING_SNAKE_CASE		)							,			mask_src=encoder_mask.to(__SCREAMING_SNAKE_CASE		)							,			tgt_str=__SCREAMING_SNAKE_CASE							,			)

      return batch






def 		UpperCamelCase__			(		__SCREAMING_SNAKE_CASE							,			__SCREAMING_SNAKE_CASE		)						->      Optional[int]:
      snake_case__					:      Optional[Any]  			=						summary_tokens.to('cpu'		).numpy()
      snake_case__					:      Dict  			=						tokenizer.decode(__SCREAMING_SNAKE_CASE		)
      snake_case__					:      Optional[int]  			=						summary.split('.'		)
      snake_case__					:      Dict  			=						[s + '.' for s in sentences]
      return sentences






def 		UpperCamelCase__			(		)						->      Any:
      snake_case__					:      Optional[int]  			=						argparse.ArgumentParser()
      parser.add_argument(
          '--documents_dir'							,			default=__SCREAMING_SNAKE_CASE							,			type=__SCREAMING_SNAKE_CASE							,			required=__SCREAMING_SNAKE_CASE							,			help='The folder where the documents to summarize are located.'							,			)
      parser.add_argument(
          '--summaries_output_dir'							,			default=__SCREAMING_SNAKE_CASE							,			type=__SCREAMING_SNAKE_CASE							,			required=__SCREAMING_SNAKE_CASE							,			help='The folder in wich the summaries should be written. Defaults to the folder where the documents are'							,			)
      parser.add_argument(
          '--compute_rouge'							,			default=__SCREAMING_SNAKE_CASE							,			type=__SCREAMING_SNAKE_CASE							,			required=__SCREAMING_SNAKE_CASE							,			help='Compute the ROUGE metrics during evaluation. Only available for the CNN/DailyMail dataset.'							,			)
      # EVALUATION options
      parser.add_argument(
          '--no_cuda'							,			default=__SCREAMING_SNAKE_CASE							,			type=__SCREAMING_SNAKE_CASE							,			help='Whether to force the execution on CPU.'							,			)
      parser.add_argument(
          '--batch_size'							,			default=4							,			type=__SCREAMING_SNAKE_CASE							,			help='Batch size per GPU/CPU for training.'							,			)
      # BEAM SEARCH arguments
      parser.add_argument(
          '--min_length'							,			default=50							,			type=__SCREAMING_SNAKE_CASE							,			help='Minimum number of tokens for the summaries.'							,			)
      parser.add_argument(
          '--max_length'							,			default=200							,			type=__SCREAMING_SNAKE_CASE							,			help='Maixmum number of tokens for the summaries.'							,			)
      parser.add_argument(
          '--beam_size'							,			default=5							,			type=__SCREAMING_SNAKE_CASE							,			help='The number of beams to start with for each example.'							,			)
      parser.add_argument(
          '--alpha'							,			default=0.95							,			type=__SCREAMING_SNAKE_CASE							,			help='The value of alpha for the length penalty in the beam search.'							,			)
      parser.add_argument(
          '--block_trigram'							,			default=__SCREAMING_SNAKE_CASE							,			type=__SCREAMING_SNAKE_CASE							,			help='Whether to block the existence of repeating trigrams in the text generated by beam search.'							,			)
      snake_case__					:      str  			=						parser.parse_args()

      # Select device (distibuted not available)
      snake_case__					:      str  			=						torch.device('cuda' if torch.cuda.is_available() and not args.no_cuda else 'cpu'		)

      # Check the existence of directories
      if not args.summaries_output_dir:
            snake_case__					:      Union[str, Any]  			=						args.documents_dir

      if not documents_dir_is_valid(args.documents_dir		):
            raise FileNotFoundError(
                'We could not find the directory you specified for the documents to summarize, or it was empty. Please'
                ' specify a valid path.'		)
      os.makedirs(args.summaries_output_dir							,			exist_ok=__SCREAMING_SNAKE_CASE		)

      evaluate(__SCREAMING_SNAKE_CASE		)






def 		UpperCamelCase__			(		__SCREAMING_SNAKE_CASE		)						->      Dict:
      if not os.path.exists(__SCREAMING_SNAKE_CASE		):
            return False

      snake_case__					:      int  			=						os.listdir(__SCREAMING_SNAKE_CASE		)
      if len(__SCREAMING_SNAKE_CASE		) == 0:
            return False

      return True


if __name__ == "__main__":
      main()
