def get_wiki_intro(url):
    """
    Get the introduction paragraphs from a Wikipedia article.
    Returns a list of cleaned paragraph texts.
    """
    response = httpx.get(url)
    soup = BeautifulSoup(response.text, 'lxml')
    
    # Get the main content
    content = soup.select_one("#mw-content-text > div.mw-content-ltr.mw-parser-output")
    paragraphs = content.find_all('p')
    
    # Collect intro paragraphs (stop at first heading)
    intro_texts = []
    for p in paragraphs:
        # Break if we hit a heading
        if p.find_previous('div', class_='mw-heading mw-heading2'):
            break
        # Only keep non-empty paragraphs
        text = p.text.strip()
        if text:
            intro_texts.append(text)
    
    return intro_texts

# Test it
url = "https://en.wikipedia.org/wiki/Evolution_of_snake_venom"
intros = get_wiki_intro(url)
for p in intros:
    print(p)
    print("\n---\n")

class ArticleAnalysis:
    "Analysis of a Wikipedia article"
    def __init__(self,
                interest_rating: int,  # Rating from 1-10 of how interesting the article is
                difficulty_rating: int,  # Rating from 1-10 of how difficult the article is
                prerequisites: list[str],  # List of topics reader should know beforehand
                key_takeaways: list[str],  # List of main points from the article
                ):
        assert 1 <= interest_rating <= 10, "Interest rating must be between 1 and 10"
        assert 1 <= difficulty_rating <= 10, "Difficulty rating must be between 1 and 10"
        store_attr()
    
    __repr__ = basic_repr('interest_rating, difficulty_rating, prerequisites, key_takeaways')

# Create a chat instance with the article analysis tool
from claudette import Chat, Client, models

chat = Chat(models[1], tools=[ArticleAnalysis])

# Get analysis for an article
def analyze_article(url):
    intro_texts = get_wiki_intro(url)
    prompt = f"""Based on these introduction paragraphs from a Wikipedia article:

{' '.join(intro_texts)}

Analyze this for a general reader with no prior knowledge of the topic. Return:
- An interest rating (1-10)
- A difficulty rating (1-10)
- A list of prerequisite knowledge needed
- Key takeaways from the text

Focus on making this accessible to someone new to the topic."""

    return chat.structured(prompt, ArticleAnalysis)

# Test it
url = "https://en.wikipedia.org/wiki/Evolution_of_snake_venom"
analysis = analyze_article(url)
print(analysis)

prompt = f"""Here's a Wikipedia article introduction:

<article>
{article_text}
</article>

Analyze this text and provide a structured analysis in exactly this format:

INTEREST RATING (1-10):
- Choose a rating where 1 means "not engaging for general readers" and 10 means "highly fascinating for anyone"
- Consider factors like real-world relevance, wow-factor, and storytelling
- Rate assuming the reader has no prior knowledge of the topic

DIFFICULTY RATING (1-10):
- Choose a rating where 1 means "easily understood by anyone" and 10 means "requires expert knowledge"
- Consider technical terminology, complex concepts, and assumed knowledge
- Rate assuming the reader has no specialized background

PREREQUISITES:
- List 3-5 basic concepts or topics that would help understand this article better
- Focus on fundamental ideas, not advanced concepts
- Each prerequisite should be a single line starting with "-"

Provide your analysis in a way that can be directly parsed into the ArticleAnalysis class structure."""

result = chat.structured(prompt, ArticleAnalysis)

def analyze_wiki_article(url):
    """
    Analyzes a Wikipedia article and returns structured information about its
    difficulty, interest level, prerequisites, and key takeaways.
    
    Args:
        url (str): URL of the Wikipedia article
    
    Returns:
        ArticleAnalysis: Structured analysis of the article
    """
    try:
        # Get article intro
        intro_texts = get_wiki_intro(url)
        article_text = "\n\n".join(intro_texts)
        
        # Create prompt with tagged text
        prompt = f"""Here's a Wikipedia article introduction:

<article_text>
{article_text}
</article_text>

Analyze this text and provide a structured analysis in exactly this format:

INTEREST RATING (1-10):
- Choose a rating where 1 means "not engaging for general readers" and 10 means "highly fascinating for anyone"
- Consider factors like real-world relevance, wow-factor, and storytelling
- Rate assuming the reader has no prior knowledge of the topic

DIFFICULTY RATING (1-10):
- Choose a rating where 1 means "easily understood by anyone" and 10 means "requires expert knowledge"
- Consider technical terminology, complex concepts, and assumed knowledge
- Rate assuming the reader has no specialized background

PREREQUISITES:
- List 3-5 basic concepts or topics that would help understand this article better
- Focus on fundamental ideas, not advanced concepts
- Each prerequisite should be a single line starting with "-"

KEY TAKEAWAYS:
- List 4-5 main points from the article
- Focus on the most important concepts
- Make them accessible to general readers

Provide your analysis in a way that can be directly parsed into the ArticleAnalysis class structure."""

        # Get analysis
        client = Client(models[1])
        result = client.structured(prompt, ArticleAnalysis)
        return result[0]
    
    except Exception as e:
        print(f"Error analyzing {url}: {str(e)}")
        return None

# Example usage:
urls = [
    "https://en.wikipedia.org/wiki/Evolution_of_snake_venom",
    "https://en.wikipedia.org/wiki/CRISPR",
    # Add more URLs here
]

analyses = {}
for url in urls:
    analysis = analyze_wiki_article(url)
    if analysis:
        analyses[url] = analysis
        print(f"\nAnalysis for {url}:")
        print(analysis)

analysis = analyze_wiki_article("https://en.wikipedia.org/wiki/CRISPR")
print(analysis)

urls = [
    "https://en.wikipedia.org/wiki/Genetic_engineering",
    "https://en.wikipedia.org/wiki/RNA_world",
    "https://en.wikipedia.org/wiki/Bioinformatics"
]

results = {url: analyze_wiki_article(url) for url in urls}

def create_analysis_prompt(article_text: str) -> str:
    """
    Creates a structured prompt for article analysis.
    
    Args:
        article_text (str): The article text to analyze
    
    Returns:
        str: Formatted prompt for Claude
    """
    return f"""Here's a Wikipedia article introduction:

<article_text>
{article_text}
</article_text>

Analyze this text and provide a structured analysis in exactly this format:

INTEREST RATING (1-10):
- Choose a rating where 1 means "not engaging for general readers" and 10 means "highly fascinating for anyone"
- Consider factors like real-world relevance, wow-factor, and storytelling
- Rate assuming the reader has no prior knowledge of the topic

DIFFICULTY RATING (1-10):
- Choose a rating where 1 means "easily understood by anyone" and 10 means "requires expert knowledge"
- Consider technical terminology, complex concepts, and assumed knowledge
- Rate assuming the reader has no specialized background

PREREQUISITES:
- List 3-5 basic concepts or topics that would help understand this article better
- Focus on fundamental ideas, not advanced concepts
- Each prerequisite should be a single line starting with "-"

Provide your analysis in a way that can be directly parsed into the ArticleAnalysis class structure."""

def get_article_analysis(article_text: str, client: Client) -> ArticleAnalysis:
    """
    Gets structured analysis of article text using Claude.
    
    Args:
        article_text (str): The article text to analyze
        client (Client): Claudette client instance
    
    Returns:
        ArticleAnalysis: Structured analysis of the article
    """
    prompt = create_analysis_prompt(article_text)
    result = client.structured(prompt, ArticleAnalysis)
    return result[0]

def analyze_wiki_article(url: str, client: Client = None) -> ArticleAnalysis:
    """
    Analyzes a Wikipedia article and returns structured information.
    
    Args:
        url (str): URL of the Wikipedia article
        client (Client): Optional Claudette client instance
    
    Returns:
        ArticleAnalysis: Structured analysis of the article
    """
    try:
        # Get article intro
        intro_texts = get_wiki_intro(url)
        article_text = "\n\n".join(intro_texts)
        
        # Create client if not provided
        if client is None:
            client = Client(models[1])
            
        # Get analysis
        return get_article_analysis(article_text, client)
    
    except Exception as e:
        print(f"Error analyzing {url}: {str(e)}")
        return None

def analyze_multiple_articles(urls: list[str]) -> dict:
    """
    Analyzes multiple Wikipedia articles.
    
    Args:
        urls (list[str]): List of Wikipedia URLs
    
    Returns:
        dict: Dictionary mapping URLs to their analyses
    """
    client = Client(models[1])  # Create single client instance
    analyses = {}
    
    for url in urls:
        analysis = analyze_wiki_article(url, client)
        if analysis:
            analyses[url] = analysis
            print(f"\nAnalysis for {url}:")
            print(analysis)
    
    return analyses

# Example usage:
if __name__ == "__main__":
    # Test single article
    url = "https://en.wikipedia.org/wiki/CRISPR"
    analysis = analyze_wiki_article(url)
    print(f"\nSingle article analysis:\n{analysis}")
    
    # Test multiple articles
    urls = [
        "https://en.wikipedia.org/wiki/Genetic_engineering",
        "https://en.wikipedia.org/wiki/RNA_world",
        "https://en.wikipedia.org/wiki/Bioinformatics"
    ]
    results = analyze_multiple_articles(urls)

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import sys
import threading

def is_interactive():
    """Check if we're running in an interactive environment (like Jupyter/IPython)"""
    return hasattr(sys, 'ps1') or bool(sys.flags.interactive) or 'ipykernel' in sys.modules

def analyze_article_wrapper(url: str, client: Client = None) -> tuple[str, ArticleAnalysis]:
    """
    Wrapper function for parallel processing that returns both url and analysis.
    
    Args:
        url (str): URL of the Wikipedia article
        client (Client): Optional Claudette client instance
    
    Returns:
        tuple: (url, analysis result)
    """
    analysis = analyze_wiki_article(url, client)
    return url, analysis

def analyze_multiple_articles(urls: list[str], max_workers: int = None) -> dict:
    """
    Analyzes multiple Wikipedia articles in parallel.
    Uses ThreadPoolExecutor in interactive environments and ProcessPoolExecutor in scripts.
    
    Args:
        urls (list[str]): List of Wikipedia URLs
        max_workers (int, optional): Maximum number of parallel workers
    
    Returns:
        dict: Dictionary mapping URLs to their analyses
    """
    # Create single client instance for thread safety
    client = Client(models[1])
    
    # Choose executor based on environment
    executor_class = ThreadPoolExecutor if is_interactive() else ProcessPoolExecutor
    
    # If max_workers not specified, use number of URLs or CPU count
    if max_workers is None:
        max_workers = min(len(urls), (threading.active_count() * 5))
    
    analyses = {}
    print(f"Using {executor_class.__name__} with {max_workers} workers")
    
    with executor_class(max_workers=max_workers) as executor:
        # Submit all tasks
        future_to_url = {
            executor.submit(analyze_article_wrapper, url, client): url 
            for url in urls
        }
        
        # Process completed tasks as they finish
        for future in concurrent.futures.as_completed(future_to_url):
            url = future_to_url[future]
            try:
                url, analysis = future.result()
                if analysis:
                    analyses[url] = analysis
                    print(f"\nAnalysis for {url}:")
                    print(analysis)
            except Exception as e:
                print(f"Error analyzing {url}: {str(e)}")
    
    return analyses

# Example usage:
if __name__ == "__main__":
    urls = [
        "https://en.wikipedia.org/wiki/Genetic_engineering",
        "https://en.wikipedia.org/wiki/RNA_world",
        "https://en.wikipedia.org/wiki/Bioinformatics",
        "https://en.wikipedia.org/wiki/CRISPR",
        "https://en.wikipedia.org/wiki/DNA_sequencing"
    ]
    
    results = analyze_multiple_articles(urls)

# For testing a few articles
urls = [
    "https://en.wikipedia.org/wiki/Genetic_engineering",
    "https://en.wikipedia.org/wiki/RNA_world",
    "https://en.wikipedia.org/wiki/Bioinformatics"
]
results = analyze_multiple_articles(urls)

# Or with custom number of workers
results = analyze_multiple_articles(urls, max_workers=2)

boring_urls = [
    "https://en.wikipedia.org/wiki/ISO_8601",  # Date/time formatting standard
    "https://en.wikipedia.org/wiki/Null_pointer",  # Technical computing concept
    "https://en.wikipedia.org/wiki/Administrative_division",  # Bureaucratic organization
    "https://en.wikipedia.org/wiki/List_of_ISO_standards",  # Technical standards list
    "https://en.wikipedia.org/wiki/Tax_form",  # Tax documentation
]

# Test these potentially boring articles
client = Client(models[1])
for url in boring_urls:
    result = analyze_wiki_article(url, client)
    print(f"\nURL: {url}")
    print(result)

more_boring_urls = [
    "https://en.wikipedia.org/wiki/Form_1040",  # Specific tax form
    "https://en.wikipedia.org/wiki/ASCII_decimal_code",  # Character encoding details
    "https://en.wikipedia.org/wiki/Binary_logarithm",  # Mathematical concept
    "https://en.wikipedia.org/wiki/HTTP_header_field",  # Technical web standard
    "https://en.wikipedia.org/wiki/Regular_expression_syntax"  # Programming syntax
]

for url in more_boring_urls:
    result = analyze_wiki_article(url, client)
    print(f"\nURL: {url}")
    print(result)

really_boring_urls = [
    "https://en.wikipedia.org/wiki/Comma-separated_values",  # CSV file format
    "https://en.wikipedia.org/wiki/Indent_style",  # Code formatting
    "https://en.wikipedia.org/wiki/File_allocation_table",  # FAT file system
    "https://en.wikipedia.org/wiki/Document_management_system",  # Document management
    "https://en.wikipedia.org/wiki/Chart_of_accounts"  # Accounting concept
]

for url in really_boring_urls:
    result = analyze_wiki_article(url, client)
    print(f"\nURL: {url}")
    print(result)

ultimate_boring_urls = [
    "https://en.wikipedia.org/wiki/Procurement",  # Corporate buying processes
    "https://en.wikipedia.org/wiki/Data_definition_language",  # Database syntax
    "https://en.wikipedia.org/wiki/Meeting_minutes",  # Meeting documentation
    "https://en.wikipedia.org/wiki/XML_Schema_(W3C)",  # XML validation rules
    "https://en.wikipedia.org/wiki/Invoice_processing"  # Invoice handling
]

for url in ultimate_boring_urls:
    result = analyze_wiki_article(url, client)
    print(f"\nURL: {url}")
    print(result)