Merge pull request #33 from adelavega/enh/read_elsevier

ENH: Enable reading in elsevier like inputs

Author: adelavega

autonima/config.py

@@ -150,11 +150,7 @@ def _validate_config(self, config: PipelineConfig) -> None:
             ConfigurationError: If configuration is invalid
         """
         # Validate search configuration
-        if config.search.pmids_file or config.search.pmids_list:
-            # PMID-based search
-            if config.search.query.strip():
-                raise ConfigurationError("Cannot specify both search query and PMIDs list/file")
-        else:
+        if not (config.search.pmids_file or config.search.pmids_list):
             # Query-based search
             if not config.search.query.strip():
                 raise ConfigurationError("Search query cannot be empty when not using PMIDs list/file")
@@ -205,6 +201,13 @@ def _validate_config(self, config: PipelineConfig) -> None:
         # Validate output directory
         if not config.output.directory.strip():
             raise ConfigurationError("Output directory cannot be empty")
+        
+        # config.retrieval.coordinates_path_templates is mutually exclusive with processed_data_path for each source
+        for source in config.retrieval.sources:
+            if source.coordinates_path_templates and source.processed_data_path:
+                raise ConfigurationError(
+                    "coordinates_path_templates and processed_data_path are mutually exclusive for each source"
+                )
 
     def get_config(self) -> PipelineConfig:
         """Get the currently loaded configuration."""

autonima/coordinates/processor.py

@@ -1,8 +1,6 @@
 """Coordinate parsing processor for the pipeline."""
 
 import logging
-import csv
-from pathlib import Path
 from typing import List
 
 from .openai_client import CoordinateParsingClient
@@ -37,25 +35,16 @@ def process_single_table(self, table):
             List of analyses extracted from the table
         """
         try:
-            # Load the table data
-            for path_attr in self.path_preference:
-                table_path_value = getattr(table, path_attr, None)
-                if table_path_value:
-                    table_path = Path(table_path_value)
-                    break
-            else:
+            # Load the raw table content using the table's method
+            table.load_raw_table()
+            
+            # If we couldn't load the raw table content, return empty list
+            if table.raw_table is None:
                 logger.warning(f"No valid table path found for table: {table.table_id}")
                 return []
-            table_path = Path(table_path)
-            if not table_path.exists():
-                logger.warning(f"Table file not found: {table_path}")
-                return []
 
-            # Read the table as text
-            with open(table_path, "r", encoding="utf-8") as f:
-                reader = csv.reader(f)
-                rows = list(reader)
-                table_text = "\n".join([",".join(r) for r in rows])
+            # Use the raw_table content directly
+            table_text = table.raw_table
 
             # Create a prompt for the table
             prompt = self._create_table_prompt(
@@ -69,7 +58,7 @@ def process_single_table(self, table):
             return result.analyses
 
         except Exception as e:
-            logger.warning(f"Error processing table {table.table_path}: {e}")
+            logger.warning(f"Error processing table {table.table_id}: {e}")
             return []
 
     def _create_table_prompt(self, table_text: str, table_caption: str = "", table_foot: str = "") -> str:

autonima/models/types.py

@@ -1,5 +1,6 @@
 """Type definitions and data models for Autonima."""
 
+import logging
 from dataclasses import dataclass, field
 from typing import List, Dict, Any, Optional
 from enum import Enum
@@ -28,6 +29,39 @@ class ActivationTable:
     table_foot: Optional[str] = None  # Footer of the table
     table_data_path: Optional[str] = None  # Path to processed table data file
     table_raw_path: Optional[str] = None  # Path to raw table data file
+    raw_table: Optional[str] = None  # Raw table XML content
+    
+    def load_raw_table(self) -> None:
+        """
+        Load the raw table content from the preferred path.
+        
+        This method populates the raw_table attribute with the content
+        of the raw table file. If the raw_table attribute is already
+        populated, it doesn't need to do anything. It keeps the
+        preference hierarchy for which path to use for populating it.
+        """
+        # If raw_table is already populated, no need to do anything
+        if self.raw_table is not None:
+            return
+        
+        # Define the path preference hierarchy
+        path_preference = ['table_raw_path', 'table_data_path']
+        
+        # Try to load the raw table content from the preferred paths
+        for path_attr in path_preference:
+            table_path_value = getattr(self, path_attr, None)
+            if table_path_value:
+                try:
+                    with open(table_path_value, 'r', encoding='utf-8') as f:
+                        self.raw_table = f.read()
+                    return
+                except Exception as e:
+                    logging.warning(
+                        f"Failed to load raw table from {table_path_value}: {e}"
+                    )
+                    continue
+        
+        logging.warning(f"No valid table path found for table: {self.table_id}")
 
 
 @dataclass