Getting Started with UV: Build a Text Processing App¶

"""Text analysis core functionality."""
import re
from typing import Dict, List
from collections import Counter


class TextAnalyzer:
    """Analyze text documents and extract statistics."""

    def __init__(self, text: str):
        self.text = text
        self.sentences = self._split_sentences()
        self.words = self._extract_words()
        self.paragraphs = self._split_paragraphs()

    def _split_sentences(self) -> List[str]:
        """Split text into sentences."""
        # Simple sentence splitting
        sentences = re.split(r'[.!?]+', self.text)
        return [s.strip() for s in sentences if s.strip()]

    def _extract_words(self) -> List[str]:
        """Extract words from text."""
        words = re.findall(r'\b[a-zA-Z]+\b', self.text.lower())
        return words

    def _split_paragraphs(self) -> List[str]:
        """Split text into paragraphs."""
        paragraphs = self.text.split('\n\n')
        return [p.strip() for p in paragraphs if p.strip()]

    def word_count(self) -> int:
        """Count total words."""
        return len(self.words)

    def sentence_count(self) -> int:
        """Count total sentences."""
        return len(self.sentences)

    def paragraph_count(self) -> int:
        """Count total paragraphs."""
        return len(self.paragraphs)

    def average_word_length(self) -> float:
        """Calculate average word length."""
        if not self.words:
            return 0.0
        return sum(len(word) for word in self.words) / len(self.words)

    def average_sentence_length(self) -> float:
        """Calculate average sentence length in words."""
        if not self.sentences:
            return 0.0
        return len(self.words) / len(self.sentences)

    def most_common_words(self, n: int = 10) -> List[tuple]:
        """Get n most common words."""
        # Filter out common stop words
        stop_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for'}
        filtered_words = [w for w in self.words if w not in stop_words]
        return Counter(filtered_words).most_common(n)

    def readability_score(self) -> float:
        """Calculate simple readability score (0-100)."""
        # Simple formula based on avg sentence length and word length
        if not self.sentences or not self.words:
            return 0.0

        avg_sentence_len = self.average_sentence_length()
        avg_word_len = self.average_word_length()

        # Lower score = easier to read
        score = 100 - (avg_sentence_len * 1.5 + avg_word_len * 10)
        return max(0, min(100, score))  # Clamp to 0-100

    def get_statistics(self) -> Dict:
        """Get all statistics as dictionary."""
        return {
            'words': self.word_count(),
            'sentences': self.sentence_count(),
            'paragraphs': self.paragraph_count(),
            'avg_word_length': round(self.average_word_length(), 2),
            'avg_sentence_length': round(self.average_sentence_length(), 2),
            'readability_score': round(self.readability_score(), 2),
            'most_common_words': self.most_common_words(10)
        }

"""Utility functions for file handling."""
from pathlib import Path
from pypdf2 import PdfReader


def read_file(filepath: str) -> str:
    """Read text from file (txt, md, or pdf)."""
    path = Path(filepath)

    if not path.exists():
        raise FileNotFoundError(f"File not found: {filepath}")

    # Handle different file types
    if path.suffix.lower() == '.pdf':
        return read_pdf(filepath)
    else:
        # Text files (txt, md, etc.)
        return path.read_text(encoding='utf-8')


def read_pdf(filepath: str) -> str:
    """Extract text from PDF file."""
    reader = PdfReader(filepath)
    text = []

    for page in reader.pages:
        text.append(page.extract_text())

    return '\n\n'.join(text)

"""Command-line interface for text analyzer."""
import click
from rich.console import Console
from rich.table import Table
from rich.panel import Panel

from .analyzer import TextAnalyzer
from .utils import read_file


console = Console()


@click.group()
def cli():
    """Text Analyzer - Analyze documents and extract statistics."""
    pass


@cli.command()
@click.argument('filepath', type=click.Path(exists=True))
def analyze(filepath: str):
    """Analyze a text file and show statistics."""
    try:
        # Read file
        console.print(f"[blue]Reading file: {filepath}[/blue]")
        text = read_file(filepath)

        # Analyze
        console.print("[blue]Analyzing...[/blue]")
        analyzer = TextAnalyzer(text)
        stats = analyzer.get_statistics()

        # Create results table
        table = Table(title="Text Analysis Results", show_header=True)
        table.add_column("Metric", style="cyan")
        table.add_column("Value", style="green")

        table.add_row("Words", str(stats['words']))
        table.add_row("Sentences", str(stats['sentences']))
        table.add_row("Paragraphs", str(stats['paragraphs']))
        table.add_row("Avg Word Length", f"{stats['avg_word_length']:.2f}")
        table.add_row("Avg Sentence Length", f"{stats['avg_sentence_length']:.2f}")
        table.add_row("Readability Score", f"{stats['readability_score']:.2f}/100")

        console.print(table)

        # Show common words
        console.print("\n[bold]Most Common Words:[/bold]")
        for word, count in stats['most_common_words']:
            console.print(f"  {word}: {count}")

        console.print(f"\n[green]✓ Analysis complete![/green]")

    except Exception as e:
        console.print(f"[red]Error: {e}[/red]")
        raise click.Abort()


@cli.command()
@click.argument('filepath', type=click.Path(exists=True))
def summary(filepath: str):
    """Generate a quick summary of the document."""
    try:
        text = read_file(filepath)
        analyzer = TextAnalyzer(text)

        # Create summary panel
        summary_text = f"""
Words: {analyzer.word_count()}
Sentences: {analyzer.sentence_count()}
Readability: {analyzer.readability_score():.1f}/100
"""

        panel = Panel(
            summary_text.strip(),
            title=f"[bold]{Path(filepath).name}[/bold]",
            border_style="blue"
        )

        console.print(panel)

    except Exception as e:
        console.print(f"[red]Error: {e}[/red]")
        raise click.Abort()


if __name__ == '__main__':
    cli()

"""Text Analyzer - Document analysis tool."""
from .analyzer import TextAnalyzer
from .utils import read_file

__version__ = "0.1.0"
__all__ = ['TextAnalyzer', 'read_file']