diff --git "a/graphify-out/graph.json" "b/graphify-out/graph.json" new file mode 100644--- /dev/null +++ "b/graphify-out/graph.json" @@ -0,0 +1,14522 @@ +{ + "directed": false, + "multigraph": false, + "graph": { + "hyperedges": [ + { + "id": "websocket_channels", + "label": "WebSocket Channel System", + "nodes": [ + "sem_unified_ws", + "sem_feed_ws", + "sem_chat_ws", + "sem_keysync_ws", + "sem_discovery_ws" + ], + "relation": "participate_in", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md" + }, + { + "id": "security_stack", + "label": "Security Defense Stack", + "nodes": [ + "sem_hmac_verification", + "sem_origin_secret", + "sem_pow_challenge", + "sem_rate_limiting", + "sem_attack_detection" + ], + "relation": "participate_in", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md" + }, + { + "id": "feed_pipeline", + "label": "Feed Recommendation Pipeline", + "nodes": [ + "sem_feed_pool", + "sem_feed_filters", + "sem_feed_scoring", + "sem_feed_heatmap", + "sem_feed_reciprocal", + "sem_feed_gradient" + ], + "relation": "form", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/feed_system_documentation.md" + } + ] + }, + "nodes": [ + { + "label": "graph_codebase.py", + "file_type": "code", + "source_file": "graph_codebase.py", + "id": "graph_codebase_py", + "community": 10, + "norm_label": "graph_codebase.py" + }, + { + "label": "graphify_rebuild.py \u2014 One-shot NudR knowledge graph regeneration.\n\nUsage:\n py", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "id": "graph_codebase_py_docstring", + "community": 10, + "norm_label": "graphify_rebuild.py \u2014 one-shot nudr knowledge graph regeneration.\n\nusage:\n py" + }, + { + "label": "detect_files()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 55", + "id": "graph_codebase_py_detect_files", + "community": 10, + "norm_label": "detect_files()" + }, + { + "label": "Walk the project and return list of relevant files with metadata.", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 55", + "id": "graph_codebase_py_detect_files_doc", + "community": 10, + "norm_label": "walk the project and return list of relevant files with metadata." + }, + { + "label": "get_changed_files()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 94", + "id": "graph_codebase_py_get_changed_files", + "community": 10, + "norm_label": "get_changed_files()" + }, + { + "label": "Compare against manifest to find changed files.", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 94", + "id": "graph_codebase_py_get_changed_files_doc", + "community": 10, + "norm_label": "compare against manifest to find changed files." + }, + { + "label": "hash_file()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 109", + "id": "graph_codebase_py_hash_file", + "community": 10, + "norm_label": "hash_file()" + }, + { + "label": "SHA-256 hash for cache keying.", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 109", + "id": "graph_codebase_py_hash_file_doc", + "community": 10, + "norm_label": "sha-256 hash for cache keying." + }, + { + "label": "extract_ast_file()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 119", + "id": "graph_codebase_py_extract_ast_file", + "community": 10, + "norm_label": "extract_ast_file()" + }, + { + "label": "Extract AST nodes and edges from a single Python file.", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 119", + "id": "graph_codebase_py_extract_ast_file_doc", + "community": 10, + "norm_label": "extract ast nodes and edges from a single python file." + }, + { + "label": "_get_call_name()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 271", + "id": "graph_codebase_py__get_call_name", + "community": 10, + "norm_label": "_get_call_name()" + }, + { + "label": "Extract callable name from ast.Call node.", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 271", + "id": "graph_codebase_py__get_call_name_doc", + "community": 10, + "norm_label": "extract callable name from ast.call node." + }, + { + "label": "_get_name()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 280", + "id": "graph_codebase_py__get_name", + "community": 10, + "norm_label": "_get_name()" + }, + { + "label": "Extract name from various AST node types.", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 280", + "id": "graph_codebase_py__get_name_doc", + "community": 10, + "norm_label": "extract name from various ast node types." + }, + { + "label": "_resolve_edges()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 289", + "id": "graph_codebase_py__resolve_edges", + "community": 10, + "norm_label": "_resolve_edges()" + }, + { + "label": "Post-process edges to resolve bare names to actual node IDs.\n\nThe per-file AST e", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 289", + "id": "graph_codebase_py__resolve_edges_doc", + "community": 10, + "norm_label": "post-process edges to resolve bare names to actual node ids.\n\nthe per-file ast e" + }, + { + "label": "run_ast_extraction()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 395", + "id": "graph_codebase_py_run_ast_extraction", + "community": 10, + "norm_label": "run_ast_extraction()" + }, + { + "label": "Run AST extraction on all Python files, with caching.", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 395", + "id": "graph_codebase_py_run_ast_extraction_doc", + "community": 10, + "norm_label": "run ast extraction on all python files, with caching." + }, + { + "label": "build_semantic_nodes()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 446", + "id": "graph_codebase_py_build_semantic_nodes", + "community": 10, + "norm_label": "build_semantic_nodes()" + }, + { + "label": "Build semantic nodes from documentation files.\nThese capture high-level architec", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 446", + "id": "graph_codebase_py_build_semantic_nodes_doc", + "community": 10, + "norm_label": "build semantic nodes from documentation files.\nthese capture high-level architec" + }, + { + "label": "merge_and_build()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 623", + "id": "graph_codebase_py_merge_and_build", + "community": 10, + "norm_label": "merge_and_build()" + }, + { + "label": "Merge AST + semantic, build NetworkX graph, cluster, analyze.", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 623", + "id": "graph_codebase_py_merge_and_build_doc", + "community": 10, + "norm_label": "merge ast + semantic, build networkx graph, cluster, analyze." + }, + { + "label": "generate_outputs()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 717", + "id": "graph_codebase_py_generate_outputs", + "community": 10, + "norm_label": "generate_outputs()" + }, + { + "label": "Generate report, HTML, JSON, and manifest.", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 717", + "id": "graph_codebase_py_generate_outputs_doc", + "community": 10, + "norm_label": "generate report, html, json, and manifest." + }, + { + "label": "run_pipeline()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 765", + "id": "graph_codebase_py_run_pipeline", + "community": 10, + "norm_label": "run_pipeline()" + }, + { + "label": "Execute the full graphify pipeline.", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 765", + "id": "graph_codebase_py_run_pipeline_doc", + "community": 10, + "norm_label": "execute the full graphify pipeline." + }, + { + "label": "watch_mode()", + "file_type": "code", + "source_file": "graph_codebase.py", + "source_location": "line 815", + "id": "graph_codebase_py_watch_mode", + "community": 10, + "norm_label": "watch_mode()" + }, + { + "label": "Watch for file changes and rebuild automatically.", + "file_type": "rationale", + "source_file": "graph_codebase.py", + "source_location": "line 815", + "id": "graph_codebase_py_watch_mode_doc", + "community": 10, + "norm_label": "watch for file changes and rebuild automatically." + }, + { + "label": "json_to_m2.py", + "file_type": "code", + "source_file": "data/raw/fce/json_to_m2.py", + "id": "data_raw_fce_json_to_m2_py", + "community": 13, + "norm_label": "json_to_m2.py" + }, + { + "label": "main()", + "file_type": "code", + "source_file": "data/raw/fce/json_to_m2.py", + "source_location": "line 11", + "id": "data_raw_fce_json_to_m2_py_main", + "community": 13, + "norm_label": "main()" + }, + { + "label": "parse_args()", + "file_type": "code", + "source_file": "data/raw/fce/json_to_m2.py", + "source_location": "line 132", + "id": "data_raw_fce_json_to_m2_py_parse_args", + "community": 13, + "norm_label": "parse_args()" + }, + { + "label": "get_paras()", + "file_type": "code", + "source_file": "data/raw/fce/json_to_m2.py", + "source_location": "line 185", + "id": "data_raw_fce_json_to_m2_py_get_paras", + "community": 13, + "norm_label": "get_paras()" + }, + { + "label": "clean_para()", + "file_type": "code", + "source_file": "data/raw/fce/json_to_m2.py", + "source_location": "line 237", + "id": "data_raw_fce_json_to_m2_py_clean_para", + "community": 13, + "norm_label": "clean_para()" + }, + { + "label": "get_token_edits()", + "file_type": "code", + "source_file": "data/raw/fce/json_to_m2.py", + "source_location": "line 283", + "id": "data_raw_fce_json_to_m2_py_get_token_edits", + "community": 13, + "norm_label": "get_token_edits()" + }, + { + "label": "get_all_tok_starts_and_ends()", + "file_type": "code", + "source_file": "data/raw/fce/json_to_m2.py", + "source_location": "line 324", + "id": "data_raw_fce_json_to_m2_py_get_all_tok_starts_and_ends", + "community": 13, + "norm_label": "get_all_tok_starts_and_ends()" + }, + { + "label": "convert_char_to_tok()", + "file_type": "code", + "source_file": "data/raw/fce/json_to_m2.py", + "source_location": "line 337", + "id": "data_raw_fce_json_to_m2_py_convert_char_to_tok", + "community": 13, + "norm_label": "convert_char_to_tok()" + }, + { + "label": "get_sents()", + "file_type": "code", + "source_file": "data/raw/fce/json_to_m2.py", + "source_location": "line 385", + "id": "data_raw_fce_json_to_m2_py_get_sents", + "community": 13, + "norm_label": "get_sents()" + }, + { + "label": "prepare_sent_edits_output()", + "file_type": "code", + "source_file": "data/raw/fce/json_to_m2.py", + "source_location": "line 464", + "id": "data_raw_fce_json_to_m2_py_prepare_sent_edits_output", + "community": 13, + "norm_label": "prepare_sent_edits_output()" + }, + { + "label": "noop_edit()", + "file_type": "code", + "source_file": "data/raw/fce/json_to_m2.py", + "source_location": "line 481", + "id": "data_raw_fce_json_to_m2_py_noop_edit", + "community": 13, + "norm_label": "noop_edit()" + }, + { + "label": "__init__.py", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/EACL_exp/m2converter/util/__init__.py", + "id": "data_raw_jfleg_repo_EACL_exp_m2converter_util___init___py", + "community": 25, + "norm_label": "__init__.py" + }, + { + "label": "gleu.py", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "id": "data_raw_jfleg_repo_eval_gleu_py", + "community": 12, + "norm_label": "gleu.py" + }, + { + "label": "(Note: This script computes sentence-level GLEU score.)\n\nThis script calculates ", + "file_type": "rationale", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "id": "data_raw_jfleg_repo_eval_gleu_py_docstring", + "community": 12, + "norm_label": "(note: this script computes sentence-level gleu score.)\n\nthis script calculates " + }, + { + "label": "GLEU", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 30", + "id": "data_raw_jfleg_repo_eval_gleu_py_GLEU", + "community": 12, + "norm_label": "gleu" + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 32", + "id": "data_raw_jfleg_repo_eval_gleu_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "load_hypothesis_sentence()", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 35", + "id": "data_raw_jfleg_repo_eval_gleu_py_load_hypothesis_sentence", + "community": 12, + "norm_label": "load_hypothesis_sentence()" + }, + { + "label": "load ngrams for a single sentence", + "file_type": "rationale", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 35", + "id": "data_raw_jfleg_repo_eval_gleu_py_load_hypothesis_sentence_doc", + "community": 12, + "norm_label": "load ngrams for a single sentence" + }, + { + "label": "load_sources()", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 41", + "id": "data_raw_jfleg_repo_eval_gleu_py_load_sources", + "community": 12, + "norm_label": "load_sources()" + }, + { + "label": "load n-grams for all source sentences", + "file_type": "rationale", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 41", + "id": "data_raw_jfleg_repo_eval_gleu_py_load_sources_doc", + "community": 12, + "norm_label": "load n-grams for all source sentences" + }, + { + "label": "load_references()", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 47", + "id": "data_raw_jfleg_repo_eval_gleu_py_load_references", + "community": 12, + "norm_label": "load_references()" + }, + { + "label": "load n-grams for all references", + "file_type": "rationale", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 47", + "id": "data_raw_jfleg_repo_eval_gleu_py_load_references_doc", + "community": 12, + "norm_label": "load n-grams for all references" + }, + { + "label": "get_ngram_counts()", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 78", + "id": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts", + "community": 12, + "norm_label": "get_ngram_counts()" + }, + { + "label": "get ngrams of order n for a tokenized sentence", + "file_type": "rationale", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 78", + "id": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts_doc", + "community": 12, + "norm_label": "get ngrams of order n for a tokenized sentence" + }, + { + "label": "get_ngram_diff()", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 83", + "id": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_diff", + "community": 12, + "norm_label": "get_ngram_diff()" + }, + { + "label": "returns ngrams in a but not in b", + "file_type": "rationale", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 83", + "id": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_diff_doc", + "community": 12, + "norm_label": "returns ngrams in a but not in b" + }, + { + "label": "normalization()", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 90", + "id": "data_raw_jfleg_repo_eval_gleu_py_normalization", + "community": 12, + "norm_label": "normalization()" + }, + { + "label": "get normalized n-gram count", + "file_type": "rationale", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 90", + "id": "data_raw_jfleg_repo_eval_gleu_py_normalization_doc", + "community": 12, + "norm_label": "get normalized n-gram count" + }, + { + "label": "gleu_stats()", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 94", + "id": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats", + "community": 12, + "norm_label": "gleu_stats()" + }, + { + "label": "Collect BLEU-relevant statistics for a single hypothesis/reference pair.\nReturn ", + "file_type": "rationale", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 94", + "id": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats_doc", + "community": 12, + "norm_label": "collect bleu-relevant statistics for a single hypothesis/reference pair.\nreturn " + }, + { + "label": "gleu()", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 120", + "id": "data_raw_jfleg_repo_eval_gleu_py_gleu", + "community": 12, + "norm_label": "gleu()" + }, + { + "label": "Compute GLEU from collected statistics obtained by call(s) to gleu_stats", + "file_type": "rationale", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 120", + "id": "data_raw_jfleg_repo_eval_gleu_py_gleu_doc", + "community": 12, + "norm_label": "compute gleu from collected statistics obtained by call(s) to gleu_stats" + }, + { + "label": "get_gleu_stats()", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 132", + "id": "data_raw_jfleg_repo_eval_gleu_py_get_gleu_stats", + "community": 12, + "norm_label": "get_gleu_stats()" + }, + { + "label": "calculate mean and confidence interval from all GLEU iterations", + "file_type": "rationale", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 132", + "id": "data_raw_jfleg_repo_eval_gleu_py_get_gleu_stats_doc", + "community": 12, + "norm_label": "calculate mean and confidence interval from all gleu iterations" + }, + { + "label": "run_iterations()", + "file_type": "code", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 141", + "id": "data_raw_jfleg_repo_eval_gleu_py_run_iterations", + "community": 12, + "norm_label": "run_iterations()" + }, + { + "label": "run specified number of iterations of GLEU, choosing a reference\nfor each senten", + "file_type": "rationale", + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "source_location": "line 141", + "id": "data_raw_jfleg_repo_eval_gleu_py_run_iterations_doc", + "community": 12, + "norm_label": "run specified number of iterations of gleu, choosing a reference\nfor each senten" + }, + { + "label": "download_all_huggingface_datasets.py", + "file_type": "code", + "source_file": "scripts/download_all_huggingface_datasets.py", + "id": "scripts_download_all_huggingface_datasets_py", + "community": 22, + "norm_label": "download_all_huggingface_datasets.py" + }, + { + "label": "Downloads all publicly available HuggingFace datasets automatically.\nDatasets re", + "file_type": "rationale", + "source_file": "scripts/download_all_huggingface_datasets.py", + "id": "scripts_download_all_huggingface_datasets_py_docstring", + "community": 22, + "norm_label": "downloads all publicly available huggingface datasets automatically.\ndatasets re" + }, + { + "label": "main()", + "file_type": "code", + "source_file": "scripts/download_all_huggingface_datasets.py", + "source_location": "line 27", + "id": "scripts_download_all_huggingface_datasets_py_main", + "community": 22, + "norm_label": "main()" + }, + { + "label": "evaluate.py", + "file_type": "code", + "source_file": "scripts/evaluate.py", + "id": "scripts_evaluate_py", + "community": 1, + "norm_label": "evaluate.py" + }, + { + "label": "Evaluation script.\nRuns all evaluation metrics on the test set.\nRun: python scri", + "file_type": "rationale", + "source_file": "scripts/evaluate.py", + "id": "scripts_evaluate_py_docstring", + "community": 1, + "norm_label": "evaluation script.\nruns all evaluation metrics on the test set.\nrun: python scri" + }, + { + "label": "evaluate()", + "file_type": "code", + "source_file": "scripts/evaluate.py", + "source_location": "line 30", + "id": "scripts_evaluate_py_evaluate", + "community": 1, + "norm_label": "evaluate()" + }, + { + "label": "Run evaluation on the specified data split.", + "file_type": "rationale", + "source_file": "scripts/evaluate.py", + "source_location": "line 30", + "id": "scripts_evaluate_py_evaluate_doc", + "community": 1, + "norm_label": "run evaluation on the specified data split." + }, + { + "label": "preprocess_data.py", + "file_type": "code", + "source_file": "scripts/preprocess_data.py", + "id": "scripts_preprocess_data_py", + "community": 15, + "norm_label": "preprocess_data.py" + }, + { + "label": "Converts all raw dataset formats into unified JSONL training format.\nOutput sche", + "file_type": "rationale", + "source_file": "scripts/preprocess_data.py", + "id": "scripts_preprocess_data_py_docstring", + "community": 15, + "norm_label": "converts all raw dataset formats into unified jsonl training format.\noutput sche" + }, + { + "label": "apply_bea19_edits()", + "file_type": "code", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 19", + "id": "scripts_preprocess_data_py_apply_bea19_edits", + "community": 15, + "norm_label": "apply_bea19_edits()" + }, + { + "label": "Apply BEA-2019 character-level edits to produce corrected text.\n\nedits_block for", + "file_type": "rationale", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 19", + "id": "scripts_preprocess_data_py_apply_bea19_edits_doc", + "community": 15, + "norm_label": "apply bea-2019 character-level edits to produce corrected text.\n\nedits_block for" + }, + { + "label": "process_bea19_json()", + "file_type": "code", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 51", + "id": "scripts_preprocess_data_py_process_bea19_json", + "community": 15, + "norm_label": "process_bea19_json()" + }, + { + "label": "Process a BEA-2019 format JSON file (FCE or W&I+LOCNESS).\nEach line is a JSON ob", + "file_type": "rationale", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 51", + "id": "scripts_preprocess_data_py_process_bea19_json_doc", + "community": 15, + "norm_label": "process a bea-2019 format json file (fce or w&i+locness).\neach line is a json ob" + }, + { + "label": "process_fce()", + "file_type": "code", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 79", + "id": "scripts_preprocess_data_py_process_fce", + "community": 15, + "norm_label": "process_fce()" + }, + { + "label": "Process all FCE JSON files.", + "file_type": "rationale", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 79", + "id": "scripts_preprocess_data_py_process_fce_doc", + "community": 15, + "norm_label": "process all fce json files." + }, + { + "label": "process_wi_locness()", + "file_type": "code", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 93", + "id": "scripts_preprocess_data_py_process_wi_locness", + "community": 15, + "norm_label": "process_wi_locness()" + }, + { + "label": "Process all W&I+LOCNESS JSON files.", + "file_type": "rationale", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 93", + "id": "scripts_preprocess_data_py_process_wi_locness_doc", + "community": 15, + "norm_label": "process all w&i+locness json files." + }, + { + "label": "process_jfleg()", + "file_type": "code", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 107", + "id": "scripts_preprocess_data_py_process_jfleg", + "community": 15, + "norm_label": "process_jfleg()" + }, + { + "label": "JFLEG: .src files (original) and .ref0..ref3 (4 human corrections).\nEach referen", + "file_type": "rationale", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 107", + "id": "scripts_preprocess_data_py_process_jfleg_doc", + "community": 15, + "norm_label": "jfleg: .src files (original) and .ref0..ref3 (4 human corrections).\neach referen" + }, + { + "label": "create_splits()", + "file_type": "code", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 137", + "id": "scripts_preprocess_data_py_create_splits", + "community": 15, + "norm_label": "create_splits()" + }, + { + "label": "Split train.jsonl into train and val sets.", + "file_type": "rationale", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 137", + "id": "scripts_preprocess_data_py_create_splits_doc", + "community": 15, + "norm_label": "split train.jsonl into train and val sets." + }, + { + "label": "main()", + "file_type": "code", + "source_file": "scripts/preprocess_data.py", + "source_location": "line 167", + "id": "scripts_preprocess_data_py_main", + "community": 15, + "norm_label": "main()" + }, + { + "label": "pretrain_human_pattern_classifier.py", + "file_type": "code", + "source_file": "scripts/pretrain_human_pattern_classifier.py", + "id": "scripts_pretrain_human_pattern_classifier_py", + "community": 7, + "norm_label": "pretrain_human_pattern_classifier.py" + }, + { + "label": "Pre-trains the HumanPatternClassifier on both Kaggle datasets.\nRun this BEFORE t", + "file_type": "rationale", + "source_file": "scripts/pretrain_human_pattern_classifier.py", + "id": "scripts_pretrain_human_pattern_classifier_py_docstring", + "community": 7, + "norm_label": "pre-trains the humanpatternclassifier on both kaggle datasets.\nrun this before t" + }, + { + "label": "train_classifier()", + "file_type": "code", + "source_file": "scripts/pretrain_human_pattern_classifier.py", + "source_location": "line 32", + "id": "scripts_pretrain_human_pattern_classifier_py_train_classifier", + "community": 7, + "norm_label": "train_classifier()" + }, + { + "label": "Pre-train the human pattern classifier on Kaggle datasets.", + "file_type": "rationale", + "source_file": "scripts/pretrain_human_pattern_classifier.py", + "source_location": "line 32", + "id": "scripts_pretrain_human_pattern_classifier_py_train_classifier_doc", + "community": 7, + "norm_label": "pre-train the human pattern classifier on kaggle datasets." + }, + { + "label": "run_inference.py", + "file_type": "code", + "source_file": "scripts/run_inference.py", + "id": "scripts_run_inference_py", + "community": 9, + "norm_label": "run_inference.py" + }, + { + "label": "Interactive inference script.\nRun: python scripts/run_inference.py --config conf", + "file_type": "rationale", + "source_file": "scripts/run_inference.py", + "id": "scripts_run_inference_py_docstring", + "community": 9, + "norm_label": "interactive inference script.\nrun: python scripts/run_inference.py --config conf" + }, + { + "label": "run_inference()", + "file_type": "code", + "source_file": "scripts/run_inference.py", + "source_location": "line 21", + "id": "scripts_run_inference_py_run_inference", + "community": 9, + "norm_label": "run_inference()" + }, + { + "label": "Run inference on text input.", + "file_type": "rationale", + "source_file": "scripts/run_inference.py", + "source_location": "line 21", + "id": "scripts_run_inference_py_run_inference_doc", + "community": 9, + "norm_label": "run inference on text input." + }, + { + "label": "train.py", + "file_type": "code", + "source_file": "scripts/train.py", + "id": "scripts_train_py", + "community": 4, + "norm_label": "train.py" + }, + { + "label": "Full training entry point.\nRun: python scripts/train.py --config configs/trainin", + "file_type": "rationale", + "source_file": "scripts/train.py", + "id": "scripts_train_py_docstring", + "community": 4, + "norm_label": "full training entry point.\nrun: python scripts/train.py --config configs/trainin" + }, + { + "label": "_setup_device()", + "file_type": "code", + "source_file": "scripts/train.py", + "source_location": "line 31", + "id": "scripts_train_py__setup_device", + "community": 4, + "norm_label": "_setup_device()" + }, + { + "label": "Detect GPU and configure hybrid VRAM management.\n\nReturns (device, gpu_info) whe", + "file_type": "rationale", + "source_file": "scripts/train.py", + "source_location": "line 31", + "id": "scripts_train_py__setup_device_doc", + "community": 4, + "norm_label": "detect gpu and configure hybrid vram management.\n\nreturns (device, gpu_info) whe" + }, + { + "label": "_auto_batch_size()", + "file_type": "code", + "source_file": "scripts/train.py", + "source_location": "line 82", + "id": "scripts_train_py__auto_batch_size", + "community": 4, + "norm_label": "_auto_batch_size()" + }, + { + "label": "Pick optimal batch size based on model size and available resources.", + "file_type": "rationale", + "source_file": "scripts/train.py", + "source_location": "line 82", + "id": "scripts_train_py__auto_batch_size_doc", + "community": 4, + "norm_label": "pick optimal batch size based on model size and available resources." + }, + { + "label": "train()", + "file_type": "code", + "source_file": "scripts/train.py", + "source_location": "line 126", + "id": "scripts_train_py_train", + "community": 4, + "norm_label": "train()" + }, + { + "label": "Launch the full training pipeline.", + "file_type": "rationale", + "source_file": "scripts/train.py", + "source_location": "line 126", + "id": "scripts_train_py_train_doc", + "community": 4, + "norm_label": "launch the full training pipeline." + }, + { + "label": "CEOnlyLoss", + "file_type": "code", + "source_file": "scripts/train.py", + "source_location": "line 221", + "id": "scripts_train_py_CEOnlyLoss", + "community": 4, + "norm_label": "ceonlyloss" + }, + { + "label": "Cross-entropy only loss \u2014 the only loss that provides gradient signal.", + "file_type": "rationale", + "source_file": "scripts/train.py", + "source_location": "line 221", + "id": "scripts_train_py_CEOnlyLoss_doc", + "community": 4, + "norm_label": "cross-entropy only loss \u2014 the only loss that provides gradient signal." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "scripts/train.py", + "source_location": "line 223", + "id": "scripts_train_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "forward()", + "file_type": "code", + "source_file": "scripts/train.py", + "source_location": "line 227", + "id": "scripts_train_py_forward", + "community": 7, + "norm_label": "forward()" + }, + { + "label": "main.py", + "file_type": "code", + "source_file": "src/api/main.py", + "id": "src_api_main_py", + "community": 9, + "norm_label": "main.py" + }, + { + "label": "FastAPI server for the Dyslexia Academic Writing Corrector API.\nProvides RESTful", + "file_type": "rationale", + "source_file": "src/api/main.py", + "id": "src_api_main_py_docstring", + "community": 9, + "norm_label": "fastapi server for the dyslexia academic writing corrector api.\nprovides restful" + }, + { + "label": "startup()", + "file_type": "code", + "source_file": "src/api/main.py", + "source_location": "line 31", + "id": "src_api_main_py_startup", + "community": 9, + "norm_label": "startup()" + }, + { + "label": "Load config and initialise corrector on startup.", + "file_type": "rationale", + "source_file": "src/api/main.py", + "source_location": "line 31", + "id": "src_api_main_py_startup_doc", + "community": 9, + "norm_label": "load config and initialise corrector on startup." + }, + { + "label": "correct_text()", + "file_type": "code", + "source_file": "src/api/main.py", + "source_location": "line 45", + "id": "src_api_main_py_correct_text", + "community": 9, + "norm_label": "correct_text()" + }, + { + "label": "Correct dyslectic text with style preservation and academic elevation.", + "file_type": "rationale", + "source_file": "src/api/main.py", + "source_location": "line 45", + "id": "src_api_main_py_correct_text_doc", + "community": 9, + "norm_label": "correct dyslectic text with style preservation and academic elevation." + }, + { + "label": "health()", + "file_type": "code", + "source_file": "src/api/main.py", + "source_location": "line 70", + "id": "src_api_main_py_health", + "community": 9, + "norm_label": "health()" + }, + { + "label": "Health check endpoint.", + "file_type": "rationale", + "source_file": "src/api/main.py", + "source_location": "line 70", + "id": "src_api_main_py_health_doc", + "community": 9, + "norm_label": "health check endpoint." + }, + { + "label": "middleware.py", + "file_type": "code", + "source_file": "src/api/middleware.py", + "id": "src_api_middleware_py", + "community": 17, + "norm_label": "middleware.py" + }, + { + "label": "API middleware for request logging, rate limiting, and error handling.", + "file_type": "rationale", + "source_file": "src/api/middleware.py", + "id": "src_api_middleware_py_docstring", + "community": 17, + "norm_label": "api middleware for request logging, rate limiting, and error handling." + }, + { + "label": "RequestLoggingMiddleware", + "file_type": "code", + "source_file": "src/api/middleware.py", + "source_location": "line 13", + "id": "src_api_middleware_py_RequestLoggingMiddleware", + "community": 17, + "norm_label": "requestloggingmiddleware" + }, + { + "label": "Logs all incoming requests with timing information.", + "file_type": "rationale", + "source_file": "src/api/middleware.py", + "source_location": "line 13", + "id": "src_api_middleware_py_RequestLoggingMiddleware_doc", + "community": 17, + "norm_label": "logs all incoming requests with timing information." + }, + { + "label": "RateLimitMiddleware", + "file_type": "code", + "source_file": "src/api/middleware.py", + "source_location": "line 35", + "id": "src_api_middleware_py_RateLimitMiddleware", + "community": 17, + "norm_label": "ratelimitmiddleware" + }, + { + "label": "Simple in-memory rate limiting.", + "file_type": "rationale", + "source_file": "src/api/middleware.py", + "source_location": "line 35", + "id": "src_api_middleware_py_RateLimitMiddleware_doc", + "community": 17, + "norm_label": "simple in-memory rate limiting." + }, + { + "label": "dispatch()", + "file_type": "code", + "source_file": "src/api/middleware.py", + "source_location": "line 45", + "id": "src_api_middleware_py_dispatch", + "community": 17, + "norm_label": "dispatch()" + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/api/middleware.py", + "source_location": "line 38", + "id": "src_api_middleware_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "schemas.py", + "file_type": "code", + "source_file": "src/api/schemas.py", + "id": "src_api_schemas_py", + "community": 20, + "norm_label": "schemas.py" + }, + { + "label": "Pydantic schemas for API request/response validation.", + "file_type": "rationale", + "source_file": "src/api/schemas.py", + "id": "src_api_schemas_py_docstring", + "community": 20, + "norm_label": "pydantic schemas for api request/response validation." + }, + { + "label": "CorrectionRequest", + "file_type": "code", + "source_file": "src/api/schemas.py", + "source_location": "line 9", + "id": "src_api_schemas_py_CorrectionRequest", + "community": 20, + "norm_label": "correctionrequest" + }, + { + "label": "CorrectionResponse", + "file_type": "code", + "source_file": "src/api/schemas.py", + "source_location": "line 15", + "id": "src_api_schemas_py_CorrectionResponse", + "community": 20, + "norm_label": "correctionresponse" + }, + { + "label": "authorship_verifier.py", + "file_type": "code", + "source_file": "src/evaluation/authorship_verifier.py", + "id": "src_evaluation_authorship_verifier_py", + "community": 8, + "norm_label": "authorship_verifier.py" + }, + { + "label": "Authorship verification module.\nUses a fine-tuned model to verify whether the co", + "file_type": "rationale", + "source_file": "src/evaluation/authorship_verifier.py", + "id": "src_evaluation_authorship_verifier_py_docstring", + "community": 8, + "norm_label": "authorship verification module.\nuses a fine-tuned model to verify whether the co" + }, + { + "label": "AuthorshipVerifier", + "file_type": "code", + "source_file": "src/evaluation/authorship_verifier.py", + "source_location": "line 14", + "id": "src_evaluation_authorship_verifier_py_AuthorshipVerifier", + "community": 8, + "norm_label": "authorshipverifier" + }, + { + "label": "Verifies authorship consistency between input and output text.", + "file_type": "rationale", + "source_file": "src/evaluation/authorship_verifier.py", + "source_location": "line 14", + "id": "src_evaluation_authorship_verifier_py_AuthorshipVerifier_doc", + "community": 8, + "norm_label": "verifies authorship consistency between input and output text." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/evaluation/authorship_verifier.py", + "source_location": "line 17", + "id": "src_evaluation_authorship_verifier_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "verify()", + "file_type": "code", + "source_file": "src/evaluation/authorship_verifier.py", + "source_location": "line 26", + "id": "src_evaluation_authorship_verifier_py_verify", + "community": 8, + "norm_label": "verify()" + }, + { + "label": "Return probability that both texts were written by the same author.\n\nUses senten", + "file_type": "rationale", + "source_file": "src/evaluation/authorship_verifier.py", + "source_location": "line 26", + "id": "src_evaluation_authorship_verifier_py_verify_doc", + "community": 8, + "norm_label": "return probability that both texts were written by the same author.\n\nuses senten" + }, + { + "label": "errant_evaluator.py", + "file_type": "code", + "source_file": "src/evaluation/errant_evaluator.py", + "id": "src_evaluation_errant_evaluator_py", + "community": 1, + "norm_label": "errant_evaluator.py" + }, + { + "label": "ERRANT-based grammatical error evaluation.\nUses the ERRANT toolkit for standardi", + "file_type": "rationale", + "source_file": "src/evaluation/errant_evaluator.py", + "id": "src_evaluation_errant_evaluator_py_docstring", + "community": 1, + "norm_label": "errant-based grammatical error evaluation.\nuses the errant toolkit for standardi" + }, + { + "label": "ERRANTEvaluator", + "file_type": "code", + "source_file": "src/evaluation/errant_evaluator.py", + "source_location": "line 11", + "id": "src_evaluation_errant_evaluator_py_ERRANTEvaluator", + "community": 1, + "norm_label": "errantevaluator" + }, + { + "label": "Evaluates grammar correction quality using ERRANT annotations.", + "file_type": "rationale", + "source_file": "src/evaluation/errant_evaluator.py", + "source_location": "line 11", + "id": "src_evaluation_errant_evaluator_py_ERRANTEvaluator_doc", + "community": 1, + "norm_label": "evaluates grammar correction quality using errant annotations." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/evaluation/errant_evaluator.py", + "source_location": "line 14", + "id": "src_evaluation_errant_evaluator_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "evaluate()", + "file_type": "code", + "source_file": "src/evaluation/errant_evaluator.py", + "source_location": "line 23", + "id": "src_evaluation_errant_evaluator_py_evaluate", + "community": 1, + "norm_label": "evaluate()" + }, + { + "label": "Compute ERRANT precision, recall, F0.5.", + "file_type": "rationale", + "source_file": "src/evaluation/errant_evaluator.py", + "source_location": "line 23", + "id": "src_evaluation_errant_evaluator_py_evaluate_doc", + "community": 1, + "norm_label": "compute errant precision, recall, f0.5." + }, + { + "label": "gleu_scorer.py", + "file_type": "code", + "source_file": "src/evaluation/gleu_scorer.py", + "id": "src_evaluation_gleu_scorer_py", + "community": 1, + "norm_label": "gleu_scorer.py" + }, + { + "label": "GLEU (Generalized Language Evaluation Understanding) score.\nPreferred over BLEU ", + "file_type": "rationale", + "source_file": "src/evaluation/gleu_scorer.py", + "id": "src_evaluation_gleu_scorer_py_docstring", + "community": 1, + "norm_label": "gleu (generalized language evaluation understanding) score.\npreferred over bleu " + }, + { + "label": "GLEUScorer", + "file_type": "code", + "source_file": "src/evaluation/gleu_scorer.py", + "source_location": "line 13", + "id": "src_evaluation_gleu_scorer_py_GLEUScorer", + "community": 1, + "norm_label": "gleuscorer" + }, + { + "label": "Computes GLEU and BERTScore metrics for GEC evaluation.", + "file_type": "rationale", + "source_file": "src/evaluation/gleu_scorer.py", + "source_location": "line 13", + "id": "src_evaluation_gleu_scorer_py_GLEUScorer_doc", + "community": 1, + "norm_label": "computes gleu and bertscore metrics for gec evaluation." + }, + { + "label": "compute_gleu()", + "file_type": "code", + "source_file": "src/evaluation/gleu_scorer.py", + "source_location": "line 16", + "id": "src_evaluation_gleu_scorer_py_compute_gleu", + "community": 1, + "norm_label": "compute_gleu()" + }, + { + "label": "Corpus-level GLEU score (0-100).\n\nGLEU is the geometric mean of n-gram precision", + "file_type": "rationale", + "source_file": "src/evaluation/gleu_scorer.py", + "source_location": "line 16", + "id": "src_evaluation_gleu_scorer_py_compute_gleu_doc", + "community": 1, + "norm_label": "corpus-level gleu score (0-100).\n\ngleu is the geometric mean of n-gram precision" + }, + { + "label": "compute_bert_score()", + "file_type": "code", + "source_file": "src/evaluation/gleu_scorer.py", + "source_location": "line 43", + "id": "src_evaluation_gleu_scorer_py_compute_bert_score", + "community": 1, + "norm_label": "compute_bert_score()" + }, + { + "label": "Returns (precision, recall, F1) as averages over the batch.", + "file_type": "rationale", + "source_file": "src/evaluation/gleu_scorer.py", + "source_location": "line 43", + "id": "src_evaluation_gleu_scorer_py_compute_bert_score_doc", + "community": 1, + "norm_label": "returns (precision, recall, f1) as averages over the batch." + }, + { + "label": "style_metrics.py", + "file_type": "code", + "source_file": "src/evaluation/style_metrics.py", + "id": "src_evaluation_style_metrics_py", + "community": 1, + "norm_label": "style_metrics.py" + }, + { + "label": "Measures style preservation between input and output.\n\nKey metrics:\n - Style Ve", + "file_type": "rationale", + "source_file": "src/evaluation/style_metrics.py", + "id": "src_evaluation_style_metrics_py_docstring", + "community": 1, + "norm_label": "measures style preservation between input and output.\n\nkey metrics:\n - style ve" + }, + { + "label": "StyleEvaluator", + "file_type": "code", + "source_file": "src/evaluation/style_metrics.py", + "source_location": "line 19", + "id": "src_evaluation_style_metrics_py_StyleEvaluator", + "community": 1, + "norm_label": "styleevaluator" + }, + { + "label": "Evaluates style preservation and academic vocabulary coverage.", + "file_type": "rationale", + "source_file": "src/evaluation/style_metrics.py", + "source_location": "line 19", + "id": "src_evaluation_style_metrics_py_StyleEvaluator_doc", + "community": 1, + "norm_label": "evaluates style preservation and academic vocabulary coverage." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/evaluation/style_metrics.py", + "source_location": "line 22", + "id": "src_evaluation_style_metrics_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "style_similarity()", + "file_type": "code", + "source_file": "src/evaluation/style_metrics.py", + "source_location": "line 26", + "id": "src_evaluation_style_metrics_py_style_similarity", + "community": 1, + "norm_label": "style_similarity()" + }, + { + "label": "Cosine similarity between style vectors. Target: > 0.85.", + "file_type": "rationale", + "source_file": "src/evaluation/style_metrics.py", + "source_location": "line 26", + "id": "src_evaluation_style_metrics_py_style_similarity_doc", + "community": 1, + "norm_label": "cosine similarity between style vectors. target: > 0.85." + }, + { + "label": "awl_coverage()", + "file_type": "code", + "source_file": "src/evaluation/style_metrics.py", + "source_location": "line 39", + "id": "src_evaluation_style_metrics_py_awl_coverage", + "community": 1, + "norm_label": "awl_coverage()" + }, + { + "label": "Fraction of content words in AWL. Target: > 0.25.", + "file_type": "rationale", + "source_file": "src/evaluation/style_metrics.py", + "source_location": "line 39", + "id": "src_evaluation_style_metrics_py_awl_coverage_doc", + "community": 1, + "norm_label": "fraction of content words in awl. target: > 0.25." + }, + { + "label": "evaluate_batch()", + "file_type": "code", + "source_file": "src/evaluation/style_metrics.py", + "source_location": "line 54", + "id": "src_evaluation_style_metrics_py_evaluate_batch", + "community": 1, + "norm_label": "evaluate_batch()" + }, + { + "label": "Compute style and AWL metrics for a batch.", + "file_type": "rationale", + "source_file": "src/evaluation/style_metrics.py", + "source_location": "line 54", + "id": "src_evaluation_style_metrics_py_evaluate_batch_doc", + "community": 1, + "norm_label": "compute style and awl metrics for a batch." + }, + { + "label": "corrector.py", + "file_type": "code", + "source_file": "src/inference/corrector.py", + "id": "src_inference_corrector_py", + "community": 9, + "norm_label": "corrector.py" + }, + { + "label": "End-to-end inference pipeline.\nAccepts raw dyslectic text (and optionally a mast", + "file_type": "rationale", + "source_file": "src/inference/corrector.py", + "id": "src_inference_corrector_py_docstring", + "community": 9, + "norm_label": "end-to-end inference pipeline.\naccepts raw dyslectic text (and optionally a mast" + }, + { + "label": "CorrectionResult", + "file_type": "code", + "source_file": "src/inference/corrector.py", + "source_location": "line 34", + "id": "src_inference_corrector_py_CorrectionResult", + "community": 9, + "norm_label": "correctionresult" + }, + { + "label": "AcademicCorrector", + "file_type": "code", + "source_file": "src/inference/corrector.py", + "source_location": "line 44", + "id": "src_inference_corrector_py_AcademicCorrector", + "community": 9, + "norm_label": "academiccorrector" + }, + { + "label": "Full inference pipeline: preprocess \u2192 fingerprint \u2192 generate \u2192 elevate \u2192 filter.", + "file_type": "rationale", + "source_file": "src/inference/corrector.py", + "source_location": "line 44", + "id": "src_inference_corrector_py_AcademicCorrector_doc", + "community": 9, + "norm_label": "full inference pipeline: preprocess \u2192 fingerprint \u2192 generate \u2192 elevate \u2192 filter." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/inference/corrector.py", + "source_location": "line 47", + "id": "src_inference_corrector_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "correct()", + "file_type": "code", + "source_file": "src/inference/corrector.py", + "source_location": "line 147", + "id": "src_inference_corrector_py_correct", + "community": 9, + "norm_label": "correct()" + }, + { + "label": "Full correction pipeline:\n1. Pre-process (spell correct + parse)\n2. Style finger", + "file_type": "rationale", + "source_file": "src/inference/corrector.py", + "source_location": "line 147", + "id": "src_inference_corrector_py_correct_doc", + "community": 9, + "norm_label": "full correction pipeline:\n1. pre-process (spell correct + parse)\n2. style finger" + }, + { + "label": "postprocessor.py", + "file_type": "code", + "source_file": "src/inference/postprocessor.py", + "id": "src_inference_postprocessor_py", + "community": 9, + "norm_label": "postprocessor.py" + }, + { + "label": "Post-processing utilities for generated text.\nHandles cleanup, formatting, and f", + "file_type": "rationale", + "source_file": "src/inference/postprocessor.py", + "id": "src_inference_postprocessor_py_docstring", + "community": 9, + "norm_label": "post-processing utilities for generated text.\nhandles cleanup, formatting, and f" + }, + { + "label": "PostProcessor", + "file_type": "code", + "source_file": "src/inference/postprocessor.py", + "source_location": "line 11", + "id": "src_inference_postprocessor_py_PostProcessor", + "community": 9, + "norm_label": "postprocessor" + }, + { + "label": "Cleans and formats generated text after model output.", + "file_type": "rationale", + "source_file": "src/inference/postprocessor.py", + "source_location": "line 11", + "id": "src_inference_postprocessor_py_PostProcessor_doc", + "community": 9, + "norm_label": "cleans and formats generated text after model output." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/inference/postprocessor.py", + "source_location": "line 26", + "id": "src_inference_postprocessor_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "clean()", + "file_type": "code", + "source_file": "src/inference/postprocessor.py", + "source_location": "line 33", + "id": "src_inference_postprocessor_py_clean", + "community": 9, + "norm_label": "clean()" + }, + { + "label": "Remove generation artifacts and normalise whitespace.", + "file_type": "rationale", + "source_file": "src/inference/postprocessor.py", + "source_location": "line 33", + "id": "src_inference_postprocessor_py_clean_doc", + "community": 9, + "norm_label": "remove generation artifacts and normalise whitespace." + }, + { + "label": "restore_entities()", + "file_type": "code", + "source_file": "src/inference/postprocessor.py", + "source_location": "line 62", + "id": "src_inference_postprocessor_py_restore_entities", + "community": 9, + "norm_label": "restore_entities()" + }, + { + "label": "Restore named entities that may have been altered during generation.\n\nUses fuzzy", + "file_type": "rationale", + "source_file": "src/inference/postprocessor.py", + "source_location": "line 62", + "id": "src_inference_postprocessor_py_restore_entities_doc", + "community": 9, + "norm_label": "restore named entities that may have been altered during generation.\n\nuses fuzzy" + }, + { + "label": "format_output()", + "file_type": "code", + "source_file": "src/inference/postprocessor.py", + "source_location": "line 90", + "id": "src_inference_postprocessor_py_format_output", + "community": 9, + "norm_label": "format_output()" + }, + { + "label": "Apply final formatting (capitalisation, punctuation, spacing).", + "file_type": "rationale", + "source_file": "src/inference/postprocessor.py", + "source_location": "line 90", + "id": "src_inference_postprocessor_py_format_output_doc", + "community": 9, + "norm_label": "apply final formatting (capitalisation, punctuation, spacing)." + }, + { + "label": "base_model.py", + "file_type": "code", + "source_file": "src/model/base_model.py", + "id": "src_model_base_model_py", + "community": 6, + "norm_label": "base_model.py" + }, + { + "label": "Loads and wraps the base pretrained model.\nSupported architectures:\n - google/f", + "file_type": "rationale", + "source_file": "src/model/base_model.py", + "id": "src_model_base_model_py_docstring", + "community": 6, + "norm_label": "loads and wraps the base pretrained model.\nsupported architectures:\n - google/f" + }, + { + "label": "load_model_and_tokenizer()", + "file_type": "code", + "source_file": "src/model/base_model.py", + "source_location": "line 32", + "id": "src_model_base_model_py_load_model_and_tokenizer", + "community": 6, + "norm_label": "load_model_and_tokenizer()" + }, + { + "label": "Load a pretrained model with optional LoRA and quantization.\n\nArgs:\n model_ke", + "file_type": "rationale", + "source_file": "src/model/base_model.py", + "source_location": "line 32", + "id": "src_model_base_model_py_load_model_and_tokenizer_doc", + "community": 6, + "norm_label": "load a pretrained model with optional lora and quantization.\n\nargs:\n model_ke" + }, + { + "label": "generation_utils.py", + "file_type": "code", + "source_file": "src/model/generation_utils.py", + "id": "src_model_generation_utils_py", + "community": 1, + "norm_label": "generation_utils.py" + }, + { + "label": "Generation utilities for text correction.\nHandles beam search, constrained decod", + "file_type": "rationale", + "source_file": "src/model/generation_utils.py", + "id": "src_model_generation_utils_py_docstring", + "community": 1, + "norm_label": "generation utilities for text correction.\nhandles beam search, constrained decod" + }, + { + "label": "generate_correction()", + "file_type": "code", + "source_file": "src/model/generation_utils.py", + "source_location": "line 12", + "id": "src_model_generation_utils_py_generate_correction", + "community": 1, + "norm_label": "generate_correction()" + }, + { + "label": "Generate corrected text from input tokens.", + "file_type": "rationale", + "source_file": "src/model/generation_utils.py", + "source_location": "line 12", + "id": "src_model_generation_utils_py_generate_correction_doc", + "community": 1, + "norm_label": "generate corrected text from input tokens." + }, + { + "label": "batch_generate()", + "file_type": "code", + "source_file": "src/model/generation_utils.py", + "source_location": "line 48", + "id": "src_model_generation_utils_py_batch_generate", + "community": 1, + "norm_label": "batch_generate()" + }, + { + "label": "Generate corrections for a batch of texts.", + "file_type": "rationale", + "source_file": "src/model/generation_utils.py", + "source_location": "line 48", + "id": "src_model_generation_utils_py_batch_generate_doc", + "community": 1, + "norm_label": "generate corrections for a batch of texts." + }, + { + "label": "lora_adapter.py", + "file_type": "code", + "source_file": "src/model/lora_adapter.py", + "id": "src_model_lora_adapter_py", + "community": 6, + "norm_label": "lora_adapter.py" + }, + { + "label": "LoRA adapter configuration and management.\nWraps PEFT LoRA utilities for applyin", + "file_type": "rationale", + "source_file": "src/model/lora_adapter.py", + "id": "src_model_lora_adapter_py_docstring", + "community": 6, + "norm_label": "lora adapter configuration and management.\nwraps peft lora utilities for applyin" + }, + { + "label": "create_lora_config()", + "file_type": "code", + "source_file": "src/model/lora_adapter.py", + "source_location": "line 12", + "id": "src_model_lora_adapter_py_create_lora_config", + "community": 6, + "norm_label": "create_lora_config()" + }, + { + "label": "Create a LoRA configuration for the given task type.", + "file_type": "rationale", + "source_file": "src/model/lora_adapter.py", + "source_location": "line 12", + "id": "src_model_lora_adapter_py_create_lora_config_doc", + "community": 6, + "norm_label": "create a lora configuration for the given task type." + }, + { + "label": "apply_lora()", + "file_type": "code", + "source_file": "src/model/lora_adapter.py", + "source_location": "line 36", + "id": "src_model_lora_adapter_py_apply_lora", + "community": 6, + "norm_label": "apply_lora()" + }, + { + "label": "Apply LoRA adapters to a model and return the wrapped model.", + "file_type": "rationale", + "source_file": "src/model/lora_adapter.py", + "source_location": "line 36", + "id": "src_model_lora_adapter_py_apply_lora_doc", + "community": 6, + "norm_label": "apply lora adapters to a model and return the wrapped model." + }, + { + "label": "merge_lora_weights()", + "file_type": "code", + "source_file": "src/model/lora_adapter.py", + "source_location": "line 45", + "id": "src_model_lora_adapter_py_merge_lora_weights", + "community": 6, + "norm_label": "merge_lora_weights()" + }, + { + "label": "Merge LoRA weights into the base model for inference.\n\nAfter merging, the model ", + "file_type": "rationale", + "source_file": "src/model/lora_adapter.py", + "source_location": "line 45", + "id": "src_model_lora_adapter_py_merge_lora_weights_doc", + "community": 6, + "norm_label": "merge lora weights into the base model for inference.\n\nafter merging, the model " + }, + { + "label": "style_conditioner.py", + "file_type": "code", + "source_file": "src/model/style_conditioner.py", + "id": "src_model_style_conditioner_py", + "community": 6, + "norm_label": "style_conditioner.py" + }, + { + "label": "Injects the style vector into the model via soft prompt conditioning.\nThe style ", + "file_type": "rationale", + "source_file": "src/model/style_conditioner.py", + "id": "src_model_style_conditioner_py_docstring", + "community": 6, + "norm_label": "injects the style vector into the model via soft prompt conditioning.\nthe style " + }, + { + "label": "StyleConditioner", + "file_type": "code", + "source_file": "src/model/style_conditioner.py", + "source_location": "line 19", + "id": "src_model_style_conditioner_py_StyleConditioner", + "community": 6, + "norm_label": "styleconditioner" + }, + { + "label": "Projects a 512-dim style vector to n_prefix_tokens virtual tokens\nin the model's", + "file_type": "rationale", + "source_file": "src/model/style_conditioner.py", + "source_location": "line 19", + "id": "src_model_style_conditioner_py_StyleConditioner_doc", + "community": 6, + "norm_label": "projects a 512-dim style vector to n_prefix_tokens virtual tokens\nin the model's" + }, + { + "label": "prepend_style_prefix()", + "file_type": "code", + "source_file": "src/model/style_conditioner.py", + "source_location": "line 61", + "id": "src_model_style_conditioner_py_prepend_style_prefix", + "community": 6, + "norm_label": "prepend_style_prefix()" + }, + { + "label": "Concatenates style prefix to input embeddings along sequence dimension.\n\nArgs:\n ", + "file_type": "rationale", + "source_file": "src/model/style_conditioner.py", + "source_location": "line 61", + "id": "src_model_style_conditioner_py_prepend_style_prefix_doc", + "community": 6, + "norm_label": "concatenates style prefix to input embeddings along sequence dimension.\n\nargs:\n " + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/model/style_conditioner.py", + "source_location": "line 25", + "id": "src_model_style_conditioner_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "forward()", + "file_type": "code", + "source_file": "src/model/style_conditioner.py", + "source_location": "line 44", + "id": "src_model_style_conditioner_py_forward", + "community": 6, + "norm_label": "forward()" + }, + { + "label": "Args:\n style_vector: [batch_size, 512]\nReturns:\n prefix_embeddings: [batch", + "file_type": "rationale", + "source_file": "src/model/style_conditioner.py", + "source_location": "line 44", + "id": "src_model_style_conditioner_py_forward_doc", + "community": 6, + "norm_label": "args:\n style_vector: [batch_size, 512]\nreturns:\n prefix_embeddings: [batch" + }, + { + "label": "dependency_parser.py", + "file_type": "code", + "source_file": "src/preprocessing/dependency_parser.py", + "id": "src_preprocessing_dependency_parser_py", + "community": 13, + "norm_label": "dependency_parser.py" + }, + { + "label": "Dependency parser module.\nExtracts grammatical skeletons (subject-verb-object) f", + "file_type": "rationale", + "source_file": "src/preprocessing/dependency_parser.py", + "id": "src_preprocessing_dependency_parser_py_docstring", + "community": 13, + "norm_label": "dependency parser module.\nextracts grammatical skeletons (subject-verb-object) f" + }, + { + "label": "DependencyParser", + "file_type": "code", + "source_file": "src/preprocessing/dependency_parser.py", + "source_location": "line 12", + "id": "src_preprocessing_dependency_parser_py_DependencyParser", + "community": 13, + "norm_label": "dependencyparser" + }, + { + "label": "Extracts dependency trees and SVO triples from text.", + "file_type": "rationale", + "source_file": "src/preprocessing/dependency_parser.py", + "source_location": "line 12", + "id": "src_preprocessing_dependency_parser_py_DependencyParser_doc", + "community": 13, + "norm_label": "extracts dependency trees and svo triples from text." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/preprocessing/dependency_parser.py", + "source_location": "line 15", + "id": "src_preprocessing_dependency_parser_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "parse()", + "file_type": "code", + "source_file": "src/preprocessing/dependency_parser.py", + "source_location": "line 22", + "id": "src_preprocessing_dependency_parser_py_parse", + "community": 13, + "norm_label": "parse()" + }, + { + "label": "Extract dependency tree for each sentence.", + "file_type": "rationale", + "source_file": "src/preprocessing/dependency_parser.py", + "source_location": "line 22", + "id": "src_preprocessing_dependency_parser_py_parse_doc", + "community": 13, + "norm_label": "extract dependency tree for each sentence." + }, + { + "label": "extract_svo()", + "file_type": "code", + "source_file": "src/preprocessing/dependency_parser.py", + "source_location": "line 47", + "id": "src_preprocessing_dependency_parser_py_extract_svo", + "community": 13, + "norm_label": "extract_svo()" + }, + { + "label": "Extract subject-verb-object triples per sentence.", + "file_type": "rationale", + "source_file": "src/preprocessing/dependency_parser.py", + "source_location": "line 47", + "id": "src_preprocessing_dependency_parser_py_extract_svo_doc", + "community": 13, + "norm_label": "extract subject-verb-object triples per sentence." + }, + { + "label": "dyslexia_simulator.py", + "file_type": "code", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "id": "src_preprocessing_dyslexia_simulator_py", + "community": 5, + "norm_label": "dyslexia_simulator.py" + }, + { + "label": "Programmatically generates dyslectic training data from clean text.\nUsed to augm", + "file_type": "rationale", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "id": "src_preprocessing_dyslexia_simulator_py_docstring", + "community": 5, + "norm_label": "programmatically generates dyslectic training data from clean text.\nused to augm" + }, + { + "label": "DyslexiaSimulator", + "file_type": "code", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 19", + "id": "src_preprocessing_dyslexia_simulator_py_DyslexiaSimulator", + "community": 5, + "norm_label": "dyslexiasimulator" + }, + { + "label": "Generates synthetic dyslectic text from clean input for data augmentation.", + "file_type": "rationale", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 19", + "id": "src_preprocessing_dyslexia_simulator_py_DyslexiaSimulator_doc", + "community": 5, + "norm_label": "generates synthetic dyslectic text from clean input for data augmentation." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 34", + "id": "src_preprocessing_dyslexia_simulator_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "_transpose_letters()", + "file_type": "code", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 38", + "id": "src_preprocessing_dyslexia_simulator_py__transpose_letters", + "community": 5, + "norm_label": "_transpose_letters()" + }, + { + "label": "Swap two adjacent letters.", + "file_type": "rationale", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 38", + "id": "src_preprocessing_dyslexia_simulator_py__transpose_letters_doc", + "community": 5, + "norm_label": "swap two adjacent letters." + }, + { + "label": "_omit_letter()", + "file_type": "code", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 48", + "id": "src_preprocessing_dyslexia_simulator_py__omit_letter", + "community": 5, + "norm_label": "_omit_letter()" + }, + { + "label": "Remove a random interior letter.", + "file_type": "rationale", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 48", + "id": "src_preprocessing_dyslexia_simulator_py__omit_letter_doc", + "community": 5, + "norm_label": "remove a random interior letter." + }, + { + "label": "_double_letter()", + "file_type": "code", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 55", + "id": "src_preprocessing_dyslexia_simulator_py__double_letter", + "community": 5, + "norm_label": "_double_letter()" + }, + { + "label": "Double a random interior letter.", + "file_type": "rationale", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 55", + "id": "src_preprocessing_dyslexia_simulator_py__double_letter_doc", + "community": 5, + "norm_label": "double a random interior letter." + }, + { + "label": "_reverse_letter()", + "file_type": "code", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 62", + "id": "src_preprocessing_dyslexia_simulator_py__reverse_letter", + "community": 5, + "norm_label": "_reverse_letter()" + }, + { + "label": "Swap b/d, p/q style reversals.", + "file_type": "rationale", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 62", + "id": "src_preprocessing_dyslexia_simulator_py__reverse_letter_doc", + "community": 5, + "norm_label": "swap b/d, p/q style reversals." + }, + { + "label": "corrupt_word()", + "file_type": "code", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 77", + "id": "src_preprocessing_dyslexia_simulator_py_corrupt_word", + "community": 5, + "norm_label": "corrupt_word()" + }, + { + "label": "Apply a single random error to a word.", + "file_type": "rationale", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 77", + "id": "src_preprocessing_dyslexia_simulator_py_corrupt_word_doc", + "community": 5, + "norm_label": "apply a single random error to a word." + }, + { + "label": "simulate()", + "file_type": "code", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 103", + "id": "src_preprocessing_dyslexia_simulator_py_simulate", + "community": 5, + "norm_label": "simulate()" + }, + { + "label": "Returns (corrupted_text, clean_text) training pair.", + "file_type": "rationale", + "source_file": "src/preprocessing/dyslexia_simulator.py", + "source_location": "line 103", + "id": "src_preprocessing_dyslexia_simulator_py_simulate_doc", + "community": 5, + "norm_label": "returns (corrupted_text, clean_text) training pair." + }, + { + "label": "ner_tagger.py", + "file_type": "code", + "source_file": "src/preprocessing/ner_tagger.py", + "id": "src_preprocessing_ner_tagger_py", + "community": 0, + "norm_label": "ner_tagger.py" + }, + { + "label": "Named Entity Recognition tagger.\nIdentifies entities (persons, locations, organi", + "file_type": "rationale", + "source_file": "src/preprocessing/ner_tagger.py", + "id": "src_preprocessing_ner_tagger_py_docstring", + "community": 0, + "norm_label": "named entity recognition tagger.\nidentifies entities (persons, locations, organi" + }, + { + "label": "EntitySpan", + "file_type": "code", + "source_file": "src/preprocessing/ner_tagger.py", + "source_location": "line 14", + "id": "src_preprocessing_ner_tagger_py_EntitySpan", + "community": 0, + "norm_label": "entityspan" + }, + { + "label": "NERTagger", + "file_type": "code", + "source_file": "src/preprocessing/ner_tagger.py", + "source_location": "line 21", + "id": "src_preprocessing_ner_tagger_py_NERTagger", + "community": 0, + "norm_label": "nertagger" + }, + { + "label": "Tags named entities and produces protected spans.", + "file_type": "rationale", + "source_file": "src/preprocessing/ner_tagger.py", + "source_location": "line 21", + "id": "src_preprocessing_ner_tagger_py_NERTagger_doc", + "community": 0, + "norm_label": "tags named entities and produces protected spans." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/preprocessing/ner_tagger.py", + "source_location": "line 24", + "id": "src_preprocessing_ner_tagger_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "tag()", + "file_type": "code", + "source_file": "src/preprocessing/ner_tagger.py", + "source_location": "line 31", + "id": "src_preprocessing_ner_tagger_py_tag", + "community": 0, + "norm_label": "tag()" + }, + { + "label": "Extract all named entities from text.", + "file_type": "rationale", + "source_file": "src/preprocessing/ner_tagger.py", + "source_location": "line 31", + "id": "src_preprocessing_ner_tagger_py_tag_doc", + "community": 0, + "norm_label": "extract all named entities from text." + }, + { + "label": "get_protected_spans()", + "file_type": "code", + "source_file": "src/preprocessing/ner_tagger.py", + "source_location": "line 46", + "id": "src_preprocessing_ner_tagger_py_get_protected_spans", + "community": 0, + "norm_label": "get_protected_spans()" + }, + { + "label": "Return (start, end) char spans that must not be modified.", + "file_type": "rationale", + "source_file": "src/preprocessing/ner_tagger.py", + "source_location": "line 46", + "id": "src_preprocessing_ner_tagger_py_get_protected_spans_doc", + "community": 0, + "norm_label": "return (start, end) char spans that must not be modified." + }, + { + "label": "pipeline.py", + "file_type": "code", + "source_file": "src/preprocessing/pipeline.py", + "id": "src_preprocessing_pipeline_py", + "community": 0, + "norm_label": "pipeline.py" + }, + { + "label": "Master pre-processing pipeline. Runs all NLP stages in sequence.\nReturns a Prepr", + "file_type": "rationale", + "source_file": "src/preprocessing/pipeline.py", + "id": "src_preprocessing_pipeline_py_docstring", + "community": 0, + "norm_label": "master pre-processing pipeline. runs all nlp stages in sequence.\nreturns a prepr" + }, + { + "label": "EntitySpan", + "file_type": "code", + "source_file": "src/preprocessing/pipeline.py", + "source_location": "line 15", + "id": "src_preprocessing_pipeline_py_EntitySpan", + "community": 0, + "norm_label": "entityspan" + }, + { + "label": "PreprocessedDoc", + "file_type": "code", + "source_file": "src/preprocessing/pipeline.py", + "source_location": "line 23", + "id": "src_preprocessing_pipeline_py_PreprocessedDoc", + "community": 0, + "norm_label": "preprocesseddoc" + }, + { + "label": "PreprocessingPipeline", + "file_type": "code", + "source_file": "src/preprocessing/pipeline.py", + "source_location": "line 35", + "id": "src_preprocessing_pipeline_py_PreprocessingPipeline", + "community": 0, + "norm_label": "preprocessingpipeline" + }, + { + "label": "Orchestrates all pre-processing stages: spell correction, parsing, NER, readabil", + "file_type": "rationale", + "source_file": "src/preprocessing/pipeline.py", + "source_location": "line 35", + "id": "src_preprocessing_pipeline_py_PreprocessingPipeline_doc", + "community": 0, + "norm_label": "orchestrates all pre-processing stages: spell correction, parsing, ner, readabil" + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/preprocessing/pipeline.py", + "source_location": "line 38", + "id": "src_preprocessing_pipeline_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "_extract_readability()", + "file_type": "code", + "source_file": "src/preprocessing/pipeline.py", + "source_location": "line 50", + "id": "src_preprocessing_pipeline_py__extract_readability", + "community": 0, + "norm_label": "_extract_readability()" + }, + { + "label": "Compute readability scores (Flesch-Kincaid, Gunning Fog, etc.).", + "file_type": "rationale", + "source_file": "src/preprocessing/pipeline.py", + "source_location": "line 50", + "id": "src_preprocessing_pipeline_py__extract_readability_doc", + "community": 0, + "norm_label": "compute readability scores (flesch-kincaid, gunning fog, etc.)." + }, + { + "label": "_extract_dep_tree()", + "file_type": "code", + "source_file": "src/preprocessing/pipeline.py", + "source_location": "line 70", + "id": "src_preprocessing_pipeline_py__extract_dep_tree", + "community": 0, + "norm_label": "_extract_dep_tree()" + }, + { + "label": "Extract grammatical skeleton: subject-verb-object per sentence.", + "file_type": "rationale", + "source_file": "src/preprocessing/pipeline.py", + "source_location": "line 70", + "id": "src_preprocessing_pipeline_py__extract_dep_tree_doc", + "community": 0, + "norm_label": "extract grammatical skeleton: subject-verb-object per sentence." + }, + { + "label": "process()", + "file_type": "code", + "source_file": "src/preprocessing/pipeline.py", + "source_location": "line 90", + "id": "src_preprocessing_pipeline_py_process", + "community": 0, + "norm_label": "process()" + }, + { + "label": "Run full pre-processing pipeline on raw text.\n\n7-step pipeline:\n1. Spell correct", + "file_type": "rationale", + "source_file": "src/preprocessing/pipeline.py", + "source_location": "line 90", + "id": "src_preprocessing_pipeline_py_process_doc", + "community": 0, + "norm_label": "run full pre-processing pipeline on raw text.\n\n7-step pipeline:\n1. spell correct" + }, + { + "label": "sentence_segmenter.py", + "file_type": "code", + "source_file": "src/preprocessing/sentence_segmenter.py", + "id": "src_preprocessing_sentence_segmenter_py", + "community": 0, + "norm_label": "sentence_segmenter.py" + }, + { + "label": "Sentence segmentation module.\nUses spaCy's sentence boundary detection for accur", + "file_type": "rationale", + "source_file": "src/preprocessing/sentence_segmenter.py", + "id": "src_preprocessing_sentence_segmenter_py_docstring", + "community": 0, + "norm_label": "sentence segmentation module.\nuses spacy's sentence boundary detection for accur" + }, + { + "label": "SentenceSegmenter", + "file_type": "code", + "source_file": "src/preprocessing/sentence_segmenter.py", + "source_location": "line 12", + "id": "src_preprocessing_sentence_segmenter_py_SentenceSegmenter", + "community": 0, + "norm_label": "sentencesegmenter" + }, + { + "label": "Segments text into sentences using spaCy's transformer model.", + "file_type": "rationale", + "source_file": "src/preprocessing/sentence_segmenter.py", + "source_location": "line 12", + "id": "src_preprocessing_sentence_segmenter_py_SentenceSegmenter_doc", + "community": 0, + "norm_label": "segments text into sentences using spacy's transformer model." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/preprocessing/sentence_segmenter.py", + "source_location": "line 15", + "id": "src_preprocessing_sentence_segmenter_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "segment()", + "file_type": "code", + "source_file": "src/preprocessing/sentence_segmenter.py", + "source_location": "line 23", + "id": "src_preprocessing_sentence_segmenter_py_segment", + "community": 0, + "norm_label": "segment()" + }, + { + "label": "Split text into individual sentences.", + "file_type": "rationale", + "source_file": "src/preprocessing/sentence_segmenter.py", + "source_location": "line 23", + "id": "src_preprocessing_sentence_segmenter_py_segment_doc", + "community": 0, + "norm_label": "split text into individual sentences." + }, + { + "label": "spell_corrector.py", + "file_type": "code", + "source_file": "src/preprocessing/spell_corrector.py", + "id": "src_preprocessing_spell_corrector_py", + "community": 0, + "norm_label": "spell_corrector.py" + }, + { + "label": "Two-pass spell correction:\nPass 1: pyspellchecker (fast, context-free, catches s", + "file_type": "rationale", + "source_file": "src/preprocessing/spell_corrector.py", + "id": "src_preprocessing_spell_corrector_py_docstring", + "community": 0, + "norm_label": "two-pass spell correction:\npass 1: pyspellchecker (fast, context-free, catches s" + }, + { + "label": "DyslexiaAwareSpellCorrector", + "file_type": "code", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 22", + "id": "src_preprocessing_spell_corrector_py_DyslexiaAwareSpellCorrector", + "community": 0, + "norm_label": "dyslexiaawarespellcorrector" + }, + { + "label": "Two-pass spell corrector with dyslexia-specific phonetic pattern handling.", + "file_type": "rationale", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 22", + "id": "src_preprocessing_spell_corrector_py_DyslexiaAwareSpellCorrector_doc", + "community": 0, + "norm_label": "two-pass spell corrector with dyslexia-specific phonetic pattern handling." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 35", + "id": "src_preprocessing_spell_corrector_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "_phonetic_pass()", + "file_type": "code", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 51", + "id": "src_preprocessing_spell_corrector_py__phonetic_pass", + "community": 0, + "norm_label": "_phonetic_pass()" + }, + { + "label": "Apply known dyslexic phonetic substitutions first.", + "file_type": "rationale", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 51", + "id": "src_preprocessing_spell_corrector_py__phonetic_pass_doc", + "community": 0, + "norm_label": "apply known dyslexic phonetic substitutions first." + }, + { + "label": "_spellcheck_pass()", + "file_type": "code", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 64", + "id": "src_preprocessing_spell_corrector_py__spellcheck_pass", + "community": 0, + "norm_label": "_spellcheck_pass()" + }, + { + "label": "pyspellchecker pass for simple token-level errors.", + "file_type": "rationale", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 64", + "id": "src_preprocessing_spell_corrector_py__spellcheck_pass_doc", + "community": 0, + "norm_label": "pyspellchecker pass for simple token-level errors." + }, + { + "label": "_languagetool_pass()", + "file_type": "code", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 87", + "id": "src_preprocessing_spell_corrector_py__languagetool_pass", + "community": 0, + "norm_label": "_languagetool_pass()" + }, + { + "label": "LanguageTool pass for context-aware grammar + spelling corrections.", + "file_type": "rationale", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 87", + "id": "src_preprocessing_spell_corrector_py__languagetool_pass_doc", + "community": 0, + "norm_label": "languagetool pass for context-aware grammar + spelling corrections." + }, + { + "label": "correct()", + "file_type": "code", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 108", + "id": "src_preprocessing_spell_corrector_py_correct", + "community": 0, + "norm_label": "correct()" + }, + { + "label": "Run all three correction passes in sequence.", + "file_type": "rationale", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 108", + "id": "src_preprocessing_spell_corrector_py_correct_doc", + "community": 0, + "norm_label": "run all three correction passes in sequence." + }, + { + "label": "close()", + "file_type": "code", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 126", + "id": "src_preprocessing_spell_corrector_py_close", + "community": 0, + "norm_label": "close()" + }, + { + "label": "Clean up LanguageTool resources.", + "file_type": "rationale", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 126", + "id": "src_preprocessing_spell_corrector_py_close_doc", + "community": 0, + "norm_label": "clean up languagetool resources." + }, + { + "label": "_replace()", + "file_type": "code", + "source_file": "src/preprocessing/spell_corrector.py", + "source_location": "line 53", + "id": "src_preprocessing_spell_corrector_py__replace", + "community": 0, + "norm_label": "_replace()" + }, + { + "label": "emotion_classifier.py", + "file_type": "code", + "source_file": "src/style/emotion_classifier.py", + "id": "src_style_emotion_classifier_py", + "community": 19, + "norm_label": "emotion_classifier.py" + }, + { + "label": "Emotion/register classifier module.\nClassifies text emotional register (neutral,", + "file_type": "rationale", + "source_file": "src/style/emotion_classifier.py", + "id": "src_style_emotion_classifier_py_docstring", + "community": 19, + "norm_label": "emotion/register classifier module.\nclassifies text emotional register (neutral," + }, + { + "label": "EmotionClassifier", + "file_type": "code", + "source_file": "src/style/emotion_classifier.py", + "source_location": "line 11", + "id": "src_style_emotion_classifier_py_EmotionClassifier", + "community": 19, + "norm_label": "emotionclassifier" + }, + { + "label": "Classifies emotional register of text using keyword-based analysis.", + "file_type": "rationale", + "source_file": "src/style/emotion_classifier.py", + "source_location": "line 11", + "id": "src_style_emotion_classifier_py_EmotionClassifier_doc", + "community": 19, + "norm_label": "classifies emotional register of text using keyword-based analysis." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/style/emotion_classifier.py", + "source_location": "line 46", + "id": "src_style_emotion_classifier_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "classify()", + "file_type": "code", + "source_file": "src/style/emotion_classifier.py", + "source_location": "line 49", + "id": "src_style_emotion_classifier_py_classify", + "community": 19, + "norm_label": "classify()" + }, + { + "label": "Return emotion distribution over register categories.\n\nReturns a dict with keys:", + "file_type": "rationale", + "source_file": "src/style/emotion_classifier.py", + "source_location": "line 49", + "id": "src_style_emotion_classifier_py_classify_doc", + "community": 19, + "norm_label": "return emotion distribution over register categories.\n\nreturns a dict with keys:" + }, + { + "label": "fingerprinter.py", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "id": "src_style_fingerprinter_py", + "community": 2, + "norm_label": "fingerprinter.py" + }, + { + "label": "Extracts a numerical style vector from any text sample.\nThe style vector encodes", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "id": "src_style_fingerprinter_py_docstring", + "community": 2, + "norm_label": "extracts a numerical style vector from any text sample.\nthe style vector encodes" + }, + { + "label": "StyleProjectionMLP", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 63", + "id": "src_style_fingerprinter_py_StyleProjectionMLP", + "community": 2, + "norm_label": "styleprojectionmlp" + }, + { + "label": "Projects raw feature vector to 512-dim style embedding.", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 63", + "id": "src_style_fingerprinter_py_StyleProjectionMLP_doc", + "community": 2, + "norm_label": "projects raw feature vector to 512-dim style embedding." + }, + { + "label": "StyleFingerprinter", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 81", + "id": "src_style_fingerprinter_py_StyleFingerprinter", + "community": 2, + "norm_label": "stylefingerprinter" + }, + { + "label": "Extracts style fingerprint vectors from text samples.", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 81", + "id": "src_style_fingerprinter_py_StyleFingerprinter_doc", + "community": 2, + "norm_label": "extracts style fingerprint vectors from text samples." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 84", + "id": "src_style_fingerprinter_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "forward()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 77", + "id": "src_style_fingerprinter_py_forward", + "community": 2, + "norm_label": "forward()" + }, + { + "label": "_load_awl()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 102", + "id": "src_style_fingerprinter_py__load_awl", + "community": 2, + "norm_label": "_load_awl()" + }, + { + "label": "Load Academic Word List from file.", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 102", + "id": "src_style_fingerprinter_py__load_awl_doc", + "community": 2, + "norm_label": "load academic word list from file." + }, + { + "label": "_passive_voice_ratio()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 115", + "id": "src_style_fingerprinter_py__passive_voice_ratio", + "community": 2, + "norm_label": "_passive_voice_ratio()" + }, + { + "label": "Compute ratio of passive voice constructions.", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 115", + "id": "src_style_fingerprinter_py__passive_voice_ratio_doc", + "community": 2, + "norm_label": "compute ratio of passive voice constructions." + }, + { + "label": "_avg_dep_tree_depth()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 128", + "id": "src_style_fingerprinter_py__avg_dep_tree_depth", + "community": 2, + "norm_label": "_avg_dep_tree_depth()" + }, + { + "label": "Compute average dependency tree depth across all tokens.", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 128", + "id": "src_style_fingerprinter_py__avg_dep_tree_depth_doc", + "community": 2, + "norm_label": "compute average dependency tree depth across all tokens." + }, + { + "label": "_lexical_density()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 145", + "id": "src_style_fingerprinter_py__lexical_density", + "community": 2, + "norm_label": "_lexical_density()" + }, + { + "label": "Compute ratio of content words to total words.", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 145", + "id": "src_style_fingerprinter_py__lexical_density_doc", + "community": 2, + "norm_label": "compute ratio of content words to total words." + }, + { + "label": "_count_syllables()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 160", + "id": "src_style_fingerprinter_py__count_syllables", + "community": 2, + "norm_label": "_count_syllables()" + }, + { + "label": "Count syllables in a word using a vowel-group heuristic.\nAvoids NLTK cmudict whi", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 160", + "id": "src_style_fingerprinter_py__count_syllables_doc", + "community": 2, + "norm_label": "count syllables in a word using a vowel-group heuristic.\navoids nltk cmudict whi" + }, + { + "label": "_avg_syllables_per_word()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 180", + "id": "src_style_fingerprinter_py__avg_syllables_per_word", + "community": 2, + "norm_label": "_avg_syllables_per_word()" + }, + { + "label": "Average syllables per word.", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 180", + "id": "src_style_fingerprinter_py__avg_syllables_per_word_doc", + "community": 2, + "norm_label": "average syllables per word." + }, + { + "label": "_flesch_reading_ease()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 188", + "id": "src_style_fingerprinter_py__flesch_reading_ease", + "community": 2, + "norm_label": "_flesch_reading_ease()" + }, + { + "label": "Compute Flesch Reading Ease score without textstat.\nFormula: 206.835 - 1.015 * A", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 188", + "id": "src_style_fingerprinter_py__flesch_reading_ease_doc", + "community": 2, + "norm_label": "compute flesch reading ease score without textstat.\nformula: 206.835 - 1.015 * a" + }, + { + "label": "extract_raw_features()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 212", + "id": "src_style_fingerprinter_py_extract_raw_features", + "community": 2, + "norm_label": "extract_raw_features()" + }, + { + "label": "Extract ~40 raw style features from text.", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 212", + "id": "src_style_fingerprinter_py_extract_raw_features_doc", + "community": 2, + "norm_label": "extract ~40 raw style features from text." + }, + { + "label": "extract_vector()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 309", + "id": "src_style_fingerprinter_py_extract_vector", + "community": 2, + "norm_label": "extract_vector()" + }, + { + "label": "Returns a 512-dim style embedding tensor.", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 309", + "id": "src_style_fingerprinter_py_extract_vector_doc", + "community": 2, + "norm_label": "returns a 512-dim style embedding tensor." + }, + { + "label": "blend_vectors()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 333", + "id": "src_style_fingerprinter_py_blend_vectors", + "community": 2, + "norm_label": "blend_vectors()" + }, + { + "label": "Blend user style with master copy style.\nalpha = weight given to user's own styl", + "file_type": "rationale", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 333", + "id": "src_style_fingerprinter_py_blend_vectors_doc", + "community": 2, + "norm_label": "blend user style with master copy style.\nalpha = weight given to user's own styl" + }, + { + "label": "_depth()", + "file_type": "code", + "source_file": "src/style/fingerprinter.py", + "source_location": "line 130", + "id": "src_style_fingerprinter_py__depth", + "community": 2, + "norm_label": "_depth()" + }, + { + "label": "formality_classifier.py", + "file_type": "code", + "source_file": "src/style/formality_classifier.py", + "id": "src_style_formality_classifier_py", + "community": 14, + "norm_label": "formality_classifier.py" + }, + { + "label": "Formality classifier module.\nClassifies text on a 0-1 formality scale using ling", + "file_type": "rationale", + "source_file": "src/style/formality_classifier.py", + "id": "src_style_formality_classifier_py_docstring", + "community": 14, + "norm_label": "formality classifier module.\nclassifies text on a 0-1 formality scale using ling" + }, + { + "label": "FormalityClassifier", + "file_type": "code", + "source_file": "src/style/formality_classifier.py", + "source_location": "line 11", + "id": "src_style_formality_classifier_py_FormalityClassifier", + "community": 14, + "norm_label": "formalityclassifier" + }, + { + "label": "Scores text formality on a 0-1 scale using rule-based heuristics.", + "file_type": "rationale", + "source_file": "src/style/formality_classifier.py", + "source_location": "line 11", + "id": "src_style_formality_classifier_py_FormalityClassifier_doc", + "community": 14, + "norm_label": "scores text formality on a 0-1 scale using rule-based heuristics." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/style/formality_classifier.py", + "source_location": "line 36", + "id": "src_style_formality_classifier_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "score()", + "file_type": "code", + "source_file": "src/style/formality_classifier.py", + "source_location": "line 39", + "id": "src_style_formality_classifier_py_score", + "community": 14, + "norm_label": "score()" + }, + { + "label": "Return formality score in [0, 1]. Higher = more formal.\n\nScoring based on:\n- Con", + "file_type": "rationale", + "source_file": "src/style/formality_classifier.py", + "source_location": "line 39", + "id": "src_style_formality_classifier_py_score_doc", + "community": 14, + "norm_label": "return formality score in [0, 1]. higher = more formal.\n\nscoring based on:\n- con" + }, + { + "label": "style_vector.py", + "file_type": "code", + "source_file": "src/style/style_vector.py", + "id": "src_style_style_vector_py", + "community": 8, + "norm_label": "style_vector.py" + }, + { + "label": "Style vector utilities.\nHelper functions for manipulating, comparing, and persis", + "file_type": "rationale", + "source_file": "src/style/style_vector.py", + "id": "src_style_style_vector_py_docstring", + "community": 8, + "norm_label": "style vector utilities.\nhelper functions for manipulating, comparing, and persis" + }, + { + "label": "cosine_similarity()", + "file_type": "code", + "source_file": "src/style/style_vector.py", + "source_location": "line 11", + "id": "src_style_style_vector_py_cosine_similarity", + "community": 8, + "norm_label": "cosine_similarity()" + }, + { + "label": "Compute cosine similarity between two style vectors.", + "file_type": "rationale", + "source_file": "src/style/style_vector.py", + "source_location": "line 11", + "id": "src_style_style_vector_py_cosine_similarity_doc", + "community": 8, + "norm_label": "compute cosine similarity between two style vectors." + }, + { + "label": "average_style_vectors()", + "file_type": "code", + "source_file": "src/style/style_vector.py", + "source_location": "line 21", + "id": "src_style_style_vector_py_average_style_vectors", + "community": 8, + "norm_label": "average_style_vectors()" + }, + { + "label": "Compute the mean style vector from a list of vectors.", + "file_type": "rationale", + "source_file": "src/style/style_vector.py", + "source_location": "line 21", + "id": "src_style_style_vector_py_average_style_vectors_doc", + "community": 8, + "norm_label": "compute the mean style vector from a list of vectors." + }, + { + "label": "save_style_vector()", + "file_type": "code", + "source_file": "src/style/style_vector.py", + "source_location": "line 31", + "id": "src_style_style_vector_py_save_style_vector", + "community": 8, + "norm_label": "save_style_vector()" + }, + { + "label": "Persist a style vector to disk.", + "file_type": "rationale", + "source_file": "src/style/style_vector.py", + "source_location": "line 31", + "id": "src_style_style_vector_py_save_style_vector_doc", + "community": 8, + "norm_label": "persist a style vector to disk." + }, + { + "label": "load_style_vector()", + "file_type": "code", + "source_file": "src/style/style_vector.py", + "source_location": "line 36", + "id": "src_style_style_vector_py_load_style_vector", + "community": 8, + "norm_label": "load_style_vector()" + }, + { + "label": "Load a style vector from disk.", + "file_type": "rationale", + "source_file": "src/style/style_vector.py", + "source_location": "line 36", + "id": "src_style_style_vector_py_load_style_vector_doc", + "community": 8, + "norm_label": "load a style vector from disk." + }, + { + "label": "callbacks.py", + "file_type": "code", + "source_file": "src/training/callbacks.py", + "id": "src_training_callbacks_py", + "community": 18, + "norm_label": "callbacks.py" + }, + { + "label": "Training callbacks for monitoring and checkpointing.\nIntegrates with Weights & B", + "file_type": "rationale", + "source_file": "src/training/callbacks.py", + "id": "src_training_callbacks_py_docstring", + "community": 18, + "norm_label": "training callbacks for monitoring and checkpointing.\nintegrates with weights & b" + }, + { + "label": "StyleMetricsCallback", + "file_type": "code", + "source_file": "src/training/callbacks.py", + "source_location": "line 16", + "id": "src_training_callbacks_py_StyleMetricsCallback", + "community": 18, + "norm_label": "stylemetricscallback" + }, + { + "label": "Logs style similarity metrics during evaluation.", + "file_type": "rationale", + "source_file": "src/training/callbacks.py", + "source_location": "line 16", + "id": "src_training_callbacks_py_StyleMetricsCallback_doc", + "community": 18, + "norm_label": "logs style similarity metrics during evaluation." + }, + { + "label": "EarlyStoppingOnStyleDrift", + "file_type": "code", + "source_file": "src/training/callbacks.py", + "source_location": "line 34", + "id": "src_training_callbacks_py_EarlyStoppingOnStyleDrift", + "community": 18, + "norm_label": "earlystoppingonstyledrift" + }, + { + "label": "Stops training if style similarity drops below threshold.", + "file_type": "rationale", + "source_file": "src/training/callbacks.py", + "source_location": "line 34", + "id": "src_training_callbacks_py_EarlyStoppingOnStyleDrift_doc", + "community": 18, + "norm_label": "stops training if style similarity drops below threshold." + }, + { + "label": "on_evaluate()", + "file_type": "code", + "source_file": "src/training/callbacks.py", + "source_location": "line 43", + "id": "src_training_callbacks_py_on_evaluate", + "community": 18, + "norm_label": "on_evaluate()" + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/training/callbacks.py", + "source_location": "line 37", + "id": "src_training_callbacks_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "dataset.py", + "file_type": "code", + "source_file": "src/training/dataset.py", + "id": "src_training_dataset_py", + "community": 5, + "norm_label": "dataset.py" + }, + { + "label": "Dataset class that handles all data sources and produces training triplets:\n(inp", + "file_type": "rationale", + "source_file": "src/training/dataset.py", + "id": "src_training_dataset_py_docstring", + "community": 5, + "norm_label": "dataset class that handles all data sources and produces training triplets:\n(inp" + }, + { + "label": "WritingCorrectionDataset", + "file_type": "code", + "source_file": "src/training/dataset.py", + "source_location": "line 45", + "id": "src_training_dataset_py_WritingCorrectionDataset", + "community": 5, + "norm_label": "writingcorrectiondataset" + }, + { + "label": "PyTorch dataset for writing correction training triplets.\n\nFully pre-computed at", + "file_type": "rationale", + "source_file": "src/training/dataset.py", + "source_location": "line 45", + "id": "src_training_dataset_py_WritingCorrectionDataset_doc", + "community": 5, + "norm_label": "pytorch dataset for writing correction training triplets.\n\nfully pre-computed at" + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/training/dataset.py", + "source_location": "line 54", + "id": "src_training_dataset_py___init__", + "community": 5, + "norm_label": "__init__()" + }, + { + "label": "_compute_cache_key()", + "file_type": "code", + "source_file": "src/training/dataset.py", + "source_location": "line 95", + "id": "src_training_dataset_py__compute_cache_key", + "community": 5, + "norm_label": "_compute_cache_key()" + }, + { + "label": "Generate a cache key based on data file content and processing params.", + "file_type": "rationale", + "source_file": "src/training/dataset.py", + "source_location": "line 95", + "id": "src_training_dataset_py__compute_cache_key_doc", + "community": 5, + "norm_label": "generate a cache key based on data file content and processing params." + }, + { + "label": "_load()", + "file_type": "code", + "source_file": "src/training/dataset.py", + "source_location": "line 107", + "id": "src_training_dataset_py__load", + "community": 5, + "norm_label": "_load()" + }, + { + "label": "Load JSONL data file.", + "file_type": "rationale", + "source_file": "src/training/dataset.py", + "source_location": "line 107", + "id": "src_training_dataset_py__load_doc", + "community": 5, + "norm_label": "load jsonl data file." + }, + { + "label": "_add_synthetic()", + "file_type": "code", + "source_file": "src/training/dataset.py", + "source_location": "line 126", + "id": "src_training_dataset_py__add_synthetic", + "community": 5, + "norm_label": "_add_synthetic()" + }, + { + "label": "Augment dataset with synthetic dyslexia examples.", + "file_type": "rationale", + "source_file": "src/training/dataset.py", + "source_location": "line 126", + "id": "src_training_dataset_py__add_synthetic_doc", + "community": 5, + "norm_label": "augment dataset with synthetic dyslexia examples." + }, + { + "label": "_precompute_all()", + "file_type": "code", + "source_file": "src/training/dataset.py", + "source_location": "line 150", + "id": "src_training_dataset_py__precompute_all", + "community": 5, + "norm_label": "_precompute_all()" + }, + { + "label": "Pre-compute tokenisation + style vectors for ALL examples.\nThis makes __getitem_", + "file_type": "rationale", + "source_file": "src/training/dataset.py", + "source_location": "line 150", + "id": "src_training_dataset_py__precompute_all_doc", + "community": 5, + "norm_label": "pre-compute tokenisation + style vectors for all examples.\nthis makes __getitem_" + }, + { + "label": "__len__()", + "file_type": "code", + "source_file": "src/training/dataset.py", + "source_location": "line 206", + "id": "src_training_dataset_py___len__", + "community": 5, + "norm_label": "__len__()" + }, + { + "label": "__getitem__()", + "file_type": "code", + "source_file": "src/training/dataset.py", + "source_location": "line 209", + "id": "src_training_dataset_py___getitem__", + "community": 5, + "norm_label": "__getitem__()" + }, + { + "label": "Pure dict return \u2014 zero computation per batch.", + "file_type": "rationale", + "source_file": "src/training/dataset.py", + "source_location": "line 209", + "id": "src_training_dataset_py___getitem___doc", + "community": 5, + "norm_label": "pure dict return \u2014 zero computation per batch." + }, + { + "label": "human_pattern_extractor.py", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "id": "src_training_human_pattern_extractor_py", + "community": 7, + "norm_label": "human_pattern_extractor.py" + }, + { + "label": "Extracts the statistical signature of human writing vs AI writing.\nUses Kaggle d", + "file_type": "rationale", + "source_file": "src/training/human_pattern_extractor.py", + "id": "src_training_human_pattern_extractor_py_docstring", + "community": 7, + "norm_label": "extracts the statistical signature of human writing vs ai writing.\nuses kaggle d" + }, + { + "label": "_compute_text_features()", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 68", + "id": "src_training_human_pattern_extractor_py__compute_text_features", + "community": 7, + "norm_label": "_compute_text_features()" + }, + { + "label": "Compute the 16 non-perplexity features from raw text.\nReturns a 16-dim float32 a", + "file_type": "rationale", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 68", + "id": "src_training_human_pattern_extractor_py__compute_text_features_doc", + "community": 7, + "norm_label": "compute the 16 non-perplexity features from raw text.\nreturns a 16-dim float32 a" + }, + { + "label": "HumanPatternFeatureExtractor", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 150", + "id": "src_training_human_pattern_extractor_py_HumanPatternFeatureExtractor", + "community": 7, + "norm_label": "humanpatternfeatureextractor" + }, + { + "label": "Extracts 17-dimensional feature vector encoding human vs AI writing patterns.\n\nO", + "file_type": "rationale", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 150", + "id": "src_training_human_pattern_extractor_py_HumanPatternFeatureExtractor_doc", + "community": 7, + "norm_label": "extracts 17-dimensional feature vector encoding human vs ai writing patterns.\n\no" + }, + { + "label": "KaggleHumanPatternDataset", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 367", + "id": "src_training_human_pattern_extractor_py_KaggleHumanPatternDataset", + "community": 7, + "norm_label": "kagglehumanpatterndataset" + }, + { + "label": "Loads both Kaggle datasets and produces (feature_vector, label) pairs.\nlabel = 1", + "file_type": "rationale", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 367", + "id": "src_training_human_pattern_extractor_py_KaggleHumanPatternDataset_doc", + "community": 7, + "norm_label": "loads both kaggle datasets and produces (feature_vector, label) pairs.\nlabel = 1" + }, + { + "label": "HumanPatternClassifier", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 506", + "id": "src_training_human_pattern_extractor_py_HumanPatternClassifier", + "community": 7, + "norm_label": "humanpatternclassifier" + }, + { + "label": "Lightweight MLP trained to distinguish human from AI writing.\nInput: feature vec", + "file_type": "rationale", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 506", + "id": "src_training_human_pattern_extractor_py_HumanPatternClassifier_doc", + "community": 7, + "norm_label": "lightweight mlp trained to distinguish human from ai writing.\ninput: feature vec" + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 515", + "id": "src_training_human_pattern_extractor_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "_perplexity()", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 184", + "id": "src_training_human_pattern_extractor_py__perplexity", + "community": 7, + "norm_label": "_perplexity()" + }, + { + "label": "GPT-2 perplexity for a single text. Lower = more AI-like.", + "file_type": "rationale", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 184", + "id": "src_training_human_pattern_extractor_py__perplexity_doc", + "community": 7, + "norm_label": "gpt-2 perplexity for a single text. lower = more ai-like." + }, + { + "label": "_perplexity_batch()", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 203", + "id": "src_training_human_pattern_extractor_py__perplexity_batch", + "community": 7, + "norm_label": "_perplexity_batch()" + }, + { + "label": "Compute GPT-2 perplexity for a batch of texts efficiently on GPU.\n\nProcesses tex", + "file_type": "rationale", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 203", + "id": "src_training_human_pattern_extractor_py__perplexity_batch_doc", + "community": 7, + "norm_label": "compute gpt-2 perplexity for a batch of texts efficiently on gpu.\n\nprocesses tex" + }, + { + "label": "extract()", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 266", + "id": "src_training_human_pattern_extractor_py_extract", + "community": 7, + "norm_label": "extract()" + }, + { + "label": "Extract full 17-dimensional feature vector for a single text.", + "file_type": "rationale", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 266", + "id": "src_training_human_pattern_extractor_py_extract_doc", + "community": 7, + "norm_label": "extract full 17-dimensional feature vector for a single text." + }, + { + "label": "extract_batch()", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 284", + "id": "src_training_human_pattern_extractor_py_extract_batch", + "community": 7, + "norm_label": "extract_batch()" + }, + { + "label": "Extract features for many texts efficiently.\n\nStrategy:\n 1. Compute perplexity ", + "file_type": "rationale", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 284", + "id": "src_training_human_pattern_extractor_py_extract_batch_doc", + "community": 7, + "norm_label": "extract features for many texts efficiently.\n\nstrategy:\n 1. compute perplexity " + }, + { + "label": "precompute_features()", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 462", + "id": "src_training_human_pattern_extractor_py_precompute_features", + "community": 7, + "norm_label": "precompute_features()" + }, + { + "label": "Pre-compute all features using optimised batched extraction.", + "file_type": "rationale", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 462", + "id": "src_training_human_pattern_extractor_py_precompute_features_doc", + "community": 7, + "norm_label": "pre-compute all features using optimised batched extraction." + }, + { + "label": "__len__()", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 488", + "id": "src_training_human_pattern_extractor_py___len__", + "community": 7, + "norm_label": "__len__()" + }, + { + "label": "__getitem__()", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 491", + "id": "src_training_human_pattern_extractor_py___getitem__", + "community": 7, + "norm_label": "__getitem__()" + }, + { + "label": "forward()", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 529", + "id": "src_training_human_pattern_extractor_py_forward", + "community": 7, + "norm_label": "forward()" + }, + { + "label": "Returns human-likeness score in [0, 1]. Higher = more human.", + "file_type": "rationale", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 529", + "id": "src_training_human_pattern_extractor_py_forward_doc", + "community": 7, + "norm_label": "returns human-likeness score in [0, 1]. higher = more human." + }, + { + "label": "score()", + "file_type": "code", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 534", + "id": "src_training_human_pattern_extractor_py_score", + "community": 7, + "norm_label": "score()" + }, + { + "label": "Convenience: score a single text string.", + "file_type": "rationale", + "source_file": "src/training/human_pattern_extractor.py", + "source_location": "line 534", + "id": "src_training_human_pattern_extractor_py_score_doc", + "community": 7, + "norm_label": "convenience: score a single text string." + }, + { + "label": "loss_functions.py", + "file_type": "code", + "source_file": "src/training/loss_functions.py", + "id": "src_training_loss_functions_py", + "community": 8, + "norm_label": "loss_functions.py" + }, + { + "label": "Combined training loss with Human-Pattern Term:\n\nL_total = L_CE + \u03bb\u2081 \u00b7 L_style +", + "file_type": "rationale", + "source_file": "src/training/loss_functions.py", + "id": "src_training_loss_functions_py_docstring", + "community": 8, + "norm_label": "combined training loss with human-pattern term:\n\nl_total = l_ce + \u03bb1 \u00b7 l_style +" + }, + { + "label": "CombinedCorrectionLoss", + "file_type": "code", + "source_file": "src/training/loss_functions.py", + "source_location": "line 24", + "id": "src_training_loss_functions_py_CombinedCorrectionLoss", + "community": 8, + "norm_label": "combinedcorrectionloss" + }, + { + "label": "V1 combined loss: L_CE + \u03bb\u2081\u00b7L_style + \u03bb\u2082\u00b7L_semantic.", + "file_type": "rationale", + "source_file": "src/training/loss_functions.py", + "source_location": "line 24", + "id": "src_training_loss_functions_py_CombinedCorrectionLoss_doc", + "community": 8, + "norm_label": "v1 combined loss: l_ce + \u03bb1\u00b7l_style + \u03bb2\u00b7l_semantic." + }, + { + "label": "CombinedCorrectionLossV2", + "file_type": "code", + "source_file": "src/training/loss_functions.py", + "source_location": "line 119", + "id": "src_training_loss_functions_py_CombinedCorrectionLossV2", + "community": 8, + "norm_label": "combinedcorrectionlossv2" + }, + { + "label": "V2 combined loss with human-pattern term: L_CE + \u03bb\u2081\u00b7L_style + \u03bb\u2082\u00b7L_semantic + \u03bb\u2083", + "file_type": "rationale", + "source_file": "src/training/loss_functions.py", + "source_location": "line 119", + "id": "src_training_loss_functions_py_CombinedCorrectionLossV2_doc", + "community": 8, + "norm_label": "v2 combined loss with human-pattern term: l_ce + \u03bb1\u00b7l_style + \u03bb2\u00b7l_semantic + \u03bb3" + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/training/loss_functions.py", + "source_location": "line 122", + "id": "src_training_loss_functions_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "_style_loss()", + "file_type": "code", + "source_file": "src/training/loss_functions.py", + "source_location": "line 50", + "id": "src_training_loss_functions_py__style_loss", + "community": 8, + "norm_label": "_style_loss()" + }, + { + "label": "1 - cosine_similarity(output_style, target_style).", + "file_type": "rationale", + "source_file": "src/training/loss_functions.py", + "source_location": "line 50", + "id": "src_training_loss_functions_py__style_loss_doc", + "community": 8, + "norm_label": "1 - cosine_similarity(output_style, target_style)." + }, + { + "label": "_semantic_loss()", + "file_type": "code", + "source_file": "src/training/loss_functions.py", + "source_location": "line 63", + "id": "src_training_loss_functions_py__semantic_loss", + "community": 8, + "norm_label": "_semantic_loss()" + }, + { + "label": "Penalises meaning change between input and output.", + "file_type": "rationale", + "source_file": "src/training/loss_functions.py", + "source_location": "line 63", + "id": "src_training_loss_functions_py__semantic_loss_doc", + "community": 8, + "norm_label": "penalises meaning change between input and output." + }, + { + "label": "forward()", + "file_type": "code", + "source_file": "src/training/loss_functions.py", + "source_location": "line 172", + "id": "src_training_loss_functions_py_forward", + "community": 8, + "norm_label": "forward()" + }, + { + "label": "Compute combined loss with human pattern term.", + "file_type": "rationale", + "source_file": "src/training/loss_functions.py", + "source_location": "line 172", + "id": "src_training_loss_functions_py_forward_doc", + "community": 8, + "norm_label": "compute combined loss with human pattern term." + }, + { + "label": "_human_pattern_loss()", + "file_type": "code", + "source_file": "src/training/loss_functions.py", + "source_location": "line 162", + "id": "src_training_loss_functions_py__human_pattern_loss", + "community": 8, + "norm_label": "_human_pattern_loss()" + }, + { + "label": "Loss = 1 - human_score. Penalise AI-like outputs.", + "file_type": "rationale", + "source_file": "src/training/loss_functions.py", + "source_location": "line 162", + "id": "src_training_loss_functions_py__human_pattern_loss_doc", + "community": 8, + "norm_label": "loss = 1 - human_score. penalise ai-like outputs." + }, + { + "label": "trainer.py", + "file_type": "code", + "source_file": "src/training/trainer.py", + "id": "src_training_trainer_py", + "community": 16, + "norm_label": "trainer.py" + }, + { + "label": "Custom HuggingFace Trainer subclass.\nUses the model's built-in cross-entropy los", + "file_type": "rationale", + "source_file": "src/training/trainer.py", + "id": "src_training_trainer_py_docstring", + "community": 16, + "norm_label": "custom huggingface trainer subclass.\nuses the model's built-in cross-entropy los" + }, + { + "label": "CorrectionTrainer", + "file_type": "code", + "source_file": "src/training/trainer.py", + "source_location": "line 12", + "id": "src_training_trainer_py_CorrectionTrainer", + "community": 16, + "norm_label": "correctiontrainer" + }, + { + "label": "Custom trainer \u2014 uses model's built-in loss directly.", + "file_type": "rationale", + "source_file": "src/training/trainer.py", + "source_location": "line 12", + "id": "src_training_trainer_py_CorrectionTrainer_doc", + "community": 16, + "norm_label": "custom trainer \u2014 uses model's built-in loss directly." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/training/trainer.py", + "source_location": "line 15", + "id": "src_training_trainer_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "_strip_custom_fields()", + "file_type": "code", + "source_file": "src/training/trainer.py", + "source_location": "line 21", + "id": "src_training_trainer_py__strip_custom_fields", + "community": 16, + "norm_label": "_strip_custom_fields()" + }, + { + "label": "Remove dataset fields that T5 doesn't accept.", + "file_type": "rationale", + "source_file": "src/training/trainer.py", + "source_location": "line 21", + "id": "src_training_trainer_py__strip_custom_fields_doc", + "community": 16, + "norm_label": "remove dataset fields that t5 doesn't accept." + }, + { + "label": "compute_loss()", + "file_type": "code", + "source_file": "src/training/trainer.py", + "source_location": "line 28", + "id": "src_training_trainer_py_compute_loss", + "community": 16, + "norm_label": "compute_loss()" + }, + { + "label": "Use model's built-in CE loss \u2014 avoids double-computing logits loss.", + "file_type": "rationale", + "source_file": "src/training/trainer.py", + "source_location": "line 28", + "id": "src_training_trainer_py_compute_loss_doc", + "community": 16, + "norm_label": "use model's built-in ce loss \u2014 avoids double-computing logits loss." + }, + { + "label": "prediction_step()", + "file_type": "code", + "source_file": "src/training/trainer.py", + "source_location": "line 39", + "id": "src_training_trainer_py_prediction_step", + "community": 16, + "norm_label": "prediction_step()" + }, + { + "label": "Compute eval loss directly \u2014 strips custom fields and runs forward.\n\nThe parent'", + "file_type": "rationale", + "source_file": "src/training/trainer.py", + "source_location": "line 39", + "id": "src_training_trainer_py_prediction_step_doc", + "community": 16, + "norm_label": "compute eval loss directly \u2014 strips custom fields and runs forward.\n\nthe parent'" + }, + { + "label": "awl_loader.py", + "file_type": "code", + "source_file": "src/vocabulary/awl_loader.py", + "id": "src_vocabulary_awl_loader_py", + "community": 3, + "norm_label": "awl_loader.py" + }, + { + "label": "Academic Word List (AWL) loader.\nLoads the Coxhead AWL and supplementary domain-", + "file_type": "rationale", + "source_file": "src/vocabulary/awl_loader.py", + "id": "src_vocabulary_awl_loader_py_docstring", + "community": 3, + "norm_label": "academic word list (awl) loader.\nloads the coxhead awl and supplementary domain-" + }, + { + "label": "AWLLoader", + "file_type": "code", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 13", + "id": "src_vocabulary_awl_loader_py_AWLLoader", + "community": 3, + "norm_label": "awlloader" + }, + { + "label": "Loads and manages Academic Word List data.", + "file_type": "rationale", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 13", + "id": "src_vocabulary_awl_loader_py_AWLLoader_doc", + "community": 3, + "norm_label": "loads and manages academic word list data." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 16", + "id": "src_vocabulary_awl_loader_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "_load_word_list()", + "file_type": "code", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 39", + "id": "src_vocabulary_awl_loader_py__load_word_list", + "community": 3, + "norm_label": "_load_word_list()" + }, + { + "label": "Load a word list file into a set of lowercase words.", + "file_type": "rationale", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 39", + "id": "src_vocabulary_awl_loader_py__load_word_list_doc", + "community": 3, + "norm_label": "load a word list file into a set of lowercase words." + }, + { + "label": "_load_synonyms()", + "file_type": "code", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 52", + "id": "src_vocabulary_awl_loader_py__load_synonyms", + "community": 3, + "norm_label": "_load_synonyms()" + }, + { + "label": "Load academic synonym mappings from JSON.", + "file_type": "rationale", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 52", + "id": "src_vocabulary_awl_loader_py__load_synonyms_doc", + "community": 3, + "norm_label": "load academic synonym mappings from json." + }, + { + "label": "is_academic()", + "file_type": "code", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 66", + "id": "src_vocabulary_awl_loader_py_is_academic", + "community": 3, + "norm_label": "is_academic()" + }, + { + "label": "Check if a word (or its lemma) is in the AWL.", + "file_type": "rationale", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 66", + "id": "src_vocabulary_awl_loader_py_is_academic_doc", + "community": 3, + "norm_label": "check if a word (or its lemma) is in the awl." + }, + { + "label": "get_academic_synonyms()", + "file_type": "code", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 70", + "id": "src_vocabulary_awl_loader_py_get_academic_synonyms", + "community": 3, + "norm_label": "get_academic_synonyms()" + }, + { + "label": "Return academic synonyms for a colloquial word.", + "file_type": "rationale", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 70", + "id": "src_vocabulary_awl_loader_py_get_academic_synonyms_doc", + "community": 3, + "norm_label": "return academic synonyms for a colloquial word." + }, + { + "label": "all_words()", + "file_type": "code", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 75", + "id": "src_vocabulary_awl_loader_py_all_words", + "community": 3, + "norm_label": "all_words()" + }, + { + "label": "Return the full set of academic words.", + "file_type": "rationale", + "source_file": "src/vocabulary/awl_loader.py", + "source_location": "line 75", + "id": "src_vocabulary_awl_loader_py_all_words_doc", + "community": 3, + "norm_label": "return the full set of academic words." + }, + { + "label": "lexical_substitution.py", + "file_type": "code", + "source_file": "src/vocabulary/lexical_substitution.py", + "id": "src_vocabulary_lexical_substitution_py", + "community": 3, + "norm_label": "lexical_substitution.py" + }, + { + "label": "Post-generation academic vocabulary elevation module.\n\nPipeline:\n1. POS-tag the ", + "file_type": "rationale", + "source_file": "src/vocabulary/lexical_substitution.py", + "id": "src_vocabulary_lexical_substitution_py_docstring", + "community": 3, + "norm_label": "post-generation academic vocabulary elevation module.\n\npipeline:\n1. pos-tag the " + }, + { + "label": "LexicalElevator", + "file_type": "code", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 29", + "id": "src_vocabulary_lexical_substitution_py_LexicalElevator", + "community": 3, + "norm_label": "lexicalelevator" + }, + { + "label": "Elevates vocabulary to academic register using BERT-based substitution.", + "file_type": "rationale", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 29", + "id": "src_vocabulary_lexical_substitution_py_LexicalElevator_doc", + "community": 3, + "norm_label": "elevates vocabulary to academic register using bert-based substitution." + }, + { + "label": "RegisterFilter", + "file_type": "code", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 178", + "id": "src_vocabulary_lexical_substitution_py_RegisterFilter", + "community": 3, + "norm_label": "registerfilter" + }, + { + "label": "Applies register-level corrections to ensure academic tone:\n- Converts contracti", + "file_type": "rationale", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 178", + "id": "src_vocabulary_lexical_substitution_py_RegisterFilter_doc", + "community": 3, + "norm_label": "applies register-level corrections to ensure academic tone:\n- converts contracti" + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 36", + "id": "src_vocabulary_lexical_substitution_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "_sem_similarity()", + "file_type": "code", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 67", + "id": "src_vocabulary_lexical_substitution_py__sem_similarity", + "community": 3, + "norm_label": "_sem_similarity()" + }, + { + "label": "Compute contextual semantic similarity using sentence embeddings.", + "file_type": "rationale", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 67", + "id": "src_vocabulary_lexical_substitution_py__sem_similarity_doc", + "community": 3, + "norm_label": "compute contextual semantic similarity using sentence embeddings." + }, + { + "label": "_get_awl_substitutions()", + "file_type": "code", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 77", + "id": "src_vocabulary_lexical_substitution_py__get_awl_substitutions", + "community": 3, + "norm_label": "_get_awl_substitutions()" + }, + { + "label": "Generate candidate AWL substitutions using BERT fill-mask.", + "file_type": "rationale", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 77", + "id": "src_vocabulary_lexical_substitution_py__get_awl_substitutions_doc", + "community": 3, + "norm_label": "generate candidate awl substitutions using bert fill-mask." + }, + { + "label": "elevate()", + "file_type": "code", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 108", + "id": "src_vocabulary_lexical_substitution_py_elevate", + "community": 3, + "norm_label": "elevate()" + }, + { + "label": "Main entry point: elevates vocabulary to academic register.", + "file_type": "rationale", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 108", + "id": "src_vocabulary_lexical_substitution_py_elevate_doc", + "community": 3, + "norm_label": "main entry point: elevates vocabulary to academic register." + }, + { + "label": "apply()", + "file_type": "code", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 222", + "id": "src_vocabulary_lexical_substitution_py_apply", + "community": 3, + "norm_label": "apply()" + }, + { + "label": "Apply contraction expansion and colloquial-to-academic substitution.", + "file_type": "rationale", + "source_file": "src/vocabulary/lexical_substitution.py", + "source_location": "line 222", + "id": "src_vocabulary_lexical_substitution_py_apply_doc", + "community": 3, + "norm_label": "apply contraction expansion and colloquial-to-academic substitution." + }, + { + "label": "register_filter.py", + "file_type": "code", + "source_file": "src/vocabulary/register_filter.py", + "id": "src_vocabulary_register_filter_py", + "community": 14, + "norm_label": "register_filter.py" + }, + { + "label": "Register filter module.\nApplies register-level post-processing to ensure output ", + "file_type": "rationale", + "source_file": "src/vocabulary/register_filter.py", + "id": "src_vocabulary_register_filter_py_docstring", + "community": 14, + "norm_label": "register filter module.\napplies register-level post-processing to ensure output " + }, + { + "label": "RegisterFilterAdvanced", + "file_type": "code", + "source_file": "src/vocabulary/register_filter.py", + "source_location": "line 12", + "id": "src_vocabulary_register_filter_py_RegisterFilterAdvanced", + "community": 14, + "norm_label": "registerfilteradvanced" + }, + { + "label": "Advanced register filtering with nominalisation and hedging passes.", + "file_type": "rationale", + "source_file": "src/vocabulary/register_filter.py", + "source_location": "line 12", + "id": "src_vocabulary_register_filter_py_RegisterFilterAdvanced_doc", + "community": 14, + "norm_label": "advanced register filtering with nominalisation and hedging passes." + }, + { + "label": "__init__()", + "file_type": "code", + "source_file": "src/vocabulary/register_filter.py", + "source_location": "line 54", + "id": "src_vocabulary_register_filter_py___init__", + "community": 4, + "norm_label": "__init__()" + }, + { + "label": "nominalise()", + "file_type": "code", + "source_file": "src/vocabulary/register_filter.py", + "source_location": "line 57", + "id": "src_vocabulary_register_filter_py_nominalise", + "community": 14, + "norm_label": "nominalise()" + }, + { + "label": "Convert verbal phrases to nominal forms where appropriate.\n\nOnly applies to clea", + "file_type": "rationale", + "source_file": "src/vocabulary/register_filter.py", + "source_location": "line 57", + "id": "src_vocabulary_register_filter_py_nominalise_doc", + "community": 14, + "norm_label": "convert verbal phrases to nominal forms where appropriate.\n\nonly applies to clea" + }, + { + "label": "add_hedging()", + "file_type": "code", + "source_file": "src/vocabulary/register_filter.py", + "source_location": "line 76", + "id": "src_vocabulary_register_filter_py_add_hedging", + "community": 14, + "norm_label": "add_hedging()" + }, + { + "label": "Add hedging language where claims are too absolute.\n\nOnly applies to the first o", + "file_type": "rationale", + "source_file": "src/vocabulary/register_filter.py", + "source_location": "line 76", + "id": "src_vocabulary_register_filter_py_add_hedging_doc", + "community": 14, + "norm_label": "add hedging language where claims are too absolute.\n\nonly applies to the first o" + }, + { + "label": "check_formality()", + "file_type": "code", + "source_file": "src/vocabulary/register_filter.py", + "source_location": "line 93", + "id": "src_vocabulary_register_filter_py_check_formality", + "community": 14, + "norm_label": "check_formality()" + }, + { + "label": "Score text formality on 0-1 scale.", + "file_type": "rationale", + "source_file": "src/vocabulary/register_filter.py", + "source_location": "line 93", + "id": "src_vocabulary_register_filter_py_check_formality_doc", + "community": 14, + "norm_label": "score text formality on 0-1 scale." + }, + { + "label": "test_evaluation.py", + "file_type": "code", + "source_file": "tests/test_evaluation.py", + "id": "tests_test_evaluation_py", + "community": 1, + "norm_label": "test_evaluation.py" + }, + { + "label": "Tests for the evaluation framework.", + "file_type": "rationale", + "source_file": "tests/test_evaluation.py", + "id": "tests_test_evaluation_py_docstring", + "community": 1, + "norm_label": "tests for the evaluation framework." + }, + { + "label": "test_gleu_scorer_instantiation()", + "file_type": "code", + "source_file": "tests/test_evaluation.py", + "source_location": "line 7", + "id": "tests_test_evaluation_py_test_gleu_scorer_instantiation", + "community": 1, + "norm_label": "test_gleu_scorer_instantiation()" + }, + { + "label": "Test that GLEU scorer can be created.", + "file_type": "rationale", + "source_file": "tests/test_evaluation.py", + "source_location": "line 7", + "id": "tests_test_evaluation_py_test_gleu_scorer_instantiation_doc", + "community": 1, + "norm_label": "test that gleu scorer can be created." + }, + { + "label": "test_gleu_perfect_score()", + "file_type": "code", + "source_file": "tests/test_evaluation.py", + "source_location": "line 13", + "id": "tests_test_evaluation_py_test_gleu_perfect_score", + "community": 1, + "norm_label": "test_gleu_perfect_score()" + }, + { + "label": "Test that identical predictions and references score high.", + "file_type": "rationale", + "source_file": "tests/test_evaluation.py", + "source_location": "line 13", + "id": "tests_test_evaluation_py_test_gleu_perfect_score_doc", + "community": 1, + "norm_label": "test that identical predictions and references score high." + }, + { + "label": "test_gleu_empty_input()", + "file_type": "code", + "source_file": "tests/test_evaluation.py", + "source_location": "line 22", + "id": "tests_test_evaluation_py_test_gleu_empty_input", + "community": 1, + "norm_label": "test_gleu_empty_input()" + }, + { + "label": "Test empty input handling.", + "file_type": "rationale", + "source_file": "tests/test_evaluation.py", + "source_location": "line 22", + "id": "tests_test_evaluation_py_test_gleu_empty_input_doc", + "community": 1, + "norm_label": "test empty input handling." + }, + { + "label": "test_awl_coverage_score()", + "file_type": "code", + "source_file": "tests/test_evaluation.py", + "source_location": "line 28", + "id": "tests_test_evaluation_py_test_awl_coverage_score", + "community": 1, + "norm_label": "test_awl_coverage_score()" + }, + { + "label": "Test AWL coverage scoring.", + "file_type": "rationale", + "source_file": "tests/test_evaluation.py", + "source_location": "line 28", + "id": "tests_test_evaluation_py_test_awl_coverage_score_doc", + "community": 1, + "norm_label": "test awl coverage scoring." + }, + { + "label": "test_model.py", + "file_type": "code", + "source_file": "tests/test_model.py", + "id": "tests_test_model_py", + "community": 6, + "norm_label": "test_model.py" + }, + { + "label": "Tests for the core model module.", + "file_type": "rationale", + "source_file": "tests/test_model.py", + "id": "tests_test_model_py_docstring", + "community": 6, + "norm_label": "tests for the core model module." + }, + { + "label": "test_model_registry_populated()", + "file_type": "code", + "source_file": "tests/test_model.py", + "source_location": "line 11", + "id": "tests_test_model_py_test_model_registry_populated", + "community": 6, + "norm_label": "test_model_registry_populated()" + }, + { + "label": "Test that model registries are defined.", + "file_type": "rationale", + "source_file": "tests/test_model.py", + "source_location": "line 11", + "id": "tests_test_model_py_test_model_registry_populated_doc", + "community": 6, + "norm_label": "test that model registries are defined." + }, + { + "label": "test_invalid_model_key()", + "file_type": "code", + "source_file": "tests/test_model.py", + "source_location": "line 17", + "id": "tests_test_model_py_test_invalid_model_key", + "community": 6, + "norm_label": "test_invalid_model_key()" + }, + { + "label": "Test that unknown model keys raise ValueError.", + "file_type": "rationale", + "source_file": "tests/test_model.py", + "source_location": "line 17", + "id": "tests_test_model_py_test_invalid_model_key_doc", + "community": 6, + "norm_label": "test that unknown model keys raise valueerror." + }, + { + "label": "test_style_conditioner_output_shape()", + "file_type": "code", + "source_file": "tests/test_model.py", + "source_location": "line 23", + "id": "tests_test_model_py_test_style_conditioner_output_shape", + "community": 6, + "norm_label": "test_style_conditioner_output_shape()" + }, + { + "label": "Test that style conditioner produces correct tensor shapes.", + "file_type": "rationale", + "source_file": "tests/test_model.py", + "source_location": "line 23", + "id": "tests_test_model_py_test_style_conditioner_output_shape_doc", + "community": 6, + "norm_label": "test that style conditioner produces correct tensor shapes." + }, + { + "label": "test_prepend_style_prefix()", + "file_type": "code", + "source_file": "tests/test_model.py", + "source_location": "line 32", + "id": "tests_test_model_py_test_prepend_style_prefix", + "community": 6, + "norm_label": "test_prepend_style_prefix()" + }, + { + "label": "Test prefix prepending dimensions.", + "file_type": "rationale", + "source_file": "tests/test_model.py", + "source_location": "line 32", + "id": "tests_test_model_py_test_prepend_style_prefix_doc", + "community": 6, + "norm_label": "test prefix prepending dimensions." + }, + { + "label": "test_lora_config_creation()", + "file_type": "code", + "source_file": "tests/test_model.py", + "source_location": "line 40", + "id": "tests_test_model_py_test_lora_config_creation", + "community": 6, + "norm_label": "test_lora_config_creation()" + }, + { + "label": "Test LoRA config creation.", + "file_type": "rationale", + "source_file": "tests/test_model.py", + "source_location": "line 40", + "id": "tests_test_model_py_test_lora_config_creation_doc", + "community": 6, + "norm_label": "test lora config creation." + }, + { + "label": "test_preprocessing.py", + "file_type": "code", + "source_file": "tests/test_preprocessing.py", + "id": "tests_test_preprocessing_py", + "community": 0, + "norm_label": "test_preprocessing.py" + }, + { + "label": "Tests for the preprocessing pipeline.", + "file_type": "rationale", + "source_file": "tests/test_preprocessing.py", + "id": "tests_test_preprocessing_py_docstring", + "community": 0, + "norm_label": "tests for the preprocessing pipeline." + }, + { + "label": "simulator()", + "file_type": "code", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 9", + "id": "tests_test_preprocessing_py_simulator", + "community": 0, + "norm_label": "simulator()" + }, + { + "label": "corrector()", + "file_type": "code", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 14", + "id": "tests_test_preprocessing_py_corrector", + "community": 0, + "norm_label": "corrector()" + }, + { + "label": "test_spell_correction_phonetic()", + "file_type": "code", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 20", + "id": "tests_test_preprocessing_py_test_spell_correction_phonetic", + "community": 0, + "norm_label": "test_spell_correction_phonetic()" + }, + { + "label": "Test that common dyslexic misspellings are corrected.", + "file_type": "rationale", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 20", + "id": "tests_test_preprocessing_py_test_spell_correction_phonetic_doc", + "community": 0, + "norm_label": "test that common dyslexic misspellings are corrected." + }, + { + "label": "test_spell_correction_empty()", + "file_type": "code", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 27", + "id": "tests_test_preprocessing_py_test_spell_correction_empty", + "community": 0, + "norm_label": "test_spell_correction_empty()" + }, + { + "label": "Test empty input handling.", + "file_type": "rationale", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 27", + "id": "tests_test_preprocessing_py_test_spell_correction_empty_doc", + "community": 0, + "norm_label": "test empty input handling." + }, + { + "label": "test_entity_protection()", + "file_type": "code", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 33", + "id": "tests_test_preprocessing_py_test_entity_protection", + "community": 0, + "norm_label": "test_entity_protection()" + }, + { + "label": "Test that named entities are identified and protected.", + "file_type": "rationale", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 33", + "id": "tests_test_preprocessing_py_test_entity_protection_doc", + "community": 0, + "norm_label": "test that named entities are identified and protected." + }, + { + "label": "test_sentence_segmentation()", + "file_type": "code", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 43", + "id": "tests_test_preprocessing_py_test_sentence_segmentation", + "community": 0, + "norm_label": "test_sentence_segmentation()" + }, + { + "label": "Test that text is correctly split into sentences.", + "file_type": "rationale", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 43", + "id": "tests_test_preprocessing_py_test_sentence_segmentation_doc", + "community": 0, + "norm_label": "test that text is correctly split into sentences." + }, + { + "label": "test_readability_scores()", + "file_type": "code", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 51", + "id": "tests_test_preprocessing_py_test_readability_scores", + "community": 0, + "norm_label": "test_readability_scores()" + }, + { + "label": "Test that readability metrics are computed.", + "file_type": "rationale", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 51", + "id": "tests_test_preprocessing_py_test_readability_scores_doc", + "community": 0, + "norm_label": "test that readability metrics are computed." + }, + { + "label": "test_dependency_trees()", + "file_type": "code", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 61", + "id": "tests_test_preprocessing_py_test_dependency_trees", + "community": 0, + "norm_label": "test_dependency_trees()" + }, + { + "label": "Test that dependency trees are extracted.", + "file_type": "rationale", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 61", + "id": "tests_test_preprocessing_py_test_dependency_trees_doc", + "community": 0, + "norm_label": "test that dependency trees are extracted." + }, + { + "label": "test_dyslexia_simulator()", + "file_type": "code", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 70", + "id": "tests_test_preprocessing_py_test_dyslexia_simulator", + "community": 0, + "norm_label": "test_dyslexia_simulator()" + }, + { + "label": "Test that the simulator produces corrupted text.", + "file_type": "rationale", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 70", + "id": "tests_test_preprocessing_py_test_dyslexia_simulator_doc", + "community": 0, + "norm_label": "test that the simulator produces corrupted text." + }, + { + "label": "test_dyslexia_simulator_preserves_clean()", + "file_type": "code", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 79", + "id": "tests_test_preprocessing_py_test_dyslexia_simulator_preserves_clean", + "community": 0, + "norm_label": "test_dyslexia_simulator_preserves_clean()" + }, + { + "label": "Test that the clean text is returned unchanged.", + "file_type": "rationale", + "source_file": "tests/test_preprocessing.py", + "source_location": "line 79", + "id": "tests_test_preprocessing_py_test_dyslexia_simulator_preserves_clean_doc", + "community": 0, + "norm_label": "test that the clean text is returned unchanged." + }, + { + "label": "test_style.py", + "file_type": "code", + "source_file": "tests/test_style.py", + "id": "tests_test_style_py", + "community": 2, + "norm_label": "test_style.py" + }, + { + "label": "Tests for the style fingerprinting module.", + "file_type": "rationale", + "source_file": "tests/test_style.py", + "id": "tests_test_style_py_docstring", + "community": 2, + "norm_label": "tests for the style fingerprinting module." + }, + { + "label": "fingerprinter()", + "file_type": "code", + "source_file": "tests/test_style.py", + "source_location": "line 10", + "id": "tests_test_style_py_fingerprinter", + "community": 2, + "norm_label": "fingerprinter()" + }, + { + "label": "test_style_vector_shape()", + "file_type": "code", + "source_file": "tests/test_style.py", + "source_location": "line 16", + "id": "tests_test_style_py_test_style_vector_shape", + "community": 2, + "norm_label": "test_style_vector_shape()" + }, + { + "label": "Test that style vectors have correct dimensionality.", + "file_type": "rationale", + "source_file": "tests/test_style.py", + "source_location": "line 16", + "id": "tests_test_style_py_test_style_vector_shape_doc", + "community": 2, + "norm_label": "test that style vectors have correct dimensionality." + }, + { + "label": "test_style_vector_different_texts()", + "file_type": "code", + "source_file": "tests/test_style.py", + "source_location": "line 22", + "id": "tests_test_style_py_test_style_vector_different_texts", + "community": 2, + "norm_label": "test_style_vector_different_texts()" + }, + { + "label": "Test that different writing styles produce different vectors.", + "file_type": "rationale", + "source_file": "tests/test_style.py", + "source_location": "line 22", + "id": "tests_test_style_py_test_style_vector_different_texts_doc", + "community": 2, + "norm_label": "test that different writing styles produce different vectors." + }, + { + "label": "test_style_blend()", + "file_type": "code", + "source_file": "tests/test_style.py", + "source_location": "line 32", + "id": "tests_test_style_py_test_style_blend", + "community": 2, + "norm_label": "test_style_blend()" + }, + { + "label": "Test that blended vectors have unit norm.", + "file_type": "rationale", + "source_file": "tests/test_style.py", + "source_location": "line 32", + "id": "tests_test_style_py_test_style_blend_doc", + "community": 2, + "norm_label": "test that blended vectors have unit norm." + }, + { + "label": "test_raw_features_keys()", + "file_type": "code", + "source_file": "tests/test_style.py", + "source_location": "line 41", + "id": "tests_test_style_py_test_raw_features_keys", + "community": 2, + "norm_label": "test_raw_features_keys()" + }, + { + "label": "Test that raw features contain expected keys.", + "file_type": "rationale", + "source_file": "tests/test_style.py", + "source_location": "line 41", + "id": "tests_test_style_py_test_raw_features_keys_doc", + "community": 2, + "norm_label": "test that raw features contain expected keys." + }, + { + "label": "test_vocabulary.py", + "file_type": "code", + "source_file": "tests/test_vocabulary.py", + "id": "tests_test_vocabulary_py", + "community": 3, + "norm_label": "test_vocabulary.py" + }, + { + "label": "Tests for the vocabulary elevation module.", + "file_type": "rationale", + "source_file": "tests/test_vocabulary.py", + "id": "tests_test_vocabulary_py_docstring", + "community": 3, + "norm_label": "tests for the vocabulary elevation module." + }, + { + "label": "test_awl_loader()", + "file_type": "code", + "source_file": "tests/test_vocabulary.py", + "source_location": "line 8", + "id": "tests_test_vocabulary_py_test_awl_loader", + "community": 3, + "norm_label": "test_awl_loader()" + }, + { + "label": "Test that AWL words are loaded correctly.", + "file_type": "rationale", + "source_file": "tests/test_vocabulary.py", + "source_location": "line 8", + "id": "tests_test_vocabulary_py_test_awl_loader_doc", + "community": 3, + "norm_label": "test that awl words are loaded correctly." + }, + { + "label": "test_awl_membership()", + "file_type": "code", + "source_file": "tests/test_vocabulary.py", + "source_location": "line 16", + "id": "tests_test_vocabulary_py_test_awl_membership", + "community": 3, + "norm_label": "test_awl_membership()" + }, + { + "label": "Test is_academic lookup.", + "file_type": "rationale", + "source_file": "tests/test_vocabulary.py", + "source_location": "line 16", + "id": "tests_test_vocabulary_py_test_awl_membership_doc", + "community": 3, + "norm_label": "test is_academic lookup." + }, + { + "label": "test_register_filter_contractions()", + "file_type": "code", + "source_file": "tests/test_vocabulary.py", + "source_location": "line 26", + "id": "tests_test_vocabulary_py_test_register_filter_contractions", + "community": 3, + "norm_label": "test_register_filter_contractions()" + }, + { + "label": "Test that contractions are expanded.", + "file_type": "rationale", + "source_file": "tests/test_vocabulary.py", + "source_location": "line 26", + "id": "tests_test_vocabulary_py_test_register_filter_contractions_doc", + "community": 3, + "norm_label": "test that contractions are expanded." + }, + { + "label": "test_register_filter_colloquialisms()", + "file_type": "code", + "source_file": "tests/test_vocabulary.py", + "source_location": "line 34", + "id": "tests_test_vocabulary_py_test_register_filter_colloquialisms", + "community": 3, + "norm_label": "test_register_filter_colloquialisms()" + }, + { + "label": "Test that colloquial phrases are replaced.", + "file_type": "rationale", + "source_file": "tests/test_vocabulary.py", + "source_location": "line 34", + "id": "tests_test_vocabulary_py_test_register_filter_colloquialisms_doc", + "community": 3, + "norm_label": "test that colloquial phrases are replaced." + }, + { + "label": "NudR Stateless API", + "file_type": "document", + "source_file": "README.md", + "id": "sem_nudr_api", + "community": 11, + "norm_label": "nudr stateless api" + }, + { + "label": "FastAPI Stateless Backend", + "file_type": "document", + "source_file": "README.md", + "id": "sem_fastapi_backend", + "community": 11, + "norm_label": "fastapi stateless backend" + }, + { + "label": "Supabase PostgreSQL Database", + "file_type": "document", + "source_file": "README.md", + "id": "sem_supabase_db", + "community": 11, + "norm_label": "supabase postgresql database" + }, + { + "label": "Redis Session & Cache Store", + "file_type": "document", + "source_file": "README.md", + "id": "sem_redis_cache", + "community": 11, + "norm_label": "redis session & cache store" + }, + { + "label": "Cloudflare Edge Proxy", + "file_type": "document", + "source_file": "README.md", + "id": "sem_cloudflare_proxy", + "community": 23, + "norm_label": "cloudflare edge proxy" + }, + { + "label": "Stripe Payment Integration", + "file_type": "document", + "source_file": "README.md", + "id": "sem_stripe_payments", + "community": 11, + "norm_label": "stripe payment integration" + }, + { + "label": "Firebase FCM Push Notifications", + "file_type": "document", + "source_file": "README.md", + "id": "sem_firebase_fcm", + "community": 11, + "norm_label": "firebase fcm push notifications" + }, + { + "label": "E2EE X25519 Key Exchange", + "file_type": "document", + "source_file": "README.md", + "id": "sem_e2ee_encryption", + "community": 11, + "norm_label": "e2ee x25519 key exchange" + }, + { + "label": "Protobuf Binary WebSocket Framing", + "file_type": "document", + "source_file": "README.md", + "id": "sem_protobuf_framing", + "community": 11, + "norm_label": "protobuf binary websocket framing" + }, + { + "label": "HMAC-SHA256 Request Verification", + "file_type": "document", + "source_file": "README.md", + "id": "sem_hmac_verification", + "community": 26, + "norm_label": "hmac-sha256 request verification" + }, + { + "label": "X-Origin-Secret Middleware", + "file_type": "document", + "source_file": "README.md", + "id": "sem_origin_secret", + "community": 23, + "norm_label": "x-origin-secret middleware" + }, + { + "label": "Proof-of-Work Challenge", + "file_type": "document", + "source_file": "README.md", + "id": "sem_pow_challenge", + "community": 27, + "norm_label": "proof-of-work challenge" + }, + { + "label": "Per-IP Rate Limiting", + "file_type": "document", + "source_file": "README.md", + "id": "sem_rate_limiting", + "community": 24, + "norm_label": "per-ip rate limiting" + }, + { + "label": "AWS Secrets Manager Integration", + "file_type": "document", + "source_file": "README.md", + "id": "sem_aws_secrets", + "community": 21, + "norm_label": "aws secrets manager integration" + }, + { + "label": "Terraform AWS Infrastructure", + "file_type": "document", + "source_file": "README.md", + "id": "sem_terraform_infra", + "community": 21, + "norm_label": "terraform aws infrastructure" + }, + { + "label": "VPC Network Topology", + "file_type": "document", + "source_file": "README.md", + "id": "sem_vpc_network", + "community": 21, + "norm_label": "vpc network topology" + }, + { + "label": "ALB + Auto Scaling Group", + "file_type": "document", + "source_file": "README.md", + "id": "sem_alb_autoscaling", + "community": 21, + "norm_label": "alb + auto scaling group" + }, + { + "label": "Lambda Origin Secret Rotator", + "file_type": "document", + "source_file": "README.md", + "id": "sem_lambda_rotator", + "community": 23, + "norm_label": "lambda origin secret rotator" + }, + { + "label": "Unified WebSocket Endpoint /ws", + "file_type": "document", + "source_file": "README.md", + "id": "sem_unified_ws", + "community": 11, + "norm_label": "unified websocket endpoint /ws" + }, + { + "label": "Feed WebSocket Channel", + "file_type": "document", + "source_file": "README.md", + "id": "sem_feed_ws", + "community": 11, + "norm_label": "feed websocket channel" + }, + { + "label": "Chat WebSocket Channel", + "file_type": "document", + "source_file": "README.md", + "id": "sem_chat_ws", + "community": 11, + "norm_label": "chat websocket channel" + }, + { + "label": "Keysync WebSocket Channel", + "file_type": "document", + "source_file": "README.md", + "id": "sem_keysync_ws", + "community": 11, + "norm_label": "keysync websocket channel" + }, + { + "label": "Discovery WebSocket Channel", + "file_type": "document", + "source_file": "README.md", + "id": "sem_discovery_ws", + "community": 11, + "norm_label": "discovery websocket channel" + }, + { + "label": "Attack Detection & IP Risk Management", + "file_type": "document", + "source_file": "README.md", + "id": "sem_attack_detection", + "community": 24, + "norm_label": "attack detection & ip risk management" + }, + { + "label": "Feed System Technical Documentation", + "file_type": "document", + "source_file": "PLAN/feed_system_documentation.md", + "id": "sem_feed_system", + "community": 11, + "norm_label": "feed system technical documentation" + }, + { + "label": "Multi-Factor Scoring Algorithm", + "file_type": "document", + "source_file": "PLAN/feed_system_documentation.md", + "id": "sem_feed_scoring", + "community": 11, + "norm_label": "multi-factor scoring algorithm" + }, + { + "label": "Feed Pool Computation Pipeline", + "file_type": "document", + "source_file": "PLAN/feed_system_documentation.md", + "id": "sem_feed_pool", + "community": 11, + "norm_label": "feed pool computation pipeline" + }, + { + "label": "Feed Hard Filters (12 Rules)", + "file_type": "document", + "source_file": "PLAN/feed_system_documentation.md", + "id": "sem_feed_filters", + "community": 11, + "norm_label": "feed hard filters (12 rules)" + }, + { + "label": "Preference Heatmap (Learned AI)", + "file_type": "document", + "source_file": "PLAN/feed_system_documentation.md", + "id": "sem_feed_heatmap", + "community": 11, + "norm_label": "preference heatmap (learned ai)" + }, + { + "label": "Reciprocal Boost & Injection", + "file_type": "document", + "source_file": "PLAN/feed_system_documentation.md", + "id": "sem_feed_reciprocal", + "community": 11, + "norm_label": "reciprocal boost & injection" + }, + { + "label": "3-Tier Gradient Distribution", + "file_type": "document", + "source_file": "PLAN/feed_system_documentation.md", + "id": "sem_feed_gradient", + "community": 11, + "norm_label": "3-tier gradient distribution" + }, + { + "label": "Feed Redis Key Schema", + "file_type": "document", + "source_file": "PLAN/feed_system_documentation.md", + "id": "sem_feed_redis", + "community": 11, + "norm_label": "feed redis key schema" + }, + { + "label": "Logic-Level Async Issue Audit", + "file_type": "document", + "source_file": "PLAN/LOGIC_ANALYSIS.md", + "id": "sem_logic_analysis", + "community": 11, + "norm_label": "logic-level async issue audit" + }, + { + "label": "DISASTROUS: id(ws) Memory Reuse Bug", + "file_type": "document", + "source_file": "PLAN/LOGIC_ANALYSIS.md", + "id": "sem_id_ws_reuse", + "community": 11, + "norm_label": "disastrous: id(ws) memory reuse bug" + }, + { + "label": "DISASTROUS: Token Refresh Crash Window", + "file_type": "document", + "source_file": "PLAN/LOGIC_ANALYSIS.md", + "id": "sem_token_refresh_crash", + "community": 11, + "norm_label": "disastrous: token refresh crash window" + }, + { + "label": "DISASTROUS: PubSub Listener Permanent Crash", + "file_type": "document", + "source_file": "PLAN/LOGIC_ANALYSIS.md", + "id": "sem_pubsub_crash", + "community": 11, + "norm_label": "disastrous: pubsub listener permanent crash" + }, + { + "label": "DISASTROUS: Redis Connection Pool Exhaustion", + "file_type": "document", + "source_file": "PLAN/LOGIC_ANALYSIS.md", + "id": "sem_redis_pool_exhaustion", + "community": 11, + "norm_label": "disastrous: redis connection pool exhaustion" + }, + { + "label": "Race Condition: Preference Merge", + "file_type": "document", + "source_file": "PLAN/LOGIC_ANALYSIS.md", + "id": "sem_preference_race", + "community": 11, + "norm_label": "race condition: preference merge" + } + ], + "links": [ + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py_docstring", + "source": "graph_codebase_py", + "target": "graph_codebase_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py_detect_files", + "source": "graph_codebase_py", + "target": "graph_codebase_py_detect_files" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py_get_changed_files", + "source": "graph_codebase_py", + "target": "graph_codebase_py_get_changed_files" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py_hash_file", + "source": "graph_codebase_py", + "target": "graph_codebase_py_hash_file" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py_extract_ast_file", + "source": "graph_codebase_py", + "target": "graph_codebase_py_extract_ast_file" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py__get_call_name", + "source": "graph_codebase_py", + "target": "graph_codebase_py__get_call_name" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py__get_name", + "source": "graph_codebase_py", + "target": "graph_codebase_py__get_name" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py__resolve_edges", + "source": "graph_codebase_py", + "target": "graph_codebase_py__resolve_edges" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py_run_ast_extraction", + "source": "graph_codebase_py", + "target": "graph_codebase_py_run_ast_extraction" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py_build_semantic_nodes", + "source": "graph_codebase_py", + "target": "graph_codebase_py_build_semantic_nodes" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py_merge_and_build", + "source": "graph_codebase_py", + "target": "graph_codebase_py_merge_and_build" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py_generate_outputs", + "source": "graph_codebase_py", + "target": "graph_codebase_py_generate_outputs" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py_run_pipeline", + "source": "graph_codebase_py", + "target": "graph_codebase_py_run_pipeline" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 1.0, + "_src": "graph_codebase_py", + "_tgt": "graph_codebase_py_watch_mode", + "source": "graph_codebase_py", + "target": "graph_codebase_py_watch_mode" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py_detect_files", + "_tgt": "graph_codebase_py_detect_files_doc", + "source": "graph_codebase_py_detect_files", + "target": "graph_codebase_py_detect_files_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_run_pipeline", + "_tgt": "graph_codebase_py_detect_files", + "source": "graph_codebase_py_detect_files", + "target": "graph_codebase_py_run_pipeline" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py_get_changed_files", + "_tgt": "graph_codebase_py_get_changed_files_doc", + "source": "graph_codebase_py_get_changed_files", + "target": "graph_codebase_py_get_changed_files_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_run_pipeline", + "_tgt": "graph_codebase_py_get_changed_files", + "source": "graph_codebase_py_get_changed_files", + "target": "graph_codebase_py_run_pipeline" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py_hash_file", + "_tgt": "graph_codebase_py_hash_file_doc", + "source": "graph_codebase_py_hash_file", + "target": "graph_codebase_py_hash_file_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_run_ast_extraction", + "_tgt": "graph_codebase_py_hash_file", + "source": "graph_codebase_py_hash_file", + "target": "graph_codebase_py_run_ast_extraction" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py_extract_ast_file", + "_tgt": "graph_codebase_py_extract_ast_file_doc", + "source": "graph_codebase_py_extract_ast_file", + "target": "graph_codebase_py_extract_ast_file_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_extract_ast_file", + "_tgt": "src_preprocessing_dependency_parser_py_parse", + "source": "graph_codebase_py_extract_ast_file", + "target": "src_preprocessing_dependency_parser_py_parse" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_extract_ast_file", + "_tgt": "graph_codebase_py__get_call_name", + "source": "graph_codebase_py_extract_ast_file", + "target": "graph_codebase_py__get_call_name" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_extract_ast_file", + "_tgt": "graph_codebase_py__get_name", + "source": "graph_codebase_py_extract_ast_file", + "target": "graph_codebase_py__get_name" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_run_ast_extraction", + "_tgt": "graph_codebase_py_extract_ast_file", + "source": "graph_codebase_py_extract_ast_file", + "target": "graph_codebase_py_run_ast_extraction" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py__get_call_name", + "_tgt": "graph_codebase_py__get_call_name_doc", + "source": "graph_codebase_py__get_call_name", + "target": "graph_codebase_py__get_call_name_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py__get_name", + "_tgt": "graph_codebase_py__get_name_doc", + "source": "graph_codebase_py__get_name", + "target": "graph_codebase_py__get_name_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py__resolve_edges", + "_tgt": "graph_codebase_py__resolve_edges_doc", + "source": "graph_codebase_py__resolve_edges", + "target": "graph_codebase_py__resolve_edges_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_run_ast_extraction", + "_tgt": "graph_codebase_py__resolve_edges", + "source": "graph_codebase_py__resolve_edges", + "target": "graph_codebase_py_run_ast_extraction" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py_run_ast_extraction", + "_tgt": "graph_codebase_py_run_ast_extraction_doc", + "source": "graph_codebase_py_run_ast_extraction", + "target": "graph_codebase_py_run_ast_extraction_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_run_pipeline", + "_tgt": "graph_codebase_py_run_ast_extraction", + "source": "graph_codebase_py_run_ast_extraction", + "target": "graph_codebase_py_run_pipeline" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py_build_semantic_nodes", + "_tgt": "graph_codebase_py_build_semantic_nodes_doc", + "source": "graph_codebase_py_build_semantic_nodes", + "target": "graph_codebase_py_build_semantic_nodes_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_run_pipeline", + "_tgt": "graph_codebase_py_build_semantic_nodes", + "source": "graph_codebase_py_build_semantic_nodes", + "target": "graph_codebase_py_run_pipeline" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py_merge_and_build", + "_tgt": "graph_codebase_py_merge_and_build_doc", + "source": "graph_codebase_py_merge_and_build", + "target": "graph_codebase_py_merge_and_build_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_run_pipeline", + "_tgt": "graph_codebase_py_merge_and_build", + "source": "graph_codebase_py_merge_and_build", + "target": "graph_codebase_py_run_pipeline" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py_generate_outputs", + "_tgt": "graph_codebase_py_generate_outputs_doc", + "source": "graph_codebase_py_generate_outputs", + "target": "graph_codebase_py_generate_outputs_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_run_pipeline", + "_tgt": "graph_codebase_py_generate_outputs", + "source": "graph_codebase_py_generate_outputs", + "target": "graph_codebase_py_run_pipeline" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py_run_pipeline", + "_tgt": "graph_codebase_py_run_pipeline_doc", + "source": "graph_codebase_py_run_pipeline", + "target": "graph_codebase_py_run_pipeline_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "graph_codebase.py", + "weight": 0.8, + "_src": "graph_codebase_py_watch_mode", + "_tgt": "graph_codebase_py_run_pipeline", + "source": "graph_codebase_py_run_pipeline", + "target": "graph_codebase_py_watch_mode" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "graph_codebase.py", + "weight": 0.5, + "_src": "graph_codebase_py_watch_mode", + "_tgt": "graph_codebase_py_watch_mode_doc", + "source": "graph_codebase_py_watch_mode", + "target": "graph_codebase_py_watch_mode_doc" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 1.0, + "_src": "data_raw_fce_json_to_m2_py", + "_tgt": "data_raw_fce_json_to_m2_py_main", + "source": "data_raw_fce_json_to_m2_py", + "target": "data_raw_fce_json_to_m2_py_main" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 1.0, + "_src": "data_raw_fce_json_to_m2_py", + "_tgt": "data_raw_fce_json_to_m2_py_parse_args", + "source": "data_raw_fce_json_to_m2_py", + "target": "data_raw_fce_json_to_m2_py_parse_args" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 1.0, + "_src": "data_raw_fce_json_to_m2_py", + "_tgt": "data_raw_fce_json_to_m2_py_get_paras", + "source": "data_raw_fce_json_to_m2_py", + "target": "data_raw_fce_json_to_m2_py_get_paras" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 1.0, + "_src": "data_raw_fce_json_to_m2_py", + "_tgt": "data_raw_fce_json_to_m2_py_clean_para", + "source": "data_raw_fce_json_to_m2_py", + "target": "data_raw_fce_json_to_m2_py_clean_para" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 1.0, + "_src": "data_raw_fce_json_to_m2_py", + "_tgt": "data_raw_fce_json_to_m2_py_get_token_edits", + "source": "data_raw_fce_json_to_m2_py", + "target": "data_raw_fce_json_to_m2_py_get_token_edits" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 1.0, + "_src": "data_raw_fce_json_to_m2_py", + "_tgt": "data_raw_fce_json_to_m2_py_get_all_tok_starts_and_ends", + "source": "data_raw_fce_json_to_m2_py", + "target": "data_raw_fce_json_to_m2_py_get_all_tok_starts_and_ends" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 1.0, + "_src": "data_raw_fce_json_to_m2_py", + "_tgt": "data_raw_fce_json_to_m2_py_convert_char_to_tok", + "source": "data_raw_fce_json_to_m2_py", + "target": "data_raw_fce_json_to_m2_py_convert_char_to_tok" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 1.0, + "_src": "data_raw_fce_json_to_m2_py", + "_tgt": "data_raw_fce_json_to_m2_py_get_sents", + "source": "data_raw_fce_json_to_m2_py", + "target": "data_raw_fce_json_to_m2_py_get_sents" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 1.0, + "_src": "data_raw_fce_json_to_m2_py", + "_tgt": "data_raw_fce_json_to_m2_py_prepare_sent_edits_output", + "source": "data_raw_fce_json_to_m2_py", + "target": "data_raw_fce_json_to_m2_py_prepare_sent_edits_output" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 1.0, + "_src": "data_raw_fce_json_to_m2_py", + "_tgt": "data_raw_fce_json_to_m2_py_noop_edit", + "source": "data_raw_fce_json_to_m2_py", + "target": "data_raw_fce_json_to_m2_py_noop_edit" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 0.8, + "_src": "data_raw_fce_json_to_m2_py_main", + "_tgt": "data_raw_fce_json_to_m2_py_parse_args", + "source": "data_raw_fce_json_to_m2_py_main", + "target": "data_raw_fce_json_to_m2_py_parse_args" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 0.8, + "_src": "data_raw_fce_json_to_m2_py_main", + "_tgt": "data_raw_fce_json_to_m2_py_get_paras", + "source": "data_raw_fce_json_to_m2_py_main", + "target": "data_raw_fce_json_to_m2_py_get_paras" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 0.8, + "_src": "data_raw_fce_json_to_m2_py_main", + "_tgt": "src_preprocessing_dependency_parser_py_parse", + "source": "data_raw_fce_json_to_m2_py_main", + "target": "src_preprocessing_dependency_parser_py_parse" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 0.8, + "_src": "data_raw_fce_json_to_m2_py_main", + "_tgt": "data_raw_fce_json_to_m2_py_clean_para", + "source": "data_raw_fce_json_to_m2_py_main", + "target": "data_raw_fce_json_to_m2_py_clean_para" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 0.8, + "_src": "data_raw_fce_json_to_m2_py_main", + "_tgt": "data_raw_fce_json_to_m2_py_get_token_edits", + "source": "data_raw_fce_json_to_m2_py_main", + "target": "data_raw_fce_json_to_m2_py_get_token_edits" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 0.8, + "_src": "data_raw_fce_json_to_m2_py_main", + "_tgt": "data_raw_fce_json_to_m2_py_get_sents", + "source": "data_raw_fce_json_to_m2_py_main", + "target": "data_raw_fce_json_to_m2_py_get_sents" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 0.8, + "_src": "data_raw_fce_json_to_m2_py_main", + "_tgt": "data_raw_fce_json_to_m2_py_noop_edit", + "source": "data_raw_fce_json_to_m2_py_main", + "target": "data_raw_fce_json_to_m2_py_noop_edit" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 0.8, + "_src": "data_raw_fce_json_to_m2_py_get_token_edits", + "_tgt": "data_raw_fce_json_to_m2_py_get_all_tok_starts_and_ends", + "source": "data_raw_fce_json_to_m2_py_get_token_edits", + "target": "data_raw_fce_json_to_m2_py_get_all_tok_starts_and_ends" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 0.8, + "_src": "data_raw_fce_json_to_m2_py_get_token_edits", + "_tgt": "data_raw_fce_json_to_m2_py_convert_char_to_tok", + "source": "data_raw_fce_json_to_m2_py_get_token_edits", + "target": "data_raw_fce_json_to_m2_py_convert_char_to_tok" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "data/raw/fce/json_to_m2.py", + "weight": 0.8, + "_src": "data_raw_fce_json_to_m2_py_get_sents", + "_tgt": "data_raw_fce_json_to_m2_py_prepare_sent_edits_output", + "source": "data_raw_fce_json_to_m2_py_get_sents", + "target": "data_raw_fce_json_to_m2_py_prepare_sent_edits_output" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.5, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_docstring", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 1.0, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_GLEU", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py_GLEU" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 1.0, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py___init__", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 1.0, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_load_hypothesis_sentence", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py_load_hypothesis_sentence" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 1.0, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_load_sources", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py_load_sources" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 1.0, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_load_references", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py_load_references" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 1.0, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 1.0, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_diff", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_diff" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 1.0, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_normalization", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py_normalization" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 1.0, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 1.0, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_gleu", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py_gleu" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 1.0, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_get_gleu_stats", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py_get_gleu_stats" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 1.0, + "_src": "data_raw_jfleg_repo_eval_gleu_py", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_run_iterations", + "source": "data_raw_jfleg_repo_eval_gleu_py", + "target": "data_raw_jfleg_repo_eval_gleu_py_run_iterations" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py___init__", + "source": "data_raw_jfleg_repo_eval_gleu_py___init__", + "target": "scripts_train_py_train" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py___init__", + "source": "data_raw_jfleg_repo_eval_gleu_py___init__", + "target": "scripts_train_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py___init__", + "source": "data_raw_jfleg_repo_eval_gleu_py___init__", + "target": "src_api_middleware_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py___init__", + "source": "data_raw_jfleg_repo_eval_gleu_py___init__", + "target": "src_model_style_conditioner_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py___init__", + "source": "data_raw_jfleg_repo_eval_gleu_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py___init__", + "source": "data_raw_jfleg_repo_eval_gleu_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py___init__", + "source": "data_raw_jfleg_repo_eval_gleu_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py___init__", + "source": "data_raw_jfleg_repo_eval_gleu_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.5, + "_src": "data_raw_jfleg_repo_eval_gleu_py_load_hypothesis_sentence", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_load_hypothesis_sentence_doc", + "source": "data_raw_jfleg_repo_eval_gleu_py_load_hypothesis_sentence", + "target": "data_raw_jfleg_repo_eval_gleu_py_load_hypothesis_sentence_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.8, + "_src": "data_raw_jfleg_repo_eval_gleu_py_load_hypothesis_sentence", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts", + "source": "data_raw_jfleg_repo_eval_gleu_py_load_hypothesis_sentence", + "target": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.8, + "_src": "data_raw_jfleg_repo_eval_gleu_py_run_iterations", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_load_hypothesis_sentence", + "source": "data_raw_jfleg_repo_eval_gleu_py_load_hypothesis_sentence", + "target": "data_raw_jfleg_repo_eval_gleu_py_run_iterations" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.5, + "_src": "data_raw_jfleg_repo_eval_gleu_py_load_sources", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_load_sources_doc", + "source": "data_raw_jfleg_repo_eval_gleu_py_load_sources", + "target": "data_raw_jfleg_repo_eval_gleu_py_load_sources_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.8, + "_src": "data_raw_jfleg_repo_eval_gleu_py_load_sources", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts", + "source": "data_raw_jfleg_repo_eval_gleu_py_load_sources", + "target": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.5, + "_src": "data_raw_jfleg_repo_eval_gleu_py_load_references", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_load_references_doc", + "source": "data_raw_jfleg_repo_eval_gleu_py_load_references", + "target": "data_raw_jfleg_repo_eval_gleu_py_load_references_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.8, + "_src": "data_raw_jfleg_repo_eval_gleu_py_load_references", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts", + "source": "data_raw_jfleg_repo_eval_gleu_py_load_references", + "target": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.5, + "_src": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts_doc", + "source": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts", + "target": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.8, + "_src": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts", + "source": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_counts", + "target": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.5, + "_src": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_diff", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_diff_doc", + "source": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_diff", + "target": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_diff_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.8, + "_src": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_diff", + "source": "data_raw_jfleg_repo_eval_gleu_py_get_ngram_diff", + "target": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.5, + "_src": "data_raw_jfleg_repo_eval_gleu_py_normalization", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_normalization_doc", + "source": "data_raw_jfleg_repo_eval_gleu_py_normalization", + "target": "data_raw_jfleg_repo_eval_gleu_py_normalization_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.5, + "_src": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats_doc", + "source": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats", + "target": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.8, + "_src": "data_raw_jfleg_repo_eval_gleu_py_run_iterations", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats", + "source": "data_raw_jfleg_repo_eval_gleu_py_gleu_stats", + "target": "data_raw_jfleg_repo_eval_gleu_py_run_iterations" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.5, + "_src": "data_raw_jfleg_repo_eval_gleu_py_gleu", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_gleu_doc", + "source": "data_raw_jfleg_repo_eval_gleu_py_gleu", + "target": "data_raw_jfleg_repo_eval_gleu_py_gleu_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.8, + "_src": "data_raw_jfleg_repo_eval_gleu_py_run_iterations", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_gleu", + "source": "data_raw_jfleg_repo_eval_gleu_py_gleu", + "target": "data_raw_jfleg_repo_eval_gleu_py_run_iterations" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.5, + "_src": "data_raw_jfleg_repo_eval_gleu_py_get_gleu_stats", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_get_gleu_stats_doc", + "source": "data_raw_jfleg_repo_eval_gleu_py_get_gleu_stats", + "target": "data_raw_jfleg_repo_eval_gleu_py_get_gleu_stats_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.8, + "_src": "data_raw_jfleg_repo_eval_gleu_py_run_iterations", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_get_gleu_stats", + "source": "data_raw_jfleg_repo_eval_gleu_py_get_gleu_stats", + "target": "data_raw_jfleg_repo_eval_gleu_py_run_iterations" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "data/raw/jfleg_repo/eval/gleu.py", + "weight": 0.5, + "_src": "data_raw_jfleg_repo_eval_gleu_py_run_iterations", + "_tgt": "data_raw_jfleg_repo_eval_gleu_py_run_iterations_doc", + "source": "data_raw_jfleg_repo_eval_gleu_py_run_iterations", + "target": "data_raw_jfleg_repo_eval_gleu_py_run_iterations_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/download_all_huggingface_datasets.py", + "weight": 0.5, + "_src": "scripts_download_all_huggingface_datasets_py", + "_tgt": "scripts_download_all_huggingface_datasets_py_docstring", + "source": "scripts_download_all_huggingface_datasets_py", + "target": "scripts_download_all_huggingface_datasets_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/download_all_huggingface_datasets.py", + "weight": 1.0, + "_src": "scripts_download_all_huggingface_datasets_py", + "_tgt": "scripts_download_all_huggingface_datasets_py_main", + "source": "scripts_download_all_huggingface_datasets_py", + "target": "scripts_download_all_huggingface_datasets_py_main" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/evaluate.py", + "weight": 0.5, + "_src": "scripts_evaluate_py", + "_tgt": "scripts_evaluate_py_docstring", + "source": "scripts_evaluate_py", + "target": "scripts_evaluate_py_docstring" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/evaluate.py", + "weight": 0.6, + "_src": "scripts_evaluate_py", + "_tgt": "src_model_base_model_py", + "source": "scripts_evaluate_py", + "target": "src_model_base_model_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/evaluate.py", + "weight": 0.6, + "_src": "scripts_evaluate_py", + "_tgt": "src_model_generation_utils_py", + "source": "scripts_evaluate_py", + "target": "src_model_generation_utils_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/evaluate.py", + "weight": 0.6, + "_src": "scripts_evaluate_py", + "_tgt": "src_evaluation_gleu_scorer_py", + "source": "scripts_evaluate_py", + "target": "src_evaluation_gleu_scorer_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/evaluate.py", + "weight": 0.6, + "_src": "scripts_evaluate_py", + "_tgt": "src_evaluation_errant_evaluator_py", + "source": "scripts_evaluate_py", + "target": "src_evaluation_errant_evaluator_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/evaluate.py", + "weight": 0.6, + "_src": "scripts_evaluate_py", + "_tgt": "src_evaluation_style_metrics_py", + "source": "scripts_evaluate_py", + "target": "src_evaluation_style_metrics_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/evaluate.py", + "weight": 0.6, + "_src": "scripts_evaluate_py", + "_tgt": "src_style_fingerprinter_py", + "source": "scripts_evaluate_py", + "target": "src_style_fingerprinter_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/evaluate.py", + "weight": 0.6, + "_src": "scripts_evaluate_py", + "_tgt": "src_vocabulary_awl_loader_py", + "source": "scripts_evaluate_py", + "target": "src_vocabulary_awl_loader_py" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/evaluate.py", + "weight": 1.0, + "_src": "scripts_evaluate_py", + "_tgt": "scripts_evaluate_py_evaluate", + "source": "scripts_evaluate_py", + "target": "scripts_evaluate_py_evaluate" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/evaluate.py", + "weight": 0.5, + "_src": "scripts_evaluate_py_evaluate", + "_tgt": "scripts_evaluate_py_evaluate_doc", + "source": "scripts_evaluate_py_evaluate", + "target": "scripts_evaluate_py_evaluate_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/evaluate.py", + "weight": 0.8, + "_src": "scripts_evaluate_py_evaluate", + "_tgt": "src_model_generation_utils_py_batch_generate", + "source": "scripts_evaluate_py_evaluate", + "target": "src_model_generation_utils_py_batch_generate" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/evaluate.py", + "weight": 0.8, + "_src": "scripts_evaluate_py_evaluate", + "_tgt": "src_evaluation_gleu_scorer_py_compute_gleu", + "source": "scripts_evaluate_py_evaluate", + "target": "src_evaluation_gleu_scorer_py_compute_gleu" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/evaluate.py", + "weight": 0.8, + "_src": "scripts_evaluate_py_evaluate", + "_tgt": "src_evaluation_gleu_scorer_py_compute_bert_score", + "source": "scripts_evaluate_py_evaluate", + "target": "src_evaluation_gleu_scorer_py_compute_bert_score" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/evaluate.py", + "weight": 0.8, + "_src": "scripts_evaluate_py_evaluate", + "_tgt": "src_evaluation_errant_evaluator_py_evaluate", + "source": "scripts_evaluate_py_evaluate", + "target": "src_evaluation_errant_evaluator_py_evaluate" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/evaluate.py", + "weight": 0.8, + "_src": "scripts_evaluate_py_evaluate", + "_tgt": "src_evaluation_style_metrics_py_evaluate_batch", + "source": "scripts_evaluate_py_evaluate", + "target": "src_evaluation_style_metrics_py_evaluate_batch" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/evaluate.py", + "weight": 0.8, + "_src": "scripts_evaluate_py_evaluate", + "_tgt": "src_model_base_model_py_load_model_and_tokenizer", + "source": "scripts_evaluate_py_evaluate", + "target": "src_model_base_model_py_load_model_and_tokenizer" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 0.5, + "_src": "scripts_preprocess_data_py", + "_tgt": "scripts_preprocess_data_py_docstring", + "source": "scripts_preprocess_data_py", + "target": "scripts_preprocess_data_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 1.0, + "_src": "scripts_preprocess_data_py", + "_tgt": "scripts_preprocess_data_py_apply_bea19_edits", + "source": "scripts_preprocess_data_py", + "target": "scripts_preprocess_data_py_apply_bea19_edits" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 1.0, + "_src": "scripts_preprocess_data_py", + "_tgt": "scripts_preprocess_data_py_process_bea19_json", + "source": "scripts_preprocess_data_py", + "target": "scripts_preprocess_data_py_process_bea19_json" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 1.0, + "_src": "scripts_preprocess_data_py", + "_tgt": "scripts_preprocess_data_py_process_fce", + "source": "scripts_preprocess_data_py", + "target": "scripts_preprocess_data_py_process_fce" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 1.0, + "_src": "scripts_preprocess_data_py", + "_tgt": "scripts_preprocess_data_py_process_wi_locness", + "source": "scripts_preprocess_data_py", + "target": "scripts_preprocess_data_py_process_wi_locness" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 1.0, + "_src": "scripts_preprocess_data_py", + "_tgt": "scripts_preprocess_data_py_process_jfleg", + "source": "scripts_preprocess_data_py", + "target": "scripts_preprocess_data_py_process_jfleg" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 1.0, + "_src": "scripts_preprocess_data_py", + "_tgt": "scripts_preprocess_data_py_create_splits", + "source": "scripts_preprocess_data_py", + "target": "scripts_preprocess_data_py_create_splits" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 1.0, + "_src": "scripts_preprocess_data_py", + "_tgt": "scripts_preprocess_data_py_main", + "source": "scripts_preprocess_data_py", + "target": "scripts_preprocess_data_py_main" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 0.5, + "_src": "scripts_preprocess_data_py_apply_bea19_edits", + "_tgt": "scripts_preprocess_data_py_apply_bea19_edits_doc", + "source": "scripts_preprocess_data_py_apply_bea19_edits", + "target": "scripts_preprocess_data_py_apply_bea19_edits_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/preprocess_data.py", + "weight": 0.8, + "_src": "scripts_preprocess_data_py_process_bea19_json", + "_tgt": "scripts_preprocess_data_py_apply_bea19_edits", + "source": "scripts_preprocess_data_py_apply_bea19_edits", + "target": "scripts_preprocess_data_py_process_bea19_json" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 0.5, + "_src": "scripts_preprocess_data_py_process_bea19_json", + "_tgt": "scripts_preprocess_data_py_process_bea19_json_doc", + "source": "scripts_preprocess_data_py_process_bea19_json", + "target": "scripts_preprocess_data_py_process_bea19_json_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/preprocess_data.py", + "weight": 0.8, + "_src": "scripts_preprocess_data_py_process_fce", + "_tgt": "scripts_preprocess_data_py_process_bea19_json", + "source": "scripts_preprocess_data_py_process_bea19_json", + "target": "scripts_preprocess_data_py_process_fce" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/preprocess_data.py", + "weight": 0.8, + "_src": "scripts_preprocess_data_py_process_wi_locness", + "_tgt": "scripts_preprocess_data_py_process_bea19_json", + "source": "scripts_preprocess_data_py_process_bea19_json", + "target": "scripts_preprocess_data_py_process_wi_locness" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 0.5, + "_src": "scripts_preprocess_data_py_process_fce", + "_tgt": "scripts_preprocess_data_py_process_fce_doc", + "source": "scripts_preprocess_data_py_process_fce", + "target": "scripts_preprocess_data_py_process_fce_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/preprocess_data.py", + "weight": 0.8, + "_src": "scripts_preprocess_data_py_main", + "_tgt": "scripts_preprocess_data_py_process_fce", + "source": "scripts_preprocess_data_py_process_fce", + "target": "scripts_preprocess_data_py_main" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 0.5, + "_src": "scripts_preprocess_data_py_process_wi_locness", + "_tgt": "scripts_preprocess_data_py_process_wi_locness_doc", + "source": "scripts_preprocess_data_py_process_wi_locness", + "target": "scripts_preprocess_data_py_process_wi_locness_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/preprocess_data.py", + "weight": 0.8, + "_src": "scripts_preprocess_data_py_main", + "_tgt": "scripts_preprocess_data_py_process_wi_locness", + "source": "scripts_preprocess_data_py_process_wi_locness", + "target": "scripts_preprocess_data_py_main" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 0.5, + "_src": "scripts_preprocess_data_py_process_jfleg", + "_tgt": "scripts_preprocess_data_py_process_jfleg_doc", + "source": "scripts_preprocess_data_py_process_jfleg", + "target": "scripts_preprocess_data_py_process_jfleg_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/preprocess_data.py", + "weight": 0.8, + "_src": "scripts_preprocess_data_py_main", + "_tgt": "scripts_preprocess_data_py_process_jfleg", + "source": "scripts_preprocess_data_py_process_jfleg", + "target": "scripts_preprocess_data_py_main" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/preprocess_data.py", + "weight": 0.5, + "_src": "scripts_preprocess_data_py_create_splits", + "_tgt": "scripts_preprocess_data_py_create_splits_doc", + "source": "scripts_preprocess_data_py_create_splits", + "target": "scripts_preprocess_data_py_create_splits_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/preprocess_data.py", + "weight": 0.8, + "_src": "scripts_preprocess_data_py_main", + "_tgt": "scripts_preprocess_data_py_create_splits", + "source": "scripts_preprocess_data_py_create_splits", + "target": "scripts_preprocess_data_py_main" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/pretrain_human_pattern_classifier.py", + "weight": 0.5, + "_src": "scripts_pretrain_human_pattern_classifier_py", + "_tgt": "scripts_pretrain_human_pattern_classifier_py_docstring", + "source": "scripts_pretrain_human_pattern_classifier_py", + "target": "scripts_pretrain_human_pattern_classifier_py_docstring" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/pretrain_human_pattern_classifier.py", + "weight": 0.6, + "_src": "scripts_pretrain_human_pattern_classifier_py", + "_tgt": "src_training_human_pattern_extractor_py", + "source": "scripts_pretrain_human_pattern_classifier_py", + "target": "src_training_human_pattern_extractor_py" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/pretrain_human_pattern_classifier.py", + "weight": 1.0, + "_src": "scripts_pretrain_human_pattern_classifier_py", + "_tgt": "scripts_pretrain_human_pattern_classifier_py_train_classifier", + "source": "scripts_pretrain_human_pattern_classifier_py", + "target": "scripts_pretrain_human_pattern_classifier_py_train_classifier" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/pretrain_human_pattern_classifier.py", + "weight": 0.5, + "_src": "scripts_pretrain_human_pattern_classifier_py_train_classifier", + "_tgt": "scripts_pretrain_human_pattern_classifier_py_train_classifier_doc", + "source": "scripts_pretrain_human_pattern_classifier_py_train_classifier", + "target": "scripts_pretrain_human_pattern_classifier_py_train_classifier_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/pretrain_human_pattern_classifier.py", + "weight": 0.8, + "_src": "scripts_pretrain_human_pattern_classifier_py_train_classifier", + "_tgt": "src_training_human_pattern_extractor_py_precompute_features", + "source": "scripts_pretrain_human_pattern_classifier_py_train_classifier", + "target": "src_training_human_pattern_extractor_py_precompute_features" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/pretrain_human_pattern_classifier.py", + "weight": 0.8, + "_src": "scripts_pretrain_human_pattern_classifier_py_train_classifier", + "_tgt": "scripts_train_py_train", + "source": "scripts_pretrain_human_pattern_classifier_py_train_classifier", + "target": "scripts_train_py_train" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/run_inference.py", + "weight": 0.5, + "_src": "scripts_run_inference_py", + "_tgt": "scripts_run_inference_py_docstring", + "source": "scripts_run_inference_py", + "target": "scripts_run_inference_py_docstring" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/run_inference.py", + "weight": 0.6, + "_src": "scripts_run_inference_py", + "_tgt": "src_inference_corrector_py", + "source": "scripts_run_inference_py", + "target": "src_inference_corrector_py" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/run_inference.py", + "weight": 1.0, + "_src": "scripts_run_inference_py", + "_tgt": "scripts_run_inference_py_run_inference", + "source": "scripts_run_inference_py", + "target": "scripts_run_inference_py_run_inference" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/run_inference.py", + "weight": 0.5, + "_src": "scripts_run_inference_py_run_inference", + "_tgt": "scripts_run_inference_py_run_inference_doc", + "source": "scripts_run_inference_py_run_inference", + "target": "scripts_run_inference_py_run_inference_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/run_inference.py", + "weight": 0.8, + "_src": "scripts_run_inference_py_run_inference", + "_tgt": "src_inference_corrector_py_correct", + "source": "scripts_run_inference_py_run_inference", + "target": "src_inference_corrector_py_correct" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/run_inference.py", + "weight": 0.8, + "_src": "scripts_run_inference_py_run_inference", + "_tgt": "src_preprocessing_spell_corrector_py_correct", + "source": "scripts_run_inference_py_run_inference", + "target": "src_preprocessing_spell_corrector_py_correct" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.5, + "_src": "scripts_train_py", + "_tgt": "scripts_train_py_docstring", + "source": "scripts_train_py", + "target": "scripts_train_py_docstring" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.6, + "_src": "scripts_train_py", + "_tgt": "src_model_base_model_py", + "source": "scripts_train_py", + "target": "src_model_base_model_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.6, + "_src": "scripts_train_py", + "_tgt": "src_model_style_conditioner_py", + "source": "scripts_train_py", + "target": "src_model_style_conditioner_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.6, + "_src": "scripts_train_py", + "_tgt": "src_training_dataset_py", + "source": "scripts_train_py", + "target": "src_training_dataset_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.6, + "_src": "scripts_train_py", + "_tgt": "src_training_loss_functions_py", + "source": "scripts_train_py", + "target": "src_training_loss_functions_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.6, + "_src": "scripts_train_py", + "_tgt": "src_training_trainer_py", + "source": "scripts_train_py", + "target": "src_training_trainer_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.6, + "_src": "scripts_train_py", + "_tgt": "src_training_callbacks_py", + "source": "scripts_train_py", + "target": "src_training_callbacks_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.6, + "_src": "scripts_train_py", + "_tgt": "src_style_fingerprinter_py", + "source": "scripts_train_py", + "target": "src_style_fingerprinter_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.6, + "_src": "scripts_train_py", + "_tgt": "src_evaluation_gleu_scorer_py", + "source": "scripts_train_py", + "target": "src_evaluation_gleu_scorer_py" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 1.0, + "_src": "scripts_train_py", + "_tgt": "scripts_train_py__setup_device", + "source": "scripts_train_py", + "target": "scripts_train_py__setup_device" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 1.0, + "_src": "scripts_train_py", + "_tgt": "scripts_train_py__auto_batch_size", + "source": "scripts_train_py", + "target": "scripts_train_py__auto_batch_size" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 1.0, + "_src": "scripts_train_py", + "_tgt": "scripts_train_py_train", + "source": "scripts_train_py", + "target": "scripts_train_py_train" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 1.0, + "_src": "scripts_train_py", + "_tgt": "scripts_train_py_CEOnlyLoss", + "source": "scripts_train_py", + "target": "scripts_train_py_CEOnlyLoss" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 1.0, + "_src": "scripts_train_py", + "_tgt": "scripts_train_py___init__", + "source": "scripts_train_py", + "target": "scripts_train_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 1.0, + "_src": "scripts_train_py", + "_tgt": "scripts_train_py_forward", + "source": "scripts_train_py", + "target": "scripts_train_py_forward" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.5, + "_src": "scripts_train_py__setup_device", + "_tgt": "scripts_train_py__setup_device_doc", + "source": "scripts_train_py__setup_device", + "target": "scripts_train_py__setup_device_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "scripts_train_py__setup_device", + "source": "scripts_train_py__setup_device", + "target": "scripts_train_py_train" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.5, + "_src": "scripts_train_py__auto_batch_size", + "_tgt": "scripts_train_py__auto_batch_size_doc", + "source": "scripts_train_py__auto_batch_size", + "target": "scripts_train_py__auto_batch_size_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "scripts_train_py__auto_batch_size", + "source": "scripts_train_py__auto_batch_size", + "target": "scripts_train_py_train" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.5, + "_src": "scripts_train_py_train", + "_tgt": "scripts_train_py_train_doc", + "source": "scripts_train_py_train", + "target": "scripts_train_py_train_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_model_base_model_py_load_model_and_tokenizer", + "source": "scripts_train_py_train", + "target": "src_model_base_model_py_load_model_and_tokenizer" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "scripts_train_py_train", + "source": "scripts_train_py_train", + "target": "scripts_train_py_train" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "scripts_train_py___init__", + "source": "scripts_train_py_train", + "target": "scripts_train_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_api_middleware_py___init__", + "source": "scripts_train_py_train", + "target": "src_api_middleware_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_evaluation_authorship_verifier_py___init__", + "source": "scripts_train_py_train", + "target": "src_evaluation_authorship_verifier_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_evaluation_errant_evaluator_py___init__", + "source": "scripts_train_py_train", + "target": "src_evaluation_errant_evaluator_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_evaluation_style_metrics_py___init__", + "source": "scripts_train_py_train", + "target": "src_evaluation_style_metrics_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_inference_corrector_py___init__", + "source": "scripts_train_py_train", + "target": "src_inference_corrector_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_inference_postprocessor_py___init__", + "source": "scripts_train_py_train", + "target": "src_inference_postprocessor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_model_style_conditioner_py___init__", + "source": "scripts_train_py_train", + "target": "src_model_style_conditioner_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_preprocessing_dependency_parser_py___init__", + "source": "scripts_train_py_train", + "target": "src_preprocessing_dependency_parser_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_preprocessing_dyslexia_simulator_py___init__", + "source": "scripts_train_py_train", + "target": "src_preprocessing_dyslexia_simulator_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_preprocessing_ner_tagger_py___init__", + "source": "scripts_train_py_train", + "target": "src_preprocessing_ner_tagger_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_preprocessing_pipeline_py___init__", + "source": "scripts_train_py_train", + "target": "src_preprocessing_pipeline_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_preprocessing_sentence_segmenter_py___init__", + "source": "scripts_train_py_train", + "target": "src_preprocessing_sentence_segmenter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_preprocessing_spell_corrector_py___init__", + "source": "scripts_train_py_train", + "target": "src_preprocessing_spell_corrector_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_style_emotion_classifier_py___init__", + "source": "scripts_train_py_train", + "target": "src_style_emotion_classifier_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_style_fingerprinter_py___init__", + "source": "scripts_train_py_train", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_style_formality_classifier_py___init__", + "source": "scripts_train_py_train", + "target": "src_style_formality_classifier_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_training_callbacks_py___init__", + "source": "scripts_train_py_train", + "target": "src_training_callbacks_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_training_dataset_py___init__", + "source": "scripts_train_py_train", + "target": "src_training_dataset_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_training_human_pattern_extractor_py___init__", + "source": "scripts_train_py_train", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_training_loss_functions_py___init__", + "source": "scripts_train_py_train", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_training_trainer_py___init__", + "source": "scripts_train_py_train", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_vocabulary_awl_loader_py___init__", + "source": "scripts_train_py_train", + "target": "src_vocabulary_awl_loader_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_vocabulary_lexical_substitution_py___init__", + "source": "scripts_train_py_train", + "target": "src_vocabulary_lexical_substitution_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py_train", + "_tgt": "src_vocabulary_register_filter_py___init__", + "source": "scripts_train_py_train", + "target": "src_vocabulary_register_filter_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "scripts/train.py", + "weight": 0.5, + "_src": "scripts_train_py_CEOnlyLoss", + "_tgt": "scripts_train_py_CEOnlyLoss_doc", + "source": "scripts_train_py_CEOnlyLoss", + "target": "scripts_train_py_CEOnlyLoss_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "scripts_train_py___init__", + "source": "scripts_train_py___init__", + "target": "src_api_middleware_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_evaluation_authorship_verifier_py___init__", + "source": "scripts_train_py___init__", + "target": "src_evaluation_authorship_verifier_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_evaluation_errant_evaluator_py___init__", + "source": "scripts_train_py___init__", + "target": "src_evaluation_errant_evaluator_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_evaluation_style_metrics_py___init__", + "source": "scripts_train_py___init__", + "target": "src_evaluation_style_metrics_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_inference_corrector_py___init__", + "source": "scripts_train_py___init__", + "target": "src_inference_corrector_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_inference_postprocessor_py___init__", + "source": "scripts_train_py___init__", + "target": "src_inference_postprocessor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "scripts_train_py___init__", + "source": "scripts_train_py___init__", + "target": "src_model_style_conditioner_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_preprocessing_dependency_parser_py___init__", + "source": "scripts_train_py___init__", + "target": "src_preprocessing_dependency_parser_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_preprocessing_dyslexia_simulator_py___init__", + "source": "scripts_train_py___init__", + "target": "src_preprocessing_dyslexia_simulator_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_preprocessing_ner_tagger_py___init__", + "source": "scripts_train_py___init__", + "target": "src_preprocessing_ner_tagger_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_preprocessing_pipeline_py___init__", + "source": "scripts_train_py___init__", + "target": "src_preprocessing_pipeline_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_preprocessing_sentence_segmenter_py___init__", + "source": "scripts_train_py___init__", + "target": "src_preprocessing_sentence_segmenter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_preprocessing_spell_corrector_py___init__", + "source": "scripts_train_py___init__", + "target": "src_preprocessing_spell_corrector_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_style_emotion_classifier_py___init__", + "source": "scripts_train_py___init__", + "target": "src_style_emotion_classifier_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "scripts_train_py___init__", + "source": "scripts_train_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_style_formality_classifier_py___init__", + "source": "scripts_train_py___init__", + "target": "src_style_formality_classifier_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_training_callbacks_py___init__", + "source": "scripts_train_py___init__", + "target": "src_training_callbacks_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_training_dataset_py___init__", + "source": "scripts_train_py___init__", + "target": "src_training_dataset_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "scripts_train_py___init__", + "source": "scripts_train_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "scripts_train_py___init__", + "source": "scripts_train_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "scripts_train_py___init__", + "source": "scripts_train_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_vocabulary_awl_loader_py___init__", + "source": "scripts_train_py___init__", + "target": "src_vocabulary_awl_loader_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_vocabulary_lexical_substitution_py___init__", + "source": "scripts_train_py___init__", + "target": "src_vocabulary_lexical_substitution_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "scripts/train.py", + "weight": 0.8, + "_src": "scripts_train_py___init__", + "_tgt": "src_vocabulary_register_filter_py___init__", + "source": "scripts_train_py___init__", + "target": "src_vocabulary_register_filter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py_score", + "_tgt": "scripts_train_py_forward", + "source": "scripts_train_py_forward", + "target": "src_training_human_pattern_extractor_py_score" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/main.py", + "weight": 0.5, + "_src": "src_api_main_py", + "_tgt": "src_api_main_py_docstring", + "source": "src_api_main_py", + "target": "src_api_main_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/main.py", + "weight": 1.0, + "_src": "src_api_main_py", + "_tgt": "src_api_main_py_startup", + "source": "src_api_main_py", + "target": "src_api_main_py_startup" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/main.py", + "weight": 1.0, + "_src": "src_api_main_py", + "_tgt": "src_api_main_py_correct_text", + "source": "src_api_main_py", + "target": "src_api_main_py_correct_text" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/main.py", + "weight": 1.0, + "_src": "src_api_main_py", + "_tgt": "src_api_main_py_health", + "source": "src_api_main_py", + "target": "src_api_main_py_health" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/main.py", + "weight": 0.5, + "_src": "src_api_main_py_startup", + "_tgt": "src_api_main_py_startup_doc", + "source": "src_api_main_py_startup", + "target": "src_api_main_py_startup_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/main.py", + "weight": 0.5, + "_src": "src_api_main_py_correct_text", + "_tgt": "src_api_main_py_correct_text_doc", + "source": "src_api_main_py_correct_text", + "target": "src_api_main_py_correct_text_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/main.py", + "weight": 0.8, + "_src": "src_api_main_py_correct_text", + "_tgt": "src_inference_corrector_py_correct", + "source": "src_api_main_py_correct_text", + "target": "src_inference_corrector_py_correct" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/main.py", + "weight": 0.8, + "_src": "src_api_main_py_correct_text", + "_tgt": "src_preprocessing_spell_corrector_py_correct", + "source": "src_api_main_py_correct_text", + "target": "src_preprocessing_spell_corrector_py_correct" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/main.py", + "weight": 0.5, + "_src": "src_api_main_py_health", + "_tgt": "src_api_main_py_health_doc", + "source": "src_api_main_py_health", + "target": "src_api_main_py_health_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/middleware.py", + "weight": 0.5, + "_src": "src_api_middleware_py", + "_tgt": "src_api_middleware_py_docstring", + "source": "src_api_middleware_py", + "target": "src_api_middleware_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/middleware.py", + "weight": 1.0, + "_src": "src_api_middleware_py", + "_tgt": "src_api_middleware_py_RequestLoggingMiddleware", + "source": "src_api_middleware_py", + "target": "src_api_middleware_py_RequestLoggingMiddleware" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/middleware.py", + "weight": 1.0, + "_src": "src_api_middleware_py", + "_tgt": "src_api_middleware_py_RateLimitMiddleware", + "source": "src_api_middleware_py", + "target": "src_api_middleware_py_RateLimitMiddleware" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/middleware.py", + "weight": 1.0, + "_src": "src_api_middleware_py", + "_tgt": "src_api_middleware_py_dispatch", + "source": "src_api_middleware_py", + "target": "src_api_middleware_py_dispatch" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/middleware.py", + "weight": 1.0, + "_src": "src_api_middleware_py", + "_tgt": "src_api_middleware_py___init__", + "source": "src_api_middleware_py", + "target": "src_api_middleware_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/middleware.py", + "weight": 0.5, + "_src": "src_api_middleware_py_RequestLoggingMiddleware", + "_tgt": "src_api_middleware_py_RequestLoggingMiddleware_doc", + "source": "src_api_middleware_py_RequestLoggingMiddleware", + "target": "src_api_middleware_py_RequestLoggingMiddleware_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/middleware.py", + "weight": 0.5, + "_src": "src_api_middleware_py_RateLimitMiddleware", + "_tgt": "src_api_middleware_py_RateLimitMiddleware_doc", + "source": "src_api_middleware_py_RateLimitMiddleware", + "target": "src_api_middleware_py_RateLimitMiddleware_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_evaluation_authorship_verifier_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_evaluation_authorship_verifier_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_evaluation_errant_evaluator_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_evaluation_errant_evaluator_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_evaluation_style_metrics_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_evaluation_style_metrics_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_inference_corrector_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_inference_corrector_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_inference_postprocessor_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_inference_postprocessor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_api_middleware_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_model_style_conditioner_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_preprocessing_dependency_parser_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_preprocessing_dependency_parser_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_preprocessing_dyslexia_simulator_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_preprocessing_dyslexia_simulator_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_preprocessing_ner_tagger_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_preprocessing_ner_tagger_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_preprocessing_pipeline_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_preprocessing_pipeline_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_preprocessing_sentence_segmenter_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_preprocessing_sentence_segmenter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_preprocessing_spell_corrector_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_preprocessing_spell_corrector_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_style_emotion_classifier_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_style_emotion_classifier_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_api_middleware_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_style_formality_classifier_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_style_formality_classifier_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_training_callbacks_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_training_callbacks_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_training_dataset_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_training_dataset_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_api_middleware_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_api_middleware_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_api_middleware_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_vocabulary_awl_loader_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_vocabulary_awl_loader_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_vocabulary_lexical_substitution_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_vocabulary_lexical_substitution_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/api/middleware.py", + "weight": 0.8, + "_src": "src_api_middleware_py___init__", + "_tgt": "src_vocabulary_register_filter_py___init__", + "source": "src_api_middleware_py___init__", + "target": "src_vocabulary_register_filter_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/schemas.py", + "weight": 0.5, + "_src": "src_api_schemas_py", + "_tgt": "src_api_schemas_py_docstring", + "source": "src_api_schemas_py", + "target": "src_api_schemas_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/schemas.py", + "weight": 1.0, + "_src": "src_api_schemas_py", + "_tgt": "src_api_schemas_py_CorrectionRequest", + "source": "src_api_schemas_py", + "target": "src_api_schemas_py_CorrectionRequest" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/api/schemas.py", + "weight": 1.0, + "_src": "src_api_schemas_py", + "_tgt": "src_api_schemas_py_CorrectionResponse", + "source": "src_api_schemas_py", + "target": "src_api_schemas_py_CorrectionResponse" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/authorship_verifier.py", + "weight": 0.5, + "_src": "src_evaluation_authorship_verifier_py", + "_tgt": "src_evaluation_authorship_verifier_py_docstring", + "source": "src_evaluation_authorship_verifier_py", + "target": "src_evaluation_authorship_verifier_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/authorship_verifier.py", + "weight": 1.0, + "_src": "src_evaluation_authorship_verifier_py", + "_tgt": "src_evaluation_authorship_verifier_py_AuthorshipVerifier", + "source": "src_evaluation_authorship_verifier_py", + "target": "src_evaluation_authorship_verifier_py_AuthorshipVerifier" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/authorship_verifier.py", + "weight": 1.0, + "_src": "src_evaluation_authorship_verifier_py", + "_tgt": "src_evaluation_authorship_verifier_py___init__", + "source": "src_evaluation_authorship_verifier_py", + "target": "src_evaluation_authorship_verifier_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/authorship_verifier.py", + "weight": 1.0, + "_src": "src_evaluation_authorship_verifier_py", + "_tgt": "src_evaluation_authorship_verifier_py_verify", + "source": "src_evaluation_authorship_verifier_py", + "target": "src_evaluation_authorship_verifier_py_verify" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/authorship_verifier.py", + "weight": 0.5, + "_src": "src_evaluation_authorship_verifier_py_AuthorshipVerifier", + "_tgt": "src_evaluation_authorship_verifier_py_AuthorshipVerifier_doc", + "source": "src_evaluation_authorship_verifier_py_AuthorshipVerifier", + "target": "src_evaluation_authorship_verifier_py_AuthorshipVerifier_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_evaluation_authorship_verifier_py___init__", + "source": "src_evaluation_authorship_verifier_py___init__", + "target": "src_model_style_conditioner_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_evaluation_authorship_verifier_py___init__", + "source": "src_evaluation_authorship_verifier_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_evaluation_authorship_verifier_py___init__", + "source": "src_evaluation_authorship_verifier_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_evaluation_authorship_verifier_py___init__", + "source": "src_evaluation_authorship_verifier_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_evaluation_authorship_verifier_py___init__", + "source": "src_evaluation_authorship_verifier_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/authorship_verifier.py", + "weight": 0.5, + "_src": "src_evaluation_authorship_verifier_py_verify", + "_tgt": "src_evaluation_authorship_verifier_py_verify_doc", + "source": "src_evaluation_authorship_verifier_py_verify", + "target": "src_evaluation_authorship_verifier_py_verify_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/evaluation/authorship_verifier.py", + "weight": 0.8, + "_src": "src_evaluation_authorship_verifier_py_verify", + "_tgt": "src_style_style_vector_py_cosine_similarity", + "source": "src_evaluation_authorship_verifier_py_verify", + "target": "src_style_style_vector_py_cosine_similarity" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/errant_evaluator.py", + "weight": 0.5, + "_src": "src_evaluation_errant_evaluator_py", + "_tgt": "src_evaluation_errant_evaluator_py_docstring", + "source": "src_evaluation_errant_evaluator_py", + "target": "src_evaluation_errant_evaluator_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/errant_evaluator.py", + "weight": 1.0, + "_src": "src_evaluation_errant_evaluator_py", + "_tgt": "src_evaluation_errant_evaluator_py_ERRANTEvaluator", + "source": "src_evaluation_errant_evaluator_py", + "target": "src_evaluation_errant_evaluator_py_ERRANTEvaluator" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/errant_evaluator.py", + "weight": 1.0, + "_src": "src_evaluation_errant_evaluator_py", + "_tgt": "src_evaluation_errant_evaluator_py___init__", + "source": "src_evaluation_errant_evaluator_py", + "target": "src_evaluation_errant_evaluator_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/errant_evaluator.py", + "weight": 1.0, + "_src": "src_evaluation_errant_evaluator_py", + "_tgt": "src_evaluation_errant_evaluator_py_evaluate", + "source": "src_evaluation_errant_evaluator_py", + "target": "src_evaluation_errant_evaluator_py_evaluate" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/errant_evaluator.py", + "weight": 0.5, + "_src": "src_evaluation_errant_evaluator_py_ERRANTEvaluator", + "_tgt": "src_evaluation_errant_evaluator_py_ERRANTEvaluator_doc", + "source": "src_evaluation_errant_evaluator_py_ERRANTEvaluator", + "target": "src_evaluation_errant_evaluator_py_ERRANTEvaluator_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_evaluation_errant_evaluator_py___init__", + "source": "src_evaluation_errant_evaluator_py___init__", + "target": "src_model_style_conditioner_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_evaluation_errant_evaluator_py___init__", + "source": "src_evaluation_errant_evaluator_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_evaluation_errant_evaluator_py___init__", + "source": "src_evaluation_errant_evaluator_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_evaluation_errant_evaluator_py___init__", + "source": "src_evaluation_errant_evaluator_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_evaluation_errant_evaluator_py___init__", + "source": "src_evaluation_errant_evaluator_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/errant_evaluator.py", + "weight": 0.5, + "_src": "src_evaluation_errant_evaluator_py_evaluate", + "_tgt": "src_evaluation_errant_evaluator_py_evaluate_doc", + "source": "src_evaluation_errant_evaluator_py_evaluate", + "target": "src_evaluation_errant_evaluator_py_evaluate_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/evaluation/errant_evaluator.py", + "weight": 0.8, + "_src": "src_evaluation_errant_evaluator_py_evaluate", + "_tgt": "src_preprocessing_dependency_parser_py_parse", + "source": "src_evaluation_errant_evaluator_py_evaluate", + "target": "src_preprocessing_dependency_parser_py_parse" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/gleu_scorer.py", + "weight": 0.5, + "_src": "src_evaluation_gleu_scorer_py", + "_tgt": "src_evaluation_gleu_scorer_py_docstring", + "source": "src_evaluation_gleu_scorer_py", + "target": "src_evaluation_gleu_scorer_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/gleu_scorer.py", + "weight": 1.0, + "_src": "src_evaluation_gleu_scorer_py", + "_tgt": "src_evaluation_gleu_scorer_py_GLEUScorer", + "source": "src_evaluation_gleu_scorer_py", + "target": "src_evaluation_gleu_scorer_py_GLEUScorer" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/gleu_scorer.py", + "weight": 1.0, + "_src": "src_evaluation_gleu_scorer_py", + "_tgt": "src_evaluation_gleu_scorer_py_compute_gleu", + "source": "src_evaluation_gleu_scorer_py", + "target": "src_evaluation_gleu_scorer_py_compute_gleu" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/gleu_scorer.py", + "weight": 1.0, + "_src": "src_evaluation_gleu_scorer_py", + "_tgt": "src_evaluation_gleu_scorer_py_compute_bert_score", + "source": "src_evaluation_gleu_scorer_py", + "target": "src_evaluation_gleu_scorer_py_compute_bert_score" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 0.6, + "_src": "tests_test_evaluation_py", + "_tgt": "src_evaluation_gleu_scorer_py", + "source": "src_evaluation_gleu_scorer_py", + "target": "tests_test_evaluation_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/gleu_scorer.py", + "weight": 0.5, + "_src": "src_evaluation_gleu_scorer_py_GLEUScorer", + "_tgt": "src_evaluation_gleu_scorer_py_GLEUScorer_doc", + "source": "src_evaluation_gleu_scorer_py_GLEUScorer", + "target": "src_evaluation_gleu_scorer_py_GLEUScorer_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/gleu_scorer.py", + "weight": 0.5, + "_src": "src_evaluation_gleu_scorer_py_compute_gleu", + "_tgt": "src_evaluation_gleu_scorer_py_compute_gleu_doc", + "source": "src_evaluation_gleu_scorer_py_compute_gleu", + "target": "src_evaluation_gleu_scorer_py_compute_gleu_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_evaluation.py", + "weight": 0.8, + "_src": "tests_test_evaluation_py_test_gleu_perfect_score", + "_tgt": "src_evaluation_gleu_scorer_py_compute_gleu", + "source": "src_evaluation_gleu_scorer_py_compute_gleu", + "target": "tests_test_evaluation_py_test_gleu_perfect_score" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_evaluation.py", + "weight": 0.8, + "_src": "tests_test_evaluation_py_test_gleu_empty_input", + "_tgt": "src_evaluation_gleu_scorer_py_compute_gleu", + "source": "src_evaluation_gleu_scorer_py_compute_gleu", + "target": "tests_test_evaluation_py_test_gleu_empty_input" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/gleu_scorer.py", + "weight": 0.5, + "_src": "src_evaluation_gleu_scorer_py_compute_bert_score", + "_tgt": "src_evaluation_gleu_scorer_py_compute_bert_score_doc", + "source": "src_evaluation_gleu_scorer_py_compute_bert_score", + "target": "src_evaluation_gleu_scorer_py_compute_bert_score_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/style_metrics.py", + "weight": 0.5, + "_src": "src_evaluation_style_metrics_py", + "_tgt": "src_evaluation_style_metrics_py_docstring", + "source": "src_evaluation_style_metrics_py", + "target": "src_evaluation_style_metrics_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/style_metrics.py", + "weight": 1.0, + "_src": "src_evaluation_style_metrics_py", + "_tgt": "src_evaluation_style_metrics_py_StyleEvaluator", + "source": "src_evaluation_style_metrics_py", + "target": "src_evaluation_style_metrics_py_StyleEvaluator" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/style_metrics.py", + "weight": 1.0, + "_src": "src_evaluation_style_metrics_py", + "_tgt": "src_evaluation_style_metrics_py___init__", + "source": "src_evaluation_style_metrics_py", + "target": "src_evaluation_style_metrics_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/style_metrics.py", + "weight": 1.0, + "_src": "src_evaluation_style_metrics_py", + "_tgt": "src_evaluation_style_metrics_py_style_similarity", + "source": "src_evaluation_style_metrics_py", + "target": "src_evaluation_style_metrics_py_style_similarity" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/style_metrics.py", + "weight": 1.0, + "_src": "src_evaluation_style_metrics_py", + "_tgt": "src_evaluation_style_metrics_py_awl_coverage", + "source": "src_evaluation_style_metrics_py", + "target": "src_evaluation_style_metrics_py_awl_coverage" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/style_metrics.py", + "weight": 1.0, + "_src": "src_evaluation_style_metrics_py", + "_tgt": "src_evaluation_style_metrics_py_evaluate_batch", + "source": "src_evaluation_style_metrics_py", + "target": "src_evaluation_style_metrics_py_evaluate_batch" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 0.6, + "_src": "tests_test_evaluation_py", + "_tgt": "src_evaluation_style_metrics_py", + "source": "src_evaluation_style_metrics_py", + "target": "tests_test_evaluation_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/style_metrics.py", + "weight": 0.5, + "_src": "src_evaluation_style_metrics_py_StyleEvaluator", + "_tgt": "src_evaluation_style_metrics_py_StyleEvaluator_doc", + "source": "src_evaluation_style_metrics_py_StyleEvaluator", + "target": "src_evaluation_style_metrics_py_StyleEvaluator_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_evaluation_style_metrics_py___init__", + "source": "src_evaluation_style_metrics_py___init__", + "target": "src_model_style_conditioner_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_evaluation_style_metrics_py___init__", + "source": "src_evaluation_style_metrics_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_evaluation_style_metrics_py___init__", + "source": "src_evaluation_style_metrics_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_evaluation_style_metrics_py___init__", + "source": "src_evaluation_style_metrics_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_evaluation_style_metrics_py___init__", + "source": "src_evaluation_style_metrics_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/style_metrics.py", + "weight": 0.5, + "_src": "src_evaluation_style_metrics_py_style_similarity", + "_tgt": "src_evaluation_style_metrics_py_style_similarity_doc", + "source": "src_evaluation_style_metrics_py_style_similarity", + "target": "src_evaluation_style_metrics_py_style_similarity_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/evaluation/style_metrics.py", + "weight": 0.8, + "_src": "src_evaluation_style_metrics_py_style_similarity", + "_tgt": "src_style_fingerprinter_py_extract_vector", + "source": "src_evaluation_style_metrics_py_style_similarity", + "target": "src_style_fingerprinter_py_extract_vector" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/evaluation/style_metrics.py", + "weight": 0.8, + "_src": "src_evaluation_style_metrics_py_style_similarity", + "_tgt": "src_style_style_vector_py_cosine_similarity", + "source": "src_evaluation_style_metrics_py_style_similarity", + "target": "src_style_style_vector_py_cosine_similarity" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/evaluation/style_metrics.py", + "weight": 0.8, + "_src": "src_evaluation_style_metrics_py_evaluate_batch", + "_tgt": "src_evaluation_style_metrics_py_style_similarity", + "source": "src_evaluation_style_metrics_py_style_similarity", + "target": "src_evaluation_style_metrics_py_evaluate_batch" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/inference/corrector.py", + "weight": 0.8, + "_src": "src_inference_corrector_py_correct", + "_tgt": "src_evaluation_style_metrics_py_style_similarity", + "source": "src_evaluation_style_metrics_py_style_similarity", + "target": "src_inference_corrector_py_correct" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/style_metrics.py", + "weight": 0.5, + "_src": "src_evaluation_style_metrics_py_awl_coverage", + "_tgt": "src_evaluation_style_metrics_py_awl_coverage_doc", + "source": "src_evaluation_style_metrics_py_awl_coverage", + "target": "src_evaluation_style_metrics_py_awl_coverage_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/evaluation/style_metrics.py", + "weight": 0.8, + "_src": "src_evaluation_style_metrics_py_awl_coverage", + "_tgt": "src_vocabulary_awl_loader_py_is_academic", + "source": "src_evaluation_style_metrics_py_awl_coverage", + "target": "src_vocabulary_awl_loader_py_is_academic" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/evaluation/style_metrics.py", + "weight": 0.8, + "_src": "src_evaluation_style_metrics_py_evaluate_batch", + "_tgt": "src_evaluation_style_metrics_py_awl_coverage", + "source": "src_evaluation_style_metrics_py_awl_coverage", + "target": "src_evaluation_style_metrics_py_evaluate_batch" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/inference/corrector.py", + "weight": 0.8, + "_src": "src_inference_corrector_py_correct", + "_tgt": "src_evaluation_style_metrics_py_awl_coverage", + "source": "src_evaluation_style_metrics_py_awl_coverage", + "target": "src_inference_corrector_py_correct" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_evaluation.py", + "weight": 0.8, + "_src": "tests_test_evaluation_py_test_awl_coverage_score", + "_tgt": "src_evaluation_style_metrics_py_awl_coverage", + "source": "src_evaluation_style_metrics_py_awl_coverage", + "target": "tests_test_evaluation_py_test_awl_coverage_score" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/evaluation/style_metrics.py", + "weight": 0.5, + "_src": "src_evaluation_style_metrics_py_evaluate_batch", + "_tgt": "src_evaluation_style_metrics_py_evaluate_batch_doc", + "source": "src_evaluation_style_metrics_py_evaluate_batch", + "target": "src_evaluation_style_metrics_py_evaluate_batch_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/corrector.py", + "weight": 0.5, + "_src": "src_inference_corrector_py", + "_tgt": "src_inference_corrector_py_docstring", + "source": "src_inference_corrector_py", + "target": "src_inference_corrector_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/corrector.py", + "weight": 1.0, + "_src": "src_inference_corrector_py", + "_tgt": "src_inference_corrector_py_CorrectionResult", + "source": "src_inference_corrector_py", + "target": "src_inference_corrector_py_CorrectionResult" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/corrector.py", + "weight": 1.0, + "_src": "src_inference_corrector_py", + "_tgt": "src_inference_corrector_py_AcademicCorrector", + "source": "src_inference_corrector_py", + "target": "src_inference_corrector_py_AcademicCorrector" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/corrector.py", + "weight": 1.0, + "_src": "src_inference_corrector_py", + "_tgt": "src_inference_corrector_py___init__", + "source": "src_inference_corrector_py", + "target": "src_inference_corrector_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/corrector.py", + "weight": 1.0, + "_src": "src_inference_corrector_py", + "_tgt": "src_inference_corrector_py_correct", + "source": "src_inference_corrector_py", + "target": "src_inference_corrector_py_correct" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/corrector.py", + "weight": 0.5, + "_src": "src_inference_corrector_py_AcademicCorrector", + "_tgt": "src_inference_corrector_py_AcademicCorrector_doc", + "source": "src_inference_corrector_py_AcademicCorrector", + "target": "src_inference_corrector_py_AcademicCorrector_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/inference/corrector.py", + "weight": 0.8, + "_src": "src_inference_corrector_py___init__", + "_tgt": "src_model_base_model_py_load_model_and_tokenizer", + "source": "src_inference_corrector_py___init__", + "target": "src_model_base_model_py_load_model_and_tokenizer" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_inference_corrector_py___init__", + "source": "src_inference_corrector_py___init__", + "target": "src_model_style_conditioner_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_inference_corrector_py___init__", + "source": "src_inference_corrector_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_inference_corrector_py___init__", + "source": "src_inference_corrector_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_inference_corrector_py___init__", + "source": "src_inference_corrector_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_inference_corrector_py___init__", + "source": "src_inference_corrector_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/corrector.py", + "weight": 0.5, + "_src": "src_inference_corrector_py_correct", + "_tgt": "src_inference_corrector_py_correct_doc", + "source": "src_inference_corrector_py_correct", + "target": "src_inference_corrector_py_correct_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/preprocessing/pipeline.py", + "weight": 0.8, + "_src": "src_preprocessing_pipeline_py_process", + "_tgt": "src_inference_corrector_py_correct", + "source": "src_inference_corrector_py_correct", + "target": "src_preprocessing_pipeline_py_process" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/inference/corrector.py", + "weight": 0.8, + "_src": "src_inference_corrector_py_correct", + "_tgt": "src_style_fingerprinter_py_extract_vector", + "source": "src_inference_corrector_py_correct", + "target": "src_style_fingerprinter_py_extract_vector" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/inference/corrector.py", + "weight": 0.8, + "_src": "src_inference_corrector_py_correct", + "_tgt": "src_inference_postprocessor_py_clean", + "source": "src_inference_corrector_py_correct", + "target": "src_inference_postprocessor_py_clean" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/inference/corrector.py", + "weight": 0.8, + "_src": "src_inference_corrector_py_correct", + "_tgt": "src_inference_postprocessor_py_restore_entities", + "source": "src_inference_corrector_py_correct", + "target": "src_inference_postprocessor_py_restore_entities" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/inference/corrector.py", + "weight": 0.8, + "_src": "src_inference_corrector_py_correct", + "_tgt": "src_vocabulary_lexical_substitution_py_apply", + "source": "src_inference_corrector_py_correct", + "target": "src_vocabulary_lexical_substitution_py_apply" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/inference/corrector.py", + "weight": 0.8, + "_src": "src_inference_corrector_py_correct", + "_tgt": "src_inference_postprocessor_py_format_output", + "source": "src_inference_corrector_py_correct", + "target": "src_inference_postprocessor_py_format_output" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/inference/corrector.py", + "weight": 0.8, + "_src": "src_inference_corrector_py_correct", + "_tgt": "src_style_fingerprinter_py_blend_vectors", + "source": "src_inference_corrector_py_correct", + "target": "src_style_fingerprinter_py_blend_vectors" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/inference/corrector.py", + "weight": 0.8, + "_src": "src_inference_corrector_py_correct", + "_tgt": "src_model_generation_utils_py_generate_correction", + "source": "src_inference_corrector_py_correct", + "target": "src_model_generation_utils_py_generate_correction" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/inference/corrector.py", + "weight": 0.8, + "_src": "src_inference_corrector_py_correct", + "_tgt": "src_vocabulary_lexical_substitution_py_elevate", + "source": "src_inference_corrector_py_correct", + "target": "src_vocabulary_lexical_substitution_py_elevate" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "tests/test_preprocessing.py", + "weight": 0.8, + "_src": "tests_test_preprocessing_py_test_spell_correction_empty", + "_tgt": "src_inference_corrector_py_correct", + "source": "src_inference_corrector_py_correct", + "target": "tests_test_preprocessing_py_test_spell_correction_empty" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/postprocessor.py", + "weight": 0.5, + "_src": "src_inference_postprocessor_py", + "_tgt": "src_inference_postprocessor_py_docstring", + "source": "src_inference_postprocessor_py", + "target": "src_inference_postprocessor_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/postprocessor.py", + "weight": 1.0, + "_src": "src_inference_postprocessor_py", + "_tgt": "src_inference_postprocessor_py_PostProcessor", + "source": "src_inference_postprocessor_py", + "target": "src_inference_postprocessor_py_PostProcessor" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/postprocessor.py", + "weight": 1.0, + "_src": "src_inference_postprocessor_py", + "_tgt": "src_inference_postprocessor_py___init__", + "source": "src_inference_postprocessor_py", + "target": "src_inference_postprocessor_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/postprocessor.py", + "weight": 1.0, + "_src": "src_inference_postprocessor_py", + "_tgt": "src_inference_postprocessor_py_clean", + "source": "src_inference_postprocessor_py", + "target": "src_inference_postprocessor_py_clean" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/postprocessor.py", + "weight": 1.0, + "_src": "src_inference_postprocessor_py", + "_tgt": "src_inference_postprocessor_py_restore_entities", + "source": "src_inference_postprocessor_py", + "target": "src_inference_postprocessor_py_restore_entities" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/postprocessor.py", + "weight": 1.0, + "_src": "src_inference_postprocessor_py", + "_tgt": "src_inference_postprocessor_py_format_output", + "source": "src_inference_postprocessor_py", + "target": "src_inference_postprocessor_py_format_output" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/postprocessor.py", + "weight": 0.5, + "_src": "src_inference_postprocessor_py_PostProcessor", + "_tgt": "src_inference_postprocessor_py_PostProcessor_doc", + "source": "src_inference_postprocessor_py_PostProcessor", + "target": "src_inference_postprocessor_py_PostProcessor_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_inference_postprocessor_py___init__", + "source": "src_inference_postprocessor_py___init__", + "target": "src_model_style_conditioner_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_inference_postprocessor_py___init__", + "source": "src_inference_postprocessor_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_inference_postprocessor_py___init__", + "source": "src_inference_postprocessor_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_inference_postprocessor_py___init__", + "source": "src_inference_postprocessor_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_inference_postprocessor_py___init__", + "source": "src_inference_postprocessor_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/postprocessor.py", + "weight": 0.5, + "_src": "src_inference_postprocessor_py_clean", + "_tgt": "src_inference_postprocessor_py_clean_doc", + "source": "src_inference_postprocessor_py_clean", + "target": "src_inference_postprocessor_py_clean_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/postprocessor.py", + "weight": 0.5, + "_src": "src_inference_postprocessor_py_restore_entities", + "_tgt": "src_inference_postprocessor_py_restore_entities_doc", + "source": "src_inference_postprocessor_py_restore_entities", + "target": "src_inference_postprocessor_py_restore_entities_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/inference/postprocessor.py", + "weight": 0.5, + "_src": "src_inference_postprocessor_py_format_output", + "_tgt": "src_inference_postprocessor_py_format_output_doc", + "source": "src_inference_postprocessor_py_format_output", + "target": "src_inference_postprocessor_py_format_output_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/base_model.py", + "weight": 0.5, + "_src": "src_model_base_model_py", + "_tgt": "src_model_base_model_py_docstring", + "source": "src_model_base_model_py", + "target": "src_model_base_model_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/base_model.py", + "weight": 1.0, + "_src": "src_model_base_model_py", + "_tgt": "src_model_base_model_py_load_model_and_tokenizer", + "source": "src_model_base_model_py", + "target": "src_model_base_model_py_load_model_and_tokenizer" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 0.6, + "_src": "tests_test_model_py", + "_tgt": "src_model_base_model_py", + "source": "src_model_base_model_py", + "target": "tests_test_model_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/base_model.py", + "weight": 0.5, + "_src": "src_model_base_model_py_load_model_and_tokenizer", + "_tgt": "src_model_base_model_py_load_model_and_tokenizer_doc", + "source": "src_model_base_model_py_load_model_and_tokenizer", + "target": "src_model_base_model_py_load_model_and_tokenizer_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_model.py", + "weight": 0.8, + "_src": "tests_test_model_py_test_invalid_model_key", + "_tgt": "src_model_base_model_py_load_model_and_tokenizer", + "source": "src_model_base_model_py_load_model_and_tokenizer", + "target": "tests_test_model_py_test_invalid_model_key" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/generation_utils.py", + "weight": 0.5, + "_src": "src_model_generation_utils_py", + "_tgt": "src_model_generation_utils_py_docstring", + "source": "src_model_generation_utils_py", + "target": "src_model_generation_utils_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/generation_utils.py", + "weight": 1.0, + "_src": "src_model_generation_utils_py", + "_tgt": "src_model_generation_utils_py_generate_correction", + "source": "src_model_generation_utils_py", + "target": "src_model_generation_utils_py_generate_correction" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/generation_utils.py", + "weight": 1.0, + "_src": "src_model_generation_utils_py", + "_tgt": "src_model_generation_utils_py_batch_generate", + "source": "src_model_generation_utils_py", + "target": "src_model_generation_utils_py_batch_generate" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/generation_utils.py", + "weight": 0.5, + "_src": "src_model_generation_utils_py_generate_correction", + "_tgt": "src_model_generation_utils_py_generate_correction_doc", + "source": "src_model_generation_utils_py_generate_correction", + "target": "src_model_generation_utils_py_generate_correction_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/generation_utils.py", + "weight": 0.5, + "_src": "src_model_generation_utils_py_batch_generate", + "_tgt": "src_model_generation_utils_py_batch_generate_doc", + "source": "src_model_generation_utils_py_batch_generate", + "target": "src_model_generation_utils_py_batch_generate_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/lora_adapter.py", + "weight": 0.5, + "_src": "src_model_lora_adapter_py", + "_tgt": "src_model_lora_adapter_py_docstring", + "source": "src_model_lora_adapter_py", + "target": "src_model_lora_adapter_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/lora_adapter.py", + "weight": 1.0, + "_src": "src_model_lora_adapter_py", + "_tgt": "src_model_lora_adapter_py_create_lora_config", + "source": "src_model_lora_adapter_py", + "target": "src_model_lora_adapter_py_create_lora_config" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/lora_adapter.py", + "weight": 1.0, + "_src": "src_model_lora_adapter_py", + "_tgt": "src_model_lora_adapter_py_apply_lora", + "source": "src_model_lora_adapter_py", + "target": "src_model_lora_adapter_py_apply_lora" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/lora_adapter.py", + "weight": 1.0, + "_src": "src_model_lora_adapter_py", + "_tgt": "src_model_lora_adapter_py_merge_lora_weights", + "source": "src_model_lora_adapter_py", + "target": "src_model_lora_adapter_py_merge_lora_weights" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 0.6, + "_src": "tests_test_model_py", + "_tgt": "src_model_lora_adapter_py", + "source": "src_model_lora_adapter_py", + "target": "tests_test_model_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/lora_adapter.py", + "weight": 0.5, + "_src": "src_model_lora_adapter_py_create_lora_config", + "_tgt": "src_model_lora_adapter_py_create_lora_config_doc", + "source": "src_model_lora_adapter_py_create_lora_config", + "target": "src_model_lora_adapter_py_create_lora_config_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_model.py", + "weight": 0.8, + "_src": "tests_test_model_py_test_lora_config_creation", + "_tgt": "src_model_lora_adapter_py_create_lora_config", + "source": "src_model_lora_adapter_py_create_lora_config", + "target": "tests_test_model_py_test_lora_config_creation" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/lora_adapter.py", + "weight": 0.5, + "_src": "src_model_lora_adapter_py_apply_lora", + "_tgt": "src_model_lora_adapter_py_apply_lora_doc", + "source": "src_model_lora_adapter_py_apply_lora", + "target": "src_model_lora_adapter_py_apply_lora_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/lora_adapter.py", + "weight": 0.5, + "_src": "src_model_lora_adapter_py_merge_lora_weights", + "_tgt": "src_model_lora_adapter_py_merge_lora_weights_doc", + "source": "src_model_lora_adapter_py_merge_lora_weights", + "target": "src_model_lora_adapter_py_merge_lora_weights_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/style_conditioner.py", + "weight": 0.5, + "_src": "src_model_style_conditioner_py", + "_tgt": "src_model_style_conditioner_py_docstring", + "source": "src_model_style_conditioner_py", + "target": "src_model_style_conditioner_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/style_conditioner.py", + "weight": 1.0, + "_src": "src_model_style_conditioner_py", + "_tgt": "src_model_style_conditioner_py_StyleConditioner", + "source": "src_model_style_conditioner_py", + "target": "src_model_style_conditioner_py_StyleConditioner" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/style_conditioner.py", + "weight": 1.0, + "_src": "src_model_style_conditioner_py", + "_tgt": "src_model_style_conditioner_py_prepend_style_prefix", + "source": "src_model_style_conditioner_py", + "target": "src_model_style_conditioner_py_prepend_style_prefix" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/style_conditioner.py", + "weight": 1.0, + "_src": "src_model_style_conditioner_py", + "_tgt": "src_model_style_conditioner_py___init__", + "source": "src_model_style_conditioner_py", + "target": "src_model_style_conditioner_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/style_conditioner.py", + "weight": 1.0, + "_src": "src_model_style_conditioner_py", + "_tgt": "src_model_style_conditioner_py_forward", + "source": "src_model_style_conditioner_py", + "target": "src_model_style_conditioner_py_forward" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 0.6, + "_src": "tests_test_model_py", + "_tgt": "src_model_style_conditioner_py", + "source": "src_model_style_conditioner_py", + "target": "tests_test_model_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/style_conditioner.py", + "weight": 0.5, + "_src": "src_model_style_conditioner_py_StyleConditioner", + "_tgt": "src_model_style_conditioner_py_StyleConditioner_doc", + "source": "src_model_style_conditioner_py_StyleConditioner", + "target": "src_model_style_conditioner_py_StyleConditioner_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/style_conditioner.py", + "weight": 0.5, + "_src": "src_model_style_conditioner_py_prepend_style_prefix", + "_tgt": "src_model_style_conditioner_py_prepend_style_prefix_doc", + "source": "src_model_style_conditioner_py_prepend_style_prefix", + "target": "src_model_style_conditioner_py_prepend_style_prefix_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_model.py", + "weight": 0.8, + "_src": "tests_test_model_py_test_prepend_style_prefix", + "_tgt": "src_model_style_conditioner_py_prepend_style_prefix", + "source": "src_model_style_conditioner_py_prepend_style_prefix", + "target": "tests_test_model_py_test_prepend_style_prefix" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_preprocessing_dependency_parser_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_preprocessing_dependency_parser_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_preprocessing_dyslexia_simulator_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_preprocessing_dyslexia_simulator_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_preprocessing_ner_tagger_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_preprocessing_ner_tagger_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_preprocessing_pipeline_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_preprocessing_pipeline_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_preprocessing_sentence_segmenter_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_preprocessing_sentence_segmenter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_preprocessing_spell_corrector_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_preprocessing_spell_corrector_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_style_emotion_classifier_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_style_emotion_classifier_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_model_style_conditioner_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_style_formality_classifier_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_style_formality_classifier_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_training_callbacks_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_training_callbacks_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_training_dataset_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_training_dataset_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_model_style_conditioner_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_model_style_conditioner_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_model_style_conditioner_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_vocabulary_awl_loader_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_vocabulary_awl_loader_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_vocabulary_lexical_substitution_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_vocabulary_lexical_substitution_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/model/style_conditioner.py", + "weight": 0.8, + "_src": "src_model_style_conditioner_py___init__", + "_tgt": "src_vocabulary_register_filter_py___init__", + "source": "src_model_style_conditioner_py___init__", + "target": "src_vocabulary_register_filter_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/model/style_conditioner.py", + "weight": 0.5, + "_src": "src_model_style_conditioner_py_forward", + "_tgt": "src_model_style_conditioner_py_forward_doc", + "source": "src_model_style_conditioner_py_forward", + "target": "src_model_style_conditioner_py_forward_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py_score", + "_tgt": "src_model_style_conditioner_py_forward", + "source": "src_model_style_conditioner_py_forward", + "target": "src_training_human_pattern_extractor_py_score" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dependency_parser.py", + "weight": 0.5, + "_src": "src_preprocessing_dependency_parser_py", + "_tgt": "src_preprocessing_dependency_parser_py_docstring", + "source": "src_preprocessing_dependency_parser_py", + "target": "src_preprocessing_dependency_parser_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dependency_parser.py", + "weight": 1.0, + "_src": "src_preprocessing_dependency_parser_py", + "_tgt": "src_preprocessing_dependency_parser_py_DependencyParser", + "source": "src_preprocessing_dependency_parser_py", + "target": "src_preprocessing_dependency_parser_py_DependencyParser" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dependency_parser.py", + "weight": 1.0, + "_src": "src_preprocessing_dependency_parser_py", + "_tgt": "src_preprocessing_dependency_parser_py___init__", + "source": "src_preprocessing_dependency_parser_py", + "target": "src_preprocessing_dependency_parser_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dependency_parser.py", + "weight": 1.0, + "_src": "src_preprocessing_dependency_parser_py", + "_tgt": "src_preprocessing_dependency_parser_py_parse", + "source": "src_preprocessing_dependency_parser_py", + "target": "src_preprocessing_dependency_parser_py_parse" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dependency_parser.py", + "weight": 1.0, + "_src": "src_preprocessing_dependency_parser_py", + "_tgt": "src_preprocessing_dependency_parser_py_extract_svo", + "source": "src_preprocessing_dependency_parser_py", + "target": "src_preprocessing_dependency_parser_py_extract_svo" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.6, + "_src": "tests_test_preprocessing_py", + "_tgt": "src_preprocessing_dependency_parser_py", + "source": "src_preprocessing_dependency_parser_py", + "target": "tests_test_preprocessing_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dependency_parser.py", + "weight": 0.5, + "_src": "src_preprocessing_dependency_parser_py_DependencyParser", + "_tgt": "src_preprocessing_dependency_parser_py_DependencyParser_doc", + "source": "src_preprocessing_dependency_parser_py_DependencyParser", + "target": "src_preprocessing_dependency_parser_py_DependencyParser_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_preprocessing_dependency_parser_py___init__", + "source": "src_preprocessing_dependency_parser_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_preprocessing_dependency_parser_py___init__", + "source": "src_preprocessing_dependency_parser_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_preprocessing_dependency_parser_py___init__", + "source": "src_preprocessing_dependency_parser_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_preprocessing_dependency_parser_py___init__", + "source": "src_preprocessing_dependency_parser_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dependency_parser.py", + "weight": 0.5, + "_src": "src_preprocessing_dependency_parser_py_parse", + "_tgt": "src_preprocessing_dependency_parser_py_parse_doc", + "source": "src_preprocessing_dependency_parser_py_parse", + "target": "src_preprocessing_dependency_parser_py_parse_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dependency_parser.py", + "weight": 0.5, + "_src": "src_preprocessing_dependency_parser_py_extract_svo", + "_tgt": "src_preprocessing_dependency_parser_py_extract_svo_doc", + "source": "src_preprocessing_dependency_parser_py_extract_svo", + "target": "src_preprocessing_dependency_parser_py_extract_svo_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_preprocessing.py", + "weight": 0.8, + "_src": "tests_test_preprocessing_py_test_dependency_trees", + "_tgt": "src_preprocessing_dependency_parser_py_extract_svo", + "source": "src_preprocessing_dependency_parser_py_extract_svo", + "target": "tests_test_preprocessing_py_test_dependency_trees" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.5, + "_src": "src_preprocessing_dyslexia_simulator_py", + "_tgt": "src_preprocessing_dyslexia_simulator_py_docstring", + "source": "src_preprocessing_dyslexia_simulator_py", + "target": "src_preprocessing_dyslexia_simulator_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 1.0, + "_src": "src_preprocessing_dyslexia_simulator_py", + "_tgt": "src_preprocessing_dyslexia_simulator_py_DyslexiaSimulator", + "source": "src_preprocessing_dyslexia_simulator_py", + "target": "src_preprocessing_dyslexia_simulator_py_DyslexiaSimulator" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 1.0, + "_src": "src_preprocessing_dyslexia_simulator_py", + "_tgt": "src_preprocessing_dyslexia_simulator_py___init__", + "source": "src_preprocessing_dyslexia_simulator_py", + "target": "src_preprocessing_dyslexia_simulator_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 1.0, + "_src": "src_preprocessing_dyslexia_simulator_py", + "_tgt": "src_preprocessing_dyslexia_simulator_py__transpose_letters", + "source": "src_preprocessing_dyslexia_simulator_py", + "target": "src_preprocessing_dyslexia_simulator_py__transpose_letters" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 1.0, + "_src": "src_preprocessing_dyslexia_simulator_py", + "_tgt": "src_preprocessing_dyslexia_simulator_py__omit_letter", + "source": "src_preprocessing_dyslexia_simulator_py", + "target": "src_preprocessing_dyslexia_simulator_py__omit_letter" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 1.0, + "_src": "src_preprocessing_dyslexia_simulator_py", + "_tgt": "src_preprocessing_dyslexia_simulator_py__double_letter", + "source": "src_preprocessing_dyslexia_simulator_py", + "target": "src_preprocessing_dyslexia_simulator_py__double_letter" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 1.0, + "_src": "src_preprocessing_dyslexia_simulator_py", + "_tgt": "src_preprocessing_dyslexia_simulator_py__reverse_letter", + "source": "src_preprocessing_dyslexia_simulator_py", + "target": "src_preprocessing_dyslexia_simulator_py__reverse_letter" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 1.0, + "_src": "src_preprocessing_dyslexia_simulator_py", + "_tgt": "src_preprocessing_dyslexia_simulator_py_corrupt_word", + "source": "src_preprocessing_dyslexia_simulator_py", + "target": "src_preprocessing_dyslexia_simulator_py_corrupt_word" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 1.0, + "_src": "src_preprocessing_dyslexia_simulator_py", + "_tgt": "src_preprocessing_dyslexia_simulator_py_simulate", + "source": "src_preprocessing_dyslexia_simulator_py", + "target": "src_preprocessing_dyslexia_simulator_py_simulate" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.6, + "_src": "tests_test_preprocessing_py", + "_tgt": "src_preprocessing_dyslexia_simulator_py", + "source": "src_preprocessing_dyslexia_simulator_py", + "target": "tests_test_preprocessing_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.5, + "_src": "src_preprocessing_dyslexia_simulator_py_DyslexiaSimulator", + "_tgt": "src_preprocessing_dyslexia_simulator_py_DyslexiaSimulator_doc", + "source": "src_preprocessing_dyslexia_simulator_py_DyslexiaSimulator", + "target": "src_preprocessing_dyslexia_simulator_py_DyslexiaSimulator_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_preprocessing_dyslexia_simulator_py___init__", + "source": "src_preprocessing_dyslexia_simulator_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_preprocessing_dyslexia_simulator_py___init__", + "source": "src_preprocessing_dyslexia_simulator_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_preprocessing_dyslexia_simulator_py___init__", + "source": "src_preprocessing_dyslexia_simulator_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_preprocessing_dyslexia_simulator_py___init__", + "source": "src_preprocessing_dyslexia_simulator_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.5, + "_src": "src_preprocessing_dyslexia_simulator_py__transpose_letters", + "_tgt": "src_preprocessing_dyslexia_simulator_py__transpose_letters_doc", + "source": "src_preprocessing_dyslexia_simulator_py__transpose_letters", + "target": "src_preprocessing_dyslexia_simulator_py__transpose_letters_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.8, + "_src": "src_preprocessing_dyslexia_simulator_py_corrupt_word", + "_tgt": "src_preprocessing_dyslexia_simulator_py__transpose_letters", + "source": "src_preprocessing_dyslexia_simulator_py__transpose_letters", + "target": "src_preprocessing_dyslexia_simulator_py_corrupt_word" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.5, + "_src": "src_preprocessing_dyslexia_simulator_py__omit_letter", + "_tgt": "src_preprocessing_dyslexia_simulator_py__omit_letter_doc", + "source": "src_preprocessing_dyslexia_simulator_py__omit_letter", + "target": "src_preprocessing_dyslexia_simulator_py__omit_letter_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.8, + "_src": "src_preprocessing_dyslexia_simulator_py_corrupt_word", + "_tgt": "src_preprocessing_dyslexia_simulator_py__omit_letter", + "source": "src_preprocessing_dyslexia_simulator_py__omit_letter", + "target": "src_preprocessing_dyslexia_simulator_py_corrupt_word" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.5, + "_src": "src_preprocessing_dyslexia_simulator_py__double_letter", + "_tgt": "src_preprocessing_dyslexia_simulator_py__double_letter_doc", + "source": "src_preprocessing_dyslexia_simulator_py__double_letter", + "target": "src_preprocessing_dyslexia_simulator_py__double_letter_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.8, + "_src": "src_preprocessing_dyslexia_simulator_py_corrupt_word", + "_tgt": "src_preprocessing_dyslexia_simulator_py__double_letter", + "source": "src_preprocessing_dyslexia_simulator_py__double_letter", + "target": "src_preprocessing_dyslexia_simulator_py_corrupt_word" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.5, + "_src": "src_preprocessing_dyslexia_simulator_py__reverse_letter", + "_tgt": "src_preprocessing_dyslexia_simulator_py__reverse_letter_doc", + "source": "src_preprocessing_dyslexia_simulator_py__reverse_letter", + "target": "src_preprocessing_dyslexia_simulator_py__reverse_letter_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.8, + "_src": "src_preprocessing_dyslexia_simulator_py_corrupt_word", + "_tgt": "src_preprocessing_dyslexia_simulator_py__reverse_letter", + "source": "src_preprocessing_dyslexia_simulator_py__reverse_letter", + "target": "src_preprocessing_dyslexia_simulator_py_corrupt_word" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.5, + "_src": "src_preprocessing_dyslexia_simulator_py_corrupt_word", + "_tgt": "src_preprocessing_dyslexia_simulator_py_corrupt_word_doc", + "source": "src_preprocessing_dyslexia_simulator_py_corrupt_word", + "target": "src_preprocessing_dyslexia_simulator_py_corrupt_word_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.8, + "_src": "src_preprocessing_dyslexia_simulator_py_simulate", + "_tgt": "src_preprocessing_dyslexia_simulator_py_corrupt_word", + "source": "src_preprocessing_dyslexia_simulator_py_corrupt_word", + "target": "src_preprocessing_dyslexia_simulator_py_simulate" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/dyslexia_simulator.py", + "weight": 0.5, + "_src": "src_preprocessing_dyslexia_simulator_py_simulate", + "_tgt": "src_preprocessing_dyslexia_simulator_py_simulate_doc", + "source": "src_preprocessing_dyslexia_simulator_py_simulate", + "target": "src_preprocessing_dyslexia_simulator_py_simulate_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/dataset.py", + "weight": 0.8, + "_src": "src_training_dataset_py__add_synthetic", + "_tgt": "src_preprocessing_dyslexia_simulator_py_simulate", + "source": "src_preprocessing_dyslexia_simulator_py_simulate", + "target": "src_training_dataset_py__add_synthetic" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_preprocessing.py", + "weight": 0.8, + "_src": "tests_test_preprocessing_py_test_dyslexia_simulator", + "_tgt": "src_preprocessing_dyslexia_simulator_py_simulate", + "source": "src_preprocessing_dyslexia_simulator_py_simulate", + "target": "tests_test_preprocessing_py_test_dyslexia_simulator" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_preprocessing.py", + "weight": 0.8, + "_src": "tests_test_preprocessing_py_test_dyslexia_simulator_preserves_clean", + "_tgt": "src_preprocessing_dyslexia_simulator_py_simulate", + "source": "src_preprocessing_dyslexia_simulator_py_simulate", + "target": "tests_test_preprocessing_py_test_dyslexia_simulator_preserves_clean" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/ner_tagger.py", + "weight": 0.5, + "_src": "src_preprocessing_ner_tagger_py", + "_tgt": "src_preprocessing_ner_tagger_py_docstring", + "source": "src_preprocessing_ner_tagger_py", + "target": "src_preprocessing_ner_tagger_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/ner_tagger.py", + "weight": 1.0, + "_src": "src_preprocessing_ner_tagger_py", + "_tgt": "src_preprocessing_ner_tagger_py_EntitySpan", + "source": "src_preprocessing_ner_tagger_py", + "target": "src_preprocessing_ner_tagger_py_EntitySpan" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/ner_tagger.py", + "weight": 1.0, + "_src": "src_preprocessing_ner_tagger_py", + "_tgt": "src_preprocessing_ner_tagger_py_NERTagger", + "source": "src_preprocessing_ner_tagger_py", + "target": "src_preprocessing_ner_tagger_py_NERTagger" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/ner_tagger.py", + "weight": 1.0, + "_src": "src_preprocessing_ner_tagger_py", + "_tgt": "src_preprocessing_ner_tagger_py___init__", + "source": "src_preprocessing_ner_tagger_py", + "target": "src_preprocessing_ner_tagger_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/ner_tagger.py", + "weight": 1.0, + "_src": "src_preprocessing_ner_tagger_py", + "_tgt": "src_preprocessing_ner_tagger_py_tag", + "source": "src_preprocessing_ner_tagger_py", + "target": "src_preprocessing_ner_tagger_py_tag" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/ner_tagger.py", + "weight": 1.0, + "_src": "src_preprocessing_ner_tagger_py", + "_tgt": "src_preprocessing_ner_tagger_py_get_protected_spans", + "source": "src_preprocessing_ner_tagger_py", + "target": "src_preprocessing_ner_tagger_py_get_protected_spans" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.6, + "_src": "tests_test_preprocessing_py", + "_tgt": "src_preprocessing_ner_tagger_py", + "source": "src_preprocessing_ner_tagger_py", + "target": "tests_test_preprocessing_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/ner_tagger.py", + "weight": 0.5, + "_src": "src_preprocessing_ner_tagger_py_NERTagger", + "_tgt": "src_preprocessing_ner_tagger_py_NERTagger_doc", + "source": "src_preprocessing_ner_tagger_py_NERTagger", + "target": "src_preprocessing_ner_tagger_py_NERTagger_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_preprocessing_ner_tagger_py___init__", + "source": "src_preprocessing_ner_tagger_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_preprocessing_ner_tagger_py___init__", + "source": "src_preprocessing_ner_tagger_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_preprocessing_ner_tagger_py___init__", + "source": "src_preprocessing_ner_tagger_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_preprocessing_ner_tagger_py___init__", + "source": "src_preprocessing_ner_tagger_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/ner_tagger.py", + "weight": 0.5, + "_src": "src_preprocessing_ner_tagger_py_tag", + "_tgt": "src_preprocessing_ner_tagger_py_tag_doc", + "source": "src_preprocessing_ner_tagger_py_tag", + "target": "src_preprocessing_ner_tagger_py_tag_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/preprocessing/ner_tagger.py", + "weight": 0.8, + "_src": "src_preprocessing_ner_tagger_py_get_protected_spans", + "_tgt": "src_preprocessing_ner_tagger_py_tag", + "source": "src_preprocessing_ner_tagger_py_tag", + "target": "src_preprocessing_ner_tagger_py_get_protected_spans" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_preprocessing.py", + "weight": 0.8, + "_src": "tests_test_preprocessing_py_test_entity_protection", + "_tgt": "src_preprocessing_ner_tagger_py_tag", + "source": "src_preprocessing_ner_tagger_py_tag", + "target": "tests_test_preprocessing_py_test_entity_protection" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/ner_tagger.py", + "weight": 0.5, + "_src": "src_preprocessing_ner_tagger_py_get_protected_spans", + "_tgt": "src_preprocessing_ner_tagger_py_get_protected_spans_doc", + "source": "src_preprocessing_ner_tagger_py_get_protected_spans", + "target": "src_preprocessing_ner_tagger_py_get_protected_spans_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/pipeline.py", + "weight": 0.5, + "_src": "src_preprocessing_pipeline_py", + "_tgt": "src_preprocessing_pipeline_py_docstring", + "source": "src_preprocessing_pipeline_py", + "target": "src_preprocessing_pipeline_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/pipeline.py", + "weight": 1.0, + "_src": "src_preprocessing_pipeline_py", + "_tgt": "src_preprocessing_pipeline_py_EntitySpan", + "source": "src_preprocessing_pipeline_py", + "target": "src_preprocessing_pipeline_py_EntitySpan" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/pipeline.py", + "weight": 1.0, + "_src": "src_preprocessing_pipeline_py", + "_tgt": "src_preprocessing_pipeline_py_PreprocessedDoc", + "source": "src_preprocessing_pipeline_py", + "target": "src_preprocessing_pipeline_py_PreprocessedDoc" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/pipeline.py", + "weight": 1.0, + "_src": "src_preprocessing_pipeline_py", + "_tgt": "src_preprocessing_pipeline_py_PreprocessingPipeline", + "source": "src_preprocessing_pipeline_py", + "target": "src_preprocessing_pipeline_py_PreprocessingPipeline" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/pipeline.py", + "weight": 1.0, + "_src": "src_preprocessing_pipeline_py", + "_tgt": "src_preprocessing_pipeline_py___init__", + "source": "src_preprocessing_pipeline_py", + "target": "src_preprocessing_pipeline_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/pipeline.py", + "weight": 1.0, + "_src": "src_preprocessing_pipeline_py", + "_tgt": "src_preprocessing_pipeline_py__extract_readability", + "source": "src_preprocessing_pipeline_py", + "target": "src_preprocessing_pipeline_py__extract_readability" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/pipeline.py", + "weight": 1.0, + "_src": "src_preprocessing_pipeline_py", + "_tgt": "src_preprocessing_pipeline_py__extract_dep_tree", + "source": "src_preprocessing_pipeline_py", + "target": "src_preprocessing_pipeline_py__extract_dep_tree" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/pipeline.py", + "weight": 1.0, + "_src": "src_preprocessing_pipeline_py", + "_tgt": "src_preprocessing_pipeline_py_process", + "source": "src_preprocessing_pipeline_py", + "target": "src_preprocessing_pipeline_py_process" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.6, + "_src": "tests_test_preprocessing_py", + "_tgt": "src_preprocessing_pipeline_py", + "source": "src_preprocessing_pipeline_py", + "target": "tests_test_preprocessing_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/pipeline.py", + "weight": 0.5, + "_src": "src_preprocessing_pipeline_py_PreprocessingPipeline", + "_tgt": "src_preprocessing_pipeline_py_PreprocessingPipeline_doc", + "source": "src_preprocessing_pipeline_py_PreprocessingPipeline", + "target": "src_preprocessing_pipeline_py_PreprocessingPipeline_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_preprocessing_pipeline_py___init__", + "source": "src_preprocessing_pipeline_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_preprocessing_pipeline_py___init__", + "source": "src_preprocessing_pipeline_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_preprocessing_pipeline_py___init__", + "source": "src_preprocessing_pipeline_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_preprocessing_pipeline_py___init__", + "source": "src_preprocessing_pipeline_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/pipeline.py", + "weight": 0.5, + "_src": "src_preprocessing_pipeline_py__extract_readability", + "_tgt": "src_preprocessing_pipeline_py__extract_readability_doc", + "source": "src_preprocessing_pipeline_py__extract_readability", + "target": "src_preprocessing_pipeline_py__extract_readability_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/preprocessing/pipeline.py", + "weight": 0.8, + "_src": "src_preprocessing_pipeline_py_process", + "_tgt": "src_preprocessing_pipeline_py__extract_readability", + "source": "src_preprocessing_pipeline_py__extract_readability", + "target": "src_preprocessing_pipeline_py_process" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/pipeline.py", + "weight": 0.5, + "_src": "src_preprocessing_pipeline_py__extract_dep_tree", + "_tgt": "src_preprocessing_pipeline_py__extract_dep_tree_doc", + "source": "src_preprocessing_pipeline_py__extract_dep_tree", + "target": "src_preprocessing_pipeline_py__extract_dep_tree_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/preprocessing/pipeline.py", + "weight": 0.8, + "_src": "src_preprocessing_pipeline_py_process", + "_tgt": "src_preprocessing_pipeline_py__extract_dep_tree", + "source": "src_preprocessing_pipeline_py__extract_dep_tree", + "target": "src_preprocessing_pipeline_py_process" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/pipeline.py", + "weight": 0.5, + "_src": "src_preprocessing_pipeline_py_process", + "_tgt": "src_preprocessing_pipeline_py_process_doc", + "source": "src_preprocessing_pipeline_py_process", + "target": "src_preprocessing_pipeline_py_process_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/preprocessing/pipeline.py", + "weight": 0.8, + "_src": "src_preprocessing_pipeline_py_process", + "_tgt": "src_preprocessing_spell_corrector_py_correct", + "source": "src_preprocessing_pipeline_py_process", + "target": "src_preprocessing_spell_corrector_py_correct" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_preprocessing.py", + "weight": 0.8, + "_src": "tests_test_preprocessing_py_test_readability_scores", + "_tgt": "src_preprocessing_pipeline_py_process", + "source": "src_preprocessing_pipeline_py_process", + "target": "tests_test_preprocessing_py_test_readability_scores" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/sentence_segmenter.py", + "weight": 0.5, + "_src": "src_preprocessing_sentence_segmenter_py", + "_tgt": "src_preprocessing_sentence_segmenter_py_docstring", + "source": "src_preprocessing_sentence_segmenter_py", + "target": "src_preprocessing_sentence_segmenter_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/sentence_segmenter.py", + "weight": 1.0, + "_src": "src_preprocessing_sentence_segmenter_py", + "_tgt": "src_preprocessing_sentence_segmenter_py_SentenceSegmenter", + "source": "src_preprocessing_sentence_segmenter_py", + "target": "src_preprocessing_sentence_segmenter_py_SentenceSegmenter" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/sentence_segmenter.py", + "weight": 1.0, + "_src": "src_preprocessing_sentence_segmenter_py", + "_tgt": "src_preprocessing_sentence_segmenter_py___init__", + "source": "src_preprocessing_sentence_segmenter_py", + "target": "src_preprocessing_sentence_segmenter_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/sentence_segmenter.py", + "weight": 1.0, + "_src": "src_preprocessing_sentence_segmenter_py", + "_tgt": "src_preprocessing_sentence_segmenter_py_segment", + "source": "src_preprocessing_sentence_segmenter_py", + "target": "src_preprocessing_sentence_segmenter_py_segment" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.6, + "_src": "tests_test_preprocessing_py", + "_tgt": "src_preprocessing_sentence_segmenter_py", + "source": "src_preprocessing_sentence_segmenter_py", + "target": "tests_test_preprocessing_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/sentence_segmenter.py", + "weight": 0.5, + "_src": "src_preprocessing_sentence_segmenter_py_SentenceSegmenter", + "_tgt": "src_preprocessing_sentence_segmenter_py_SentenceSegmenter_doc", + "source": "src_preprocessing_sentence_segmenter_py_SentenceSegmenter", + "target": "src_preprocessing_sentence_segmenter_py_SentenceSegmenter_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_preprocessing_sentence_segmenter_py___init__", + "source": "src_preprocessing_sentence_segmenter_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_preprocessing_sentence_segmenter_py___init__", + "source": "src_preprocessing_sentence_segmenter_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_preprocessing_sentence_segmenter_py___init__", + "source": "src_preprocessing_sentence_segmenter_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_preprocessing_sentence_segmenter_py___init__", + "source": "src_preprocessing_sentence_segmenter_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/sentence_segmenter.py", + "weight": 0.5, + "_src": "src_preprocessing_sentence_segmenter_py_segment", + "_tgt": "src_preprocessing_sentence_segmenter_py_segment_doc", + "source": "src_preprocessing_sentence_segmenter_py_segment", + "target": "src_preprocessing_sentence_segmenter_py_segment_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_preprocessing.py", + "weight": 0.8, + "_src": "tests_test_preprocessing_py_test_sentence_segmentation", + "_tgt": "src_preprocessing_sentence_segmenter_py_segment", + "source": "src_preprocessing_sentence_segmenter_py_segment", + "target": "tests_test_preprocessing_py_test_sentence_segmentation" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 0.5, + "_src": "src_preprocessing_spell_corrector_py", + "_tgt": "src_preprocessing_spell_corrector_py_docstring", + "source": "src_preprocessing_spell_corrector_py", + "target": "src_preprocessing_spell_corrector_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 1.0, + "_src": "src_preprocessing_spell_corrector_py", + "_tgt": "src_preprocessing_spell_corrector_py_DyslexiaAwareSpellCorrector", + "source": "src_preprocessing_spell_corrector_py", + "target": "src_preprocessing_spell_corrector_py_DyslexiaAwareSpellCorrector" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 1.0, + "_src": "src_preprocessing_spell_corrector_py", + "_tgt": "src_preprocessing_spell_corrector_py___init__", + "source": "src_preprocessing_spell_corrector_py", + "target": "src_preprocessing_spell_corrector_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 1.0, + "_src": "src_preprocessing_spell_corrector_py", + "_tgt": "src_preprocessing_spell_corrector_py__phonetic_pass", + "source": "src_preprocessing_spell_corrector_py", + "target": "src_preprocessing_spell_corrector_py__phonetic_pass" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 1.0, + "_src": "src_preprocessing_spell_corrector_py", + "_tgt": "src_preprocessing_spell_corrector_py__spellcheck_pass", + "source": "src_preprocessing_spell_corrector_py", + "target": "src_preprocessing_spell_corrector_py__spellcheck_pass" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 1.0, + "_src": "src_preprocessing_spell_corrector_py", + "_tgt": "src_preprocessing_spell_corrector_py__languagetool_pass", + "source": "src_preprocessing_spell_corrector_py", + "target": "src_preprocessing_spell_corrector_py__languagetool_pass" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 1.0, + "_src": "src_preprocessing_spell_corrector_py", + "_tgt": "src_preprocessing_spell_corrector_py_correct", + "source": "src_preprocessing_spell_corrector_py", + "target": "src_preprocessing_spell_corrector_py_correct" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 1.0, + "_src": "src_preprocessing_spell_corrector_py", + "_tgt": "src_preprocessing_spell_corrector_py_close", + "source": "src_preprocessing_spell_corrector_py", + "target": "src_preprocessing_spell_corrector_py_close" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 1.0, + "_src": "src_preprocessing_spell_corrector_py", + "_tgt": "src_preprocessing_spell_corrector_py__replace", + "source": "src_preprocessing_spell_corrector_py", + "target": "src_preprocessing_spell_corrector_py__replace" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.6, + "_src": "tests_test_preprocessing_py", + "_tgt": "src_preprocessing_spell_corrector_py", + "source": "src_preprocessing_spell_corrector_py", + "target": "tests_test_preprocessing_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 0.5, + "_src": "src_preprocessing_spell_corrector_py_DyslexiaAwareSpellCorrector", + "_tgt": "src_preprocessing_spell_corrector_py_DyslexiaAwareSpellCorrector_doc", + "source": "src_preprocessing_spell_corrector_py_DyslexiaAwareSpellCorrector", + "target": "src_preprocessing_spell_corrector_py_DyslexiaAwareSpellCorrector_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_preprocessing_spell_corrector_py___init__", + "source": "src_preprocessing_spell_corrector_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_preprocessing_spell_corrector_py___init__", + "source": "src_preprocessing_spell_corrector_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_preprocessing_spell_corrector_py___init__", + "source": "src_preprocessing_spell_corrector_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_preprocessing_spell_corrector_py___init__", + "source": "src_preprocessing_spell_corrector_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 0.5, + "_src": "src_preprocessing_spell_corrector_py__phonetic_pass", + "_tgt": "src_preprocessing_spell_corrector_py__phonetic_pass_doc", + "source": "src_preprocessing_spell_corrector_py__phonetic_pass", + "target": "src_preprocessing_spell_corrector_py__phonetic_pass_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 0.8, + "_src": "src_preprocessing_spell_corrector_py_correct", + "_tgt": "src_preprocessing_spell_corrector_py__phonetic_pass", + "source": "src_preprocessing_spell_corrector_py__phonetic_pass", + "target": "src_preprocessing_spell_corrector_py_correct" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_preprocessing.py", + "weight": 0.8, + "_src": "tests_test_preprocessing_py_test_spell_correction_phonetic", + "_tgt": "src_preprocessing_spell_corrector_py__phonetic_pass", + "source": "src_preprocessing_spell_corrector_py__phonetic_pass", + "target": "tests_test_preprocessing_py_test_spell_correction_phonetic" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 0.5, + "_src": "src_preprocessing_spell_corrector_py__spellcheck_pass", + "_tgt": "src_preprocessing_spell_corrector_py__spellcheck_pass_doc", + "source": "src_preprocessing_spell_corrector_py__spellcheck_pass", + "target": "src_preprocessing_spell_corrector_py__spellcheck_pass_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 0.8, + "_src": "src_preprocessing_spell_corrector_py_correct", + "_tgt": "src_preprocessing_spell_corrector_py__spellcheck_pass", + "source": "src_preprocessing_spell_corrector_py__spellcheck_pass", + "target": "src_preprocessing_spell_corrector_py_correct" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 0.5, + "_src": "src_preprocessing_spell_corrector_py__languagetool_pass", + "_tgt": "src_preprocessing_spell_corrector_py__languagetool_pass_doc", + "source": "src_preprocessing_spell_corrector_py__languagetool_pass", + "target": "src_preprocessing_spell_corrector_py__languagetool_pass_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 0.8, + "_src": "src_preprocessing_spell_corrector_py_correct", + "_tgt": "src_preprocessing_spell_corrector_py__languagetool_pass", + "source": "src_preprocessing_spell_corrector_py__languagetool_pass", + "target": "src_preprocessing_spell_corrector_py_correct" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 0.5, + "_src": "src_preprocessing_spell_corrector_py_correct", + "_tgt": "src_preprocessing_spell_corrector_py_correct_doc", + "source": "src_preprocessing_spell_corrector_py_correct", + "target": "src_preprocessing_spell_corrector_py_correct_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "tests/test_preprocessing.py", + "weight": 0.8, + "_src": "tests_test_preprocessing_py_test_spell_correction_empty", + "_tgt": "src_preprocessing_spell_corrector_py_correct", + "source": "src_preprocessing_spell_corrector_py_correct", + "target": "tests_test_preprocessing_py_test_spell_correction_empty" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 0.5, + "_src": "src_preprocessing_spell_corrector_py_close", + "_tgt": "src_preprocessing_spell_corrector_py_close_doc", + "source": "src_preprocessing_spell_corrector_py_close", + "target": "src_preprocessing_spell_corrector_py_close_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/preprocessing/spell_corrector.py", + "weight": 0.8, + "_src": "src_preprocessing_spell_corrector_py_close", + "_tgt": "src_preprocessing_spell_corrector_py_close", + "source": "src_preprocessing_spell_corrector_py_close", + "target": "src_preprocessing_spell_corrector_py_close" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_preprocessing.py", + "weight": 0.8, + "_src": "tests_test_preprocessing_py_corrector", + "_tgt": "src_preprocessing_spell_corrector_py_close", + "source": "src_preprocessing_spell_corrector_py_close", + "target": "tests_test_preprocessing_py_corrector" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/emotion_classifier.py", + "weight": 0.5, + "_src": "src_style_emotion_classifier_py", + "_tgt": "src_style_emotion_classifier_py_docstring", + "source": "src_style_emotion_classifier_py", + "target": "src_style_emotion_classifier_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/emotion_classifier.py", + "weight": 1.0, + "_src": "src_style_emotion_classifier_py", + "_tgt": "src_style_emotion_classifier_py_EmotionClassifier", + "source": "src_style_emotion_classifier_py", + "target": "src_style_emotion_classifier_py_EmotionClassifier" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/emotion_classifier.py", + "weight": 1.0, + "_src": "src_style_emotion_classifier_py", + "_tgt": "src_style_emotion_classifier_py___init__", + "source": "src_style_emotion_classifier_py", + "target": "src_style_emotion_classifier_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/emotion_classifier.py", + "weight": 1.0, + "_src": "src_style_emotion_classifier_py", + "_tgt": "src_style_emotion_classifier_py_classify", + "source": "src_style_emotion_classifier_py", + "target": "src_style_emotion_classifier_py_classify" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/emotion_classifier.py", + "weight": 0.5, + "_src": "src_style_emotion_classifier_py_EmotionClassifier", + "_tgt": "src_style_emotion_classifier_py_EmotionClassifier_doc", + "source": "src_style_emotion_classifier_py_EmotionClassifier", + "target": "src_style_emotion_classifier_py_EmotionClassifier_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_style_emotion_classifier_py___init__", + "source": "src_style_emotion_classifier_py___init__", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_style_emotion_classifier_py___init__", + "source": "src_style_emotion_classifier_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_style_emotion_classifier_py___init__", + "source": "src_style_emotion_classifier_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_style_emotion_classifier_py___init__", + "source": "src_style_emotion_classifier_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/emotion_classifier.py", + "weight": 0.5, + "_src": "src_style_emotion_classifier_py_classify", + "_tgt": "src_style_emotion_classifier_py_classify_doc", + "source": "src_style_emotion_classifier_py_classify", + "target": "src_style_emotion_classifier_py_classify_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py_docstring", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py_StyleProjectionMLP", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py_StyleProjectionMLP" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py_StyleFingerprinter", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py_StyleFingerprinter" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py___init__", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py_forward", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py_forward" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py__load_awl", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py__load_awl" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py__passive_voice_ratio", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py__passive_voice_ratio" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py__avg_dep_tree_depth", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py__avg_dep_tree_depth" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py__lexical_density", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py__lexical_density" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py__count_syllables", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py__count_syllables" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py__avg_syllables_per_word", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py__avg_syllables_per_word" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py__flesch_reading_ease", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py__flesch_reading_ease" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py_extract_raw_features", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py_extract_raw_features" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py_extract_vector", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py_extract_vector" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py_blend_vectors", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py_blend_vectors" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 1.0, + "_src": "src_style_fingerprinter_py", + "_tgt": "src_style_fingerprinter_py__depth", + "source": "src_style_fingerprinter_py", + "target": "src_style_fingerprinter_py__depth" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 0.6, + "_src": "tests_test_evaluation_py", + "_tgt": "src_style_fingerprinter_py", + "source": "src_style_fingerprinter_py", + "target": "tests_test_evaluation_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_style.py", + "weight": 0.6, + "_src": "tests_test_style_py", + "_tgt": "src_style_fingerprinter_py", + "source": "src_style_fingerprinter_py", + "target": "tests_test_style_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py_StyleProjectionMLP", + "_tgt": "src_style_fingerprinter_py_StyleProjectionMLP_doc", + "source": "src_style_fingerprinter_py_StyleProjectionMLP", + "target": "src_style_fingerprinter_py_StyleProjectionMLP_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py_StyleFingerprinter", + "_tgt": "src_style_fingerprinter_py_StyleFingerprinter_doc", + "source": "src_style_fingerprinter_py_StyleFingerprinter", + "target": "src_style_fingerprinter_py_StyleFingerprinter_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_style_formality_classifier_py___init__", + "source": "src_style_fingerprinter_py___init__", + "target": "src_style_formality_classifier_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_training_callbacks_py___init__", + "source": "src_style_fingerprinter_py___init__", + "target": "src_training_callbacks_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_training_dataset_py___init__", + "source": "src_style_fingerprinter_py___init__", + "target": "src_training_dataset_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_style_fingerprinter_py___init__", + "source": "src_style_fingerprinter_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_style_fingerprinter_py___init__", + "source": "src_style_fingerprinter_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_style_fingerprinter_py___init__", + "source": "src_style_fingerprinter_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_vocabulary_awl_loader_py___init__", + "source": "src_style_fingerprinter_py___init__", + "target": "src_vocabulary_awl_loader_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_vocabulary_lexical_substitution_py___init__", + "source": "src_style_fingerprinter_py___init__", + "target": "src_vocabulary_lexical_substitution_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_vocabulary_register_filter_py___init__", + "source": "src_style_fingerprinter_py___init__", + "target": "src_vocabulary_register_filter_py___init__" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py___init__", + "_tgt": "src_style_fingerprinter_py__load_awl", + "source": "src_style_fingerprinter_py___init__", + "target": "src_style_fingerprinter_py__load_awl" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py_score", + "_tgt": "src_style_fingerprinter_py_forward", + "source": "src_style_fingerprinter_py_forward", + "target": "src_training_human_pattern_extractor_py_score" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py__load_awl", + "_tgt": "src_style_fingerprinter_py__load_awl_doc", + "source": "src_style_fingerprinter_py__load_awl", + "target": "src_style_fingerprinter_py__load_awl_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py__passive_voice_ratio", + "_tgt": "src_style_fingerprinter_py__passive_voice_ratio_doc", + "source": "src_style_fingerprinter_py__passive_voice_ratio", + "target": "src_style_fingerprinter_py__passive_voice_ratio_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py_extract_raw_features", + "_tgt": "src_style_fingerprinter_py__passive_voice_ratio", + "source": "src_style_fingerprinter_py__passive_voice_ratio", + "target": "src_style_fingerprinter_py_extract_raw_features" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py__avg_dep_tree_depth", + "_tgt": "src_style_fingerprinter_py__avg_dep_tree_depth_doc", + "source": "src_style_fingerprinter_py__avg_dep_tree_depth", + "target": "src_style_fingerprinter_py__avg_dep_tree_depth_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py__avg_dep_tree_depth", + "_tgt": "src_style_fingerprinter_py__depth", + "source": "src_style_fingerprinter_py__avg_dep_tree_depth", + "target": "src_style_fingerprinter_py__depth" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py_extract_raw_features", + "_tgt": "src_style_fingerprinter_py__avg_dep_tree_depth", + "source": "src_style_fingerprinter_py__avg_dep_tree_depth", + "target": "src_style_fingerprinter_py_extract_raw_features" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py__lexical_density", + "_tgt": "src_style_fingerprinter_py__lexical_density_doc", + "source": "src_style_fingerprinter_py__lexical_density", + "target": "src_style_fingerprinter_py__lexical_density_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py_extract_raw_features", + "_tgt": "src_style_fingerprinter_py__lexical_density", + "source": "src_style_fingerprinter_py__lexical_density", + "target": "src_style_fingerprinter_py_extract_raw_features" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py__count_syllables", + "_tgt": "src_style_fingerprinter_py__count_syllables_doc", + "source": "src_style_fingerprinter_py__count_syllables", + "target": "src_style_fingerprinter_py__count_syllables_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py__avg_syllables_per_word", + "_tgt": "src_style_fingerprinter_py__count_syllables", + "source": "src_style_fingerprinter_py__count_syllables", + "target": "src_style_fingerprinter_py__avg_syllables_per_word" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py__avg_syllables_per_word", + "_tgt": "src_style_fingerprinter_py__avg_syllables_per_word_doc", + "source": "src_style_fingerprinter_py__avg_syllables_per_word", + "target": "src_style_fingerprinter_py__avg_syllables_per_word_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py_extract_raw_features", + "_tgt": "src_style_fingerprinter_py__avg_syllables_per_word", + "source": "src_style_fingerprinter_py__avg_syllables_per_word", + "target": "src_style_fingerprinter_py_extract_raw_features" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py__flesch_reading_ease", + "_tgt": "src_style_fingerprinter_py__flesch_reading_ease_doc", + "source": "src_style_fingerprinter_py__flesch_reading_ease", + "target": "src_style_fingerprinter_py__flesch_reading_ease_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py_extract_raw_features", + "_tgt": "src_style_fingerprinter_py__flesch_reading_ease", + "source": "src_style_fingerprinter_py__flesch_reading_ease", + "target": "src_style_fingerprinter_py_extract_raw_features" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py_extract_raw_features", + "_tgt": "src_style_fingerprinter_py_extract_raw_features_doc", + "source": "src_style_fingerprinter_py_extract_raw_features", + "target": "src_style_fingerprinter_py_extract_raw_features_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py_extract_raw_features", + "_tgt": "src_style_formality_classifier_py_score", + "source": "src_style_fingerprinter_py_extract_raw_features", + "target": "src_style_formality_classifier_py_score" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py_extract_raw_features", + "_tgt": "src_training_human_pattern_extractor_py_score", + "source": "src_style_fingerprinter_py_extract_raw_features", + "target": "src_training_human_pattern_extractor_py_score" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/style/fingerprinter.py", + "weight": 0.8, + "_src": "src_style_fingerprinter_py_extract_vector", + "_tgt": "src_style_fingerprinter_py_extract_raw_features", + "source": "src_style_fingerprinter_py_extract_raw_features", + "target": "src_style_fingerprinter_py_extract_vector" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_style.py", + "weight": 0.8, + "_src": "tests_test_style_py_test_raw_features_keys", + "_tgt": "src_style_fingerprinter_py_extract_raw_features", + "source": "src_style_fingerprinter_py_extract_raw_features", + "target": "tests_test_style_py_test_raw_features_keys" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py_extract_vector", + "_tgt": "src_style_fingerprinter_py_extract_vector_doc", + "source": "src_style_fingerprinter_py_extract_vector", + "target": "src_style_fingerprinter_py_extract_vector_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/dataset.py", + "weight": 0.8, + "_src": "src_training_dataset_py__precompute_all", + "_tgt": "src_style_fingerprinter_py_extract_vector", + "source": "src_style_fingerprinter_py_extract_vector", + "target": "src_training_dataset_py__precompute_all" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_style.py", + "weight": 0.8, + "_src": "tests_test_style_py_test_style_vector_shape", + "_tgt": "src_style_fingerprinter_py_extract_vector", + "source": "src_style_fingerprinter_py_extract_vector", + "target": "tests_test_style_py_test_style_vector_shape" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_style.py", + "weight": 0.8, + "_src": "tests_test_style_py_test_style_vector_different_texts", + "_tgt": "src_style_fingerprinter_py_extract_vector", + "source": "src_style_fingerprinter_py_extract_vector", + "target": "tests_test_style_py_test_style_vector_different_texts" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_style.py", + "weight": 0.8, + "_src": "tests_test_style_py_test_style_blend", + "_tgt": "src_style_fingerprinter_py_extract_vector", + "source": "src_style_fingerprinter_py_extract_vector", + "target": "tests_test_style_py_test_style_blend" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/fingerprinter.py", + "weight": 0.5, + "_src": "src_style_fingerprinter_py_blend_vectors", + "_tgt": "src_style_fingerprinter_py_blend_vectors_doc", + "source": "src_style_fingerprinter_py_blend_vectors", + "target": "src_style_fingerprinter_py_blend_vectors_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_style.py", + "weight": 0.8, + "_src": "tests_test_style_py_test_style_blend", + "_tgt": "src_style_fingerprinter_py_blend_vectors", + "source": "src_style_fingerprinter_py_blend_vectors", + "target": "tests_test_style_py_test_style_blend" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/formality_classifier.py", + "weight": 0.5, + "_src": "src_style_formality_classifier_py", + "_tgt": "src_style_formality_classifier_py_docstring", + "source": "src_style_formality_classifier_py", + "target": "src_style_formality_classifier_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/formality_classifier.py", + "weight": 1.0, + "_src": "src_style_formality_classifier_py", + "_tgt": "src_style_formality_classifier_py_FormalityClassifier", + "source": "src_style_formality_classifier_py", + "target": "src_style_formality_classifier_py_FormalityClassifier" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/formality_classifier.py", + "weight": 1.0, + "_src": "src_style_formality_classifier_py", + "_tgt": "src_style_formality_classifier_py___init__", + "source": "src_style_formality_classifier_py", + "target": "src_style_formality_classifier_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/formality_classifier.py", + "weight": 1.0, + "_src": "src_style_formality_classifier_py", + "_tgt": "src_style_formality_classifier_py_score", + "source": "src_style_formality_classifier_py", + "target": "src_style_formality_classifier_py_score" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/register_filter.py", + "weight": 0.6, + "_src": "src_vocabulary_register_filter_py", + "_tgt": "src_style_formality_classifier_py", + "source": "src_style_formality_classifier_py", + "target": "src_vocabulary_register_filter_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/formality_classifier.py", + "weight": 0.5, + "_src": "src_style_formality_classifier_py_FormalityClassifier", + "_tgt": "src_style_formality_classifier_py_FormalityClassifier_doc", + "source": "src_style_formality_classifier_py_FormalityClassifier", + "target": "src_style_formality_classifier_py_FormalityClassifier_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_style_formality_classifier_py___init__", + "source": "src_style_formality_classifier_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_style_formality_classifier_py___init__", + "source": "src_style_formality_classifier_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_style_formality_classifier_py___init__", + "source": "src_style_formality_classifier_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/formality_classifier.py", + "weight": 0.5, + "_src": "src_style_formality_classifier_py_score", + "_tgt": "src_style_formality_classifier_py_score_doc", + "source": "src_style_formality_classifier_py_score", + "target": "src_style_formality_classifier_py_score_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py__human_pattern_loss", + "_tgt": "src_style_formality_classifier_py_score", + "source": "src_style_formality_classifier_py_score", + "target": "src_training_loss_functions_py__human_pattern_loss" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/vocabulary/register_filter.py", + "weight": 0.8, + "_src": "src_vocabulary_register_filter_py_check_formality", + "_tgt": "src_style_formality_classifier_py_score", + "source": "src_style_formality_classifier_py_score", + "target": "src_vocabulary_register_filter_py_check_formality" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/style_vector.py", + "weight": 0.5, + "_src": "src_style_style_vector_py", + "_tgt": "src_style_style_vector_py_docstring", + "source": "src_style_style_vector_py", + "target": "src_style_style_vector_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/style_vector.py", + "weight": 1.0, + "_src": "src_style_style_vector_py", + "_tgt": "src_style_style_vector_py_cosine_similarity", + "source": "src_style_style_vector_py", + "target": "src_style_style_vector_py_cosine_similarity" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/style_vector.py", + "weight": 1.0, + "_src": "src_style_style_vector_py", + "_tgt": "src_style_style_vector_py_average_style_vectors", + "source": "src_style_style_vector_py", + "target": "src_style_style_vector_py_average_style_vectors" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/style_vector.py", + "weight": 1.0, + "_src": "src_style_style_vector_py", + "_tgt": "src_style_style_vector_py_save_style_vector", + "source": "src_style_style_vector_py", + "target": "src_style_style_vector_py_save_style_vector" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/style_vector.py", + "weight": 1.0, + "_src": "src_style_style_vector_py", + "_tgt": "src_style_style_vector_py_load_style_vector", + "source": "src_style_style_vector_py", + "target": "src_style_style_vector_py_load_style_vector" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_style.py", + "weight": 0.6, + "_src": "tests_test_style_py", + "_tgt": "src_style_style_vector_py", + "source": "src_style_style_vector_py", + "target": "tests_test_style_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/style_vector.py", + "weight": 0.5, + "_src": "src_style_style_vector_py_cosine_similarity", + "_tgt": "src_style_style_vector_py_cosine_similarity_doc", + "source": "src_style_style_vector_py_cosine_similarity", + "target": "src_style_style_vector_py_cosine_similarity_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/style/style_vector.py", + "weight": 0.8, + "_src": "src_style_style_vector_py_cosine_similarity", + "_tgt": "src_style_style_vector_py_cosine_similarity", + "source": "src_style_style_vector_py_cosine_similarity", + "target": "src_style_style_vector_py_cosine_similarity" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py__style_loss", + "_tgt": "src_style_style_vector_py_cosine_similarity", + "source": "src_style_style_vector_py_cosine_similarity", + "target": "src_training_loss_functions_py__style_loss" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py__semantic_loss", + "_tgt": "src_style_style_vector_py_cosine_similarity", + "source": "src_style_style_vector_py_cosine_similarity", + "target": "src_training_loss_functions_py__semantic_loss" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py_forward", + "_tgt": "src_style_style_vector_py_cosine_similarity", + "source": "src_style_style_vector_py_cosine_similarity", + "target": "src_training_loss_functions_py_forward" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 0.8, + "_src": "src_vocabulary_lexical_substitution_py__sem_similarity", + "_tgt": "src_style_style_vector_py_cosine_similarity", + "source": "src_style_style_vector_py_cosine_similarity", + "target": "src_vocabulary_lexical_substitution_py__sem_similarity" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_style.py", + "weight": 0.8, + "_src": "tests_test_style_py_test_style_vector_different_texts", + "_tgt": "src_style_style_vector_py_cosine_similarity", + "source": "src_style_style_vector_py_cosine_similarity", + "target": "tests_test_style_py_test_style_vector_different_texts" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/style_vector.py", + "weight": 0.5, + "_src": "src_style_style_vector_py_average_style_vectors", + "_tgt": "src_style_style_vector_py_average_style_vectors_doc", + "source": "src_style_style_vector_py_average_style_vectors", + "target": "src_style_style_vector_py_average_style_vectors_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/style_vector.py", + "weight": 0.5, + "_src": "src_style_style_vector_py_save_style_vector", + "_tgt": "src_style_style_vector_py_save_style_vector_doc", + "source": "src_style_style_vector_py_save_style_vector", + "target": "src_style_style_vector_py_save_style_vector_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/style/style_vector.py", + "weight": 0.5, + "_src": "src_style_style_vector_py_load_style_vector", + "_tgt": "src_style_style_vector_py_load_style_vector_doc", + "source": "src_style_style_vector_py_load_style_vector", + "target": "src_style_style_vector_py_load_style_vector_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/callbacks.py", + "weight": 0.5, + "_src": "src_training_callbacks_py", + "_tgt": "src_training_callbacks_py_docstring", + "source": "src_training_callbacks_py", + "target": "src_training_callbacks_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/callbacks.py", + "weight": 1.0, + "_src": "src_training_callbacks_py", + "_tgt": "src_training_callbacks_py_StyleMetricsCallback", + "source": "src_training_callbacks_py", + "target": "src_training_callbacks_py_StyleMetricsCallback" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/callbacks.py", + "weight": 1.0, + "_src": "src_training_callbacks_py", + "_tgt": "src_training_callbacks_py_EarlyStoppingOnStyleDrift", + "source": "src_training_callbacks_py", + "target": "src_training_callbacks_py_EarlyStoppingOnStyleDrift" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/callbacks.py", + "weight": 1.0, + "_src": "src_training_callbacks_py", + "_tgt": "src_training_callbacks_py_on_evaluate", + "source": "src_training_callbacks_py", + "target": "src_training_callbacks_py_on_evaluate" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/callbacks.py", + "weight": 1.0, + "_src": "src_training_callbacks_py", + "_tgt": "src_training_callbacks_py___init__", + "source": "src_training_callbacks_py", + "target": "src_training_callbacks_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/callbacks.py", + "weight": 0.5, + "_src": "src_training_callbacks_py_StyleMetricsCallback", + "_tgt": "src_training_callbacks_py_StyleMetricsCallback_doc", + "source": "src_training_callbacks_py_StyleMetricsCallback", + "target": "src_training_callbacks_py_StyleMetricsCallback_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/callbacks.py", + "weight": 0.5, + "_src": "src_training_callbacks_py_EarlyStoppingOnStyleDrift", + "_tgt": "src_training_callbacks_py_EarlyStoppingOnStyleDrift_doc", + "source": "src_training_callbacks_py_EarlyStoppingOnStyleDrift", + "target": "src_training_callbacks_py_EarlyStoppingOnStyleDrift_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_training_callbacks_py___init__", + "source": "src_training_callbacks_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_training_callbacks_py___init__", + "source": "src_training_callbacks_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_training_callbacks_py___init__", + "source": "src_training_callbacks_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 0.5, + "_src": "src_training_dataset_py", + "_tgt": "src_training_dataset_py_docstring", + "source": "src_training_dataset_py", + "target": "src_training_dataset_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 1.0, + "_src": "src_training_dataset_py", + "_tgt": "src_training_dataset_py_WritingCorrectionDataset", + "source": "src_training_dataset_py", + "target": "src_training_dataset_py_WritingCorrectionDataset" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 1.0, + "_src": "src_training_dataset_py", + "_tgt": "src_training_dataset_py___init__", + "source": "src_training_dataset_py", + "target": "src_training_dataset_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 1.0, + "_src": "src_training_dataset_py", + "_tgt": "src_training_dataset_py__compute_cache_key", + "source": "src_training_dataset_py", + "target": "src_training_dataset_py__compute_cache_key" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 1.0, + "_src": "src_training_dataset_py", + "_tgt": "src_training_dataset_py__load", + "source": "src_training_dataset_py", + "target": "src_training_dataset_py__load" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 1.0, + "_src": "src_training_dataset_py", + "_tgt": "src_training_dataset_py__add_synthetic", + "source": "src_training_dataset_py", + "target": "src_training_dataset_py__add_synthetic" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 1.0, + "_src": "src_training_dataset_py", + "_tgt": "src_training_dataset_py__precompute_all", + "source": "src_training_dataset_py", + "target": "src_training_dataset_py__precompute_all" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 1.0, + "_src": "src_training_dataset_py", + "_tgt": "src_training_dataset_py___len__", + "source": "src_training_dataset_py", + "target": "src_training_dataset_py___len__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 1.0, + "_src": "src_training_dataset_py", + "_tgt": "src_training_dataset_py___getitem__", + "source": "src_training_dataset_py", + "target": "src_training_dataset_py___getitem__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 0.5, + "_src": "src_training_dataset_py_WritingCorrectionDataset", + "_tgt": "src_training_dataset_py_WritingCorrectionDataset_doc", + "source": "src_training_dataset_py_WritingCorrectionDataset", + "target": "src_training_dataset_py_WritingCorrectionDataset_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/dataset.py", + "weight": 0.8, + "_src": "src_training_dataset_py___init__", + "_tgt": "src_training_dataset_py__load", + "source": "src_training_dataset_py___init__", + "target": "src_training_dataset_py__load" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/dataset.py", + "weight": 0.8, + "_src": "src_training_dataset_py___init__", + "_tgt": "src_training_dataset_py__compute_cache_key", + "source": "src_training_dataset_py___init__", + "target": "src_training_dataset_py__compute_cache_key" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/dataset.py", + "weight": 0.8, + "_src": "src_training_dataset_py___init__", + "_tgt": "src_training_dataset_py__add_synthetic", + "source": "src_training_dataset_py___init__", + "target": "src_training_dataset_py__add_synthetic" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/dataset.py", + "weight": 0.8, + "_src": "src_training_dataset_py___init__", + "_tgt": "src_training_dataset_py__precompute_all", + "source": "src_training_dataset_py___init__", + "target": "src_training_dataset_py__precompute_all" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_training_dataset_py___init__", + "source": "src_training_dataset_py___init__", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_training_dataset_py___init__", + "source": "src_training_dataset_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_training_dataset_py___init__", + "source": "src_training_dataset_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 0.5, + "_src": "src_training_dataset_py__compute_cache_key", + "_tgt": "src_training_dataset_py__compute_cache_key_doc", + "source": "src_training_dataset_py__compute_cache_key", + "target": "src_training_dataset_py__compute_cache_key_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 0.5, + "_src": "src_training_dataset_py__load", + "_tgt": "src_training_dataset_py__load_doc", + "source": "src_training_dataset_py__load", + "target": "src_training_dataset_py__load_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 0.5, + "_src": "src_training_dataset_py__add_synthetic", + "_tgt": "src_training_dataset_py__add_synthetic_doc", + "source": "src_training_dataset_py__add_synthetic", + "target": "src_training_dataset_py__add_synthetic_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 0.5, + "_src": "src_training_dataset_py__precompute_all", + "_tgt": "src_training_dataset_py__precompute_all_doc", + "source": "src_training_dataset_py__precompute_all", + "target": "src_training_dataset_py__precompute_all_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/dataset.py", + "weight": 0.5, + "_src": "src_training_dataset_py___getitem__", + "_tgt": "src_training_dataset_py___getitem___doc", + "source": "src_training_dataset_py___getitem__", + "target": "src_training_dataset_py___getitem___doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.5, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py_docstring", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py__compute_text_features", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py__compute_text_features" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py_HumanPatternFeatureExtractor", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py_HumanPatternFeatureExtractor" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py_KaggleHumanPatternDataset", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py_KaggleHumanPatternDataset" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py_HumanPatternClassifier", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py_HumanPatternClassifier" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py___init__", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py__perplexity", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py__perplexity" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py__perplexity_batch", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py__perplexity_batch" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py_extract", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py_extract" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py_extract_batch", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py_extract_batch" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py_precompute_features", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py_precompute_features" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py___len__", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py___len__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py___getitem__", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py___getitem__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py_forward", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py_forward" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 1.0, + "_src": "src_training_human_pattern_extractor_py", + "_tgt": "src_training_human_pattern_extractor_py_score", + "source": "src_training_human_pattern_extractor_py", + "target": "src_training_human_pattern_extractor_py_score" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.5, + "_src": "src_training_human_pattern_extractor_py__compute_text_features", + "_tgt": "src_training_human_pattern_extractor_py__compute_text_features_doc", + "source": "src_training_human_pattern_extractor_py__compute_text_features", + "target": "src_training_human_pattern_extractor_py__compute_text_features_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py_extract", + "_tgt": "src_training_human_pattern_extractor_py__compute_text_features", + "source": "src_training_human_pattern_extractor_py__compute_text_features", + "target": "src_training_human_pattern_extractor_py_extract" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py_extract_batch", + "_tgt": "src_training_human_pattern_extractor_py__compute_text_features", + "source": "src_training_human_pattern_extractor_py__compute_text_features", + "target": "src_training_human_pattern_extractor_py_extract_batch" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.5, + "_src": "src_training_human_pattern_extractor_py_HumanPatternFeatureExtractor", + "_tgt": "src_training_human_pattern_extractor_py_HumanPatternFeatureExtractor_doc", + "source": "src_training_human_pattern_extractor_py_HumanPatternFeatureExtractor", + "target": "src_training_human_pattern_extractor_py_HumanPatternFeatureExtractor_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.5, + "_src": "src_training_human_pattern_extractor_py_KaggleHumanPatternDataset", + "_tgt": "src_training_human_pattern_extractor_py_KaggleHumanPatternDataset_doc", + "source": "src_training_human_pattern_extractor_py_KaggleHumanPatternDataset", + "target": "src_training_human_pattern_extractor_py_KaggleHumanPatternDataset_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.5, + "_src": "src_training_human_pattern_extractor_py_HumanPatternClassifier", + "_tgt": "src_training_human_pattern_extractor_py_HumanPatternClassifier_doc", + "source": "src_training_human_pattern_extractor_py_HumanPatternClassifier", + "target": "src_training_human_pattern_extractor_py_HumanPatternClassifier_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_training_human_pattern_extractor_py___init__", + "source": "src_training_human_pattern_extractor_py___init__", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_training_human_pattern_extractor_py___init__", + "source": "src_training_human_pattern_extractor_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_vocabulary_awl_loader_py___init__", + "source": "src_training_human_pattern_extractor_py___init__", + "target": "src_vocabulary_awl_loader_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_vocabulary_lexical_substitution_py___init__", + "source": "src_training_human_pattern_extractor_py___init__", + "target": "src_vocabulary_lexical_substitution_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___init__", + "_tgt": "src_vocabulary_register_filter_py___init__", + "source": "src_training_human_pattern_extractor_py___init__", + "target": "src_vocabulary_register_filter_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.5, + "_src": "src_training_human_pattern_extractor_py__perplexity", + "_tgt": "src_training_human_pattern_extractor_py__perplexity_doc", + "source": "src_training_human_pattern_extractor_py__perplexity", + "target": "src_training_human_pattern_extractor_py__perplexity_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py_extract", + "_tgt": "src_training_human_pattern_extractor_py__perplexity", + "source": "src_training_human_pattern_extractor_py__perplexity", + "target": "src_training_human_pattern_extractor_py_extract" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.5, + "_src": "src_training_human_pattern_extractor_py__perplexity_batch", + "_tgt": "src_training_human_pattern_extractor_py__perplexity_batch_doc", + "source": "src_training_human_pattern_extractor_py__perplexity_batch", + "target": "src_training_human_pattern_extractor_py__perplexity_batch_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py_extract_batch", + "_tgt": "src_training_human_pattern_extractor_py__perplexity_batch", + "source": "src_training_human_pattern_extractor_py__perplexity_batch", + "target": "src_training_human_pattern_extractor_py_extract_batch" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.5, + "_src": "src_training_human_pattern_extractor_py_extract", + "_tgt": "src_training_human_pattern_extractor_py_extract_doc", + "source": "src_training_human_pattern_extractor_py_extract", + "target": "src_training_human_pattern_extractor_py_extract_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py___getitem__", + "_tgt": "src_training_human_pattern_extractor_py_extract", + "source": "src_training_human_pattern_extractor_py_extract", + "target": "src_training_human_pattern_extractor_py___getitem__" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py_score", + "_tgt": "src_training_human_pattern_extractor_py_extract", + "source": "src_training_human_pattern_extractor_py_extract", + "target": "src_training_human_pattern_extractor_py_score" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.5, + "_src": "src_training_human_pattern_extractor_py_extract_batch", + "_tgt": "src_training_human_pattern_extractor_py_extract_batch_doc", + "source": "src_training_human_pattern_extractor_py_extract_batch", + "target": "src_training_human_pattern_extractor_py_extract_batch_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py_precompute_features", + "_tgt": "src_training_human_pattern_extractor_py_extract_batch", + "source": "src_training_human_pattern_extractor_py_extract_batch", + "target": "src_training_human_pattern_extractor_py_precompute_features" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.5, + "_src": "src_training_human_pattern_extractor_py_precompute_features", + "_tgt": "src_training_human_pattern_extractor_py_precompute_features_doc", + "source": "src_training_human_pattern_extractor_py_precompute_features", + "target": "src_training_human_pattern_extractor_py_precompute_features_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.5, + "_src": "src_training_human_pattern_extractor_py_forward", + "_tgt": "src_training_human_pattern_extractor_py_forward_doc", + "source": "src_training_human_pattern_extractor_py_forward", + "target": "src_training_human_pattern_extractor_py_forward_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.5, + "_src": "src_training_human_pattern_extractor_py_score", + "_tgt": "src_training_human_pattern_extractor_py_score_doc", + "source": "src_training_human_pattern_extractor_py_score", + "target": "src_training_human_pattern_extractor_py_score_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/human_pattern_extractor.py", + "weight": 0.8, + "_src": "src_training_human_pattern_extractor_py_score", + "_tgt": "src_training_loss_functions_py_forward", + "source": "src_training_human_pattern_extractor_py_score", + "target": "src_training_loss_functions_py_forward" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py__human_pattern_loss", + "_tgt": "src_training_human_pattern_extractor_py_score", + "source": "src_training_human_pattern_extractor_py_score", + "target": "src_training_loss_functions_py__human_pattern_loss" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/vocabulary/register_filter.py", + "weight": 0.8, + "_src": "src_vocabulary_register_filter_py_check_formality", + "_tgt": "src_training_human_pattern_extractor_py_score", + "source": "src_training_human_pattern_extractor_py_score", + "target": "src_vocabulary_register_filter_py_check_formality" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 0.5, + "_src": "src_training_loss_functions_py", + "_tgt": "src_training_loss_functions_py_docstring", + "source": "src_training_loss_functions_py", + "target": "src_training_loss_functions_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 1.0, + "_src": "src_training_loss_functions_py", + "_tgt": "src_training_loss_functions_py_CombinedCorrectionLoss", + "source": "src_training_loss_functions_py", + "target": "src_training_loss_functions_py_CombinedCorrectionLoss" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 1.0, + "_src": "src_training_loss_functions_py", + "_tgt": "src_training_loss_functions_py_CombinedCorrectionLossV2", + "source": "src_training_loss_functions_py", + "target": "src_training_loss_functions_py_CombinedCorrectionLossV2" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 1.0, + "_src": "src_training_loss_functions_py", + "_tgt": "src_training_loss_functions_py___init__", + "source": "src_training_loss_functions_py", + "target": "src_training_loss_functions_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 1.0, + "_src": "src_training_loss_functions_py", + "_tgt": "src_training_loss_functions_py__style_loss", + "source": "src_training_loss_functions_py", + "target": "src_training_loss_functions_py__style_loss" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 1.0, + "_src": "src_training_loss_functions_py", + "_tgt": "src_training_loss_functions_py__semantic_loss", + "source": "src_training_loss_functions_py", + "target": "src_training_loss_functions_py__semantic_loss" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 1.0, + "_src": "src_training_loss_functions_py", + "_tgt": "src_training_loss_functions_py_forward", + "source": "src_training_loss_functions_py", + "target": "src_training_loss_functions_py_forward" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 1.0, + "_src": "src_training_loss_functions_py", + "_tgt": "src_training_loss_functions_py__human_pattern_loss", + "source": "src_training_loss_functions_py", + "target": "src_training_loss_functions_py__human_pattern_loss" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 0.5, + "_src": "src_training_loss_functions_py_CombinedCorrectionLoss", + "_tgt": "src_training_loss_functions_py_CombinedCorrectionLoss_doc", + "source": "src_training_loss_functions_py_CombinedCorrectionLoss", + "target": "src_training_loss_functions_py_CombinedCorrectionLoss_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 0.5, + "_src": "src_training_loss_functions_py_CombinedCorrectionLossV2", + "_tgt": "src_training_loss_functions_py_CombinedCorrectionLossV2_doc", + "source": "src_training_loss_functions_py_CombinedCorrectionLossV2", + "target": "src_training_loss_functions_py_CombinedCorrectionLossV2_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_training_loss_functions_py___init__", + "source": "src_training_loss_functions_py___init__", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_vocabulary_awl_loader_py___init__", + "source": "src_training_loss_functions_py___init__", + "target": "src_vocabulary_awl_loader_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_vocabulary_lexical_substitution_py___init__", + "source": "src_training_loss_functions_py___init__", + "target": "src_vocabulary_lexical_substitution_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py___init__", + "_tgt": "src_vocabulary_register_filter_py___init__", + "source": "src_training_loss_functions_py___init__", + "target": "src_vocabulary_register_filter_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 0.5, + "_src": "src_training_loss_functions_py__style_loss", + "_tgt": "src_training_loss_functions_py__style_loss_doc", + "source": "src_training_loss_functions_py__style_loss", + "target": "src_training_loss_functions_py__style_loss_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py_forward", + "_tgt": "src_training_loss_functions_py__style_loss", + "source": "src_training_loss_functions_py__style_loss", + "target": "src_training_loss_functions_py_forward" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 0.5, + "_src": "src_training_loss_functions_py__semantic_loss", + "_tgt": "src_training_loss_functions_py__semantic_loss_doc", + "source": "src_training_loss_functions_py__semantic_loss", + "target": "src_training_loss_functions_py__semantic_loss_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py_forward", + "_tgt": "src_training_loss_functions_py__semantic_loss", + "source": "src_training_loss_functions_py__semantic_loss", + "target": "src_training_loss_functions_py_forward" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 0.5, + "_src": "src_training_loss_functions_py_forward", + "_tgt": "src_training_loss_functions_py_forward_doc", + "source": "src_training_loss_functions_py_forward", + "target": "src_training_loss_functions_py_forward_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/loss_functions.py", + "weight": 0.8, + "_src": "src_training_loss_functions_py_forward", + "_tgt": "src_training_loss_functions_py__human_pattern_loss", + "source": "src_training_loss_functions_py_forward", + "target": "src_training_loss_functions_py__human_pattern_loss" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/loss_functions.py", + "weight": 0.5, + "_src": "src_training_loss_functions_py__human_pattern_loss", + "_tgt": "src_training_loss_functions_py__human_pattern_loss_doc", + "source": "src_training_loss_functions_py__human_pattern_loss", + "target": "src_training_loss_functions_py__human_pattern_loss_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/trainer.py", + "weight": 0.5, + "_src": "src_training_trainer_py", + "_tgt": "src_training_trainer_py_docstring", + "source": "src_training_trainer_py", + "target": "src_training_trainer_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/trainer.py", + "weight": 1.0, + "_src": "src_training_trainer_py", + "_tgt": "src_training_trainer_py_CorrectionTrainer", + "source": "src_training_trainer_py", + "target": "src_training_trainer_py_CorrectionTrainer" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/trainer.py", + "weight": 1.0, + "_src": "src_training_trainer_py", + "_tgt": "src_training_trainer_py___init__", + "source": "src_training_trainer_py", + "target": "src_training_trainer_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/trainer.py", + "weight": 1.0, + "_src": "src_training_trainer_py", + "_tgt": "src_training_trainer_py__strip_custom_fields", + "source": "src_training_trainer_py", + "target": "src_training_trainer_py__strip_custom_fields" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/trainer.py", + "weight": 1.0, + "_src": "src_training_trainer_py", + "_tgt": "src_training_trainer_py_compute_loss", + "source": "src_training_trainer_py", + "target": "src_training_trainer_py_compute_loss" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/trainer.py", + "weight": 1.0, + "_src": "src_training_trainer_py", + "_tgt": "src_training_trainer_py_prediction_step", + "source": "src_training_trainer_py", + "target": "src_training_trainer_py_prediction_step" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/trainer.py", + "weight": 0.5, + "_src": "src_training_trainer_py_CorrectionTrainer", + "_tgt": "src_training_trainer_py_CorrectionTrainer_doc", + "source": "src_training_trainer_py_CorrectionTrainer", + "target": "src_training_trainer_py_CorrectionTrainer_doc" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_vocabulary_awl_loader_py___init__", + "source": "src_training_trainer_py___init__", + "target": "src_vocabulary_awl_loader_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_vocabulary_lexical_substitution_py___init__", + "source": "src_training_trainer_py___init__", + "target": "src_vocabulary_lexical_substitution_py___init__" + }, + { + "relation": "calls", + "confidence": "INFERRED", + "confidence_score": 0.6, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py___init__", + "_tgt": "src_vocabulary_register_filter_py___init__", + "source": "src_training_trainer_py___init__", + "target": "src_vocabulary_register_filter_py___init__" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/trainer.py", + "weight": 0.5, + "_src": "src_training_trainer_py__strip_custom_fields", + "_tgt": "src_training_trainer_py__strip_custom_fields_doc", + "source": "src_training_trainer_py__strip_custom_fields", + "target": "src_training_trainer_py__strip_custom_fields_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py_compute_loss", + "_tgt": "src_training_trainer_py__strip_custom_fields", + "source": "src_training_trainer_py__strip_custom_fields", + "target": "src_training_trainer_py_compute_loss" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/training/trainer.py", + "weight": 0.8, + "_src": "src_training_trainer_py_prediction_step", + "_tgt": "src_training_trainer_py__strip_custom_fields", + "source": "src_training_trainer_py__strip_custom_fields", + "target": "src_training_trainer_py_prediction_step" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/trainer.py", + "weight": 0.5, + "_src": "src_training_trainer_py_compute_loss", + "_tgt": "src_training_trainer_py_compute_loss_doc", + "source": "src_training_trainer_py_compute_loss", + "target": "src_training_trainer_py_compute_loss_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/training/trainer.py", + "weight": 0.5, + "_src": "src_training_trainer_py_prediction_step", + "_tgt": "src_training_trainer_py_prediction_step_doc", + "source": "src_training_trainer_py_prediction_step", + "target": "src_training_trainer_py_prediction_step_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 0.5, + "_src": "src_vocabulary_awl_loader_py", + "_tgt": "src_vocabulary_awl_loader_py_docstring", + "source": "src_vocabulary_awl_loader_py", + "target": "src_vocabulary_awl_loader_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 1.0, + "_src": "src_vocabulary_awl_loader_py", + "_tgt": "src_vocabulary_awl_loader_py_AWLLoader", + "source": "src_vocabulary_awl_loader_py", + "target": "src_vocabulary_awl_loader_py_AWLLoader" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 1.0, + "_src": "src_vocabulary_awl_loader_py", + "_tgt": "src_vocabulary_awl_loader_py___init__", + "source": "src_vocabulary_awl_loader_py", + "target": "src_vocabulary_awl_loader_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 1.0, + "_src": "src_vocabulary_awl_loader_py", + "_tgt": "src_vocabulary_awl_loader_py__load_word_list", + "source": "src_vocabulary_awl_loader_py", + "target": "src_vocabulary_awl_loader_py__load_word_list" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 1.0, + "_src": "src_vocabulary_awl_loader_py", + "_tgt": "src_vocabulary_awl_loader_py__load_synonyms", + "source": "src_vocabulary_awl_loader_py", + "target": "src_vocabulary_awl_loader_py__load_synonyms" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 1.0, + "_src": "src_vocabulary_awl_loader_py", + "_tgt": "src_vocabulary_awl_loader_py_is_academic", + "source": "src_vocabulary_awl_loader_py", + "target": "src_vocabulary_awl_loader_py_is_academic" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 1.0, + "_src": "src_vocabulary_awl_loader_py", + "_tgt": "src_vocabulary_awl_loader_py_get_academic_synonyms", + "source": "src_vocabulary_awl_loader_py", + "target": "src_vocabulary_awl_loader_py_get_academic_synonyms" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 1.0, + "_src": "src_vocabulary_awl_loader_py", + "_tgt": "src_vocabulary_awl_loader_py_all_words", + "source": "src_vocabulary_awl_loader_py", + "target": "src_vocabulary_awl_loader_py_all_words" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 0.6, + "_src": "tests_test_evaluation_py", + "_tgt": "src_vocabulary_awl_loader_py", + "source": "src_vocabulary_awl_loader_py", + "target": "tests_test_evaluation_py" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_vocabulary.py", + "weight": 0.6, + "_src": "tests_test_vocabulary_py", + "_tgt": "src_vocabulary_awl_loader_py", + "source": "src_vocabulary_awl_loader_py", + "target": "tests_test_vocabulary_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 0.5, + "_src": "src_vocabulary_awl_loader_py_AWLLoader", + "_tgt": "src_vocabulary_awl_loader_py_AWLLoader_doc", + "source": "src_vocabulary_awl_loader_py_AWLLoader", + "target": "src_vocabulary_awl_loader_py_AWLLoader_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 0.8, + "_src": "src_vocabulary_awl_loader_py___init__", + "_tgt": "src_vocabulary_awl_loader_py__load_word_list", + "source": "src_vocabulary_awl_loader_py___init__", + "target": "src_vocabulary_awl_loader_py__load_word_list" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 0.8, + "_src": "src_vocabulary_awl_loader_py___init__", + "_tgt": "src_vocabulary_awl_loader_py__load_synonyms", + "source": "src_vocabulary_awl_loader_py___init__", + "target": "src_vocabulary_awl_loader_py__load_synonyms" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 0.5, + "_src": "src_vocabulary_awl_loader_py__load_word_list", + "_tgt": "src_vocabulary_awl_loader_py__load_word_list_doc", + "source": "src_vocabulary_awl_loader_py__load_word_list", + "target": "src_vocabulary_awl_loader_py__load_word_list_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 0.5, + "_src": "src_vocabulary_awl_loader_py__load_synonyms", + "_tgt": "src_vocabulary_awl_loader_py__load_synonyms_doc", + "source": "src_vocabulary_awl_loader_py__load_synonyms", + "target": "src_vocabulary_awl_loader_py__load_synonyms_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 0.5, + "_src": "src_vocabulary_awl_loader_py_is_academic", + "_tgt": "src_vocabulary_awl_loader_py_is_academic_doc", + "source": "src_vocabulary_awl_loader_py_is_academic", + "target": "src_vocabulary_awl_loader_py_is_academic_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 0.8, + "_src": "src_vocabulary_lexical_substitution_py__get_awl_substitutions", + "_tgt": "src_vocabulary_awl_loader_py_is_academic", + "source": "src_vocabulary_awl_loader_py_is_academic", + "target": "src_vocabulary_lexical_substitution_py__get_awl_substitutions" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 0.8, + "_src": "src_vocabulary_lexical_substitution_py_elevate", + "_tgt": "src_vocabulary_awl_loader_py_is_academic", + "source": "src_vocabulary_awl_loader_py_is_academic", + "target": "src_vocabulary_lexical_substitution_py_elevate" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_vocabulary.py", + "weight": 0.8, + "_src": "tests_test_vocabulary_py_test_awl_membership", + "_tgt": "src_vocabulary_awl_loader_py_is_academic", + "source": "src_vocabulary_awl_loader_py_is_academic", + "target": "tests_test_vocabulary_py_test_awl_membership" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 0.5, + "_src": "src_vocabulary_awl_loader_py_get_academic_synonyms", + "_tgt": "src_vocabulary_awl_loader_py_get_academic_synonyms_doc", + "source": "src_vocabulary_awl_loader_py_get_academic_synonyms", + "target": "src_vocabulary_awl_loader_py_get_academic_synonyms_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/awl_loader.py", + "weight": 0.5, + "_src": "src_vocabulary_awl_loader_py_all_words", + "_tgt": "src_vocabulary_awl_loader_py_all_words_doc", + "source": "src_vocabulary_awl_loader_py_all_words", + "target": "src_vocabulary_awl_loader_py_all_words_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 0.5, + "_src": "src_vocabulary_lexical_substitution_py", + "_tgt": "src_vocabulary_lexical_substitution_py_docstring", + "source": "src_vocabulary_lexical_substitution_py", + "target": "src_vocabulary_lexical_substitution_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 1.0, + "_src": "src_vocabulary_lexical_substitution_py", + "_tgt": "src_vocabulary_lexical_substitution_py_LexicalElevator", + "source": "src_vocabulary_lexical_substitution_py", + "target": "src_vocabulary_lexical_substitution_py_LexicalElevator" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 1.0, + "_src": "src_vocabulary_lexical_substitution_py", + "_tgt": "src_vocabulary_lexical_substitution_py_RegisterFilter", + "source": "src_vocabulary_lexical_substitution_py", + "target": "src_vocabulary_lexical_substitution_py_RegisterFilter" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 1.0, + "_src": "src_vocabulary_lexical_substitution_py", + "_tgt": "src_vocabulary_lexical_substitution_py___init__", + "source": "src_vocabulary_lexical_substitution_py", + "target": "src_vocabulary_lexical_substitution_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 1.0, + "_src": "src_vocabulary_lexical_substitution_py", + "_tgt": "src_vocabulary_lexical_substitution_py__sem_similarity", + "source": "src_vocabulary_lexical_substitution_py", + "target": "src_vocabulary_lexical_substitution_py__sem_similarity" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 1.0, + "_src": "src_vocabulary_lexical_substitution_py", + "_tgt": "src_vocabulary_lexical_substitution_py__get_awl_substitutions", + "source": "src_vocabulary_lexical_substitution_py", + "target": "src_vocabulary_lexical_substitution_py__get_awl_substitutions" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 1.0, + "_src": "src_vocabulary_lexical_substitution_py", + "_tgt": "src_vocabulary_lexical_substitution_py_elevate", + "source": "src_vocabulary_lexical_substitution_py", + "target": "src_vocabulary_lexical_substitution_py_elevate" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 1.0, + "_src": "src_vocabulary_lexical_substitution_py", + "_tgt": "src_vocabulary_lexical_substitution_py_apply", + "source": "src_vocabulary_lexical_substitution_py", + "target": "src_vocabulary_lexical_substitution_py_apply" + }, + { + "relation": "imports", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_vocabulary.py", + "weight": 0.6, + "_src": "tests_test_vocabulary_py", + "_tgt": "src_vocabulary_lexical_substitution_py", + "source": "src_vocabulary_lexical_substitution_py", + "target": "tests_test_vocabulary_py" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 0.5, + "_src": "src_vocabulary_lexical_substitution_py_LexicalElevator", + "_tgt": "src_vocabulary_lexical_substitution_py_LexicalElevator_doc", + "source": "src_vocabulary_lexical_substitution_py_LexicalElevator", + "target": "src_vocabulary_lexical_substitution_py_LexicalElevator_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 0.5, + "_src": "src_vocabulary_lexical_substitution_py_RegisterFilter", + "_tgt": "src_vocabulary_lexical_substitution_py_RegisterFilter_doc", + "source": "src_vocabulary_lexical_substitution_py_RegisterFilter", + "target": "src_vocabulary_lexical_substitution_py_RegisterFilter_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 0.5, + "_src": "src_vocabulary_lexical_substitution_py__sem_similarity", + "_tgt": "src_vocabulary_lexical_substitution_py__sem_similarity_doc", + "source": "src_vocabulary_lexical_substitution_py__sem_similarity", + "target": "src_vocabulary_lexical_substitution_py__sem_similarity_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 0.8, + "_src": "src_vocabulary_lexical_substitution_py_elevate", + "_tgt": "src_vocabulary_lexical_substitution_py__sem_similarity", + "source": "src_vocabulary_lexical_substitution_py__sem_similarity", + "target": "src_vocabulary_lexical_substitution_py_elevate" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 0.5, + "_src": "src_vocabulary_lexical_substitution_py__get_awl_substitutions", + "_tgt": "src_vocabulary_lexical_substitution_py__get_awl_substitutions_doc", + "source": "src_vocabulary_lexical_substitution_py__get_awl_substitutions", + "target": "src_vocabulary_lexical_substitution_py__get_awl_substitutions_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 0.8, + "_src": "src_vocabulary_lexical_substitution_py_elevate", + "_tgt": "src_vocabulary_lexical_substitution_py__get_awl_substitutions", + "source": "src_vocabulary_lexical_substitution_py__get_awl_substitutions", + "target": "src_vocabulary_lexical_substitution_py_elevate" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 0.5, + "_src": "src_vocabulary_lexical_substitution_py_elevate", + "_tgt": "src_vocabulary_lexical_substitution_py_elevate_doc", + "source": "src_vocabulary_lexical_substitution_py_elevate", + "target": "src_vocabulary_lexical_substitution_py_elevate_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/lexical_substitution.py", + "weight": 0.5, + "_src": "src_vocabulary_lexical_substitution_py_apply", + "_tgt": "src_vocabulary_lexical_substitution_py_apply_doc", + "source": "src_vocabulary_lexical_substitution_py_apply", + "target": "src_vocabulary_lexical_substitution_py_apply_doc" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_vocabulary.py", + "weight": 0.8, + "_src": "tests_test_vocabulary_py_test_register_filter_contractions", + "_tgt": "src_vocabulary_lexical_substitution_py_apply", + "source": "src_vocabulary_lexical_substitution_py_apply", + "target": "tests_test_vocabulary_py_test_register_filter_contractions" + }, + { + "relation": "calls", + "confidence": "EXTRACTED", + "confidence_score": 0.9, + "source_file": "tests/test_vocabulary.py", + "weight": 0.8, + "_src": "tests_test_vocabulary_py_test_register_filter_colloquialisms", + "_tgt": "src_vocabulary_lexical_substitution_py_apply", + "source": "src_vocabulary_lexical_substitution_py_apply", + "target": "tests_test_vocabulary_py_test_register_filter_colloquialisms" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/register_filter.py", + "weight": 0.5, + "_src": "src_vocabulary_register_filter_py", + "_tgt": "src_vocabulary_register_filter_py_docstring", + "source": "src_vocabulary_register_filter_py", + "target": "src_vocabulary_register_filter_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/register_filter.py", + "weight": 1.0, + "_src": "src_vocabulary_register_filter_py", + "_tgt": "src_vocabulary_register_filter_py_RegisterFilterAdvanced", + "source": "src_vocabulary_register_filter_py", + "target": "src_vocabulary_register_filter_py_RegisterFilterAdvanced" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/register_filter.py", + "weight": 1.0, + "_src": "src_vocabulary_register_filter_py", + "_tgt": "src_vocabulary_register_filter_py___init__", + "source": "src_vocabulary_register_filter_py", + "target": "src_vocabulary_register_filter_py___init__" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/register_filter.py", + "weight": 1.0, + "_src": "src_vocabulary_register_filter_py", + "_tgt": "src_vocabulary_register_filter_py_nominalise", + "source": "src_vocabulary_register_filter_py", + "target": "src_vocabulary_register_filter_py_nominalise" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/register_filter.py", + "weight": 1.0, + "_src": "src_vocabulary_register_filter_py", + "_tgt": "src_vocabulary_register_filter_py_add_hedging", + "source": "src_vocabulary_register_filter_py", + "target": "src_vocabulary_register_filter_py_add_hedging" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/register_filter.py", + "weight": 1.0, + "_src": "src_vocabulary_register_filter_py", + "_tgt": "src_vocabulary_register_filter_py_check_formality", + "source": "src_vocabulary_register_filter_py", + "target": "src_vocabulary_register_filter_py_check_formality" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/register_filter.py", + "weight": 0.5, + "_src": "src_vocabulary_register_filter_py_RegisterFilterAdvanced", + "_tgt": "src_vocabulary_register_filter_py_RegisterFilterAdvanced_doc", + "source": "src_vocabulary_register_filter_py_RegisterFilterAdvanced", + "target": "src_vocabulary_register_filter_py_RegisterFilterAdvanced_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/register_filter.py", + "weight": 0.5, + "_src": "src_vocabulary_register_filter_py_nominalise", + "_tgt": "src_vocabulary_register_filter_py_nominalise_doc", + "source": "src_vocabulary_register_filter_py_nominalise", + "target": "src_vocabulary_register_filter_py_nominalise_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/register_filter.py", + "weight": 0.5, + "_src": "src_vocabulary_register_filter_py_add_hedging", + "_tgt": "src_vocabulary_register_filter_py_add_hedging_doc", + "source": "src_vocabulary_register_filter_py_add_hedging", + "target": "src_vocabulary_register_filter_py_add_hedging_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "src/vocabulary/register_filter.py", + "weight": 0.5, + "_src": "src_vocabulary_register_filter_py_check_formality", + "_tgt": "src_vocabulary_register_filter_py_check_formality_doc", + "source": "src_vocabulary_register_filter_py_check_formality", + "target": "src_vocabulary_register_filter_py_check_formality_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 0.5, + "_src": "tests_test_evaluation_py", + "_tgt": "tests_test_evaluation_py_docstring", + "source": "tests_test_evaluation_py", + "target": "tests_test_evaluation_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 1.0, + "_src": "tests_test_evaluation_py", + "_tgt": "tests_test_evaluation_py_test_gleu_scorer_instantiation", + "source": "tests_test_evaluation_py", + "target": "tests_test_evaluation_py_test_gleu_scorer_instantiation" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 1.0, + "_src": "tests_test_evaluation_py", + "_tgt": "tests_test_evaluation_py_test_gleu_perfect_score", + "source": "tests_test_evaluation_py", + "target": "tests_test_evaluation_py_test_gleu_perfect_score" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 1.0, + "_src": "tests_test_evaluation_py", + "_tgt": "tests_test_evaluation_py_test_gleu_empty_input", + "source": "tests_test_evaluation_py", + "target": "tests_test_evaluation_py_test_gleu_empty_input" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 1.0, + "_src": "tests_test_evaluation_py", + "_tgt": "tests_test_evaluation_py_test_awl_coverage_score", + "source": "tests_test_evaluation_py", + "target": "tests_test_evaluation_py_test_awl_coverage_score" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 0.5, + "_src": "tests_test_evaluation_py_test_gleu_scorer_instantiation", + "_tgt": "tests_test_evaluation_py_test_gleu_scorer_instantiation_doc", + "source": "tests_test_evaluation_py_test_gleu_scorer_instantiation", + "target": "tests_test_evaluation_py_test_gleu_scorer_instantiation_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 0.5, + "_src": "tests_test_evaluation_py_test_gleu_perfect_score", + "_tgt": "tests_test_evaluation_py_test_gleu_perfect_score_doc", + "source": "tests_test_evaluation_py_test_gleu_perfect_score", + "target": "tests_test_evaluation_py_test_gleu_perfect_score_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 0.5, + "_src": "tests_test_evaluation_py_test_gleu_empty_input", + "_tgt": "tests_test_evaluation_py_test_gleu_empty_input_doc", + "source": "tests_test_evaluation_py_test_gleu_empty_input", + "target": "tests_test_evaluation_py_test_gleu_empty_input_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_evaluation.py", + "weight": 0.5, + "_src": "tests_test_evaluation_py_test_awl_coverage_score", + "_tgt": "tests_test_evaluation_py_test_awl_coverage_score_doc", + "source": "tests_test_evaluation_py_test_awl_coverage_score", + "target": "tests_test_evaluation_py_test_awl_coverage_score_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 0.5, + "_src": "tests_test_model_py", + "_tgt": "tests_test_model_py_docstring", + "source": "tests_test_model_py", + "target": "tests_test_model_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 1.0, + "_src": "tests_test_model_py", + "_tgt": "tests_test_model_py_test_model_registry_populated", + "source": "tests_test_model_py", + "target": "tests_test_model_py_test_model_registry_populated" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 1.0, + "_src": "tests_test_model_py", + "_tgt": "tests_test_model_py_test_invalid_model_key", + "source": "tests_test_model_py", + "target": "tests_test_model_py_test_invalid_model_key" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 1.0, + "_src": "tests_test_model_py", + "_tgt": "tests_test_model_py_test_style_conditioner_output_shape", + "source": "tests_test_model_py", + "target": "tests_test_model_py_test_style_conditioner_output_shape" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 1.0, + "_src": "tests_test_model_py", + "_tgt": "tests_test_model_py_test_prepend_style_prefix", + "source": "tests_test_model_py", + "target": "tests_test_model_py_test_prepend_style_prefix" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 1.0, + "_src": "tests_test_model_py", + "_tgt": "tests_test_model_py_test_lora_config_creation", + "source": "tests_test_model_py", + "target": "tests_test_model_py_test_lora_config_creation" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 0.5, + "_src": "tests_test_model_py_test_model_registry_populated", + "_tgt": "tests_test_model_py_test_model_registry_populated_doc", + "source": "tests_test_model_py_test_model_registry_populated", + "target": "tests_test_model_py_test_model_registry_populated_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 0.5, + "_src": "tests_test_model_py_test_invalid_model_key", + "_tgt": "tests_test_model_py_test_invalid_model_key_doc", + "source": "tests_test_model_py_test_invalid_model_key", + "target": "tests_test_model_py_test_invalid_model_key_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 0.5, + "_src": "tests_test_model_py_test_style_conditioner_output_shape", + "_tgt": "tests_test_model_py_test_style_conditioner_output_shape_doc", + "source": "tests_test_model_py_test_style_conditioner_output_shape", + "target": "tests_test_model_py_test_style_conditioner_output_shape_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 0.5, + "_src": "tests_test_model_py_test_prepend_style_prefix", + "_tgt": "tests_test_model_py_test_prepend_style_prefix_doc", + "source": "tests_test_model_py_test_prepend_style_prefix", + "target": "tests_test_model_py_test_prepend_style_prefix_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_model.py", + "weight": 0.5, + "_src": "tests_test_model_py_test_lora_config_creation", + "_tgt": "tests_test_model_py_test_lora_config_creation_doc", + "source": "tests_test_model_py_test_lora_config_creation", + "target": "tests_test_model_py_test_lora_config_creation_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.5, + "_src": "tests_test_preprocessing_py", + "_tgt": "tests_test_preprocessing_py_docstring", + "source": "tests_test_preprocessing_py", + "target": "tests_test_preprocessing_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 1.0, + "_src": "tests_test_preprocessing_py", + "_tgt": "tests_test_preprocessing_py_simulator", + "source": "tests_test_preprocessing_py", + "target": "tests_test_preprocessing_py_simulator" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 1.0, + "_src": "tests_test_preprocessing_py", + "_tgt": "tests_test_preprocessing_py_corrector", + "source": "tests_test_preprocessing_py", + "target": "tests_test_preprocessing_py_corrector" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 1.0, + "_src": "tests_test_preprocessing_py", + "_tgt": "tests_test_preprocessing_py_test_spell_correction_phonetic", + "source": "tests_test_preprocessing_py", + "target": "tests_test_preprocessing_py_test_spell_correction_phonetic" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 1.0, + "_src": "tests_test_preprocessing_py", + "_tgt": "tests_test_preprocessing_py_test_spell_correction_empty", + "source": "tests_test_preprocessing_py", + "target": "tests_test_preprocessing_py_test_spell_correction_empty" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 1.0, + "_src": "tests_test_preprocessing_py", + "_tgt": "tests_test_preprocessing_py_test_entity_protection", + "source": "tests_test_preprocessing_py", + "target": "tests_test_preprocessing_py_test_entity_protection" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 1.0, + "_src": "tests_test_preprocessing_py", + "_tgt": "tests_test_preprocessing_py_test_sentence_segmentation", + "source": "tests_test_preprocessing_py", + "target": "tests_test_preprocessing_py_test_sentence_segmentation" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 1.0, + "_src": "tests_test_preprocessing_py", + "_tgt": "tests_test_preprocessing_py_test_readability_scores", + "source": "tests_test_preprocessing_py", + "target": "tests_test_preprocessing_py_test_readability_scores" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 1.0, + "_src": "tests_test_preprocessing_py", + "_tgt": "tests_test_preprocessing_py_test_dependency_trees", + "source": "tests_test_preprocessing_py", + "target": "tests_test_preprocessing_py_test_dependency_trees" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 1.0, + "_src": "tests_test_preprocessing_py", + "_tgt": "tests_test_preprocessing_py_test_dyslexia_simulator", + "source": "tests_test_preprocessing_py", + "target": "tests_test_preprocessing_py_test_dyslexia_simulator" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 1.0, + "_src": "tests_test_preprocessing_py", + "_tgt": "tests_test_preprocessing_py_test_dyslexia_simulator_preserves_clean", + "source": "tests_test_preprocessing_py", + "target": "tests_test_preprocessing_py_test_dyslexia_simulator_preserves_clean" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.5, + "_src": "tests_test_preprocessing_py_test_spell_correction_phonetic", + "_tgt": "tests_test_preprocessing_py_test_spell_correction_phonetic_doc", + "source": "tests_test_preprocessing_py_test_spell_correction_phonetic", + "target": "tests_test_preprocessing_py_test_spell_correction_phonetic_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.5, + "_src": "tests_test_preprocessing_py_test_spell_correction_empty", + "_tgt": "tests_test_preprocessing_py_test_spell_correction_empty_doc", + "source": "tests_test_preprocessing_py_test_spell_correction_empty", + "target": "tests_test_preprocessing_py_test_spell_correction_empty_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.5, + "_src": "tests_test_preprocessing_py_test_entity_protection", + "_tgt": "tests_test_preprocessing_py_test_entity_protection_doc", + "source": "tests_test_preprocessing_py_test_entity_protection", + "target": "tests_test_preprocessing_py_test_entity_protection_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.5, + "_src": "tests_test_preprocessing_py_test_sentence_segmentation", + "_tgt": "tests_test_preprocessing_py_test_sentence_segmentation_doc", + "source": "tests_test_preprocessing_py_test_sentence_segmentation", + "target": "tests_test_preprocessing_py_test_sentence_segmentation_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.5, + "_src": "tests_test_preprocessing_py_test_readability_scores", + "_tgt": "tests_test_preprocessing_py_test_readability_scores_doc", + "source": "tests_test_preprocessing_py_test_readability_scores", + "target": "tests_test_preprocessing_py_test_readability_scores_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.5, + "_src": "tests_test_preprocessing_py_test_dependency_trees", + "_tgt": "tests_test_preprocessing_py_test_dependency_trees_doc", + "source": "tests_test_preprocessing_py_test_dependency_trees", + "target": "tests_test_preprocessing_py_test_dependency_trees_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.5, + "_src": "tests_test_preprocessing_py_test_dyslexia_simulator", + "_tgt": "tests_test_preprocessing_py_test_dyslexia_simulator_doc", + "source": "tests_test_preprocessing_py_test_dyslexia_simulator", + "target": "tests_test_preprocessing_py_test_dyslexia_simulator_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_preprocessing.py", + "weight": 0.5, + "_src": "tests_test_preprocessing_py_test_dyslexia_simulator_preserves_clean", + "_tgt": "tests_test_preprocessing_py_test_dyslexia_simulator_preserves_clean_doc", + "source": "tests_test_preprocessing_py_test_dyslexia_simulator_preserves_clean", + "target": "tests_test_preprocessing_py_test_dyslexia_simulator_preserves_clean_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_style.py", + "weight": 0.5, + "_src": "tests_test_style_py", + "_tgt": "tests_test_style_py_docstring", + "source": "tests_test_style_py", + "target": "tests_test_style_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_style.py", + "weight": 1.0, + "_src": "tests_test_style_py", + "_tgt": "tests_test_style_py_fingerprinter", + "source": "tests_test_style_py", + "target": "tests_test_style_py_fingerprinter" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_style.py", + "weight": 1.0, + "_src": "tests_test_style_py", + "_tgt": "tests_test_style_py_test_style_vector_shape", + "source": "tests_test_style_py", + "target": "tests_test_style_py_test_style_vector_shape" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_style.py", + "weight": 1.0, + "_src": "tests_test_style_py", + "_tgt": "tests_test_style_py_test_style_vector_different_texts", + "source": "tests_test_style_py", + "target": "tests_test_style_py_test_style_vector_different_texts" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_style.py", + "weight": 1.0, + "_src": "tests_test_style_py", + "_tgt": "tests_test_style_py_test_style_blend", + "source": "tests_test_style_py", + "target": "tests_test_style_py_test_style_blend" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_style.py", + "weight": 1.0, + "_src": "tests_test_style_py", + "_tgt": "tests_test_style_py_test_raw_features_keys", + "source": "tests_test_style_py", + "target": "tests_test_style_py_test_raw_features_keys" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_style.py", + "weight": 0.5, + "_src": "tests_test_style_py_test_style_vector_shape", + "_tgt": "tests_test_style_py_test_style_vector_shape_doc", + "source": "tests_test_style_py_test_style_vector_shape", + "target": "tests_test_style_py_test_style_vector_shape_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_style.py", + "weight": 0.5, + "_src": "tests_test_style_py_test_style_vector_different_texts", + "_tgt": "tests_test_style_py_test_style_vector_different_texts_doc", + "source": "tests_test_style_py_test_style_vector_different_texts", + "target": "tests_test_style_py_test_style_vector_different_texts_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_style.py", + "weight": 0.5, + "_src": "tests_test_style_py_test_style_blend", + "_tgt": "tests_test_style_py_test_style_blend_doc", + "source": "tests_test_style_py_test_style_blend", + "target": "tests_test_style_py_test_style_blend_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_style.py", + "weight": 0.5, + "_src": "tests_test_style_py_test_raw_features_keys", + "_tgt": "tests_test_style_py_test_raw_features_keys_doc", + "source": "tests_test_style_py_test_raw_features_keys", + "target": "tests_test_style_py_test_raw_features_keys_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_vocabulary.py", + "weight": 0.5, + "_src": "tests_test_vocabulary_py", + "_tgt": "tests_test_vocabulary_py_docstring", + "source": "tests_test_vocabulary_py", + "target": "tests_test_vocabulary_py_docstring" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_vocabulary.py", + "weight": 1.0, + "_src": "tests_test_vocabulary_py", + "_tgt": "tests_test_vocabulary_py_test_awl_loader", + "source": "tests_test_vocabulary_py", + "target": "tests_test_vocabulary_py_test_awl_loader" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_vocabulary.py", + "weight": 1.0, + "_src": "tests_test_vocabulary_py", + "_tgt": "tests_test_vocabulary_py_test_awl_membership", + "source": "tests_test_vocabulary_py", + "target": "tests_test_vocabulary_py_test_awl_membership" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_vocabulary.py", + "weight": 1.0, + "_src": "tests_test_vocabulary_py", + "_tgt": "tests_test_vocabulary_py_test_register_filter_contractions", + "source": "tests_test_vocabulary_py", + "target": "tests_test_vocabulary_py_test_register_filter_contractions" + }, + { + "relation": "defines", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_vocabulary.py", + "weight": 1.0, + "_src": "tests_test_vocabulary_py", + "_tgt": "tests_test_vocabulary_py_test_register_filter_colloquialisms", + "source": "tests_test_vocabulary_py", + "target": "tests_test_vocabulary_py_test_register_filter_colloquialisms" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_vocabulary.py", + "weight": 0.5, + "_src": "tests_test_vocabulary_py_test_awl_loader", + "_tgt": "tests_test_vocabulary_py_test_awl_loader_doc", + "source": "tests_test_vocabulary_py_test_awl_loader", + "target": "tests_test_vocabulary_py_test_awl_loader_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_vocabulary.py", + "weight": 0.5, + "_src": "tests_test_vocabulary_py_test_awl_membership", + "_tgt": "tests_test_vocabulary_py_test_awl_membership_doc", + "source": "tests_test_vocabulary_py_test_awl_membership", + "target": "tests_test_vocabulary_py_test_awl_membership_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_vocabulary.py", + "weight": 0.5, + "_src": "tests_test_vocabulary_py_test_register_filter_contractions", + "_tgt": "tests_test_vocabulary_py_test_register_filter_contractions_doc", + "source": "tests_test_vocabulary_py_test_register_filter_contractions", + "target": "tests_test_vocabulary_py_test_register_filter_contractions_doc" + }, + { + "relation": "has_rationale", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "tests/test_vocabulary.py", + "weight": 0.5, + "_src": "tests_test_vocabulary_py_test_register_filter_colloquialisms", + "_tgt": "tests_test_vocabulary_py_test_register_filter_colloquialisms_doc", + "source": "tests_test_vocabulary_py_test_register_filter_colloquialisms", + "target": "tests_test_vocabulary_py_test_register_filter_colloquialisms_doc" + }, + { + "relation": "implements", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_nudr_api", + "_tgt": "sem_fastapi_backend", + "source": "sem_nudr_api", + "target": "sem_fastapi_backend" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/feed_system_documentation.md", + "weight": 1.0, + "_src": "sem_feed_system", + "_tgt": "sem_nudr_api", + "source": "sem_nudr_api", + "target": "sem_feed_system" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/LOGIC_ANALYSIS.md", + "weight": 1.0, + "_src": "sem_logic_analysis", + "_tgt": "sem_nudr_api", + "source": "sem_nudr_api", + "target": "sem_logic_analysis" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_fastapi_backend", + "_tgt": "sem_supabase_db", + "source": "sem_fastapi_backend", + "target": "sem_supabase_db" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_fastapi_backend", + "_tgt": "sem_redis_cache", + "source": "sem_fastapi_backend", + "target": "sem_redis_cache" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_stripe_payments", + "_tgt": "sem_fastapi_backend", + "source": "sem_fastapi_backend", + "target": "sem_stripe_payments" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_firebase_fcm", + "_tgt": "sem_fastapi_backend", + "source": "sem_fastapi_backend", + "target": "sem_firebase_fcm" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/feed_system_documentation.md", + "weight": 1.0, + "_src": "sem_feed_pool", + "_tgt": "sem_supabase_db", + "source": "sem_supabase_db", + "target": "sem_feed_pool" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/LOGIC_ANALYSIS.md", + "weight": 1.0, + "_src": "sem_preference_race", + "_tgt": "sem_supabase_db", + "source": "sem_supabase_db", + "target": "sem_preference_race" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/feed_system_documentation.md", + "weight": 1.0, + "_src": "sem_feed_pool", + "_tgt": "sem_redis_cache", + "source": "sem_redis_cache", + "target": "sem_feed_pool" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/feed_system_documentation.md", + "weight": 1.0, + "_src": "sem_feed_redis", + "_tgt": "sem_redis_cache", + "source": "sem_redis_cache", + "target": "sem_feed_redis" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/LOGIC_ANALYSIS.md", + "weight": 1.0, + "_src": "sem_pubsub_crash", + "_tgt": "sem_redis_cache", + "source": "sem_redis_cache", + "target": "sem_pubsub_crash" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/LOGIC_ANALYSIS.md", + "weight": 1.0, + "_src": "sem_redis_pool_exhaustion", + "_tgt": "sem_redis_cache", + "source": "sem_redis_cache", + "target": "sem_redis_pool_exhaustion" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_cloudflare_proxy", + "_tgt": "sem_origin_secret", + "source": "sem_cloudflare_proxy", + "target": "sem_origin_secret" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_e2ee_encryption", + "_tgt": "sem_keysync_ws", + "source": "sem_e2ee_encryption", + "target": "sem_keysync_ws" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_protobuf_framing", + "_tgt": "sem_unified_ws", + "source": "sem_protobuf_framing", + "target": "sem_unified_ws" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_origin_secret", + "_tgt": "sem_lambda_rotator", + "source": "sem_origin_secret", + "target": "sem_lambda_rotator" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_attack_detection", + "_tgt": "sem_rate_limiting", + "source": "sem_rate_limiting", + "target": "sem_attack_detection" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_terraform_infra", + "_tgt": "sem_aws_secrets", + "source": "sem_aws_secrets", + "target": "sem_terraform_infra" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_terraform_infra", + "_tgt": "sem_vpc_network", + "source": "sem_terraform_infra", + "target": "sem_vpc_network" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_terraform_infra", + "_tgt": "sem_alb_autoscaling", + "source": "sem_terraform_infra", + "target": "sem_alb_autoscaling" + }, + { + "relation": "conceptually_related_to", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_unified_ws", + "_tgt": "sem_feed_ws", + "source": "sem_unified_ws", + "target": "sem_feed_ws" + }, + { + "relation": "conceptually_related_to", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_unified_ws", + "_tgt": "sem_chat_ws", + "source": "sem_unified_ws", + "target": "sem_chat_ws" + }, + { + "relation": "conceptually_related_to", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_unified_ws", + "_tgt": "sem_keysync_ws", + "source": "sem_unified_ws", + "target": "sem_keysync_ws" + }, + { + "relation": "conceptually_related_to", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md", + "weight": 1.0, + "_src": "sem_unified_ws", + "_tgt": "sem_discovery_ws", + "source": "sem_unified_ws", + "target": "sem_discovery_ws" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/LOGIC_ANALYSIS.md", + "weight": 1.0, + "_src": "sem_id_ws_reuse", + "_tgt": "sem_unified_ws", + "source": "sem_unified_ws", + "target": "sem_id_ws_reuse" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/LOGIC_ANALYSIS.md", + "weight": 1.0, + "_src": "sem_token_refresh_crash", + "_tgt": "sem_unified_ws", + "source": "sem_unified_ws", + "target": "sem_token_refresh_crash" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/feed_system_documentation.md", + "weight": 1.0, + "_src": "sem_feed_system", + "_tgt": "sem_feed_ws", + "source": "sem_feed_ws", + "target": "sem_feed_system" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/feed_system_documentation.md", + "weight": 1.0, + "_src": "sem_feed_scoring", + "_tgt": "sem_feed_pool", + "source": "sem_feed_scoring", + "target": "sem_feed_pool" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/feed_system_documentation.md", + "weight": 1.0, + "_src": "sem_feed_heatmap", + "_tgt": "sem_feed_scoring", + "source": "sem_feed_scoring", + "target": "sem_feed_heatmap" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/feed_system_documentation.md", + "weight": 1.0, + "_src": "sem_feed_reciprocal", + "_tgt": "sem_feed_scoring", + "source": "sem_feed_scoring", + "target": "sem_feed_reciprocal" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/feed_system_documentation.md", + "weight": 1.0, + "_src": "sem_feed_gradient", + "_tgt": "sem_feed_scoring", + "source": "sem_feed_scoring", + "target": "sem_feed_gradient" + }, + { + "relation": "references", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/feed_system_documentation.md", + "weight": 1.0, + "_src": "sem_feed_filters", + "_tgt": "sem_feed_pool", + "source": "sem_feed_pool", + "target": "sem_feed_filters" + } + ], + "hyperedges": [ + { + "id": "websocket_channels", + "label": "WebSocket Channel System", + "nodes": [ + "sem_unified_ws", + "sem_feed_ws", + "sem_chat_ws", + "sem_keysync_ws", + "sem_discovery_ws" + ], + "relation": "participate_in", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md" + }, + { + "id": "security_stack", + "label": "Security Defense Stack", + "nodes": [ + "sem_hmac_verification", + "sem_origin_secret", + "sem_pow_challenge", + "sem_rate_limiting", + "sem_attack_detection" + ], + "relation": "participate_in", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "README.md" + }, + { + "id": "feed_pipeline", + "label": "Feed Recommendation Pipeline", + "nodes": [ + "sem_feed_pool", + "sem_feed_filters", + "sem_feed_scoring", + "sem_feed_heatmap", + "sem_feed_reciprocal", + "sem_feed_gradient" + ], + "relation": "form", + "confidence": "EXTRACTED", + "confidence_score": 1.0, + "source_file": "PLAN/feed_system_documentation.md" + } + ] +} \ No newline at end of file