Add thread visualization with interactive D3 force graph

+3 -1

pyproject.toml

··· 39 39 "bleach>=6.0.0", 40 40 "platformdirs>=4.0.0", 41 41 "pyyaml>=6.0.0", 42 - "email_validator" 42 + "email_validator", 43 + "textual>=4.0.0", 44 + "flask>=3.1.1", 43 45 ] 44 46 45 47 [project.optional-dependencies]

+2 -2

src/thicket/cli/commands/__init__.py

··· 1 1 """CLI commands for thicket.""" 2 2 3 3 # Import all commands to register them with the main app 4 - from . import add, duplicates, index_cmd, info_cmd, init, links_cmd, list_cmd, sync 4 + from . import add, duplicates, info_cmd, init, links_cmd, list_cmd, sync, threads_cmd 5 5 6 - __all__ = ["add", "duplicates", "index_cmd", "info_cmd", "init", "links_cmd", "list_cmd", "sync"] 6 + __all__ = ["add", "duplicates", "info_cmd", "init", "links_cmd", "list_cmd", "sync", "threads_cmd"]

-427

src/thicket/cli/commands/index_cmd.py

··· 1 - """CLI command for building reference index from blog entries.""" 2 - 3 - import json 4 - from pathlib import Path 5 - from typing import Optional 6 - 7 - import typer 8 - from rich.console import Console 9 - from rich.progress import ( 10 - BarColumn, 11 - Progress, 12 - SpinnerColumn, 13 - TaskProgressColumn, 14 - TextColumn, 15 - ) 16 - from rich.table import Table 17 - 18 - from ...core.git_store import GitStore 19 - from ...core.reference_parser import ReferenceIndex, ReferenceParser 20 - from ..main import app 21 - from ..utils import get_tsv_mode, load_config 22 - 23 - console = Console() 24 - 25 - 26 - @app.command() 27 - def index( 28 - config_file: Optional[Path] = typer.Option( 29 - None, 30 - "--config", 31 - "-c", 32 - help="Path to configuration file", 33 - ), 34 - output_file: Optional[Path] = typer.Option( 35 - None, 36 - "--output", 37 - "-o", 38 - help="Path to output index file (default: updates links.json in git store)", 39 - ), 40 - verbose: bool = typer.Option( 41 - False, 42 - "--verbose", 43 - "-v", 44 - help="Show detailed progress information", 45 - ), 46 - ) -> None: 47 - """Build a reference index showing which blog entries reference others. 48 - 49 - This command analyzes all blog entries to detect cross-references between 50 - different blogs, creating an index that can be used to build threaded 51 - views of related content. 52 - 53 - Updates the unified links.json file with reference data. 54 - """ 55 - try: 56 - # Load configuration 57 - config = load_config(config_file) 58 - 59 - # Initialize Git store 60 - git_store = GitStore(config.git_store) 61 - 62 - # Initialize reference parser 63 - parser = ReferenceParser() 64 - 65 - # Build user domain mapping 66 - if verbose: 67 - console.print("Building user domain mapping...") 68 - user_domains = parser.build_user_domain_mapping(git_store) 69 - 70 - if verbose: 71 - console.print(f"Found {len(user_domains)} users with {sum(len(d) for d in user_domains.values())} total domains") 72 - 73 - # Initialize reference index 74 - ref_index = ReferenceIndex() 75 - ref_index.user_domains = user_domains 76 - 77 - # Get all users 78 - index = git_store._load_index() 79 - users = list(index.users.keys()) 80 - 81 - if not users: 82 - console.print("[yellow]No users found in Git store[/yellow]") 83 - raise typer.Exit(0) 84 - 85 - # Process all entries 86 - total_entries = 0 87 - total_references = 0 88 - all_references = [] 89 - 90 - with Progress( 91 - SpinnerColumn(), 92 - TextColumn("[progress.description]{task.description}"), 93 - BarColumn(), 94 - TaskProgressColumn(), 95 - console=console, 96 - ) as progress: 97 - 98 - # Count total entries first 99 - counting_task = progress.add_task("Counting entries...", total=len(users)) 100 - entry_counts = {} 101 - for username in users: 102 - entries = git_store.list_entries(username) 103 - entry_counts[username] = len(entries) 104 - total_entries += len(entries) 105 - progress.advance(counting_task) 106 - 107 - progress.remove_task(counting_task) 108 - 109 - # Process entries - extract references 110 - processing_task = progress.add_task( 111 - f"Extracting references from {total_entries} entries...", 112 - total=total_entries 113 - ) 114 - 115 - for username in users: 116 - entries = git_store.list_entries(username) 117 - 118 - for entry in entries: 119 - # Extract references from this entry 120 - references = parser.extract_references(entry, username, user_domains) 121 - all_references.extend(references) 122 - 123 - progress.advance(processing_task) 124 - 125 - if verbose and references: 126 - console.print(f" Found {len(references)} references in {username}:{entry.title[:50]}...") 127 - 128 - progress.remove_task(processing_task) 129 - 130 - # Resolve target_entry_ids for references 131 - if all_references: 132 - resolve_task = progress.add_task( 133 - f"Resolving {len(all_references)} references...", 134 - total=len(all_references) 135 - ) 136 - 137 - if verbose: 138 - console.print(f"Resolving target entry IDs for {len(all_references)} references...") 139 - 140 - resolved_references = parser.resolve_target_entry_ids(all_references, git_store) 141 - 142 - # Count resolved references 143 - resolved_count = sum(1 for ref in resolved_references if ref.target_entry_id is not None) 144 - if verbose: 145 - console.print(f"Resolved {resolved_count} out of {len(all_references)} references") 146 - 147 - # Add resolved references to index 148 - for ref in resolved_references: 149 - ref_index.add_reference(ref) 150 - total_references += 1 151 - progress.advance(resolve_task) 152 - 153 - progress.remove_task(resolve_task) 154 - 155 - # Determine output path 156 - if output_file: 157 - output_path = output_file 158 - else: 159 - output_path = config.git_store / "links.json" 160 - 161 - # Load existing links data or create new structure 162 - if output_path.exists() and not output_file: 163 - # Load existing unified structure 164 - with open(output_path) as f: 165 - existing_data = json.load(f) 166 - else: 167 - # Create new structure 168 - existing_data = { 169 - "links": {}, 170 - "reverse_mapping": {}, 171 - "user_domains": {} 172 - } 173 - 174 - # Update with reference data 175 - existing_data["references"] = ref_index.to_dict()["references"] 176 - existing_data["user_domains"] = {k: list(v) for k, v in user_domains.items()} 177 - 178 - # Save updated structure 179 - with open(output_path, "w") as f: 180 - json.dump(existing_data, f, indent=2, default=str) 181 - 182 - # Show summary 183 - if not get_tsv_mode(): 184 - console.print("\n[green]✓ Reference index built successfully[/green]") 185 - 186 - # Create summary table or TSV output 187 - if get_tsv_mode(): 188 - print("Metric\tCount") 189 - print(f"Total Users\t{len(users)}") 190 - print(f"Total Entries\t{total_entries}") 191 - print(f"Total References\t{total_references}") 192 - print(f"Outbound Refs\t{len(ref_index.outbound_refs)}") 193 - print(f"Inbound Refs\t{len(ref_index.inbound_refs)}") 194 - print(f"Output File\t{output_path}") 195 - else: 196 - table = Table(title="Reference Index Summary") 197 - table.add_column("Metric", style="cyan") 198 - table.add_column("Count", style="green") 199 - 200 - table.add_row("Total Users", str(len(users))) 201 - table.add_row("Total Entries", str(total_entries)) 202 - table.add_row("Total References", str(total_references)) 203 - table.add_row("Outbound Refs", str(len(ref_index.outbound_refs))) 204 - table.add_row("Inbound Refs", str(len(ref_index.inbound_refs))) 205 - table.add_row("Output File", str(output_path)) 206 - 207 - console.print(table) 208 - 209 - # Show some interesting statistics 210 - if total_references > 0: 211 - if not get_tsv_mode(): 212 - console.print("\n[bold]Reference Statistics:[/bold]") 213 - 214 - # Most referenced users 215 - target_counts = {} 216 - unresolved_domains = set() 217 - 218 - for ref in ref_index.references: 219 - if ref.target_username: 220 - target_counts[ref.target_username] = target_counts.get(ref.target_username, 0) + 1 221 - else: 222 - # Track unresolved domains 223 - from urllib.parse import urlparse 224 - domain = urlparse(ref.target_url).netloc.lower() 225 - unresolved_domains.add(domain) 226 - 227 - if target_counts: 228 - if get_tsv_mode(): 229 - print("Referenced User\tReference Count") 230 - for username, count in sorted(target_counts.items(), key=lambda x: x[1], reverse=True)[:5]: 231 - print(f"{username}\t{count}") 232 - else: 233 - console.print("\nMost referenced users:") 234 - for username, count in sorted(target_counts.items(), key=lambda x: x[1], reverse=True)[:5]: 235 - console.print(f" {username}: {count} references") 236 - 237 - if unresolved_domains and verbose: 238 - if get_tsv_mode(): 239 - print("Unresolved Domain\tCount") 240 - for domain in sorted(list(unresolved_domains)[:10]): 241 - print(f"{domain}\t1") 242 - if len(unresolved_domains) > 10: 243 - print(f"... and {len(unresolved_domains) - 10} more\t...") 244 - else: 245 - console.print(f"\nUnresolved domains: {len(unresolved_domains)}") 246 - for domain in sorted(list(unresolved_domains)[:10]): 247 - console.print(f" {domain}") 248 - if len(unresolved_domains) > 10: 249 - console.print(f" ... and {len(unresolved_domains) - 10} more") 250 - 251 - except Exception as e: 252 - console.print(f"[red]Error building reference index: {e}[/red]") 253 - if verbose: 254 - console.print_exception() 255 - raise typer.Exit(1) 256 - 257 - 258 - @app.command() 259 - def threads( 260 - config_file: Optional[Path] = typer.Option( 261 - None, 262 - "--config", 263 - "-c", 264 - help="Path to configuration file", 265 - ), 266 - index_file: Optional[Path] = typer.Option( 267 - None, 268 - "--index", 269 - "-i", 270 - help="Path to reference index file (default: links.json in git store)", 271 - ), 272 - username: Optional[str] = typer.Option( 273 - None, 274 - "--username", 275 - "-u", 276 - help="Show threads for specific username only", 277 - ), 278 - entry_id: Optional[str] = typer.Option( 279 - None, 280 - "--entry", 281 - "-e", 282 - help="Show thread for specific entry ID", 283 - ), 284 - min_size: int = typer.Option( 285 - 2, 286 - "--min-size", 287 - "-m", 288 - help="Minimum thread size to display", 289 - ), 290 - ) -> None: 291 - """Show threaded view of related blog entries. 292 - 293 - This command uses the reference index to show which blog entries 294 - are connected through cross-references, creating an email-style 295 - threaded view of the conversation. 296 - 297 - Reads reference data from the unified links.json file. 298 - """ 299 - try: 300 - # Load configuration 301 - config = load_config(config_file) 302 - 303 - # Determine index file path 304 - if index_file: 305 - index_path = index_file 306 - else: 307 - index_path = config.git_store / "links.json" 308 - 309 - if not index_path.exists(): 310 - console.print(f"[red]Links file not found: {index_path}[/red]") 311 - console.print("Run 'thicket links' and 'thicket index' first to build the reference index") 312 - raise typer.Exit(1) 313 - 314 - # Load unified data 315 - with open(index_path) as f: 316 - unified_data = json.load(f) 317 - 318 - # Check if references exist in the unified structure 319 - if "references" not in unified_data: 320 - console.print(f"[red]No references found in {index_path}[/red]") 321 - console.print("Run 'thicket index' first to build the reference index") 322 - raise typer.Exit(1) 323 - 324 - # Extract reference data and reconstruct ReferenceIndex 325 - ref_index = ReferenceIndex.from_dict({ 326 - "references": unified_data["references"], 327 - "user_domains": unified_data.get("user_domains", {}) 328 - }) 329 - 330 - # Initialize Git store to get entry details 331 - git_store = GitStore(config.git_store) 332 - 333 - if entry_id and username: 334 - # Show specific thread 335 - thread_members = ref_index.get_thread_members(username, entry_id) 336 - _display_thread(thread_members, ref_index, git_store, f"Thread for {username}:{entry_id}") 337 - 338 - elif username: 339 - # Show all threads involving this user 340 - user_index = git_store._load_index() 341 - user = user_index.get_user(username) 342 - if not user: 343 - console.print(f"[red]User not found: {username}[/red]") 344 - raise typer.Exit(1) 345 - 346 - entries = git_store.list_entries(username) 347 - threads_found = set() 348 - 349 - console.print(f"[bold]Threads involving {username}:[/bold]\n") 350 - 351 - for entry in entries: 352 - thread_members = ref_index.get_thread_members(username, entry.id) 353 - if len(thread_members) >= min_size: 354 - thread_key = tuple(sorted(thread_members)) 355 - if thread_key not in threads_found: 356 - threads_found.add(thread_key) 357 - _display_thread(thread_members, ref_index, git_store, f"Thread #{len(threads_found)}") 358 - 359 - else: 360 - # Show all threads 361 - console.print("[bold]All conversation threads:[/bold]\n") 362 - 363 - all_threads = set() 364 - processed_entries = set() 365 - 366 - # Get all entries 367 - user_index = git_store._load_index() 368 - for username in user_index.users.keys(): 369 - entries = git_store.list_entries(username) 370 - for entry in entries: 371 - entry_key = (username, entry.id) 372 - if entry_key in processed_entries: 373 - continue 374 - 375 - thread_members = ref_index.get_thread_members(username, entry.id) 376 - if len(thread_members) >= min_size: 377 - thread_key = tuple(sorted(thread_members)) 378 - if thread_key not in all_threads: 379 - all_threads.add(thread_key) 380 - _display_thread(thread_members, ref_index, git_store, f"Thread #{len(all_threads)}") 381 - 382 - # Mark all members as processed 383 - for member in thread_members: 384 - processed_entries.add(member) 385 - 386 - if not all_threads: 387 - console.print("[yellow]No conversation threads found[/yellow]") 388 - console.print(f"(minimum thread size: {min_size})") 389 - 390 - except Exception as e: 391 - console.print(f"[red]Error showing threads: {e}[/red]") 392 - raise typer.Exit(1) 393 - 394 - 395 - def _display_thread(thread_members, ref_index, git_store, title): 396 - """Display a single conversation thread.""" 397 - console.print(f"[bold cyan]{title}[/bold cyan]") 398 - console.print(f"Thread size: {len(thread_members)} entries") 399 - 400 - # Get entry details for each member 401 - thread_entries = [] 402 - for username, entry_id in thread_members: 403 - entry = git_store.get_entry(username, entry_id) 404 - if entry: 405 - thread_entries.append((username, entry)) 406 - 407 - # Sort by publication date 408 - thread_entries.sort(key=lambda x: x[1].published or x[1].updated) 409 - 410 - # Display entries 411 - for i, (username, entry) in enumerate(thread_entries): 412 - prefix = "├─" if i < len(thread_entries) - 1 else "└─" 413 - 414 - # Get references for this entry 415 - outbound = ref_index.get_outbound_refs(username, entry.id) 416 - inbound = ref_index.get_inbound_refs(username, entry.id) 417 - 418 - ref_info = "" 419 - if outbound or inbound: 420 - ref_info = f" ({len(outbound)} out, {len(inbound)} in)" 421 - 422 - console.print(f" {prefix} [{username}] {entry.title[:60]}...{ref_info}") 423 - 424 - if entry.published: 425 - console.print(f" Published: {entry.published.strftime('%Y-%m-%d')}") 426 - 427 - console.print() # Empty line after each thread

+33 -52

src/thicket/cli/commands/info_cmd.py

··· 1 1 """CLI command for displaying detailed information about a specific atom entry.""" 2 2 3 - import json 4 3 from pathlib import Path 5 4 from typing import Optional 6 5 ··· 11 10 from rich.text import Text 12 11 13 12 from ...core.git_store import GitStore 14 - from ...core.reference_parser import ReferenceIndex 15 13 from ..main import app 16 14 from ..utils import load_config, get_tsv_mode 17 15 ··· 105 103 console.print(f"[red]Entry with {'URL' if is_url else 'atom ID'} '{identifier}' not found in any user's entries[/red]") 106 104 raise typer.Exit(1) 107 105 108 - # Load reference index if available 109 - links_path = config.git_store / "links.json" 110 - ref_index = None 111 - if links_path.exists(): 112 - with open(links_path) as f: 113 - unified_data = json.load(f) 114 - 115 - # Check if references exist in the unified structure 116 - if "references" in unified_data: 117 - ref_index = ReferenceIndex.from_dict({ 118 - "references": unified_data["references"], 119 - "user_domains": unified_data.get("user_domains", {}) 120 - }) 121 - 122 106 # Display information 123 107 if get_tsv_mode(): 124 - _display_entry_info_tsv(entry, found_username, ref_index, show_content) 108 + _display_entry_info_tsv(entry, found_username, show_content) 125 109 else: 126 110 _display_entry_info(entry, found_username) 127 111 128 - if ref_index: 129 - _display_link_info(entry, found_username, ref_index) 130 - else: 131 - console.print("\n[yellow]No reference index found. Run 'thicket links' and 'thicket index' to build cross-reference data.[/yellow]") 112 + # Display links and backlinks from entry fields 113 + _display_link_info(entry, found_username, git_store) 132 114 133 115 # Optionally display content 134 116 if show_content and entry.content: ··· 193 175 console.print(panel) 194 176 195 177 196 - def _display_link_info(entry, username: str, ref_index: ReferenceIndex) -> None: 178 + def _display_link_info(entry, username: str, git_store: GitStore) -> None: 197 179 """Display inbound and outbound link information.""" 198 180 199 - # Get links 200 - outbound_refs = ref_index.get_outbound_refs(username, entry.id) 201 - inbound_refs = ref_index.get_inbound_refs(username, entry.id) 181 + # Get links from entry fields 182 + outbound_links = getattr(entry, 'links', []) 183 + backlinks = getattr(entry, 'backlinks', []) 202 184 203 - if not outbound_refs and not inbound_refs: 185 + if not outbound_links and not backlinks: 204 186 console.print("\n[dim]No cross-references found for this entry.[/dim]") 205 187 return 206 188 207 189 # Create links table 208 190 links_table = Table(title="Cross-References") 209 191 links_table.add_column("Direction", style="cyan", width=10) 210 - links_table.add_column("Target/Source", style="green", width=20) 211 - links_table.add_column("URL", style="blue", width=50) 192 + links_table.add_column("Target/Source", style="green", width=30) 193 + links_table.add_column("URL/ID", style="blue", width=60) 212 194 213 - # Add outbound references 214 - for ref in outbound_refs: 215 - target_info = f"{ref.target_username}:{ref.target_entry_id}" if ref.target_username and ref.target_entry_id else "External" 216 - links_table.add_row("→ Out", target_info, ref.target_url) 195 + # Add outbound links 196 + for link in outbound_links: 197 + links_table.add_row("→ Out", "External/Other", link) 217 198 218 - # Add inbound references 219 - for ref in inbound_refs: 220 - source_info = f"{ref.source_username}:{ref.source_entry_id}" 221 - links_table.add_row("← In", source_info, ref.target_url) 199 + # Add backlinks (inbound references) 200 + for backlink_id in backlinks: 201 + # Try to find which user this entry belongs to 202 + source_info = backlink_id 203 + # Could enhance this by looking up the actual entry to get username 204 + links_table.add_row("← In", "Entry", source_info) 222 205 223 206 console.print() 224 207 console.print(links_table) 225 208 226 209 # Summary 227 - console.print(f"\n[bold]Summary:[/bold] {len(outbound_refs)} outbound, {len(inbound_refs)} inbound references") 210 + console.print(f"\n[bold]Summary:[/bold] {len(outbound_links)} outbound links, {len(backlinks)} inbound backlinks") 228 211 229 212 230 213 def _display_content(content: str) -> None: ··· 246 229 console.print(panel) 247 230 248 231 249 - def _display_entry_info_tsv(entry, username: str, ref_index: Optional[ReferenceIndex], show_content: bool) -> None: 232 + def _display_entry_info_tsv(entry, username: str, show_content: bool) -> None: 250 233 """Display entry information in TSV format.""" 251 234 252 235 # Basic info ··· 287 270 if entry.source: 288 271 print(f"Source Feed\t{entry.source}") 289 272 290 - # Add reference info if available 291 - if ref_index: 292 - outbound_refs = ref_index.get_outbound_refs(username, entry.id) 293 - inbound_refs = ref_index.get_inbound_refs(username, entry.id) 294 - 295 - print(f"Outbound References\t{len(outbound_refs)}") 296 - print(f"Inbound References\t{len(inbound_refs)}") 273 + # Add links info from entry fields 274 + outbound_links = getattr(entry, 'links', []) 275 + backlinks = getattr(entry, 'backlinks', []) 276 + 277 + if outbound_links or backlinks: 278 + print(f"Outbound Links\t{len(outbound_links)}") 279 + print(f"Backlinks\t{len(backlinks)}") 297 280 298 - # Show each reference 299 - for ref in outbound_refs: 300 - target_info = f"{ref.target_username}:{ref.target_entry_id}" if ref.target_username and ref.target_entry_id else "External" 301 - print(f"Outbound Reference\t{target_info}\t{ref.target_url}") 281 + # Show each link 282 + for link in outbound_links: 283 + print(f"→ Link\t{link}") 302 284 303 - for ref in inbound_refs: 304 - source_info = f"{ref.source_username}:{ref.source_entry_id}" 305 - print(f"Inbound Reference\t{source_info}\t{ref.target_url}") 285 + for backlink_id in backlinks: 286 + print(f"← Backlink\t{backlink_id}") 306 287 307 288 # Show content if requested 308 289 if show_content and entry.content:

+204 -289

src/thicket/cli/commands/links_cmd.py

··· 1 1 """CLI command for extracting and categorizing all outbound links from blog entries.""" 2 2 3 - import json 4 3 import re 5 4 from pathlib import Path 6 - from typing import Dict, List, Optional, Set 5 + from typing import Any, Optional 7 6 from urllib.parse import urljoin, urlparse 8 7 9 8 import typer 10 9 from rich.console import Console 11 - from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn 10 + from rich.progress import ( 11 + BarColumn, 12 + Progress, 13 + SpinnerColumn, 14 + TaskProgressColumn, 15 + TextColumn, 16 + ) 12 17 from rich.table import Table 13 18 14 19 from ...core.git_store import GitStore 15 20 from ..main import app 16 - from ..utils import load_config, get_tsv_mode 21 + from ..utils import get_tsv_mode, load_config 17 22 18 23 console = Console() 19 24 20 25 21 - class LinkData: 22 - """Represents a link found in a blog entry.""" 23 - 24 - def __init__(self, url: str, entry_id: str, username: str): 25 - self.url = url 26 - self.entry_id = entry_id 27 - self.username = username 28 - 29 - def to_dict(self) -> dict: 30 - """Convert to dictionary for JSON serialization.""" 31 - return { 32 - "url": self.url, 33 - "entry_id": self.entry_id, 34 - "username": self.username 35 - } 36 - 37 - @classmethod 38 - def from_dict(cls, data: dict) -> "LinkData": 39 - """Create from dictionary.""" 40 - return cls( 41 - url=data["url"], 42 - entry_id=data["entry_id"], 43 - username=data["username"] 44 - ) 45 - 46 - 47 - class LinkCategorizer: 48 - """Categorizes links as internal, user, or unknown.""" 49 - 50 - def __init__(self, user_domains: Dict[str, Set[str]]): 51 - self.user_domains = user_domains 52 - # Create reverse mapping of domain -> username 53 - self.domain_to_user = {} 54 - for username, domains in user_domains.items(): 55 - for domain in domains: 56 - self.domain_to_user[domain] = username 57 - 58 - def categorize_url(self, url: str, source_username: str) -> tuple[str, Optional[str]]: 59 - """ 60 - Categorize a URL as 'internal', 'user', or 'unknown'. 61 - Returns (category, target_username). 62 - """ 63 - try: 64 - parsed = urlparse(url) 65 - domain = parsed.netloc.lower() 66 - 67 - # Check if it's a link to the same user's domain (internal) 68 - if domain in self.user_domains.get(source_username, set()): 69 - return "internal", source_username 70 - 71 - # Check if it's a link to another user's domain 72 - if domain in self.domain_to_user: 73 - return "user", self.domain_to_user[domain] 74 - 75 - # Everything else is unknown 76 - return "unknown", None 77 - 78 - except Exception: 79 - return "unknown", None 80 - 81 - 82 26 class LinkExtractor: 83 27 """Extracts and resolves links from blog entries.""" 84 - 85 - def __init__(self): 28 + 29 + def __init__(self) -> None: 86 30 # Pattern for extracting links from HTML 87 - self.link_pattern = re.compile(r'<a[^>]+href="([^"]+)"[^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL) 31 + self.link_pattern = re.compile( 32 + r'<a[^>]+href="([^"]+)"[^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL 33 + ) 88 34 self.url_pattern = re.compile(r'https?://[^\s<>"]+') 89 - 90 - def extract_links_from_html(self, html_content: str, base_url: str) -> List[tuple[str, str]]: 35 + 36 + def extract_links_from_html( 37 + self, html_content: str, base_url: str 38 + ) -> list[tuple[str, str]]: 91 39 """Extract all links from HTML content and resolve them against base URL.""" 92 40 links = [] 93 - 41 + 94 42 # Extract links from <a> tags 95 43 for match in self.link_pattern.finditer(html_content): 96 44 url = match.group(1) 97 - text = re.sub(r'<[^>]+>', '', match.group(2)).strip() # Remove HTML tags from link text 98 - 45 + text = re.sub( 46 + r"<[^>]+>", "", match.group(2) 47 + ).strip() # Remove HTML tags from link text 48 + 99 49 # Resolve relative URLs against base URL 100 50 resolved_url = urljoin(base_url, url) 101 51 links.append((resolved_url, text)) 102 - 52 + 103 53 return links 104 - 105 - 106 - def extract_links_from_entry(self, entry, username: str, base_url: str) -> List[LinkData]: 54 + 55 + def extract_links_from_entry( 56 + self, entry: Any, username: str, base_url: str 57 + ) -> list[str]: 107 58 """Extract all links from a blog entry.""" 108 59 links = [] 109 - 60 + 110 61 # Combine all text content for analysis 111 62 content_to_search = [] 112 63 if entry.content: 113 64 content_to_search.append(entry.content) 114 65 if entry.summary: 115 66 content_to_search.append(entry.summary) 116 - 67 + 117 68 for content in content_to_search: 118 69 extracted_links = self.extract_links_from_html(content, base_url) 119 - 120 - for url, link_text in extracted_links: 70 + 71 + for url, _link_text in extracted_links: 121 72 # Skip empty URLs 122 - if not url or url.startswith('#'): 73 + if not url or url.startswith("#"): 123 74 continue 124 - 125 - link_data = LinkData( 126 - url=url, 127 - entry_id=entry.id, 128 - username=username 129 - ) 130 - 131 - links.append(link_data) 132 - 75 + 76 + links.append(url) 77 + 133 78 return links 134 79 135 80 ··· 141 86 "-c", 142 87 help="Path to configuration file", 143 88 ), 144 - output_file: Optional[Path] = typer.Option( 145 - None, 146 - "--output", 147 - "-o", 148 - help="Path to output unified links file (default: links.json in git store)", 149 - ), 150 89 verbose: bool = typer.Option( 151 90 False, 152 91 "--verbose", ··· 154 93 help="Show detailed progress information", 155 94 ), 156 95 ) -> None: 157 - """Extract and categorize all outbound links from blog entries. 158 - 96 + """Extract and store outbound links and backlinks in blog entry JSON files. 97 + 159 98 This command analyzes all blog entries to extract outbound links, 160 99 resolve them properly with respect to the feed's base URL, and 161 - categorize them as internal, user, or unknown links. 162 - 163 - Creates a unified links.json file containing all link data. 100 + store them in each entry's JSON file in a 'links' field. 101 + 102 + It also builds backlinks by finding all entries that link to each entry 103 + and storing the referring entry IDs in a 'backlinks' field. 164 104 """ 165 105 try: 166 106 # Load configuration ··· 168 108 169 109 # Initialize Git store 170 110 git_store = GitStore(config.git_store) 171 - 111 + 172 112 # Build user domain mapping 173 113 if verbose: 174 114 console.print("Building user domain mapping...") 175 - 115 + 176 116 index = git_store._load_index() 177 117 user_domains = {} 178 - 118 + 179 119 for username, user_metadata in index.users.items(): 180 120 domains = set() 181 - 121 + 182 122 # Add domains from feeds 183 123 for feed_url in user_metadata.feeds: 184 124 domain = urlparse(feed_url).netloc.lower() 185 125 if domain: 186 126 domains.add(domain) 187 - 127 + 188 128 # Add domain from homepage 189 129 if user_metadata.homepage: 190 130 domain = urlparse(str(user_metadata.homepage)).netloc.lower() 191 131 if domain: 192 132 domains.add(domain) 193 - 133 + 194 134 user_domains[username] = domains 195 - 135 + 196 136 if verbose: 197 - console.print(f"Found {len(user_domains)} users with {sum(len(d) for d in user_domains.values())} total domains") 198 - 137 + console.print( 138 + f"Found {len(user_domains)} users with {sum(len(d) for d in user_domains.values())} total domains" 139 + ) 140 + 199 141 # Initialize components 200 142 link_extractor = LinkExtractor() 201 - categorizer = LinkCategorizer(user_domains) 202 - 143 + 203 144 # Get all users 204 145 users = list(index.users.keys()) 205 - 146 + 206 147 if not users: 207 148 console.print("[yellow]No users found in Git store[/yellow]") 208 149 raise typer.Exit(0) 209 - 210 - # Process all entries 211 - all_links = [] 212 - link_categories = {"internal": [], "user": [], "unknown": []} 213 - link_dict = {} # Dictionary with link URL as key, maps to list of atom IDs 214 - reverse_dict = {} # Dictionary with atom ID as key, maps to list of URLs 215 - 150 + 151 + # First pass: collect all entries and build URL mapping 152 + all_entries = [] # List of (username, entry) tuples 153 + url_to_entry = {} # Map URL to (username, entry_id) 154 + 216 155 with Progress( 217 156 SpinnerColumn(), 218 157 TextColumn("[progress.description]{task.description}"), ··· 220 159 TaskProgressColumn(), 221 160 console=console, 222 161 ) as progress: 223 - 224 162 # Count total entries first 225 163 counting_task = progress.add_task("Counting entries...", total=len(users)) 226 164 total_entries = 0 227 - 165 + 228 166 for username in users: 229 167 entries = git_store.list_entries(username) 230 168 total_entries += len(entries) 169 + for entry in entries: 170 + all_entries.append((username, entry)) 171 + # Map entry's permalink URL to the entry 172 + if hasattr(entry, "link") and entry.link: 173 + url_to_entry[str(entry.link)] = (username, entry.id) 231 174 progress.advance(counting_task) 232 - 175 + 233 176 progress.remove_task(counting_task) 234 - 235 - # Process entries 177 + 178 + if verbose: 179 + console.print(f"Built URL mapping for {len(url_to_entry)} entry URLs") 180 + 181 + # Second pass: process links for each entry 236 182 processing_task = progress.add_task( 237 - f"Processing {total_entries} entries...", 238 - total=total_entries 183 + f"Processing {total_entries} entries for links...", total=total_entries 239 184 ) 240 - 241 - for username in users: 242 - entries = git_store.list_entries(username) 185 + 186 + updated_entries = 0 187 + total_links_found = 0 188 + link_mapping = {} # entry_id -> list of linked URLs 189 + 190 + for username, entry in all_entries: 243 191 user_metadata = index.users[username] 244 - 192 + 245 193 # Get base URL for this user (use first feed URL) 246 - base_url = str(user_metadata.feeds[0]) if user_metadata.feeds else "https://example.com" 247 - 248 - for entry in entries: 249 - # Extract links from this entry 250 - entry_links = link_extractor.extract_links_from_entry(entry, username, base_url) 251 - 252 - # Track unique links per entry 253 - entry_urls_seen = set() 254 - 255 - # Categorize each link 256 - for link_data in entry_links: 257 - # Skip if we've already seen this URL in this entry 258 - if link_data.url in entry_urls_seen: 259 - continue 260 - entry_urls_seen.add(link_data.url) 261 - 262 - category, target_username = categorizer.categorize_url(link_data.url, username) 263 - 264 - # Add to link dictionary (URL as key, maps to list of atom IDs) 265 - if link_data.url not in link_dict: 266 - link_dict[link_data.url] = [] 267 - if link_data.entry_id not in link_dict[link_data.url]: 268 - link_dict[link_data.url].append(link_data.entry_id) 269 - 270 - # Also add to reverse mapping (atom ID -> list of URLs) 271 - if link_data.entry_id not in reverse_dict: 272 - reverse_dict[link_data.entry_id] = [] 273 - if link_data.url not in reverse_dict[link_data.entry_id]: 274 - reverse_dict[link_data.entry_id].append(link_data.url) 275 - 276 - # Add category info to link data for categories tracking 277 - link_info = link_data.to_dict() 278 - link_info["category"] = category 279 - link_info["target_username"] = target_username 280 - 281 - all_links.append(link_info) 282 - link_categories[category].append(link_info) 283 - 284 - progress.advance(processing_task) 285 - 286 - if verbose and entry_links: 287 - console.print(f" Found {len(entry_links)} links in {username}:{entry.title[:50]}...") 288 - 289 - # Determine output path 290 - if output_file: 291 - output_path = output_file 292 - else: 293 - output_path = config.git_store / "links.json" 294 - 295 - # Save all extracted links (not just filtered ones) 296 - if verbose: 297 - console.print("Preparing output data...") 298 - 299 - # Build a set of all URLs that correspond to posts in the git database 300 - registered_urls = set() 301 - 302 - # Get all entries from all users and build URL mappings 303 - for username in users: 304 - entries = git_store.list_entries(username) 305 - user_metadata = index.users[username] 306 - 307 - for entry in entries: 308 - # Try to match entry URLs with extracted links 309 - if hasattr(entry, 'link') and entry.link: 310 - registered_urls.add(str(entry.link)) 311 - 312 - # Also check entry alternate links if they exist 313 - if hasattr(entry, 'links') and entry.links: 314 - for link in entry.links: 315 - if hasattr(link, 'href') and link.href: 316 - registered_urls.add(str(link.href)) 317 - 318 - # Build unified structure with metadata 319 - unified_links = {} 320 - reverse_mapping = {} 321 - 322 - for url, entry_ids in link_dict.items(): 323 - unified_links[url] = { 324 - "referencing_entries": entry_ids 325 - } 326 - 327 - # Find target username if this is a tracked post 328 - if url in registered_urls: 329 - for username in users: 330 - user_domains_set = {domain for domain in user_domains.get(username, [])} 331 - if any(domain in url for domain in user_domains_set): 332 - unified_links[url]["target_username"] = username 333 - break 334 - 335 - # Build reverse mapping 336 - for entry_id in entry_ids: 337 - if entry_id not in reverse_mapping: 338 - reverse_mapping[entry_id] = [] 339 - if url not in reverse_mapping[entry_id]: 340 - reverse_mapping[entry_id].append(url) 341 - 342 - # Create unified output data 343 - output_data = { 344 - "links": unified_links, 345 - "reverse_mapping": reverse_mapping, 346 - "user_domains": {k: list(v) for k, v in user_domains.items()} 347 - } 348 - 349 - if verbose: 350 - console.print(f"Found {len(registered_urls)} registered post URLs") 351 - console.print(f"Found {len(link_dict)} total links, {sum(1 for link in unified_links.values() if 'target_username' in link)} tracked posts") 352 - 353 - # Save unified data 354 - with open(output_path, "w") as f: 355 - json.dump(output_data, f, indent=2, default=str) 356 - 194 + base_url = ( 195 + str(user_metadata.feeds[0]) 196 + if user_metadata.feeds 197 + else "https://example.com" 198 + ) 199 + 200 + # Extract links from this entry 201 + extracted_urls = link_extractor.extract_links_from_entry( 202 + entry, username, base_url 203 + ) 204 + 205 + # Remove duplicates while preserving order 206 + unique_urls = [] 207 + seen_urls = set() 208 + 209 + for url in extracted_urls: 210 + if url not in seen_urls: 211 + unique_urls.append(url) 212 + seen_urls.add(url) 213 + 214 + # Store the links in our mapping for backlink processing 215 + link_mapping[entry.id] = unique_urls 216 + 217 + # Update entry with links 218 + entry.links = unique_urls 219 + if unique_urls: 220 + updated_entries += 1 221 + total_links_found += len(unique_urls) 222 + 223 + if verbose: 224 + console.print( 225 + f" Updated {username}:{entry.title[:50]}... with {len(unique_urls)} links" 226 + ) 227 + 228 + progress.advance(processing_task) 229 + 230 + progress.remove_task(processing_task) 231 + 232 + # Third pass: process backlinks 233 + backlink_task = progress.add_task( 234 + f"Processing backlinks for {total_entries} entries...", 235 + total=total_entries, 236 + ) 237 + 238 + # Initialize backlinks for all entries 239 + for _username, entry in all_entries: 240 + entry.backlinks = [] 241 + 242 + # Build backlinks by examining all the links 243 + for _username, entry in all_entries: 244 + source_entry_id = entry.id 245 + for linked_url in link_mapping.get(source_entry_id, []): 246 + # Check if this URL corresponds to an entry we know about 247 + if linked_url in url_to_entry: 248 + target_username, target_entry_id = url_to_entry[linked_url] 249 + # Find the target entry and add this source as a backlink 250 + for target_user, target_entry in all_entries: 251 + if ( 252 + target_user == target_username 253 + and target_entry.id == target_entry_id 254 + ): 255 + if source_entry_id not in target_entry.backlinks: 256 + target_entry.backlinks.append(source_entry_id) 257 + break 258 + 259 + progress.advance(backlink_task) 260 + 261 + progress.remove_task(backlink_task) 262 + 263 + # Final pass: save all updated entries 264 + saving_task = progress.add_task( 265 + f"Saving {total_entries} updated entries...", total=total_entries 266 + ) 267 + 268 + backlinks_updated = 0 269 + for username, entry in all_entries: 270 + # Count entries that have backlinks 271 + if entry.backlinks: 272 + backlinks_updated += 1 273 + 274 + # Store the updated entry back to the git store 275 + git_store.store_entry(username, entry) 276 + progress.advance(saving_task) 277 + 357 278 # Show summary 358 279 if not get_tsv_mode(): 359 280 console.print("\n[green]✓ Links extraction completed successfully[/green]") 360 - 281 + 361 282 # Create summary table or TSV output 362 283 if get_tsv_mode(): 363 - print("Category\tCount\tDescription") 364 - print(f"Internal\t{len(link_categories['internal'])}\tLinks to same user's domain") 365 - print(f"User\t{len(link_categories['user'])}\tLinks to other tracked users") 366 - print(f"Unknown\t{len(link_categories['unknown'])}\tLinks to external sites") 367 - print(f"Total Extracted\t{len(all_links)}\tAll extracted links") 368 - print(f"Saved to Output\t{len(output_data['links'])}\tLinks saved to output file") 369 - print(f"Cross-references\t{sum(1 for link in unified_links.values() if 'target_username' in link)}\tLinks to registered posts only") 284 + print("Metric\tValue\tDescription") 285 + print( 286 + f"Entries Updated\t{updated_entries}\tBlog entries updated with links" 287 + ) 288 + print( 289 + f"Total Links\t{total_links_found}\tTotal unique links found across all entries" 290 + ) 291 + print( 292 + f"Entries with Backlinks\t{backlinks_updated}\tEntries that have backlinks from other entries" 293 + ) 294 + print(f"Total Entries\t{total_entries}\tTotal entries processed") 370 295 else: 371 - table = Table(title="Links Summary") 372 - table.add_column("Category", style="cyan") 373 - table.add_column("Count", style="green") 296 + table = Table(title="Links & Backlinks Processing Summary") 297 + table.add_column("Metric", style="cyan") 298 + table.add_column("Value", style="green") 374 299 table.add_column("Description", style="white") 375 - 376 - table.add_row("Internal", str(len(link_categories["internal"])), "Links to same user's domain") 377 - table.add_row("User", str(len(link_categories["user"])), "Links to other tracked users") 378 - table.add_row("Unknown", str(len(link_categories["unknown"])), "Links to external sites") 379 - table.add_row("Total Extracted", str(len(all_links)), "All extracted links") 380 - table.add_row("Saved to Output", str(len(output_data['links'])), "Links saved to output file") 381 - table.add_row("Cross-references", str(sum(1 for link in unified_links.values() if 'target_username' in link)), "Links to registered posts only") 382 - 300 + 301 + table.add_row( 302 + "Entries Updated", 303 + str(updated_entries), 304 + "Blog entries updated with links", 305 + ) 306 + table.add_row( 307 + "Total Links", 308 + str(total_links_found), 309 + "Total unique links found across all entries", 310 + ) 311 + table.add_row( 312 + "Entries with Backlinks", 313 + str(backlinks_updated), 314 + "Entries that have backlinks from other entries", 315 + ) 316 + table.add_row( 317 + "Total Entries", str(total_entries), "Total entries processed" 318 + ) 319 + 383 320 console.print(table) 384 - 385 - # Show user links if verbose 386 - if verbose and link_categories["user"]: 387 - if get_tsv_mode(): 388 - print("User Link Source\tUser Link Target\tLink Count") 389 - user_link_counts = {} 390 - 391 - for link in link_categories["user"]: 392 - key = f"{link['username']} -> {link['target_username']}" 393 - user_link_counts[key] = user_link_counts.get(key, 0) + 1 394 - 395 - for link_pair, count in sorted(user_link_counts.items(), key=lambda x: x[1], reverse=True)[:10]: 396 - source, target = link_pair.split(" -> ") 397 - print(f"{source}\t{target}\t{count}") 398 - else: 399 - console.print("\n[bold]User-to-user links:[/bold]") 400 - user_link_counts = {} 401 - 402 - for link in link_categories["user"]: 403 - key = f"{link['username']} -> {link['target_username']}" 404 - user_link_counts[key] = user_link_counts.get(key, 0) + 1 405 - 406 - for link_pair, count in sorted(user_link_counts.items(), key=lambda x: x[1], reverse=True)[:10]: 407 - console.print(f" {link_pair}: {count} links") 408 - 321 + 409 322 if not get_tsv_mode(): 410 - console.print(f"\nUnified links data saved to: {output_path}") 323 + console.print( 324 + "\nLinks and backlinks have been stored in individual entry JSON files in the git repository." 325 + ) 411 326 412 327 except Exception as e: 413 328 console.print(f"[red]Error extracting links: {e}[/red]") 414 329 if verbose: 415 330 console.print_exception() 416 - raise typer.Exit(1) 331 + raise typer.Exit(1) from e

+1111

src/thicket/cli/commands/threads_cmd.py

··· 1 + """CLI command for displaying and browsing thread-graphs of blog posts.""" 2 + 3 + from dataclasses import dataclass, field 4 + from datetime import datetime 5 + from enum import Enum 6 + from pathlib import Path 7 + from typing import Dict, List, Optional, Set, Tuple 8 + 9 + import typer 10 + from rich.console import Console 11 + import json 12 + import webbrowser 13 + import threading 14 + import time 15 + from flask import Flask, render_template_string, jsonify 16 + from textual import events 17 + from textual.app import App, ComposeResult 18 + from textual.containers import Container, Horizontal, Vertical 19 + from textual.reactive import reactive 20 + from textual.widget import Widget 21 + from textual.widgets import Footer, Header, Label, Static 22 + 23 + from ...core.git_store import GitStore 24 + from ...models import AtomEntry 25 + from ..main import app 26 + from ..utils import get_tsv_mode, load_config 27 + 28 + console = Console() 29 + 30 + 31 + class LinkType(Enum): 32 + """Types of links between entries.""" 33 + 34 + SELF_REFERENCE = "self" # Link to same user's content 35 + USER_REFERENCE = "user" # Link to another tracked user 36 + EXTERNAL = "external" # Link to external content 37 + 38 + 39 + @dataclass 40 + class ThreadNode: 41 + """Represents a node in the thread graph.""" 42 + 43 + entry_id: str 44 + username: str 45 + entry: AtomEntry 46 + outbound_links: List[Tuple[str, LinkType]] = field( 47 + default_factory=list 48 + ) # (url, type) 49 + inbound_backlinks: List[str] = field(default_factory=list) # entry_ids 50 + 51 + @property 52 + def published_date(self) -> datetime: 53 + """Get the published or updated date for sorting.""" 54 + return self.entry.published or self.entry.updated 55 + 56 + @property 57 + def title(self) -> str: 58 + """Get the entry title.""" 59 + return self.entry.title 60 + 61 + @property 62 + def summary(self) -> str: 63 + """Get a short summary of the entry.""" 64 + if self.entry.summary: 65 + return ( 66 + self.entry.summary[:100] + "..." 67 + if len(self.entry.summary) > 100 68 + else self.entry.summary 69 + ) 70 + return "" 71 + 72 + 73 + @dataclass 74 + class ThreadGraph: 75 + """Represents the full thread graph of interconnected posts.""" 76 + 77 + nodes: Dict[str, ThreadNode] = field(default_factory=dict) # entry_id -> ThreadNode 78 + user_entries: Dict[str, List[str]] = field( 79 + default_factory=dict 80 + ) # username -> [entry_ids] 81 + url_to_entry: Dict[str, str] = field(default_factory=dict) # url -> entry_id 82 + 83 + def add_node(self, node: ThreadNode) -> None: 84 + """Add a node to the graph.""" 85 + self.nodes[node.entry_id] = node 86 + 87 + # Update user entries index 88 + if node.username not in self.user_entries: 89 + self.user_entries[node.username] = [] 90 + self.user_entries[node.username].append(node.entry_id) 91 + 92 + # Update URL mapping 93 + if node.entry.link: 94 + self.url_to_entry[str(node.entry.link)] = node.entry_id 95 + 96 + def get_connected_components(self) -> List[Set[str]]: 97 + """Find all connected components in the graph (threads).""" 98 + visited: Set[str] = set() 99 + components: List[Set[str]] = [] 100 + 101 + for entry_id in self.nodes: 102 + if entry_id not in visited: 103 + component: Set[str] = set() 104 + self._dfs(entry_id, visited, component) 105 + components.append(component) 106 + 107 + return components 108 + 109 + def _dfs(self, entry_id: str, visited: Set[str], component: Set[str]) -> None: 110 + """Depth-first search to find connected components.""" 111 + if entry_id in visited: 112 + return 113 + 114 + visited.add(entry_id) 115 + component.add(entry_id) 116 + 117 + node = self.nodes.get(entry_id) 118 + if not node: 119 + return 120 + 121 + # Follow outbound links 122 + for url, link_type in node.outbound_links: 123 + if url in self.url_to_entry: 124 + target_id = self.url_to_entry[url] 125 + self._dfs(target_id, visited, component) 126 + 127 + # Follow backlinks 128 + for backlink_id in node.inbound_backlinks: 129 + self._dfs(backlink_id, visited, component) 130 + 131 + def get_standalone_entries(self) -> List[str]: 132 + """Get entries with no connections.""" 133 + standalone = [] 134 + for entry_id, node in self.nodes.items(): 135 + if not node.outbound_links and not node.inbound_backlinks: 136 + standalone.append(entry_id) 137 + return standalone 138 + 139 + def sort_component_chronologically(self, component: Set[str]) -> List[str]: 140 + """Sort a component by published date.""" 141 + nodes = [ 142 + self.nodes[entry_id] for entry_id in component if entry_id in self.nodes 143 + ] 144 + nodes.sort(key=lambda n: n.published_date) 145 + return [n.entry_id for n in nodes] 146 + 147 + 148 + def build_thread_graph(git_store: GitStore) -> ThreadGraph: 149 + """Build the thread graph from all entries in the git store.""" 150 + graph = ThreadGraph() 151 + 152 + # Get all users from index 153 + index = git_store._load_index() 154 + user_domains = {} 155 + 156 + # Build user domain mapping 157 + for username, user_metadata in index.users.items(): 158 + domains = set() 159 + 160 + # Add domains from feeds 161 + for feed_url in user_metadata.feeds: 162 + from urllib.parse import urlparse 163 + 164 + domain = urlparse(str(feed_url)).netloc.lower() 165 + if domain: 166 + domains.add(domain) 167 + 168 + # Add domain from homepage 169 + if user_metadata.homepage: 170 + domain = urlparse(str(user_metadata.homepage)).netloc.lower() 171 + if domain: 172 + domains.add(domain) 173 + 174 + user_domains[username] = domains 175 + 176 + # Process all entries 177 + for username in index.users: 178 + entries = git_store.list_entries(username) 179 + 180 + for entry in entries: 181 + # Create node 182 + node = ThreadNode(entry_id=entry.id, username=username, entry=entry) 183 + 184 + # Process outbound links 185 + for link in getattr(entry, "links", []): 186 + link_type = categorize_link(link, username, user_domains) 187 + node.outbound_links.append((link, link_type)) 188 + 189 + # Copy backlinks 190 + node.inbound_backlinks = getattr(entry, "backlinks", []) 191 + 192 + # Add to graph 193 + graph.add_node(node) 194 + 195 + return graph 196 + 197 + 198 + def categorize_link( 199 + url: str, source_username: str, user_domains: Dict[str, Set[str]] 200 + ) -> LinkType: 201 + """Categorize a link as self-reference, user reference, or external.""" 202 + from urllib.parse import urlparse 203 + 204 + try: 205 + parsed = urlparse(url) 206 + domain = parsed.netloc.lower() 207 + 208 + # Check if it's a self-reference 209 + if domain in user_domains.get(source_username, set()): 210 + return LinkType.SELF_REFERENCE 211 + 212 + # Check if it's a reference to another tracked user 213 + for username, domains in user_domains.items(): 214 + if username != source_username and domain in domains: 215 + return LinkType.USER_REFERENCE 216 + 217 + # Otherwise it's external 218 + return LinkType.EXTERNAL 219 + 220 + except Exception: 221 + return LinkType.EXTERNAL 222 + 223 + 224 + class ThreadTreeWidget(Static): 225 + """Widget for displaying a thread as a tree.""" 226 + 227 + def __init__(self, component: Set[str], graph: ThreadGraph, **kwargs): 228 + super().__init__(**kwargs) 229 + self.component = component 230 + self.graph = graph 231 + 232 + def compose(self) -> ComposeResult: 233 + """Create the tree display.""" 234 + # Sort entries chronologically 235 + sorted_ids = self.graph.sort_component_chronologically(self.component) 236 + 237 + # Build tree structure as text 238 + content_lines = ["Thread:"] 239 + added_nodes: Set[str] = set() 240 + 241 + # Add nodes in chronological order, showing connections 242 + for entry_id in sorted_ids: 243 + if entry_id not in added_nodes: 244 + self._add_node_to_text(content_lines, entry_id, added_nodes, 0) 245 + 246 + # Join all lines into content 247 + content = "\n".join(content_lines) 248 + 249 + # Create a Static widget with the content 250 + yield Static(content, id="thread-content") 251 + 252 + def _add_node_to_text( 253 + self, content_lines: List[str], entry_id: str, added_nodes: Set[str], indent: int = 0 254 + ): 255 + """Recursively add nodes to the text display.""" 256 + if entry_id in added_nodes: 257 + # Show cycle reference 258 + node = self.graph.nodes.get(entry_id) 259 + if node: 260 + prefix = " " * indent 261 + content_lines.append(f"{prefix}↻ {node.username}: {node.title}") 262 + return 263 + 264 + added_nodes.add(entry_id) 265 + node = self.graph.nodes.get(entry_id) 266 + if not node: 267 + return 268 + 269 + # Format node display 270 + prefix = " " * indent 271 + date_str = node.published_date.strftime("%Y-%m-%d") 272 + node_label = f"{prefix}• {node.username}: {node.title} ({date_str})" 273 + content_lines.append(node_label) 274 + 275 + # Add connections info 276 + if node.outbound_links: 277 + links_by_type: Dict[LinkType, List[str]] = {} 278 + for url, link_type in node.outbound_links: 279 + if link_type not in links_by_type: 280 + links_by_type[link_type] = [] 281 + links_by_type[link_type].append(url) 282 + 283 + for link_type, urls in links_by_type.items(): 284 + type_label = f"{prefix} → {link_type.value}: {len(urls)} link(s)" 285 + content_lines.append(type_label) 286 + 287 + if node.inbound_backlinks: 288 + backlink_label = f"{prefix} ← backlinks: {len(node.inbound_backlinks)}" 289 + content_lines.append(backlink_label) 290 + 291 + 292 + class ThreadBrowserApp(App): 293 + """Terminal UI for browsing threads.""" 294 + 295 + CSS = """ 296 + ThreadBrowserApp { 297 + background: $surface; 298 + } 299 + 300 + #thread-list { 301 + width: 1fr; 302 + height: 1fr; 303 + border: solid $primary; 304 + overflow-y: scroll; 305 + } 306 + 307 + #entry-detail { 308 + width: 1fr; 309 + height: 1fr; 310 + border: solid $secondary; 311 + overflow-y: scroll; 312 + padding: 1; 313 + } 314 + """ 315 + 316 + BINDINGS = [ 317 + ("q", "quit", "Quit"), 318 + ("j", "next_thread", "Next Thread"), 319 + ("k", "prev_thread", "Previous Thread"), 320 + ("enter", "select_thread", "View Thread"), 321 + ] 322 + 323 + def __init__(self, graph: ThreadGraph): 324 + super().__init__() 325 + self.graph = graph 326 + self.threads = [] 327 + self.current_thread_index = 0 328 + self._build_thread_list() 329 + 330 + def _build_thread_list(self): 331 + """Build the list of threads to display.""" 332 + # Get connected components (actual threads) 333 + components = self.graph.get_connected_components() 334 + 335 + # Sort components by the earliest date in each 336 + sorted_components = [] 337 + for component in components: 338 + if len(component) > 1: # Only show actual threads 339 + sorted_ids = self.graph.sort_component_chronologically(component) 340 + if sorted_ids: 341 + first_node = self.graph.nodes.get(sorted_ids[0]) 342 + if first_node: 343 + sorted_components.append((first_node.published_date, component)) 344 + 345 + sorted_components.sort(key=lambda x: x[0], reverse=True) 346 + self.threads = [comp for _, comp in sorted_components] 347 + 348 + def compose(self) -> ComposeResult: 349 + """Create the UI layout.""" 350 + yield Header() 351 + 352 + with Horizontal(): 353 + with Vertical(id="thread-list"): 354 + yield Label("Threads", classes="title") 355 + for i, thread in enumerate(self.threads): 356 + # Get thread summary 357 + sorted_ids = self.graph.sort_component_chronologically(thread) 358 + if sorted_ids: 359 + first_node = self.graph.nodes.get(sorted_ids[0]) 360 + if first_node: 361 + label = f"{i + 1}. {first_node.title} ({len(thread)} posts)" 362 + yield Label(label, classes="thread-item") 363 + 364 + with Vertical(id="entry-detail"): 365 + if self.threads: 366 + yield ThreadTreeWidget(self.threads[0], self.graph) 367 + 368 + yield Footer() 369 + 370 + def action_next_thread(self) -> None: 371 + """Move to next thread.""" 372 + if self.current_thread_index < len(self.threads) - 1: 373 + self.current_thread_index += 1 374 + self.update_display() 375 + 376 + def action_prev_thread(self) -> None: 377 + """Move to previous thread.""" 378 + if self.current_thread_index > 0: 379 + self.current_thread_index -= 1 380 + self.update_display() 381 + 382 + def action_select_thread(self) -> None: 383 + """View detailed thread.""" 384 + # In a real implementation, this could show more detail 385 + pass 386 + 387 + def update_display(self) -> None: 388 + """Update the thread display.""" 389 + detail_view = self.query_one("#entry-detail") 390 + detail_view.remove_children() 391 + 392 + if self.threads and self.current_thread_index < len(self.threads): 393 + widget = ThreadTreeWidget( 394 + self.threads[self.current_thread_index], self.graph 395 + ) 396 + detail_view.mount(widget) 397 + 398 + 399 + @app.command() 400 + def threads( 401 + config_file: Optional[Path] = typer.Option( 402 + Path("thicket.yaml"), 403 + "--config", 404 + "-c", 405 + help="Path to configuration file", 406 + ), 407 + interactive: bool = typer.Option( 408 + True, 409 + "--interactive/--no-interactive", 410 + "-i/-n", 411 + help="Launch interactive terminal UI", 412 + ), 413 + web: bool = typer.Option( 414 + False, 415 + "--web", 416 + "-w", 417 + help="Launch web server with D3 force graph visualization", 418 + ), 419 + port: int = typer.Option( 420 + 8080, 421 + "--port", 422 + "-p", 423 + help="Port for web server", 424 + ), 425 + ) -> None: 426 + """Browse and visualize thread-graphs of interconnected blog posts. 427 + 428 + This command analyzes all blog entries and their links/backlinks to build 429 + a graph of conversations and references between posts. Threads are displayed 430 + as connected components in the link graph. 431 + """ 432 + try: 433 + # Load configuration 434 + config = load_config(config_file) 435 + 436 + # Initialize Git store 437 + git_store = GitStore(config.git_store) 438 + 439 + # Build thread graph 440 + console.print("Building thread graph...") 441 + graph = build_thread_graph(git_store) 442 + 443 + # Get statistics 444 + components = graph.get_connected_components() 445 + threads = [c for c in components if len(c) > 1] 446 + standalone = graph.get_standalone_entries() 447 + 448 + console.print( 449 + f"\n[green]Found {len(threads)} threads and {len(standalone)} standalone posts[/green]" 450 + ) 451 + 452 + if web: 453 + # Launch web server with D3 visualization 454 + _launch_web_server(graph, port) 455 + elif interactive and threads: 456 + # Launch terminal UI 457 + app = ThreadBrowserApp(graph) 458 + app.run() 459 + else: 460 + # Display in console 461 + if get_tsv_mode(): 462 + _display_threads_tsv(graph, threads) 463 + else: 464 + _display_threads_rich(graph, threads) 465 + 466 + except Exception as e: 467 + console.print(f"[red]Error building threads: {e}[/red]") 468 + raise typer.Exit(1) 469 + 470 + 471 + def _display_threads_rich(graph: ThreadGraph, threads: List[Set[str]]) -> None: 472 + """Display threads using rich formatting.""" 473 + for i, thread in enumerate(threads[:10]): # Show first 10 threads 474 + sorted_ids = graph.sort_component_chronologically(thread) 475 + 476 + console.print(f"\n[bold]Thread {i + 1}[/bold] ({len(thread)} posts)") 477 + 478 + for j, entry_id in enumerate(sorted_ids): 479 + node = graph.nodes.get(entry_id) 480 + if node: 481 + date_str = node.published_date.strftime("%Y-%m-%d") 482 + indent = " " * min(j, 3) # Max 3 levels of indent 483 + console.print(f"{indent}• [{node.username}] {node.title} ({date_str})") 484 + 485 + # Show link types 486 + if node.outbound_links: 487 + link_summary = {} 488 + for _, link_type in node.outbound_links: 489 + link_summary[link_type] = link_summary.get(link_type, 0) + 1 490 + 491 + link_str = ", ".join( 492 + [f"{t.value}:{c}" for t, c in link_summary.items()] 493 + ) 494 + console.print(f"{indent} → Links: {link_str}") 495 + 496 + 497 + def _display_threads_tsv(graph: ThreadGraph, threads: List[Set[str]]) -> None: 498 + """Display threads in TSV format.""" 499 + print("Thread\tSize\tFirst Post\tLast Post\tUsers") 500 + 501 + for i, thread in enumerate(threads): 502 + sorted_ids = graph.sort_component_chronologically(thread) 503 + 504 + if sorted_ids: 505 + first_node = graph.nodes.get(sorted_ids[0]) 506 + last_node = graph.nodes.get(sorted_ids[-1]) 507 + 508 + users = set() 509 + for entry_id in thread: 510 + node = graph.nodes.get(entry_id) 511 + if node: 512 + users.add(node.username) 513 + 514 + if first_node and last_node: 515 + print( 516 + f"{i + 1}\t{len(thread)}\t{first_node.published_date.strftime('%Y-%m-%d')}\t{last_node.published_date.strftime('%Y-%m-%d')}\t{','.join(users)}" 517 + ) 518 + 519 + 520 + def _build_graph_json(graph: ThreadGraph) -> dict: 521 + """Convert ThreadGraph to JSON format for D3 visualization.""" 522 + nodes = [] 523 + links = [] 524 + 525 + # Color mapping for different users 526 + user_colors = {} 527 + colors = [ 528 + "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", 529 + "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf", 530 + "#aec7e8", "#ffbb78", "#98df8a", "#ff9896", "#c5b0d5" 531 + ] 532 + 533 + # Assign colors to users 534 + for i, username in enumerate(set(node.username for node in graph.nodes.values())): 535 + user_colors[username] = colors[i % len(colors)] 536 + 537 + # Create nodes 538 + for entry_id, node in graph.nodes.items(): 539 + nodes.append({ 540 + "id": entry_id, 541 + "title": node.title, 542 + "username": node.username, 543 + "date": node.published_date.strftime("%Y-%m-%d"), 544 + "summary": node.summary, 545 + "color": user_colors[node.username], 546 + "outbound_count": len(node.outbound_links), 547 + "backlink_count": len(node.inbound_backlinks), 548 + "link_types": { 549 + "self": len([l for l in node.outbound_links if l[1] == LinkType.SELF_REFERENCE]), 550 + "user": len([l for l in node.outbound_links if l[1] == LinkType.USER_REFERENCE]), 551 + "external": len([l for l in node.outbound_links if l[1] == LinkType.EXTERNAL]) 552 + } 553 + }) 554 + 555 + # Create links (only for links between tracked entries) 556 + for entry_id, node in graph.nodes.items(): 557 + for url, link_type in node.outbound_links: 558 + if url in graph.url_to_entry: 559 + target_id = graph.url_to_entry[url] 560 + if target_id in graph.nodes: 561 + links.append({ 562 + "source": entry_id, 563 + "target": target_id, 564 + "type": link_type.value, 565 + "url": url 566 + }) 567 + 568 + return { 569 + "nodes": nodes, 570 + "links": links, 571 + "stats": { 572 + "total_nodes": len(nodes), 573 + "total_links": len(links), 574 + "users": list(user_colors.keys()), 575 + "user_colors": user_colors 576 + } 577 + } 578 + 579 + 580 + def _launch_web_server(graph: ThreadGraph, port: int) -> None: 581 + """Launch Flask web server with D3 force graph visualization.""" 582 + flask_app = Flask(__name__) 583 + 584 + # Store graph data globally for the Flask app 585 + graph_data = _build_graph_json(graph) 586 + 587 + @flask_app.route('/') 588 + def index(): 589 + """Serve the main visualization page.""" 590 + return render_template_string(HTML_TEMPLATE, port=port) 591 + 592 + @flask_app.route('/api/graph') 593 + def api_graph(): 594 + """API endpoint to serve graph data as JSON.""" 595 + return jsonify(graph_data) 596 + 597 + # Disable Flask logging in development mode 598 + import logging 599 + log = logging.getLogger('werkzeug') 600 + log.setLevel(logging.ERROR) 601 + 602 + def open_browser(): 603 + """Open browser after a short delay.""" 604 + time.sleep(1.5) 605 + webbrowser.open(f'http://localhost:{port}') 606 + 607 + # Start browser in a separate thread 608 + browser_thread = threading.Thread(target=open_browser) 609 + browser_thread.daemon = True 610 + browser_thread.start() 611 + 612 + console.print(f"\n[green]Starting web server at http://localhost:{port}[/green]") 613 + console.print("[yellow]Press Ctrl+C to stop the server[/yellow]") 614 + 615 + try: 616 + flask_app.run(host='0.0.0.0', port=port, debug=False) 617 + except KeyboardInterrupt: 618 + console.print("\n[green]Server stopped[/green]") 619 + 620 + 621 + # HTML template for D3 force graph visualization 622 + HTML_TEMPLATE = """ 623 + <!DOCTYPE html> 624 + <html lang="en"> 625 + <head> 626 + <meta charset="UTF-8"> 627 + <meta name="viewport" content="width=device-width, initial-scale=1.0"> 628 + <title>Thicket Thread Graph Visualization</title> 629 + <script src="https://d3js.org/d3.v7.min.js"></script> 630 + <style> 631 + body { 632 + font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; 633 + margin: 0; 634 + padding: 20px; 635 + background-color: #f5f5f5; 636 + } 637 + 638 + .header { 639 + text-align: center; 640 + margin-bottom: 20px; 641 + } 642 + 643 + h1 { 644 + color: #333; 645 + margin-bottom: 10px; 646 + } 647 + 648 + .controls { 649 + display: flex; 650 + justify-content: center; 651 + gap: 15px; 652 + margin-bottom: 20px; 653 + flex-wrap: wrap; 654 + } 655 + 656 + .control-group { 657 + display: flex; 658 + align-items: center; 659 + gap: 5px; 660 + } 661 + 662 + select, input[type="range"] { 663 + padding: 5px; 664 + border: 1px solid #ddd; 665 + border-radius: 4px; 666 + } 667 + 668 + .stats { 669 + display: flex; 670 + justify-content: center; 671 + gap: 20px; 672 + margin-bottom: 20px; 673 + font-size: 14px; 674 + color: #666; 675 + } 676 + 677 + .stat-item { 678 + background: white; 679 + padding: 10px 15px; 680 + border-radius: 6px; 681 + box-shadow: 0 2px 4px rgba(0,0,0,0.1); 682 + } 683 + 684 + #graph-container { 685 + background: white; 686 + border-radius: 8px; 687 + box-shadow: 0 4px 6px rgba(0,0,0,0.1); 688 + overflow: hidden; 689 + } 690 + 691 + #graph { 692 + cursor: grab; 693 + } 694 + 695 + #graph:active { 696 + cursor: grabbing; 697 + } 698 + 699 + .node { 700 + stroke: #fff; 701 + stroke-width: 1.5px; 702 + cursor: pointer; 703 + } 704 + 705 + .node:hover { 706 + stroke: #333; 707 + stroke-width: 2px; 708 + } 709 + 710 + .link { 711 + stroke: #999; 712 + stroke-opacity: 0.6; 713 + stroke-width: 1px; 714 + } 715 + 716 + .link.self-link { 717 + stroke: #2ca02c; 718 + } 719 + 720 + .link.user-link { 721 + stroke: #ff7f0e; 722 + } 723 + 724 + .link.external-link { 725 + stroke: #d62728; 726 + } 727 + 728 + .tooltip { 729 + position: absolute; 730 + background: rgba(0, 0, 0, 0.9); 731 + color: white; 732 + padding: 10px; 733 + border-radius: 4px; 734 + font-size: 12px; 735 + line-height: 1.4; 736 + pointer-events: none; 737 + z-index: 1000; 738 + max-width: 300px; 739 + } 740 + 741 + .legend { 742 + position: fixed; 743 + top: 20px; 744 + right: 20px; 745 + background: white; 746 + padding: 15px; 747 + border-radius: 6px; 748 + box-shadow: 0 2px 8px rgba(0,0,0,0.15); 749 + font-size: 12px; 750 + z-index: 100; 751 + } 752 + 753 + .legend h3 { 754 + margin: 0 0 10px 0; 755 + font-size: 14px; 756 + color: #333; 757 + } 758 + 759 + .legend-item { 760 + display: flex; 761 + align-items: center; 762 + margin-bottom: 5px; 763 + } 764 + 765 + .legend-color { 766 + width: 12px; 767 + height: 12px; 768 + margin-right: 8px; 769 + border-radius: 2px; 770 + } 771 + 772 + .legend-line { 773 + width: 20px; 774 + height: 2px; 775 + margin-right: 8px; 776 + } 777 + </style> 778 + </head> 779 + <body> 780 + <div class="header"> 781 + <h1>Thicket Thread Graph Visualization</h1> 782 + <p>Interactive visualization of blog post connections and conversations</p> 783 + </div> 784 + 785 + <div class="controls"> 786 + <div class="control-group"> 787 + <label for="userFilter">Filter by user:</label> 788 + <select id="userFilter"> 789 + <option value="all">All Users</option> 790 + </select> 791 + </div> 792 + 793 + <div class="control-group"> 794 + <label for="linkFilter">Show links:</label> 795 + <select id="linkFilter"> 796 + <option value="all">All Links</option> 797 + <option value="user">User Links Only</option> 798 + <option value="self">Self Links Only</option> 799 + <option value="external">External Links Only</option> 800 + </select> 801 + </div> 802 + 803 + <div class="control-group"> 804 + <label for="forceStrength">Force Strength:</label> 805 + <input type="range" id="forceStrength" min="0.1" max="2" step="0.1" value="0.3"> 806 + </div> 807 + 808 + <div class="control-group"> 809 + <label for="nodeSize">Node Size:</label> 810 + <input type="range" id="nodeSize" min="3" max="15" step="1" value="6"> 811 + </div> 812 + </div> 813 + 814 + <div class="stats" id="stats"></div> 815 + 816 + <div id="graph-container"> 817 + <svg id="graph"></svg> 818 + </div> 819 + 820 + <div class="legend"> 821 + <h3>Link Types</h3> 822 + <div class="legend-item"> 823 + <div class="legend-line" style="background: #2ca02c;"></div> 824 + <span>Self References</span> 825 + </div> 826 + <div class="legend-item"> 827 + <div class="legend-line" style="background: #ff7f0e;"></div> 828 + <span>User References</span> 829 + </div> 830 + <div class="legend-item"> 831 + <div class="legend-line" style="background: #d62728;"></div> 832 + <span>External References</span> 833 + </div> 834 + 835 + <h3 style="margin-top: 15px;">Interactions</h3> 836 + <div style="font-size: 11px; color: #666;"> 837 + • Hover: Show details<br> 838 + • Click: Pin/unpin node<br> 839 + • Drag: Move nodes<br> 840 + • Zoom: Mouse wheel 841 + </div> 842 + </div> 843 + 844 + <div class="tooltip" id="tooltip" style="display: none;"></div> 845 + 846 + <script> 847 + let graphData; 848 + let simulation; 849 + let svg, g, link, node; 850 + let width = window.innerWidth - 40; 851 + let height = window.innerHeight - 200; 852 + 853 + // Initialize the visualization 854 + async function init() { 855 + // Fetch graph data 856 + const response = await fetch('/api/graph'); 857 + graphData = await response.json(); 858 + 859 + // Set up SVG 860 + svg = d3.select("#graph") 861 + .attr("width", width) 862 + .attr("height", height); 863 + 864 + // Add zoom behavior 865 + const zoom = d3.zoom() 866 + .scaleExtent([0.1, 4]) 867 + .on("zoom", (event) => { 868 + g.attr("transform", event.transform); 869 + }); 870 + 871 + svg.call(zoom); 872 + 873 + // Create main group for all elements 874 + g = svg.append("g"); 875 + 876 + // Set up controls 877 + setupControls(); 878 + 879 + // Initial render 880 + updateVisualization(); 881 + 882 + // Update stats 883 + updateStats(); 884 + 885 + // Handle window resize 886 + window.addEventListener('resize', () => { 887 + width = window.innerWidth - 40; 888 + height = window.innerHeight - 200; 889 + svg.attr("width", width).attr("height", height); 890 + simulation.force("center", d3.forceCenter(width / 2, height / 2)); 891 + simulation.restart(); 892 + }); 893 + } 894 + 895 + function setupControls() { 896 + // Populate user filter 897 + const userFilter = d3.select("#userFilter"); 898 + graphData.stats.users.forEach(user => { 899 + userFilter.append("option").attr("value", user).text(user); 900 + }); 901 + 902 + // Add event listeners 903 + d3.select("#userFilter").on("change", updateVisualization); 904 + d3.select("#linkFilter").on("change", updateVisualization); 905 + d3.select("#forceStrength").on("input", updateForces); 906 + d3.select("#nodeSize").on("input", updateNodeSizes); 907 + } 908 + 909 + function updateVisualization() { 910 + // Filter data based on controls 911 + const userFilter = d3.select("#userFilter").property("value"); 912 + const linkFilter = d3.select("#linkFilter").property("value"); 913 + 914 + let filteredNodes = graphData.nodes; 915 + let filteredLinks = graphData.links; 916 + 917 + if (userFilter !== "all") { 918 + filteredNodes = graphData.nodes.filter(n => n.username === userFilter); 919 + const nodeIds = new Set(filteredNodes.map(n => n.id)); 920 + filteredLinks = graphData.links.filter(l => 921 + nodeIds.has(l.source.id || l.source) && nodeIds.has(l.target.id || l.target) 922 + ); 923 + } 924 + 925 + if (linkFilter !== "all") { 926 + filteredLinks = filteredLinks.filter(l => l.type === linkFilter); 927 + } 928 + 929 + // Clear existing elements 930 + g.selectAll(".link").remove(); 931 + g.selectAll(".node").remove(); 932 + 933 + // Create force simulation 934 + simulation = d3.forceSimulation(filteredNodes) 935 + .force("link", d3.forceLink(filteredLinks).id(d => d.id) 936 + .distance(d => { 937 + // Get source and target nodes 938 + const sourceNode = filteredNodes.find(n => n.id === (d.source.id || d.source)); 939 + const targetNode = filteredNodes.find(n => n.id === (d.target.id || d.target)); 940 + 941 + // If nodes are from different users, make them attract more (shorter distance) 942 + if (sourceNode && targetNode && sourceNode.username !== targetNode.username) { 943 + return 30; // Shorter distance = stronger attraction 944 + } 945 + 946 + // Same user posts have normal distance 947 + return 60; 948 + }) 949 + .strength(d => { 950 + // Get source and target nodes 951 + const sourceNode = filteredNodes.find(n => n.id === (d.source.id || d.source)); 952 + const targetNode = filteredNodes.find(n => n.id === (d.target.id || d.target)); 953 + 954 + // If nodes are from different users, make the link stronger 955 + if (sourceNode && targetNode && sourceNode.username !== targetNode.username) { 956 + return 1.5; // Stronger link force 957 + } 958 + 959 + // Same user posts have normal strength 960 + return 1.0; 961 + })) 962 + .force("charge", d3.forceManyBody().strength(-200)) 963 + .force("center", d3.forceCenter(width / 2, height / 2)) 964 + .force("collision", d3.forceCollide().radius(15)); 965 + 966 + // Create links 967 + link = g.append("g") 968 + .selectAll(".link") 969 + .data(filteredLinks) 970 + .enter().append("line") 971 + .attr("class", d => `link ${d.type}-link`) 972 + .attr("stroke-width", d => { 973 + // Get source and target nodes 974 + const sourceNode = filteredNodes.find(n => n.id === (d.source.id || d.source)); 975 + const targetNode = filteredNodes.find(n => n.id === (d.target.id || d.target)); 976 + 977 + // If nodes are from different users, make the line thicker 978 + if (sourceNode && targetNode && sourceNode.username !== targetNode.username) { 979 + return 2.5; // Thicker line for cross-user connections 980 + } 981 + 982 + // Same user posts have normal thickness 983 + return 1; 984 + }); 985 + 986 + // Create nodes 987 + node = g.append("g") 988 + .selectAll(".node") 989 + .data(filteredNodes) 990 + .enter().append("circle") 991 + .attr("class", "node") 992 + .attr("r", d => Math.max(4, Math.log(d.outbound_count + d.backlink_count + 1) * 3)) 993 + .attr("fill", d => d.color) 994 + .call(d3.drag() 995 + .on("start", dragstarted) 996 + .on("drag", dragged) 997 + .on("end", dragended)) 998 + .on("mouseover", showTooltip) 999 + .on("mouseout", hideTooltip) 1000 + .on("click", togglePin); 1001 + 1002 + // Update force simulation 1003 + simulation.on("tick", () => { 1004 + link 1005 + .attr("x1", d => d.source.x) 1006 + .attr("y1", d => d.source.y) 1007 + .attr("x2", d => d.target.x) 1008 + .attr("y2", d => d.target.y); 1009 + 1010 + node 1011 + .attr("cx", d => d.x) 1012 + .attr("cy", d => d.y); 1013 + }); 1014 + 1015 + updateStats(filteredNodes, filteredLinks); 1016 + } 1017 + 1018 + function updateForces() { 1019 + const strength = +d3.select("#forceStrength").property("value"); 1020 + if (simulation) { 1021 + simulation.force("charge").strength(-200 * strength); 1022 + simulation.alpha(0.3).restart(); 1023 + } 1024 + } 1025 + 1026 + function updateNodeSizes() { 1027 + const size = +d3.select("#nodeSize").property("value"); 1028 + if (node) { 1029 + node.attr("r", d => Math.max(size * 0.5, Math.log(d.outbound_count + d.backlink_count + 1) * size * 0.5)); 1030 + } 1031 + } 1032 + 1033 + function dragstarted(event, d) { 1034 + if (!event.active) simulation.alphaTarget(0.3).restart(); 1035 + d.fx = d.x; 1036 + d.fy = d.y; 1037 + } 1038 + 1039 + function dragged(event, d) { 1040 + d.fx = event.x; 1041 + d.fy = event.y; 1042 + } 1043 + 1044 + function dragended(event, d) { 1045 + if (!event.active) simulation.alphaTarget(0); 1046 + if (!d.pinned) { 1047 + d.fx = null; 1048 + d.fy = null; 1049 + } 1050 + } 1051 + 1052 + function togglePin(event, d) { 1053 + d.pinned = !d.pinned; 1054 + if (d.pinned) { 1055 + d.fx = d.x; 1056 + d.fy = d.y; 1057 + } else { 1058 + d.fx = null; 1059 + d.fy = null; 1060 + } 1061 + } 1062 + 1063 + function showTooltip(event, d) { 1064 + const tooltip = d3.select("#tooltip"); 1065 + tooltip.style("display", "block") 1066 + .html(` 1067 + <strong>${d.title}</strong><br> 1068 + <strong>User:</strong> ${d.username}<br> 1069 + <strong>Date:</strong> ${d.date}<br> 1070 + <strong>Outbound Links:</strong> ${d.outbound_count}<br> 1071 + <strong>Backlinks:</strong> ${d.backlink_count}<br> 1072 + <strong>Link Types:</strong> Self: ${d.link_types.self}, User: ${d.link_types.user}, External: ${d.link_types.external} 1073 + ${d.summary ? '<br><br>' + d.summary : ''} 1074 + `) 1075 + .style("left", (event.pageX + 10) + "px") 1076 + .style("top", (event.pageY - 10) + "px"); 1077 + } 1078 + 1079 + function hideTooltip() { 1080 + d3.select("#tooltip").style("display", "none"); 1081 + } 1082 + 1083 + function updateStats(nodes = graphData.nodes, links = graphData.links) { 1084 + const stats = d3.select("#stats"); 1085 + const userCounts = {}; 1086 + nodes.forEach(n => { 1087 + userCounts[n.username] = (userCounts[n.username] || 0) + 1; 1088 + }); 1089 + 1090 + stats.html(` 1091 + <div class="stat-item"> 1092 + <strong>${nodes.length}</strong> Nodes 1093 + </div> 1094 + <div class="stat-item"> 1095 + <strong>${links.length}</strong> Links 1096 + </div> 1097 + <div class="stat-item"> 1098 + <strong>${Object.keys(userCounts).length}</strong> Users 1099 + </div> 1100 + <div class="stat-item"> 1101 + Users: ${Object.entries(userCounts).map(([user, count]) => `${user} (${count})`).join(', ')} 1102 + </div> 1103 + `); 1104 + } 1105 + 1106 + // Initialize when page loads 1107 + init(); 1108 + </script> 1109 + </body> 1110 + </html> 1111 + """

+1 -1

src/thicket/cli/main.py

··· 47 47 48 48 49 49 # Import commands to register them 50 - from .commands import add, duplicates, index_cmd, info_cmd, init, links_cmd, list_cmd, sync 50 + from .commands import add, duplicates, info_cmd, init, links_cmd, list_cmd, sync, threads_cmd 51 51 52 52 if __name__ == "__main__": 53 53 app()

-301

src/thicket/core/reference_parser.py

··· 1 - """Reference detection and parsing for blog entries.""" 2 - 3 - import re 4 - from typing import Optional 5 - from urllib.parse import urlparse 6 - 7 - from ..models import AtomEntry 8 - 9 - 10 - class BlogReference: 11 - """Represents a reference from one blog entry to another.""" 12 - 13 - def __init__( 14 - self, 15 - source_entry_id: str, 16 - source_username: str, 17 - target_url: str, 18 - target_username: Optional[str] = None, 19 - target_entry_id: Optional[str] = None, 20 - ): 21 - self.source_entry_id = source_entry_id 22 - self.source_username = source_username 23 - self.target_url = target_url 24 - self.target_username = target_username 25 - self.target_entry_id = target_entry_id 26 - 27 - def to_dict(self) -> dict: 28 - """Convert to dictionary for JSON serialization.""" 29 - result = { 30 - "source_entry_id": self.source_entry_id, 31 - "source_username": self.source_username, 32 - "target_url": self.target_url, 33 - } 34 - 35 - # Only include optional fields if they are not None 36 - if self.target_username is not None: 37 - result["target_username"] = self.target_username 38 - if self.target_entry_id is not None: 39 - result["target_entry_id"] = self.target_entry_id 40 - 41 - return result 42 - 43 - @classmethod 44 - def from_dict(cls, data: dict) -> "BlogReference": 45 - """Create from dictionary.""" 46 - return cls( 47 - source_entry_id=data["source_entry_id"], 48 - source_username=data["source_username"], 49 - target_url=data["target_url"], 50 - target_username=data.get("target_username"), 51 - target_entry_id=data.get("target_entry_id"), 52 - ) 53 - 54 - 55 - class ReferenceIndex: 56 - """Index of blog-to-blog references for creating threaded views.""" 57 - 58 - def __init__(self): 59 - self.references: list[BlogReference] = [] 60 - self.outbound_refs: dict[ 61 - str, list[BlogReference] 62 - ] = {} # entry_id -> outbound refs 63 - self.inbound_refs: dict[ 64 - str, list[BlogReference] 65 - ] = {} # entry_id -> inbound refs 66 - self.user_domains: dict[str, set[str]] = {} # username -> set of domains 67 - 68 - def add_reference(self, ref: BlogReference) -> None: 69 - """Add a reference to the index.""" 70 - self.references.append(ref) 71 - 72 - # Update outbound references 73 - source_key = f"{ref.source_username}:{ref.source_entry_id}" 74 - if source_key not in self.outbound_refs: 75 - self.outbound_refs[source_key] = [] 76 - self.outbound_refs[source_key].append(ref) 77 - 78 - # Update inbound references if we can identify the target 79 - if ref.target_username and ref.target_entry_id: 80 - target_key = f"{ref.target_username}:{ref.target_entry_id}" 81 - if target_key not in self.inbound_refs: 82 - self.inbound_refs[target_key] = [] 83 - self.inbound_refs[target_key].append(ref) 84 - 85 - def get_outbound_refs(self, username: str, entry_id: str) -> list[BlogReference]: 86 - """Get all outbound references from an entry.""" 87 - key = f"{username}:{entry_id}" 88 - return self.outbound_refs.get(key, []) 89 - 90 - def get_inbound_refs(self, username: str, entry_id: str) -> list[BlogReference]: 91 - """Get all inbound references to an entry.""" 92 - key = f"{username}:{entry_id}" 93 - return self.inbound_refs.get(key, []) 94 - 95 - def get_thread_members(self, username: str, entry_id: str) -> set[tuple[str, str]]: 96 - """Get all entries that are part of the same thread.""" 97 - visited = set() 98 - to_visit = [(username, entry_id)] 99 - thread_members = set() 100 - 101 - while to_visit: 102 - current_user, current_entry = to_visit.pop() 103 - if (current_user, current_entry) in visited: 104 - continue 105 - 106 - visited.add((current_user, current_entry)) 107 - thread_members.add((current_user, current_entry)) 108 - 109 - # Add outbound references 110 - for ref in self.get_outbound_refs(current_user, current_entry): 111 - if ref.target_username and ref.target_entry_id: 112 - to_visit.append((ref.target_username, ref.target_entry_id)) 113 - 114 - # Add inbound references 115 - for ref in self.get_inbound_refs(current_user, current_entry): 116 - to_visit.append((ref.source_username, ref.source_entry_id)) 117 - 118 - return thread_members 119 - 120 - def to_dict(self) -> dict: 121 - """Convert to dictionary for JSON serialization.""" 122 - return { 123 - "references": [ref.to_dict() for ref in self.references], 124 - "user_domains": {k: list(v) for k, v in self.user_domains.items()}, 125 - } 126 - 127 - @classmethod 128 - def from_dict(cls, data: dict) -> "ReferenceIndex": 129 - """Create from dictionary.""" 130 - index = cls() 131 - for ref_data in data.get("references", []): 132 - ref = BlogReference.from_dict(ref_data) 133 - index.add_reference(ref) 134 - 135 - for username, domains in data.get("user_domains", {}).items(): 136 - index.user_domains[username] = set(domains) 137 - 138 - return index 139 - 140 - 141 - class ReferenceParser: 142 - """Parses blog entries to detect references to other blogs.""" 143 - 144 - def __init__(self): 145 - # Common blog platforms and patterns 146 - self.blog_patterns = [ 147 - r"https?://[^/]+\.(?:org|com|net|io|dev|me|co\.uk)/.*", # Common blog domains 148 - r"https?://[^/]+\.github\.io/.*", # GitHub Pages 149 - r"https?://[^/]+\.substack\.com/.*", # Substack 150 - r"https?://medium\.com/.*", # Medium 151 - r"https?://[^/]+\.wordpress\.com/.*", # WordPress.com 152 - r"https?://[^/]+\.blogspot\.com/.*", # Blogger 153 - ] 154 - 155 - # Compile regex patterns 156 - self.link_pattern = re.compile( 157 - r'<a[^>]+href="([^"]+)"[^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL 158 - ) 159 - self.url_pattern = re.compile(r'https?://[^\s<>"]+') 160 - 161 - def extract_links_from_html(self, html_content: str) -> list[tuple[str, str]]: 162 - """Extract all links from HTML content.""" 163 - links = [] 164 - 165 - # Extract links from <a> tags 166 - for match in self.link_pattern.finditer(html_content): 167 - url = match.group(1) 168 - text = re.sub( 169 - r"<[^>]+>", "", match.group(2) 170 - ).strip() # Remove HTML tags from link text 171 - links.append((url, text)) 172 - 173 - return links 174 - 175 - def is_blog_url(self, url: str) -> bool: 176 - """Check if a URL likely points to a blog post.""" 177 - for pattern in self.blog_patterns: 178 - if re.match(pattern, url): 179 - return True 180 - return False 181 - 182 - def resolve_target_user( 183 - self, url: str, user_domains: dict[str, set[str]] 184 - ) -> Optional[str]: 185 - """Try to resolve a URL to a known user based on domain mapping.""" 186 - parsed_url = urlparse(url) 187 - domain = parsed_url.netloc.lower() 188 - 189 - for username, domains in user_domains.items(): 190 - if domain in domains: 191 - return username 192 - 193 - return None 194 - 195 - def extract_references( 196 - self, entry: AtomEntry, username: str, user_domains: dict[str, set[str]] 197 - ) -> list[BlogReference]: 198 - """Extract all blog references from an entry.""" 199 - references = [] 200 - 201 - # Combine all text content for analysis 202 - content_to_search = [] 203 - if entry.content: 204 - content_to_search.append(entry.content) 205 - if entry.summary: 206 - content_to_search.append(entry.summary) 207 - 208 - for content in content_to_search: 209 - links = self.extract_links_from_html(content) 210 - 211 - for url, _link_text in links: 212 - # Skip internal links (same domain as the entry) 213 - entry_domain = ( 214 - urlparse(str(entry.link)).netloc.lower() if entry.link else "" 215 - ) 216 - link_domain = urlparse(url).netloc.lower() 217 - 218 - if link_domain == entry_domain: 219 - continue 220 - 221 - # Check if this looks like a blog URL 222 - if not self.is_blog_url(url): 223 - continue 224 - 225 - # Try to resolve to a known user 226 - target_username = self.resolve_target_user(url, user_domains) 227 - 228 - ref = BlogReference( 229 - source_entry_id=entry.id, 230 - source_username=username, 231 - target_url=url, 232 - target_username=target_username, 233 - target_entry_id=None, # Will be resolved later if possible 234 - ) 235 - 236 - references.append(ref) 237 - 238 - return references 239 - 240 - def build_user_domain_mapping(self, git_store: "GitStore") -> dict[str, set[str]]: 241 - """Build mapping of usernames to their known domains.""" 242 - user_domains = {} 243 - index = git_store._load_index() 244 - 245 - for username, user_metadata in index.users.items(): 246 - domains = set() 247 - 248 - # Add domains from feeds 249 - for feed_url in user_metadata.feeds: 250 - domain = urlparse(feed_url).netloc.lower() 251 - if domain: 252 - domains.add(domain) 253 - 254 - # Add domain from homepage 255 - if user_metadata.homepage: 256 - domain = urlparse(str(user_metadata.homepage)).netloc.lower() 257 - if domain: 258 - domains.add(domain) 259 - 260 - user_domains[username] = domains 261 - 262 - return user_domains 263 - 264 - def resolve_target_entry_ids( 265 - self, references: list[BlogReference], git_store: "GitStore" 266 - ) -> list[BlogReference]: 267 - """Resolve target_entry_id for references that have target_username but no target_entry_id.""" 268 - resolved_refs = [] 269 - 270 - for ref in references: 271 - # If we already have a target_entry_id, keep the reference as-is 272 - if ref.target_entry_id is not None: 273 - resolved_refs.append(ref) 274 - continue 275 - 276 - # If we don't have a target_username, we can't resolve it 277 - if ref.target_username is None: 278 - resolved_refs.append(ref) 279 - continue 280 - 281 - # Try to find the entry by matching the URL 282 - entries = git_store.list_entries(ref.target_username) 283 - resolved_entry_id = None 284 - 285 - for entry in entries: 286 - # Check if the entry's link matches the target URL 287 - if entry.link and str(entry.link) == ref.target_url: 288 - resolved_entry_id = entry.id 289 - break 290 - 291 - # Create a new reference with the resolved target_entry_id 292 - resolved_ref = BlogReference( 293 - source_entry_id=ref.source_entry_id, 294 - source_username=ref.source_username, 295 - target_url=ref.target_url, 296 - target_username=ref.target_username, 297 - target_entry_id=resolved_entry_id, 298 - ) 299 - resolved_refs.append(resolved_ref) 300 - 301 - return resolved_refs

+4 -2

src/thicket/models/feed.py

··· 1 1 """Feed and entry models for thicket.""" 2 2 3 3 from datetime import datetime 4 - from typing import TYPE_CHECKING, Optional 4 + from typing import TYPE_CHECKING, Any, Optional 5 5 6 6 from pydantic import BaseModel, ConfigDict, EmailStr, HttpUrl 7 7 ··· 25 25 summary: Optional[str] = None 26 26 content: Optional[str] = None # Full body content from Atom entry 27 27 content_type: Optional[str] = "html" # text, html, xhtml 28 - author: Optional[dict] = None 28 + author: Optional[dict[str, Any]] = None 29 29 categories: list[str] = [] 30 30 rights: Optional[str] = None # Copyright info 31 31 source: Optional[str] = None # Source feed URL 32 + links: list[str] = [] # URLs mentioned in this entry 33 + backlinks: list[str] = [] # Entry IDs that link to this entry 32 34 33 35 34 36 class FeedMetadata(BaseModel):

+210

uv.lock

··· 82 82 ] 83 83 84 84 [[package]] 85 + name = "blinker" 86 + version = "1.9.0" 87 + source = { registry = "https://pypi.org/simple" } 88 + sdist = { url = "https://files.pythonhosted.org/packages/21/28/9b3f50ce0e048515135495f198351908d99540d69bfdc8c1d15b73dc55ce/blinker-1.9.0.tar.gz", hash = "sha256:b4ce2265a7abece45e7cc896e98dbebe6cead56bcf805a3d23136d145f5445bf", size = 22460, upload-time = "2024-11-08T17:25:47.436Z" } 89 + wheels = [ 90 + { url = "https://files.pythonhosted.org/packages/10/cb/f2ad4230dc2eb1a74edf38f1a38b9b52277f75bef262d8908e60d957e13c/blinker-1.9.0-py3-none-any.whl", hash = "sha256:ba0efaa9080b619ff2f3459d1d500c57bddea4a6b424b60a91141db6fd2f08bc", size = 8458, upload-time = "2024-11-08T17:25:46.184Z" }, 91 + ] 92 + 93 + [[package]] 85 94 name = "certifi" 86 95 version = "2025.7.14" 87 96 source = { registry = "https://pypi.org/simple" } ··· 255 264 ] 256 265 257 266 [[package]] 267 + name = "flask" 268 + version = "3.1.1" 269 + source = { registry = "https://pypi.org/simple" } 270 + dependencies = [ 271 + { name = "blinker" }, 272 + { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, 273 + { name = "click", version = "8.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, 274 + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, 275 + { name = "itsdangerous" }, 276 + { name = "jinja2" }, 277 + { name = "markupsafe" }, 278 + { name = "werkzeug" }, 279 + ] 280 + sdist = { url = "https://files.pythonhosted.org/packages/c0/de/e47735752347f4128bcf354e0da07ef311a78244eba9e3dc1d4a5ab21a98/flask-3.1.1.tar.gz", hash = "sha256:284c7b8f2f58cb737f0cf1c30fd7eaf0ccfcde196099d24ecede3fc2005aa59e", size = 753440, upload-time = "2025-05-13T15:01:17.447Z" } 281 + wheels = [ 282 + { url = "https://files.pythonhosted.org/packages/3d/68/9d4508e893976286d2ead7f8f571314af6c2037af34853a30fd769c02e9d/flask-3.1.1-py3-none-any.whl", hash = "sha256:07aae2bb5eaf77993ef57e357491839f5fd9f4dc281593a81a9e4d79a24f295c", size = 103305, upload-time = "2025-05-13T15:01:15.591Z" }, 283 + ] 284 + 285 + [[package]] 258 286 name = "gitdb" 259 287 version = "4.0.12" 260 288 source = { registry = "https://pypi.org/simple" } ··· 325 353 ] 326 354 327 355 [[package]] 356 + name = "importlib-metadata" 357 + version = "8.7.0" 358 + source = { registry = "https://pypi.org/simple" } 359 + dependencies = [ 360 + { name = "zipp", marker = "python_full_version < '3.10'" }, 361 + ] 362 + sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" } 363 + wheels = [ 364 + { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" }, 365 + ] 366 + 367 + [[package]] 328 368 name = "iniconfig" 329 369 version = "2.1.0" 330 370 source = { registry = "https://pypi.org/simple" } ··· 334 374 ] 335 375 336 376 [[package]] 377 + name = "itsdangerous" 378 + version = "2.2.0" 379 + source = { registry = "https://pypi.org/simple" } 380 + sdist = { url = "https://files.pythonhosted.org/packages/9c/cb/8ac0172223afbccb63986cc25049b154ecfb5e85932587206f42317be31d/itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173", size = 54410, upload-time = "2024-04-16T21:28:15.614Z" } 381 + wheels = [ 382 + { url = "https://files.pythonhosted.org/packages/04/96/92447566d16df59b2a776c0fb82dbc4d9e07cd95062562af01e408583fc4/itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef", size = 16234, upload-time = "2024-04-16T21:28:14.499Z" }, 383 + ] 384 + 385 + [[package]] 386 + name = "jinja2" 387 + version = "3.1.6" 388 + source = { registry = "https://pypi.org/simple" } 389 + dependencies = [ 390 + { name = "markupsafe" }, 391 + ] 392 + sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } 393 + wheels = [ 394 + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, 395 + ] 396 + 397 + [[package]] 398 + name = "linkify-it-py" 399 + version = "2.0.3" 400 + source = { registry = "https://pypi.org/simple" } 401 + dependencies = [ 402 + { name = "uc-micro-py" }, 403 + ] 404 + sdist = { url = "https://files.pythonhosted.org/packages/2a/ae/bb56c6828e4797ba5a4821eec7c43b8bf40f69cda4d4f5f8c8a2810ec96a/linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048", size = 27946, upload-time = "2024-02-04T14:48:04.179Z" } 405 + wheels = [ 406 + { url = "https://files.pythonhosted.org/packages/04/1e/b832de447dee8b582cac175871d2f6c3d5077cc56d5575cadba1fd1cccfa/linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79", size = 19820, upload-time = "2024-02-04T14:48:02.496Z" }, 407 + ] 408 + 409 + [[package]] 337 410 name = "markdown-it-py" 338 411 version = "3.0.0" 339 412 source = { registry = "https://pypi.org/simple" } ··· 345 418 { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" }, 346 419 ] 347 420 421 + [package.optional-dependencies] 422 + linkify = [ 423 + { name = "linkify-it-py" }, 424 + ] 425 + plugins = [ 426 + { name = "mdit-py-plugins" }, 427 + ] 428 + 429 + [[package]] 430 + name = "markupsafe" 431 + version = "3.0.2" 432 + source = { registry = "https://pypi.org/simple" } 433 + sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537, upload-time = "2024-10-18T15:21:54.129Z" } 434 + wheels = [ 435 + { url = "https://files.pythonhosted.org/packages/04/90/d08277ce111dd22f77149fd1a5d4653eeb3b3eaacbdfcbae5afb2600eebd/MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8", size = 14357, upload-time = "2024-10-18T15:20:51.44Z" }, 436 + { url = "https://files.pythonhosted.org/packages/04/e1/6e2194baeae0bca1fae6629dc0cbbb968d4d941469cbab11a3872edff374/MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158", size = 12393, upload-time = "2024-10-18T15:20:52.426Z" }, 437 + { url = "https://files.pythonhosted.org/packages/1d/69/35fa85a8ece0a437493dc61ce0bb6d459dcba482c34197e3efc829aa357f/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579", size = 21732, upload-time = "2024-10-18T15:20:53.578Z" }, 438 + { url = "https://files.pythonhosted.org/packages/22/35/137da042dfb4720b638d2937c38a9c2df83fe32d20e8c8f3185dbfef05f7/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d", size = 20866, upload-time = "2024-10-18T15:20:55.06Z" }, 439 + { url = "https://files.pythonhosted.org/packages/29/28/6d029a903727a1b62edb51863232152fd335d602def598dade38996887f0/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb", size = 20964, upload-time = "2024-10-18T15:20:55.906Z" }, 440 + { url = "https://files.pythonhosted.org/packages/cc/cd/07438f95f83e8bc028279909d9c9bd39e24149b0d60053a97b2bc4f8aa51/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b", size = 21977, upload-time = "2024-10-18T15:20:57.189Z" }, 441 + { url = "https://files.pythonhosted.org/packages/29/01/84b57395b4cc062f9c4c55ce0df7d3108ca32397299d9df00fedd9117d3d/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c", size = 21366, upload-time = "2024-10-18T15:20:58.235Z" }, 442 + { url = "https://files.pythonhosted.org/packages/bd/6e/61ebf08d8940553afff20d1fb1ba7294b6f8d279df9fd0c0db911b4bbcfd/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171", size = 21091, upload-time = "2024-10-18T15:20:59.235Z" }, 443 + { url = "https://files.pythonhosted.org/packages/11/23/ffbf53694e8c94ebd1e7e491de185124277964344733c45481f32ede2499/MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50", size = 15065, upload-time = "2024-10-18T15:21:00.307Z" }, 444 + { url = "https://files.pythonhosted.org/packages/44/06/e7175d06dd6e9172d4a69a72592cb3f7a996a9c396eee29082826449bbc3/MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a", size = 15514, upload-time = "2024-10-18T15:21:01.122Z" }, 445 + { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353, upload-time = "2024-10-18T15:21:02.187Z" }, 446 + { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392, upload-time = "2024-10-18T15:21:02.941Z" }, 447 + { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984, upload-time = "2024-10-18T15:21:03.953Z" }, 448 + { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120, upload-time = "2024-10-18T15:21:06.495Z" }, 449 + { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032, upload-time = "2024-10-18T15:21:07.295Z" }, 450 + { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057, upload-time = "2024-10-18T15:21:08.073Z" }, 451 + { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359, upload-time = "2024-10-18T15:21:09.318Z" }, 452 + { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306, upload-time = "2024-10-18T15:21:10.185Z" }, 453 + { url = "https://files.pythonhosted.org/packages/9a/34/a15aa69f01e2181ed8d2b685c0d2f6655d5cca2c4db0ddea775e631918cd/MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d", size = 15094, upload-time = "2024-10-18T15:21:11.005Z" }, 454 + { url = "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", size = 15521, upload-time = "2024-10-18T15:21:12.911Z" }, 455 + { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274, upload-time = "2024-10-18T15:21:13.777Z" }, 456 + { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348, upload-time = "2024-10-18T15:21:14.822Z" }, 457 + { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149, upload-time = "2024-10-18T15:21:15.642Z" }, 458 + { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118, upload-time = "2024-10-18T15:21:17.133Z" }, 459 + { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993, upload-time = "2024-10-18T15:21:18.064Z" }, 460 + { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178, upload-time = "2024-10-18T15:21:18.859Z" }, 461 + { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319, upload-time = "2024-10-18T15:21:19.671Z" }, 462 + { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352, upload-time = "2024-10-18T15:21:20.971Z" }, 463 + { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097, upload-time = "2024-10-18T15:21:22.646Z" }, 464 + { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601, upload-time = "2024-10-18T15:21:23.499Z" }, 465 + { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274, upload-time = "2024-10-18T15:21:24.577Z" }, 466 + { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352, upload-time = "2024-10-18T15:21:25.382Z" }, 467 + { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122, upload-time = "2024-10-18T15:21:26.199Z" }, 468 + { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085, upload-time = "2024-10-18T15:21:27.029Z" }, 469 + { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978, upload-time = "2024-10-18T15:21:27.846Z" }, 470 + { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208, upload-time = "2024-10-18T15:21:28.744Z" }, 471 + { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357, upload-time = "2024-10-18T15:21:29.545Z" }, 472 + { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344, upload-time = "2024-10-18T15:21:30.366Z" }, 473 + { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101, upload-time = "2024-10-18T15:21:31.207Z" }, 474 + { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603, upload-time = "2024-10-18T15:21:32.032Z" }, 475 + { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510, upload-time = "2024-10-18T15:21:33.625Z" }, 476 + { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486, upload-time = "2024-10-18T15:21:34.611Z" }, 477 + { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480, upload-time = "2024-10-18T15:21:35.398Z" }, 478 + { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914, upload-time = "2024-10-18T15:21:36.231Z" }, 479 + { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796, upload-time = "2024-10-18T15:21:37.073Z" }, 480 + { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473, upload-time = "2024-10-18T15:21:37.932Z" }, 481 + { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114, upload-time = "2024-10-18T15:21:39.799Z" }, 482 + { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098, upload-time = "2024-10-18T15:21:40.813Z" }, 483 + { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208, upload-time = "2024-10-18T15:21:41.814Z" }, 484 + { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739, upload-time = "2024-10-18T15:21:42.784Z" }, 485 + { url = "https://files.pythonhosted.org/packages/a7/ea/9b1530c3fdeeca613faeb0fb5cbcf2389d816072fab72a71b45749ef6062/MarkupSafe-3.0.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:eaa0a10b7f72326f1372a713e73c3f739b524b3af41feb43e4921cb529f5929a", size = 14344, upload-time = "2024-10-18T15:21:43.721Z" }, 486 + { url = "https://files.pythonhosted.org/packages/4b/c2/fbdbfe48848e7112ab05e627e718e854d20192b674952d9042ebd8c9e5de/MarkupSafe-3.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:48032821bbdf20f5799ff537c7ac3d1fba0ba032cfc06194faffa8cda8b560ff", size = 12389, upload-time = "2024-10-18T15:21:44.666Z" }, 487 + { url = "https://files.pythonhosted.org/packages/f0/25/7a7c6e4dbd4f867d95d94ca15449e91e52856f6ed1905d58ef1de5e211d0/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a9d3f5f0901fdec14d8d2f66ef7d035f2157240a433441719ac9a3fba440b13", size = 21607, upload-time = "2024-10-18T15:21:45.452Z" }, 488 + { url = "https://files.pythonhosted.org/packages/53/8f/f339c98a178f3c1e545622206b40986a4c3307fe39f70ccd3d9df9a9e425/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88b49a3b9ff31e19998750c38e030fc7bb937398b1f78cfa599aaef92d693144", size = 20728, upload-time = "2024-10-18T15:21:46.295Z" }, 489 + { url = "https://files.pythonhosted.org/packages/1a/03/8496a1a78308456dbd50b23a385c69b41f2e9661c67ea1329849a598a8f9/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cfad01eed2c2e0c01fd0ecd2ef42c492f7f93902e39a42fc9ee1692961443a29", size = 20826, upload-time = "2024-10-18T15:21:47.134Z" }, 490 + { url = "https://files.pythonhosted.org/packages/e6/cf/0a490a4bd363048c3022f2f475c8c05582179bb179defcee4766fb3dcc18/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:1225beacc926f536dc82e45f8a4d68502949dc67eea90eab715dea3a21c1b5f0", size = 21843, upload-time = "2024-10-18T15:21:48.334Z" }, 491 + { url = "https://files.pythonhosted.org/packages/19/a3/34187a78613920dfd3cdf68ef6ce5e99c4f3417f035694074beb8848cd77/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:3169b1eefae027567d1ce6ee7cae382c57fe26e82775f460f0b2778beaad66c0", size = 21219, upload-time = "2024-10-18T15:21:49.587Z" }, 492 + { url = "https://files.pythonhosted.org/packages/17/d8/5811082f85bb88410ad7e452263af048d685669bbbfb7b595e8689152498/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:eb7972a85c54febfb25b5c4b4f3af4dcc731994c7da0d8a0b4a6eb0640e1d178", size = 20946, upload-time = "2024-10-18T15:21:50.441Z" }, 493 + { url = "https://files.pythonhosted.org/packages/7c/31/bd635fb5989440d9365c5e3c47556cfea121c7803f5034ac843e8f37c2f2/MarkupSafe-3.0.2-cp39-cp39-win32.whl", hash = "sha256:8c4e8c3ce11e1f92f6536ff07154f9d49677ebaaafc32db9db4620bc11ed480f", size = 15063, upload-time = "2024-10-18T15:21:51.385Z" }, 494 + { url = "https://files.pythonhosted.org/packages/b3/73/085399401383ce949f727afec55ec3abd76648d04b9f22e1c0e99cb4bec3/MarkupSafe-3.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:6e296a513ca3d94054c2c881cc913116e90fd030ad1c656b3869762b754f5f8a", size = 15506, upload-time = "2024-10-18T15:21:52.974Z" }, 495 + ] 496 + 497 + [[package]] 498 + name = "mdit-py-plugins" 499 + version = "0.4.2" 500 + source = { registry = "https://pypi.org/simple" } 501 + dependencies = [ 502 + { name = "markdown-it-py" }, 503 + ] 504 + sdist = { url = "https://files.pythonhosted.org/packages/19/03/a2ecab526543b152300717cf232bb4bb8605b6edb946c845016fa9c9c9fd/mdit_py_plugins-0.4.2.tar.gz", hash = "sha256:5f2cd1fdb606ddf152d37ec30e46101a60512bc0e5fa1a7002c36647b09e26b5", size = 43542, upload-time = "2024-09-09T20:27:49.564Z" } 505 + wheels = [ 506 + { url = "https://files.pythonhosted.org/packages/a7/f7/7782a043553ee469c1ff49cfa1cdace2d6bf99a1f333cf38676b3ddf30da/mdit_py_plugins-0.4.2-py3-none-any.whl", hash = "sha256:0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636", size = 55316, upload-time = "2024-09-09T20:27:48.397Z" }, 507 + ] 508 + 348 509 [[package]] 349 510 name = "mdurl" 350 511 version = "0.1.2" ··· 867 1028 ] 868 1029 869 1030 [[package]] 1031 + name = "textual" 1032 + version = "4.0.0" 1033 + source = { registry = "https://pypi.org/simple" } 1034 + dependencies = [ 1035 + { name = "markdown-it-py", extra = ["linkify", "plugins"] }, 1036 + { name = "platformdirs" }, 1037 + { name = "rich" }, 1038 + { name = "typing-extensions" }, 1039 + ] 1040 + sdist = { url = "https://files.pythonhosted.org/packages/f1/22/a2812ab1e5b0cb3a327a4ea79b430234c2271ba13462b989f435b40a247d/textual-4.0.0.tar.gz", hash = "sha256:1cab4ea3cfc0e47ae773405cdd6bc2a17ed76ff7b648379ac8017ea89c5ad28c", size = 1606128, upload-time = "2025-07-12T09:41:20.812Z" } 1041 + wheels = [ 1042 + { url = "https://files.pythonhosted.org/packages/d8/e4/ebe27c54d2534cc41d00ea1d78b783763f97abf3e3d6dd41e5536daa52a5/textual-4.0.0-py3-none-any.whl", hash = "sha256:214051640f890676a670aa7d29cd2a37d27cfe6b2cf866e9d5abc3b6c89c5800", size = 692382, upload-time = "2025-07-12T09:41:18.828Z" }, 1043 + ] 1044 + 1045 + [[package]] 870 1046 name = "thicket" 871 1047 source = { editable = "." } 872 1048 dependencies = [ 873 1049 { name = "bleach" }, 874 1050 { name = "email-validator" }, 875 1051 { name = "feedparser" }, 1052 + { name = "flask" }, 876 1053 { name = "gitpython" }, 877 1054 { name = "httpx" }, 878 1055 { name = "pendulum" }, ··· 881 1058 { name = "pydantic-settings" }, 882 1059 { name = "pyyaml" }, 883 1060 { name = "rich" }, 1061 + { name = "textual" }, 884 1062 { name = "typer" }, 885 1063 ] 886 1064 ··· 901 1079 { name = "bleach", specifier = ">=6.0.0" }, 902 1080 { name = "email-validator" }, 903 1081 { name = "feedparser", specifier = ">=6.0.11" }, 1082 + { name = "flask", specifier = ">=3.1.1" }, 904 1083 { name = "gitpython", specifier = ">=3.1.40" }, 905 1084 { name = "httpx", specifier = ">=0.28.0" }, 906 1085 { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.13.0" }, ··· 914 1093 { name = "pyyaml", specifier = ">=6.0.0" }, 915 1094 { name = "rich", specifier = ">=13.0.0" }, 916 1095 { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.8.0" }, 1096 + { name = "textual", specifier = ">=4.0.0" }, 917 1097 { name = "typer", specifier = ">=0.15.0" }, 918 1098 { name = "types-pyyaml", marker = "extra == 'dev'", specifier = ">=6.0.0" }, 919 1099 ] ··· 1014 1194 ] 1015 1195 1016 1196 [[package]] 1197 + name = "uc-micro-py" 1198 + version = "1.0.3" 1199 + source = { registry = "https://pypi.org/simple" } 1200 + sdist = { url = "https://files.pythonhosted.org/packages/91/7a/146a99696aee0609e3712f2b44c6274566bc368dfe8375191278045186b8/uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a", size = 6043, upload-time = "2024-02-09T16:52:01.654Z" } 1201 + wheels = [ 1202 + { url = "https://files.pythonhosted.org/packages/37/87/1f677586e8ac487e29672e4b17455758fce261de06a0d086167bb760361a/uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5", size = 6229, upload-time = "2024-02-09T16:52:00.371Z" }, 1203 + ] 1204 + 1205 + [[package]] 1017 1206 name = "webencodings" 1018 1207 version = "0.5.1" 1019 1208 source = { registry = "https://pypi.org/simple" } ··· 1021 1210 wheels = [ 1022 1211 { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" }, 1023 1212 ] 1213 + 1214 + [[package]] 1215 + name = "werkzeug" 1216 + version = "3.1.3" 1217 + source = { registry = "https://pypi.org/simple" } 1218 + dependencies = [ 1219 + { name = "markupsafe" }, 1220 + ] 1221 + sdist = { url = "https://files.pythonhosted.org/packages/9f/69/83029f1f6300c5fb2471d621ab06f6ec6b3324685a2ce0f9777fd4a8b71e/werkzeug-3.1.3.tar.gz", hash = "sha256:60723ce945c19328679790e3282cc758aa4a6040e4bb330f53d30fa546d44746", size = 806925, upload-time = "2024-11-08T15:52:18.093Z" } 1222 + wheels = [ 1223 + { url = "https://files.pythonhosted.org/packages/52/24/ab44c871b0f07f491e5d2ad12c9bd7358e527510618cb1b803a88e986db1/werkzeug-3.1.3-py3-none-any.whl", hash = "sha256:54b78bf3716d19a65be4fceccc0d1d7b89e608834989dfae50ea87564639213e", size = 224498, upload-time = "2024-11-08T15:52:16.132Z" }, 1224 + ] 1225 + 1226 + [[package]] 1227 + name = "zipp" 1228 + version = "3.23.0" 1229 + source = { registry = "https://pypi.org/simple" } 1230 + sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" } 1231 + wheels = [ 1232 + { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" }, 1233 + ]

Configure Feed

Configure Feed