pystylometry 1.3.5__py3-none-any.whl → 1.3.6__py3-none-any.whl

pystylometry/cli.py

@@ -4,6 +4,7 @@ Usage:
     pystylometry-drift <file> [--window-size=N] [--stride=N] [--mode=MODE] [--json]
     pystylometry-drift <file> --plot [output.png]
     pystylometry-tokenize <file> [--json] [--metadata] [--stats]
+    bnc --input-file <file> [--output-file <file>] [--format csv|html|json]
 
 Example:
     pystylometry-drift manuscript.txt
@@ -14,6 +15,9 @@ Example:
     pystylometry-tokenize manuscript.txt
     pystylometry-tokenize manuscript.txt --json --metadata
     pystylometry-tokenize manuscript.txt --stats
+    bnc --input-file manuscript.txt
+    bnc --input-file manuscript.txt --output-file report.html --format html
+    bnc -i manuscript.txt --format json
 """
 
 from __future__ import annotations
@@ -744,5 +748,375 @@ Examples:
             print(token)
 
 
+def bnc_frequency_cli() -> None:
+    """CLI entry point for BNC word frequency analysis."""
+    parser = argparse.ArgumentParser(
+        prog="bnc",
+        description="Analyze word frequencies against the British National Corpus (BNC).",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  bnc --input-file manuscript.txt
+  bnc --input-file manuscript.txt --output-file report.html
+  bnc --input-file manuscript.txt --format json
+  bnc --input-file manuscript.txt --overuse-threshold 2.0 --min-mentions 3
+  bnc --input-file manuscript.txt --no-wordnet
+
+Output:
+  Generates a report with three sections:
+  - Not in BNC: Words not found in the corpus (with WordNet status, character type)
+  - Most Underused: Words appearing less frequently than expected
+  - Most Overused: Words appearing more frequently than expected
+
+Thresholds:
+  Words with ratio > overuse-threshold are "overused"
+  Words with ratio < underuse-threshold are "underused"
+  Ratio = observed_count / expected_count (based on BNC frequencies)
+""",
+    )
+
+    parser.add_argument(
+        "--input-file",
+        "-i",
+        type=Path,
+        required=True,
+        metavar="FILE",
+        help="Path to text file to analyze",
+    )
+    parser.add_argument(
+        "--output-file",
+        "-o",
+        type=Path,
+        default=None,
+        metavar="FILE",
+        help="Output file (default: <input>_bnc_frequency.<ext> based on --format)",
+    )
+    parser.add_argument(
+        "--overuse-threshold",
+        type=float,
+        default=1.3,
+        metavar="N",
+        help="Ratio above which words are considered overused (default: 1.3)",
+    )
+    parser.add_argument(
+        "--underuse-threshold",
+        type=float,
+        default=0.8,
+        metavar="N",
+        help="Ratio below which words are considered underused (default: 0.8)",
+    )
+    parser.add_argument(
+        "--min-mentions",
+        type=int,
+        default=1,
+        metavar="N",
+        help="Minimum word occurrences to include (default: 1)",
+    )
+    parser.add_argument(
+        "--no-wordnet",
+        action="store_true",
+        help="Skip WordNet lookup for unknown words",
+    )
+    parser.add_argument(
+        "--format",
+        choices=["csv", "html", "json", "excel"],
+        default="csv",
+        help="Output format: csv (tab-delimited), html (interactive), json, excel (default: csv)",
+    )
+
+    args = parser.parse_args()
+
+    # Import rich for colored output
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.text import Text
+
+    console = Console(stderr=True)
+
+    # Validate file exists
+    if not args.input_file.exists():
+        console.print(f"[red]Error:[/red] File not found: {args.input_file}")
+        sys.exit(1)
+
+    # Read file
+    try:
+        text = args.input_file.read_text(encoding="utf-8")
+    except Exception as e:
+        console.print(f"[red]Error reading file:[/red] {e}")
+        sys.exit(1)
+
+    # Determine output path (extension based on format)
+    suffix_map = {"csv": ".tsv", "html": ".html", "json": ".json", "excel": ".xlsx"}
+    if args.output_file:
+        output_path = args.output_file
+    else:
+        suffix = suffix_map[args.format]
+        output_path = args.input_file.with_name(f"{args.input_file.stem}_bnc_frequency{suffix}")
+
+    # Calculate file stats
+    token_count = len(text.split())
+    char_count = len(text)
+
+    # Print header
+    console.print()
+    header = Text()
+    header.append("PYSTYLOMETRY", style="bold cyan")
+    header.append(" — ", style="dim")
+    header.append("BNC Word Frequency Analysis", style="bold white")
+    console.print(Panel(header, border_style="cyan"))
+
+    # Input section
+    console.print()
+    console.print("[bold]INPUT[/bold]", style="cyan")
+    console.print("─" * 60, style="dim")
+    console.print(f"  File:    [white]{args.input_file}[/white]")
+    console.print(
+        f"  Size:    [green]{char_count:,}[/green] chars / [green]{token_count:,}[/green] tokens"
+    )
+
+    # Parameters section
+    console.print()
+    console.print("[bold]PARAMETERS[/bold]", style="cyan")
+    console.print("─" * 60, style="dim")
+    console.print(f"  Overuse threshold:   [yellow]{args.overuse_threshold}x[/yellow]")
+    console.print(f"  Underuse threshold:  [yellow]{args.underuse_threshold}x[/yellow]")
+    console.print(f"  Min mentions:        [yellow]{args.min_mentions}[/yellow]")
+    console.print(f"  WordNet lookup:      [yellow]{'no' if args.no_wordnet else 'yes'}[/yellow]")
+
+    # Output section
+    console.print()
+    console.print("[bold]OUTPUT[/bold]", style="cyan")
+    console.print("─" * 60, style="dim")
+    fmt_display = {
+        "csv": "Tab-delimited CSV",
+        "html": "Interactive HTML",
+        "json": "JSON",
+        "excel": "Excel (.xlsx)",
+    }
+    console.print(f"  Format:      [magenta]{fmt_display[args.format]}[/magenta]")
+    console.print(f"  Destination: [white]{output_path}[/white]")
+
+    # Run analysis with spinner
+    console.print()
+    with console.status("[bold cyan]Running analysis...[/bold cyan]", spinner="dots"):
+        from pystylometry.lexical.bnc_frequency import compute_bnc_frequency
+
+        result = compute_bnc_frequency(
+            text,
+            overuse_threshold=args.overuse_threshold,
+            underuse_threshold=args.underuse_threshold,
+            include_wordnet=not args.no_wordnet,
+            min_mentions=args.min_mentions,
+        )
+
+    # Output results
+    if args.format == "json":
+        output = {
+            "stats": {
+                "total_tokens": result.total_tokens,
+                "unique_tokens": result.unique_tokens,
+                "overused_count": len(result.overused),
+                "underused_count": len(result.underused),
+                "not_in_bnc_count": len(result.not_in_bnc),
+            },
+            "overused": [
+                {
+                    "word": w.word,
+                    "observed": w.observed,
+                    "expected": w.expected,
+                    "ratio": w.ratio,
+                    "char_type": w.char_type,
+                }
+                for w in result.overused
+            ],
+            "underused": [
+                {
+                    "word": w.word,
+                    "observed": w.observed,
+                    "expected": w.expected,
+                    "ratio": w.ratio,
+                    "char_type": w.char_type,
+                }
+                for w in result.underused
+            ],
+            "not_in_bnc": [
+                {
+                    "word": w.word,
+                    "observed": w.observed,
+                    "in_wordnet": w.in_wordnet,
+                    "char_type": w.char_type,
+                }
+                for w in result.not_in_bnc
+            ],
+        }
+        output_path.write_text(json.dumps(output, indent=2))
+        console.print(f'[green]✓[/green] JSON saved to: [white]"{output_path}"[/white]')
+
+    elif args.format == "csv":
+        # Tab-delimited output with category column
+        lines = ["category\tword\tobserved\texpected\tratio\tin_wordnet\tchar_type"]
+
+        def fmt_wordnet(val: bool | None) -> str:
+            if val is True:
+                return "yes"
+            elif val is False:
+                return "no"
+            return ""
+
+        for w in result.overused:
+            expected = f"{w.expected:.2f}" if w.expected else ""
+            ratio = f"{w.ratio:.4f}" if w.ratio else ""
+            in_wn = fmt_wordnet(w.in_wordnet)
+            lines.append(
+                f"overused\t{w.word}\t{w.observed}\t{expected}\t{ratio}\t{in_wn}\t{w.char_type}"
+            )
+
+        for w in result.underused:
+            expected = f"{w.expected:.2f}" if w.expected else ""
+            ratio = f"{w.ratio:.4f}" if w.ratio else ""
+            in_wn = fmt_wordnet(w.in_wordnet)
+            lines.append(
+                f"underused\t{w.word}\t{w.observed}\t{expected}\t{ratio}\t{in_wn}\t{w.char_type}"
+            )
+
+        for w in result.not_in_bnc:
+            in_wn = fmt_wordnet(w.in_wordnet)
+            lines.append(f"not-in-bnc\t{w.word}\t{w.observed}\t\t\t{in_wn}\t{w.char_type}")
+
+        output_path.write_text("\n".join(lines))
+        console.print(f'[green]✓[/green] TSV saved to: [white]"{output_path}"[/white]')
+
+    elif args.format == "excel":
+        try:
+            from openpyxl import Workbook  # type: ignore[import-untyped]
+            from openpyxl.styles import Alignment, PatternFill  # type: ignore[import-untyped]
+        except ImportError:
+            console.print("[red]Error:[/red] Excel export requires openpyxl.")
+            console.print("  Install with: [yellow]pip install pystylometry[excel][/yellow]")
+            console.print("  Or for pipx: [yellow]pipx inject pystylometry openpyxl[/yellow]")
+            sys.exit(1)
+
+        wb = Workbook()
+
+        # Remove default sheet
+        wb.remove(wb.active)
+
+        # Cell style: width 15, centered, vertically centered
+        align = Alignment(horizontal="center", vertical="center")
+
+        def fmt_wordnet_excel(val: bool | None) -> str:
+            if val is True:
+                return "yes"
+            elif val is False:
+                return "no"
+            return ""
+
+        # Overused sheet (sorted by ratio, high to low)
+        ws_over = wb.create_sheet("overused")
+        ws_over.append(["word", "observed", "expected", "ratio", "in_wordnet", "char_type"])
+        for w in sorted(result.overused, key=lambda x: x.ratio or 0, reverse=True):
+            in_wn = fmt_wordnet_excel(w.in_wordnet)
+            ws_over.append([w.word, w.observed, w.expected, w.ratio, in_wn, w.char_type])
+
+        # Underused sheet (sorted by ratio, high to low)
+        ws_under = wb.create_sheet("underused")
+        ws_under.append(["word", "observed", "expected", "ratio", "in_wordnet", "char_type"])
+        for w in sorted(result.underused, key=lambda x: x.ratio or 0, reverse=True):
+            in_wn = fmt_wordnet_excel(w.in_wordnet)
+            ws_under.append([w.word, w.observed, w.expected, w.ratio, in_wn, w.char_type])
+
+        # Not in BNC sheet
+        ws_notbnc = wb.create_sheet("not-in-bnc")
+        ws_notbnc.append(["word", "observed", "in_wordnet", "char_type", "plural_form"])
+        for w in result.not_in_bnc:
+            in_wn = fmt_wordnet_excel(w.in_wordnet)
+            plural = "yes" if w.word.endswith("s") else "no"
+            ws_notbnc.append([w.word, w.observed, in_wn, w.char_type, plural])
+
+        # Apply formatting to all sheets
+        for ws in [ws_over, ws_under, ws_notbnc]:
+            for col in ws.columns:
+                col_letter = col[0].column_letter
+                # Word column (A) gets width 30, others get 15
+                ws.column_dimensions[col_letter].width = 30 if col_letter == "A" else 15
+            for row in ws.iter_rows():
+                for cell in row:
+                    cell.alignment = align
+
+        # Apply number formatting to expected (C) and ratio (D) columns
+        for ws in [ws_over, ws_under]:
+            for row in range(2, ws.max_row + 1):  # Skip header row
+                ws[f"C{row}"].number_format = "0.00"
+                ws[f"D{row}"].number_format = "0.00"
+
+        # Apply background colors to in_wordnet column
+        fill_yes = PatternFill(start_color="C6EFCE", end_color="C6EFCE", fill_type="solid")
+        fill_no = PatternFill(start_color="FFC7CE", end_color="FFC7CE", fill_type="solid")
+
+        # in_wordnet is column E for overused/underused, column C for not-in-bnc
+        for ws in [ws_over, ws_under]:
+            for row in range(2, ws.max_row + 1):
+                cell = ws[f"E{row}"]
+                if cell.value == "yes":
+                    cell.fill = fill_yes
+                elif cell.value == "no":
+                    cell.fill = fill_no
+
+        for row in range(2, ws_notbnc.max_row + 1):
+            cell = ws_notbnc[f"C{row}"]
+            if cell.value == "yes":
+                cell.fill = fill_yes
+            elif cell.value == "no":
+                cell.fill = fill_no
+
+        # Apply background colors to plural_form column (E) in not-in-bnc
+        fill_plural_yes = PatternFill(
+            start_color="BDD7EE", end_color="BDD7EE", fill_type="solid"
+        )  # Light blue
+        fill_plural_no = PatternFill(
+            start_color="FCE4D6", end_color="FCE4D6", fill_type="solid"
+        )  # Light peach
+        for row in range(2, ws_notbnc.max_row + 1):
+            cell = ws_notbnc[f"E{row}"]
+            if cell.value == "yes":
+                cell.fill = fill_plural_yes
+            elif cell.value == "no":
+                cell.fill = fill_plural_no
+
+        wb.save(output_path)
+        console.print(f'[green]✓[/green] Excel saved to: [white]"{output_path}"[/white]')
+
+    else:  # html
+        from pystylometry.viz.jsx import export_bnc_frequency_jsx
+
+        export_bnc_frequency_jsx(
+            result,
+            output_file=output_path,
+            title=f"BNC Frequency Analysis: {args.input_file.name}",
+            source_file=str(args.input_file),
+        )
+
+        abs_path = output_path.resolve()
+        file_url = f"file://{abs_path}"
+        console.print(f'[green]✓[/green] HTML report saved to: [white]"{output_path}"[/white]')
+        console.print(f"  Open in browser: [link={file_url}]{file_url}[/link]")
+
+    # Summary table
+    console.print()
+    table = Table(title="Summary", border_style="cyan", header_style="bold cyan")
+    table.add_column("Metric", style="white")
+    table.add_column("Count", justify="right", style="green")
+
+    table.add_row("Total tokens", f"{result.total_tokens:,}")
+    table.add_row("Unique words", f"{result.unique_tokens:,}")
+    table.add_row("Not in BNC", f"[dim]{len(result.not_in_bnc):,}[/dim]")
+    table.add_row("Underused", f"[blue]{len(result.underused):,}[/blue]")
+    table.add_row("Overused", f"[red]{len(result.overused):,}[/red]")
+
+    console.print(table)
+    console.print()
+
+
 if __name__ == "__main__":
     drift_cli()

pystylometry/lexical/__init__.py

@@ -2,6 +2,7 @@
 
 # Local implementations
 from .advanced_diversity import compute_hdd, compute_mattr, compute_msttr, compute_vocd_d
+from .bnc_frequency import compute_bnc_frequency
 from .function_words import compute_function_words
 from .hapax import compute_hapax_ratios, compute_hapax_with_lexicon_analysis
 from .mtld import compute_mtld
@@ -17,6 +18,7 @@ __all__ = [
     "compute_yule",
     "compute_hapax_ratios",
     "compute_hapax_with_lexicon_analysis",
+    "compute_bnc_frequency",
     "compute_function_words",
     "compute_vocd_d",
     "compute_mattr",

pystylometry/lexical/bnc_frequency.py

@@ -0,0 +1,309 @@
+"""BNC (British National Corpus) frequency analysis for stylometric comparison.
+
+This module computes word frequency ratios by comparing observed word frequencies
+in a text against expected frequencies from the British National Corpus (BNC).
+Words can be categorized as:
+- Overused: appear more frequently than expected (ratio > 1)
+- Underused: appear less frequently than expected (ratio < 1)
+- Not in BNC: words that don't exist in the BNC corpus
+
+Related GitHub Issue:
+    #TBD - BNC frequency analysis CLI
+    https://github.com/craigtrim/pystylometry/issues/TBD
+
+References:
+    British National Corpus: http://www.natcorp.ox.ac.uk/
+    The BNC is a 100-million word collection of samples of written and spoken
+    language from a wide range of sources, designed to represent a wide
+    cross-section of British English from the late 20th century.
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from collections import Counter
+from dataclasses import dataclass
+from typing import Literal
+
+from .._utils import check_optional_dependency
+
+# Unicode apostrophe variants to normalize to ASCII apostrophe (U+0027)
+# See: https://github.com/craigtrim/pystylometry/issues/45
+_APOSTROPHE_VARIANTS = (
+    "\u0060"  # GRAVE ACCENT
+    "\u00B4"  # ACUTE ACCENT
+    "\u2018"  # LEFT SINGLE QUOTATION MARK
+    "\u2019"  # RIGHT SINGLE QUOTATION MARK
+    "\u201B"  # SINGLE HIGH-REVERSED-9 QUOTATION MARK
+    "\u2032"  # PRIME
+    "\u2035"  # REVERSED PRIME
+    "\u02B9"  # MODIFIER LETTER PRIME
+    "\u02BC"  # MODIFIER LETTER APOSTROPHE
+    "\u02C8"  # MODIFIER LETTER VERTICAL LINE
+    "\u0313"  # COMBINING COMMA ABOVE
+    "\u0315"  # COMBINING COMMA ABOVE RIGHT
+    "\u055A"  # ARMENIAN APOSTROPHE
+    "\u05F3"  # HEBREW PUNCTUATION GERESH
+    "\u07F4"  # NKO HIGH TONE APOSTROPHE
+    "\u07F5"  # NKO LOW TONE APOSTROPHE
+    "\uFF07"  # FULLWIDTH APOSTROPHE
+    "\u1FBF"  # GREEK PSILI
+    "\u1FBD"  # GREEK KORONIS
+    "\uA78C"  # LATIN SMALL LETTER SALTILLO
+)
+
+
+def _normalize_apostrophes(text: str) -> str:
+    """Normalize Unicode apostrophe variants to ASCII apostrophe.
+
+    Many texts (especially ebooks, PDFs, and word processor output) use
+    typographic "smart quotes" instead of ASCII apostrophes. This function
+    normalizes all variants to the standard ASCII apostrophe (U+0027) to
+    ensure consistent BNC lookups.
+
+    Args:
+        text: Input text potentially containing apostrophe variants
+
+    Returns:
+        Text with all apostrophe variants normalized to ASCII apostrophe
+
+    Example:
+        >>> _normalize_apostrophes("don't")  # curly apostrophe
+        "don't"  # ASCII apostrophe
+    """
+    for char in _APOSTROPHE_VARIANTS:
+        text = text.replace(char, "'")
+    return text
+
+
+@dataclass
+class WordAnalysis:
+    """Analysis of a single word against BNC frequency.
+
+    Attributes:
+        word: The word being analyzed (lowercase)
+        observed: Number of times the word appears in the text
+        expected: Expected count based on BNC relative frequency
+        ratio: observed / expected (None if not in BNC)
+        in_wordnet: Whether the word exists in WordNet
+        char_type: Classification of character content
+    """
+
+    word: str
+    observed: int
+    expected: float | None
+    ratio: float | None
+    in_wordnet: bool | None
+    char_type: Literal["latin", "unicode", "numeric", "mixed", "punctuation"]
+
+
+@dataclass
+class BNCFrequencyResult:
+    """Result of BNC frequency analysis.
+
+    Attributes:
+        overused: Words appearing more frequently than expected (ratio > threshold)
+        underused: Words appearing less frequently than expected (ratio < threshold)
+        not_in_bnc: Words not found in the BNC corpus
+        total_tokens: Total word count in the text
+        unique_tokens: Number of unique words
+        overuse_threshold: Ratio above which words are considered overused
+        underuse_threshold: Ratio below which words are considered underused
+        metadata: Additional analysis metadata
+    """
+
+    overused: list[WordAnalysis]
+    underused: list[WordAnalysis]
+    not_in_bnc: list[WordAnalysis]
+    total_tokens: int
+    unique_tokens: int
+    overuse_threshold: float
+    underuse_threshold: float
+    metadata: dict
+
+
+def _classify_char_type(
+    word: str,
+) -> Literal["latin", "unicode", "numeric", "mixed", "punctuation"]:
+    """Classify the character content of a word.
+
+    Args:
+        word: Word to classify
+
+    Returns:
+        Character type classification:
+        - latin: Pure ASCII alphabetic characters (a-z, A-Z)
+        - unicode: Contains non-ASCII characters (accents, etc.)
+        - numeric: Contains only digits
+        - mixed: Contains letters and numbers or other combinations
+        - punctuation: Contains only punctuation
+    """
+    if not word:
+        return "punctuation"
+
+    has_ascii_alpha = bool(re.search(r"[a-zA-Z]", word))
+    has_unicode_alpha = any(unicodedata.category(c).startswith("L") and ord(c) > 127 for c in word)
+    has_digit = any(c.isdigit() for c in word)
+    has_punct = any(unicodedata.category(c).startswith("P") for c in word)
+
+    # Determine classification
+    if has_unicode_alpha:
+        return "unicode"
+    elif has_digit and not has_ascii_alpha:
+        return "numeric"
+    elif has_digit and has_ascii_alpha:
+        return "mixed"
+    elif has_ascii_alpha and not has_punct:
+        return "latin"
+    elif has_ascii_alpha and has_punct:
+        return "mixed"
+    elif not has_ascii_alpha and not has_digit:
+        return "punctuation"
+    else:
+        return "mixed"
+
+
+def compute_bnc_frequency(
+    text: str,
+    overuse_threshold: float = 1.3,
+    underuse_threshold: float = 0.8,
+    include_wordnet: bool = True,
+    min_mentions: int = 1,
+) -> BNCFrequencyResult:
+    """Compute BNC frequency analysis for a text.
+
+    Compares observed word frequencies against expected frequencies from the
+    British National Corpus. Words are categorized as overused, underused,
+    or not in BNC based on their frequency ratios.
+
+    Args:
+        text: Input text to analyze
+        overuse_threshold: Ratio above which words are considered overused (default: 1.3)
+        underuse_threshold: Ratio below which words are considered underused (default: 0.8)
+        include_wordnet: Whether to check WordNet for unknown words (default: True)
+        min_mentions: Minimum number of mentions to include word (default: 1)
+
+    Returns:
+        BNCFrequencyResult with categorized word lists
+
+    Raises:
+        ImportError: If bnc-lookup package is not installed
+
+    Example:
+        >>> result = compute_bnc_frequency("The captain ordered the larboard watch...")
+        >>> result.overused[:3]  # Top 3 overused words
+        [WordAnalysis(word='larboard', ratio=33153.5, ...), ...]
+        >>> result.not_in_bnc[:3]  # Words not in BNC
+        [WordAnalysis(word='xyzbot', ...), ...]
+    """
+    # Check dependency
+    check_optional_dependency("bnc_lookup", "lexical")
+    from bnc_lookup import relative_frequency  # type: ignore[import-untyped]
+
+    # Optional wordnet lookup
+    wordnet_checker = None
+    if include_wordnet:
+        try:
+            from wordnet_lookup import (
+                is_wordnet_term as _is_wordnet_term,  # type: ignore[import-untyped]
+            )
+
+            wordnet_checker = _is_wordnet_term
+        except ImportError:
+            # WordNet lookup is optional
+            pass
+
+    # Tokenize text (simple whitespace + punctuation stripping)
+    # First normalize apostrophes to ensure consistent BNC lookups (Issue #45)
+    normalized_text = _normalize_apostrophes(text)
+    raw_tokens = normalized_text.split()
+    tokens = []
+    for raw in raw_tokens:
+        # Strip leading/trailing punctuation, lowercase
+        cleaned = re.sub(r"^[^\w]+|[^\w]+$", "", raw).lower()
+        if cleaned:
+            tokens.append(cleaned)
+
+    total_tokens = len(tokens)
+
+    # Count observed frequency of each word
+    observed = Counter(tokens)
+    unique_words = list(observed.keys())
+
+    # Get BNC relative frequencies (one at a time - bnc_lookup doesn't have batch)
+    bnc_freqs = {word: relative_frequency(word) for word in unique_words}
+
+    # Analyze each word
+    overused: list[WordAnalysis] = []
+    underused: list[WordAnalysis] = []
+    not_in_bnc: list[WordAnalysis] = []
+
+    for word, obs_count in observed.items():
+        if obs_count < min_mentions:
+            continue
+
+        # Classify character type
+        char_type = _classify_char_type(word)
+
+        # Get BNC frequency
+        rel_freq = bnc_freqs.get(word)
+
+        # Check WordNet if requested
+        in_wordnet = None
+        if wordnet_checker is not None:
+            in_wordnet = wordnet_checker(word)
+
+        if rel_freq is None or rel_freq == 0:
+            # Word not in BNC
+            analysis = WordAnalysis(
+                word=word,
+                observed=obs_count,
+                expected=None,
+                ratio=None,
+                in_wordnet=in_wordnet,
+                char_type=char_type,
+            )
+            not_in_bnc.append(analysis)
+        else:
+            # Compute expected count and ratio
+            expected = rel_freq * total_tokens
+            ratio = obs_count / expected if expected > 0 else None
+
+            analysis = WordAnalysis(
+                word=word,
+                observed=obs_count,
+                expected=expected,
+                ratio=ratio,
+                in_wordnet=in_wordnet,
+                char_type=char_type,
+            )
+
+            if ratio is not None:
+                if ratio > overuse_threshold:
+                    overused.append(analysis)
+                elif ratio < underuse_threshold:
+                    underused.append(analysis)
+
+    # Sort by ratio (highest first for overused, lowest first for underused)
+    overused.sort(key=lambda x: x.ratio or 0, reverse=True)
+    underused.sort(key=lambda x: x.ratio or float("inf"))
+    # Sort not_in_bnc by observed count
+    not_in_bnc.sort(key=lambda x: x.observed, reverse=True)
+
+    return BNCFrequencyResult(
+        overused=overused,
+        underused=underused,
+        not_in_bnc=not_in_bnc,
+        total_tokens=total_tokens,
+        unique_tokens=len(unique_words),
+        overuse_threshold=overuse_threshold,
+        underuse_threshold=underuse_threshold,
+        metadata={
+            "include_wordnet": include_wordnet,
+            "min_mentions": min_mentions,
+            "overused_count": len(overused),
+            "underused_count": len(underused),
+            "not_in_bnc_count": len(not_in_bnc),
+        },
+    )

pystylometry/viz/jsx/__init__.py

@@ -20,6 +20,7 @@ Example:
     >>> export_drift_viewer("drift_analyzer.html")
 """
 
+from .bnc_frequency import export_bnc_frequency_jsx
 from .report import export_drift_report_jsx
 from .timeline import export_drift_timeline_jsx
 from .viewer import export_drift_viewer
@@ -28,4 +29,5 @@ __all__ = [
     "export_drift_timeline_jsx",
     "export_drift_report_jsx",
     "export_drift_viewer",
+    "export_bnc_frequency_jsx",
 ]

pystylometry/viz/jsx/bnc_frequency.py

@@ -0,0 +1,495 @@
+"""Interactive HTML export for BNC frequency analysis.
+
+This module generates a self-contained HTML report showing word frequency
+comparisons against the British National Corpus (BNC).
+
+The report has three sections:
+1. Not in BNC - Words not found in the corpus (with WordNet and character type info)
+2. Most Underused - Words appearing less frequently than expected
+3. Most Overused - Words appearing more frequently than expected
+
+Related GitHub Issue:
+    #TBD - BNC frequency analysis CLI
+    https://github.com/craigtrim/pystylometry/issues/TBD
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from ._base import CARD_STYLES, generate_html_document, write_html_file
+
+if TYPE_CHECKING:
+    from pystylometry.lexical.bnc_frequency import BNCFrequencyResult
+
+
+def export_bnc_frequency_jsx(
+    result: "BNCFrequencyResult",
+    output_file: str | Path,
+    title: str = "BNC Word Frequency Analysis",
+    source_file: str | None = None,
+) -> Path:
+    """Export BNC frequency analysis as interactive HTML.
+
+    Generates a self-contained HTML file with three sections:
+    - Not in BNC: Complete table with WordNet status and character type
+    - Most Underused: Words below the underuse threshold
+    - Most Overused: Words above the overuse threshold
+
+    Args:
+        result: BNCFrequencyResult from compute_bnc_frequency()
+        output_file: Path to write the HTML file
+        title: Page title (default: "BNC Word Frequency Analysis")
+        source_file: Optional source filename to display
+
+    Returns:
+        Path to the written HTML file
+
+    Example:
+        >>> from pystylometry.lexical.bnc_frequency import compute_bnc_frequency
+        >>> from pystylometry.viz.jsx import export_bnc_frequency_jsx
+        >>> result = compute_bnc_frequency(text)
+        >>> export_bnc_frequency_jsx(result, "frequency_report.html")
+    """
+    # Build data for the React component
+    not_in_bnc_data = [
+        {
+            "word": w.word,
+            "observed": w.observed,
+            "inWordnet": w.in_wordnet,
+            "charType": w.char_type,
+        }
+        for w in result.not_in_bnc
+    ]
+
+    underused_data = [
+        {
+            "word": w.word,
+            "observed": w.observed,
+            "expected": round(w.expected, 2) if w.expected else None,
+            "ratio": round(w.ratio, 4) if w.ratio else None,
+            "charType": w.char_type,
+        }
+        for w in result.underused
+    ]
+
+    overused_data = [
+        {
+            "word": w.word,
+            "observed": w.observed,
+            "expected": round(w.expected, 2) if w.expected else None,
+            "ratio": round(w.ratio, 1) if w.ratio else None,
+            "charType": w.char_type,
+        }
+        for w in result.overused
+    ]
+
+    config = {
+        "title": title,
+        "sourceFile": source_file,
+        "notInBnc": not_in_bnc_data,
+        "underused": underused_data,
+        "overused": overused_data,
+        "stats": {
+            "totalTokens": result.total_tokens,
+            "uniqueTokens": result.unique_tokens,
+            "notInBncCount": len(result.not_in_bnc),
+            "underusedCount": len(result.underused),
+            "overusedCount": len(result.overused),
+            "overuseThreshold": result.overuse_threshold,
+            "underuseThreshold": result.underuse_threshold,
+        },
+    }
+
+    react_component = """
+    // Color mapping for character types
+    const CHAR_TYPE_COLORS = {
+      latin: { bg: '#dcfce7', text: '#166534', label: 'Latin' },
+      unicode: { bg: '#fef3c7', text: '#92400e', label: 'Unicode' },
+      numeric: { bg: '#dbeafe', text: '#1e40af', label: 'Numeric' },
+      mixed: { bg: '#f3e8ff', text: '#6b21a8', label: 'Mixed' },
+      punctuation: { bg: '#f1f5f9', text: '#475569', label: 'Punct' },
+    };
+
+    // Tab configuration
+    const TABS = [
+      { id: 'overused', label: 'Most Overused', color: '#ef4444' },
+      { id: 'underused', label: 'Most Underused', color: '#3b82f6' },
+      { id: 'notInBnc', label: 'Not in BNC', color: '#6b7280' },
+    ];
+
+    // WordNet status badge
+    function WordnetBadge({ inWordnet }) {
+      if (inWordnet === null || inWordnet === undefined) {
+        return <span style={{ color: '#9ca3af', fontSize: '12px' }}>—</span>;
+      }
+      return inWordnet ? (
+        <span style={{
+          background: '#dcfce7',
+          color: '#166534',
+          padding: '2px 8px',
+          borderRadius: '9999px',
+          fontSize: '11px',
+          fontWeight: 500,
+        }}>Yes</span>
+      ) : (
+        <span style={{
+          background: '#fee2e2',
+          color: '#991b1b',
+          padding: '2px 8px',
+          borderRadius: '9999px',
+          fontSize: '11px',
+          fontWeight: 500,
+        }}>No</span>
+      );
+    }
+
+    // Character type badge
+    function CharTypeBadge({ charType }) {
+      const config = CHAR_TYPE_COLORS[charType] || CHAR_TYPE_COLORS.mixed;
+      return (
+        <span style={{
+          background: config.bg,
+          color: config.text,
+          padding: '2px 8px',
+          borderRadius: '9999px',
+          fontSize: '11px',
+          fontWeight: 500,
+        }}>{config.label}</span>
+      );
+    }
+
+    // Ratio display with color intensity
+    function RatioDisplay({ ratio, isOverused }) {
+      if (ratio === null || ratio === undefined) return '—';
+
+      let color, intensity;
+      if (isOverused) {
+        intensity = Math.min(Math.log2(ratio) / 6, 1);
+        const r = 239;
+        const g = Math.round(68 + (1 - intensity) * 120);
+        color = `rgb(${r}, ${g}, 68)`;
+      } else {
+        intensity = Math.min(Math.abs(Math.log2(ratio)) / 4, 1);
+        const b = 246;
+        const g = Math.round(130 + (1 - intensity) * 60);
+        color = `rgb(59, ${g}, ${b})`;
+      }
+
+      const displayValue = isOverused ? ratio.toFixed(1) + 'x' : ratio.toFixed(4);
+
+      return (
+        <span style={{
+          color: color,
+          fontWeight: 600,
+          fontFamily: 'ui-monospace, monospace',
+        }}>{displayValue}</span>
+      );
+    }
+
+    // Stats summary card
+    function StatsCard({ stats, activeTab, onTabChange }) {
+      return (
+        <div className="card" style={{ marginBottom: '24px' }}>
+          <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(120px, 1fr))', gap: '16px' }}>
+            <div>
+              <div style={{ fontSize: '11px', color: '#6b7280', marginBottom: '4px' }}>Total Tokens</div>
+              <div style={{ fontSize: '20px', fontWeight: 600 }}>{stats.totalTokens.toLocaleString()}</div>
+            </div>
+            <div>
+              <div style={{ fontSize: '11px', color: '#6b7280', marginBottom: '4px' }}>Unique Words</div>
+              <div style={{ fontSize: '20px', fontWeight: 600 }}>{stats.uniqueTokens.toLocaleString()}</div>
+            </div>
+            {TABS.map(tab => (
+              <div
+                key={tab.id}
+                onClick={() => onTabChange(tab.id)}
+                style={{
+                  cursor: 'pointer',
+                  padding: '8px',
+                  margin: '-8px',
+                  borderRadius: '8px',
+                  background: activeTab === tab.id ? `${tab.color}10` : 'transparent',
+                  border: activeTab === tab.id ? `2px solid ${tab.color}` : '2px solid transparent',
+                  transition: 'all 0.15s',
+                }}
+              >
+                <div style={{ fontSize: '11px', color: '#6b7280', marginBottom: '4px' }}>{tab.label}</div>
+                <div style={{ fontSize: '20px', fontWeight: 600, color: tab.color }}>
+                  {tab.id === 'overused' ? stats.overusedCount.toLocaleString() :
+                   tab.id === 'underused' ? stats.underusedCount.toLocaleString() :
+                   stats.notInBncCount.toLocaleString()}
+                </div>
+              </div>
+            ))}
+          </div>
+        </div>
+      );
+    }
+
+    // Tab bar component
+    function TabBar({ activeTab, onTabChange, stats }) {
+      return (
+        <div style={{ display: 'flex', gap: '4px', marginBottom: '16px', borderBottom: '2px solid #e2e8f0', paddingBottom: '0' }}>
+          {TABS.map(tab => {
+            const count = tab.id === 'overused' ? stats.overusedCount :
+                          tab.id === 'underused' ? stats.underusedCount :
+                          stats.notInBncCount;
+            const isActive = activeTab === tab.id;
+            return (
+              <button
+                key={tab.id}
+                onClick={() => onTabChange(tab.id)}
+                style={{
+                  padding: '12px 20px',
+                  border: 'none',
+                  background: 'transparent',
+                  cursor: 'pointer',
+                  fontSize: '14px',
+                  fontWeight: isActive ? 600 : 500,
+                  color: isActive ? tab.color : '#6b7280',
+                  borderBottom: isActive ? `3px solid ${tab.color}` : '3px solid transparent',
+                  marginBottom: '-2px',
+                  transition: 'all 0.15s',
+                }}
+              >
+                {tab.label}
+                <span style={{
+                  marginLeft: '8px',
+                  padding: '2px 8px',
+                  borderRadius: '9999px',
+                  fontSize: '12px',
+                  background: isActive ? `${tab.color}20` : '#f1f5f9',
+                  color: isActive ? tab.color : '#6b7280',
+                }}>{count.toLocaleString()}</span>
+              </button>
+            );
+          })}
+        </div>
+      );
+    }
+
+    // Data table component
+    function DataTable({ data, columns, emptyMessage, filter, onFilterChange }) {
+      const [sortKey, setSortKey] = React.useState(null);
+      const [sortDir, setSortDir] = React.useState('desc');
+
+      const filteredData = React.useMemo(() => {
+        if (!filter) return data;
+        const lowerFilter = filter.toLowerCase();
+        return data.filter(row => row.word.toLowerCase().includes(lowerFilter));
+      }, [data, filter]);
+
+      const sortedData = React.useMemo(() => {
+        if (!sortKey) return filteredData;
+        return [...filteredData].sort((a, b) => {
+          let aVal = a[sortKey];
+          let bVal = b[sortKey];
+          if (aVal === null || aVal === undefined) aVal = sortDir === 'desc' ? -Infinity : Infinity;
+          if (bVal === null || bVal === undefined) bVal = sortDir === 'desc' ? -Infinity : Infinity;
+          if (typeof aVal === 'string') {
+            return sortDir === 'desc' ? bVal.localeCompare(aVal) : aVal.localeCompare(bVal);
+          }
+          return sortDir === 'desc' ? bVal - aVal : aVal - bVal;
+        });
+      }, [filteredData, sortKey, sortDir]);
+
+      const handleSort = (key) => {
+        if (sortKey === key) {
+          setSortDir(sortDir === 'desc' ? 'asc' : 'desc');
+        } else {
+          setSortKey(key);
+          setSortDir('desc');
+        }
+      };
+
+      return (
+        <div>
+          <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '12px' }}>
+            <span style={{ fontSize: '13px', color: '#6b7280' }}>{sortedData.length} words</span>
+            <input
+              type="text"
+              placeholder="Filter words..."
+              value={filter}
+              onChange={(e) => onFilterChange(e.target.value)}
+              style={{
+                padding: '8px 12px',
+                border: '1px solid #e2e8f0',
+                borderRadius: '6px',
+                fontSize: '13px',
+                width: '200px',
+              }}
+            />
+          </div>
+
+          {sortedData.length === 0 ? (
+            <div style={{ padding: '48px', textAlign: 'center', color: '#9ca3af' }}>
+              {filter ? 'No matching words' : emptyMessage}
+            </div>
+          ) : (
+            <div style={{ overflowX: 'auto', maxHeight: '600px', overflowY: 'auto' }}>
+              <table style={{ width: '100%', borderCollapse: 'collapse', fontSize: '13px' }}>
+                <thead style={{ position: 'sticky', top: 0, background: 'white' }}>
+                  <tr style={{ borderBottom: '2px solid #e2e8f0' }}>
+                    {columns.map(col => (
+                      <th
+                        key={col.key}
+                        onClick={() => col.sortable !== false && handleSort(col.key)}
+                        style={{
+                          textAlign: col.align || 'left',
+                          padding: '10px 12px',
+                          fontWeight: 600,
+                          color: '#374151',
+                          cursor: col.sortable !== false ? 'pointer' : 'default',
+                          userSelect: 'none',
+                          whiteSpace: 'nowrap',
+                          background: 'white',
+                        }}
+                      >
+                        {col.label}
+                        {sortKey === col.key && (
+                          <span style={{ marginLeft: '4px' }}>{sortDir === 'desc' ? '↓' : '↑'}</span>
+                        )}
+                      </th>
+                    ))}
+                  </tr>
+                </thead>
+                <tbody>
+                  {sortedData.map((row, idx) => (
+                    <tr key={idx} style={{ borderBottom: '1px solid #f1f5f9' }}>
+                      {columns.map(col => (
+                        <td key={col.key} style={{ padding: '10px 12px', textAlign: col.align || 'left' }}>
+                          {col.render ? col.render(row[col.key], row) : row[col.key]}
+                        </td>
+                      ))}
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          )}
+        </div>
+      );
+    }
+
+    // Main component
+    function BNCFrequencyReport() {
+      const { title, sourceFile, notInBnc, underused, overused, stats } = CONFIG;
+      const [activeTab, setActiveTab] = React.useState('overused');
+      const [filter, setFilter] = React.useState('');
+
+      // Reset filter when tab changes
+      const handleTabChange = (tab) => {
+        setActiveTab(tab);
+        setFilter('');
+      };
+
+      // Column definitions
+      const notInBncColumns = [
+        { key: 'word', label: 'Word', render: (v) => <code style={{ background: '#f1f5f9', padding: '2px 6px', borderRadius: '4px' }}>{v}</code> },
+        { key: 'observed', label: 'Mentions', align: 'right' },
+        { key: 'inWordnet', label: 'In WordNet', align: 'center', render: (v) => <WordnetBadge inWordnet={v} />, sortable: false },
+        { key: 'charType', label: 'Char Type', align: 'center', render: (v) => <CharTypeBadge charType={v} />, sortable: false },
+      ];
+
+      const frequencyColumns = (isOverused) => [
+        { key: 'word', label: 'Word', render: (v) => <code style={{ background: '#f1f5f9', padding: '2px 6px', borderRadius: '4px' }}>{v}</code> },
+        { key: 'observed', label: 'Observed', align: 'right' },
+        { key: 'expected', label: 'Expected', align: 'right', render: (v) => v !== null ? v.toFixed(2) : '—' },
+        { key: 'ratio', label: 'Ratio', align: 'right', render: (v) => <RatioDisplay ratio={v} isOverused={isOverused} /> },
+        { key: 'charType', label: 'Char Type', align: 'center', render: (v) => <CharTypeBadge charType={v} />, sortable: false },
+      ];
+
+      const getTabContent = () => {
+        switch (activeTab) {
+          case 'overused':
+            return (
+              <DataTable
+                data={overused}
+                columns={frequencyColumns(true)}
+                emptyMessage="No significantly overused words"
+                filter={filter}
+                onFilterChange={setFilter}
+              />
+            );
+          case 'underused':
+            return (
+              <DataTable
+                data={underused}
+                columns={frequencyColumns(false)}
+                emptyMessage="No significantly underused words"
+                filter={filter}
+                onFilterChange={setFilter}
+              />
+            );
+          case 'notInBnc':
+            return (
+              <DataTable
+                data={notInBnc}
+                columns={notInBncColumns}
+                emptyMessage="All words found in BNC"
+                filter={filter}
+                onFilterChange={setFilter}
+              />
+            );
+        }
+      };
+
+      return (
+        <div>
+          <div style={{ marginBottom: '24px' }}>
+            <h1 style={{ margin: '0 0 8px', fontSize: '24px', fontWeight: 600 }}>{title}</h1>
+            {sourceFile && (
+              <div style={{ fontSize: '14px', color: '#6b7280' }}>
+                Source: <code style={{ background: '#f1f5f9', padding: '2px 6px', borderRadius: '4px' }}>{sourceFile}</code>
+              </div>
+            )}
+          </div>
+
+          <StatsCard stats={stats} activeTab={activeTab} onTabChange={handleTabChange} />
+
+          <div className="card">
+            <TabBar activeTab={activeTab} onTabChange={handleTabChange} stats={stats} />
+            {getTabContent()}
+          </div>
+
+          <div style={{ marginTop: '24px', padding: '16px', background: '#f8fafc', borderRadius: '8px', fontSize: '12px', color: '#6b7280' }}>
+            <strong>About this analysis:</strong> Word frequencies are compared against the British National Corpus (BNC),
+            a 100-million word collection of British English. Ratios indicate how much more (or less) frequently
+            a word appears in this text compared to typical usage. Words not in BNC may be proper nouns,
+            technical terms, neologisms, or OCR errors.
+          </div>
+        </div>
+      );
+    }
+    """
+
+    extra_styles = (
+        CARD_STYLES
+        + """
+    code {
+      font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    }
+    table {
+      font-variant-numeric: tabular-nums;
+    }
+    input:focus {
+      outline: 2px solid #3b82f6;
+      outline-offset: -1px;
+    }
+    tr:hover {
+      background: #f8fafc;
+    }
+    """
+    )
+
+    html = generate_html_document(
+        title=title,
+        config=config,
+        react_component=react_component,
+        component_name="BNCFrequencyReport",
+        extra_styles=extra_styles,
+    )
+
+    return write_html_file(output_file, html)

{pystylometry-1.3.5.dist-info → pystylometry-1.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pystylometry
-Version: 1.3.5
+Version: 1.3.6
 Summary: Comprehensive Python package for stylometric analysis
 License: MIT
 Keywords: stylometry,nlp,text-analysis,authorship,readability,lexical-diversity,readability-metrics
@@ -19,6 +19,20 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Text Processing :: Linguistic
 Classifier: Typing :: Typed
+Provides-Extra: all
+Provides-Extra: excel
+Provides-Extra: lexical
+Provides-Extra: readability
+Provides-Extra: syntactic
+Provides-Extra: viz
+Requires-Dist: bnc-lookup (>=1.3.2) ; extra == "lexical" or extra == "all"
+Requires-Dist: matplotlib (>=3.8.0,<4.0.0) ; extra == "viz" or extra == "all"
+Requires-Dist: openpyxl (>=3.1.0,<4.0.0) ; extra == "lexical" or extra == "excel" or extra == "all"
+Requires-Dist: pronouncing (>=0.2.0,<0.3.0) ; extra == "readability" or extra == "all"
+Requires-Dist: rich (>=13.0,<14.0)
+Requires-Dist: seaborn (>=0.13.0,<0.14.0) ; extra == "viz" or extra == "all"
+Requires-Dist: spacy (>=3.8.0,<4.0.0) ; extra == "readability" or extra == "syntactic" or extra == "all"
+Requires-Dist: wordnet-lookup ; extra == "lexical" or extra == "all"
 Project-URL: Homepage, https://github.com/craigtrim/pystylometry
 Project-URL: Issues, https://github.com/craigtrim/pystylometry/issues
 Project-URL: Repository, https://github.com/craigtrim/pystylometry

{pystylometry-1.3.5.dist-info → pystylometry-1.3.6.dist-info}/RECORD

@@ -13,7 +13,7 @@ pystylometry/authorship/zeta.py,sha256=oOi9Y6ZPq15ILLVl6So9O9ERvzig26en6_dpQJWeo
 pystylometry/character/README.md,sha256=poQwhbI8MabVD_626CWjEL87IOX5YDGS0ZJTH1hNwEE,607
 pystylometry/character/__init__.py,sha256=CiiKJmZ10UJE8qAecavpOKyw-vGonsOew_mFH34ZOC0,371
 pystylometry/character/character_metrics.py,sha256=OCIGP_ivtwtzcifcxcbmp2R5SIKh2tKyvKcHAv64S8g,14029
-pystylometry/cli.py,sha256=HvzBZxFSiS5AAXCb6N9Eo3QonkH-ucRFp6xDF1kJTQ0,26380
+pystylometry/cli.py,sha256=NRKuA4oCEJPNPkeSUttZxd0ZVQSn4kh77qOTWfjsgyM,40635
 pystylometry/consistency/README.md,sha256=HG_Rd6WRBnIz3M7J11dVDv1S2ARkMABFYrTn-VV8xRY,1058
 pystylometry/consistency/__init__.py,sha256=l7nzpS7M4yHDBbM2LGAtW0XGT2n7YjSey_1xKf45224,2181
 pystylometry/consistency/_thresholds.py,sha256=5fZwdJ_cnDy0ED7CCYs6V_zP6kIAR1p0h0NYkbZ0HRg,6381
@@ -24,8 +24,9 @@ pystylometry/dialect/_data/dialect_markers.json,sha256=DthluOA6q0rG_8IrCrFIYWh_E
 pystylometry/dialect/_loader.py,sha256=M2ATp-5754v_yX9EWvBP0r5qgNf8xlL8XadVsVb_Hco,12989
 pystylometry/dialect/detector.py,sha256=9x0ZuIfTIjsmdNSx0Ezy5AC0SAFtC4kVw11iOSBd9gQ,20147
 pystylometry/lexical/README.md,sha256=cFQ7KRZV4ubsQwIlOH3YHTbhhNl5X91Sr3zcn-3x0HI,1185
-pystylometry/lexical/__init__.py,sha256=ib_F-NGVydLNGT_HgaWurBT25AadTE4eNcAN1lGMKmQ,934
+pystylometry/lexical/__init__.py,sha256=p5vYmHSr_kUHC2Vpng8ObncLs10cdb6s3P23DPmwzoc,1012
 pystylometry/lexical/advanced_diversity.py,sha256=rL1hlNqTnaEFcA2v4oBJlojHZMTqdvvm4jYXTFGVpYE,25664
+pystylometry/lexical/bnc_frequency.py,sha256=m_AEYY4joEwVVbzBYJm9zq2-K7Nix9MLE3l4LHomjig,10580
 pystylometry/lexical/function_words.py,sha256=eel9bq_qWgWlvG0NtDiouilMt9kaFqz2rh3add2UC4U,17832
 pystylometry/lexical/hapax.py,sha256=djTqZyZIYXa3GRiPoy6TTGHPm0wCRNJ9U0Rwnf5NoDk,12173
 pystylometry/lexical/mtld.py,sha256=XpeCF8sOXZhWbaazHGuqm08mrOf_DYfkfGGAltWnyy4,7101
@@ -66,13 +67,14 @@ pystylometry/tokenizer.py,sha256=03FEF4kKp72v-ypbtMg8u0WyVJGk3YJx6Nw3SGzyAnA,181
 pystylometry/viz/README.md,sha256=mizuBpUzWgJqjC2u9C-Lu4sVDCcTQOgGsarRSkeWPf4,1031
 pystylometry/viz/__init__.py,sha256=3kHMAcJJi8oPhTqUZIRdyf311cdyPOHWaJIUv-w0V04,2219
 pystylometry/viz/drift.py,sha256=r98gQ4s_IlrEuaouxDMyue3cTjGqj10i4IeKC01IuCo,18956
-pystylometry/viz/jsx/__init__.py,sha256=ZCgbpMPhG5PiJ92IkJRrZwrb7RodZB9MyauO0MGgbRM,1107
+pystylometry/viz/jsx/__init__.py,sha256=_-BFtPtBhQyBiKJWGPndI-m-3SRBk1JsFombYXYc2Fk,1191
 pystylometry/viz/jsx/_base.py,sha256=nd7kEc13fUcRMom3A5jqjGyTy-djIeydq2k3oPHZIHY,3708
+pystylometry/viz/jsx/bnc_frequency.py,sha256=U8plmMOXMgLuJPMtL5k5MecFAX-5CdnxSLX3mVAmoLY,18391
 pystylometry/viz/jsx/report.py,sha256=DbbHnnNAEi5tmVg4PmiHb17vkBBXujyE4x1CfVBiOBw,25857
 pystylometry/viz/jsx/timeline.py,sha256=hor-xnBa6oVkSqN0AEZUCQFBOB-iTfHSFZHiEfeakPA,30716
 pystylometry/viz/jsx/viewer.py,sha256=3LO49d_2bRf_P-P-2oSKpKx4N8Ugo4oCLb3DtvyNxXI,43716
-pystylometry-1.3.5.dist-info/LICENSE,sha256=vou5JCLAT5nHcsUv-AkjUYAihYfN9mwPDXxV2DHyHBo,1067
-pystylometry-1.3.5.dist-info/METADATA,sha256=DEFzNf_ZQd3mulwOnFMRSyc1s30alGM6UtO-L7nloPc,4779
-pystylometry-1.3.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pystylometry-1.3.5.dist-info/entry_points.txt,sha256=XsJvKgKs3LRDuzdF45JO7ZnS0wGKg1f5qsxVYSZzLp8,165
-pystylometry-1.3.5.dist-info/RECORD,,
+pystylometry-1.3.6.dist-info/LICENSE,sha256=vou5JCLAT5nHcsUv-AkjUYAihYfN9mwPDXxV2DHyHBo,1067
+pystylometry-1.3.6.dist-info/METADATA,sha256=No130TQB2VZMHPz6XD_Z37ZmyT0lC2Y785PSaDkeeZc,5545
+pystylometry-1.3.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pystylometry-1.3.6.dist-info/entry_points.txt,sha256=Gr2keJe638qHrrJpCGZAP3AYduxxIaSCoBH4FwAJt7U,204
+pystylometry-1.3.6.dist-info/RECORD,,

{pystylometry-1.3.5.dist-info → pystylometry-1.3.6.dist-info}/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
+bnc=pystylometry.cli:bnc_frequency_cli
 pystylometry-drift=pystylometry.cli:drift_cli
 pystylometry-tokenize=pystylometry.cli:tokenize_cli
 pystylometry-viewer=pystylometry.cli:viewer_cli