working with basic boolean query

test_two_phase_search.py

@@ -1,74 +1,140 @@
-from typing import List, Dict, Optional
-from opensearch_client import OpenSearchClient
+from test_embeddings import create_test_data, transform_jobseeker_to_opensearch, IndependentJobSeekerAssessmentRDS
 from chroma_storage import ChromaMatchingSystem
-from embeddings import JobPosting
+from opensearch_client import OpenSearchClient
+from two_phase_search import TwoPhaseSearchSystem
+import json
 
-class TwoPhaseSearchSystem:
-    def __init__(self, chroma_matcher: ChromaMatchingSystem, opensearch_client: OpenSearchClient):
-        self.chroma_matcher = chroma_matcher
-        self.opensearch_client = opensearch_client
+def test_single_jobseeker(opensearch_client):
+    """Test OpenSearch with one jobseeker"""
+    print("\nTesting OpenSearch with a single jobseeker...")
 
-    def search_candidates(self, 
-                        job_posting: JobPosting,
-                        search_params: Dict,
-                        n_results: int = 10) -> List[Dict]:
-        """
-        Two-phase search:
-        1. OpenSearch boolean filtering
-        2. ChromaDB embedding matching
-        """
-        # Phase 1: OpenSearch Filtering
-        opensearch_results = self.opensearch_client.search_jobseekers(search_params)
+    # Create one test jobseeker
+    test_jobseeker = IndependentJobSeekerAssessmentRDS(
+        primary_skills=["Python", "AWS"],
+        secondary_skills=["Docker", "CI/CD"],
+        experiences=[{
+            "title": "Software Engineer",
+            "company": "Tech Co.",
+            "duration": "3 years",
+            "description": "Developed scalable software systems and optimized cloud infrastructure."
+        }],
+        educations=[{
+            "degree": "Bachelor's",
+            "field": "Computer Science",
+            "institution": "Tech University"
+        }],
+        certifications=[{
+            "name": "AWS Solutions Architect",
+            "organization": "AWS",
+            "start_date": "2022-01",
+            "end_date": "2025-01"
+        }]
+    )
 
-        if not opensearch_results:
-            return []
+    # Transform and index into OpenSearch
+    jobseeker_id = "test_seeker_1"
+    payload = transform_jobseeker_to_opensearch(test_jobseeker, jobseeker_id)
+    response = opensearch_client.index_jobseeker(payload)
 
-        # Phase 2: ChromaDB Embedding Matching
-        # Get matches only for jobseekers that passed OpenSearch filtering
-        matches = self.chroma_matcher.get_matches(
-            job_posting=job_posting,
-            n_results=n_results,
-            where_conditions={"jobseeker_id": {"$in": [r['jobseeker_id'] for r in opensearch_results]}}
-        )
+    if response:
+        print(f"Successfully indexed jobseeker {jobseeker_id}: {response}")
+    else:
+        print(f"Failed to index jobseeker {jobseeker_id}")
 
-        # Combine OpenSearch scores with ChromaDB match results
-        final_results = []
-        for match in matches:
-            # Find corresponding OpenSearch result
-            opensearch_result = next(
-                (r for r in opensearch_results if r['jobseeker_id'] == match.jobseeker_id), 
-                None
-            )
-            if opensearch_result:
-                final_results.append({
-                    'jobseeker_id': match.jobseeker_id,
-                    'similarity_score': match.similarity_score,
-                    'field_scores': match.field_scores,
-                    'explanation': match.explanation,
-                    'opensearch_score': opensearch_result.get('_score', 0.0)
-                })
+def test_two_phase_search():
+    """Test the complete two-phase search pipeline"""
+    print("\nTesting two-phase search system...")
+    
+    # Initialize components
+    chroma_matcher = ChromaMatchingSystem()
+    opensearch_client = OpenSearchClient()
+    search_system = TwoPhaseSearchSystem(chroma_matcher, opensearch_client)
 
-        return final_results
+    # Check if OpenSearch database has any data
+    print("\nChecking if OpenSearch database has any data...")
+    test_payload = {
+        "boolean_search_query": "Software AND (Python OR AWS)",  # Simple boolean query
+        "skills": [],                # No skill requirements
+        "size": 100,                 # Retrieve up to 100 entries
+        "sort_by": ["score"]
+    }
+    opensearch_results = opensearch_client.search_jobseekers(test_payload)
+    if opensearch_results:
+        print(f"OpenSearch returned {len(opensearch_results)} entries.")
+    else:
+        print("OpenSearch database is empty or the query returned no results.")
 
-    def build_search_params(self,
-                          job_posting: JobPosting,
-                          location: Optional[Dict] = None,
-                          certifications: Optional[Dict] = None,
-                          tags: Optional[List[Dict]] = None) -> Dict:
-        """Build OpenSearch query parameters matching working format"""
-        # Extract skills from job posting
-        primary_skills = [skill.skill_name for skill in job_posting.primary_skills][:2]  # Just first two skills
-        
-        # Build boolean query like the working example
-        skills_part = ' OR '.join(primary_skills)
-        boolean_query = f"Software AND ({skills_part})"
+    # Get test data
+    (job_posting, matching_seeker, matching_info,
+     partial_matching_seeker, partial_matching_info,
+     non_matching_seeker, non_matching_info) = create_test_data()
+    
+    print("\nAdding test seekers to ChromaDB...")
+    # Add test seekers to ChromaDB
+    test_seekers = [
+        ("seeker_1", matching_seeker, matching_info, 
+         {"experience_level": "senior"}),
+        ("seeker_2", partial_matching_seeker, partial_matching_info,
+         {"experience_level": "mid"}),
+        ("seeker_3", non_matching_seeker, non_matching_info,
+         {"experience_level": "mid"})
+    ]
+    
+    for seeker_id, processed, unprocessed, metadata in test_seekers:
+        print(f"Adding job seeker: {seeker_id}")
+        chroma_matcher.add_job_seeker(seeker_id, processed, unprocessed, metadata)
+    
+    # Build search parameters using updated method
+    search_params = search_system.build_search_params(
+        job_posting=job_posting,
+        location={
+            "state": "CA",
+            "country": "US"
+        },
+        certifications={
+            "name": "AWS Solutions Architect",
+            "organization": "AWS"
+        },
+        tags=[
+            {
+                "tag_key": "seniority",
+                "tag_value": "senior"
+            }
+        ]
+    )
+    
+    print("\nConstructed Search Parameters:")
+    print("=" * 60)
+    print(json.dumps(search_params, indent=2))
+    
+    # Perform search
+    print("\nPerforming search...")
+    results = search_system.search_candidates(
+        job_posting=job_posting,
+        search_params=search_params,
+        n_results=10
+    )
+    
+    # Print results
+    print("\nSearch Results:")
+    print("=" * 60)
+    
+    if not results:
+        print("No matches found")
+        print("\nDebug: Checking OpenSearch response...")
+        opensearch_results = opensearch_client.search_jobseekers(search_params)
+        print(f"OpenSearch returned {len(opensearch_results)} results")
+        return
         
-        # Use exactly what worked
-        params = {
-            "boolean_search_query": boolean_query,
-            "skills": [],
-            "size": 100,
-            "sort_by": ["score"]
-        }
+    for i, result in enumerate(results, 1):
+        print(f"\nMatch {i}:")
+        print(f"Jobseeker ID: {result['jobseeker_id']}")
+        print(f"ChromaDB Score: {result['similarity_score']:.3f}")
+        print(f"OpenSearch Score: {result['opensearch_score']:.3f}")
+        print("\nField Scores:")
+        for field, score in result['field_scores'].items():
+            print(f"  {field}: {score:.3f}")
+        print(f"\nExplanation: {result['explanation']}")
 
-        return params
+if __name__ == "__main__":
+    test_two_phase_search()