Page Navigation

class WikipediaPage:
    @property
    def links(self) -> dict[str, WikipediaPage]:
        """
        Get all internal links from this page to other Wikipedia pages.
        
        Returns:
        Dictionary mapping page titles to WikipediaPage objects.
        Keys are page titles, values are WikipediaPage instances.
        """

import wikipediaapi

wiki = wikipediaapi.Wikipedia('MyApp/1.0', 'en')
page = wiki.page('Artificial_intelligence')

# Get all internal links
links = page.links
print(f"Page has {len(links)} internal links")

# Browse some links
for i, (title, linked_page) in enumerate(links.items()):
    if i >= 5:  # Show first 5 links
        break
    print(f"Link: {title}")
    print(f"  Language: {linked_page.language}")
    print(f"  Namespace: {linked_page.namespace}")

# Access specific linked page
if 'Machine learning' in links:
    ml_page = links['Machine learning']
    print(f"Found link to: {ml_page.title}")
    if ml_page.exists():
        print(f"Summary: {ml_page.summary[:100]}...")

# Navigate through links
python_page = wiki.page('Python_(programming_language)')
for link_title, link_page in python_page.links.items():
    if 'artificial' in link_title.lower():
        print(f"AI-related link: {link_title}")
        # Could continue navigating from link_page.links

class WikipediaPage:
    @property
    def backlinks(self) -> dict[str, WikipediaPage]:
        """
        Get pages that link to this page.
        
        Returns:
        Dictionary mapping page titles to WikipediaPage objects.
        Keys are titles of pages that link here, values are WikipediaPage instances.
        """

page = wiki.page('Neural_network')

# Get pages that link to this page
backlinks = page.backlinks
print(f"Page has {len(backlinks)} backlinks")

# Explore pages that reference this topic
for title, referring_page in backlinks.items():
    print(f"Referenced by: {title}")
    if referring_page.namespace == wikipediaapi.Namespace.MAIN:
        print(f"  Main article: {title}")
    elif referring_page.namespace == wikipediaapi.Namespace.CATEGORY:
        print(f"  Category: {title}")

# Find related research areas
ml_page = wiki.page('Machine_learning')
backlinks = ml_page.backlinks

# Look for academic or research-related pages
research_pages = []
for title, page in backlinks.items():
    if any(keyword in title.lower() for keyword in ['research', 'university', 'algorithm']):
        research_pages.append(title)

print(f"Found {len(research_pages)} research-related backlinks")
for title in research_pages[:10]:  # Show first 10
    print(f"  - {title}")

class WikipediaPage:
    @property
    def langlinks(self) -> dict[str, WikipediaPage]:
        """
        Get language versions of this page.
        
        Returns:
        Dictionary mapping language codes to WikipediaPage objects.
        Keys are language codes (e.g., 'es', 'fr', 'de'), 
        values are WikipediaPage instances for those languages.
        """

page = wiki.page('Climate_change')

# Get all language versions
lang_versions = page.langlinks
print(f"Page available in {len(lang_versions)} languages")

# Browse available languages
for lang_code, lang_page in lang_versions.items():
    print(f"{lang_code}: {lang_page.title}")

# Access specific language versions
if 'es' in lang_versions:
    spanish_page = lang_versions['es']
    print(f"Spanish title: {spanish_page.title}")
    print(f"Spanish URL: {spanish_page.fullurl}")
    print(f"Spanish summary: {spanish_page.summary[:100]}...")

if 'fr' in lang_versions:
    french_page = lang_versions['fr']
    print(f"French title: {french_page.title}")

# Work with multiple languages
page_en = wiki.page('Quantum_computing')
if page_en.exists():
    langs = page_en.langlinks
    
    # Create Wikipedia instances for other languages
    wiki_de = wikipediaapi.Wikipedia('MyApp/1.0', 'de')
    wiki_ja = wikipediaapi.Wikipedia('MyApp/1.0', 'ja')
    
    if 'de' in langs:
        german_title = langs['de'].title
        german_page_direct = wiki_de.page(german_title)
        print(f"German page: {german_page_direct.title}")
    
    if 'ja' in langs:
        japanese_title = langs['ja'].title  
        japanese_page_direct = wiki_ja.page(japanese_title)
        print(f"Japanese page: {japanese_page_direct.title}")

def compare_languages(topic, languages):
    """Compare a topic across multiple languages."""
    results = {}
    
    for lang in languages:
        wiki_lang = wikipediaapi.Wikipedia('MyApp/1.0', lang)
        
        # Try to find the page in this language
        page = wiki_lang.page(topic)
        if page.exists():
            results[lang] = {
                'title': page.title,
                'summary_length': len(page.summary),
                'sections': len(page.sections),
                'url': page.fullurl
            }
        else:
            # Try to find via English page's language links
            wiki_en = wikipediaapi.Wikipedia('MyApp/1.0', 'en')
            en_page = wiki_en.page(topic)
            if en_page.exists() and lang in en_page.langlinks:
                lang_page = en_page.langlinks[lang]
                results[lang] = {
                    'title': lang_page.title,
                    'summary_length': len(lang_page.summary),
                    'sections': len(lang_page.sections),
                    'url': lang_page.fullurl
                }
    
    return results

# Compare "Artificial Intelligence" across languages
comparison = compare_languages('Artificial_intelligence', ['en', 'es', 'fr', 'de', 'zh'])
for lang, info in comparison.items():
    print(f"{lang}: {info['title']} ({info['summary_length']} chars, {info['sections']} sections)")

def find_common_links(page1_title, page2_title):
    """Find pages that both pages link to."""
    wiki = wikipediaapi.Wikipedia('MyApp/1.0', 'en')
    
    page1 = wiki.page(page1_title)
    page2 = wiki.page(page2_title)
    
    if not (page1.exists() and page2.exists()):
        return []
    
    links1 = set(page1.links.keys())
    links2 = set(page2.links.keys())
    
    common_links = links1.intersection(links2)
    return sorted(common_links)

def find_linking_path(start_page_title, target_page_title, max_depth=2):
    """Find if there's a linking path between two pages."""
    wiki = wikipediaapi.Wikipedia('MyApp/1.0', 'en')
    
    start_page = wiki.page(start_page_title)
    if not start_page.exists():
        return None
    
    # Check direct link
    if target_page_title in start_page.links:
        return [start_page_title, target_page_title]
    
    # Check two-hop links
    if max_depth >= 2:
        for intermediate_title, intermediate_page in start_page.links.items():
            if intermediate_page.exists():
                intermediate_links = intermediate_page.links
                if target_page_title in intermediate_links:
                    return [start_page_title, intermediate_title, target_page_title]
    
    return None

# Example usage
common = find_common_links('Machine_learning', 'Artificial_intelligence')
print(f"Common links: {len(common)}")
for link in common[:10]:
    print(f"  - {link}")

path = find_linking_path('Python_(programming_language)', 'Machine_learning')
if path:
    print(f"Path found: {' -> '.join(path)}")
else:
    print("No direct path found")