PROJECT_INDEX.json

{"at":"2025-11-04T17:07:12.174640","root":".","tree":[".","\u251c\u2500\u2500 docs/","\u251c\u2500\u2500 evals/ (8 files)","\u2502   \u2514\u2500\u2500 README.md","\u251c\u2500\u2500 notebooks/ (3 files)","\u2502   \u2514\u2500\u2500 data/ (2 files)","\u2502       \u2514\u2500\u2500 defs/ (6 files)","\u251c\u2500\u2500 scripts/ (3 files)","\u251c\u2500\u2500 specs/","\u2502   \u2514\u2500\u2500 001-ai-based-finding/","\u2502       \u2514\u2500\u2500 contracts/","\u251c\u2500\u2500 src/ (30 files)","\u2502   \u2514\u2500\u2500 findingmodel/ (30 files)","\u2502       \u251c\u2500\u2500 data/","\u2502       \u2514\u2500\u2500 tools/ (15 files)","\u2502           \u2514\u2500\u2500 prompt_templates/","\u251c\u2500\u2500 tasks/","\u2502   \u251c\u2500\u2500 done/","\u2502   \u2502   \u2514\u2500\u2500 README.md","\u2502   \u2514\u2500\u2500 refactoring/"],"stats":{"total_files":68,"total_directories":30,"fully_parsed":{"python":57},"listed_only":{"json":11},"markdown_files":72},"f":{"evals/__init__.py":["p",["ensure_instrumented:22:()>None::"]],"evals/anatomic_search.py":["p",["create_success_common_terms:408:()>list[AnatomicSearchCase]::Create success cases for common anatomic terms.","create_success_specific_locations:486:()>list[AnatomicSearchCase]::Create success cases for specific anatomic locations.","create_success_hierarchical:534:()>list[AnatomicSearchCase]::Create success cases testing hierarchical relationships.","create_success_synonyms:569:()>list[AnatomicSearchCase]::Create success cases testing synonym handling.","create_success_systems:614:()>list[AnatomicSearchCase]::Create success cases for anatomic systems.","create_rejection_non_anatomic:645:()>list[AnatomicSearchCase]::Create rejection cases for non-anatomic terms.","create_edge_cases:689:()>list[AnatomicSearchCase]::Create edge cases and boundary conditions.","create_performance_cases:782:()>list[AnatomicSearchCase]::Create cases focused on performance testing.","verify_database_populated:816:()>None::","run_anatomic_search_task:869:async (input_data:AnatomicSearchInput)>AnatomicSearchActualOutput:evaluate:","run_anatomic_search_evals:960:async ()>EvaluationReport[ AnatomicSearchInput, AnatomicSearchActualOutput, AnatomicSearchExpectedOutput ]:main,run_anatomic_search_evals:"],{"AnatomicSearchInput":["73",[]],"AnatomicSearchExpectedOutput":["80",[]],"AnatomicSearchActualOutput":["105",[]],"AnatomicSearchCase":["113",["__init__:131:(self, name:str, finding_name:str, description:str | None = None, should_succeed:bool = True, expected_primary_ids:list[str] | None = None, expected_alternate_ids:list[str] | None = None, unexpected_location_ids:list[str] | None = None, expected_region:str | None = None, min_alternates:int = 0, max_alternates:int = 3, semantic_keywords:list[str] | None = None, hierarchy_parent_id:str | None = None, max_query_time:float = 30.0,)>None:__init__:"]],"SearchAccuracyEvaluator":["173",["evaluate:190:(self, ctx:EvaluatorContext[AnatomicSearchInput, AnatomicSearchActualOutput, AnatomicSearchExpectedOutput],)>float::"]],"HierarchyEvaluator":["233",["evaluate:249:(self, ctx:EvaluatorContext[AnatomicSearchInput, AnatomicSearchActualOutput, AnatomicSearchExpectedOutput],)>float::"]],"RankingQualityEvaluator":["344",["evaluate:365:(self, ctx:EvaluatorContext[AnatomicSearchInput, AnatomicSearchActualOutput, AnatomicSearchExpectedOutput],)>float::"]]}],"evals/finding_description.py":["p",["create_common_findings_cases:586:()>list[FindingDescriptionCase]::Create cases for common medical findings with clear descriptions.","create_complex_findings_cases:657:()>list[FindingDescriptionCase]::Create cases for complex findings requiring detailed descriptions.","create_normalization_cases:708:()>list[FindingDescriptionCase]::Create cases testing name normalization (acronyms, specificity, plurals).","create_perplexity_detail_cases:771:()>list[FindingDescriptionCase]::Create cases testing Perplexity detail enhancement with citations.","create_edge_cases:808:()>list[FindingDescriptionCase]::Create edge cases and boundary conditions.","create_terminology_validation_cases:863:()>list[FindingDescriptionCase]::Create cases for medical terminology validation.","run_finding_description_task:916:async (input_data:FindingDescriptionInput)>FindingDescriptionActualOutput:evaluate:","run_finding_description_evals:1026:async ()>EvaluationReport[ FindingDescriptionInput, FindingDescriptionActualOutput, FindingDescriptionExpectedOutput ]:main,run_finding_description_evals:"],{"FindingDescriptionInput":["74",[]],"FindingDescriptionExpectedOutput":["81",[]],"FindingDescriptionActualOutput":["113",[]]}],"evals/markdown_in.py":["p",["create_success_cases:436:()>list[MarkdownInCase]::Create success cases for well-formed markdown.","create_edge_cases:613:()>list[MarkdownInCase]::Create edge cases and boundary conditions.","create_error_handling_cases:858:()>list[MarkdownInCase]::Create error handling and robustness cases.","create_complex_structure_cases:934:()>list[MarkdownInCase]::Create cases with complex attribute structures.","run_markdown_in_task:1028:async (input_data:MarkdownInInput)>MarkdownInActualOutput:evaluate:","run_markdown_in_evals:1113:async ()>EvaluationReport[ MarkdownInInput, MarkdownInActualOutput, MarkdownInExpectedOutput ]:main,run_markdown_in_evals:"],{"MarkdownInInput":["78",[]],"MarkdownInExpectedOutput":["87",[]],"MarkdownInActualOutput":["111",[]],"MarkdownInCase":["119",["__init__:138:(self, name:str, finding_name:str, finding_description:str, markdown_text:str, synonyms:list[str] | None = None, should_succeed:bool = True, expected_attribute_names:list[str] | None = None, expected_attribute_types:dict[str, str] | None = None, min_attributes:int = 0, max_attributes:int = 100, semantic_keywords:list[str] | None = None, error_keywords:list[str] | None = None, max_query_time:float = 30.0, round_trip_score_threshold:float = 0.99,)>None:__init__:"]],"StructuralValidityEvaluator":["182",["evaluate:197:(self, ctx:EvaluatorContext[MarkdownInInput, MarkdownInActualOutput, MarkdownInExpectedOutput],)>float::"]],"AttributePreservationEvaluator":["238",["evaluate:252:(self, ctx:EvaluatorContext[MarkdownInInput, MarkdownInActualOutput, MarkdownInExpectedOutput],)>float::"]],"TypeCorrectnessEvaluator":["285",["evaluate:299:(self, ctx:EvaluatorContext[MarkdownInInput, MarkdownInActualOutput, MarkdownInExpectedOutput],)>float::"]],"ErrorMessageQualityEvaluator":["334",["evaluate:348:(self, ctx:EvaluatorContext[MarkdownInInput, MarkdownInActualOutput, MarkdownInExpectedOutput],)>float::"]],"RoundTripEvaluator":["381",["evaluate:396:(self, ctx:EvaluatorContext[MarkdownInInput, MarkdownInActualOutput, MarkdownInExpectedOutput],)>float::"]]}],"evals/model_editor.py":["p",["load_fm_json:131:(filename:str)>str::Load a .fm.json file from the test data directory.","create_successful_edit_cases:137:()>list[ModelEditorCase]:load_fm_json:Create cases for successful edits that should be applied.","create_rejection_cases:210:()>list[ModelEditorCase]:load_fm_json:Create cases for edits that should be rejected.","create_markdown_edit_cases:279:()>list[ModelEditorCase]:load_fm_json:Create cases for markdown-based edits.","run_model_editor_task:678:async (input_data:ModelEditorInput)>ModelEditorActualOutput:evaluate:","run_model_editor_evals:836:async ()>EvaluationReport[ ModelEditorInput, ModelEditorActualOutput, ModelEditorExpectedOutput ]:main,run_model_editor_evals:"],{"ModelEditorInput":["41",[]],"ModelEditorExpectedOutput":["49",[]],"ModelEditorActualOutput":["59",[]],"ModelEditorCase":["68",["__init__:82:(self, name:str, model_json:str, command:str, edit_type:str, should_succeed:bool, should_preserve_id:bool = True, added_attribute_names:list[str] | None = None, rejection_keywords:list[str] | None = None, changes_keywords:list[str] | None = None,)>None:__init__:","_execute:106:async (self, input_data:ModelEditorInput)>ModelEditorActualOutput:evaluate:"]],"IDPreservationEvaluator":["340",["evaluate:373:(self, ctx:EvaluatorContext[ModelEditorInput, ModelEditorActualOutput, ModelEditorExpectedOutput])>float::"]],"AttributeAdditionEvaluator":["399",["evaluate:433:(self, ctx:EvaluatorContext[ModelEditorInput, ModelEditorActualOutput, ModelEditorExpectedOutput])>float::"]],"ChangeTrackingEvaluator":["468",["evaluate:507:(self, ctx:EvaluatorContext[ModelEditorInput, ModelEditorActualOutput, ModelEditorExpectedOutput])>float::"]],"RejectionAccuracyEvaluator":["542",["evaluate:581:(self, ctx:EvaluatorContext[ModelEditorInput, ModelEditorActualOutput, ModelEditorExpectedOutput])>float::"]],"ContentPreservationEvaluator":["616",["evaluate:647:(self, ctx:EvaluatorContext[ModelEditorInput, ModelEditorActualOutput, ModelEditorExpectedOutput])>float::"]]}],"evals/ontology_match.py":["p",["create_success_cases:476:()>list[OntologyMatchCase]::Create success cases for common radiology concepts.","create_synonym_cases:548:()>list[OntologyMatchCase]::Create cases testing synonym and abbreviation handling.","create_edge_cases:591:()>list[OntologyMatchCase]::Create edge cases and boundary conditions.","create_ranking_cases:659:()>list[OntologyMatchCase]::Create cases for testing ranking quality.","create_rejection_cases:706:()>list[OntologyMatchCase]::Create rejection and error cases.","create_performance_cases:749:()>list[OntologyMatchCase]::Create cases focused on performance testing.","run_ontology_match_task:792:async (input_data:OntologyMatchInput)>OntologyMatchActualOutput:evaluate:","run_ontology_match_evals:876:async ()>EvaluationReport[ OntologyMatchInput, OntologyMatchActualOutput, OntologyMatchExpectedOutput ]:main,run_ontology_match_evals:"],{"OntologyMatchInput":["65",[]],"OntologyMatchExpectedOutput":["75",[]],"OntologyMatchActualOutput":["97",[]],"OntologyMatchCase":["105",["__init__:123:(self, name:str, finding_name:str, finding_description:str | None = None, ontologies:list[str] | None = None, should_succeed:bool = True, expected_exact_match_ids:list[str] | None = None, expected_should_include_ids:list[str] | None = None, unexpected_concept_ids:list[str] | None = None, min_exact_matches:int = 0, max_exact_matches:int = 5, semantic_keywords:list[str] | None = None, ranking_target_ndcg:float = 0.8, max_query_time:float = 30.0,)>None:__init__:"]],"RankingQualityEvaluator":["227",["_calculate_dcg:248:(self, relevances:list[float])>float::","_calculate_ndcg:266:(self, actual_relevances:list[float], expected_relevances:list[float])>float:_calculate_dcg:","evaluate:293:(self, ctx:EvaluatorContext[OntologyMatchInput, OntologyMatchActualOutput, OntologyMatchExpectedOutput],)>float:_calculate_ndcg:"]],"SynonymHandlingEvaluator":["379",["evaluate:396:(self, ctx:EvaluatorContext[OntologyMatchInput, OntologyMatchActualOutput, OntologyMatchExpectedOutput],)>float::"]],"ErrorHandlingEvaluator":["433",["evaluate:447:(self, ctx:EvaluatorContext[OntologyMatchInput, OntologyMatchActualOutput, OntologyMatchExpectedOutput],)>float::"]]}],"evals/similar_models.py":["p",["create_exact_duplicate_cases:432:()>list[SimilarModelsCase]::Create cases for exact duplicate detection.","create_semantic_similarity_cases:481:()>list[SimilarModelsCase]::Create cases for semantic similarity detection (no exact match).","create_dissimilar_cases:531:()>list[SimilarModelsCase]::Create cases for findings that should not match (create new).","create_edge_cases:570:()>list[SimilarModelsCase]::Create edge cases and boundary conditions.","create_performance_cases:673:()>list[SimilarModelsCase]::Create cases focused on performance testing.","create_error_handling_cases:702:()>list[SimilarModelsCase]::Create cases for error handling and robustness.","create_ranking_consistency_cases:742:()>list[SimilarModelsCase]::Create cases for testing ranking consistency.","create_recommendation_threshold_cases:763:()>list[SimilarModelsCase]::Create cases for testing recommendation threshold boundaries.","run_similar_models_task:802:async (input_data:SimilarModelsInput)>SimilarModelsActualOutput:evaluate:","run_similar_models_evals:907:async ()>EvaluationReport[ SimilarModelsInput, SimilarModelsActualOutput, SimilarModelsExpectedOutput ]:main,run_similar_models_evals:"],{"SimilarModelsInput":["67",[]],"SimilarModelsExpectedOutput":["75",[]],"SimilarModelsActualOutput":["96",[]],"SimilarModelsCase":["104",["__init__:120:(self, name:str, finding_name:str, description:str | None = None, synonyms:list[str] | None = None, should_find_exact_match:bool = False, expected_recommendation:str | None = None, expected_similar_ids:list[str] | None = None, unexpected_similar_ids:list[str] | None = None, min_confidence:float = 0.0, max_query_time:float = 30.0, semantic_keywords:list[str] | None = None,)>None:__init__:"]],"RankingQualityEvaluator":["213",["evaluate:232:(self, ctx:EvaluatorContext[SimilarModelsInput, SimilarModelsActualOutput, SimilarModelsExpectedOutput],)>float::"]],"PrecisionAtKEvaluator":["270",["__init__:283:(self, k:int = 3)>None::","evaluate:294:(self, ctx:EvaluatorContext[SimilarModelsInput, SimilarModelsActualOutput, SimilarModelsExpectedOutput],)>float::"]],"ExclusionEvaluator":["385",["evaluate:399:(self, ctx:EvaluatorContext[SimilarModelsInput, SimilarModelsActualOutput, SimilarModelsExpectedOutput],)>float::"]]}],"evals/utils.py":["p",["load_fm_json:18:(filename:str)>str:load_fm_json:","create_mock_edit_result:43:(model:FindingModelFull, changes:list[str] | None = None, rejections:list[str] | None = None,)>\"model_editor.EditResult\":create_mock_edit_result:","compare_models:75:(model1:FindingModelFull, model2:FindingModelFull)>bool:compare_models:","extract_text_for_keywords:96:(changes:list[str], rejections:list[str])>str:extract_text_for_keywords:","get_attribute_names:122:(model:FindingModelFull)>set[str]:get_attribute_names:"]],"s/anatomic_location_search.py":["p",["perform_search_stages:23:async (finding_info:FindingInfo)>dict::Perform the search in stages, returning results and timing for each.","_create_finding_info:67:(finding_name:str, description:Optional[str])>tuple[FindingInfo, str, float]:_async_create_finding_info:Create FindingInfo and return info, source, and timing.","_print_finding_info_stage:87:(finding_info:FindingInfo, source:str, timing:float)>None::Print the finding info stage output.","_print_verbose_stages:101:(results:dict)>None:_print_ai_selection_stage:Print all verbose stage outputs.","_print_ai_selection_stage:127:(results:dict)>None::Print AI selection stage output.","_print_summary:145:(finding_name:str, results:dict, total_time:float)>None::Print non-verbose summary output.","test_anatomic_location_search:162:async (finding_name:str, description:Optional[str] = None, verbose:bool = False)>None:_print_finding_info_stage,_print_summary,_print_verbose_stages,perform_search_stages:Test anatomic location search with timing information.","check_configuration:209:()>bool::Check if the configuration is valid for running the tool.","parse_args:237:()>argparse.Namespace::Parse command-line arguments.","main:261:async ()>None:check_configuration,parse_args,test_anatomic_location_search:Main entry point for the anatomic location search tool."]],"s/edit_finding_model.py":["p",["_await_with_timer:64:async (coro:Awaitable[T], message:str)>T::","run_with_timer:81:(coro:Awaitable[T], message:str)>T:_await_with_timer,_runner:","load_model:88:(path:Path)>FindingModelFull::","save_model:93:(model:FindingModelFull, path:Path)>None::","render_rejections:97:(rejections:list[str])>None::","render_changes:107:(changes:list[str])>None::","display_current:118:(state:DemoState)>None::","explain_commands:123:()>None::","prompt_markdown_edit:155:(state:DemoState)>str | None::","prompt_command_text:172:(provided:list[str])>str::","apply_edit:187:(state:DemoState, result:EditResult, context:str)>None:display_current,mark_updated,render_changes,render_rejections:","handle_natural_language:206:(state:DemoState, text:str)>None:apply_edit,run_with_timer:","handle_markdown_edit:221:(state:DemoState)>None:apply_edit,prompt_markdown_edit,run_with_timer:","handle_save:239:(state:DemoState, maybe_path:list[str])>None:record_save,save_model:","_handle_command_input:255:(state:DemoState, args:list[str])>None:handle_natural_language,prompt_command_text:","_handle_reset:261:(state:DemoState, _:list[str])>None:display_current,reset:","handle_command:276:(state:DemoState, command:str, args:list[str])>bool::","run_session:288:(state:DemoState)>None:explain_commands,handle_command,handle_natural_language:","parse_args:321:()>argparse.Namespace:parse_args:","main:339:()>int:display_current,load_model,parse_args,run_session:"],{"DemoState":["37",["__init__:40:(self, model:FindingModelFull, save_path:Path)>None::","markdown:47:(self)>str::","mark_updated:50:(self, result:EditResult)>None::","reset:55:(self)>None::","record_save:59:(self)>None::"]]}],"s/ontology_concept_match.py":["p",["perform_search_stages:21:async (finding_info:FindingInfo)>dict::Perform the search in stages, returning results and timing for each.","_print_finding_info_stage:69:(finding_info:FindingInfo, source:str, timing:float)>None::Print the finding info stage output.","_print_query_terms_stage:83:(results:dict)>None::Print query terms generation stage.","_print_bio_search_stage:92:(results:dict)>None::Print BioOntology search stage.","_print_categorization_stage:107:(results:dict)>None::Print AI categorization stage.","_print_final_output_stage:122:(results:dict)>None::Print final output building stage.","_print_verbose_stages:153:(results:dict)>None:_print_bio_search_stage,_print_categorization_stage,_print_final_output_stage,_print_query_terms_stage:Print all verbose stage outputs.","_print_summary:161:(finding_name:str, results:dict, total_time:float)>None::Print non-verbose summary output.","test_ontology_concept_match:187:async (finding_name:str, description:Optional[str] = None, verbose:bool = False)>None:_print_finding_info_stage,_print_summary,_print_verbose_stages,perform_search_stages:Test ontology concept matching with timing information.","check_configuration:232:()>bool::Check if the configuration is valid for running the tool.","parse_args:257:()>argparse.Namespace::Parse command-line arguments.","main:281:async ()>None:check_configuration,parse_args,test_ontology_concept_match:Main entry point for the ontology concept matching tool."]],"sr/findingmodel/abstract_finding_model.py":["p",{"AbstractNumericAttribute":["6",[]],"AbstractChoiceValue":["18",[]],"AbstractChoiceAttribute":["25",[]],"AbstractFindingModel":["36",["as_markdown:45:(self)>str::Render the finding model as a markdown string."]]}],"sr/findingmodel/anatomic_migration.py":["p",["create_searchable_text:25:(record:dict[str, Any])>str::","determine_sided:56:(record:dict[str, Any])>str::","load_anatomic_data:88:async (source:str)>list[dict[str, Any]]::","validate_anatomic_record:120:(record:dict[str, Any])>list[str]::","create_anatomic_database:151:async (db_path:Path, records:list[dict[str, Any]], client:AsyncOpenAI, batch_size:int = 50,)>tuple[int, int]:_create_indexes,_process_and_insert_data,_verify_database:","_process_and_insert_data:204:async (conn:duckdb.DuckDBPyConnection, records:list[dict[str, Any]], client:AsyncOpenAI, batch_size:int,)>tuple[int, int]:_insert_batch,create_searchable_text,determine_sided,validate_anatomic_record:","_insert_batch:284:async (conn:duckdb.DuckDBPyConnection, batch_records:list[dict[str, Any]], batch_texts:list[str], client:AsyncOpenAI,)>None::","_create_indexes:320:(conn:duckdb.DuckDBPyConnection, dimensions:int)>None::","_verify_database:367:(conn:duckdb.DuckDBPyConnection)>None::","get_database_stats:417:(db_path:Path)>dict[str, Any]::"]],"sr/findingmodel/cli.py":["p",["cli:32:()>None::","config:37:()>None::Show the currently active configuration.","print_info_truncate_detail:44:(console:Console, finding_info:FindingInfo)>None::","make_info:57:(finding_name:str, detailed:bool, output:Path | None)>None:_do_make_info,print_info_truncate_detail:Generate description/synonyms and more details/citations for a finding name.","make_stub_model:94:(finding_name:str, tags:list[str], with_codes:bool, with_ids:bool, source:str | None, output:Path | None)>None:_do_make_stub_model:Generate a simple finding model object (presence and change elements only) fr...","markdown_to_fm:135:(finding_path:Path, with_ids:bool, source:str | None, output:Path | None)>None:_do_markdown_to_fm,print_info_truncate_detail:Convert markdown file to finding model format.","fm_to_markdown:172:(finding_model_path:Path, output:Path | None)>None::Convert finding model JSON file to Markdown format.","index:196:()>None::Index management commands.","build:204:(directory:Path, output:Path | None)>None:_do_build,progress_update:Build index from directory of *.fm.json files.","update:240:(directory:Path, index:Path | None)>None:_do_update,progress_update:Update existing index from directory.","_validate_single_file:273:async (fm_file:Path, directory:Path, idx:DuckDBIndex)>tuple[str, list[str]] | None::Validate a single finding model file. Returns (filename, errors) if validatio...","validate:301:(directory:Path)>None:_do_validate,_validate_single_file:Validate finding models without writing to index.","stats:358:(index:Path | None)>None:_do_stats:Show index statistics.","anatomic:432:()>None::Anatomic location database management commands.","anatomic_build:445:(source:str | None, output:Path | None, force:bool)>None:_do_build:Build anatomic location database from source data.","anatomic_validate:513:(source:str | None)>None:_do_validate:Validate anatomic location data without building database.","anatomic_stats:561:(db_path:Path | None)>None::Show anatomic location database statistics."]],"sr/findingmodel/common.py":["p",["normalize_name:4:(name:str)>str::","model_file_name:12:(name:str)>str:normalize_name:Convert a finding model name to a file name."]],"sr/findingmodel/config.py":["p",["strip_quotes:19:(value:str)>str::","strip_quotes_secret:23:(value:str | SecretStr)>str:strip_quotes:","_resolve_target_path:140:(file_path:str | Path | None, manifest_key:str)>Path::","_verify_file_hash:164:(file_path:Path, expected_hash:str)>bool::","_download_file:185:(target_path:Path, url:str, hash_value:str)>Path::","_download_from_manifest:212:(target_path:Path, manifest_key:str)>Path:_download_file,fetch_manifest:","ensure_db_file:247:(file_path:str | Path | None, remote_url:str | None, remote_hash:str | None, manifest_key:str,)>Path:_download_file,_download_from_manifest,_resolve_target_path,_verify_file_hash,ensure_db_file:","ensure_index_db:321:()>Path:ensure_db_file:","ensure_anatomic_db:338:()>Path:ensure_db_file:","fetch_manifest:355:()>dict[str, Any]:fetch_manifest:","clear_manifest_cache:393:()>None::Clear the manifest cache (for testing)."],{"ConfigurationError":["15",[]],"FindingModelConfig":["35",["validate_remote_db_config:105:(self)>Self::Validate that remote URL and hash are provided together (or neither).","check_ready_for_openai:125:(self)>Literal[True]::","check_ready_for_perplexity:130:(self)>Literal[True]::"]]}],"sr/findingmodel/contributor.py":["p",{"Organization":["16",["_register_org:24:(self)>Self::","get:32:(cls, code:str)>Self | None:get:","organizations:39:(cls)>list[Self]::","load_jsonl:46:(cls, jsonl_file:str | Path)>None::","save_jsonl:58:(cls, jsonl_file:str | Path)>None::"]],"Person":["68",["organization:78:(self)>Organization:get:","_register_person:87:(self)>Self::","get:95:(cls, username:str)>Self | None:get:","people:102:(cls)>list[Self]::","load_jsonl:109:(cls, jsonl_file:str | Path)>None::","save_jsonl:121:(cls, jsonl_file:str | Path)>None::"]]}],"sr/findingmodel/embedding_cache.py":["p",{"EmbeddingCache":["20",["__init__:27:(self, db_path:Path | None = None)>None::","__aenter__:36:async (self)>EmbeddingCache:setup:Enter context manager.","__aexit__:41:async (self, exc_type:object, exc_val:object, exc_tb:object)>None::Exit context manager.","setup:47:async (self)>None::Create schema if not exists.","_get_connection:87:(self, read_only:bool = True)>duckdb.DuckDBPyConnection::","_hash_text:100:(self, text:str)>str::","_to_float32:111:(self, embedding:list[float])>list[float]::","get_embedding:122:async (self, text:str, model:str, dimensions:int)>list[float] | None:_get_connection,_hash_text:","store_embedding:161:async (self, text:str, model:str, dimensions:int, embedding:list[float])>None:_get_connection,_hash_text,_to_float32:","get_embeddings_batch:200:async (self, texts:list[str], model:str, dimensions:int)>list[list[float] | None]:_get_connection,_hash_text:","store_embeddings_batch:252:async (self, texts:list[str], model:str, dimensions:int, embeddings:list[list[float]])>None:_get_connection,_hash_text,_to_float32:","clear_cache:305:async (self, model:str | None = None, older_than_days:int | None = None)>int:_get_connection:"]]}],"sr/findingmodel/finding_info.py":["p",{"FindingInfo":["4",[]]}],"sr/findingmodel/finding_model.py":["p",["_random_digits:36:(length:int)>str::","generate_oifma_id:40:(source:str)>str:_random_digits:","_index_codes_str:69:(index_codes:Iterable[IndexCode] | None)>str | None::","fix_max_selected_validator:122:(cls, data:dict[str, Any])>dict[str, Any]::","generate_oifm_id:338:(source:str)>str:_random_digits:"],{"ChoiceValue":["44",[]],"ChoiceValueIded":["73",["index_codes_str:84:(self)>str | None:_index_codes_str:"]],"ChoiceAttribute":["133",["fix_max_selected:148:(cls, data):fix_max_selected_validator:"]],"ChoiceAttributeIded":["152",["fix_max_selected:164:(cls, data):fix_max_selected_validator:","add_value_codes:169:(cls, data)::Add the value codes to the choice values if they are not already present.","index_codes_str:189:(self)>str | None:_index_codes_str:"]],"NumericAttribute":["217",[]],"NumericAttributeIded":["230",["index_codes_str:243:(self)>str | None:_index_codes_str:"]],"FindingModelBase":["302",["as_markdown:316:(self)>str::"]],"FindingModelFull":["345",["as_markdown:361:(self, hide_ids:bool = False)>str::","index_codes_str:398:(self)>str | None:_index_codes_str:"]]}],"sr/findingmodel/index.py":["p",{"AttributeInfo":["39",[]],"IndexEntry":["47",["match:63:(self, identifier:str)>bool::Check if the identifier matches the ID, name, or synonyms."]],"_BatchPayload":["82",[]],"_RowData":["96",[]],"DuckDBIndex":["210",["__init__:213:(self, db_path:str | Path | None = None, *, read_only:bool = True)>None::","setup:227:async (self)>None:_create_search_indexes,_ensure_connection,_load_base_contributors:Ensure the database exists, connection opened, and schema ready.","__aenter__:244:async (self)>DuckDBIndex:_ensure_connection:Enter async context manager, ensuring a connection is available.","__aexit__:255:async (self, exc_type:type[BaseException] | None, exc_val:BaseException | None, exc_tb:TracebackType | None,)>None::Close the database connection when leaving the context.","contains:262:async (self, identifier:str)>bool:_ensure_connection,_resolve_oifm_id:Return True if an ID, name, or synonym exists in the index.","get:268:async (self, identifier:str)>IndexEntry | None:_ensure_connection,_fetch_index_entry,_resolve_oifm_id:Retrieve an index entry by ID, name, or synonym.","get_full:277:async (self, oifm_id:str)>FindingModelFull:_ensure_connection,get_full,setup:","get_full_batch:304:async (self, oifm_ids:list[str])>dict[str, FindingModelFull]:_ensure_connection,get_full_batch,setup:","count:330:async (self)>int:_ensure_connection:Return the number of finding models in the index.","count_people:337:async (self)>int:_ensure_connection:Return the number of people in the normalized table.","count_organizations:344:async (self)>int:_ensure_connection:Return the number of organizations in the normalized table.","get_person:351:async (self, github_username:str)>Person | None:_ensure_connection:Retrieve a person by GitHub username.","get_organization:373:async (self, code:str)>Organization | None:_ensure_connection:Retrieve an organization by code.","get_people:389:async (self)>list[Person]:_ensure_connection:Retrieve all people from the index.","get_organizations:410:async (self)>list[Organization]:_ensure_connection:Retrieve all organizations from the index.","all:428:async (self, limit:int = 100, offset:int = 0, order_by:str = \"name\", order_dir:Literal[\"asc\", \"desc\"] = \"asc\",)>tuple[list[IndexEntry], int]:_execute_paginated_query,all:","search_by_slug:470:async (self, pattern:str, limit:int = 100, offset:int = 0, match_type:Literal[\"exact\", \"prefix\", \"contains\"] = \"contains\",)>tuple[list[IndexEntry], int]:_build_slug_search_clause,_execute_paginated_query,search_by_slug:","count_search:513:async (self, pattern:str, match_type:Literal[\"exact\", \"prefix\", \"contains\"] = \"contains\")>int:_build_slug_search_clause,_ensure_connection,count_search:","_build_slug_search_clause:537:(self, pattern:str, match_type:Literal[\"exact\", \"prefix\", \"contains\"])>tuple[str, str, str]:_build_slug_search_clause:","_execute_paginated_query:568:(self, where_clause:str = \"\", where_params:list[object] | None = None, order_clause:str = \"LOWER(name)\", order_params:list[object] | None = None, limit:int = 100, offset:int = 0,)>tuple[list[IndexEntry], int]:_ensure_connection,count,search_by_slug:","add_or_update_entry_from_file:630:async (self, filename:str | Path, model:FindingModelFull | None = None, *, allow_duplicate_synonyms:bool = False,)>IndexReturnType:_build_embedding_text,_build_search_text,_calculate_file_hash,_create_search_indexes,_delete_denormalized_records,_drop_search_indexes,_ensure_openai_client,_ensure_writable_connection,_replace_attributes,_replace_synonyms,_replace_tags,_upsert_contributors,_validate_model,setup:Insert or update a finding model from a `.fm.json` file.","_collect_directory_files:747:(self, directory:Path)>list[tuple[str, str, Path]]:_calculate_file_hash:","_stage_directory_files:754:(self, conn:duckdb.DuckDBPyConnection, files:Sequence[tuple[str, str, Path]])>None::","_classify_directory_changes:767:(self, conn:duckdb.DuckDBPyConnection,)>tuple[set[str], dict[str, str], set[str]]::","_prepare_batch_payload:805:async (self, filenames_to_process:Sequence[str], files_by_name:Mapping[str, tuple[str, Path]], updated_entries:Mapping[str, str], removed_ids:Iterable[str], *, allow_duplicate_synonyms:bool = False,)>_BatchPayload:_build_row_data,_generate_embeddings,_load_models_metadata:","_execute_batch_directory_update:840:(self, conn:duckdb.DuckDBPyConnection, payload:_BatchPayload, progress_callback:Callable[[str], None] | None = None,)>None:_create_search_indexes,_delete_old_entries,_drop_search_indexes,_insert_models_with_progress:","_delete_old_entries:876:(self, conn:duckdb.DuckDBPyConnection, ids_to_delete:list[str], progress_callback:Callable[[str], None] | None,)>None:_delete_denormalized_records:Delete old entries from all tables.","_insert_models_with_progress:892:(self, conn:duckdb.DuckDBPyConnection, payload:_BatchPayload, progress_callback:Callable[[str], None] | None,)>None:_apply_batch_mutations,_create_chunk_payload:Insert models with progress updates for large batches.","_create_chunk_payload:937:(self, payload:_BatchPayload, start_idx:int, end_idx:int,)>_BatchPayload::Create a chunk of the payload for batch processing.","_load_models_metadata:976:(self, filenames_to_process:Sequence[str], files_by_name:Mapping[str, tuple[str, Path]], updated_entries:Mapping[str, str], *, allow_duplicate_synonyms:bool = False,)>tuple[list[tuple[FindingModelFull, str, str, str, str]], list[str]]:_build_embedding_text,_build_search_text,_validate_model:","_generate_embeddings:998:async (self, embedding_payloads:Sequence[str])>list[list[float]]:_ensure_openai_client:","_build_row_data:1016:(self, metadata:Sequence[tuple[FindingModelFull, str, str, str, str]], embeddings:Sequence[list[float]],)>_RowData::","_apply_batch_mutations:1096:(self, conn:duckdb.DuckDBPyConnection, payload:_BatchPayload)>None:_delete_denormalized_records:","update_from_directory:1239:async (self, directory:str | Path, *, allow_duplicate_synonyms:bool = False, progress_callback:Callable[[str], None] | None = None,)>dict[str, int]:_classify_directory_changes,_collect_directory_files,_ensure_writable_connection,_execute_batch_directory_update,_prepare_batch_payload,_stage_directory_files,setup:","remove_entry:1324:async (self, oifm_id:str)>bool:_create_search_indexes,_delete_denormalized_records,_drop_search_indexes,_ensure_writable_connection,setup:Remove a finding model by ID.","search:1352:async (self, query:str, *, limit:int = 10, tags:Sequence[str] | None = None,)>list[IndexEntry]:_ensure_connection,_search_exact,_search_fts,_search_semantic:","search_batch:1397:async (self, queries:list[str], *, limit:int = 10)>dict[str, list[IndexEntry]]:_ensure_connection,_ensure_openai_client,_search_exact,_search_fts,_search_semantic_with_embedding:","_load_oifm_ids_for_source:1462:(self, source:str)>set[str]:_ensure_connection:","_load_oifma_ids_for_source:1485:(self, source:str)>set[str]:_ensure_connection:","generate_model_id:1508:(self, source:str = \"OIDM\", max_attempts:int = 100)>str:_load_oifm_ids_for_source,generate_model_id,setup:","generate_attribute_id:1561:(self, model_oifm_id:str | None = None, source:str | None = None, max_attempts:int = 100,)>str:_load_oifma_ids_for_source,generate_attribute_id,setup:","add_ids_to_model:1636:(self, finding_model:FindingModelBase | FindingModelFull, source:str,)>FindingModelFull:add_ids_to_model,generate_attribute_id,generate_model_id,get,setup:","finalize_placeholder_attribute_ids:1686:(self, finding_model:FindingModelFull, source:str | None = None,)>FindingModelFull:finalize_placeholder_attribute_ids,generate_attribute_id,get,setup:","_ensure_connection:1761:(self)>duckdb.DuckDBPyConnection::","_ensure_writable_connection:1768:(self)>duckdb.DuckDBPyConnection:_ensure_connection:","_ensure_openai_client:1773:async (self)>AsyncOpenAI::","_fetch_index_entry:1779:(self, conn:duckdb.DuckDBPyConnection, oifm_id:str)>IndexEntry | None:_collect_contributors:","_collect_contributors:1828:(self, conn:duckdb.DuckDBPyConnection, oifm_id:str)>list[str]::","_resolve_oifm_id:1845:(self, conn:duckdb.DuckDBPyConnection, identifier:str)>str | None::","_upsert_contributors:1880:(self, conn:duckdb.DuckDBPyConnection, model:FindingModelFull)>None::","_replace_synonyms:1941:(self, conn:duckdb.DuckDBPyConnection, oifm_id:str, synonyms:Sequence[str] | None,)>None::","_replace_tags:1956:(self, conn:duckdb.DuckDBPyConnection, oifm_id:str, tags:Sequence[str] | None,)>None::","_replace_attributes:1966:(self, conn:duckdb.DuckDBPyConnection, model:FindingModelFull)>None::","_build_search_text:1991:(self, model:FindingModelFull)>str::","_build_embedding_text:2002:(self, model:FindingModelFull)>str::","_validate_model:2016:(self, model:FindingModelFull)>list[str]:_ensure_connection:","_calculate_file_hash:2075:(self, filename:Path)>str::","_search_exact:2086:(self, conn:duckdb.DuckDBPyConnection, query:str, *, tags:Sequence[str] | None = None,)>list[IndexEntry]:_entry_has_tags,_fetch_index_entry,_resolve_oifm_id:","_entry_has_tags:2100:(self, entry:IndexEntry, tags:Sequence[str])>bool:all:","_search_fts:2111:(self, conn:duckdb.DuckDBPyConnection, query:str, *, limit:int, tags:Sequence[str] | None = None,)>list[tuple[IndexEntry, float]]:_entry_has_tags,_fetch_index_entry:","_delete_denormalized_records:2157:(self, conn:duckdb.DuckDBPyConnection, oifm_ids:Sequence[str],)>None::","_create_search_indexes:2170:(self, conn:duckdb.DuckDBPyConnection)>None::","_load_base_contributors:2189:(self, conn:duckdb.DuckDBPyConnection)>None:get:Load base organizations and people if the tables are empty.","_drop_search_indexes:2236:(self, conn:duckdb.DuckDBPyConnection)>None::","_search_semantic:2246:async (self, conn:duckdb.DuckDBPyConnection, query:str, *, limit:int, tags:Sequence[str] | None = None,)>list[tuple[IndexEntry, float]]:_ensure_openai_client,_search_semantic_with_embedding:Perform semantic search by generating embedding for query text.","_search_semantic_with_embedding:2272:(self, conn:duckdb.DuckDBPyConnection, embedding:list[float], *, limit:int, tags:Sequence[str] | None = None,)>list[tuple[IndexEntry, float]]:_entry_has_tags,_fetch_index_entry,search_batch:"]]}],"sr/findingmodel/index_code.py":["p",{"IndexCode":["4",[]]}],"sr/findingmodel/index_validation.py":["p",["check_oifm_id_conflict:50:(model:FindingModelFull, existing_ids:set[str], *, allow_self:bool = False,)>list[str]::","check_name_conflict:74:(model:FindingModelFull, existing_names:set[str], *, allow_self:bool = False,)>list[str]::","check_attribute_id_conflict:111:(model:FindingModelFull, attribute_ids_by_model:dict[str, str], *, allow_self:bool = False,)>list[str]::","validate_finding_model:143:async (model:FindingModelFull, context:ValidationContext, *, allow_self:bool = False,)>list[str]:check_attribute_id_conflict,check_name_conflict,check_oifm_id_conflict,get_attribute_ids_by_model,get_existing_names,get_existing_oifm_ids:"],{"ValidationContext":["13",["get_existing_oifm_ids:20:async (self)>set[str]::","get_existing_names:28:async (self)>set[str]::","get_attribute_ids_by_model:36:async (self)>dict[str, str]::"]]}],"sr/findingmodel/tools/__init__.py":["p",["add_ids_to_model:24:(finding_model:FindingModelBase | FindingModelFull, source:str,)>FindingModelFull:add_ids_to_model:","add_ids_to_finding_model:48:(finding_model:FindingModelBase | FindingModelFull, source:str,)>FindingModelFull:add_ids_to_model:"]],"sr/findingmodel/tools/anatomic_location_search.py":["p",["generate_anatomic_query_terms:43:async (finding_name:str, finding_description:str | None = None, model:str | None = None)>AnatomicQueryTerms::","execute_anatomic_search:114:async (query_info:AnatomicQueryTerms, client:OntologySearchProtocol, limit:int = 30)>list[OntologySearchResult]::","create_location_selection_agent:162:(model:str | None = None)>Agent[None, LocationSearchResponse]::","find_anatomic_locations:204:async (finding_name:str, description:str | None = None, use_duckdb:bool = True, model:str | None = None,)>LocationSearchResponse:create_location_selection_agent,execute_anatomic_search,generate_anatomic_query_terms:"],{"AnatomicQueryTerms":["28",[]],"LocationSearchResponse":["154",[]]}],"sr/findingmodel/tools/common.py":["p",["_get_embedding_cache:18:async ()>EmbeddingCache::","get_async_instructor_client:31:()>AsyncInstructor::","get_async_perplexity_client:36:()>AsyncOpenAI::","get_openai_model:43:(model_name:str)>OpenAIModel::Helper function to get OpenAI model instance - moved from similar_finding_mod...","get_embedding:57:async (text:str, client:AsyncOpenAI | None = None, model:str | None = None, dimensions:int = 512, use_cache:bool = True,)>list[float] | None:_get_embedding_cache,get_embedding:","_lookup_cached_embeddings:110:async (texts:list[str], model:str, dimensions:int)>tuple[list[list[float] | None], list[str], list[int]]:_get_embedding_cache,get_embeddings_batch:","_fetch_and_store_embeddings:154:async (texts_to_fetch:list[str], fetch_indices:list[int], embeddings:list[list[float] | None], client:AsyncOpenAI, model:str, dimensions:int, use_cache:bool,)>None:_get_embedding_cache:","get_embeddings_batch:193:async (texts:list[str], client:AsyncOpenAI | None = None, model:str | None = None, dimensions:int = 512, use_cache:bool = True,)>list[list[float] | None]:_fetch_and_store_embeddings,_lookup_cached_embeddings:","get_markdown_text_from_path_or_text:238:(*, markdown_text:str | None = None, markdown_path:str | Path | None = None)>str::"]],"sr/findingmodel/tools/create_stub.py":["p",["create_model_stub_from_info:9:(finding_info:FindingInfo, tags:list[str] | None = None)>FindingModelBase:create_change_element,create_presence_element:","create_finding_model_stub_from_finding_info:65:(finding_info:FindingInfo, tags:list[str] | None = None)>FindingModelBase:create_model_stub_from_info:"]],"sr/findingmodel/tools/duckdb_search.py":["p",{"DuckDBOntologySearchClient":["14",["__init__:17:(self, db_path:str | None = None)>None::","__aenter__:36:async (self)>\"DuckDBOntologySearchClient\"::Enter async context.","__aexit__:51:async (self, exc_type:type[BaseException] | None, exc_val:BaseException | None, exc_tb:Any, # noqa:ANN401)>None::Exit async context.","search:62:async (self, queries:list[str], max_results:int = 30, filter_anatomical:bool = True,)>list[OntologySearchResult]:_search_single:","search_parallel:101:async (self, queries:list[str], tables:list[str] | None = None, limit_per_query:int = 30, filter_anatomical:bool = False,)>list[OntologySearchResult]:_search_single:","search_with_filters:141:async (self, queries:list[str], region:str | None = None, sided_filter:list[str] | None = None, limit_per_query:int = 30,)>list[OntologySearchResult]:_search_single_with_filters:","_search_single:177:async (self, query:str, limit:int = 30)>list[OntologySearchResult]:_apply_rrf_fusion,_combine_with_exact_matches,_find_exact_matches,_get_embedding,_row_to_result,search:","_find_exact_matches:246:(self, query:str, where_clause:str | None = None, params:list[Any] | None = None)>list[OntologySearchResult]:_row_to_result:","_row_to_result:303:(self, row:tuple[Any, ...], score:float)>OntologySearchResult::","_apply_rrf_fusion:325:(self, fts_results:list[tuple[Any, ...]], vector_results:list[tuple[Any, ...]], limit:int,)>list[tuple[Any, ...]]::","_combine_with_exact_matches:364:(self, exact_matches:list[OntologySearchResult], other_results:list[OntologySearchResult], limit:int)>list[OntologySearchResult]::","_search_single_with_filters:392:async (self, query:str, region:str | None = None, sided_filter:list[str] | None = None, limit:int = 30)>list[OntologySearchResult]:_apply_rrf_fusion,_combine_with_exact_matches,_find_exact_matches,_get_embedding,_row_to_result:","_get_embedding:475:async (self, text:str)>list[float] | None::"]]}],"sr/findingmodel/tools/duckdb_utils.py":["p",["setup_duckdb_connection:27:(db_path:Path | str, *, read_only:bool = True, extensions:Iterable[str] = _DEFAULT_EXTENSIONS,)>duckdb.DuckDBPyConnection::","get_embedding_for_duckdb:60:async (text:str, *, client:AsyncOpenAI | None = None, model:str | None = None, dimensions:int | None = None,)>list[float] | None:_to_float32:Generate a float32 embedding suitable for DuckDB storage.","batch_embeddings_for_duckdb:83:async (texts:Sequence[str], *, client:AsyncOpenAI | None = None, model:str | None = None, dimensions:int | None = None,)>list[list[float] | None]:_to_float32:Generate float32 embeddings for several texts in a single API call.","normalize_scores:104:(scores:Sequence[float])>list[float]::Min-max normalise scores to the [0, 1] range.","weighted_fusion:126:(results_a:Sequence[ScoreTuple], results_b:Sequence[ScoreTuple], *, weight_a:float = 0.3, weight_b:float = 0.7, normalise:bool = True,)>list[ScoreTuple]:normalize_scores:Combine two result sets using weighted score fusion.","rrf_fusion:159:(results_a:Sequence[ScoreTuple], results_b:Sequence[ScoreTuple], *, k:int = 60, weight_a:float = 0.5, weight_b:float = 0.5,)>list[ScoreTuple]::Combine two result sets using Reciprocal Rank Fusion (RRF).","l2_to_cosine_similarity:177:(l2_distance:float)>float::Convert an L2 distance to an approximate cosine similarity.","_to_float32:182:(values:Sequence[float])>list[float]::Convert an iterable of floats to 32-bit precision.","create_fts_index:196:(conn:duckdb.DuckDBPyConnection, table:str, id_column:str, *text_columns:str, stemmer:str = \"porter\", stopwords:str = \"english\", lower:int = 0, overwrite:bool = True,)>None:create_fts_index:","create_hnsw_index:237:(conn:duckdb.DuckDBPyConnection, table:str, column:str, index_name:str | None = None, *, metric:str = \"cosine\", ef_construction:int = 128, ef_search:int = 64, m:int = 16,)>None::","drop_search_indexes:271:(conn:duckdb.DuckDBPyConnection, table:str, hnsw_index_name:str | None = None,)>None::"]],"sr/findingmodel/tools/evaluators.py":["p",{"PerformanceEvaluator":["34",["evaluate:81:(self, ctx:EvaluatorContext[InputT, OutputT, MetadataT])>float::"]]}],"sr/findingmodel/tools/finding_description.py":["p",["create_info_from_name:17:async (finding_name:str, model_name:str = settings.openai_default_model)>FindingInfo:_create_finding_info_agent,_normalize_finding_info:","_normalize_finding_info:39:(finding_info:FindingInfo, *, original_input:str)>FindingInfo::Trim whitespace, deduplicate synonyms, and ensure the original term is preser...","_create_finding_info_agent:72:(model_name:str, instructions:str)>Agent[None, FindingInfo]::Factory to build the finding info agent, extracted for easier testing overrides.","add_details_to_info:84:async (finding:FindingInfo, model_name:str = settings.perplexity_default_model)>FindingInfo | None::","describe_finding_name:120:async (finding_name:str, model_name:str = settings.openai_default_model)>FindingInfo:create_info_from_name:","get_detail_on_finding:133:async (finding:FindingInfo, model_name:str = settings.perplexity_default_model)>FindingInfo | None:add_details_to_info:","create_finding_info_from_name:147:async (finding_name:str, model_name:str = settings.openai_default_model)>FindingInfo:create_info_from_name:","add_details_to_finding_info:162:async (finding:FindingInfo, model_name:str = settings.perplexity_default_model)>FindingInfo | None:add_details_to_info:"]],"sr/findingmodel/tools/index_codes.py":["p",["_add_index_codes:11:(target:Codeable, name:str)>None::","add_standard_codes_to_model:26:(finding_model:FindingModelFull)>None:_add_index_codes:","add_standard_codes_to_finding_model:40:(finding_model:FindingModelFull)>None:add_standard_codes_to_model:"],{"Codeable":["7",[]]}],"sr/findingmodel/tools/markdown_in.py":["p",["create_model_from_markdown:21:async (finding_info:FindingInfo, /, markdown_path:str | Path | None = None, markdown_text:str | None = None, openai_model:str = settings.openai_default_model,)>FindingModelBase::","create_finding_model_from_markdown:60:async (finding_info:FindingInfo, /, markdown_path:str | Path | None = None, markdown_text:str | None = None, openai_model:str = settings.openai_default_model,)>FindingModelBase:create_model_from_markdown:"]],"sr/findingmodel/tools/model_editor.py":["p",["_get_index:18:()>Index::Get or create module-level Index instance.","_combine_instruction_sections:41:(*sections:str)>str::","_common_editing_instructions:45:()>str:_combine_instruction_sections:","_natural_language_instructions:71:()>str:_combine_instruction_sections:","_edited_text_instructions:79:()>str:_combine_instruction_sections:","create_edit_agent:89:()>Agent[EditDeps, EditResult]:_basic_edit_validation,_combine_instruction_sections,_common_editing_instructions,_natural_language_instructions,_normalize_new_attribute_ids,_validate_output:","create_markdown_edit_agent:122:()>Agent[EditDeps, EditResult]:_basic_edit_validation,_combine_instruction_sections,_common_editing_instructions,_edited_text_instructions,_normalize_new_attribute_ids,_validate_output:","edit_model_natural_language:162:async (model:FindingModelFull, command:str, *, agent:Agent[EditDeps, EditResult] | None = None)>EditResult:create_edit_agent:","_render_top_metadata_lines:188:(model:FindingModelFull)>list[str]::","_render_attribute_lines:215:(attr:object)>list[str]::Render a single attribute in the simple Markdown format expected by tests.","export_model_for_editing:256:(model:FindingModelFull, *, attributes_only:bool = False)>str:_render_attribute_lines,_render_top_metadata_lines:","edit_model_markdown:278:async (model:FindingModelFull, edited_markdown:str, *, agent:Agent[EditDeps, EditResult] | None = None,)>EditResult:create_markdown_edit_agent:","_basic_edit_validation:322:(*, original:FindingModelFull, updated:FindingModelFull)>list[str]:_validate_choice_value_indices_and_bases,_validate_model_id,_validate_new_items_have_ids,_validate_original_attributes_present:Compose simple validators and return combined messages (deduped).","_normalize_new_attribute_ids:336:(*, original:FindingModelFull, updated:FindingModelFull)>None::Force placeholder IDs for newly added attributes and their values.","assign_real_attribute_ids:364:(model:FindingModelFull, *, source:str | None = None, index:Index | None = None,)>FindingModelFull:_get_index:","_validate_model_id:379:(original:FindingModelFull, updated:FindingModelFull)>list[str]::","_validate_original_attributes_present:389:(orig_attrs:Mapping[str | None, object], upd_attrs:Mapping[str | None, object])>list[str]::","_validate_new_items_have_ids:421:(orig_attrs:Mapping[str | None, object], upd_attrs:Mapping[str | None, object])>list[str]::","_validate_choice_value_indices_and_bases:443:(orig_attrs:Mapping[str | None, object], upd_attrs:Mapping[str | None, object])>list[str]:_collect_value_codes,_validate_existing_attr_suffixes,_validate_new_attr_suffixes:Top-level dispatcher across updated choice attributes.","_parse_suffix:465:(vcode:str)>int | None::","_collect_value_codes:474:(oifma_id:str | None, upd_attr:object, name:str)>tuple[list[str], list[int], list[str], int]:_parse_suffix:","_validate_new_attr_suffixes:510:(name:str, oifma_id:str | None, suffixes:list[int], values_len:int)>list[str]::","_validate_existing_attr_suffixes:524:(name:str, oifma_id:str | None, vcodes:list[str], suffixes:list[int], orig_attr:object)>list[str]:_parse_suffix:"],{"EditResult":["26",[]],"EditDeps":["36",[]]}],"sr/findingmodel/tools/ontology_concept_match.py":["p",["_filter_anatomical_concepts:65:(search_results:list[OntologySearchResult])>list[OntologySearchResult]::Filter out anatomical concepts from search results.","_add_exact_matches:91:(sorted_results:list[OntologySearchResult], query_terms:list[str], max_results:int, selected_ids:set[str])>tuple[list[OntologySearchResult], int]::Add exact matches that were ranked lower to the top results.","execute_ontology_search:121:async (query_terms:list[str], exclude_anatomical:bool = True, base_limit:int = 30, max_results:int = 12, ontologies:list[str] | None = None,)>list[OntologySearchResult]:_add_exact_matches,_filter_anatomical_concepts:","create_categorization_agent:205:()>Agent[CategorizationContext, CategorizedConcepts]::","ensure_exact_matches_post_process:262:(output:CategorizedConcepts, search_results:list[OntologySearchResult], query_terms:list[str],)>CategorizedConcepts::","create_query_generator_agent:331:()>Agent[None, list[str]]::","generate_finding_query_terms:359:async (finding_name:str, finding_description:str | None = None)>list[str]:create_query_generator_agent:","categorize_with_validation:401:async (finding_name:str, search_results:list[OntologySearchResult], query_terms:list[str],)>CategorizedConcepts:create_categorization_agent,ensure_exact_matches_post_process:","build_final_output:460:(categorized:CategorizedConcepts, search_results:list[OntologySearchResult], max_exact_matches:int = 5, max_should_include:int = 10, max_marginal:int = 10,)>CategorizedOntologyConcepts::","match_ontology_concepts:529:async (finding_name:str, finding_description:str | None = None, exclude_anatomical:bool = True, max_exact_matches:int = 5, max_should_include:int = 10, max_marginal:int = 10, ontologies:list[str] | None = None,)>CategorizedOntologyConcepts:build_final_output,categorize_with_validation,execute_ontology_search,generate_finding_query_terms:"],{"CategorizedConcepts":["27",[]],"CategorizedOntologyConcepts":["36",[]],"CategorizationContext":["57",[]]}],"sr/findingmodel/tools/ontology_search.py":["p",["normalize_concept:33:(text:str)>str::"],{"OntologySearchProtocol":["86",["search:99:async (self, queries:list[str], max_results:int = 30, filter_anatomical:bool = True,)>list[\"OntologySearchResult\"]::","__aenter__:112:async (self)>\"OntologySearchProtocol\"::Async context manager entry.","__aexit__:121:async (self, _exc_type:type[BaseException] | None, _exc_val:BaseException | None, _exc_tb:Any, # noqa:ANN401)>None::Async context manager exit.","search_parallel:131:async (self, queries:list[str], tables:list[str] | None = None, limit_per_query:int = 30, filter_anatomical:bool = False,)>list[\"OntologySearchResult\"]:search:"]],"OntologySearchResult":["146",["as_index_code:158:(self)>IndexCode:normalize_concept:Convert to IndexCode format"]],"BioOntologySearchResult":["168",["from_api_response:180:(cls, item:dict[str, Any])>\"BioOntologySearchResult\"::Create from BioOntology API response item.","to_ontology_search_result:221:(self)>OntologySearchResult::Convert to standard OntologySearchResult format."]],"BioOntologySearchResults":["244",[]],"BioOntologySearchClient":["254",["__init__:261:(self, api_key:Optional[str] = None, client:Optional[httpx.AsyncClient] = None)>None::","__aenter__:284:async (self)>\"BioOntologySearchClient\"::Async context manager entry.","__aexit__:295:async (self, exc_type:type[BaseException] | None, exc_val:BaseException | None, exc_tb:Any, # noqa:ANN401)>None::Async context manager exit.","search_bioontology:312:async (self, query:str, ontologies:Optional[list[str]] = None, page_size:int = 50, page:int = 1, include_fields:Optional[str] = None, require_exact_match:bool = False, semantic_types:Optional[list[str]] = None,)>BioOntologySearchResults:from_api_response,search:","search_all_pages:396:async (self, query:str, ontologies:Optional[list[str]] = None, max_results:int = 100, include_fields:Optional[str] = None, require_exact_match:bool = False, semantic_types:Optional[list[str]] = None,)>list[BioOntologySearchResult]:search_bioontology:","search_as_ontology_results:446:async (self, query:str, ontologies:Optional[list[str]] = None, max_results:int = 50, **kwargs:Any, # noqa:ANN401)>list[OntologySearchResult]:search_all_pages,to_ontology_search_result:","search:475:async (self, queries:list[str], max_results:int = 30, filter_anatomical:bool = True,)>list[OntologySearchResult]:search_as_ontology_results:","search_parallel:546:async (self, queries:list[str], tables:list[str] | None = None, limit_per_query:int = 30, filter_anatomical:bool = False,)>list[OntologySearchResult]:search:"]]}],"sr/findingmodel/tools/prompt_template.py":["p",["load_prompt_template:16:(template_file_name:str)>Template::","render_agent_prompt:27:(template:Template, **kwargs:Any)>tuple[str, str]:load_prompt_template,render_agent_prompt:","create_prompt_messages:75:(template:Template, **kwargs:Any)>list[ChatCompletionMessageParam]:create_prompt_messages,render_agent_prompt:"]],"sr/findingmodel/tools/similar_finding_models.py":["p",["search_models_tool:56:async (ctx:RunContext[SearchContext], query:str, limit:int = 5)>str::","create_search_agent:89:(openai_model:str)>Agent[SearchContext, SearchStrategy]::Create the search agent for gathering comprehensive results.","create_term_generation_agent:121:(openai_model:str)>Agent[None, SearchTerms]::Create a lightweight agent for generating search terms.","create_analysis_agent:154:(openai_model:str)>Agent[None, SimilarModelAnalysis]::Create the analysis agent for evaluating similarity and making recommendations.","find_similar_models:203:async (# noqa:C901 finding_name:str, description:str | None = None, synonyms:list[str] | None = None, index:Index | None = None, search_model:str | None = None, analysis_model:str | None = None,)>SimilarModelAnalysis:_generate_search_terms_with_fallback:","_generate_search_terms_with_fallback:349:async (term_prompt:str, search_model:str, finding_name:str)>list[str]:create_term_generation_agent:"],{"SearchResult":["25",[]],"SearchTerms":["34",[]],"SearchStrategy":["40",[]],"SearchContext":["50",[]],"SimilarModelAnalysis":["140",[]]}],"test/conftest.py":["p",["configure_test_logging:20:()>None::Configure logging for test session - runs once at start of session.","base_model:29:()>FindingModelBase::","full_model:56:()>FindingModelFull::","real_model:89:()>FindingModelFull::","real_model_markdown:97:()>str::","pe_fm_json:104:()>str::","tn_fm_json:111:()>str::","tn_markdown:118:()>str::","finding_info:125:()>FindingInfo::","tmp_defs_path:134:(tmp_path:Path)>Path::Create a temporary path with test files copied from test/data/defs."]],"test/test_anatomic_locations.py":["p",["_fake_openai_client:54:(*_:Any, **__:Any)>object::Return a dummy OpenAI client for patched calls.","_fake_embedding_anatomic:59:(text:str, **kwargs:Any)>list[float]::Deterministic fake embedding based on text hash.","_fake_batch_embeddings:67:async (texts:list[str], **kwargs:Any)>list[list[float] | None]:_fake_embedding_anatomic:Fake batch embeddings.","_module_anatomic_monkeypatch:74:()>Generator[None, None, None]::Module-scoped monkeypatch for anatomic migration tests.","test_find_anatomic_locations_basic_wiring:1083:async ()>None::"],{"TestOntologySearchResult":["95",["test_creation_with_all_fields:98:(self)>None::Test creating an OntologySearchResult with all fields.","test_as_index_code_radlex:107:(self)>None::Test converting a RadLex result to IndexCode.","test_as_index_code_snomedct:117:(self)>None::Test converting a SNOMED CT result to IndexCode.","test_as_index_code_anatomic_locations:129:(self)>None::Test converting an anatomic locations result to IndexCode.","test_as_index_code_unknown_table:141:(self)>None::Test converting with unknown table falls back to table name.","test_as_index_code_with_concept_normalization:152:(self)>None::Test that concept text is normalized when converting to IndexCode."]],"TestAnatomicQueryTerms":["168",["test_creation_with_region:171:(self)>None::Test creating AnatomicQueryTerms with region.","test_creation_without_region:178:(self)>None::Test creating AnatomicQueryTerms without region.","test_empty_terms:185:(self)>None::Test creating AnatomicQueryTerms with empty terms."]],"TestLocationSearchResponse":["193",["test_creation:196:(self)>None::Test creating LocationSearchResponse."]],"TestGenerateAnatomicQueryTerms":["215",["test_successful_generation:219:async (self)>None::Test successful query term generation.","test_generation_with_description:232:async (self)>None::Test query term generation with description.","test_generation_fallback_on_error:242:async (self)>None::Test fallback when generation fails."]],"TestExecuteAnatomicSearch":["254",["test_search_with_duckdb:258:async (self)>None::Test executing search with DuckDB client.","test_search_without_region:282:async (self)>None::Test executing search without region filter."]],"TestCreateLocationSelectionAgent":["298",["test_agent_creation:301:(self)>None::Test creating location selection agent.","test_agent_with_custom_model:313:(self)>None::Test creating agent with custom model."]],"TestFindAnatomicLocations":["325",["test_successful_search_with_duckdb:329:async (self)>None::Test successful anatomic location search using DuckDB.","test_empty_search_results:376:async (self)>None::Test handling of empty search results."]],"TestCreateSearchableText":["402",["test_with_all_fields:405:(self)>None::Test creating searchable text with all fields present.","test_with_missing_synonyms:421:(self)>None::Test with missing synonyms field.","test_with_missing_definition:431:(self)>None::Test with missing definition field.","test_with_empty_synonyms_list:440:(self)>None::Test with empty synonyms list.","test_with_null_synonyms:450:(self)>None::Test with null synonyms value.","test_with_many_synonyms:459:(self)>None::Test that only first 5 synonyms are included.","test_with_long_definition:474:(self)>None::Test that long definitions are truncated.","test_with_short_definition:484:(self)>None::Test that short definitions are not truncated.","test_with_only_description:494:(self)>None::Test with only description field."]],"TestDetermineSided":["503",["test_generic_with_both_left_and_right:506:(self)>None::Test record with both leftRef and rightRef returns 'generic'.","test_left_only:514:(self)>None::Test record with only leftRef returns 'left'.","test_right_only:522:(self)>None::Test record with only rightRef returns 'right'.","test_unsided:530:(self)>None::Test record with only unsidedRef returns 'unsided'.","test_nonlateral_no_refs:538:(self)>None::Test record with no laterality refs returns 'nonlateral'.","test_nonlateral_with_unrelated_refs:546:(self)>None::Test record with only partOfRef returns 'nonlateral'.","test_generic_with_extra_refs:554:(self)>None::Test generic determination ignores other refs.","test_left_with_unsided:567:(self)>None::Test that leftRef takes precedence over unsidedRef."]],"TestLoadAnatomicData":["576",["test_load_from_local_file:580:async (self, tmp_path:Path)>None::Test loading data from local file path.","test_load_from_url:597:async (self)>None::Test loading data from URL.","test_file_not_found:615:async (self, tmp_path:Path)>None::Test error when file doesn't exist.","test_invalid_json:623:async (self, tmp_path:Path)>None::Test error when JSON is invalid.","test_not_a_list:632:async (self, tmp_path:Path)>None::Test error when JSON is not a list.","test_network_error:641:async (self)>None::Test handling of network errors.","test_http_error:652:async (self)>None:raise_http_error:Test handling of HTTP errors.","raise_http_error:655:()>None::"]],"TestValidateAnatomicRecord":["671",["test_valid_record_with_all_fields:674:(self)>None::Test validation of a complete valid record.","test_valid_record_minimal:688:(self)>None::Test validation of minimal valid record.","test_missing_id:696:(self)>None::Test error when _id is missing.","test_missing_description:705:(self)>None::Test error when description is missing.","test_multiple_missing_fields:714:(self)>None::Test multiple validation errors.","test_invalid_synonyms_type:724:(self)>None::Test error when synonyms is not a list.","test_empty_synonyms_list_valid:734:(self)>None::Test that empty synonyms list is valid.","test_empty_id:742:(self)>None::Test error when _id is empty string.","test_empty_description:751:(self)>None::Test error when description is empty string."]],"TestCreateAnatomicDatabase":["761",["test_successful_database_creation:765:async (self, tmp_path:Path)>None::Test successful creation of anatomic database.","test_database_with_multiple_records:802:async (self, tmp_path:Path)>None::Test creating database with multiple records.","test_database_with_validation_errors:825:async (self, tmp_path:Path)>None::Test handling of invalid records during database creation.","test_database_indexes_created:845:async (self, tmp_path:Path)>None::Test that indexes are created properly.","test_database_with_batch_processing:871:async (self, tmp_path:Path)>None:mock_batch_embeddings:Test batch processing with batch_size parameter.","mock_batch_embeddings:886:async (texts:list[str], **kwargs:Any)>list[list[float]]::"]],"TestGetDatabaseStats":["902",["test_stats_for_valid_database:906:async (self, tmp_path:Path)>None::Test getting stats from a valid database.","test_stats_database_not_found:931:(self, tmp_path:Path)>None::Test error when database file doesn't exist.","test_stats_empty_database:939:async (self, tmp_path:Path)>None::Test stats for database with no records.","test_stats_sided_distribution:955:async (self, tmp_path:Path)>None::Test sided distribution in stats."]],"TestAnatomicCLI":["987",["test_build_basic:990:(self, tmp_path:Path, _module_anatomic_monkeypatch:None)>None:_fake_openai_client:Happy path: build from local file.","test_build_error_no_api_key:1005:(self, tmp_path:Path, _module_anatomic_monkeypatch:None)>None::Error case: missing API key.","test_validate_basic:1020:(self, _module_anatomic_monkeypatch:None)>None::Happy path: validate valid data.","test_validate_error_invalid_data:1029:(self, tmp_path:Path, _module_anatomic_monkeypatch:None)>None::Error case: validation errors.","test_stats_basic:1045:(self, tmp_path:Path, _module_anatomic_monkeypatch:None)>None:_fake_openai_client:Happy path: show stats.","test_stats_error_no_database:1064:(self, tmp_path:Path, _module_anatomic_monkeypatch:None)>None::Error case: database not found (custom path with no remote URL)."]]}],"test/test_cli.py":["p",["_fake_openai_client:26:(*_:Any, **__:Any)>object::Return a dummy OpenAI client for patched calls.","_fake_embedding_deterministic:37:async (text:str, *, client:object | None = None, model:str | None = None, dimensions:int | None = None,)>list[float]::Deterministic fake embedding based on text hash.","_fake_client_for_testing:47:async ()>object:_fake_openai_client:Return fake OpenAI client for testing.","_session_cli_monkeypatch_setup:54:()>Generator[None, None, None]:_fake_client_for_testing,_fake_embedding_deterministic:","test_index_build_basic:84:(tmp_path:Path, tmp_defs_path:Path, _session_cli_monkeypatch_setup:None)>None::Test happy path: build from directory.","test_index_build_error_no_openai_key:97:(tmp_path:Path, _session_cli_monkeypatch_setup:None)>None::Test error: missing API key.","test_index_update_basic:117:(tmp_path:Path, tmp_defs_path:Path, _session_cli_monkeypatch_setup:None)>None::Test happy path: update existing index.","test_index_update_creates_database_if_not_exists:138:(tmp_path:Path, tmp_defs_path:Path, _session_cli_monkeypatch_setup:None)>None::Test that update creates database if it doesn't exist.","test_index_validate_basic:159:(tmp_path:Path, tmp_defs_path:Path, _session_cli_monkeypatch_setup:None)>None::Test happy path: validate directory.","test_index_validate_detects_errors:169:(tmp_path:Path, _session_cli_monkeypatch_setup:None)>None::Test error: validation errors found.","test_index_stats_basic:205:(tmp_path:Path, tmp_defs_path:Path, _session_cli_monkeypatch_setup:None)>None::Test happy path: show stats.","test_index_stats_with_empty_database:221:(tmp_path:Path, _session_cli_monkeypatch_setup:None)>None::Test stats on empty database (created on-demand with base contributors)."]],"test/test_config.py":["p",["test_remote_anatomic_url_without_hash_raises_error:8:(monkeypatch:MonkeyPatch)>None::Test that providing only URL without hash for anatomic DB raises validation e...","test_remote_anatomic_hash_without_url_raises_error:19:(monkeypatch:MonkeyPatch)>None::Test that providing only hash without URL for anatomic DB raises validation e...","test_remote_index_url_without_hash_raises_error:30:(monkeypatch:MonkeyPatch)>None::Test that providing only URL without hash for index DB raises validation error.","test_remote_index_hash_without_url_raises_error:41:(monkeypatch:MonkeyPatch)>None::Test that providing only hash without URL for index DB raises validation error.","test_remote_config_with_both_url_and_hash_succeeds:52:(monkeypatch:MonkeyPatch)>None::Test that providing both URL and hash succeeds.","test_remote_config_with_neither_succeeds:68:(monkeypatch:MonkeyPatch)>None::Test that providing neither URL nor hash succeeds (uses manifest)."]],"test/test_duckdb_index.py":["p",["_fake_openai_client:35:(*_:Any, **__:Any)>object::Return a dummy OpenAI client for patched calls.","_write_model_file:40:(path:Path, data:FindingModelFull)>None::Write a FindingModelFull to a JSON file.","_table_count:45:(conn:duckdb.DuckDBPyConnection, table:str)>int::Get row count from a table.","_hnsw_index_exists:52:(conn:duckdb.DuckDBPyConnection)>bool::Check if HNSW index exists on finding_models table.","_fts_index_works:58:(conn:duckdb.DuckDBPyConnection)>bool::Check if FTS index is functional.","_fake_embedding_deterministic:101:async (text:str, *, client:object | None = None, model:str | None = None, dimensions:int | None = None,)>list[float]::Deterministic fake embedding based on text hash.","_fake_client_for_testing:111:async ()>object:_fake_openai_client:Return fake OpenAI client for testing.","event_loop:118:()>Generator[asyncio.AbstractEventLoop, None, None]::","_session_monkeypatch_setup:131:()>Generator[None, None, None]:_fake_client_for_testing,_fake_embedding_deterministic:","session_populated_index:160:async (tmp_path_factory:pytest.TempPathFactory, _session_monkeypatch_setup:None)>AsyncGenerator[DuckDBIndex, None]::","index:198:async (tmp_path:Path, monkeypatch:pytest.MonkeyPatch)>AsyncGenerator[DuckDBIndex, None]:_fake_openai_client,fake_client,fake_embedding:Create a DuckDBIndex for testing with mocked OpenAI client.","populated_index:236:async (index:DuckDBIndex, tmp_defs_path:Path)>DuckDBIndex::Populate the index with all *.fm.json files from test/data/defs.","test_add_and_retrieve_model:258:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test adding a model and retrieving it by ID.","test_validate_model_no_duplicates:275:(index:DuckDBIndex, full_model:FindingModelFull)>None::Test that validation passes when no duplicates exist.","test_contains_method:282:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test the contains method with ID and name lookups.","test_count_method:299:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test that count returns correct number of models.","test_populated_index_count:316:async (session_populated_index:DuckDBIndex)>None::Test count on populated index.","test_populated_index_retrieval:324:async (session_populated_index:DuckDBIndex)>None::Test retrieving all models from populated index.","test_add_already_existing_model_unchanged:333:async (populated_index:DuckDBIndex, tmp_defs_path:Path)>None::Test that adding an unchanged model returns 'unchanged'.","test_add_new_model:343:async (populated_index:DuckDBIndex, tmp_defs_path:Path)>None::Test adding a new model to populated index.","test_add_updated_model_file:360:async (populated_index:DuckDBIndex, tmp_defs_path:Path)>None:_write_model_file:Test updating an existing model file.","test_remove_not_found_model:384:async (populated_index:DuckDBIndex, tmp_defs_path:Path)>None::Test removing entries not in the filenames list (equivalent to remove_unused_...","test_duplicate_oifm_id_fails_validation:417:(session_populated_index:DuckDBIndex, full_model:FindingModelFull)>None::Test validation fails when OIFM ID already exists.","test_duplicate_name_fails_validation:425:(session_populated_index:DuckDBIndex, full_model:FindingModelFull)>None::Test validation fails when name already exists (case-insensitive).","test_duplicate_attribute_id_fails_validation:437:(session_populated_index:DuckDBIndex, full_model:FindingModelFull)>None::Test validation fails when attribute ID is used by another model.","test_update_from_directory:455:async (populated_index:DuckDBIndex, tmp_defs_path:Path)>None:_write_model_file:Test the update_from_directory method with add, modify, and delete operations.","test_update_from_directory_empty_directory:514:async (populated_index:DuckDBIndex, tmp_path:Path)>None::Test update_from_directory with an empty directory removes all entries.","test_update_from_directory_nonexistent_directory:537:async (populated_index:DuckDBIndex, tmp_path:Path)>None::Test update_from_directory with a nonexistent directory raises ValueError.","test_search_basic_functionality:551:async (session_populated_index:DuckDBIndex)>None::Test basic search functionality with populated index.","test_search_by_name:568:async (session_populated_index:DuckDBIndex)>None::Test search functionality by exact and partial name matches.","test_search_by_description:582:async (session_populated_index:DuckDBIndex)>None::Test search functionality using description content.","test_search_by_synonyms:594:async (session_populated_index:DuckDBIndex)>None::Test search functionality using synonyms.","test_search_limit_parameter:604:async (session_populated_index:DuckDBIndex)>None::Test that search respects the limit parameter.","test_search_no_results:619:async (session_populated_index:DuckDBIndex)>None::Test search with query that should return no results.","test_search_empty_query:628:async (session_populated_index:DuckDBIndex)>None::Test search behavior with empty query.","test_search_case_insensitive:636:async (session_populated_index:DuckDBIndex)>None::Test that search is case insensitive.","test_search_multiple_terms:647:async (session_populated_index:DuckDBIndex)>None::Test search with multiple terms.","test_search_with_empty_index:661:async (index:DuckDBIndex)>None::Test search functionality with empty index.","test_add_entry_with_invalid_json_file:674:async (index:DuckDBIndex, tmp_path:Path)>None::Test error handling when adding file with invalid JSON.","test_add_entry_with_nonexistent_file:686:async (index:DuckDBIndex, tmp_path:Path)>None::Test error handling when adding nonexistent file.","test_add_entry_with_invalid_model_data:696:async (index:DuckDBIndex, tmp_path:Path)>None::Test error handling when adding file with invalid model data.","test_batch_operation_partial_failure:714:async (index:DuckDBIndex, tmp_path:Path, full_model:FindingModelFull)>None:_write_model_file:Test behavior when batch operations partially fail.","test_concurrent_index_operations:736:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file,add_file:Test Index behavior under concurrent operations.","test_large_query_handling:769:async (index:DuckDBIndex)>None::Test Index behavior with very large search queries.","test_get_person:790:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test retrieving a person by github username.","test_get_organization:814:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test retrieving an organization by code.","test_get_people:839:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test retrieving all people from the index.","test_get_organizations:865:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test retrieving all organizations from the index.","test_count_people:891:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test counting people in the index.","test_count_organizations:928:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test counting organizations in the index.","test_denormalized_synonyms_table:954:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_table_count,_write_model_file:Test that synonyms table is populated correctly.","test_denormalized_tags_table:973:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_table_count,_write_model_file:Test that tags table is populated correctly.","test_denormalized_attributes_table:992:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_table_count,_write_model_file:Test that attributes table is populated correctly.","test_denormalized_model_people_table:1017:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_table_count,_write_model_file:Test that model_people junction table is populated correctly.","test_denormalized_model_organizations_table:1045:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_table_count,_write_model_file:Test that model_organizations junction table is populated correctly.","test_remove_entry_clears_related_rows:1074:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_table_count,_write_model_file:Test that removing an entry clears all denormalized table rows.","test_setup_creates_search_indexes:1108:(index:DuckDBIndex)>None:_fts_index_works,_hnsw_index_exists:Test that setup() creates both HNSW and FTS indexes.","test_write_operations_rebuild_search_indexes:1118:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_fts_index_works,_hnsw_index_exists,_write_model_file:Test that write operations drop and rebuild search indexes.","test_batch_update_rebuilds_indexes_once:1137:async (index:DuckDBIndex, tmp_defs_path:Path)>None:_fts_index_works,_hnsw_index_exists:Test that batch directory update rebuilds indexes once, not per file.","test_search_with_single_tag:1155:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test search with single tag filter.","test_search_with_multiple_tags_and_logic:1197:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test search with multiple tags (AND logic - must have ALL).","test_search_with_nonexistent_tags:1228:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test search with tags that don't exist.","test_tag_filtering_works_in_all_search_paths:1245:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test that tag filtering works in exact, FTS, and semantic search paths.","test_search_batch_multiple_queries:1279:async (session_populated_index:DuckDBIndex)>None::Test batching multiple queries efficiently.","test_search_batch_all_queries_return_results:1295:async (session_populated_index:DuckDBIndex)>None::Test that all queries in batch return their results.","test_search_batch_empty_queries_list:1306:async (index:DuckDBIndex)>None::Test search_batch with empty queries list.","test_search_batch_with_valid_and_invalid_queries:1313:async (session_populated_index:DuckDBIndex)>None::Test search_batch with mix of valid and invalid queries.","test_update_from_directory_batch_add:1333:async (index:DuckDBIndex, tmp_defs_path:Path)>None::Test batch directory ingestion - add scenario.","test_update_from_directory_batch_update:1346:async (populated_index:DuckDBIndex, tmp_defs_path:Path)>None:_write_model_file:Test batch directory ingestion - update scenario.","test_update_from_directory_batch_delete:1362:async (populated_index:DuckDBIndex, tmp_defs_path:Path)>None::Test batch directory ingestion - delete scenario.","test_update_from_directory_batch_mixed:1383:async (populated_index:DuckDBIndex, tmp_defs_path:Path)>None:_write_model_file:Test batch directory ingestion - mixed add/update/delete scenario.","test_update_from_directory_no_changes:1414:async (populated_index:DuckDBIndex, tmp_defs_path:Path)>None::Test update_from_directory when no changes are needed.","test_read_only_mode_blocks_writes:1432:async (full_model:FindingModelFull, tmp_path:Path, monkeypatch:pytest.MonkeyPatch)>None:_fake_openai_client,_write_model_file,fake_client:Test that read-only mode prevents write operations.","test_search_latency_benchmark:1470:async (session_populated_index:DuckDBIndex)>None::Test that search latency is reasonable (< 200ms for typical query).","test_batch_embedding_optimization:1484:async (session_populated_index:DuckDBIndex)>None::Test that search_batch is faster than individual searches.","test_directory_sync_performance:1509:async (index:DuckDBIndex, tmp_defs_path:Path)>None::Test that directory sync with 10+ models completes in reasonable time.","test_semantic_search_returns_results:1530:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test semantic search with HNSW returns results (uses fake embeddings).","test_semantic_search_with_precomputed_embedding:1550:async (tmp_path:Path, full_model:FindingModelFull)>None::Test semantic search using pre-computed embedding (deterministic, no API calls).","test_semantic_search_with_real_openai_api:1654:async (tmp_path:Path, full_model:FindingModelFull)>None:_write_model_file:Test semantic search using real OpenAI API (requires OPENAI_API_KEY).","test_remove_entry_when_not_exists:1688:async (index:DuckDBIndex)>None::Test removing an entry that doesn't exist returns False.","test_all_pagination:1705:async (session_populated_index:DuckDBIndex)>None::Test that all() respects limit and offset.","test_all_sorting_all_fields:1729:async (session_populated_index:DuckDBIndex)>None::Test all valid fields for ordering (name, oifm_id, created_at, updated_at, sl...","test_all_case_insensitive_sorting:1765:async (session_populated_index:DuckDBIndex)>None::Verify LOWER() works for name/slug_name.","test_all_invalid_order_by:1784:async (session_populated_index:DuckDBIndex)>None::Verify ValueError raised for invalid order_by.","test_all_invalid_order_dir:1797:async (session_populated_index:DuckDBIndex)>None::Verify ValueError raised for invalid order_dir.","test_all_empty_database:1810:async (index:DuckDBIndex)>None::Verify returns ([], 0) for empty database.","test_all_single_page:1818:async (session_populated_index:DuckDBIndex)>None::Verify works with results < limit.","test_search_by_slug_exact_match:1835:async (session_populated_index:DuckDBIndex)>None::Verify exact match type finds only exact matches.","test_search_by_slug_prefix_match:1850:async (session_populated_index:DuckDBIndex)>None::Verify prefix match type finds slug_name.startswith(pattern).","test_search_by_slug_contains_match:1866:async (session_populated_index:DuckDBIndex)>None::Verify contains match type finds slug_name.__contains__(pattern).","test_search_by_slug_relevance_ranking:1882:async ()>None:_write_model_file,fake_embedding,populated_index:Verify exact > prefix > contains, then alphabetical.","test_search_by_slug_pattern_normalization:1991:async (session_populated_index:DuckDBIndex)>None::Verify normalize_name() called on pattern.","test_search_by_slug_pagination:2005:async (session_populated_index:DuckDBIndex)>None::Verify limit/offset work.","test_search_by_slug_no_matches:2023:async (session_populated_index:DuckDBIndex)>None::Verify returns ([], 0) for no matches.","test_count_search_exact_match:2036:async (session_populated_index:DuckDBIndex)>None::Verify count with exact match type.","test_count_search_prefix_match:2048:async (session_populated_index:DuckDBIndex)>None::Verify count with prefix match type.","test_count_search_contains_match:2060:async (session_populated_index:DuckDBIndex)>None::Verify count with contains match type.","test_count_search_empty_database:2072:async (index:DuckDBIndex)>None::Verify returns 0 for empty database.","test_generate_model_id_format:2088:(session_populated_index:DuckDBIndex)>None::Test that generate_model_id() returns correctly formatted IDs.","test_generate_model_id_uniqueness:2097:(session_populated_index:DuckDBIndex)>None::Test that generate_model_id() generates unique IDs in batch.","test_generate_model_id_different_sources_independent:2104:(session_populated_index:DuckDBIndex)>None::Test that different sources have independent ID spaces.","test_generate_model_id_collision_avoidance:2120:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test that collision detection works by pre-populating database with IDs.","test_generate_model_id_cache_prevents_self_collision:2147:(session_populated_index:DuckDBIndex)>None::Test that cache prevents self-collision when generating multiple IDs in same ...","test_generate_model_id_invalid_source_too_short:2161:(session_populated_index:DuckDBIndex)>None::Test that generate_model_id() rejects source codes that are too short.","test_generate_model_id_invalid_source_too_long:2170:(session_populated_index:DuckDBIndex)>None::Test that generate_model_id() rejects source codes that are too long.","test_generate_model_id_invalid_source_contains_digits:2179:(session_populated_index:DuckDBIndex)>None::Test that generate_model_id() rejects source codes with digits.","test_generate_model_id_source_normalization:2188:(session_populated_index:DuckDBIndex)>None::Test that source code is normalized (trimmed and uppercased).","test_generate_model_id_max_attempts_exhausted:2205:(session_populated_index:DuckDBIndex, monkeypatch:pytest.MonkeyPatch)>None:mock_random_digits:Test that RuntimeError is raised when max_attempts is exhausted.","test_generate_attribute_id_format:2230:(session_populated_index:DuckDBIndex)>None::Test that generate_attribute_id() returns correctly formatted IDs.","test_generate_attribute_id_uniqueness:2239:(session_populated_index:DuckDBIndex)>None::Test that generate_attribute_id() generates unique IDs in batch.","test_generate_attribute_id_independent_from_oifm_ids:2246:(session_populated_index:DuckDBIndex)>None::Test that attribute IDs (OIFMA) are independent from model IDs (OIFM).","test_generate_attribute_id_infer_source_from_model_id:2263:(session_populated_index:DuckDBIndex)>None::Test that generate_attribute_id() can infer source from model OIFM ID.","test_generate_attribute_id_explicit_source_overrides_inference:2272:(session_populated_index:DuckDBIndex)>None::Test that explicit source parameter overrides inference from model_oifm_id.","test_generate_attribute_id_default_source:2281:(session_populated_index:DuckDBIndex)>None::Test that generate_attribute_id() defaults to 'OIDM' when no source provided.","test_generate_attribute_id_invalid_model_id_format:2290:(session_populated_index:DuckDBIndex)>None::Test that generate_attribute_id() rejects invalid model ID formats.","test_generate_attribute_id_invalid_source:2305:(session_populated_index:DuckDBIndex)>None::Test that generate_attribute_id() rejects invalid source codes.","test_generate_attribute_id_collision_avoidance:2320:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test that attribute ID collision detection works.","test_generate_attribute_id_cache_prevents_self_collision:2348:(session_populated_index:DuckDBIndex)>None::Test that cache prevents self-collision for attribute IDs.","test_load_oifm_ids_for_source_caching:2370:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test that _load_oifm_ids_for_source() caches results.","test_load_oifma_ids_for_source_caching:2395:async (index:DuckDBIndex, full_model:FindingModelFull, tmp_path:Path)>None:_write_model_file:Test that _load_oifma_ids_for_source() caches results.","test_add_ids_to_model_complete_new_model:2423:(index:DuckDBIndex)>None::Test add_ids_to_model generates all IDs for a new model.","test_add_ids_to_model_existing_oifm_id:2458:(index:DuckDBIndex)>None::Test add_ids_to_model preserves existing OIFM ID when using FindingModelFull.","test_add_ids_to_model_partial_attribute_ids:2498:(index:DuckDBIndex)>None::Test add_ids_to_model generates IDs for attributes without them.","test_add_ids_to_model_all_ids_present:2543:(index:DuckDBIndex, full_model:FindingModelFull)>None::Test add_ids_to_model preserves all IDs when model is already complete.","test_add_ids_to_model_source_used:2559:(index:DuckDBIndex)>None::Test add_ids_to_model uses the specified source code.","test_add_ids_to_model_invalid_source_too_short:2585:(index:DuckDBIndex, base_model:FindingModelBase)>None::Test add_ids_to_model rejects invalid source (too short).","test_add_ids_to_model_invalid_source_too_long:2591:(index:DuckDBIndex, base_model:FindingModelBase)>None::Test add_ids_to_model rejects invalid source (too long).","test_add_ids_to_model_invalid_source_contains_digits:2597:(index:DuckDBIndex, base_model:FindingModelBase)>None::Test add_ids_to_model rejects invalid source (contains digits).","test_finalize_placeholder_single_placeholder:2603:(index:DuckDBIndex)>None::Test finalize_placeholder_attribute_ids replaces a single placeholder.","test_finalize_placeholder_multiple_placeholders:2644:(index:DuckDBIndex)>None::Test finalize_placeholder_attribute_ids replaces multiple placeholders with u...","test_finalize_placeholder_no_placeholders:2693:(index:DuckDBIndex, full_model:FindingModelFull)>None::Test finalize_placeholder_attribute_ids returns original model when no placeh...","test_finalize_placeholder_source_inference:2702:(index:DuckDBIndex)>None::Test finalize_placeholder_attribute_ids infers source from model OIFM ID.","test_finalize_placeholder_explicit_source_override:2732:(index:DuckDBIndex)>None::Test finalize_placeholder_attribute_ids uses explicit source over inference.","test_finalize_placeholder_choice_value_codes:2762:(index:DuckDBIndex)>None::Test finalize_placeholder_attribute_ids renumbers value codes for choice attr...","test_finalize_placeholder_invalid_source:2803:(index:DuckDBIndex)>None::Test finalize_placeholder_attribute_ids rejects invalid explicit source.","test_finalize_placeholder_invalid_model_id_inference:2834:(index:DuckDBIndex)>None::Test finalize_placeholder_attribute_ids fails when model ID is malformed and ..."]],"test/test_duckdb_utils.py":["p",["_fts_index_exists:19:(conn:duckdb.DuckDBPyConnection, table:str)>bool::Check if FTS index exists for a table.","_hnsw_index_exists:29:(conn:duckdb.DuckDBPyConnection, index_name:str)>bool::Check if HNSW index exists by name.","memory_conn:41:()>duckdb.DuckDBPyConnection::Create an in-memory DuckDB connection with extensions loaded.","test_table:53:(memory_conn:duckdb.DuckDBPyConnection)>str::Create a test table with text columns for FTS testing.","vector_table:73:(memory_conn:duckdb.DuckDBPyConnection)>str::Create a test table with vector column for HNSW testing.","test_create_fts_index_basic:98:(memory_conn:duckdb.DuckDBPyConnection, test_table:str)>None:_fts_index_exists:Test creating FTS index with default parameters.","test_create_fts_index_custom_parameters:115:(memory_conn:duckdb.DuckDBPyConnection, test_table:str)>None:_fts_index_exists:Test creating FTS index with custom stemmer, stopwords, and lower settings.","test_create_fts_index_multiple_columns:141:(memory_conn:duckdb.DuckDBPyConnection, test_table:str)>None:_fts_index_exists:Test creating FTS index on multiple text columns.","test_create_fts_index_no_text_columns:158:(memory_conn:duckdb.DuckDBPyConnection, test_table:str)>None::Test that creating FTS index without text columns raises ValueError.","test_create_hnsw_index_basic:169:(memory_conn:duckdb.DuckDBPyConnection, vector_table:str)>None:_hnsw_index_exists:Test creating HNSW index with default parameters and auto-generated name.","test_create_hnsw_index_custom_name:179:(memory_conn:duckdb.DuckDBPyConnection, vector_table:str)>None:_hnsw_index_exists:Test creating HNSW index with explicit custom name.","test_create_hnsw_index_custom_metric:188:(memory_conn:duckdb.DuckDBPyConnection, vector_table:str)>None:_hnsw_index_exists:Test creating HNSW index with L2 squared metric instead of cosine.","test_create_hnsw_index_custom_parameters:204:(memory_conn:duckdb.DuckDBPyConnection, vector_table:str)>None:_hnsw_index_exists:Test creating HNSW index with custom ef_construction, ef_search, and m parame...","test_drop_search_indexes_both:226:(memory_conn:duckdb.DuckDBPyConnection, test_table:str, vector_table:str)>None:_fts_index_exists,_hnsw_index_exists:Test dropping both FTS and HNSW indexes.","test_drop_search_indexes_fts_only:254:(memory_conn:duckdb.DuckDBPyConnection, test_table:str)>None:_fts_index_exists:Test dropping FTS index when no HNSW index exists.","test_drop_search_indexes_missing_gracefully:269:(memory_conn:duckdb.DuckDBPyConnection, test_table:str)>None:_fts_index_exists:Test that dropping non-existent indexes doesn't raise errors."]],"test/test_embedding_cache.py":["p",["cache:18:async (tmp_path:Path)>AsyncGenerator[EmbeddingCache, None]::Create an EmbeddingCache for testing.","test_setup_creates_schema:35:async (tmp_path:Path)>None::Test that setup() creates the cache schema correctly.","test_store_and_get_embedding_round_trip:62:async (cache:EmbeddingCache)>None::Test storing and retrieving an embedding successfully.","test_get_embedding_cache_miss:84:async (cache:EmbeddingCache)>None::Test that get_embedding returns None for cache miss.","test_embeddings_stored_with_float32_precision:91:async (cache:EmbeddingCache)>None::Test that embeddings are stored with float32 precision.","test_store_and_get_embeddings_batch:117:async (cache:EmbeddingCache)>None::Test batch storage and retrieval of embeddings.","test_batch_partial_cache_hits:142:async (cache:EmbeddingCache)>None::Test batch retrieval with some cached and some not cached.","test_batch_empty_returns_empty_list:162:async (cache:EmbeddingCache)>None::Test that empty batch returns empty list.","test_batch_order_preservation:172:async (cache:EmbeddingCache)>None::Test that batch operations preserve order of results.","test_same_text_same_model_returns_cached:207:async (cache:EmbeddingCache)>None::Test that same text with same model/dimensions returns cached result.","test_different_text_returns_different_results:226:async (cache:EmbeddingCache)>None::Test that different text returns different results.","test_cache_limitation_with_model_variations:251:async (cache:EmbeddingCache)>None::","test_cache_limitation_with_dimension_variations:274:async (cache:EmbeddingCache)>None::","test_clear_cache_no_filters_clears_all:303:async (cache:EmbeddingCache)>None::Test that clear_cache() with no filters clears all entries.","test_clear_cache_specific_model_only:325:async (cache:EmbeddingCache)>None::Test that clear_cache(model=...) only clears specific model.","test_clear_cache_older_than_days:348:async (cache:EmbeddingCache)>None::","test_clear_cache_combined_filters:385:async (cache:EmbeddingCache)>None::","test_context_manager_setup_and_cleanup:433:async (tmp_path:Path)>None::Test that async with EmbeddingCache() works correctly.","test_context_manager_cleanup_on_exception:452:async (tmp_path:Path)>None::Test that context manager cleans up even on exception.","test_store_embedding_wrong_dimensions_not_cached:476:async (cache:EmbeddingCache)>None::Test that embeddings with wrong dimensions are not cached.","test_batch_store_text_embedding_count_mismatch:492:async (cache:EmbeddingCache)>None::Test that batch store handles text/embedding count mismatch gracefully.","test_batch_store_skips_invalid_dimensions:506:async (cache:EmbeddingCache)>None::Test that batch store skips embeddings with wrong dimensions.","test_operations_continue_after_cache_errors:527:async (tmp_path:Path)>None::","test_concurrent_cache_operations:551:async (cache:EmbeddingCache)>None:store_embedding_task:Test that concurrent cache operations don't cause issues.","test_cache_with_special_characters_in_text:574:async (cache:EmbeddingCache)>None::Test that cache handles text with special characters correctly.","test_cache_empty_text_string:597:async (cache:EmbeddingCache)>None::Test that cache handles empty text string correctly."]],"test/test_index_validation.py":["p",["another_model:49:()>FindingModelFull::Create another model with different IDs for conflict testing.","test_mock_validation_context_implements_protocol:73:async ()>None:get_attribute_ids_by_model,get_existing_names,get_existing_oifm_ids:Test that MockValidationContext correctly implements the ValidationContext pr...","test_validation_context_accepts_different_implementations:93:async ()>None:get_attribute_ids_by_model,get_existing_names,get_existing_oifm_ids:Test that ValidationContext protocol works with multiple implementations.","test_check_oifm_id_conflict_no_conflict:116:(full_model:FindingModelFull)>None::Test that no conflict is detected when ID is unique.","test_check_oifm_id_conflict_detects_duplicate:123:(full_model:FindingModelFull)>None::Test that conflict is detected when ID already exists.","test_check_oifm_id_conflict_allow_self_permits_duplicate:132:(full_model:FindingModelFull)>None::Test that allow_self=True permits the model's own ID (for updates).","test_check_oifm_id_conflict_allow_self_false_blocks_duplicate:139:(full_model:FindingModelFull)>None::Test that allow_self=False blocks the model's own ID.","test_check_oifm_id_conflict_empty_existing_set:147:(full_model:FindingModelFull)>None::Test with empty existing IDs set.","test_check_name_conflict_no_conflict:155:(full_model:FindingModelFull)>None::Test that no conflict is detected when name is unique.","test_check_name_conflict_detects_case_insensitive_duplicate:162:(full_model:FindingModelFull)>None::Test that conflict is detected with case-insensitive matching.","test_check_name_conflict_detects_exact_case_match:172:(full_model:FindingModelFull)>None::Test detection of exact case match.","test_check_name_conflict_detects_normalized_slug:181:(full_model:FindingModelFull)>None::Test that normalized slug names are checked.","test_check_name_conflict_allow_self_permits_duplicate:191:(full_model:FindingModelFull)>None::Test that allow_self=True permits the model's own name (for updates).","test_check_name_conflict_allow_self_false_blocks_duplicate:198:(full_model:FindingModelFull)>None::Test that allow_self=False blocks the model's own name.","test_check_name_conflict_empty_existing_set:205:(full_model:FindingModelFull)>None::Test with empty existing names set.","test_check_name_conflict_various_cases:212:(full_model:FindingModelFull)>None::Test case-insensitive matching with various case combinations.","test_check_attribute_id_conflict_no_conflict:228:(full_model:FindingModelFull)>None::Test that no conflict is detected when all attribute IDs are unique.","test_check_attribute_id_conflict_detects_duplicate_in_different_model:238:(full_model:FindingModelFull)>None::Test that conflict is detected when attribute ID is used by another model.","test_check_attribute_id_conflict_allow_self_permits_own_attributes:251:(full_model:FindingModelFull)>None::Test that allow_self permits the same model's attributes (for updates).","test_check_attribute_id_conflict_detects_multiple_conflicts:262:(full_model:FindingModelFull)>None::Test detection of conflicts in multiple attributes.","test_check_attribute_id_conflict_some_conflicting_some_not:275:(full_model:FindingModelFull)>None::Test with some attributes conflicting and others not.","test_check_attribute_id_conflict_empty_attribute_map:288:(full_model:FindingModelFull)>None::Test with empty attribute map.","test_check_attribute_id_conflict_model_with_no_attributes:295:()>None::Test with a model that has no attributes (edge case, though models require at...","test_validate_finding_model_no_conflicts:322:async (full_model:FindingModelFull)>None::Test validation passes when there are no conflicts.","test_validate_finding_model_detects_id_conflict:334:async (full_model:FindingModelFull)>None::Test validation detects OIFM ID conflict.","test_validate_finding_model_detects_name_conflict:348:async (full_model:FindingModelFull)>None::Test validation detects name conflict.","test_validate_finding_model_detects_attribute_conflict:362:async (full_model:FindingModelFull)>None::Test validation detects attribute ID conflict.","test_validate_finding_model_detects_multiple_conflicts:376:async (full_model:FindingModelFull)>None::Test validation combines all error messages when multiple conflicts exist.","test_validate_finding_model_allow_self_permits_all_conflicts:393:async (full_model:FindingModelFull)>None::Test that allow_self=True permits all conflicts (for updates).","test_validate_finding_model_allow_self_false_detects_conflicts:408:async (full_model:FindingModelFull)>None::Test that allow_self=False detects conflicts with the model's own data.","test_validate_finding_model_empty_context:424:async (full_model:FindingModelFull)>None::Test validation with completely empty context.","test_validate_finding_model_with_full_model_fixture:433:async (full_model:FindingModelFull)>None::Test validation with the full_model fixture from conftest.py.","test_validate_finding_model_with_real_model_data:441:async (real_model:FindingModelFull)>None::Test validation with real model structure from test data.","test_validate_finding_model_single_attribute:449:async ()>None::Test validation with model that has a single attribute (minimum required).","test_validate_finding_model_minimal_synonyms:473:async ()>None::Test validation with model that has minimal synonyms (1 required).","test_validate_finding_model_minimal_tags:500:async ()>None::Test validation with model that has minimal tags (1 required).","test_validate_finding_model_cross_model_attribute_conflict:525:async ()>None::Test validation detects attribute conflicts across different models.","test_validate_finding_model_concurrent_validation_safety:573:async ()>None::Test that multiple validations can run concurrently without interference."],{"MockValidationContext":["25",["__init__:33:(self, existing_ids:set[str] | None = None, existing_names:set[str] | None = None, attribute_ids_by_model:dict[str, str] | None = None,)>None::","get_existing_oifm_ids:38:async (self)>set[str]::","get_existing_names:41:async (self)>set[str]::","get_attribute_ids_by_model:44:async (self)>dict[str, str]::"]]}],"test/test_manifest_integration.py":["p",["test_duckdb_index_uses_manifest_when_no_db_path_provided:26:()>None::","test_duckdb_index_has_new_schema_with_finding_model_json_table:96:async (tmp_path:Path)>None::","test_manifest_integration_with_mock_download:161:async (tmp_path:Path)>None::","test_ensure_db_file_with_manifest_key_fetches_manifest:218:()>None::"]],"test/test_model_editor.py":["p",["_disable_model_requests:14:()>Iterator[None]::","test_edit_model_natural_language_add_attribute:24:async (real_model:FindingModelFull)>None::Test adding an attribute via natural language command.","test_export_model_for_editing_roundtrip:67:(real_model:FindingModelFull)>None::","test_export_model_for_editing_structure_full:74:(real_model:FindingModelFull)>None::","test_export_model_for_editing_attributes_only:106:(real_model:FindingModelFull)>None::","test_edit_model_natural_language_callout_real_api:121:async (real_model:FindingModelFull)>None::","test_assign_real_attribute_ids_infers_source:146:(real_model:FindingModelFull)>None::Test that assign_real_attribute_ids infers source from model's OIFM ID.","test_assign_real_attribute_ids_uses_explicit_source:172:(real_model:FindingModelFull,)>None::Test that assign_real_attribute_ids uses explicitly provided source code.","test_assign_real_attribute_ids_no_placeholders_returns_same_object:197:(real_model:FindingModelFull,)>None::Test that when no placeholders exist, the original model is returned unchanged."]],"test/test_models.py":["p",["test_choice_value:24:()>None::","test_choice_attribute:30:()>None::","test_numeric_attribute:45:()>None::","test_multichoice_attribute:60:()>None::","test_finding_model_base:72:(tmp_path)>None::","test_load_finding_model:104:(pe_fm_json:str)>None::","test_load_finding_model_with_codes:115:(tn_fm_json:str)>None::","test_load_finding_model_with_contributors:148:(tn_fm_json:str)>None::","test_base_model_markdown:198:(base_model:FindingModelBase)>None::","test_full_model_markdown_with_ids:235:(full_model:FindingModelFull)>None::","test_full_model_markdown_hide_ids:245:(full_model:FindingModelFull)>None::","test_real_model_markdown:255:(real_model:FindingModelFull, real_model_markdown:str)>None::","test_real_model_markdown_with_codes:261:(tn_fm_json:str, tn_markdown:str)>None::","clear_registries:274:()>Generator[None, None, None]::Clears the registries before each test to ensure isolation.","sample_org_oidm:284:()>dict[str, str]::","sample_org_acr:289:()>dict[str, str]::","sample_person_john:294:(sample_org_oidm:dict[str, str])>dict[str, str]::","sample_person_jane:306:(sample_org_acr:dict[str, str])>dict[str, str]::","test_organization_creation:321:(sample_org_oidm:dict[str, str])>None::","test_organization_duplicate_code:329:(sample_org_oidm:dict[str, str])>None::","test_organization_invalid_code_pattern:339:()>None::","test_organization_organizations_list:348:(sample_org_oidm:dict[str, str], sample_org_acr:dict[str, str])>None::","test_organization_save_and_load_jsonl:363:(tmp_path:Path, sample_org_oidm:dict[str, str], sample_org_acr:dict[str, str])>None::","test_organization_load_jsonl_file_not_found:386:(tmp_path:Path)>None::","test_person_creation:394:(sample_person_john:dict[str, str], sample_org_oidm:dict[str, str])>None::","test_person_duplicate_github_username:402:(sample_person_john:dict[str, str])>None::","test_person_organization_property:417:(sample_person_john:dict[str, str], sample_org_oidm:dict[str, str])>None::","test_person_organization_property_org_deleted_after_person_creation:425:(sample_person_john:dict[str, str])>None::","test_person_get_non_existent:435:()>None::","test_person_people_list:439:(sample_person_john:dict[str, str], sample_person_jane:dict[str, str])>None::","test_person_save_and_load_jsonl:454:(tmp_path:Path, sample_person_john:dict[str, str], sample_person_jane:dict[str, str], sample_org_oidm:dict[str, str], sample_org_acr:dict[str, str],)>None::","test_person_load_jsonl_file_not_found:484:(tmp_path:Path)>None::"]],"test/test_ontology_search.py":["p",["test_bioontology_implements_protocol:36:()>None::Test that BioOntologySearchClient implements OntologySearchProtocol.","test_protocol_context_managers:58:async ()>None::Test that BioOntology client works as async context manager.","test_bioontology_search_result_from_api_response:69:()>None::Test creating a search result from API response.","test_bioontology_search_result_minimal:95:()>None::Test creating a search result with minimal fields.","test_bioontology_client_no_api_key:116:()>None::Test that client raises error without API key.","test_default_ontologies_limited:130:()>None::","test_query_terms_deduplication:146:()>None::Test that duplicate terms are removed from list.","test_generate_finding_query_terms_single_word:174:async ()>None::Test query generation for single word.","test_generate_finding_query_terms_with_description:191:async ()>None::Test query generation with description.","test_create_query_generator_agent:208:()>None::Test that the query generator agent is created correctly.","test_execute_ontology_search:234:async ()>None::Test executing search with filtering using BioOntology API.","test_execute_ontology_search_with_custom_ontologies:277:async ()>None::Test execute_ontology_search with custom ontologies parameter.","test_execute_ontology_search_with_none_ontologies:321:async ()>None::Test execute_ontology_search with ontologies=None (uses defaults).","test_execute_ontology_search_missing_api_key:358:async ()>None::Test that execute_ontology_search raises ValueError when BioOntology API key ...","test_ensure_exact_matches_adds_missing:374:()>None::Test that missing exact matches are added.","test_ensure_exact_matches_respects_limit:402:()>None::Test that max_length of 5 is respected.","test_categorization_agent_creation:430:()>None::Test that agent is created properly.","test_categorization_with_test_model:447:async ()>None::Test categorization using TestModel.","test_match_ontology_concepts_integration:486:async ()>None::Test the complete workflow using BioOntology API.","test_match_ontology_concepts_with_custom_ontologies:532:async ()>None::Test match_ontology_concepts with custom ontologies parameter.","test_match_ontology_concepts_with_none_ontologies:590:async ()>None::Test match_ontology_concepts with ontologies=None (uses defaults).","test_match_ontology_concepts_missing_api_key:646:async ()>None::Test that match_ontology_concepts raises ValueError when BioOntology API key ...","test_match_ontology_concepts_basic_wiring:664:async ()>None::"]],"test/test_remote_resource.py":["p",{"TestEnsureDbFileMocked":["11",["test_existing_file_with_no_hash_uses_file_directly:14:(self, tmp_path:Path)>None::Test that existing file with no URL/hash is used directly without any verific...","test_existing_file_with_matching_hash_skips_download:41:(self, tmp_path:Path)>None::Test that file with matching hash is used without downloading.","test_existing_file_with_mismatched_hash_redownloads:72:(self, tmp_path:Path)>None::Test that file with mismatched hash triggers re-download.","test_downloads_when_file_missing_and_url_configured:102:(self, tmp_path:Path)>None:create_file_and_return:Test that missing files trigger Pooch download when URL is configured.","create_file_and_return:171:(*args:object, **kwargs:object)>str::","test_returns_path_when_no_url_configured:137:(self, tmp_path:Path)>None::Test that function raises error when manifest fails and no URL configured.","test_creates_parent_directory_before_download:161:(self, tmp_path:Path)>None:create_file_and_return:Test that parent directory is created before download."]],"TestEnsureDbFileRealDownload":["190",["test_downloads_from_real_url:193:(self, tmp_path:Path)>None::Test actual download from remote URL."]],"TestWrapperFunctions":["236",["test_ensure_index_db_calls_ensure_db_file_correctly:239:(self, tmp_path:Path)>None::Test that ensure_index_db() calls ensure_db_file() with correct parameters.","test_ensure_anatomic_db_calls_ensure_db_file_correctly:265:(self, tmp_path:Path)>None::Test that ensure_anatomic_db() calls ensure_db_file() with correct parameters."]]}],"test/test_tools.py":["p",["test_create_stub:20:(finding_info:FindingInfo)>None::Test creating a stub finding model from a FindingInfo object.","test_add_ids_to_finding_model:32:(base_model:FindingModelBase)>None::Test adding IDs to a finding model.","test_render_agent_prompt:50:()>None::Test render_agent_prompt extracts instructions and user prompt correctly.","test_render_agent_prompt_missing_user_section:71:()>None::Test render_agent_prompt raises error if USER section missing.","test_create_info_from_name_normalizes_and_logs:100:async (monkeypatch:pytest.MonkeyPatch)>None:fake_info:","test_create_info_from_name_preserves_name_without_logging:147:async (monkeypatch:pytest.MonkeyPatch)>None::","test_add_index_codes_to_finding_model:186:(full_model:FindingModelFull)>None::Test adding codes to a finding model.","test_add_index_codes_to_finding_model_no_duplicates:208:(full_model:FindingModelFull)>None::Test adding codes to a finding model.","test_create_model_stub_from_info_new_api:221:(finding_info:FindingInfo)>None::Test creating a stub finding model using the new function name.","test_add_ids_to_model_new_api:233:(base_model:FindingModelBase)>None::Test adding IDs to a finding model using the new function name.","test_add_standard_codes_to_model_new_api:251:(full_model:FindingModelFull)>None::Test adding codes to a finding model using the new function name.","test_add_standard_codes_to_model_no_duplicates_new_api:273:(full_model:FindingModelFull)>None::Test adding codes to a finding model using the new function name (no duplicat...","test_create_info_from_name_basic_wiring:287:async ()>None::","test_add_details_to_info_basic_wiring:319:async ()>None::","test_create_model_from_markdown_with_test_model:354:async ()>None::","test_create_model_from_markdown_basic_wiring:425:async ()>None::","test_find_similar_models_basic_wiring:471:async ()>None::","test_tools_import_failures:505:()>None::Test graceful handling when optional dependencies are missing.","test_concurrent_id_generation:516:(base_model:FindingModelBase)>None:generate_ids:Test ID generation under concurrent access."],{"_StubFindingInfoAgent":["89",["__init__:90:(self, output:FindingInfo)>None::","run:94:async (self, prompt:str)>SimpleNamespace::"]]}],"test/tools/test_evaluators.py":["p",["_create_ctx:27:(output:Any, duration:float | None = None, metadata:Any = None,)>EvaluatorContext::","test_performance_under_limit_from_ctx_duration:84:()>None:_create_ctx:Verify execution under time limit returns 1.0 when using ctx.duration.","test_performance_under_limit_from_output_duration:98:()>None:_create_ctx:Verify execution under time limit returns 1.0 when using output.duration.","test_performance_under_limit_from_query_time:112:()>None:_create_ctx:Verify execution under time limit returns 1.0 when using output.query_time.","test_performance_over_limit_from_ctx_duration:131:()>None:_create_ctx:Verify execution over time limit returns 0.0 when using ctx.duration.","test_performance_over_limit_from_output_duration:145:()>None:_create_ctx:Verify execution over time limit returns 0.0 when using output.duration.","test_performance_over_limit_from_query_time:159:()>None:_create_ctx:Verify execution over time limit returns 0.0 when using output.query_time.","test_performance_exactly_at_limit:178:()>None:_create_ctx:Verify execution exactly at time limit returns 1.0 (inclusive boundary).","test_performance_just_over_limit:192:()>None:_create_ctx:Verify execution just over time limit returns 0.0.","test_performance_ctx_duration_takes_precedence:211:()>None:_create_ctx:Verify ctx.duration takes precedence over output attributes.","test_performance_query_time_over_output_duration:227:()>None:_create_ctx:Verify output.query_time takes precedence over output.duration.","test_performance_missing_metadata_returns_na:253:()>None:_create_ctx:Verify missing metadata returns 1.0 (N/A case).","test_performance_error_case_returns_na:267:()>None:_create_ctx:Verify error case returns 1.0 (N/A - error scored separately).","test_performance_missing_duration_returns_na:281:()>None:_create_ctx:Verify missing duration from all sources returns 1.0 (N/A case).","test_performance_error_overrides_slow_execution:295:()>None:_create_ctx:Verify error case returns 1.0 even if execution was slow.","test_performance_very_fast_execution:315:()>None:_create_ctx:Verify very fast execution (0.5s) passes 5s limit.","test_performance_one_second_execution:329:()>None:_create_ctx:Verify 1.0s execution passes 5s limit.","test_performance_very_slow_execution:343:()>None:_create_ctx:Verify very slow execution (30s) fails 5s limit.","test_performance_instantaneous_execution:357:()>None:_create_ctx:Verify instantaneous execution (0.0s) passes any limit.","test_performance_custom_time_limit:376:()>None:_create_ctx:Verify custom time limit configuration works correctly.","test_performance_default_time_limit:397:()>None:_create_ctx:Verify default time limit is 30.0 seconds."],{"OutputWithDuration":["52",[]],"OutputWithQueryTime":["59",[]],"OutputWithError":["66",[]],"OutputWithoutTime":["73",[]]}]},"g":[["run_finding_description_task","ExclusionEvaluator.evaluate"],["ModelEditorCase.__init__","ModelEditorCase.__init__"],["ModelEditorCase.__init__","AnatomicSearchCase.__init__"],["test_create_fts_index_custom_parameters","_fts_index_exists"],["DuckDBOntologySearchClient._search_single_with_filters","_get_embedding"],["update","progress_update"],["EmbeddingCache.get_embedding","_get_connection"],["EmbeddingCache.store_embeddings_batch","_hash_text"],["create_finding_model_from_markdown","create_model_from_markdown"],["DuckDBIndex._load_models_metadata","_validate_model"],["OntologySearchProtocol.search_parallel","search"],["SimilarModelsCase.__init__","SimilarModelsCase.__init__"],["test_concurrent_id_generation","generate_ids"],["DuckDBIndex._execute_batch_directory_update","_insert_models_with_progress"],["EmbeddingCache.get_embedding","EmbeddingCache._get_connection"],["DuckDBOntologySearchClient._search_single_with_filters","DuckDBOntologySearchClient._combine_with_exact_matches"],["run_session","explain_commands"],["batch_embeddings_for_duckdb","_to_float32"],["DuckDBIndex.update_from_directory","_collect_directory_files"],["OntologyMatchCase.__init__","DuckDBOntologySearchClient.__init__"],["test_performance_over_limit_from_ctx_duration","_create_ctx"],["OntologyMatchCase.__init__","__init__"],["EmbeddingCache.get_embeddings_batch","EmbeddingCache._hash_text"],["test_performance_error_overrides_slow_execution","_create_ctx"],["DuckDBIndex._search_exact","DuckDBIndex._resolve_oifm_id"],["DuckDBIndex.update_from_directory","DuckDBIndex._execute_batch_directory_update"],["DuckDBIndex.finalize_placeholder_attribute_ids","Person.get"],["create_model_stub_from_info","create_change_element"],["create_markdown_edit_cases","load_fm_json"],["MarkdownInCase.__init__","PrecisionAtKEvaluator.__init__"],["MarkdownInCase.__init__","BioOntologySearchClient.__init__"],["run_similar_models_task","ErrorHandlingEvaluator.evaluate"],["AnatomicSearchCase.__init__","PrecisionAtKEvaluator.__init__"],["AnatomicSearchCase.__init__","BioOntologySearchClient.__init__"],["test_search_with_multiple_tags_and_logic","_write_model_file"],["create_anatomic_database","_verify_database"],["MarkdownInCase.__init__","OntologyMatchCase.__init__"],["OntologyMatchCase.__init__","DemoState.__init__"],["run_markdown_in_task","ErrorMessageQualityEvaluator.evaluate"],["Person.get","get"],["test_performance_error_case_returns_na","_create_ctx"],["test_remove_entry_clears_related_rows","_table_count"],["Person.organization","Person.get"],["test_ontology_concept_match","_print_verbose_stages"],["run_similar_models_task","ContentPreservationEvaluator.evaluate"],["test_read_only_mode_blocks_writes","fake_client"],["test_read_only_mode_blocks_writes","_write_model_file"],["DuckDBIndex._load_oifm_ids_for_source","_ensure_connection"],["TestEnsureDbFileMocked.test_downloads_when_file_missing_and_url_configured","TestEnsureDbFileMocked.create_file_and_return"],["run_session","handle_natural_language"],["run_similar_models_evals","main"],["test_drop_search_indexes_fts_only","_fts_index_exists"],["_print_verbose_stages","_print_bio_search_stage"],["test_remove_entry_clears_related_rows","_write_model_file"],["TestAnatomicCLI.test_stats_basic","_fake_openai_client"],["test_create_hnsw_index_custom_parameters","_hnsw_index_exists"],["run_similar_models_task","ExclusionEvaluator.evaluate"],["run_ontology_match_task","evaluate"],["BioOntologySearchClient.search_parallel","OntologySearchProtocol.search"],["test_mock_validation_context_implements_protocol","ValidationContext.get_attribute_ids_by_model"],["main","parse_args"],["ModelEditorCase._execute","RejectionAccuracyEvaluator.evaluate"],["create_finding_info_from_name","create_info_from_name"],["test_mock_validation_context_implements_protocol","MockValidationContext.get_existing_oifm_ids"],["TestLoadAnatomicData.test_http_error","raise_http_error"],["TestCreateAnatomicDatabase.test_database_with_batch_processing","mock_batch_embeddings"],["_handle_reset","reset"],["run_markdown_in_task","IDPreservationEvaluator.evaluate"],["RankingQualityEvaluator._calculate_ndcg","_calculate_dcg"],["DuckDBIndex.add_or_update_entry_from_file","_create_search_indexes"],["run_model_editor_task","TypeCorrectnessEvaluator.evaluate"],["run_model_editor_task","AttributePreservationEvaluator.evaluate"],["apply_edit","DemoState.mark_updated"],["DuckDBIndex.generate_attribute_id","_load_oifma_ids_for_source"],["DuckDBOntologySearchClient._search_single","DuckDBOntologySearchClient._find_exact_matches"],["DuckDBOntologySearchClient._find_exact_matches","_row_to_result"],["DuckDBIndex.add_ids_to_model","EmbeddingCache.setup"],["create_prompt_messages","create_prompt_messages"],["test_create_info_from_name_normalizes_and_logs","fake_info"],["MarkdownInCase.__init__","EmbeddingCache.__init__"],["render_agent_prompt","render_agent_prompt"],["run_ontology_match_task","PrecisionAtKEvaluator.evaluate"],["run_markdown_in_task","AttributeAdditionEvaluator.evaluate"],["AnatomicSearchCase.__init__","EmbeddingCache.__init__"],["EmbeddingCache.store_embeddings_batch","_to_float32"],["ModelEditorCase.__init__","__init__"],["RankingQualityEvaluator.evaluate","_calculate_ndcg"],["run_markdown_in_task","SynonymHandlingEvaluator.evaluate"],["get_attribute_names","get_attribute_names"],["DuckDBIndex._load_models_metadata","DuckDBIndex._build_embedding_text"],["DuckDBIndex.setup","DuckDBIndex._load_base_contributors"],["ModelEditorCase.__init__","DuckDBOntologySearchClient.__init__"],["DuckDBOntologySearchClient._search_single","DuckDBOntologySearchClient._row_to_result"],["test_performance_exactly_at_limit","_create_ctx"],["test_batch_update_rebuilds_indexes_once","_fts_index_works"],["run_ontology_match_task","RejectionAccuracyEvaluator.evaluate"],["DuckDBIndex._load_models_metadata","DuckDBIndex._build_search_text"],["BioOntologySearchClient.search_bioontology","BioOntologySearchResult.from_api_response"],["batch_embeddings_for_duckdb","EmbeddingCache._to_float32"],["run_similar_models_task","PerformanceEvaluator.evaluate"],["DuckDBIndex.add_or_update_entry_from_file","_calculate_file_hash"],["DuckDBIndex.add_or_update_entry_from_file","_build_search_text"],["_fetch_and_store_embeddings","_get_embedding_cache"],["export_model_for_editing","_render_top_metadata_lines"],["DuckDBIndex._prepare_batch_payload","_build_row_data"],["RankingQualityEvaluator.evaluate","RankingQualityEvaluator._calculate_ndcg"],["ModelEditorCase.__init__","DemoState.__init__"],["DuckDBIndex.get","DuckDBIndex._ensure_connection"],["DuckDBOntologySearchClient._search_single_with_filters","DuckDBOntologySearchClient._get_embedding"],["run_anatomic_search_task","RejectionAccuracyEvaluator.evaluate"],["DuckDBIndex.remove_entry","_delete_denormalized_records"],["DuckDBIndex.add_ids_to_model","DuckDBIndex.generate_attribute_id"],["strip_quotes_secret","strip_quotes"],["DuckDBIndex._apply_batch_mutations","DuckDBIndex._delete_denormalized_records"],["DuckDBIndex.add_or_update_entry_from_file","_delete_denormalized_records"],["validate_finding_model","MockValidationContext.get_attribute_ids_by_model"],["test_search_by_slug_relevance_ranking","_write_model_file"],["DuckDBIndex._load_base_contributors","Organization.get"],["DuckDBIndex._search_fts","DuckDBIndex._fetch_index_entry"],["DuckDBIndex._search_fts","DuckDBIndex._entry_has_tags"],["DuckDBIndex.add_ids_to_model","DuckDBIndex.generate_model_id"],["run_finding_description_task","StructuralValidityEvaluator.evaluate"],["test_performance_under_limit_from_ctx_duration","_create_ctx"],["MarkdownInCase.__init__","MockValidationContext.__init__"],["validate","_do_validate"],["DuckDBIndex._execute_paginated_query","_ensure_connection"],["DuckDBIndex._ensure_writable_connection","DuckDBIndex._ensure_connection"],["run_ontology_match_task","SearchAccuracyEvaluator.evaluate"],["EmbeddingCache.store_embedding","EmbeddingCache._hash_text"],["_lookup_cached_embeddings","_get_embedding_cache"],["AnatomicSearchCase.__init__","MockValidationContext.__init__"],["DuckDBIndex._search_fts","_entry_has_tags"],["MarkdownInCase.__init__","ModelEditorCase.__init__"],["DuckDBIndex._search_semantic","_search_semantic_with_embedding"],["OntologyMatchCase.__init__","OntologyMatchCase.__init__"],["DuckDBIndex.get_full","DuckDBIndex.setup"],["DuckDBIndex.remove_entry","_ensure_writable_connection"],["match_ontology_concepts","categorize_with_validation"],["test_create_hnsw_index_custom_name","_hnsw_index_exists"],["run_markdown_in_task","RoundTripEvaluator.evaluate"],["AnatomicSearchCase.__init__","ModelEditorCase.__init__"],["create_markdown_edit_agent","_edited_text_instructions"],["DuckDBIndex.add_or_update_entry_from_file","_ensure_writable_connection"],["test_anatomic_location_search","perform_search_stages"],["validate_finding_model","check_attribute_id_conflict"],["DuckDBIndex._load_oifma_ids_for_source","DuckDBIndex._ensure_connection"],["validate_finding_model","get_attribute_ids_by_model"],["_process_and_insert_data","determine_sided"],["_collect_value_codes","_parse_suffix"],["DuckDBIndex.get_full","DuckDBIndex.get_full"],["find_similar_models","_generate_search_terms_with_fallback"],["BioOntologySearchClient.search_bioontology","OntologySearchProtocol.search"],["test_setup_creates_search_indexes","_hnsw_index_exists"],["_lookup_cached_embeddings","EmbeddingCache.get_embeddings_batch"],["ChoiceAttribute.fix_max_selected","fix_max_selected_validator"],["DuckDBIndex._collect_directory_files","DuckDBIndex._calculate_file_hash"],["DuckDBIndex.search","_search_semantic"],["handle_markdown_edit","prompt_markdown_edit"],["create_mock_edit_result","create_mock_edit_result"],["DuckDBIndex.generate_attribute_id","DuckDBIndex._load_oifma_ids_for_source"],["DuckDBIndex._generate_embeddings","_ensure_openai_client"],["DuckDBOntologySearchClient._search_single","DuckDBOntologySearchClient._apply_rrf_fusion"],["DuckDBIndex.update_from_directory","_stage_directory_files"],["SimilarModelsCase.__init__","DuckDBIndex.__init__"],["EmbeddingCache.store_embeddings_batch","EmbeddingCache._to_float32"],["DuckDBIndex._insert_models_with_progress","_create_chunk_payload"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._ensure_openai_client"],["run_model_editor_task","ContentPreservationEvaluator.evaluate"],["validate_finding_model","ValidationContext.get_existing_names"],["test_denormalized_synonyms_table","_table_count"],["index","fake_client"],["test_generate_attribute_id_collision_avoidance","_write_model_file"],["run_similar_models_task","StructuralValidityEvaluator.evaluate"],["ModelEditorCase._execute","HierarchyEvaluator.evaluate"],["DuckDBIndex.add_or_update_entry_from_file","EmbeddingCache.setup"],["DuckDBIndex.remove_entry","DuckDBIndex._drop_search_indexes"],["generate_finding_query_terms","create_query_generator_agent"],["ensure_db_file","_resolve_target_path"],["DuckDBIndex._execute_batch_directory_update","DuckDBIndex._delete_old_entries"],["NumericAttributeIded.index_codes_str","_index_codes_str"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._build_embedding_text"],["run_ontology_match_task","ChangeTrackingEvaluator.evaluate"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._drop_search_indexes"],["DuckDBIndex.search_by_slug","DuckDBIndex._build_slug_search_clause"],["EmbeddingCache.store_embeddings_batch","_get_connection"],["DuckDBIndex._fetch_index_entry","_collect_contributors"],["DuckDBIndex._search_fts","_fetch_index_entry"],["test_load_oifma_ids_for_source_caching","_write_model_file"],["test_search_by_slug_relevance_ranking","fake_embedding"],["DuckDBIndex.add_ids_to_model","Organization.get"],["DuckDBOntologySearchClient._search_single","DuckDBIndex.search"],["EmbeddingCache.store_embeddings_batch","EmbeddingCache._get_connection"],["run_anatomic_search_evals","run_anatomic_search_evals"],["DuckDBIndex.get_full_batch","DuckDBIndex.get_full_batch"],["DuckDBIndex._execute_paginated_query","DuckDBIndex.count"],["run_ontology_match_task","RankingQualityEvaluator.evaluate"],["DuckDBIndex.count","_ensure_connection"],["run_markdown_in_task","evaluate"],["run_finding_description_task","TypeCorrectnessEvaluator.evaluate"],["DuckDBOntologySearchClient._search_single_with_filters","DuckDBOntologySearchClient._row_to_result"],["DuckDBIndex.add_or_update_entry_from_file","_ensure_openai_client"],["run_finding_description_task","AttributePreservationEvaluator.evaluate"],["ChoiceAttributeIded.index_codes_str","_index_codes_str"],["execute_ontology_search","_add_exact_matches"],["DuckDBIndex.finalize_placeholder_attribute_ids","DuckDBIndex.get"],["test_write_operations_rebuild_search_indexes","_write_model_file"],["ModelEditorCase.__init__","OntologyMatchCase.__init__"],["run_ontology_match_task","HierarchyEvaluator.evaluate"],["DuckDBIndex.count_organizations","_ensure_connection"],["DuckDBIndex.search_by_slug","_execute_paginated_query"],["DuckDBIndex.remove_entry","DuckDBIndex.setup"],["_print_verbose_stages","_print_categorization_stage"],["run_session","handle_command"],["handle_save","DemoState.record_save"],["DuckDBIndex._search_semantic","DuckDBIndex._ensure_openai_client"],["test_validation_context_accepts_different_implementations","MockValidationContext.get_existing_oifm_ids"],["DuckDBIndex.get_full_batch","get_full_batch"],["Person.organization","DuckDBIndex.get"],["DuckDBIndex.search_batch","_ensure_connection"],["test_update_from_directory_batch_mixed","_write_model_file"],["run_model_editor_task","PerformanceEvaluator.evaluate"],["run_anatomic_search_task","HierarchyEvaluator.evaluate"],["DuckDBIndex.generate_attribute_id","DuckDBIndex.generate_attribute_id"],["ModelEditorCase._execute","ErrorHandlingEvaluator.evaluate"],["_basic_edit_validation","_validate_choice_value_indices_and_bases"],["test_mock_validation_context_implements_protocol","get_attribute_ids_by_model"],["run_markdown_in_task","PrecisionAtKEvaluator.evaluate"],["DuckDBIndex._search_semantic_with_embedding","DuckDBIndex._fetch_index_entry"],["DuckDBIndex._search_semantic_with_embedding","DuckDBIndex._entry_has_tags"],["test_performance_instantaneous_execution","_create_ctx"],["ModelEditorCase._execute","ContentPreservationEvaluator.evaluate"],["run_markdown_in_task","RejectionAccuracyEvaluator.evaluate"],["handle_natural_language","apply_edit"],["create_model_stub_from_info","create_presence_element"],["_session_cli_monkeypatch_setup","_fake_client_for_testing"],["test_mock_validation_context_implements_protocol","MockValidationContext.get_existing_names"],["index","fake_embedding"],["AnatomicSearchCase.__init__","DemoState.__init__"],["Organization.get","DuckDBIndex.get"],["add_standard_codes_to_finding_model","add_standard_codes_to_model"],["run_model_editor_task","RoundTripEvaluator.evaluate"],["test_contains_method","_write_model_file"],["DuckDBIndex._search_semantic_with_embedding","_entry_has_tags"],["run_similar_models_task","TypeCorrectnessEvaluator.evaluate"],["ModelEditorCase._execute","ExclusionEvaluator.evaluate"],["run_similar_models_task","AttributePreservationEvaluator.evaluate"],["DuckDBIndex.generate_attribute_id","setup"],["ensure_db_file","_download_from_manifest"],["DuckDBIndex._validate_model","_ensure_connection"],["DuckDBIndex.remove_entry","DuckDBIndex._delete_denormalized_records"],["make_info","print_info_truncate_detail"],["_session_cli_monkeypatch_setup","_fake_embedding_deterministic"],["test_drop_search_indexes_missing_gracefully","_fts_index_exists"],["SimilarModelsCase.__init__","_StubFindingInfoAgent.__init__"],["anatomic_build","_do_build"],["test_ontology_concept_match","_print_finding_info_stage"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._delete_denormalized_records"],["DuckDBIndex.get_full","get_full"],["create_markdown_edit_agent","_normalize_new_attribute_ids"],["run_finding_description_evals","main"],["DuckDBIndex.search_batch","DuckDBIndex._ensure_connection"],["run_ontology_match_evals","run_ontology_match_evals"],["_validate_choice_value_indices_and_bases","_validate_existing_attr_suffixes"],["SimilarModelsCase.__init__","AnatomicSearchCase.__init__"],["test_performance_under_limit_from_query_time","_create_ctx"],["DuckDBIndex._apply_batch_mutations","_delete_denormalized_records"],["run_markdown_in_evals","run_markdown_in_evals"],["DuckDBIndex._execute_batch_directory_update","_drop_search_indexes"],["run_markdown_in_task","SearchAccuracyEvaluator.evaluate"],["run_anatomic_search_task","ErrorHandlingEvaluator.evaluate"],["run_with_timer","_runner"],["match_ontology_concepts","execute_ontology_search"],["create_anatomic_database","_create_indexes"],["_basic_edit_validation","_validate_model_id"],["apply_edit","mark_updated"],["test_get_organizations","_write_model_file"],["OntologySearchResult.as_index_code","normalize_concept"],["run_anatomic_search_task","ContentPreservationEvaluator.evaluate"],["Person.get","DuckDBIndex.get"],["validate_finding_model","ValidationContext.get_existing_oifm_ids"],["create_successful_edit_cases","load_fm_json"],["DuckDBIndex.get_person","DuckDBIndex._ensure_connection"],["DuckDBIndex.add_or_update_entry_from_file","_replace_attributes"],["DuckDBIndex.search_batch","_ensure_openai_client"],["DuckDBIndex._load_base_contributors","Person.get"],["run_finding_description_task","ContentPreservationEvaluator.evaluate"],["run_anatomic_search_task","ExclusionEvaluator.evaluate"],["DuckDBIndex._search_semantic_with_embedding","_fetch_index_entry"],["DuckDBIndex.count_search","DuckDBIndex._ensure_connection"],["validate_finding_model","get_existing_names"],["create_anatomic_database","_process_and_insert_data"],["create_prompt_messages","render_agent_prompt"],["DuckDBIndex.update_from_directory","DuckDBIndex._ensure_writable_connection"],["OntologySearchProtocol.search_parallel","BioOntologySearchClient.search"],["DuckDBIndex.search_by_slug","_build_slug_search_clause"],["run_similar_models_task","ErrorMessageQualityEvaluator.evaluate"],["DuckDBIndex._load_models_metadata","DuckDBIndex._validate_model"],["markdown_to_fm","print_info_truncate_detail"],["DuckDBIndex.generate_model_id","EmbeddingCache.setup"],["test_batch_update_rebuilds_indexes_once","_hnsw_index_exists"],["run_markdown_in_task","ChangeTrackingEvaluator.evaluate"],["DuckDBIndex.update_from_directory","DuckDBIndex._classify_directory_changes"],["DuckDBIndex.add_ids_to_model","generate_attribute_id"],["validate_finding_model","get_existing_oifm_ids"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._calculate_file_hash"],["DuckDBIndex.contains","_resolve_oifm_id"],["DuckDBIndex.update_from_directory","DuckDBIndex._collect_directory_files"],["run_markdown_in_task","RankingQualityEvaluator.evaluate"],["DuckDBIndex.search","DuckDBIndex._ensure_connection"],["export_model_for_editing","_render_attribute_lines"],["AnatomicSearchCase.__init__","OntologyMatchCase.__init__"],["stats","_do_stats"],["BioOntologySearchClient.search_parallel","DuckDBIndex.search"],["run_finding_description_task","PerformanceEvaluator.evaluate"],["RankingQualityEvaluator._calculate_ndcg","RankingQualityEvaluator._calculate_dcg"],["run_similar_models_task","IDPreservationEvaluator.evaluate"],["test_get_person","_write_model_file"],["test_validation_context_accepts_different_implementations","MockValidationContext.get_attribute_ids_by_model"],["BioOntologySearchClient.search","search_as_ontology_results"],["run_markdown_in_task","HierarchyEvaluator.evaluate"],["SimilarModelsCase.__init__","DuckDBOntologySearchClient.__init__"],["SimilarModelsCase.__init__","__init__"],["DuckDBIndex.get","_ensure_connection"],["run_finding_description_evals","run_finding_description_evals"],["compare_models","compare_models"],["TestEnsureDbFileMocked.test_creates_parent_directory_before_download","TestEnsureDbFileMocked.create_file_and_return"],["test_performance_ctx_duration_takes_precedence","_create_ctx"],["DuckDBIndex.generate_model_id","DuckDBIndex.generate_model_id"],["test_denormalized_model_people_table","_write_model_file"],["BioOntologySearchClient.search_as_ontology_results","search_all_pages"],["ModelEditorCase._execute","StructuralValidityEvaluator.evaluate"],["run_similar_models_task","AttributeAdditionEvaluator.evaluate"],["DuckDBOntologySearchClient.search_with_filters","DuckDBOntologySearchClient._search_single_with_filters"],["DuckDBOntologySearchClient._search_single","DuckDBOntologySearchClient.search"],["OntologySearchProtocol.search_parallel","OntologySearchProtocol.search"],["SimilarModelsCase.__init__","DemoState.__init__"],["run_similar_models_task","SynonymHandlingEvaluator.evaluate"],["run_finding_description_task","RoundTripEvaluator.evaluate"],["test_mock_validation_context_implements_protocol","ValidationContext.get_existing_oifm_ids"],["create_edit_agent","_basic_edit_validation"],["DuckDBIndex.search_batch","_search_exact"],["DuckDBIndex.generate_model_id","setup"],["DuckDBIndex._search_semantic_with_embedding","search_batch"],["edit_model_natural_language","create_edit_agent"],["DuckDBIndex._build_slug_search_clause","_build_slug_search_clause"],["DuckDBOntologySearchClient._search_single_with_filters","_combine_with_exact_matches"],["TestLoadAnatomicData.test_http_error","TestLoadAnatomicData.raise_http_error"],["test_validation_context_accepts_different_implementations","get_attribute_ids_by_model"],["MarkdownInCase.__init__","MarkdownInCase.__init__"],["run_model_editor_evals","main"],["_download_from_manifest","_download_file"],["DuckDBIndex._ensure_writable_connection","_ensure_connection"],["update","_do_update"],["BioOntologySearchClient.search_all_pages","BioOntologySearchClient.search_bioontology"],["test_mock_validation_context_implements_protocol","get_existing_names"],["test_generate_model_id_collision_avoidance","_write_model_file"],["create_markdown_edit_agent","_validate_output"],["DuckDBOntologySearchClient._search_single_with_filters","_row_to_result"],["test_validation_context_accepts_different_implementations","MockValidationContext.get_existing_names"],["EmbeddingCache.store_embedding","_hash_text"],["DuckDBIndex.search_batch","DuckDBIndex._search_exact"],["DuckDBIndex.finalize_placeholder_attribute_ids","EmbeddingCache.setup"],["DuckDBIndex._load_oifma_ids_for_source","_ensure_connection"],["get_embedding","_get_embedding_cache"],["DuckDBIndex.add_or_update_entry_from_file","_validate_model"],["test_validation_context_accepts_different_implementations","ValidationContext.get_existing_names"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._validate_model"],["handle_save","save_model"],["DuckDBIndex.finalize_placeholder_attribute_ids","DuckDBIndex.finalize_placeholder_attribute_ids"],["DuckDBIndex.__aenter__","DuckDBIndex._ensure_connection"],["DuckDBIndex._delete_old_entries","DuckDBIndex._delete_denormalized_records"],["test_mock_validation_context_implements_protocol","get_existing_oifm_ids"],["run_anatomic_search_task","StructuralValidityEvaluator.evaluate"],["DuckDBIndex._execute_paginated_query","count"],["validate","_validate_single_file"],["DuckDBIndex.add_ids_to_model","DuckDBIndex.add_ids_to_model"],["test_performance_one_second_execution","_create_ctx"],["test_performance_default_time_limit","_create_ctx"],["DuckDBIndex._insert_models_with_progress","DuckDBIndex._create_chunk_payload"],["DuckDBIndex._search_semantic","DuckDBIndex._search_semantic_with_embedding"],["run_similar_models_task","RoundTripEvaluator.evaluate"],["make_stub_model","_do_make_stub_model"],["ensure_db_file","_verify_file_hash"],["DuckDBIndex.add_ids_to_model","DuckDBIndex.setup"],["ChoiceValueIded.index_codes_str","_index_codes_str"],["DuckDBIndex.finalize_placeholder_attribute_ids","DuckDBIndex.generate_attribute_id"],["test_performance_missing_metadata_returns_na","_create_ctx"],["run_model_editor_task","ChangeTrackingEvaluator.evaluate"],["DuckDBIndex.update_from_directory","_ensure_writable_connection"],["test_create_fts_index_basic","_fts_index_exists"],["apply_edit","display_current"],["DuckDBIndex._generate_embeddings","DuckDBIndex._ensure_openai_client"],["test_drop_search_indexes_both","_hnsw_index_exists"],["_basic_edit_validation","_validate_new_items_have_ids"],["DuckDBIndex.generate_model_id","generate_model_id"],["DuckDBIndex.add_ids_to_model","add_ids_to_model"],["DuckDBIndex.generate_model_id","_load_oifm_ids_for_source"],["ModelEditorCase._execute","TypeCorrectnessEvaluator.evaluate"],["ModelEditorCase._execute","AttributePreservationEvaluator.evaluate"],["run_model_editor_task","ErrorMessageQualityEvaluator.evaluate"],["BioOntologySearchClient.search_bioontology","DuckDBIndex.search"],["find_anatomic_locations","create_location_selection_agent"],["DuckDBIndex.search","_search_exact"],["TestCreateAnatomicDatabase.test_database_with_batch_processing","TestCreateAnatomicDatabase.mock_batch_embeddings"],["DuckDBIndex.search_by_slug","DuckDBIndex._execute_paginated_query"],["DuckDBIndex.finalize_placeholder_attribute_ids","setup"],["categorize_with_validation","create_categorization_agent"],["DuckDBIndex._prepare_batch_payload","DuckDBIndex._generate_embeddings"],["handle_markdown_edit","run_with_timer"],["DuckDBIndex.search_batch","_search_fts"],["_basic_edit_validation","_validate_original_attributes_present"],["DuckDBIndex.update_from_directory","EmbeddingCache.setup"],["test_denormalized_attributes_table","_table_count"],["SimilarModelsCase.__init__","PrecisionAtKEvaluator.__init__"],["DuckDBIndex._execute_batch_directory_update","DuckDBIndex._insert_models_with_progress"],["main","load_model"],["SimilarModelsCase.__init__","BioOntologySearchClient.__init__"],["load_fm_json","load_fm_json"],["main","test_anatomic_location_search"],["render_agent_prompt","load_prompt_template"],["DuckDBIndex._load_base_contributors","DuckDBIndex.get"],["EmbeddingCache.store_embedding","_to_float32"],["SimilarModelsCase.__init__","OntologyMatchCase.__init__"],["test_denormalized_attributes_table","_write_model_file"],["_process_and_insert_data","validate_anatomic_record"],["run_model_editor_task","IDPreservationEvaluator.evaluate"],["create_markdown_edit_agent","_combine_instruction_sections"],["validate_finding_model","check_name_conflict"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._replace_attributes"],["run_similar_models_task","evaluate"],["test_read_only_mode_blocks_writes","_fake_openai_client"],["test_ontology_concept_match","_print_summary"],["test_update_from_directory","_write_model_file"],["OntologyMatchCase.__init__","MarkdownInCase.__init__"],["find_anatomic_locations","generate_anatomic_query_terms"],["describe_finding_name","create_info_from_name"],["DuckDBIndex.search_batch","_search_semantic_with_embedding"],["OntologyMatchCase.__init__","DuckDBIndex.__init__"],["markdown_to_fm","_do_markdown_to_fm"],["DuckDBIndex.get_full_batch","DuckDBIndex._ensure_connection"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._build_search_text"],["DuckDBOntologySearchClient._search_single_with_filters","DuckDBOntologySearchClient._find_exact_matches"],["extract_text_for_keywords","extract_text_for_keywords"],["DuckDBIndex.get_full_batch","EmbeddingCache.setup"],["TestEnsureDbFileMocked.test_downloads_when_file_missing_and_url_configured","create_file_and_return"],["run_anatomic_search_task","TypeCorrectnessEvaluator.evaluate"],["get_embedding","EmbeddingCache.get_embedding"],["DuckDBIndex.search_batch","DuckDBIndex._search_fts"],["DuckDBOntologySearchClient._search_single","search"],["run_anatomic_search_task","AttributePreservationEvaluator.evaluate"],["ensure_db_file","ensure_db_file"],["DuckDBOntologySearchClient._search_single","BioOntologySearchClient.search"],["DuckDBIndex.add_or_update_entry_from_file","_replace_tags"],["run_model_editor_task","AttributeAdditionEvaluator.evaluate"],["test_count_method","_write_model_file"],["create_markdown_edit_agent","_common_editing_instructions"],["run_model_editor_task","SynonymHandlingEvaluator.evaluate"],["DuckDBIndex._load_models_metadata","_build_embedding_text"],["DuckDBIndex.generate_attribute_id","EmbeddingCache.setup"],["test_mock_validation_context_implements_protocol","MockValidationContext.get_attribute_ids_by_model"],["DuckDBIndex.finalize_placeholder_attribute_ids","Organization.get"],["test_denormalized_model_organizations_table","_table_count"],["test_search_with_single_tag","_write_model_file"],["_handle_command_input","handle_natural_language"],["run_model_editor_evals","run_model_editor_evals"],["DuckDBIndex.get","_resolve_oifm_id"],["run_similar_models_task","PrecisionAtKEvaluator.evaluate"],["test_denormalized_model_organizations_table","_write_model_file"],["DuckDBIndex.update_from_directory","setup"],["DuckDBIndex.update_from_directory","_execute_batch_directory_update"],["SimilarModelsCase.__init__","EmbeddingCache.__init__"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex.setup"],["Person.organization","Organization.get"],["test_generate_model_id_max_attempts_exhausted","mock_random_digits"],["run_similar_models_task","RejectionAccuracyEvaluator.evaluate"],["DuckDBIndex.count_people","DuckDBIndex._ensure_connection"],["DuckDBIndex._load_base_contributors","get"],["test_validation_context_accepts_different_implementations","ValidationContext.get_existing_oifm_ids"],["test_denormalized_tags_table","_write_model_file"],["DuckDBIndex._execute_batch_directory_update","DuckDBIndex._create_search_indexes"],["EmbeddingCache.get_embedding","EmbeddingCache._hash_text"],["DuckDBIndex.update_from_directory","_classify_directory_changes"],["MarkdownInCase.__init__","SimilarModelsCase.__init__"],["test_create_hnsw_index_custom_metric","_hnsw_index_exists"],["test_validation_context_accepts_different_implementations","get_existing_names"],["DuckDBIndex.count_search","DuckDBIndex._build_slug_search_clause"],["Organization.get","Organization.get"],["ModelEditorCase._execute","IDPreservationEvaluator.evaluate"],["DuckDBIndex.get_full_batch","setup"],["DuckDBIndex.get_person","_ensure_connection"],["test_load_oifm_ids_for_source_caching","_write_model_file"],["find_anatomic_locations","execute_anatomic_search"],["test_count_people","_write_model_file"],["_common_editing_instructions","_combine_instruction_sections"],["EmbeddingCache.store_embedding","EmbeddingCache._to_float32"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._upsert_contributors"],["ModelEditorCase.__init__","MarkdownInCase.__init__"],["DuckDBIndex.count_search","_ensure_connection"],["BioOntologySearchClient.search_as_ontology_results","to_ontology_search_result"],["test_mock_validation_context_implements_protocol","ValidationContext.get_existing_names"],["ModelEditorCase.__init__","DuckDBIndex.__init__"],["run_similar_models_task","SearchAccuracyEvaluator.evaluate"],["DuckDBOntologySearchClient._search_single","_get_embedding"],["run_finding_description_task","ChangeTrackingEvaluator.evaluate"],["test_performance_under_limit_from_output_duration","_create_ctx"],["test_concurrent_cache_operations","store_embedding_task"],["run_ontology_match_task","ErrorHandlingEvaluator.evaluate"],["SimilarModelsCase.__init__","MockValidationContext.__init__"],["ModelEditorCase._execute","AttributeAdditionEvaluator.evaluate"],["DuckDBIndex.search_batch","DuckDBIndex._ensure_openai_client"],["ModelEditorCase._execute","SynonymHandlingEvaluator.evaluate"],["DuckDBIndex._insert_models_with_progress","_apply_batch_mutations"],["DuckDBIndex._search_exact","DuckDBIndex._entry_has_tags"],["EmbeddingCache.store_embedding","_get_connection"],["test_validation_context_accepts_different_implementations","get_existing_oifm_ids"],["DuckDBIndex._delete_old_entries","_delete_denormalized_records"],["DuckDBOntologySearchClient._search_single_with_filters","DuckDBOntologySearchClient._apply_rrf_fusion"],["run_finding_description_task","ErrorMessageQualityEvaluator.evaluate"],["SimilarModelsCase.__init__","ModelEditorCase.__init__"],["BioOntologySearchClient.search_as_ontology_results","BioOntologySearchClient.search_all_pages"],["EmbeddingCache.store_embedding","EmbeddingCache._get_connection"],["DuckDBIndex.setup","DuckDBIndex._ensure_connection"],["test_search_by_slug_relevance_ranking","populated_index"],["run_ontology_match_task","ContentPreservationEvaluator.evaluate"],["EmbeddingCache.__aenter__","EmbeddingCache.setup"],["OntologyMatchCase.__init__","_StubFindingInfoAgent.__init__"],["test_performance_over_limit_from_output_duration","_create_ctx"],["_process_and_insert_data","_insert_batch"],["run_with_timer","_await_with_timer"],["test_setup_creates_search_indexes","_fts_index_works"],["run_ontology_match_task","ExclusionEvaluator.evaluate"],["EmbeddingCache.get_embeddings_batch","_hash_text"],["DuckDBOntologySearchClient.search_parallel","DuckDBOntologySearchClient._search_single"],["create_info_from_name","_create_finding_info_agent"],["Person.get","Organization.get"],["DuckDBIndex.add_ids_to_model","get"],["test_performance_missing_duration_returns_na","_create_ctx"],["run_anatomic_search_task","IDPreservationEvaluator.evaluate"],["DuckDBIndex.search","_ensure_connection"],["ModelEditorCase._execute","PerformanceEvaluator.evaluate"],["DuckDBIndex._prepare_batch_payload","DuckDBIndex._build_row_data"],["main","display_current"],["create_edit_agent","_combine_instruction_sections"],["DuckDBIndex._search_exact","_resolve_oifm_id"],["run_finding_description_task","IDPreservationEvaluator.evaluate"],["DuckDBIndex.get_organization","DuckDBIndex._ensure_connection"],["run_model_editor_task","evaluate"],["DuckDBIndex.remove_entry","DuckDBIndex._create_search_indexes"],["run_similar_models_task","ChangeTrackingEvaluator.evaluate"],["index","_fake_openai_client"],["generate_oifm_id","_random_digits"],["DuckDBIndex.get_organizations","DuckDBIndex._ensure_connection"],["run_anatomic_search_task","AttributeAdditionEvaluator.evaluate"],["test_semantic_search_with_real_openai_api","_write_model_file"],["run_anatomic_search_task","SynonymHandlingEvaluator.evaluate"],["test_performance_just_over_limit","_create_ctx"],["ModelEditorCase._execute","RoundTripEvaluator.evaluate"],["_validate_choice_value_indices_and_bases","_collect_value_codes"],["test_create_hnsw_index_basic","_hnsw_index_exists"],["run_similar_models_task","RankingQualityEvaluator.evaluate"],["_print_verbose_stages","_print_query_terms_stage"],["run_finding_description_task","AttributeAdditionEvaluator.evaluate"],["run_finding_description_task","SynonymHandlingEvaluator.evaluate"],["create_info_from_name","_normalize_finding_info"],["validate_finding_model","ValidationContext.get_attribute_ids_by_model"],["BioOntologySearchClient.search_bioontology","DuckDBOntologySearchClient.search"],["run_ontology_match_task","PerformanceEvaluator.evaluate"],["DuckDBIndex._search_exact","_fetch_index_entry"],["EmbeddingCache.__aenter__","setup"],["add_ids_to_model","DuckDBIndex.add_ids_to_model"],["run_anatomic_search_evals","main"],["OntologyMatchCase.__init__","SimilarModelsCase.__init__"],["test_anatomic_location_search","_print_finding_info_stage"],["DuckDBIndex._execute_paginated_query","search_by_slug"],["ChoiceAttributeIded.fix_max_selected","fix_max_selected_validator"],["test_get_organization","_write_model_file"],["run_similar_models_task","HierarchyEvaluator.evaluate"],["run_model_editor_task","PrecisionAtKEvaluator.evaluate"],["DuckDBIndex._execute_batch_directory_update","_create_search_indexes"],["get_detail_on_finding","add_details_to_info"],["create_edit_agent","_natural_language_instructions"],["_create_finding_info","_async_create_finding_info"],["DuckDBIndex.update_from_directory","_prepare_batch_payload"],["run_anatomic_search_task","PerformanceEvaluator.evaluate"],["ModelEditorCase.__init__","_StubFindingInfoAgent.__init__"],["run_model_editor_task","RejectionAccuracyEvaluator.evaluate"],["get_embeddings_batch","_lookup_cached_embeddings"],["add_ids_to_model","add_ids_to_model"],["DuckDBIndex.finalize_placeholder_attribute_ids","generate_attribute_id"],["DuckDBIndex._entry_has_tags","all"],["BioOntologySearchClient.search_parallel","search"],["_download_from_manifest","fetch_manifest"],["assign_real_attribute_ids","_get_index"],["DuckDBIndex.remove_entry","_drop_search_indexes"],["DuckDBOntologySearchClient.search_with_filters","_search_single_with_filters"],["test_batch_operation_partial_failure","_write_model_file"],["create_finding_model_stub_from_finding_info","create_model_stub_from_info"],["DuckDBOntologySearchClient._search_single","DuckDBOntologySearchClient._get_embedding"],["_session_monkeypatch_setup","_fake_client_for_testing"],["test_denormalized_model_people_table","_table_count"],["_generate_search_terms_with_fallback","create_term_generation_agent"],["DuckDBIndex.add_or_update_entry_from_file","_drop_search_indexes"],["DuckDBIndex.add_or_update_entry_from_file","_replace_synonyms"],["test_add_and_retrieve_model","_write_model_file"],["DuckDBIndex.setup","DuckDBIndex._create_search_indexes"],["OntologySearchProtocol.search_parallel","DuckDBIndex.search"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._replace_synonyms"],["DuckDBIndex.add_ids_to_model","Person.get"],["run_anatomic_search_task","RoundTripEvaluator.evaluate"],["FindingModelFull.index_codes_str","_index_codes_str"],["DuckDBIndex.__aenter__","_ensure_connection"],["DuckDBIndex.generate_model_id","DuckDBIndex.setup"],["DuckDBIndex._load_models_metadata","_build_search_text"],["test_performance_very_slow_execution","_create_ctx"],["DuckDBIndex.get_people","DuckDBIndex._ensure_connection"],["DuckDBIndex.remove_entry","DuckDBIndex._ensure_writable_connection"],["make_info","_do_make_info"],["_session_monkeypatch_setup","_fake_embedding_deterministic"],["ModelEditorCase._execute","evaluate"],["build","progress_update"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._ensure_writable_connection"],["DuckDBIndex.count_search","_build_slug_search_clause"],["run_model_editor_task","SearchAccuracyEvaluator.evaluate"],["test_write_operations_rebuild_search_indexes","_fts_index_works"],["DuckDBIndex.all","all"],["MarkdownInCase.__init__","DuckDBIndex.__init__"],["create_edit_agent","_normalize_new_attribute_ids"],["AnatomicSearchCase.__init__","MarkdownInCase.__init__"],["anatomic_validate","_do_validate"],["DuckDBIndex.update_from_directory","DuckDBIndex._prepare_batch_payload"],["DuckDBIndex._fetch_index_entry","DuckDBIndex._collect_contributors"],["test_get_people","_write_model_file"],["AnatomicSearchCase.__init__","DuckDBIndex.__init__"],["handle_natural_language","run_with_timer"],["DuckDBIndex.get_full","_ensure_connection"],["DuckDBIndex.search_by_slug","search_by_slug"],["_process_and_insert_data","create_searchable_text"],["_print_verbose_stages","_print_ai_selection_stage"],["ModelEditorCase.__init__","SimilarModelsCase.__init__"],["EmbeddingCache.store_embeddings_batch","EmbeddingCache._hash_text"],["run_ontology_match_task","StructuralValidityEvaluator.evaluate"],["run_markdown_in_task","ErrorHandlingEvaluator.evaluate"],["ModelEditorCase._execute","PrecisionAtKEvaluator.evaluate"],["DuckDBOntologySearchClient.search_parallel","_search_single"],["fetch_manifest","fetch_manifest"],["get_embeddings_batch","_fetch_and_store_embeddings"],["DuckDBIndex.contains","DuckDBIndex._resolve_oifm_id"],["DuckDBIndex.remove_entry","_create_search_indexes"],["run_markdown_in_task","ContentPreservationEvaluator.evaluate"],["test_anatomic_location_search","_print_verbose_stages"],["Organization.get","Person.get"],["run_anatomic_search_task","evaluate"],["DuckDBIndex.search","DuckDBIndex._search_semantic"],["main","check_configuration"],["test_ontology_concept_match","perform_search_stages"],["DuckDBIndex._entry_has_tags","DuckDBIndex.all"],["run_markdown_in_task","ExclusionEvaluator.evaluate"],["run_finding_description_task","evaluate"],["create_fts_index","create_fts_index"],["model_file_name","normalize_name"],["DuckDBOntologySearchClient.search","_search_single"],["create_rejection_cases","load_fm_json"],["edit_model_markdown","create_markdown_edit_agent"],["DuckDBOntologySearchClient._search_single","_find_exact_matches"],["DuckDBIndex.get_full_batch","_ensure_connection"],["parse_args","parse_args"],["DuckDBIndex.finalize_placeholder_attribute_ids","DuckDBIndex.setup"],["run_model_editor_task","RankingQualityEvaluator.evaluate"],["DuckDBIndex.get_full","DuckDBIndex._ensure_connection"],["BioOntologySearchClient.search_bioontology","BioOntologySearchClient.search"],["DuckDBIndex.generate_attribute_id","generate_attribute_id"],["DuckDBIndex.get_full","EmbeddingCache.setup"],["BioOntologySearchClient.search_bioontology","search"],["DuckDBIndex._execute_batch_directory_update","DuckDBIndex._drop_search_indexes"],["ModelEditorCase._execute","SearchAccuracyEvaluator.evaluate"],["main","test_ontology_concept_match"],["DuckDBIndex._load_oifm_ids_for_source","DuckDBIndex._ensure_connection"],["DuckDBIndex.all","DuckDBIndex._execute_paginated_query"],["run_anatomic_search_task","PrecisionAtKEvaluator.evaluate"],["get_embedding","get_embedding"],["test_concurrent_index_operations","add_file"],["EmbeddingCache.get_embeddings_batch","_get_connection"],["run_model_editor_task","HierarchyEvaluator.evaluate"],["BioOntologySearchClient.search_bioontology","from_api_response"],["DuckDBIndex.all","DuckDBIndex.all"],["EmbeddingCache.get_embeddings_batch","EmbeddingCache._get_connection"],["_validate_existing_attr_suffixes","_parse_suffix"],["_handle_command_input","prompt_command_text"],["run_finding_description_task","PrecisionAtKEvaluator.evaluate"],["Person.get","Person.get"],["DuckDBIndex._execute_paginated_query","DuckDBIndex.search_by_slug"],["DuckDBIndex.search","DuckDBIndex._search_exact"],["DuckDBIndex.search_batch","DuckDBIndex._search_semantic_with_embedding"],["run_markdown_in_task","PerformanceEvaluator.evaluate"],["DuckDBIndex.setup","_create_search_indexes"],["run_finding_description_task","RejectionAccuracyEvaluator.evaluate"],["DuckDBIndex.update_from_directory","DuckDBIndex._stage_directory_files"],["DuckDBIndex.count_people","_ensure_connection"],["match_ontology_concepts","generate_finding_query_terms"],["test_performance_very_fast_execution","_create_ctx"],["MarkdownInCase.__init__","_StubFindingInfoAgent.__init__"],["run_ontology_match_task","TypeCorrectnessEvaluator.evaluate"],["DuckDBIndex.get","DuckDBIndex._fetch_index_entry"],["run_ontology_match_task","AttributePreservationEvaluator.evaluate"],["validate_finding_model","check_oifm_id_conflict"],["test_add_updated_model_file","_write_model_file"],["AnatomicSearchCase.__init__","_StubFindingInfoAgent.__init__"],["OntologyMatchCase.__init__","PrecisionAtKEvaluator.__init__"],["TestAnatomicCLI.test_build_basic","_fake_openai_client"],["DuckDBIndex.setup","_load_base_contributors"],["OntologyMatchCase.__init__","BioOntologySearchClient.__init__"],["BioOntologySearchClient.search_all_pages","search_bioontology"],["DuckDBIndex.add_ids_to_model","setup"],["run_markdown_in_evals","main"],["MarkdownInCase.__init__","AnatomicSearchCase.__init__"],["EmbeddingCache.get_embedding","_hash_text"],["weighted_fusion","normalize_scores"],["_lookup_cached_embeddings","get_embeddings_batch"],["AnatomicSearchCase.__init__","AnatomicSearchCase.__init__"],["DuckDBIndex._prepare_batch_payload","DuckDBIndex._load_models_metadata"],["ensure_anatomic_db","ensure_db_file"],["DuckDBIndex._search_semantic_with_embedding","DuckDBIndex.search_batch"],["run_anatomic_search_task","SearchAccuracyEvaluator.evaluate"],["DuckDBIndex.count_search","DuckDBIndex.count_search"],["ModelEditorCase._execute","ChangeTrackingEvaluator.evaluate"],["DuckDBIndex._insert_models_with_progress","DuckDBIndex._apply_batch_mutations"],["DuckDBOntologySearchClient._search_single","_apply_rrf_fusion"],["DuckDBIndex.get_full","setup"],["categorize_with_validation","ensure_exact_matches_post_process"],["test_create_fts_index_multiple_columns","_fts_index_exists"],["DuckDBIndex.update_from_directory","DuckDBIndex.setup"],["ensure_index_db","ensure_db_file"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._replace_tags"],["TestEnsureDbFileMocked.test_creates_parent_directory_before_download","create_file_and_return"],["run_finding_description_task","SearchAccuracyEvaluator.evaluate"],["add_ids_to_finding_model","DuckDBIndex.add_ids_to_model"],["main","run_session"],["run_model_editor_task","ErrorHandlingEvaluator.evaluate"],["DuckDBIndex.all","_execute_paginated_query"],["create_edit_agent","_validate_output"],["validate_finding_model","MockValidationContext.get_existing_names"],["add_details_to_finding_info","add_details_to_info"],["ModelEditorCase._execute","RankingQualityEvaluator.evaluate"],["ModelEditorCase._execute","ErrorMessageQualityEvaluator.evaluate"],["_natural_language_instructions","_combine_instruction_sections"],["test_denormalized_tags_table","_table_count"],["test_performance_custom_time_limit","_create_ctx"],["SimilarModelsCase.__init__","MarkdownInCase.__init__"],["DuckDBIndex.finalize_placeholder_attribute_ids","finalize_placeholder_attribute_ids"],["DuckDBIndex.remove_entry","EmbeddingCache.setup"],["test_drop_search_indexes_both","_fts_index_exists"],["DuckDBIndex.setup","_ensure_connection"],["add_ids_to_finding_model","add_ids_to_model"],["apply_edit","render_changes"],["DuckDBIndex.search_by_slug","DuckDBIndex.search_by_slug"],["BioOntologySearchClient.search_parallel","DuckDBOntologySearchClient.search"],["run_model_editor_task","ExclusionEvaluator.evaluate"],["DuckDBIndex._execute_paginated_query","DuckDBIndex._ensure_connection"],["DuckDBIndex.search","_search_fts"],["DuckDBIndex.get_full_batch","DuckDBIndex.setup"],["test_denormalized_synonyms_table","_write_model_file"],["test_performance_over_limit_from_query_time","_create_ctx"],["DuckDBIndex._prepare_batch_payload","_load_models_metadata"],["get_embedding_for_duckdb","_to_float32"],["OntologyMatchCase.__init__","EmbeddingCache.__init__"],["DuckDBIndex.contains","_ensure_connection"],["AnatomicSearchCase.__init__","SimilarModelsCase.__init__"],["DuckDBIndex.add_ids_to_model","DuckDBIndex.get"],["DuckDBIndex.generate_attribute_id","DuckDBIndex.setup"],["DuckDBIndex.get","_fetch_index_entry"],["DuckDBOntologySearchClient._find_exact_matches","DuckDBOntologySearchClient._row_to_result"],["DuckDBOntologySearchClient._search_single_with_filters","_find_exact_matches"],["OntologySearchProtocol.search_parallel","DuckDBOntologySearchClient.search"],["run_markdown_in_task","StructuralValidityEvaluator.evaluate"],["DuckDBIndex.add_ids_to_model","generate_model_id"],["run_ontology_match_task","ErrorMessageQualityEvaluator.evaluate"],["run_anatomic_search_task","ChangeTrackingEvaluator.evaluate"],["DuckDBIndex._prepare_batch_payload","_generate_embeddings"],["DuckDBIndex.generate_model_id","DuckDBIndex._load_oifm_ids_for_source"],["DuckDBOntologySearchClient._search_single","OntologySearchProtocol.search"],["ModelEditorCase.__init__","PrecisionAtKEvaluator.__init__"],["test_anatomic_location_search","_print_summary"],["ModelEditorCase.__init__","BioOntologySearchClient.__init__"],["DuckDBIndex.get_organization","_ensure_connection"],["build","_do_build"],["DuckDBIndex.get_organizations","_ensure_connection"],["test_validation_context_accepts_different_implementations","ValidationContext.get_attribute_ids_by_model"],["run_anatomic_search_task","RankingQualityEvaluator.evaluate"],["test_semantic_search_returns_results","_write_model_file"],["run_anatomic_search_task","ErrorMessageQualityEvaluator.evaluate"],["DuckDBIndex.search","DuckDBIndex._search_fts"],["DuckDBIndex._search_exact","DuckDBIndex._fetch_index_entry"],["DuckDBOntologySearchClient._search_single","DuckDBOntologySearchClient._combine_with_exact_matches"],["_fake_client_for_testing","_fake_openai_client"],["BioOntologySearchClient.search_as_ontology_results","BioOntologySearchResult.to_ontology_search_result"],["run_finding_description_task","RankingQualityEvaluator.evaluate"],["MarkdownInCase.__init__","DuckDBOntologySearchClient.__init__"],["MarkdownInCase.__init__","__init__"],["DuckDBIndex.remove_entry","setup"],["AnatomicSearchCase.__init__","DuckDBOntologySearchClient.__init__"],["AnatomicSearchCase.__init__","__init__"],["DuckDBIndex._search_exact","_entry_has_tags"],["run_ontology_match_task","IDPreservationEvaluator.evaluate"],["handle_save","record_save"],["DuckDBIndex._collect_directory_files","_calculate_file_hash"],["OntologyMatchCase.__init__","MockValidationContext.__init__"],["DuckDBIndex.add_or_update_entry_from_file","setup"],["run_finding_description_task","HierarchyEvaluator.evaluate"],["generate_oifma_id","_random_digits"],["DuckDBIndex.contains","DuckDBIndex._ensure_connection"],["DuckDBIndex.add_or_update_entry_from_file","_build_embedding_text"],["match_ontology_concepts","build_final_output"],["_handle_reset","display_current"],["OntologyMatchCase.__init__","ModelEditorCase.__init__"],["OntologyMatchCase.__init__","AnatomicSearchCase.__init__"],["run_similar_models_evals","run_similar_models_evals"],["MarkdownInCase.__init__","DemoState.__init__"],["DuckDBIndex._execute_batch_directory_update","_delete_old_entries"],["DuckDBIndex.get","DuckDBIndex._resolve_oifm_id"],["test_concurrent_index_operations","_write_model_file"],["DuckDBIndex._build_slug_search_clause","DuckDBIndex._build_slug_search_clause"],["DuckDBIndex.count","DuckDBIndex._ensure_connection"],["run_ontology_match_task","AttributeAdditionEvaluator.evaluate"],["DuckDBIndex._search_semantic","_ensure_openai_client"],["run_ontology_match_task","SynonymHandlingEvaluator.evaluate"],["ModelEditorCase.__init__","EmbeddingCache.__init__"],["DuckDBIndex.finalize_placeholder_attribute_ids","get"],["DuckDBOntologySearchClient._search_single_with_filters","_apply_rrf_fusion"],["create_markdown_edit_agent","_basic_edit_validation"],["test_update_from_directory_batch_update","_write_model_file"],["EmbeddingCache.clear_cache","_get_connection"],["test_search_with_nonexistent_tags","_write_model_file"],["test_write_operations_rebuild_search_indexes","_hnsw_index_exists"],["DuckDBIndex.count_organizations","DuckDBIndex._ensure_connection"],["DuckDBIndex.add_or_update_entry_from_file","DuckDBIndex._create_search_indexes"],["_edited_text_instructions","_combine_instruction_sections"],["get_embedding_for_duckdb","EmbeddingCache._to_float32"],["EmbeddingCache.clear_cache","EmbeddingCache._get_connection"],["DuckDBOntologySearchClient.search","DuckDBOntologySearchClient._search_single"],["_fake_batch_embeddings","_fake_embedding_anatomic"],["create_edit_agent","_common_editing_instructions"],["EmbeddingCache.__aenter__","DuckDBIndex.setup"],["DuckDBIndex.get_people","_ensure_connection"],["run_markdown_in_task","TypeCorrectnessEvaluator.evaluate"],["execute_ontology_search","_filter_anatomical_concepts"],["Person.organization","get"],["run_markdown_in_task","AttributePreservationEvaluator.evaluate"],["test_performance_query_time_over_output_duration","_create_ctx"],["_print_verbose_stages","_print_final_output_stage"],["run_ontology_match_evals","main"],["_validate_choice_value_indices_and_bases","_validate_new_attr_suffixes"],["DuckDBOntologySearchClient._search_single","_combine_with_exact_matches"],["test_tag_filtering_works_in_all_search_paths","_write_model_file"],["DuckDBIndex.add_or_update_entry_from_file","_upsert_contributors"],["validate_finding_model","MockValidationContext.get_existing_oifm_ids"],["ensure_db_file","_download_file"],["run_finding_description_task","ErrorHandlingEvaluator.evaluate"],["BioOntologySearchClient.search","BioOntologySearchClient.search_as_ontology_results"],["DuckDBOntologySearchClient._search_single","_row_to_result"],["apply_edit","render_rejections"],["add_standard_codes_to_model","_add_index_codes"],["Organization.get","get"],["DuckDBIndex.count_search","count_search"],["BioOntologySearchClient.search_parallel","BioOntologySearchClient.search"],["ModelEditorCase.__init__","MockValidationContext.__init__"],["run_model_editor_task","StructuralValidityEvaluator.evaluate"],["run_ontology_match_task","RoundTripEvaluator.evaluate"],["_handle_reset","DemoState.reset"],["handle_markdown_edit","apply_edit"],["DuckDBIndex._validate_model","DuckDBIndex._ensure_connection"],["test_count_organizations","_write_model_file"]],"d":{".github/copilot-instructions.md":["Copilot Instructions \u00b7 FindingModel"],".github/prompts/implement-plan.prompt.md":["Implement Development Plan","Approach: One Phase at a Time","Before Starting Phase","During Implementation","After Completing Phase","If Something Goes Wrong","Remember"],".github/prompts/review-plan.prompt.md":["Plan Review Assessment","Context","Review Process","Step 1: Check Historical Context","Step 2: Goal Assessment","Step 3: Work Breakdown Evaluation","Step 4: Technical Approach Validation","Step 5: Completeness Check","Output","Executive Summary"],".serena/memories/agent_evaluation_best_practices_2025.md":["Agent Evaluation Best Practices - 2025","Framework: Pydantic AI Evals","Evaluator Architecture","Core Pattern","1. Define data models","2. Create focused evaluators (return 0.0-1.0)","3. Build dataset AT MODULE LEVEL with evaluators","4. Run evaluation (evaluators already in Dataset)","Logfire Integration (Automatic)","What Happens When `ensure_instrumented()` Is Called"],".serena/memories/ai_assistant_usage_2025.md":["AI Assistant Usage Guidelines (2025-10-06)","Core Principles","Instruction File Strategy","Best Practices (Sources: GitHub Copilot Custom Instructions Guidance, Claude Code Memory Docs)","Testing Guidelines (Updated 2025-10-06)","Model Editing Feature (v0.4)","Required Behaviors for Agents"],".serena/memories/anatomic_location_search_implementation.md":["Anatomic Location Search Implementation","Overview","CLI Commands (2025-10-13)","Build database from default URL","Build from custom source with force overwrite  ","Validate data without building database","Show database statistics","Architecture Decisions","Two-Agent Pattern","DuckDB Backend (2025-09)"],".serena/memories/api_integration.md":["API Integration and External Services","Required API Keys","OpenAI API","Perplexity API","MongoDB (Optional)","Configuration Management","Testing with External APIs","API Error Handling"],".serena/memories/bioontology_integration_2025.md":["BioOntology API Integration (2025-09-09)","Overview","Implementation Details","BioOntologySearchClient","Key Features","API Response Mapping","Integration with Protocol","Performance Characteristics","Configuration Requirements",".env file"],".serena/memories/code_style_conventions.md":["Code Style and Conventions","Python Version","Code Style","Code Patterns","Logging","Testing","Error Handling","Naming Conventions","Design Principles","Package Data Pattern"],".serena/memories/documentation_corrections_2025.md":["Documentation Corrections - January 2025","Overview","Major Corrections","1. Index Class Documentation","2. find_similar_models() Function","Wrong signature and behavior","Returns list of tuples (wrong)","Actual signature and behavior","Returns SimilarModelAnalysis object with:","- recommendation: \"edit_existing\", \"create_new\", or \"review_needed\""],".serena/memories/duckdb_hybrid_search_research_2025.md":["DuckDB Hybrid Search Best Practices (2025)","Overview","Key Technical Approaches","1. Full-Text Search (FTS)","2. Vector Embeddings","3. Hybrid Search Fusion","4. Schema Design Best Practices","Implementation Pattern from Anatomic Location Search","References"],".serena/memories/evaluator_architecture_2025.md":["Evaluator Architecture (2025)","Overview","Evaluator Hierarchy (Priority Order)","Where Evaluators Live","`src/findingmodel/tools/evaluators.py`","Inline in Eval Scripts (`evals/*.py`)","Import Patterns","For Eval Scripts","Built-in evaluators from Pydantic Evals","Custom reusable evaluators from our library"],".serena/memories/index_duckdb_migration_decisions_2025.md":["Index DuckDB Migration - Key Decisions","Architecture Decisions","Drop/Rebuild HNSW Strategy (2025-10-08)","No Foreign Key Constraints (2025-10-08)","Separate Contributor Tables (2025-10-08)","Denormalized Tables (2025-10-08)","Batch Directory Ingestion (2025-10-08)","Read-Only Mode by Default (2025-10-08)","Semantic Search Always Enabled (2025-10-08)","Remote Database Downloads (2025-10-11)"],".serena/memories/index_duckdb_migration_status_2025.md":["DuckDB Index Migration Status","Phase 1: Technology Migration - COMPLETE \u2705","Implementation Complete","Tests Complete","Bug Fixes Applied","What's Next","Integration Tasks (can be separate PR)","Optional Enhancements (deferred)","Phase 2: Architectural Refactoring","Key Architectural Decisions"],".serena/memories/instruction_files_plan_2025.md":["Instruction File Alignment Plan (2025-09-28)","Goal","Structure Blueprint","Update Process"],".serena/memories/logfire_observability_2025.md":["Logfire Observability for FindingModel - 2025","Overview","Key Design Principles - FindingModel Implementation","1. Settings-Based Configuration (NOT os.getenv)","Configure Logfire using project settings","Instrument Pydantic AI agents (PRIMARY instrumentation)","2. Environment Variables (Managed by Settings)","3. ConsoleOptions for Console Configuration","Structured Logging Patterns","Use Named Parameters"],".serena/memories/model_editing_guardrails_2025-09-26.md":["Model Editing Guardrails (September 26, 2025)"],".serena/memories/multi_agent_orchestration_system_2025.md":["Multi-Agent Orchestration System (2025)","Overview","Architecture","Orchestrator Layer","Implementation Agents","Evaluation Agents","Workflow","Evaluation Criteria","Orchestration Patterns","Parallel Processing"],".serena/memories/ontology_concept_search_refactoring.md":["Ontology Concept Search Refactoring (2025-09-04)","Overview","Key Architecture Changes","Performance Optimization (85% improvement)","Pydantic AI Pattern Corrections","Query Generation","Text Normalization Improvements","Post-Processing for Exact Matches","Testing Improvements","Framework Consistency"],".serena/memories/ontology_search_optimizations_2025.md":["Ontology Search Optimizations (2025-09-15)","Performance Improvements Implemented","1. Reduced Default Ontology Set","2. Cohere Reranking Configuration","3. SNOMEDCT Prioritization","4. Code Complexity Management","Architecture Decisions","Protocol-Based Backend Support","Configuration Philosophy","Testing Strategy"],".serena/memories/project_overview.md":["FindingModel Project Overview","Purpose","Tech Stack","Project Structure","Key Features"],".serena/memories/project_state_january_2025.md":["Project State - January 2025","Current Status","\u2705 All Tests Passing","\u2705 Code Quality","\u2705 Documentation","Recent Major Improvements","Test Suite Enhancements","Documentation Fixes","Code Quality Improvements","Known Working Commands"],".serena/memories/protocol_based_architecture_2025.md":["Protocol-Based Architecture Pattern (2025-09-09)","Overview","Key Design Decisions","Protocol Interface Design","Implementation Pattern","Backend Implementations","Auto-Detection and Parallel Execution","Benefits","Flexibility","Performance"],".serena/memories/pydantic_ai_best_practices_2025_09.md":["Pydantic AI Usage Notes (Sep 2025)"],".serena/memories/pydantic_ai_testing_best_practices.md":["Pydantic AI Testing Best Practices","Core Philosophy","Essential Patterns","1. Prevent Accidental API Calls","2. Use TestModel for Simple Testing","3. Use FunctionModel for Complex Behavior","4. Integration Test Pattern","Anti-Patterns to Avoid","\u274c Testing Library Functionality","BAD - tests Pydantic AI, not your code"],".serena/memories/pytest_fixtures_reference_2025.md":["Pytest Fixtures Reference","Overview","Critical Rules for Test Implementation","\u274c DO NOT","\u2705 DO","Available Fixtures","1. `full_model` - Valid Test Model with IDs","2. `real_model` - Real Pulmonary Embolism Model","3. `tmp_defs_path` - Directory of Test Files","4. `base_model` - Model Without IDs"],".serena/memories/suggested_commands.md":["Development Commands","Primary Commands (using Task)","Testing","Code Quality","Building","Alternative Commands (using uv directly)","Testing","Code Quality","Building","CLI Usage"],".serena/memories/task_completion_checklist.md":["Task Completion Checklist","1. Code Quality Checks (REQUIRED)","2. Run Tests (REQUIRED)","3. Test External APIs (if modified)","4. Verify Specific Changes","5. Check Git Status","Important Notes","When to Skip Checks"],".serena/memories/test_suite_improvements_2025.md":["Test Suite Improvements - January 2025","Overview","Added Test Coverage","1. Index.search() Functionality Tests (test_index.py)","2. AI Tools Integration Tests (test_tools.py)","3. find_similar_models() Coverage (test_tools.py)","4. Error Handling Tests","Linting Fixes Applied","Test Statistics","Running Tests"],"CHANGELOG.md":["Changelog","[Unreleased\u2014presumed 0.5.1]","Added","Removed","Fixed","[0.5.0] - 2025-11-03","Added","Changed","Deprecated","Removed"],"CLAUDE.md":["CLAUDE.md","0. Operate via Serena MCP at all times","1. Project snapshot (see Serena `project_overview`)","2. Architecture touchpoints","3. Coding standards (Serena `code_style_conventions`)","4. Testing + QA (Serena `pydantic_ai_testing_best_practices`)","Three-Tier Testing Structure","Test Data and Fixtures","Tasks","5. Workflow expectations"],"README.md":["`findingmodel` Package","Features","Installation","Configuration","API Keys (Required/Optional by Feature)","Required for most features","Optional - only needed for add_details_to_info()","Optional - only needed for BioOntology backend in ontology searches","Local Database Configuration","Production: use pre-mounted files"],"docs/database-management.md":["Database Management Guide","Overview","Database Architecture","Finding Models Index","Anatomic Locations Database","Automatic Database Downloads","Finding models index","Anatomic locations database","CLI Commands","Finding Models Index Management"],"docs/logfire_observability_guide.md":["Logfire Observability Guide for FindingModel","Overview","Table of Contents","Installation and Setup","Installation","Install all dev dependencies including logfire","Or install logfire specifically","Authentication","Authenticate with Logfire (interactive)","This creates credentials in ~/.logfire/"],"docs/manifest_schema.md":["Manifest.json Schema","Purpose","Schema (v1.0)","Field Definitions","Top Level","Database Entry","Validation Rules","Update Process","Backward Compatibility"],"evals/CLAUDE.md":["CLAUDE.md - Eval Development Quick Reference","Purpose","Documentation Map","Essential Quick Facts","File Naming","No Logfire Code Needed","Standard Pattern","1. Data models (input, expected output, actual output)","2. Evaluators inheriting from Evaluator base class","3. Dataset at module level with cases + evaluators"],"evals/README.md":["Eval Suites for FindingModel AI Agents","What are Evals?","How to Run Evals","Run all eval suites","Run specific eval suite","Or directly:","From Python","Calculate overall score (average of all evaluator scores across all cases)","How to Read Eval Output","Understanding Scores"],"evals/evals_guide.md":["Evaluation Guide for FindingModel AI Agents","Overview","Table of Contents","Why Evaluate AI Agents","Two-Level Evaluation Strategy","Evaluation Framework","Pydantic AI Evals","Core Concepts","Pydantic Evals Architecture","The Standard Pattern"],"specs/001-ai-based-finding/contracts/markdown_api.md":["API Contract: Markdown Editing","`export_model_for_editing`","Inputs","Behavior","Output","`edit_model_markdown`","Inputs","Behavior","Output","Post-processing Requirements"],"specs/001-ai-based-finding/contracts/natural_language_api.md":["API Contract: Natural Language Editing","`edit_model_natural_language`","Inputs","Behavior","Output","Post-processing Requirements","Related Tests"],"specs/001-ai-based-finding/plan.md":["Implementation Plan: AI-Based Finding Model Editor","Execution Flow (/plan command scope)","Summary","Technical Context","Technical Context","Constitution Check","Project Structure","Implementation Approach"],"specs/001-ai-based-finding/quickstart.md":["Quickstart: AI-Based Finding Model Editor (Simplified)","Prerequisites","Natural Language Editing","Markdown Editing","User edits markdown_content..."],"specs/001-ai-based-finding/research.md":["Research: AI-Based Finding Model Editor (Expanded)","Technical Context","Pydantic AI Agent Usage Patterns","Testing Pydantic AI Agents","Example: Async Agent Test","Patterns from Existing Code","Rationale"],"specs/001-ai-based-finding/spec.md":["Feature Specification: AI-Based Finding Model Editor","\u26a1 Quick Guidelines","User Scenarios & Testing","Primary User Story","Acceptance Scenarios","Edge Cases","Requirements","Functional Requirements (Minimal Plan)","Key Entities (Minimal Plan)"],"specs/001-ai-based-finding/tasks.md":["Tasks: AI-Based Finding Model Editor","Task List","T001. [P] Project Setup and Linting \u2705 COMPLETED","T002. [P] Contract Test: Natural Language Editing \u2705 COMPLETED","T003. [P] Contract Test: Markdown Editing \u2705 COMPLETED","T004. Implement: Natural Language Editing \u2705 COMPLETED","T005. Implement: Markdown Editing \u2705 COMPLETED","T006. Demo Script: Natural Language Editing \u2705 COMPLETED","T007. Demo Script: Markdown Editing \u2705 COMPLETED","T008. [P] Polish: Documentation and Final Tests \u2705 COMPLETED"],"specs/001-ai-based-finding/team-update-2025-09-26.md":["Team Update \u2014 26 September 2025","Highlights","What To Know","Follow-Up Actions","Lessons Learned"],"tasks/agent_refactoring_plan.md":["Agent Refactoring Plan","Overview","Plan 1: Replace instructor with Pydantic AI","Task 1.1: Refactor `create_model_from_markdown()` to use Pydantic AI Agent","Replace this:","With this:","Task 1.1.1: Refactor finding_description.py to use render_agent_prompt()","Task 1.2: Remove instructor dependency from common.py","Task 1.3: Remove instructor from dependencies"],"tasks/anatomic-location-cleanup.md":["Anatomic Location Search Cleanup","Goal","Implementation","Phase 1: Refactor Search Client","Phase 2: Create CLI Commands","Phase 3: Add Tests","Phase 4: Cleanup","Key Files","Notes"],"tasks/deferred_to_0_5_1.md":["Deferred to v0.5.1","1. Manifest and Database Distribution Enhancements","Overview","1.1 CLI Command for Manifest Generation","1.2 S3 Upload and Deployment","Upload databases and generate manifest in one command","In FindingModelConfig or env vars","1.3 Version History and Pinning"],"tasks/done/README.md":["Completed Tasks","Active Consolidated Documents","agent_eval_expansion_and_architecture_refactoring.md","Other Completed Tasks","evaluation_system_phase_0_complete.md","refactor_model_editor_evals.md","separate_evals_from_tests_plan.md","anatomic-location-search-implementation-plan.md & anatomic-location-search-prd.md","drive_to_040.md","Notes"],"tasks/done/agent_eval_expansion_and_architecture_refactoring.md":["Agent Evaluation Expansion & Architecture Refactoring","Executive Summary","Key Outcomes","Table of Contents","Original Plan: Expand Agent Evaluation Coverage","Overview","Scope","Implementation Strategy","Shared Patterns","1. Imp"],"tasks/done/anatomic-location-search-implementation-plan.md":["Implementation Plan for Anatomic Location Search Tool","Current Status","Phase 1: Refactor Common Utilities \u2705 COMPLETED","Phase 2: Create Ontology Search Module \u2705 COMPLETED","Phase 3: Add LanceDB Configuration \u2705 COMPLETED","Phase 4: Implement Anatomic Location Search \u2705 COMPLETED","Phase 5: Testing \ud83d\udd04 IN PROGRESS - MAJOR ISSUES IDENTIFIED","Critical Issues Found (2025-08-29):"],"tasks/done/anatomic-location-search-prd.md":["PRD: Anatomic Location Search Tool for FindingModel","Overview","Core Architecture","1. Modular File Structure","2. Core Components","src/findingmodel/tools/ontology_search.py","Table constants","src/findingmodel/tools/common.py (add this function)"],"tasks/done/drive_to_040.md":["Drive to v0.4.0 Release","Overview","Phase 1: DuckDB Utilities Extraction","Current Duplication","Implementation Tasks","Phase 2: MongoDB \u2192 DuckDB Swap","File Operations","Config Updates","Dependency Updates","Testing"],"tasks/done/evaluation_system_phase_0_complete.md":["Evaluation System - Next Steps","Context","What's Been Completed","The Problem","Phase 0: Fix Logfire Observability Architecture \u2705 COMPLETE","Task 0.1: Create Centralized Logfire Configuration","Configure Logfire once for entire evals package","Follows Python logging best practice: configure at package level","Instrument Pydantic AI once for automatic agent/model/tool tracing","Task 0.2: Refactor evals/model_editor.py"],"tasks/done/refactor_model_editor_evals.md":["Refactor Model Editor Evaluation Suite","Status: Phase 3 Complete - All Core Work Done","Overview","Current State","Implemented (in PR `copilot/add-eval-case-functionality`)","Phase 2 Improvements (NOW COMPLETE)","Goals","Implementation Plan","Phase 1: Foundation \u2705 IMPLEMENTED (except tests)","Evaluators to implement:"],"tasks/done/separate_evals_from_tests_plan.md":["Separate Evals from Tests - Implementation Plan","Vision & Context","The Problem","The Solution","Outcome","Overall Phases","Task Breakdown","Phase 1: Create evals/ Directory Structure"],"tasks/duckdb-common-patterns.md":["DuckDB Common Patterns - Code Consolidation Plan","Goal","Analysis: Common Patterns","1. Connection Management \u2705 **EXTRACT**","src/findingmodel/tools/duckdb_utils.py","In DuckDBOntologySearchClient","In DuckDBIndex","2. Embedding Generation \u2705 **EXTRACT**","src/findingmodel/tools/duckdb_utils.py"],"tasks/finding_info_generation_rework_prd.md":["FindingInfo Generation Rework PRD","1. Overview","2. Background","3. Problem Statement","4. Goals & Non-Goals","Goals","Non-Goals","5. User Stories","6. Functional Requirements","7. Non-Functional Requirements"],"tasks/finding_info_generation_rework_tasks.md":["FindingInfo Generation Rework Tasks","Task 1 \u2014 Replace Instructor client with Pydantic AI Agent","Task 2 \u2014 Revise finding description prompt instructions","Task 3 \u2014 Light-touch normalization helper (optional)","Task 4 \u2014 Update CLI and imports","Task 5 \u2014 Add deterministic unit tests for agent behavior","Task 6 \u2014 Documentation and verification"],"tasks/index-duckdb-migration.md":["Index DuckDB Migration Plan - Phase 1","Goal","Current State (2025-10-11)","Phase 1 Implementation Complete \u2705","What's Remaining for Integration \u23f3","Anatomic Location Search Status","Architectural Note","Why Phase 1 First?"],"tasks/index_api_enhancements_plan.md":["Index API Enhancements and Database Self-Containment Plan","Overview","Key Architecture Decisions","JSON Storage","Manifest Schema","Code Quality","Background","Current Problems","Real-World Impact","\u274c Breaking abstraction - accessing internal connection"],"tasks/ontology-concept-search-prd.md":["Product Requirements Document: Comprehensive Ontology Concept Search Tool","Overview","Purpose","Key Differentiators from Anatomic Location Search","Functional Requirements","1. Search Scope","2. Multi-Agent Architecture","3. Output Format","4. Search Strategy","Pydantic AI Agent Architecture"],"tasks/pending-fixes.md":["Pending Fixes and Technical Debt","Anatomic Location Search - Hardcoded Dimensions","Migration Script - Config Usage","Anatomic Location DuckDB Rebuild - Preserve Embeddings","DuckDB Migration Script","Issue: Uses hardcoded embedding configuration","Future Refactoring","Consolidate DuckDB common code","Remove Cohere references"],"tasks/refactoring/01-index-decomposition.md":["Index Class Decomposition Plan - Phase 2","Executive Summary","Current State Analysis (Post-Phase 1)","Two Monolithic Implementations","Common Problems","Key Methods by Responsibility","Database Operations (10 methods)","Validation (6 methods)  ","File Operations (5 methods)","Search (4 methods)"],"tasks/refactoring/02-api-cleanup.md":["API Cleanup and Deprecation Plan","Executive Summary","Current State Analysis","Duplicate Functions Identified","Problems","Target State","Naming Convention","Public API Structure","src/findingmodel/tools/__init__.py","Implementation Plan"],"tasks/refactoring/03-validation-framework.md":["Validation Framework Plan","Executive Summary","Current State Analysis","Problems with Current Validation","Target Architecture","Core Design Pattern: Chain of Responsibility","src/findingmodel/validation/base.py","Specific Validators","src/findingmodel/validation/validators/id_validator.py","src/findingmodel/validation/validators/name_validator.py"],"tasks/refactoring/04-circular-dependencies.md":["Breaking Circular Dependencies Plan","Executive Summary","Current State Analysis","Circular Dependency Map","Problems","Current problematic code","Person references Index directly","Target Architecture","Design Patterns Applied","New Architecture"],"tasks/refactoring/05-performance-optimizations.md":["Performance Optimizations Plan","Executive Summary","Current Performance Analysis","Identified Bottlenecks","Current: Multiple get() calls in validation","Current: Process files one by one","Current: Individual inserts in batch operations","Target Performance Improvements","Optimization Goals","Implementation Details"],"tasks/test-multi-agent-system.md":["Test Multi-Agent System Plan","Goal","Phase 1: Create Simple Utility Function","Phase 2: Add Tests for Utility Function","Notes"],"test/data/pulmonary_embolism.md":["Pulmonary embolism\u2014`OIFM_MSFT_932618`","Attributes","Presence\u2014`OIFMA_MSFT_463871`","Change from prior\u2014`OIFMA_MSFT_592864`","Other presence\u2014`OIFMA_MSFT_463872`","Size\u2014`OIFMA_MSFT_592865`"],"test/data/thyroid_nodule_codes.md":["Thyroid nodule\u2014`OIFM_MGB_274588`","Attributes","Presence\u2014`OIFMA_MGB_771712`","Size\u2014`OIFMA_MGB_337706`","Change from prior\u2014`OIFMA_MGB_337707`"]},"deps":{"evals/__init__.py":["logfire","logfire","findingmodel.config"],"evals/anatomic_search.py":["time","pydantic","pydantic_evals","pydantic_evals.evaluators","pydantic_evals.reporting","findingmodel.tools.anatomic_location_search","findingmodel.tools.evaluators","findingmodel.config","findingmodel.tools.duckdb_utils","asyncio","evals"],"evals/finding_description.py":["asyncio","os","re","time","pydantic","pydantic_evals","pydantic_evals.evaluators","pydantic_evals.reporting","findingmodel.config","findingmodel.finding_info","findingmodel.tools.evaluators","findingmodel.tools.finding_description","asyncio","evals"],"evals/markdown_in.py":["time","pydantic","pydantic_evals","pydantic_evals.evaluators","pydantic_evals.reporting","findingmodel.finding_info","findingmodel.finding_model","findingmodel.tools.evaluators","findingmodel.tools.markdown_in","asyncio","evals"],"evals/model_editor.py":["pathlib","pydantic","pydantic_evals","pydantic_evals.evaluators","pydantic_evals.reporting","evals.utils","findingmodel.finding_model","findingmodel.tools","asyncio","evals"],"evals/ontology_match.py":["math","time","pydantic","pydantic_evals","pydantic_evals.evaluators","pydantic_evals.reporting","findingmodel.tools.evaluators","findingmodel.tools.ontology_concept_match","findingmodel.tools.ontology_search","asyncio","evals"],"evals/similar_models.py":["time","pydantic","pydantic_evals","pydantic_evals.evaluators","pydantic_evals.reporting","findingmodel.index","findingmodel.tools.evaluators","findingmodel.tools.similar_finding_models","asyncio","evals"],"evals/utils.py":["__future__","pathlib","typing","findingmodel.finding_model","findingmodel.tools","findingmodel.tools"],"scripts/anatomic_location_search.py":["argparse","asyncio","json","sys","time","pathlib","typing","findingmodel","findingmodel.config","findingmodel.finding_info","findingmodel.tools","findingmodel.tools.anatomic_location_search","findingmodel.tools.duckdb_search","asyncio","traceback"],"scripts/edit_finding_model.py":["__future__","argparse","asyncio","json","shlex","collections.abc","pathlib","typing","prompt_toolkit","prompt_toolkit.completion","prompt_toolkit.formatted_text","prompt_toolkit.history","prompt_toolkit.shortcuts","rich.console","rich.markdown","rich.panel","rich.progress","rich.table","findingmodel.finding_model","findingmodel.index","findingmodel.tools.model_editor"],"scripts/ontology_concept_match.py":["argparse","asyncio","sys","time","typing","findingmodel","findingmodel.config","findingmodel.finding_info","findingmodel.tools","findingmodel.tools.ontology_concept_match","traceback"],"src/findingmodel/abstract_finding_model.py":["typing","findingmodel.finding_model"],"src/findingmodel/anatomic_migration.py":["json","pathlib","typing","duckdb","httpx","openai","findingmodel","findingmodel.config","findingmodel.tools.duckdb_utils"],"src/findingmodel/cli.py":["asyncio","json","sys","pathlib","click","openai","rich.console","rich.table","rich.markdown","findingmodel.config","findingmodel.config","tempfile","findingmodel.config","findingmodel.config","findingmodel.config"],"src/findingmodel/common.py":["re"],"src/findingmodel/config.py":["pathlib","typing","httpx","openai","platformdirs","pydantic","pydantic_settings","typing_extensions","pooch","pooch","findingmodel","findingmodel","findingmodel","findingmodel"],"src/findingmodel/contributor.py":["pathlib","typing","pydantic","typing_extensions"],"src/findingmodel/embedding_cache.py":["__future__","hashlib","array","pathlib","typing","duckdb","platformdirs","findingmodel"],"src/findingmodel/finding_info.py":["pydantic"],"src/findingmodel/finding_model.py":["random","re","enum","typing","pydantic","findingmodel.contributor"],"src/findingmodel/index.py":["__future__","hashlib","collections.abc","dataclasses","datetime","enum","pathlib","types","typing","duckdb","openai","pydantic","findingmodel","findingmodel.common","findingmodel.config","findingmodel.contributor","findingmodel.finding_model","findingmodel.tools.duckdb_utils","findingmodel.config","findingmodel.finding_model","findingmodel.finding_model","json","importlib.resources"],"src/findingmodel/index_code.py":["pydantic"],"src/findingmodel/index_validation.py":["typing","findingmodel.common","findingmodel.finding_model"],"src/findingmodel/tools/__init__.py":["findingmodel.finding_model","findingmodel.index","warnings"],"src/findingmodel/tools/anatomic_location_search.py":["json","pydantic","pydantic_ai","typing_extensions","findingmodel","findingmodel.config","findingmodel.tools.common","findingmodel.tools.duckdb_search","findingmodel.tools.ontology_search"],"src/findingmodel/tools/common.py":["pathlib","instructor","openai","pydantic_ai.models.openai","pydantic_ai.providers.openai","findingmodel","findingmodel.config","findingmodel.embedding_cache"],"src/findingmodel/tools/create_stub.py":["findingmodel.finding_info","findingmodel.finding_model","warnings"],"src/findingmodel/tools/duckdb_search.py":["pathlib","typing","duckdb","openai","findingmodel.config","findingmodel.tools.duckdb_utils","findingmodel.tools.ontology_search","findingmodel.config"],"src/findingmodel/tools/duckdb_utils.py":["__future__","array","collections.abc","contextlib","pathlib","typing","duckdb","openai","findingmodel","findingmodel.config","findingmodel.tools.common"],"src/findingmodel/tools/evaluators.py":["dataclasses","typing","pydantic_evals.evaluators"],"src/findingmodel/tools/finding_description.py":["warnings","pydantic_ai","findingmodel","findingmodel.config","findingmodel.finding_info"],"src/findingmodel/tools/index_codes.py":["typing","findingmodel.finding_model","findingmodel.index_code","warnings"],"src/findingmodel/tools/markdown_in.py":["pathlib","pydantic_ai","findingmodel.config","findingmodel.finding_info","findingmodel.finding_model","warnings"],"src/findingmodel/tools/model_editor.py":["dataclasses","typing","pydantic","pydantic_ai","pydantic_ai.agent","findingmodel","findingmodel.config","findingmodel.finding_model","findingmodel.index","findingmodel.tools.common"],"src/findingmodel/tools/ontology_concept_match.py":["json","dataclasses","pydantic","pydantic_ai","findingmodel","findingmodel.config","findingmodel.tools.common","findingmodel.tools.ontology_search"],"src/findingmodel/tools/ontology_search.py":["asyncio","typing","httpx","pydantic","findingmodel","findingmodel.config","findingmodel.index_code"],"src/findingmodel/tools/prompt_template.py":["re","pathlib","typing","jinja2","openai.types.chat","warnings"],"src/findingmodel/tools/similar_finding_models.py":["json","dataclasses","typing","pydantic","pydantic_ai","typing_extensions","findingmodel","findingmodel.config","findingmodel.index","findingmodel.tools.common","time"],"test/conftest.py":["pathlib","pytest","findingmodel","findingmodel.finding_info","findingmodel.finding_model","shutil"],"test/test_anatomic_locations.py":["__future__","json","pathlib","typing","unittest.mock","duckdb","httpx","pytest","click.testing","openai","pydantic_ai.models.test","collections.abc","pydantic_ai","findingmodel.anatomic_migration","findingmodel.cli","findingmodel.config","findingmodel.tools.anatomic_location_search","findingmodel.tools.duckdb_search","findingmodel.tools.ontology_search","findingmodel","findingmodel.config"],"test/test_cli.py":["__future__","asyncio","json","pathlib","typing","pytest","click.testing","collections.abc","findingmodel","findingmodel.cli","findingmodel.config","findingmodel.index"],"test/test_config.py":["pytest","_pytest.monkeypatch","pydantic","findingmodel.config","findingmodel.config","findingmodel.config","findingmodel.config","findingmodel.config","findingmodel.config"],"test/test_duckdb_index.py":["__future__","asyncio","json","shutil","pathlib","typing","duckdb","pytest","pytest_asyncio","pydantic","collections.abc","findingmodel","findingmodel.config","findingmodel.contributor","findingmodel.finding_model","findingmodel.index","shutil","findingmodel.index","pydantic","pydantic","time","time","time","findingmodel.common","tempfile","findingmodel.finding_model","asyncio","findingmodel","findingmodel","findingmodel.index","findingmodel.index","findingmodel.index","findingmodel.index","findingmodel.index","findingmodel.index","findingmodel.index"],"test/test_duckdb_utils.py":["__future__","duckdb","pytest","findingmodel.tools.duckdb_utils"],"test/test_embedding_cache.py":["__future__","asyncio","pathlib","typing","pytest","collections.abc","findingmodel.embedding_cache"],"test/test_index_validation.py":["pytest","findingmodel.finding_model","findingmodel.index_validation","asyncio"],"test/test_manifest_integration.py":["__future__","contextlib","pathlib","unittest.mock","pytest","findingmodel.config","findingmodel.index","findingmodel.config"],"test/test_model_editor.py":["collections.abc","pytest","pydantic_ai","pydantic_ai.models.test","findingmodel","findingmodel.finding_model","findingmodel.index","findingmodel.tools","findingmodel.tools.common"],"test/test_models.py":["pathlib","typing","pytest","pydantic","findingmodel.contributor","findingmodel.finding_model"],"test/test_ontology_search.py":["inspect","unittest.mock","pytest","pydantic_ai","pydantic_ai.models.test","findingmodel.config","findingmodel.tools.ontology_concept_match","findingmodel.tools.ontology_search","findingmodel"],"test/test_remote_resource.py":["pathlib","unittest.mock","pytest","findingmodel.config","pooch","findingmodel.config","unittest.mock","findingmodel.config","unittest.mock","findingmodel.config"],"test/test_tools.py":["types","pytest","pydantic_ai","findingmodel.tools","findingmodel.tools.finding_description","findingmodel","findingmodel.config","findingmodel.finding_model","findingmodel.index_code","jinja2","findingmodel.tools.prompt_template","jinja2","findingmodel.tools.prompt_template","findingmodel.finding_info","findingmodel.tools","findingmodel.finding_info","findingmodel.tools","unittest.mock","pydantic_ai.models.test","findingmodel.finding_model","findingmodel.tools","findingmodel.finding_model","findingmodel.tools","findingmodel.tools","findingmodel.tools.similar_finding_models","findingmodel.tools.create_stub","concurrent.futures"],"test/tools/test_evaluators.py":["typing","pydantic","pydantic_ai","pydantic_evals.evaluators","findingmodel.tools.evaluators"]},"dir_purposes":{".serena/memories":"Test files and test utilities","docs":"Project documentation","evals":"Data models and schemas","scripts":"Build and utility scripts","specs/001-ai-based-finding":"Test files and test utilities","src/findingmodel":"Data models and schemas","src/findingmodel/tools":"Data models and schemas","tasks":"Test files and test utilities","tasks/done":"Test files and test utilities","test":"Test files and test utilities","test/data":"Test files and test utilities","test/tools":"Test files and test utilities"},"staleness":1761689232.409133}