Update SPM/mcp_output/mcp_plugin/mcp_service.py

SPM/mcp_output/mcp_plugin/mcp_service.py

@@ -37,13 +37,32 @@ def sequence_pattern_matching(input_sequence: str, target_sequence: str) -> dict
         
         # Call the real volumeScoring function
         result_data = volumeScoring(query_seq_volume, uniprot_info, target_sequence)
-        
+
         # Extract results
-        best_score = result_data[1]  # score
-        best_position = result_data[2]  # position (0-indexed)
-        
-        # Get the matched region
+        best_score = float(result_data[1])  # score
+        best_position = int(result_data[2])  # position (0-indexed)
+
+        # Fallback: if score is the sentinel 9999 or indices invalid, do local sliding-window
         query_len = len(input_sequence)
+        need_fallback = (
+            best_score == 9999.0 or
+            best_position < 0 or
+            best_position + query_len > len(target_sequence)
+        )
+        if need_fallback:
+            db_seq_volume = np.array([volume[i] for i in target_sequence])
+            max_start = len(db_seq_volume) - query_len
+            if max_start < 0:
+                return {"success": False, "result": None, "error": "Query sequence longer than target sequence"}
+            best_score = float("inf")
+            best_position = 0
+            for i in range(max_start + 1):
+                s = float(np.sum(np.abs(db_seq_volume[i:i + query_len] - query_seq_volume)))
+                if s < best_score:
+                    best_score = s
+                    best_position = i
+
+        # Get the matched region
         matched_region = target_sequence[best_position:best_position + query_len]
         
         # Create comprehensive result
@@ -96,12 +115,31 @@ def spm_database_search(query_sequence: str, database_sequences: list) -> dict:
                 
             # Use the real volumeScoring function
             result_data = volumeScoring(query_seq_volume, name, sequence)
-            
+
+            score = float(result_data[1])
+            pos = int(result_data[2])
+
+            # Fallback: handle sentinel 9999 or invalid indices
+            qlen = len(query_sequence)
+            if score == 9999.0 or pos < 0 or pos + qlen > len(sequence):
+                db_seq_volume = np.array([volume[i] for i in sequence])
+                max_start = len(db_seq_volume) - qlen
+                if max_start >= 0:
+                    best_s = float("inf")
+                    best_i = 0
+                    for i in range(max_start + 1):
+                        s = float(np.sum(np.abs(db_seq_volume[i:i + qlen] - query_seq_volume)))
+                        if s < best_s:
+                            best_s = s
+                            best_i = i
+                    score = best_s
+                    pos = best_i
+
             results.append({
                 'name': result_data[0],
-                'score': float(result_data[1]),
-                'position': int(result_data[2]),
-                'matched_region': sequence[result_data[2]:result_data[2] + len(query_sequence)],
+                'score': float(score),
+                'position': int(pos),
+                'matched_region': sequence[pos:pos + len(query_sequence)],
                 'sequence_length': len(sequence)
             })