8000 Remove the report from pylint. by schmmd · Pull Request #1932 · allenai/allennlp · GitHub
[go: up one dir, main page]
More Web Proxy on the site http://driver.im/
Skip to content
This repository was archived by the owner on Dec 16, 2022. It is now read-only.

Remove the report from pylint. #1932

Merged
merged 1 commit into from
Oct 22, 2018
Merged

Remove the report from pylint. #1932

merged 1 commit into from
Oct 22, 2018

Conversation

schmmd
Copy link
Member
@schmmd schmmd commented Oct 22, 2018

This disables the report, which I've never used and is quite annoying to scroll back over. That said, others may use this and there's no sense merging it if anyone has an objection. Sample output:

Verifying with ['pylint']
Linter (pylint):
Using config file /Users/michael/hack/allenai/allennlp/.pylintrc
************* Module allennlp.tests.commands.train_test
C: 21, 0: Exactly one space required after comma
        params = lambda: Params({"model": {"type": "simple_tagger","text_field_embedder": {"tokens": {
                                                                  ^ (bad-whitespace)
C: 22, 0: Wrong hanging indentation (remove 24 spaces).
                                        "type": "embedding",
                |                       ^ (bad-continuation)
C: 23, 0: Wrong hanging indentation (remove 24 spaces).
                                        "embedding_dim": 5
                |                       ^ (bad-continuation)
C: 24, 0: Wrong hanging indentation.
                                }
        |       |               ^ (bad-continuation)
C: 25, 0: Wrong continued indentation (add 66 spaces).
                        },
                        ^                                                                 | (bad-continuation)
C: 26, 0: Wrong continued indentation (add 19 spaces).
                        "encoder": {
                        ^                  | (bad-continuation)
C: 32, 0: Wrong continued indentation (add 26 spaces).
                },
                ^                         | (bad-continuation)
C: 33, 0: Wrong continued indentation (add 17 spaces).
                "dataset_reader": {"type": "sequence_tagging"},
                ^                | (bad-continuation)
C: 34, 0: Wrong continued indentation (add 17 spaces).
                "train_data_path": SEQUENCE_TAGGING_DATA_PATH,
                ^                | (bad-continuation)
C: 35, 0: Wrong continued indentation (add 17 spaces).
                "validation_data_path": SEQUENCE_TAGGING_DATA_PATH,
                ^                | (bad-continuation)
C: 36, 0: Wrong continued indentation (add 17 spaces).
                "iterator": {"type": "basic", "batch_size": 2},
                ^                | (bad-continuation)
C: 37, 0: Wrong continued indentation (add 17 spaces).
                "trainer": {
                ^                | (bad-continuation)
C: 41, 0: Wrong continued indentation (add 24 spaces).
        })
        ^                       | (bad-continuation)

--------------------------------------------------------------------
Your code has been rated at 10.00/10 (previous run: 10.00/10, +0.00)

The following is omitted.

Report
======
33090 statements analysed.

Statistics by type
------------------

+---------+-------+-----------+-----------+------------+---------+
|type     |number |old number |difference |%documented |%badname |
+=========+=======+===========+===========+============+=========+
|module   |590    |590        |=          |23.39       |0.00     |
+---------+-------+-----------+-----------+------------+---------+
|class    |602    |602        |=          |49.67       |4.15     |
+---------+-------+-----------+-----------+------------+---------+
|method   |2659   |2659       |=          |52.58       |13.24    |
+---------+-------+-----------+-----------+------------+---------+
|function |330    |330        |=          |61.82       |2.42     |
+---------+-------+-----------+-----------+------------+---------+



External dependencies
---------------------
::

    _jsonnet (allennlp.tests.nn.initializers_test)
    allennlp (allennlp.common.util)
      \-commands (allennlp.tests.commands.elmo_test)
      | \-configure (allennlp.commands)
      | \-dry_run (allennlp.tests.commands.dry_run_test)
      | \-elmo (allennlp.tests.commands.elmo_test)
      | \-evaluate (allennlp.tests.commands.evaluate_test)
      | \-find_learning_rate (allennlp.tests.commands.find_learning_rate_test)
      | \-fine_tune (allennlp.tests.commands.fine_tune_test)
      | \-make_vocab (allennlp.tests.commands.make_vocab_test)
      | \-predict (allennlp.tests.commands.predict_test)
      | \-subcommand (allennlp.tests.commands.main_test)
      | \-test_install (allennlp.tests.commands.test_install_test)
      | \-train (allennlp.tests.modules.token_embedders.elmo_token_embedder_test)
      \-common (allennlp.service.server_simple)
      | \-Params (allennlp.training.trainer)
      | \-Registrable (allennlp.training.trainer)
      | \-Tqdm (allennlp.modules.token_embedders.embedding)
      | \-checks (allennlp.training.trainer)
      | \-configuration (allennlp.tests.common.configuration_test)
      | \-file_utils (allennlp.tests.semparse.worlds.atis_world_test)
      | \-from_params (allennlp.tests.common.from_params_test)
      | \-params (allennlp.tests.training.metrics.span_based_f1_measure_test)
      | \-registrable (allennlp.training.metrics.metric)
      | \-tee_logger (allennlp.common.util)
      | \-testing (allennlp.tests.training.metrics.span_based_f1_measure_test)
      | | \-model_test_case (allennlp.tests.models.graph_parser_test)
      | | \-test_case (allennlp.tests.modules.matrix_attention.linear_matrix_attention_test)
      | \-tqdm (allennlp.training.trainer)
      | \-util (allennlp.training.trainer)
      \-custom_extensions 
      | \-_ext 
      |   \-highway_lstm_layer (allennlp.modules.alternating_highway_lstm)
      \-data (allennlp.tests.semparse.contexts.table_question_knowledge_graph_test)
      | \-Instance (allennlp.tests.modules.elmo_test)
      | \-Vocabulary (allennlp.tests.training.metrics.span_based_f1_measure_test)
      | \-dataset (allennlp.tests.modules.token_embedders.openai_transformer_embedder_test)
      | \-dataset_readers (allennlp.tests.training.trainer_test)
      | | \-ccgbank (allennlp.data.dataset_readers)
      | | \-conll2000 (allennlp.tests.data.dataset_readers.conll2000_dataset_reader_test)
      | | \-conll2003 (allennlp.tests.data.dataset_readers.conll2003_dataset_reader_test)
      | | \-coreference_resolution (allennlp.data.dataset_readers)
      | | | \-conll (allennlp.data.dataset_readers.coreference_resolution)
      | | | \-winobias (allennlp.data.dataset_readers.coreference_resolution)
      | | \-dataset_reader (allennlp.tests.data.iterators.basic_iterator_test)
      | | \-dataset_utils (allennlp.data.dataset_readers.coreference_resolution.winobias)
      | | | \-Ontonotes (allennlp.data.dataset_readers.coreference_resolution.conll)
      | | | \-ontonotes (allennlp.data.dataset_readers.dataset_utils.span_utils)
      | | | \-span_utils (allennlp.training.metrics.span_based_f1_measure)
      | | | \-text2sql_utils (allennlp.semparse.worlds.text2sql_world)
      | | \-event2mind (allennlp.data.dataset_readers)
      | | \-language_modeling (allennlp.data.dataset_readers)
      | | \-multiprocess_dataset_reader (allennlp.data.dataset_readers)
      | | \-ontonotes_ner (allennlp.tests.data.dataset_readers.ontonotes_ner_test)
      | | \-penn_tree_bank (allennlp.data.dataset_readers)
      | | \-quora_paraphrase (allennlp.data.dataset_readers)
      | | \-reading_comprehension (allennlp.data.dataset_readers)
      | | | \-quac (allennlp.data.dataset_readers.reading_comprehension)
      | | | \-squad (allennlp.data.dataset_readers.reading_comprehension)
      | | | \-triviaqa (allennlp.data.dataset_readers.reading_comprehension)
      | | | \-util (allennlp.tests.data.dataset_readers.reading_comprehension.util_test)
      | | \-semantic_dependency_parsing (allennlp.tests.data.dataset_readers.semantic_dependency_parsing)
      | | \-semantic_parsing (allennlp.data.dataset_readers.wikitables)
      | | | \-atis (allennlp.data.dataset_readers.semantic_parsing)
      | | | \-grammar_based_text2sql (allennlp.data.dataset_readers.semantic_parsing)
      | | | \-nlvr (allennlp.data.dataset_readers.semantic_parsing)
      | | | \-quarel (allennlp.predictors.quarel_parser)
      | | | \-template_text2sql (allennlp.data.dataset_readers.semantic_parsing)
      | | | \-wikitables 
      | | |   \-util (allennlp.data.dataset_readers.semantic_parsing.wikitables.wikitables)
      | | |   \-wikitables (allennlp.data.dataset_readers.semantic_parsing)
      | | \-semantic_role_labeling (allennlp.tests.data.dataset_readers.srl_dataset_reader_test)
      | | \-seq2seq (allennlp.data.dataset_readers)
      | | \-sequence_tagging (allennlp.data.dataset_readers)
      | | \-simple_language_modeling (allennlp.data.dataset_readers)
      | | \-snli (allennlp.data.dataset_readers)
      | | \-stanford_sentiment_tree_bank (allennlp.data.dataset_readers)
      | | \-universal_dependencies (allennlp.data.dataset_readers)
      | \-fields (allennlp.tests.data.fields.text_field_test)
      | | \-Field (allennlp.data.dataset_readers.semantic_parsing.wikitables.wikitables)
      | | \-adjacency_field (allennlp.data.fields)
      | | \-array_field (allennlp.data.fields)
      | | \-field (allennlp.data.fields.knowledge_graph_field)
      | | \-index_field (allennlp.data.fields)
      | | \-knowledge_graph_field (allennlp.data.fields)
      | | \-label_field (allennlp.data.fields)
      | | \-list_field (allennlp.data.fields)
      | | \-metadata_field (allennlp.data.fields)
      | | \-multilabel_field (allennlp.data.fields)
      | | \-production_rule_field (allennlp.state_machines.states.grammar_based_state)
      | | \-sequence_field (allennlp.data.fields.text_field)
      | | \-sequence_label_field (allennlp.data.fields)

8000
      | | \-span_field (allennlp.data.fields)
      | | \-text_field (allennlp.data.fields)
      | \-instance (allennlp.training.trainer)
      | \-iterators (allennlp.tests.training.trainer_test)
      | | \-basic_iterator (allennlp.data.iterators)
      | | \-bucket_iterator (allennlp.data.iterators.epoch_tracking_bucket_iterator)
      | | \-data_iterator (allennlp.training.trainer)
      | | \-epoch_tracking_bucket_iterator (allennlp.data.iterators)
      | | \-multiprocess_iterator (allennlp.data.iterators)
      | \-token_indexers (allennlp.tests.modules.token_embedders.openai_transformer_embedder_test)
      | | \-dep_label_indexer (allennlp.data.token_indexers)
      | | \-elmo_indexer (allennlp.tests.modules.elmo_test)
      | | \-ner_tag_indexer (allennlp.data.token_indexers)
      | | \-openai_transformer_byte_pair_indexer (allennlp.tests.modules.token_embedders.openai_transformer_embedder_test)
      | | \-pos_tag_indexer (allennlp.data.token_indexers)
      | | \-single_id_token_indexer (allennlp.tests.modules.elmo_test)
      | | \-token_characters_indexer (allennlp.data.token_indexers)
      | | \-token_indexer (allennlp.tests.common.registrable_test)
      | \-tokenizers (allennlp.tests.semparse.executors.wikitables_variable_free_executor_test)
      | | \-Token (allennlp.tests.semparse.worlds.wikitables_world_test)
      | | \-Tokenizer (allennlp.semparse.worlds.atis_world)
      | | \-character_tokenizer (allennlp.tests.data.token_indexers.character_token_indexer_test)
      | | \-token (allennlp.tests.data.tokenizers.word_splitter_test)
      | | \-tokenizer (allennlp.tests.common.registrable_test)
      | | \-word_filter (allennlp.data.tokenizers.word_tokenizer)
      | | \-word_splitter (allennlp.tests.semparse.contexts.table_question_context_test)
      | | \-word_stemmer (allennlp.data.tokenizers.word_tokenizer)
      | | \-word_tokenizer (allennlp.data.tokenizers)
      | \-vocabulary (allennlp.training.metrics.span_based_f1_measure)
      \-models (allennlp.tests.models.reading_comprehension.bidaf_test)
      | \-Model (allennlp.tests.models.semantic_parsing.nlvr.nlvr_coverage_semantic_parser_test)
      | \-archival (allennlp.tests.service.server_simple_test)
      | \-biaffine_dependency_parser (allennlp.models)
      | \-biattentive_classification_network (allennlp.models)
      | \-bidirectional_lm (allennlp.models)
      | \-bimpm (allennlp.models)
      | \-constituency_parser (allennlp.tests.models.constituency_parser_test)
      | \-coreference_resolution 
      | | \-coref (allennlp.models.coreference_resolution)
      | \-crf_tagger (allennlp.models)
      | \-decomposable_attention (allennlp.models)
      | \-encoder_decoders 
      | | \-simple_seq2seq (allennlp.models.encoder_decoders)
      | \-ensemble (allennlp.models.reading_comprehension.bidaf_ensemble)
      | \-esim (allennlp.models)
      | \-event2mind (allennlp.models)
      | \-graph_parser (allennlp.models)
      | \-model (allennlp.training.trainer)
      | \-reading_comprehension 
      | | \-bidaf (allennlp.models.reading_comprehension.bidaf_ensemble)
      | | \-bidaf_ensemble (allennlp.tests.models.reading_comprehension.bidaf_ensemble_test)
      | | \-dialog_qa (allennlp.models.reading_comprehension)
      | \-semantic_parsing 
      | | \-atis 
      | | | \-atis_semantic_parser (allennlp.models)
      | | \-nlvr 
      | | | \-nlvr_coverage_semantic_parser (allennlp.models)
      | | | \-nlvr_direct_semantic_parser (allennlp.models)
      | | | \-nlvr_semantic_parser (allennlp.models.semantic_parsing.nlvr.nlvr_coverage_semantic_parser)
      | | \-quarel 
      | | | \-quarel_semantic_parser (allennlp.models)
      | | \-text2sql_parser (allennlp.tests.models.semantic_parsing.text2sql_parser_test)
      | | \-wikitables 
      | |   \-wikitables_erm_semantic_parser (allennlp.models)
      | |   \-wikitables_mml_semantic_parser (allennlp.models)
      | |   \-wikitables_semantic_parser (allennlp.models.semantic_parsing.wikitables.wikitables_erm_semantic_parser)
      | \-semantic_role_labeler (allennlp.tests.training.metrics.span_based_f1_measure_test)
      | \-simple_tagger (allennlp.tests.training.trainer_test)
      \-modules (allennlp.tests.modules.token_embedders.token_characters_encoder_test)
      | \-Attention (allennlp.tests.state_machines.transition_functions.basic_transition_function_test)
      | \-Elmo (allennlp.models.biattentive_classification_network)
      | \-FeedForward (allennlp.tests.modules.feedforward_test)
      | \-Highway (allennlp.tests.modules.highway_test)
      | \-Maxout (allennlp.tests.modules.maxout_test)
      | \-Pruner (allennlp.tests.modules.pruner_test)
      | \-alternating_highway_lstm (allennlp.modules.seq2seq_encoders)
      | \-attention (allennlp.tests.modules.attention.bilinear_attention_test)
      | | \-Attention (allennlp.modules)
      | | \-attention (allennlp.tests.modules.attention.legacy_attention_test)
      | | \-bilinear_attention (allennlp.modules.attention)
      | | \-cosine_attention (allennlp.tests.modules.attention.cosine_attention_test)
      | | \-dot_product_attention (allennlp.tests.modules.attention.dot_product_attention_test)
      | | \-legacy_attention (allennlp.tests.modules.attention.legacy_attention_test)
      | | \-linear_attention (allennlp.modules.attention)
      | \-augmented_lstm (allennlp.tests.modules.augmented_lstm_test)
      | \-bimpm_matching (allennlp.modules)
      | \-conditional_random_field (allennlp.tests.modules.conditional_random_field_test)
      | \-elmo (allennlp.tests.modules.elmo_test)
      | \-elmo_lstm (allennlp.tests.modules.stacked_elmo_lstm_test)
      | \-encoder_base (allennlp.tests.modules.encoder_base_test)
      | \-feedforward (allennlp.modules.seq2seq_encoders.stacked_self_attention)
      | \-highway (allennlp.modules.seq2vec_encoders.cnn_highway_encoder)
      | \-input_variational_dropout (allennlp.modules)
      | \-layer_norm (allennlp.modules.seq2seq_encoders.stacked_self_attention)
      | \-lstm_cell_with_projection (allennlp.tests.modules.lstm_cell_with_projection_test)
      | \-masked_layer_norm (allennlp.tests.modules.masked_layer_norm_test)
      | \-matrix_attention (allennlp.tests.modules.matrix_attention.linear_matrix_attention_test)
      | | \-bilinear_matrix_attention (allennlp.modules.matrix_attention)
      | | \-cosine_matrix_attention (allennlp.modules.matrix_attention)
      | | \-dot_product_matrix_attention (allennlp.modules.matrix_attention)
      | | \-legacy_matrix_attention (allennlp.tests.modules.matrix_attention.legacy_matrix_attention_test)
      | | \-linear_matrix_attention (allennlp.modules.matrix_attention)
      | | \-matrix_attention (allennlp.tests.modules.matrix_attention.linear_matrix_attention_test)
      | \-maxout (allennlp.modules)
      | \-openai_transformer (allennlp.tests.modules.token_embedders.openai_transformer_embedder_test)
      | \-pruner (allennlp.modules)
      | \-scalar_mix (allennlp.modules.token_embedders.openai_transformer_embedder)
      | \-seq2seq_encoders (allennlp.tests.modules.seq2seq_encoders.pytorch_seq2seq_wrapper_test)
      | | \-gated_cnn_encoder (allennlp.tests.modules.seq2seq_encoders.gated_cnn_encoder_test)
      | | \-intra_sentence_attention (allennlp.modules.seq2seq_encoders)
      | | \-multi_head_self_attention (allennlp.modules.seq2seq_encoders.stacked_self_attention)
      | | \-pass_through_encoder (allennlp.modules.seq2seq_encoders)
      | | \-pytorch_seq2seq_wrapper (allennlp.modules.seq2seq_encoders)
      | | \-seq2seq_encoder (allennlp.tests.common.registrable_test)
      | | \-stacked_self_attention (allennlp.modules.seq2seq_encoders)
      | \-seq2vec_encoders (allennlp.tests.modules.seq2vec_encoders.pytorch_seq2vec_wrapper_test)
      | | \-boe_encoder (allennlp.modules.seq2vec_encoders)
      | | \-cnn_encoder (allennlp.modules.seq2vec_encoders)
      | | \-cnn_highway_encoder (allennlp.tests.modules.seq2vec_encoders.cnn_highway_encoder_test)
      | | \-pytorch_seq2vec_wrapper (allennlp.modules.seq2vec_encoders)
      | | \-seq2vec_encoder (allennlp.tests.common.registrable_test)
      | \-similarity_functions (allennlp.tests.modules.similarity_functions.linear_test)
      | | \-bilinear (allennlp.modules.similarity_functions)
      | | \-cosine (allennlp.modules.similarity_functions)
      | | \-dot_product (allennlp.tests.modules.matrix_attention.legacy_matrix_attention_test)
      | | \-linear (allennlp.modules.similarity_functions)
      | | \-multiheaded (allennlp.modules.similarity_functions)
      | | \-similarity_function (allennlp.modules.similarity_functions.multiheaded)
      | \-span_extractors (allennlp.tests.modules.span_extractors.self_attentive_span_extractor_test)
      | | \-bidirectional_endpoint_span_extractor (allennlp.modules.span_extractors)
      | | \-endpoint_span_extractor (allennlp.modules.span_extractors)
      | | \-self_attentive_span_extractor (allennlp.modules.span_extractors)
      | | \-span_extractor (allennlp.modules.span_extractors.self_attentive_span_extractor)
      | \-stacked_alternating_lstm (allennlp.tests.modules.stacked_alternating_lstm_test)
      | \-stacked_bidirectional_lstm (allennlp.tests.modules.stacked_bidirectional_lstm_test)
      | \-text_field_embedders (allennlp.tests.modules.text_field_embedders.basic_text_field_embedder_test)
      | | \-basic_text_field_embedder (allennlp.modules.text_field_embedders)
      | | \-text_field_embedder (allennlp.tests.common.registrable_test)
      | \-time_distributed (allennlp.tests.modules.seq2vec_encoders.cnn_highway_encoder_test)
      | \-token_embedders (allennlp.tests.modules.token_embedders.openai_transformer_embedder_test)
      |   \-Embedding (allennlp.tests.modules.token_embedders.token_characters_encoder_test)
      |   \-elmo_token_embedder (allennlp.modules.token_embedders)
      |   \-embedding (allennlp.tests.modules.token_embedders.embedding_test)
      |   \-openai_transformer_embedder (allennlp.modules.token_embedders)
      |   \-token_characters_encoder (allennlp.modules.token_embedders)
      |   \-token_embedder (allennlp.tests.common.registrable_test)
      \-nn (allennlp.tests.nn.initializers_test)
      | \-activations (allennlp.nn)
      | \-beam_search (allennlp.tests.nn.beam_search_test)
      | \-chu_liu_edmonds (allennlp.tests.nn.chu_liu_edmonds_test)
      | \-initializers (allennlp.tests.nn.initializers_test)
      | \-regularizers (allennlp.tests.nn.regularizers_test)
      | | \-Regularizer (allennlp.common.configuration)
      | | \-regularizer (allennlp.tests.common.registrable_test)
      | | \-regularizer_applicator (allennlp.nn.regularizers)
      | | \-regularizers (allennlp.nn.regularizers)
      | \-util (allennlp.training.trainer)
      \-predictors (allennlp.tests.commands.predict_test)
      | \-Predictor (allennlp.tests.service.server_simple_test)
      | \-atis_parser (allennlp.predictors)
      | \-biaffine_dependency_parser (allennlp.predictors)
      | \-bidaf (allennlp.tests.service.config_explorer_test)
      | \-constituency_parser (allennlp.tests.predictors.constituency_parser_test)
      | \-coref (allennlp.service.predictors.coref)
      | \-decomposable_attention (allennlp.service.predictors.decomposable_attention)
      | \-dialog_qa (allennlp.predictors)
      | \-event2mind (allennlp.predictors)
      | \-nlvr_parser (allennlp.service.predictors.nlvr_parser)
      | \-open_information_extraction (allennlp.tests.predictors.open_information_extraction_test)
      | \-predictor (allennlp.service.predictors.predictor)
      | \-quarel_parser (allennlp.predictors)
      | \-semantic_role_labeler (allennlp.service.predictors.semantic_role_labeler)
      | \-sentence_tagger (allennlp.service.predictors.sentence_tagger)
      | \-simple_seq2seq (allennlp.service.predictors.simple_seq2seq)
      | \-wikitables_parser (allennlp.tests.predictors.wikitables_parser_test)
      \-pretrained (allennlp.tests.models.sniff_test)
      \-semparse (allennlp.tests.semparse.worlds.wikitables_world_test)
      | \-action_space_walker (allennlp.semparse)
      | \-contexts (allennlp.tests.semparse.worlds.wikitables_world_test)
      | | \-atis_sql_table_context (allennlp.semparse.worlds.atis_world)
      | | \-knowledge_graph (allennlp.semparse.worlds.quarel_world)
      | | \-quarel_utils (allennlp.tests.models.semantic_parsing.quarel.quarel_semantic_parser_test)
      | | \-sql_context_utils (allennlp.tests.semparse.worlds.text2sql_world_test)
      | | \-table_question_context (allennlp.semparse.contexts)
      | | \-table_question_knowledge_graph (allennlp.semparse.executors.wikitables_variable_free_executor)
      | | \-text2sql_table_context (allennlp.semparse.worlds.text2sql_world)
      | \-executors (allennlp.tests.semparse.executors.wikitables_variable_free_executor_test)
      | | \-nlvr_executor (allennlp.semparse.executors)
      | | \-sql_executor (allennlp.semparse.executors)
      | | \-wikitables_sempre_executor (allennlp.tests.semparse.executors.wikitables_sempre_executor_test)
      | | \-wikitables_variable_free_executor (allennlp.tests.semparse.executors.wikitables_variable_free_executor_test)
      | \-type_declarations 
      | | \-nlvr_type_declaration (allennlp.semparse.worlds.nlvr_world)
      | | \-quarel_type_declaration (allennlp.semparse.worlds.quarel_world)
      | | \-type_declaration (allennlp.tests.state_machines.transition_functions.basic_transition_function_test)
      | | \-wikitables_lambda_dcs (allennlp.tests.semparse.worlds.wikitables_world_test)
      | | \-wikitables_variable_free (allennlp.tests.semparse.worlds.wikitables_variable_free_world_test)
      | \-util (allennlp.tests.semparse.util_test)
      | \-worlds (allennlp.tests.semparse.worlds.wikitables_world_test)
      |   \-atis_world (allennlp.tests.semparse.worlds.atis_world_test)
      |   \-nlvr_box (allennlp.tests.semparse.executors.nlvr_executor_test)
      |   \-nlvr_object (allennlp.semparse.worlds.nlvr_box)
      |   \-nlvr_world (allennlp.tests.semparse.worlds.nlvr_world_test)
      |   \-quarel_world (allennlp.semparse.contexts.quarel_utils)
      |   \-text2sql_world (allennlp.tests.semparse.worlds.text2sql_world_test)
      |   \-wikitables_variable_free_world (allennlp.semparse.worlds)
      |   \-wikitables_world (allennlp.semparse.worlds)
      |   \-world (allennlp.tests.semparse.executors.wikitables_variable_free_executor_test)
      \-service 
      | \-config_explorer (allennlp.tests.service.config_explorer_test)
      | \-server_simple (allennlp.tests.service.server_simple_test)
      \-state_machines (allennlp.tests.state_machines.simple_transition_system)
      | \-beam_search (allennlp.state_machines)
      | \-constrained_beam_search (allennlp.state_machines.trainers.maximum_marginal_likelihood)
      | \-states (allennlp.tests.state_machines.transition_functions.basic_transition_function_test)
      | | \-State (allennlp.state_machines.trainers.expected_risk_minimization)
      | | \-checklist_statelet (allennlp.state_machines.states.coverage_state)
      | | \-coverage_state (allennlp.state_machines.states)
      | | \-grammar_based_state (allennlp.state_machines.states.coverage_state)
      | | \-grammar_statelet (allennlp.state_machines.states.grammar_based_state)
      | | \-lambda_grammar_statelet (allennlp.state_machines.states)
      | | \-rnn_statelet (allennlp.state_machines.states.grammar_based_state)
      | | \-state (allennlp.state_machines.states.grammar_based_state)
      | \-trainers (allennlp.tests.state_machines.trainers.expected_risk_minimization_test)
      | | \-decoder_trainer (allennlp.state_machines.trainers.expected_risk_minimization)
      | | \-expected_risk_minimization (allennlp.state_machines.trainers)
      | | \-maximum_marginal_likelihood (allennlp.state_machines.trainers)
      | \-transition_functions (allennlp.tests.state_machines.transition_functions.basic_transition_function_test)
      | | \-basic_transition_function (allennlp.state_machines.transition_functions.linking_transition_function)
      | | \-coverage_transition_function (allennlp.state_machines.transition_functions.linking_coverage_transition_function)
      | | \-linking_coverage_transition_function (allennlp.state_machines.transition_functions)
      | | \-linking_transition_function (allennlp.state_machines.transition_functions)
      | | \-transition_function (allennlp.state_machines.transition_functions.basic_transition_function)
      | \-util (allennlp.tests.state_machines.util_test)
      \-tests 
      | \-data 
      | | \-iterators 
      | |   \-basic_iterator_test (allennlp.tests.data.iterators.multiprocess_iterator_test)
      | \-modules 
      | | \-elmo_test (allennlp.tests.commands.elmo_test)
      | \-state_machines 
      |   \-simple_transition_system (allennlp.tests.state_machines.trainers.expected_risk_minimization_test)
      \-tools 
      | \-squad_eval (allennlp.training.metrics.squad_em_and_f1)
      \-training 
      | \-Trainer (allennlp.tests.models.simple_tagger_test)
      | \-learning_rate_schedulers (allennlp.training.trainer)
      | \-metrics (allennlp.tests.training.metrics.span_based_f1_measure_test)
      | | \-Average (allennlp.models.semantic_parsing.quarel.quarel_semantic_parser)
      | | \-Covariance (allennlp.tests.training.metrics.covariance_test)
      | | \-Entropy (allennlp.tests.training.metrics.entropy_test)
      | | \-Metric (allennlp.tests.training.metrics.span_based_f1_measure_test)
      | | \-attachment_scores (allennlp.training.metrics)
      | | \-average (allennlp.training.metrics)
      | | \-boolean_accuracy (allennlp.training.metrics)
      | | \-categorical_accuracy (allennlp.training.metrics)
      | | \-conll_coref_scores (allennlp.training.metrics)
      | | \-covariance (allennlp.training.metrics.pearson_correlation)
      | | \-entropy (allennlp.training.metrics)
      | | \-evalb_bracketing_scorer (allennlp.training.metrics)
      | | \-f1_measure (allennlp.training.metrics)
      | | \-mean_absolute_error (allennlp.training.metrics)
      | | \-mention_recall (allennlp.training.metrics)
      | | \-metric (allennlp.training.metrics.span_based_f1_measure)
      | | \-pearson_correlation (allennlp.training.metrics)
      | | \-sequence_accuracy (allennlp.training.metrics)
      | | \-span_based_f1_measure (allennlp.training.metrics)
      | | \-squad_em_and_f1 (allennlp.training.metrics)
      | | \-unigram_recall (allennlp.training.metrics)
      | \-optimizers (allennlp.training.trainer)
      \-version (allennlp)
    boto3 (allennlp.tests.common.file_utils_test)
    botocore 
      \-exceptions (allennlp.common.file_utils)
    conllu 
      \-parser (allennlp.data.dataset_readers.universal_dependencies)
    editdistance (allennlp.data.fields.knowledge_graph_field)
    flaky (allennlp.tests.models.semantic_parsing.wikitables.wikitables_mml_semantic_parser_test)
    flask (allennlp.tests.service.server_simple_test)
      \-testing (allennlp.tests.service.server_simple_test)
    flask_cors (allennlp.service.server_simple)
    ftfy (allennlp.data.tokenizers.word_splitter)
    gevent 
      \-pywsgi (allennlp.service.server_simple)
    h5py (allennlp.tests.modules.token_embedders.openai_transformer_embedder_test)
    matplotlib (allennlp.commands.find_learning_rate)
      \-pyplot (allennlp.commands.find_learning_rate)
    moto (allennlp.tests.common.file_utils_test)
    nbconvert 
      \-preprocessors (allennlp.tests.notebooks_test)
        \-execute (allennlp.tests.notebooks_test)
    nbformat (allennlp.tests.notebooks_test)
    nltk (allennlp.semparse.worlds.atis_world)
      \-Tree (allennlp.training.metrics.evalb_bracketing_scorer)
      \-corpus 
      | \-reader 
      |   \-bracket_parse (allennlp.data.dataset_readers.penn_tree_bank)
      \-metrics 
      | \-distance (allennlp.semparse.contexts.quarel_utils)
      \-sem 
      | \-logic (allennlp.tests.semparse.action_space_walker_test)
      \-stem (allennlp.semparse.contexts.quarel_utils)
      \-tree (allennlp.tests.data.dataset_readers.penn_tree_bank_reader_test)
    numpy (allennlp.training.metrics.conll_coref_scores)
      \-testing (allennlp.tests.training.metrics.pearson_correlation_test)
    numpydoc 
      \-docscrape (allennlp.common.configuration)
    overrides 
      \-overrides (allennlp.training.metrics.unigram_recall)
    parsimonious (allennlp.tests.semparse.worlds.text2sql_world_test)
      \-Grammar (allennlp.tests.semparse.worlds.text2sql_world_test)
      \-exceptions (allennlp.semparse.contexts.sql_context_utils)
      \-expressions (allennlp.tests.semparse.worlds.atis_world_test)
      \-grammar (allennlp.semparse.worlds.atis_world)
      \-nodes (allennlp.semparse.contexts.sql_context_utils)
    pytest (allennlp.tests.training.trainer_test)
    requests (allennlp.semparse.executors.wikitables_sempre_executor)
    responses (allennlp.tests.common.file_utils_test)
    six (allennlp.semparse.contexts.sql_context_utils)
    sklearn 
      \-utils 
        \-linear_assignment_ (allennlp.training.metrics.conll_coref_scores)
    spacy (allennlp.tests.modules.token_embedders.openai_transformer_embedder_test)
      \-cli 
      | \-download (allennlp.common.util)
      \-lang 
      | \-en 
      |   \-tag_map (allennlp.predictors.constituency_parser)
      \-language (allennlp.common.util)
      \-tokens 
        \-Token (allennlp.data.fields.text_field)
    sqlparse (allennlp.models.semantic_parsing.atis.atis_semantic_parser)
    tensorboardX (allennlp.training.trainer)
    torch (allennlp.training.trainer)
      \-autograd 
      | \-Function (allennlp.modules.alternating_highway_lstm)
      | \-Variable (allennlp.tests.modules.attention.linear_attention_test)
      \-cuda (allennlp.common.checks)
      \-multiprocessing (allennlp.data.iterators.multiprocess_iterator)
      | \-Queue (allennlp.data.iterators.multiprocess_iterator)
      \-nn (allennlp.tests.modules.seq2vec_encoders.pytorch_seq2vec_wrapper_test)
      | \-Parameter (allennlp.tests.modules.matrix_attention.linear_matrix_attention_test)
      | \-functional (allennlp.modules.token_embedders.embedding)
      | \-init (allennlp.tests.nn.regularizers_test)
      | \-modules 
      | | \-Dropout (allennlp.modules.elmo)
      | | \-Linear (allennlp.models.semantic_role_labeler)
      | | \-linear (allennlp.state_machines.transition_functions.basic_transition_function)
      | | \-rnn (allennlp.tests.modules.augmented_lstm_test)
      | \-parallel 
      | | \-parallel_apply (allennlp.training.trainer)
      | | \-replicate (allennlp.training.trainer)
      | | \-scatter_gather (allennlp.training.trainer)
      | \-parameter (allennlp.tests.modules.similarity_functions.linear_test)
      | \-utils 
      |   \-rnn (allennlp.tests.modules.seq2vec_encoders.pytorch_seq2vec_wrapper_test)
      \-optim 
        \-lr_scheduler (allennlp.training.trainer)
    tqdm (allennlp.data.dataset_readers.semantic_parsing.quarel)
    unidecode (allennlp.semparse.contexts.table_question_knowledge_graph)



Raw metrics
-----------

+----------+-------+------+---------+-----------+
|type      |number |%     |previous |difference |
+==========+=======+======+=========+===========+
|code      |43609  |57.82 |43609    |=          |
+----------+-------+------+---------+-----------+
|docstring |17356  |23.01 |17360    |-4.00      |
+----------+-------+------+---------+-----------+
|comment   |5459   |7.24  |5459     |=          |
+----------+-------+------+---------+-----------+
|empty     |9003   |11.94 |9004     |-1.00      |
+----------+-------+------+---------+-----------+



Duplication
-----------

+-------------------------+------+---------+-----------+
|                         |now   |previous |difference |
+=========================+======+=========+===========+
|nb duplicated lines      |0     |0        |=          |
+-------------------------+------+---------+-----------+
|percent duplicated lines |0.000 |0.000    |=          |
+-------------------------+------+---------+-----------+



Messages by category
--------------------

+-----------+-------+---------+-----------+
|type       |number |previous |difference |
+===========+=======+=========+===========+
|convention |13     |0        |+13.00     |
+-----------+-------+---------+-----------+
|refactor   |0      |0        |=          |
+-----------+-------+---------+-----------+
|warning    |0      |0        |=          |
+-----------+-------+---------+-----------+
|error      |0      |0        |=          |
+-----------+-------+---------+-----------+



% errors / warnings by module
-----------------------------

+-----------------------------------+------+--------+---------+-----------+
|module                             |error |warning |refactor |convention |
+===================================+======+========+=========+===========+
|allennlp.tests.commands.train_test |0.00  |0.00    |0.00     |100.00     |
+-----------------------------------+------+--------+---------+-----------+



Messages
--------

+-----------------+------------+
|message id       |occurrences |
+=================+============+
|bad-continuation |12          |
+-----------------+------------+
|bad-whitespace   |1           |
+-----------------+------------+

joelgrus
joelgrus approved these changes Oct 22, 2018
View reviewed changes
Copy link
Contributor
@joelgrus joelgrus left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

love it

@schmmd schmmd merged commit 3e2d795 into allenai:master Oct 22, 2018
Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.
Reviewers

@joelgrus joelgrus joelgrus approved these changes

@matt-gardner matt-gardner matt-gardner approved these changes

@DeNeutoy DeNeutoy Awaiting requested review from DeNeutoy

Assignees
No one assigned
4A87
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

Successfully merging this pull request may close these issues.
3 participants
@schmmd @joelgrus @matt-gardner
0