Merge pull request #20 from mdhishaamakhtar/master

AdityaSareen06 · web-flow · commit a0dea40fb7e0 · 2025-08-21T13:24:09.000+05:30
diff --git a/.coverage b/.coverage
diff --git a/app/api/schemas.py b/app/api/schemas.py
@@ -1,4 +1,4 @@
-from marshmallow import Schema, fields, validate, ValidationError, post_load
+from marshmallow import Schema, fields, validate, post_load
 from app.core.models import SearchRequest, ExploreRequest
 
 
diff --git a/app/core/pathfinding.py b/app/core/pathfinding.py
@@ -1,5 +1,5 @@
 import uuid
-from typing import List, Set, Dict, Optional, Any
+from typing import List, Dict, Optional, Any
 from app.core.interfaces import (
     PathFinderInterface,
     WikipediaClientInterface,
@@ -9,7 +9,6 @@
 from app.utils.exceptions import (
     PathNotFoundError,
     InvalidPageError,
-    WikipediaPageNotFoundError,
 )
 from app.utils.logging import get_logger
 
diff --git a/app/core/services.py b/app/core/services.py
@@ -13,9 +13,8 @@
     WikipediaPage,
 )
 from app.utils.exceptions import (
-    PathNotFoundError,
     InvalidPageError,
-    WikipediaPageNotFoundError,
+    DisambiguationPageError,
 )
 from app.utils.logging import get_logger
 import networkx as nx
@@ -99,16 +98,52 @@ def find_path(self, request: SearchRequest) -> PathResult:
             )
             raise
 
-    def validate_pages(self, start_page: str, end_page: str) -> tuple[bool, bool]:
+    def validate_pages(self, start_page: str, end_page: str) -> tuple[bool, bool, dict]:
         """
-        Validate that both pages exist on Wikipedia.
+        Validate that both pages exist on Wikipedia and check for disambiguation pages.
+
+        Args:
+            start_page: Starting page title
+            end_page: Target page title
 
         Returns:
-            Tuple of (start_exists, end_exists)
+            Tuple of (start_exists, end_exists, validation_details)
+
+        Raises:
+            DisambiguationPageError: When end page is a disambiguation page
         """
-        start_exists = self.wikipedia_client.page_exists(start_page)
-        end_exists = self.wikipedia_client.page_exists(end_page)
-        return start_exists, end_exists
+        # Get detailed info for both pages
+        start_info = self.wikipedia_client.get_page_with_redirect_info(start_page)
+        end_info = self.wikipedia_client.get_page_with_redirect_info(end_page)
+
+        start_exists = start_info.get("exists", False)
+        end_exists = end_info.get("exists", False)
+
+        validation_details = {
+            "start_page": {
+                "original": start_page,
+                "final_title": start_info.get("final_title", start_page),
+                "was_redirected": start_info.get("was_redirected", False),
+                "is_disambiguation": start_info.get("is_disambiguation", False),
+                "exists": start_exists,
+            },
+            "end_page": {
+                "original": end_page,
+                "final_title": end_info.get("final_title", end_page),
+                "was_redirected": end_info.get("was_redirected", False),
+                "is_disambiguation": end_info.get("is_disambiguation", False),
+                "exists": end_exists,
+            },
+        }
+
+        # Check if end page is disambiguation - this should fail
+        if end_exists and end_info.get("is_disambiguation", False):
+            final_title = end_info.get("final_title", end_page)
+            raise DisambiguationPageError(end_page, final_title)
+
+        # Note: We allow start page to be disambiguation as it might have useful links
+
+        return start_exists, end_exists, validation_details
 
 
 class ExploreService:
diff --git a/app/external/wikipedia.py b/app/external/wikipedia.py
@@ -2,7 +2,7 @@
 from concurrent.futures import ThreadPoolExecutor
 from typing import Dict, List, Optional
 from app.core.interfaces import WikipediaClientInterface, CacheServiceInterface
-from app.utils.exceptions import WikipediaAPIError, WikipediaPageNotFoundError
+from app.utils.exceptions import WikipediaAPIError
 from app.utils.logging import get_logger
 
 logger = get_logger(__name__)
@@ -197,6 +197,81 @@ def page_exists(self, page_title: str) -> bool:
             logger.error(f"Failed to check page existence for {page_title}: {e}")
             return False
 
+    def get_page_with_redirect_info(self, page_title: str) -> Optional[dict]:
+        """
+        Get page information including redirect details.
+
+        Args:
+            page_title: Wikipedia page title
+
+        Returns:
+            Dict with 'exists', 'final_title', 'was_redirected', 'is_disambiguation'
+        """
+        params = {
+            "action": "query",
+            "format": "json",
+            "titles": page_title,
+            "prop": "info|categories",
+            "redirects": 1,
+        }
+
+        try:
+            response = self.session.get(self.base_url, params=params, timeout=10)
+            response.raise_for_status()
+            data = response.json().get("query", {})
+
+            # Check for redirects
+            redirects = data.get("redirects", [])
+            was_redirected = len(redirects) > 0
+            final_title = page_title
+
+            if was_redirected:
+                # Find the final redirect target
+                for redirect in redirects:
+                    if redirect.get("from") == page_title:
+                        final_title = redirect.get("to", page_title)
+                        break
+
+            # Check if page exists
+            pages = data.get("pages", {})
+            page_exists = False
+            is_disambiguation = False
+
+            for page_data in pages.values():
+                if "missing" not in page_data:
+                    page_exists = True
+                    current_title = page_data.get("title", "")
+
+                    # Check if it's a disambiguation page
+                    if "(disambiguation)" in current_title.lower():
+                        is_disambiguation = True
+                    else:
+                        # Check categories for disambiguation
+                        categories = page_data.get("categories", [])
+                        for category in categories:
+                            cat_title = category.get("title", "").lower()
+                            if "disambiguation" in cat_title:
+                                is_disambiguation = True
+                                break
+
+            return {
+                "exists": page_exists,
+                "final_title": final_title,
+                "was_redirected": was_redirected,
+                "is_disambiguation": is_disambiguation,
+                "original_title": page_title,
+            }
+
+        except requests.RequestException as e:
+            logger.error(f"Failed to get page redirect info for {page_title}: {e}")
+            return {
+                "exists": False,
+                "final_title": page_title,
+                "was_redirected": False,
+                "is_disambiguation": False,
+                "original_title": page_title,
+            }
+
     def get_page_info(self, page_title: str) -> Optional[dict]:
         """
         Get basic information about a Wikipedia page.
diff --git a/app/infrastructure/tasks.py b/app/infrastructure/tasks.py
@@ -7,6 +7,7 @@
     InvalidPageError,
     WikipediaAPIError,
     CacheConnectionError,
+    DisambiguationPageError,
 )
 from app.utils.logging import get_logger
 
@@ -88,10 +89,20 @@ def progress_update(progress_data):
         # Get pathfinding service with progress callback
         pathfinding_service = get_pathfinding_service(algorithm, progress_update)
 
-        # Validate that pages exist
-        start_exists, end_exists = pathfinding_service.validate_pages(
-            start_page, end_page
-        )
+        # Validate that pages exist and check for disambiguation issues
+        try:
+            start_exists, end_exists, validation_details = (
+                pathfinding_service.validate_pages(start_page, end_page)
+            )
+        except DisambiguationPageError as e:
+            logger.error(f"Task {task_id}: Disambiguation page error - {e}")
+            return {
+                "status": "FAILURE",
+                "error": str(e),
+                "code": "DISAMBIGUATION_PAGE",
+                "start_page": start_page,
+                "end_page": end_page,
+            }
 
         if not start_exists:
             logger.error(f"Task {task_id}: Start page '{start_page}' does not exist")
@@ -175,6 +186,16 @@ def progress_update(progress_data):
             "end_page": end_page,
         }
 
+    except DisambiguationPageError as e:
+        logger.error(f"Task {task_id}: Disambiguation page error - {e}")
+        return {
+            "status": "FAILURE",
+            "error": str(e),
+            "code": "DISAMBIGUATION_PAGE",
+            "start_page": start_page,
+            "end_page": end_page,
+        }
+
     except (requests.RequestException, CacheConnectionError, WikipediaAPIError) as e:
         # These exceptions trigger auto-retry
         logger.warning(f"Task {task_id}: Retryable error - {e}")
diff --git a/app/utils/exceptions.py b/app/utils/exceptions.py
@@ -78,6 +78,22 @@ def __init__(self, message: str = None, page_title: str = None):
         self.code = "INVALID_PAGE"
 
 
+class DisambiguationPageError(PathFindingError):
+    """Raised when a disambiguation page is used as a target."""
+
+    def __init__(self, page_title: str, resolved_title: str = None):
+        self.page_title = page_title
+        self.resolved_title = resolved_title
+
+        if resolved_title and resolved_title != page_title:
+            message = f"'{page_title}' redirects to disambiguation page '{resolved_title}'. Please specify a more specific page."
+        else:
+            message = f"'{page_title}' is a disambiguation page. Please specify a more specific page."
+
+        super().__init__(message, page_title, resolved_title)
+        self.code = "DISAMBIGUATION_PAGE"
+
+
 class CacheError(IrisBaseException):
     """Base exception for cache-related errors."""
 
diff --git a/static/script.js b/static/script.js
@@ -412,7 +412,17 @@ class PathFinderUI {
         this.hideLoading();
 
         if (!result.path || result.path.length === 0) {
-            // Hide the visualization section and show error
+            // Check if this is actually a nested error response
+            if (result.status === 'FAILURE' && result.error) {
+                // Show the specific error message from the nested result
+                const section = document.getElementById('visualizationSection');
+                section.classList.remove('show');
+                this.showError(result.error);
+                StateManager.clear();
+                return;
+            }
+            
+            // Fallback to generic message for actual empty paths
             const section = document.getElementById('visualizationSection');
             section.classList.remove('show');
             this.showError('No path found between the pages');
diff --git a/tests/integration/test_services.py b/tests/integration/test_services.py
@@ -104,9 +104,26 @@ def test_find_path_not_found(self, mock_wikipedia_client, mock_cache_service):
 
     def test_validate_pages(self, mock_wikipedia_client, mock_cache_service):
         """Test page validation."""
+
         # Mock Wikipedia client responses
-        mock_wikipedia_client.page_exists.side_effect = (
-            lambda page: page != "NonExistent"
+        def mock_get_page_info(page):
+            if page == "NonExistent":
+                return {
+                    "exists": False,
+                    "final_title": page,
+                    "was_redirected": False,
+                    "is_disambiguation": False,
+                }
+            else:
+                return {
+                    "exists": True,
+                    "final_title": page,
+                    "was_redirected": False,
+                    "is_disambiguation": False,
+                }
+
+        mock_wikipedia_client.get_page_with_redirect_info.side_effect = (
+            mock_get_page_info
         )
 
         mock_path_finder = Mock()
@@ -115,14 +132,22 @@ def test_validate_pages(self, mock_wikipedia_client, mock_cache_service):
         )
 
         # Test both pages exist
-        start_exists, end_exists = service.validate_pages("Page A", "Page B")
+        start_exists, end_exists, validation_details = service.validate_pages(
+            "Page A", "Page B"
+        )
         assert start_exists is True
         assert end_exists is True
+        assert validation_details["start_page"]["exists"] is True
+        assert validation_details["end_page"]["exists"] is True
 
         # Test one page doesn't exist
-        start_exists, end_exists = service.validate_pages("Page A", "NonExistent")
+        start_exists, end_exists, validation_details = service.validate_pages(
+            "Page A", "NonExistent"
+        )
         assert start_exists is True
         assert end_exists is False
+        assert validation_details["start_page"]["exists"] is True
+        assert validation_details["end_page"]["exists"] is False
 
 
 class TestExploreService:
diff --git a/tests/unit/test_external_wikipedia_client.py b/tests/unit/test_external_wikipedia_client.py
@@ -121,4 +121,3 @@ def fake_process(batch):
     assert (len(calls) == 2) and (set(calls[0]) <= set(titles))
     # merged keys exist from both batches
     assert any(k in res for k in ("P0", "P49", "P50", "P74"))
-
diff --git a/tests/unit/test_factory_and_tasks_config.py b/tests/unit/test_factory_and_tasks_config.py
@@ -73,4 +73,3 @@ def __init__(self):
     configure_periodic_tasks(app)
     assert isinstance(app.conf.beat_schedule, dict)
     assert app.conf.timezone == "UTC"
-
diff --git a/tests/unit/test_middleware_and_logging.py b/tests/unit/test_middleware_and_logging.py
@@ -180,5 +180,7 @@ def test_configure_logging_writes_file_handler(tmp_path):
     configure_logging(app)
 
     # File handler should be added when not debug/testing
-    has_file_handler = any(h.__class__.__name__ == "RotatingFileHandler" for h in app.logger.handlers)
+    has_file_handler = any(
+        h.__class__.__name__ == "RotatingFileHandler" for h in app.logger.handlers
+    )
     assert has_file_handler is True

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-from marshmallow import Schema, fields, validate, ValidationError, post_load`
	`1`	`+from marshmallow import Schema, fields, validate, post_load`
`2`	`2`	`from app.core.models import SearchRequest, ExploreRequest`
`3`	`3`
`4`	`4`