update config model usage

Author: kazmer97

lib/idp_common_pkg/idp_common/assessment/__init__.py

@@ -7,9 +7,8 @@
 This module provides services for assessing the confidence and accuracy of
 extraction results by analyzing them against source documents using LLMs.
 
-The module supports both:
-1. Original approach: Single inference for all attributes in a section
-2. Granular approach: Multiple focused inferences with caching and parallelization
+All assessment now uses the granular approach with Strands agents for
+multiple focused inferences with caching and parallelization.
 """
 
 import logging
@@ -19,33 +18,32 @@
 
 from .granular_service import GranularAssessmentService
 from .models import AssessmentResult, AttributeAssessment
-from .service import AssessmentService as OriginalAssessmentService
 
 logger = logging.getLogger(__name__)
 
 
 class AssessmentService:
     """
-    Backward-compatible AssessmentService that automatically selects the appropriate implementation.
+    Assessment service for evaluating document extraction confidence.
 
-    This class maintains the same interface as the original AssessmentService but automatically
-    chooses between the original and granular implementations based on configuration.
+    This class uses the granular Strands-based assessment approach for all assessments.
+    It provides backward compatibility by maintaining the same interface.
     """
 
     def __init__(self, region: str | None = None, config: IDPConfig | None = None):
         """
-        Initialize the assessment service with automatic implementation selection.
+        Initialize the assessment service.
 
         Args:
             region: AWS region for Bedrock
-            config: Configuration dictionary
+            config: Configuration dictionary or IDPConfig model
         """
         if config is None:
             config = IDPConfig()
         elif isinstance(config, dict):
             config = IDPConfig(**config)
 
-        self._service = create_assessment_service(region=region, config=config)
+        self._service = GranularAssessmentService(region=region, config=config)
 
     def process_document_section(self, document, section_id: str):
         """Process a single section from a Document object to assess extraction confidence."""
@@ -60,40 +58,25 @@ def create_assessment_service(
     region: Optional[str] = None, config: Optional[IDPConfig] = None
 ):
     """
-    Factory function to create the appropriate assessment service based on configuration.
+    Factory function to create the assessment service.
 
     Args:
         region: AWS region for Bedrock
-        config: Configuration dictionary
+        config: Configuration dictionary or IDPConfig model
 
     Returns:
-        OriginalAssessmentService or GranularAssessmentService based on configuration
+        GranularAssessmentService instance
     """
     if not config:
         config = IDPConfig()
-        logger.info("No config provided, using original AssessmentService")
-        return OriginalAssessmentService(region=region, config=config)
 
-    # Check if granular assessment is enabled (default: False for backward compatibility)
-
-    # Normalize the enabled value to handle both boolean and string values
-
-    logger.info(
-        f"Granular assessment enabled check: raw_value={config.assessment.granular.enabled} (type: {type(config.assessment.granular.enabled)})"
-    )
-
-    if config.assessment.granular.enabled:
-        logger.info("Granular assessment enabled, using GranularAssessmentService")
-        return GranularAssessmentService(region=region, config=config)
-    else:
-        logger.info("Using original AssessmentService")
-        return OriginalAssessmentService(region=region, config=config)
+    logger.info("Creating GranularAssessmentService (Strands-based assessment)")
+    return GranularAssessmentService(region=region, config=config)
 
 
 __all__ = [
     "AssessmentService",
     "GranularAssessmentService",
-    "OriginalAssessmentService",
     "AssessmentResult",
     "AttributeAssessment",
     "create_assessment_service",

lib/idp_common_pkg/tests/unit/config/test_config_models.py

@@ -142,23 +142,18 @@ def process_config(config: ExtractionConfig) -> bool:
         result = process_config(config)
         assert result is True
 
-    def test_assessment_granular_config(self):
-        """Test granular assessment configuration"""
+    def test_assessment_config(self):
+        """Test assessment configuration with new flat structure"""
         config_dict = {
             "model": "us.amazon.nova-lite-v1:0",
-            "granular": {
-                "enabled": True,
-                "list_batch_size": "5",
-                "simple_batch_size": "10",
-                "max_workers": "20",
-            },
+            "enabled": True,
+            "max_workers": "20",
         }
         config = AssessmentConfig.model_validate(config_dict)
 
-        assert config.granular.enabled is True
-        assert config.granular.list_batch_size == 5
-        assert config.granular.simple_batch_size == 10
-        assert config.granular.max_workers == 20
+        assert config.enabled is True
+        assert config.max_workers == 20
+        assert isinstance(config.max_workers, int)
 
     def test_config_validation_range_checks(self):
         """Test that validation enforces ranges"""

lib/idp_common_pkg/tests/unit/config/test_config_models_integration.py

@@ -217,12 +217,10 @@ def test_criteria_validation_config(self, config_root):
         assert config.assessment is not None
         assert isinstance(config.assessment.enabled, bool)
 
-        # Validate granular assessment settings
-        if hasattr(config.assessment, "granular"):
-            assert isinstance(config.assessment.granular.enabled, bool)
-            if config.assessment.granular.enabled:
-                assert config.assessment.granular.list_batch_size > 0
-                assert config.assessment.granular.simple_batch_size > 0
+        # Validate assessment settings
+        assert isinstance(config.assessment.enabled, bool)
+        if config.assessment.enabled:
+            assert config.assessment.max_workers > 0
 
     def test_config_with_all_optional_fields(self, config_root):
         """Test that configs work even if optional fields are missing"""
@@ -284,8 +282,8 @@ def test_config_type_coercion(self):
         assert config.extraction.top_p == 0.2
         assert isinstance(config.extraction.top_p, float)
 
-        assert config.assessment.granular.list_batch_size == 5
-        assert isinstance(config.assessment.granular.list_batch_size, int)
+        assert config.assessment.max_workers == 20
+        assert isinstance(config.assessment.max_workers, int)
 
     def test_boolean_variations(self):
         """Test various boolean representations"""

patterns/pattern-2/src/assessment_function/index.py

@@ -151,13 +151,9 @@ def handler(event, context):
     if not section:
         raise ValueError(f"Section {section_id} not found in document")
 
-    # Check if granular assessment is enabled (moved earlier for Lambda metering context)
-    assessment_context = (
-        "GranularAssessment" if config.assessment.granular.enabled else "Assessment"
-    )
-    logger.info(
-        f"Assessment mode: {'Granular' if config.assessment.granular.enabled else 'Regular'} (context: {assessment_context})"
-    )
+    # Assessment context for Lambda metering
+    assessment_context = "Assessment"
+    logger.info(f"Assessment mode: Strands-based (context: {assessment_context})")
 
     # Intelligent Assessment Skip: Check if extraction results already contain explainability_info
     if section.extraction_result_uri and section.extraction_result_uri.strip():
@@ -254,15 +250,13 @@ def handler(event, context):
     # Initialize assessment service with cache table for enhanced retry handling
     cache_table = os.environ.get("TRACKING_TABLE")
 
-    # Check if granular assessment is enabled
-
-    # Use granular assessment service (always enabled)
+    # Use Strands-based granular assessment service (always enabled)
     from idp_common.assessment.granular_service import GranularAssessmentService
 
     assessment_service = GranularAssessmentService(
         config=config, cache_table=cache_table
     )
-    logger.info("Using granular assessment service")
+    logger.info("Using Strands-based assessment service")
 
     # Process the document section for assessment
     t0 = time.time()
@@ -333,11 +327,11 @@ def handler(event, context):
 
     # Assessment validation
     validation_enabled = (
-        config.assessment.granular.enabled and config.assessment.validation_enabled
+        config.assessment.enabled and config.assessment.validation_enabled
     )
-    logger.info(f"Assessment Enabled:{config.assessment.granular.enabled}")
-    logger.info(f"Validation Enabled:{validation_enabled}")
-    if not config.assessment.granular.enabled:
+    logger.info(f"Assessment Enabled: {config.assessment.enabled}")
+    logger.info(f"Validation Enabled: {validation_enabled}")
+    if not config.assessment.enabled:
         logger.info("Assessment is disabled.")
     elif not validation_enabled:
         logger.info("Assessment validation is disabled.")

patterns/pattern-3/src/assessment_function/index.py

@@ -63,13 +63,9 @@ def handler(event, context):
     if not section:
         raise ValueError(f"Section {section_id} not found in document")
 
-    # Check if granular assessment is enabled (for Lambda metering context)
-    granular_config = config.assessment.granular
-    granular_enabled = granular_config.enabled
-    assessment_context = "GranularAssessment" if granular_enabled else "Assessment"
-    logger.info(
-        f"Assessment mode: {'Granular' if granular_enabled else 'Regular'} (context: {assessment_context})"
-    )
+    # Assessment context for Lambda metering
+    assessment_context = "Assessment"
+    logger.info(f"Assessment mode: Strands-based (context: {assessment_context})")
 
     # Intelligent Assessment Skip: Check if extraction results already contain explainability_info
     if section.extraction_result_uri and section.extraction_result_uri.strip():