pakt 0.1.0__py3-none-any.whl

pakt/__init__.py

@@ -0,0 +1,3 @@
+"""Pakt - Fast, efficient Plex-Trakt sync."""
+
+__version__ = "0.1.0"

pakt/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m pakt."""
+
+from pakt.cli import main
+
+if __name__ == "__main__":
+    main()

pakt/assets/icon.svg

@@ -0,0 +1,10 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256">
+  <defs>
+    <linearGradient id="bg" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#6366f1"/>
+      <stop offset="100%" style="stop-color:#8b5cf6"/>
+    </linearGradient>
+  </defs>
+  <circle cx="128" cy="128" r="120" fill="url(#bg)"/>
+  <text x="128" y="165" font-family="Inter, -apple-system, sans-serif" font-size="140" font-weight="600" fill="white" text-anchor="middle">P</text>
+</svg>

pakt/cli.py

@@ -0,0 +1,422 @@
+"""CLI interface for Pakt."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from pakt import __version__
+from pakt.config import Config, get_config_dir
+from pakt.trakt import DeviceAuthStatus, TraktClient
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="pakt")
+def main():
+    """Pakt - Fast Plex-Trakt sync using batch operations."""
+    pass
+
+
+def _make_token_refresh_callback(config: Config):
+    """Create a callback that saves tokens when they're refreshed."""
+    def on_token_refresh(token: dict):
+        config.trakt.access_token = token["access_token"]
+        config.trakt.refresh_token = token["refresh_token"]
+        config.trakt.expires_at = token["created_at"] + token["expires_in"]
+        config.save()
+    return on_token_refresh
+
+
+@main.command()
+@click.option("--dry-run", is_flag=True, help="Show what would be synced without making changes")
+@click.option("--verbose", "-v", is_flag=True, help="Show detailed list of items to sync")
+def sync(dry_run: bool, verbose: bool):
+    """Sync watched status and ratings between Plex and Trakt."""
+    from pakt.sync import run_sync
+
+    config = Config.load()
+
+    if not config.trakt.access_token:
+        console.print("[red]Error:[/] Not logged in to Trakt. Run 'pakt login' first.")
+        sys.exit(1)
+
+    if not config.plex.url or not config.plex.token:
+        console.print("[red]Error:[/] Plex not configured. Run 'pakt setup' first.")
+        sys.exit(1)
+
+    result = asyncio.run(run_sync(config, dry_run=dry_run, verbose=verbose, on_token_refresh=_make_token_refresh_callback(config)))
+
+    console.print("\n[bold green]Sync complete![/]")
+    console.print(f"  Added to Trakt: {result.added_to_trakt}")
+    console.print(f"  Added to Plex: {result.added_to_plex}")
+    console.print(f"  Ratings synced: {result.ratings_synced}")
+    console.print(f"  Duration: {result.duration_seconds:.1f}s")
+
+    if result.errors:
+        console.print(f"\n[yellow]Errors ({len(result.errors)}):[/]")
+        for error in result.errors[:10]:
+            console.print(f"  - {error}")
+
+
+@main.command()
+def login():
+    """Authenticate with Trakt using device code flow."""
+    config = Config.load()
+
+    async def do_auth():
+        async with TraktClient(config.trakt) as client:
+            console.print("[cyan]Getting device code...[/]")
+            device = await client.device_code()
+
+            console.print(f"\n[bold]→ Go to:[/] [cyan]{device['verification_url']}[/]")
+            console.print(f"[bold]→ Enter:[/] [bold yellow]{device['user_code']}[/]")
+            console.print("\n[dim]Waiting for authorization...[/]")
+
+            result = await client.poll_device_token(
+                device["device_code"],
+                interval=device.get("interval", 5),
+                expires_in=device.get("expires_in", 600),
+            )
+
+            if result.status == DeviceAuthStatus.SUCCESS and result.token:
+                config.trakt.access_token = result.token["access_token"]
+                config.trakt.refresh_token = result.token["refresh_token"]
+                config.trakt.expires_at = result.token["created_at"] + result.token["expires_in"]
+                config.save()
+                console.print("\n[green]✓ Successfully authenticated with Trakt![/]")
+            else:
+                console.print(f"\n[red]✗ {result.message}[/]")
+                sys.exit(1)
+
+    asyncio.run(do_auth())
+
+
+@main.command()
+def logout():
+    """Revoke Trakt authentication and clear tokens."""
+    config = Config.load()
+
+    if not config.trakt.access_token:
+        console.print("[yellow]Not currently logged in to Trakt.[/]")
+        return
+
+    async def do_logout():
+        async with TraktClient(config.trakt) as client:
+            console.print("[cyan]Revoking Trakt access token...[/]")
+            success = await client.revoke_token()
+
+            if success:
+                console.print("[green]Token revoked successfully.[/]")
+            else:
+                console.print("[yellow]Token revocation failed, clearing local tokens anyway.[/]")
+
+            # Clear local tokens regardless
+            config.trakt.access_token = ""
+            config.trakt.refresh_token = ""
+            config.trakt.expires_at = 0
+            config.save()
+            console.print("[green]Logged out from Trakt.[/]")
+
+    asyncio.run(do_logout())
+
+
+@main.command()
+def setup():
+    """Interactive setup wizard - configure Trakt and Plex in one go."""
+    from pakt.plex import PlexClient
+
+    config = Config.load()
+
+    console.print("\n[bold cyan]═══ Pakt Setup Wizard ═══[/]\n")
+
+    # Check what's already configured
+    trakt_done = bool(config.trakt.access_token)
+    plex_done = bool(config.plex.url and config.plex.token)
+
+    if trakt_done and plex_done:
+        console.print("[green]✓[/] Trakt: Authenticated")
+        console.print("[green]✓[/] Plex: Configured")
+        console.print("\nEverything is already set up! Run [cyan]pakt sync[/] to start syncing.")
+        if click.confirm("\nReconfigure anyway?", default=False):
+            trakt_done = False
+            plex_done = False
+        else:
+            return
+
+    # Step 1: Trakt
+    if not trakt_done:
+        console.print("[bold]Step 1: Trakt Authentication[/]\n")
+
+        async def do_auth():
+            async with TraktClient(config.trakt) as client:
+                console.print("[cyan]Getting device code...[/]")
+                device = await client.device_code()
+
+                console.print(f"\n[bold]→ Go to:[/] [cyan]{device['verification_url']}[/]")
+                console.print(f"[bold]→ Enter:[/] [bold yellow]{device['user_code']}[/]")
+                console.print("\n[dim]Waiting for you to authorize...[/]")
+
+                result = await client.poll_device_token(
+                    device["device_code"],
+                    interval=device.get("interval", 5),
+                    expires_in=device.get("expires_in", 600),
+                )
+
+                if result.status == DeviceAuthStatus.SUCCESS and result.token:
+                    config.trakt.access_token = result.token["access_token"]
+                    config.trakt.refresh_token = result.token["refresh_token"]
+                    config.trakt.expires_at = result.token["created_at"] + result.token["expires_in"]
+                    config.save()
+                    console.print("\n[green]✓ Trakt authenticated![/]")
+                    return True
+                else:
+                    console.print(f"\n[red]✗ {result.message}[/]")
+                    return False
+
+        if not asyncio.run(do_auth()):
+            console.print("\n[yellow]Setup incomplete. Run 'pakt setup' to try again.[/]")
+            return
+    else:
+        console.print("[green]✓[/] Trakt: Already authenticated\n")
+
+    # Step 2: Plex
+    if not plex_done:
+        console.print("\n[bold]Step 2: Plex Connection[/]\n")
+
+        # Try to auto-detect local Plex
+        console.print("[dim]Checking for local Plex server...[/]")
+        detected_url = None
+        try:
+            import httpx
+            resp = httpx.get("http://localhost:32400/identity", timeout=2)
+            if resp.status_code == 200:
+                detected_url = "http://localhost:32400"
+                console.print(f"[green]✓[/] Found Plex at {detected_url}")
+        except Exception:
+            console.print("[dim]No local server found[/]")
+
+        default_url = detected_url or config.plex.url or "http://localhost:32400"
+        config.plex.url = click.prompt("\nPlex server URL", default=default_url)
+
+        console.print("\n[dim]To get your Plex token:")
+        console.print("1. Open Plex Web App and sign in")
+        console.print("2. Open any media item")
+        console.print("3. Click ⋮ → Get Info → View XML")
+        console.print("4. In the URL, find X-Plex-Token=xxxxx")
+        console.print("5. Copy just the token part after the =[/]\n")
+
+        token = click.prompt("Plex token")
+        # Auto-strip prefix if user pasted the whole thing
+        if token.lower().startswith("x-plex-token="):
+            token = token[13:]
+        elif token.startswith("="):
+            token = token[1:]
+        config.plex.token = token
+        config.save()
+
+        # Test connection
+        console.print("\n[dim]Testing connection...[/]")
+        try:
+            plex = PlexClient(config.plex)
+            plex.connect()
+            console.print(f"[green]✓[/] Connected to: {plex.server.friendlyName}")
+            libs = plex.get_movie_libraries() + plex.get_show_libraries()
+            console.print(f"[green]✓[/] Libraries: {', '.join(libs)}")
+        except Exception as e:
+            console.print(f"[red]✗ Connection failed:[/] {e}")
+            console.print("\n[yellow]Check your URL and token, then run 'pakt setup' again.[/]")
+            return
+    else:
+        console.print("[green]✓[/] Plex: Already configured")
+
+    # Done!
+    console.print("\n[bold green]═══ Setup Complete! ═══[/]\n")
+    console.print("You're ready to sync. Try these commands:")
+    console.print("  [cyan]pakt sync --dry-run[/]  - Preview what will sync")
+    console.print("  [cyan]pakt sync[/]           - Run the sync")
+    console.print("  [cyan]pakt serve[/]          - Start web interface")
+
+
+@main.command()
+def status():
+    """Show current configuration status."""
+    config = Config.load()
+    config_dir = get_config_dir()
+
+    console.print("[bold]Pakt Status[/]\n")
+
+    # Trakt status
+    table = Table(title="Trakt")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value")
+
+    table.add_row("Client ID", config.trakt.client_id[:20] + "..." if config.trakt.client_id else "[red]Not set[/]")
+    table.add_row("Authenticated", "[green]Yes[/]" if config.trakt.access_token else "[red]No[/]")
+    console.print(table)
+
+    # Plex status
+    table = Table(title="Plex")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value")
+
+    table.add_row("URL", config.plex.url or "[red]Not set[/]")
+    table.add_row("Token", "***" if config.plex.token else "[red]Not set[/]")
+    console.print(table)
+
+    console.print(f"\n[dim]Config directory: {config_dir}[/]")
+
+
+@main.command()
+@click.option("--host", default="127.0.0.1", help="Host to bind to")
+@click.option("--port", default=8080, help="Port to bind to")
+@click.option("--tray/--no-tray", default=None, help="Enable/disable system tray icon")
+def serve(host: str, port: int, tray: bool | None):
+    """Start the web interface."""
+    import os
+    import uvicorn
+
+    from pakt.web import create_app
+
+    # Only show tray when explicitly requested with --tray
+    show_tray = tray is True
+
+    # Suppress console output only when --tray explicitly passed (for pythonw compatibility)
+    silent_mode = tray is True
+
+    # Redirect stdout/stderr to devnull in silent mode (for pythonw)
+    if silent_mode:
+        try:
+            devnull = open(os.devnull, 'w')
+            sys.stdout = devnull
+            sys.stderr = devnull
+        except Exception:
+            pass
+
+    tray_instance = None
+    if show_tray:
+        try:
+            from pakt.tray import TRAY_AVAILABLE, PaktTray
+
+            if TRAY_AVAILABLE:
+                web_url = f"http://{host}:{port}"
+                tray_instance = PaktTray(
+                    web_url=web_url,
+                    shutdown_callback=lambda: sys.exit(0),
+                )
+                tray_instance.start()
+            elif not silent_mode:
+                console.print("[yellow]System tray requested but dependencies not installed.[/]")
+                console.print("[yellow]Install with: pip install pystray Pillow[/]")
+        except ImportError:
+            if not silent_mode:
+                console.print("[yellow]System tray requested but dependencies not installed.[/]")
+                console.print("[yellow]Install with: pip install pystray Pillow[/]")
+
+    if not silent_mode:
+        console.print("[bold]Starting Pakt web interface...[/]")
+        console.print(f"Open [cyan]http://{host}:{port}[/] in your browser")
+        console.print("[dim]Press Ctrl+C to stop[/]\n")
+
+    app = create_app()
+
+    try:
+        log_level = "critical" if silent_mode else "warning"
+        uvicorn.run(app, host=host, port=port, log_level=log_level)
+    finally:
+        if tray_instance:
+            tray_instance.stop()
+
+
+@main.command()
+@click.option("--movie", "-m", multiple=True, help="Movie libraries to sync (can specify multiple)")
+@click.option("--show", "-s", multiple=True, help="Show libraries to sync (can specify multiple)")
+@click.option("--all", "sync_all", is_flag=True, help="Sync all libraries (clear selection)")
+def libraries(movie: tuple[str, ...], show: tuple[str, ...], sync_all: bool):
+    """Configure which Plex libraries to sync.
+
+    Run without options to see available libraries and current selection.
+    """
+    from pakt.plex import PlexClient
+
+    config = Config.load()
+
+    if not config.plex.url or not config.plex.token:
+        console.print("[red]Error:[/] Plex not configured. Run 'pakt setup' first.")
+        return
+
+    # Connect to Plex to get available libraries
+    try:
+        plex = PlexClient(config.plex)
+        plex.connect()
+    except Exception as e:
+        console.print(f"[red]Error connecting to Plex:[/] {e}")
+        return
+
+    available_movie_libs = plex.get_movie_libraries()
+    available_show_libs = plex.get_show_libraries()
+
+    # If options provided, update config
+    if movie or show or sync_all:
+        if sync_all:
+            config.sync.movie_libraries = []
+            config.sync.show_libraries = []
+            console.print("[green]✓[/] Set to sync all libraries")
+        else:
+            if movie:
+                # Validate library names
+                invalid = [m for m in movie if m not in available_movie_libs]
+                if invalid:
+                    console.print(f"[yellow]Warning:[/] Unknown movie libraries: {', '.join(invalid)}")
+                config.sync.movie_libraries = [m for m in movie if m in available_movie_libs]
+
+            if show:
+                invalid = [s for s in show if s not in available_show_libs]
+                if invalid:
+                    console.print(f"[yellow]Warning:[/] Unknown show libraries: {', '.join(invalid)}")
+                config.sync.show_libraries = [s for s in show if s in available_show_libs]
+
+        config.save()
+        console.print("[green]✓[/] Configuration saved")
+        console.print()
+
+    # Display current state
+    table = Table(title="Plex Libraries")
+    table.add_column("Type", style="cyan")
+    table.add_column("Library")
+    table.add_column("Status")
+
+    current_movie = config.sync.movie_libraries or []
+    current_show = config.sync.show_libraries or []
+    sync_all_movies = len(current_movie) == 0
+    sync_all_shows = len(current_show) == 0
+
+    for lib in available_movie_libs:
+        if sync_all_movies or lib in current_movie:
+            status = "[green]✓ Syncing[/]"
+        else:
+            status = "[dim]Skipped[/]"
+        table.add_row("Movie", lib, status)
+
+    for lib in available_show_libs:
+        if sync_all_shows or lib in current_show:
+            status = "[green]✓ Syncing[/]"
+        else:
+            status = "[dim]Skipped[/]"
+        table.add_row("Show", lib, status)
+
+    console.print(table)
+
+    if sync_all_movies and sync_all_shows:
+        console.print("\n[dim]All libraries selected (default)[/]")
+    console.print("\n[dim]Use --movie/-m and --show/-s to select specific libraries[/]")
+    console.print("[dim]Use --all to reset to syncing all libraries[/]")
+
+
+if __name__ == "__main__":
+    main()

pakt/config.py

@@ -0,0 +1,200 @@
+"""Configuration management for Pakt."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Literal
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def get_config_dir() -> Path:
+    """Get the configuration directory (platform-appropriate)."""
+    if os.name == "nt":  # Windows
+        base = Path(os.environ.get("APPDATA", Path.home()))
+        config_dir = base / "pakt"
+    else:  # Linux/macOS
+        config_dir = Path.home() / ".config" / "pakt"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def get_cache_dir() -> Path:
+    """Get the cache directory (platform-appropriate)."""
+    if os.name == "nt":  # Windows
+        base = Path(os.environ.get("LOCALAPPDATA", Path.home()))
+        cache_dir = base / "pakt" / "cache"
+    else:  # Linux/macOS
+        cache_dir = Path.home() / ".cache" / "pakt"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir
+
+
+class TraktConfig(BaseSettings):
+    """Trakt API configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="TRAKT_")
+
+    # Default app credentials - users get their own rate limits after auth
+    client_id: str = "bc25ba5024e871104e3a090b98e44895670d66d89d5296fa6ed027d6e2a44f9d"
+    client_secret: str = "0a3cb10a368e848ef67ebcbdb0f64b437ee5abf17e07e4f216c9aa7346f587f5"
+    access_token: str = ""
+    refresh_token: str = ""
+    expires_at: int = 0
+
+
+class PlexConfig(BaseSettings):
+    """Plex configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="PLEX_")
+
+    url: str = ""
+    token: str = ""
+    server_name: str = ""
+
+
+class SyncConfig(BaseSettings):
+    """Sync behavior configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="PAKT_SYNC_")
+
+    # Sync directions - watched
+    watched_plex_to_trakt: bool = True
+    watched_trakt_to_plex: bool = True
+
+    # Sync directions - ratings
+    ratings_plex_to_trakt: bool = True
+    ratings_trakt_to_plex: bool = True
+
+    # Sync directions - collection (Plex library -> Trakt collection)
+    collection_plex_to_trakt: bool = False
+
+    # Sync directions - watchlist
+    watchlist_plex_to_trakt: bool = False
+    watchlist_trakt_to_plex: bool = False
+
+    # Rating priority when both have ratings
+    rating_priority: Literal["plex", "trakt", "newest"] = "newest"
+
+    # Libraries to sync (empty = all)
+    movie_libraries: list[str] = Field(default_factory=list)
+    show_libraries: list[str] = Field(default_factory=list)
+
+    # Libraries to exclude
+    excluded_libraries: list[str] = Field(default_factory=list)
+
+    @field_validator("movie_libraries", "show_libraries", "excluded_libraries", mode="before")
+    @classmethod
+    def parse_library_list(cls, v: str | list[str]) -> list[str]:
+        """Parse library list from env var (JSON array or comma-separated)."""
+        if isinstance(v, list):
+            return v
+        if not v or (isinstance(v, str) and v.strip() == ""):
+            return []
+        # Try JSON first (new format), fall back to comma-separated (legacy)
+        v_str = v.strip()
+        if v_str.startswith("["):
+            try:
+                parsed = json.loads(v_str)
+                return parsed if isinstance(parsed, list) else []
+            except json.JSONDecodeError:
+                pass
+        return [lib.strip() for lib in v.split(",") if lib.strip()]
+
+
+class SchedulerConfig(BaseSettings):
+    """Scheduler configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="PAKT_SCHEDULER_")
+
+    enabled: bool = False
+    interval_hours: int = 0  # 0 = disabled
+    run_on_startup: bool = False
+
+
+class Config(BaseSettings):
+    """Main configuration."""
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    trakt: TraktConfig = Field(default_factory=TraktConfig)
+    plex: PlexConfig = Field(default_factory=PlexConfig)
+    sync: SyncConfig = Field(default_factory=SyncConfig)
+    scheduler: SchedulerConfig = Field(default_factory=SchedulerConfig)
+
+    @classmethod
+    def load(cls, config_dir: Path | None = None) -> Config:
+        """Load configuration from file and environment."""
+        if config_dir is None:
+            config_dir = get_config_dir()
+
+        # Fields that need empty string -> [] conversion for pydantic-settings
+        list_fields = {
+            "PAKT_SYNC_MOVIE_LIBRARIES",
+            "PAKT_SYNC_SHOW_LIBRARIES",
+            "PAKT_SYNC_EXCLUDED_LIBRARIES",
+        }
+
+        # Fix any existing empty list env vars (pydantic-settings needs valid JSON)
+        for key in list_fields:
+            if key in os.environ and os.environ[key].strip() == "":
+                os.environ[key] = "[]"
+
+        env_file = config_dir / ".env"
+        if env_file.exists():
+            # Load env vars into os.environ so nested configs pick them up
+            for line in env_file.read_text().splitlines():
+                line = line.strip()
+                if line and "=" in line and not line.startswith("#"):
+                    key, value = line.split("=", 1)
+                    # Convert empty strings to JSON empty array for list fields
+                    if key in list_fields and value.strip() == "":
+                        value = "[]"
+                    os.environ[key] = value
+
+        return cls()
+
+    def save(self, config_dir: Path | None = None) -> None:
+        """Save configuration to file."""
+        if config_dir is None:
+            config_dir = get_config_dir()
+
+        env_file = config_dir / ".env"
+        lines = [
+            # Trakt
+            f"TRAKT_CLIENT_ID={self.trakt.client_id}",
+            f"TRAKT_CLIENT_SECRET={self.trakt.client_secret}",
+            f"TRAKT_ACCESS_TOKEN={self.trakt.access_token}",
+            f"TRAKT_REFRESH_TOKEN={self.trakt.refresh_token}",
+            f"TRAKT_EXPIRES_AT={self.trakt.expires_at}",
+            # Plex
+            f"PLEX_URL={self.plex.url}",
+            f"PLEX_TOKEN={self.plex.token}",
+            f"PLEX_SERVER_NAME={self.plex.server_name}",
+            # Sync - watched
+            f"PAKT_SYNC_WATCHED_PLEX_TO_TRAKT={str(self.sync.watched_plex_to_trakt).lower()}",
+            f"PAKT_SYNC_WATCHED_TRAKT_TO_PLEX={str(self.sync.watched_trakt_to_plex).lower()}",
+            # Sync - ratings
+            f"PAKT_SYNC_RATINGS_PLEX_TO_TRAKT={str(self.sync.ratings_plex_to_trakt).lower()}",
+            f"PAKT_SYNC_RATINGS_TRAKT_TO_PLEX={str(self.sync.ratings_trakt_to_plex).lower()}",
+            # Sync - collection
+            f"PAKT_SYNC_COLLECTION_PLEX_TO_TRAKT={str(self.sync.collection_plex_to_trakt).lower()}",
+            # Sync - watchlist
+            f"PAKT_SYNC_WATCHLIST_PLEX_TO_TRAKT={str(self.sync.watchlist_plex_to_trakt).lower()}",
+            f"PAKT_SYNC_WATCHLIST_TRAKT_TO_PLEX={str(self.sync.watchlist_trakt_to_plex).lower()}",
+            # Sync - libraries (JSON format for pydantic-settings)
+            f"PAKT_SYNC_MOVIE_LIBRARIES={json.dumps(self.sync.movie_libraries)}",
+            f"PAKT_SYNC_SHOW_LIBRARIES={json.dumps(self.sync.show_libraries)}",
+            # Scheduler
+            f"PAKT_SCHEDULER_ENABLED={str(self.scheduler.enabled).lower()}",
+            f"PAKT_SCHEDULER_INTERVAL_HOURS={self.scheduler.interval_hours}",
+            f"PAKT_SCHEDULER_RUN_ON_STARTUP={str(self.scheduler.run_on_startup).lower()}",
+        ]
+        env_file.write_text("\n".join(lines))