spatelier 0.3.0__py3-none-any.whl

cli/audio.py

@@ -0,0 +1,129 @@
+"""
+Audio processing CLI commands.
+
+This module provides command-line interfaces for audio processing operations.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from cli.error_handlers import handle_cli_error, handle_file_not_found
+from core.config import Config
+from core.decorators import handle_errors, time_operation
+from core.logger import get_logger
+from core.service_factory import ServiceFactory
+from modules.audio.converter import AudioConverter
+
+# Create the audio CLI app
+app = typer.Typer(
+    name="audio",
+    help="Audio processing commands",
+    rich_markup_mode="rich",
+)
+
+console = Console()
+
+
+@app.command()
+@handle_errors(context="audio convert", verbose=True)
+@time_operation(verbose=True)
+def convert(
+    input_file: Path = typer.Argument(..., help="Input audio file"),
+    output_file: Path = typer.Argument(..., help="Output audio file"),
+    bitrate: int = typer.Option(320, "--bitrate", "-b", help="Audio bitrate (kbps)"),
+    format: str = typer.Option("mp3", "--format", "-f", help="Output format"),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    Convert audio to different format.
+
+    Supports various input and output formats including MP3, FLAC, WAV, etc.
+    """
+    config = Config()
+    logger = get_logger("audio-convert", verbose=verbose)
+
+    # Validate input file
+    if not input_file.exists():
+        handle_file_not_found(input_file, "convert")
+
+    try:
+        with ServiceFactory(config, verbose=verbose) as services:
+            # Create audio converter
+            converter = AudioConverter(config, verbose=verbose)
+
+            # Perform conversion
+            result = converter.convert(
+                input_file=input_file,
+                output_file=output_file,
+                format=format,
+                bitrate=bitrate,
+            )
+
+            # Display success message
+            console.print(
+                Panel(
+                    f"[green]✓[/green] Conversion successful!\n"
+                    f"Input: {input_file.name}\n"
+                    f"Output: {output_file.name}\n"
+                    f"Format: {format.upper()}\n"
+                    f"Bitrate: {bitrate}kbps\n"
+                    f"Size: {result.metadata.get('input_size', 0):,} -> {result.metadata.get('output_size', 0):,} bytes",
+                    title="Conversion Complete",
+                    border_style="green",
+                )
+            )
+
+    except Exception as e:
+        handle_cli_error(e, "audio conversion")
+
+
+@app.command()
+@handle_errors(context="audio info", verbose=True)
+@time_operation(verbose=True)
+def info(
+    file_path: Path = typer.Argument(..., help="Audio file to analyze"),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    Display detailed information about an audio file.
+    """
+    config = Config()
+    logger = get_logger("audio-info", verbose=verbose)
+
+    with ServiceFactory(config, verbose=verbose) as services:
+        try:
+            if not file_path.exists():
+                handle_file_not_found(file_path, "analyze")
+
+            # Create audio converter to get detailed info
+            converter = AudioConverter(config, verbose=verbose)
+            audio_info = converter.get_audio_info(file_path)
+
+            # Create info table
+            table = Table(title=f"Audio Information: {file_path.name}")
+            table.add_column("Property", style="cyan")
+            table.add_column("Value", style="magenta")
+
+            table.add_row("File Path", str(file_path))
+            table.add_row("File Size", f"{file_path.stat().st_size:,} bytes")
+            table.add_row("Format", audio_info.get("format", "unknown"))
+            table.add_row("Codec", audio_info.get("codec", "unknown"))
+            table.add_row("Duration", f"{audio_info.get('duration', 0):.2f} seconds")
+            table.add_row("Bitrate", f"{audio_info.get('bitrate', 0):,} bps")
+            table.add_row("Sample Rate", f"{audio_info.get('sample_rate', 0):,} Hz")
+            table.add_row("Channels", str(audio_info.get("channels", 0)))
+            table.add_row("Channel Layout", audio_info.get("channel_layout", "unknown"))
+
+            console.print(table)
+
+        except Exception as e:
+            handle_cli_error(e, "audio analysis")

cli/cli_analytics.py

@@ -0,0 +1,320 @@
+"""
+Analytics CLI commands.
+
+This module provides command-line interfaces for analytics and reporting operations.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+from sqlalchemy import func
+
+from analytics.reporter import AnalyticsReporter
+from core.config import Config
+from core.decorators import handle_errors, time_operation
+from core.logger import get_logger
+from core.service_factory import ServiceFactory
+
+# Create the analytics CLI app
+app = typer.Typer(
+    name="analytics",
+    help="Analytics and reporting commands",
+    rich_markup_mode="rich",
+)
+
+console = Console()
+
+
+@app.command()
+@handle_errors(context="analytics report", verbose=True)
+@time_operation(verbose=True)
+def report(
+    days: int = typer.Option(30, "--days", "-d", help="Number of days to analyze"),
+    output: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+    format: str = typer.Option(
+        "json", "--format", "-f", help="Output format (json, csv, excel)"
+    ),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    Generate comprehensive analytics report.
+    """
+    config = Config()
+    logger = get_logger("analytics-report", verbose=verbose)
+
+    with ServiceFactory(config, verbose=verbose) as services:
+        try:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+            ) as progress:
+                task = progress.add_task("Generating analytics report...", total=None)
+
+                # Create analytics reporter with database service
+                from analytics.reporter import AnalyticsReporter
+
+                reporter = AnalyticsReporter(
+                    config, verbose=verbose, db_service=services.database
+                )
+
+            # Generate reports
+            progress.update(task, description="Generating media report...")
+            media_report = reporter.generate_media_report(days)
+
+            progress.update(task, description="Generating processing report...")
+            processing_report = reporter.generate_processing_report(days)
+
+            progress.update(task, description="Generating usage report...")
+            usage_report = reporter.generate_usage_report(days)
+
+            # Combine reports
+            combined_report = {
+                "period_days": days,
+                "generated_at": reporter.session.query(func.now()).scalar(),
+                "media_report": media_report,
+                "processing_report": processing_report,
+                "usage_report": usage_report,
+            }
+
+            # Display summary
+            table = Table(title=f"Analytics Summary (Last {days} days)")
+            table.add_column("Metric", style="cyan")
+            table.add_column("Value", style="magenta")
+
+            table.add_row("Total Files", str(media_report["total_files"]))
+            table.add_row("Total Size (MB)", f"{media_report['total_size_mb']:.2f}")
+            table.add_row("Total Jobs", str(processing_report["total_jobs"]))
+            table.add_row("Success Rate", f"{processing_report['success_rate']:.2%}")
+            table.add_row(
+                "Avg Processing Time",
+                f"{processing_report['avg_processing_time_seconds']:.2f}s",
+            )
+            table.add_row("Total Events", str(usage_report["total_events"]))
+
+            console.print(table)
+
+            # Save to file if requested
+            if output:
+                progress.update(task, description="Saving report...")
+                reporter.export_data(output, format)
+                console.print(
+                    Panel(
+                        f"[green]✓[/green] Report saved to: {output}",
+                        title="Report Saved",
+                        border_style="green",
+                    )
+                )
+
+        except Exception as e:
+            logger.error(f"Analytics report failed: {e}")
+            console.print(
+                Panel(
+                    f"[red]✗[/red] Analytics report failed: {str(e)}",
+                    title="Error",
+                    border_style="red",
+                )
+            )
+            raise typer.Exit(1)
+
+
+@app.command()
+def visualize(
+    output_dir: Path = typer.Argument(..., help="Output directory for visualizations"),
+    days: int = typer.Option(30, "--days", "-d", help="Number of days to analyze"),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    Create visualization charts and dashboards.
+    """
+    config = Config()
+    logger = get_logger("analytics-visualize", verbose=verbose)
+
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Creating visualizations...", total=None)
+
+            reporter = AnalyticsReporter(config, verbose=verbose)
+
+            progress.update(task, description="Generating charts...")
+            created_files = reporter.create_visualizations(output_dir, days)
+
+            console.print(
+                Panel(
+                    f"[green]✓[/green] Created {len(created_files)} visualization files\n"
+                    f"Output directory: {output_dir}",
+                    title="Visualizations Created",
+                    border_style="green",
+                )
+            )
+
+            # List created files
+            if created_files:
+                table = Table(title="Created Files")
+                table.add_column("File", style="cyan")
+                table.add_column("Type", style="magenta")
+
+                for file_path in created_files:
+                    file_type = "Chart" if file_path.suffix == ".png" else "Dashboard"
+                    table.add_row(str(file_path.name), file_type)
+
+                console.print(table)
+
+    except Exception as e:
+        logger.error(f"Visualization creation failed: {e}")
+        console.print(
+            Panel(
+                f"[red]✗[/red] Visualization creation failed: {str(e)}",
+                title="Error",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def stats(
+    days: int = typer.Option(30, "--days", "-d", help="Number of days to analyze"),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    Display quick statistics overview.
+    """
+    config = Config()
+    logger = get_logger("analytics-stats", verbose=verbose)
+
+    try:
+        reporter = AnalyticsReporter(config, verbose=verbose)
+
+        # Get quick stats
+        media_report = reporter.generate_media_report(days)
+        processing_report = reporter.generate_processing_report(days)
+        usage_report = reporter.generate_usage_report(days)
+
+        # Create stats table
+        table = Table(title=f"Quick Stats (Last {days} days)")
+        table.add_column("Category", style="cyan")
+        table.add_column("Metric", style="yellow")
+        table.add_column("Value", style="magenta")
+
+        # Media stats
+        table.add_row("Media", "Total Files", str(media_report["total_files"]))
+        table.add_row(
+            "Media", "Total Size (MB)", f"{media_report['total_size_mb']:.2f}"
+        )
+        table.add_row(
+            "Media",
+            "Avg File Size (MB)",
+            f"{media_report['avg_file_size_bytes'] / (1024 * 1024):.2f}",
+        )
+
+        # Processing stats
+        table.add_row("Processing", "Total Jobs", str(processing_report["total_jobs"]))
+        table.add_row(
+            "Processing", "Success Rate", f"{processing_report['success_rate']:.2%}"
+        )
+        table.add_row(
+            "Processing",
+            "Avg Time (s)",
+            f"{processing_report['avg_processing_time_seconds']:.2f}",
+        )
+
+        # Usage stats
+        table.add_row("Usage", "Total Events", str(usage_report["total_events"]))
+        table.add_row(
+            "Usage", "Most Active Day", usage_report.get("most_active_day", "N/A")
+        )
+        table.add_row(
+            "Usage", "Trend", usage_report.get("trend_analysis", {}).get("trend", "N/A")
+        )
+
+        console.print(table)
+
+        # Show files by type
+        if media_report["files_by_type"]:
+            type_table = Table(title="Files by Type")
+            type_table.add_column("Type", style="cyan")
+            type_table.add_column("Count", style="magenta")
+
+            for file_type, count in media_report["files_by_type"].items():
+                type_table.add_row(file_type, str(count))
+
+            console.print(type_table)
+
+    except Exception as e:
+        logger.error(f"Stats display failed: {e}")
+        console.print(
+            Panel(
+                f"[red]✗[/red] Stats display failed: {str(e)}",
+                title="Error",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def export(
+    output_path: Path = typer.Argument(..., help="Output file path"),
+    format: str = typer.Option(
+        "json", "--format", "-f", help="Export format (json, csv, excel)"
+    ),
+    days: int = typer.Option(30, "--days", "-d", help="Number of days to export"),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output"
+    ),
+):
+    """
+    Export analytics data to file.
+    """
+    config = Config()
+    logger = get_logger("analytics-export", verbose=verbose)
+
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Exporting analytics data...", total=None)
+
+            reporter = AnalyticsReporter(config, verbose=verbose)
+
+            progress.update(task, description="Generating reports...")
+            exported_file = reporter.export_data(output_path, format)
+
+            console.print(
+                Panel(
+                    f"[green]✓[/green] Data exported to: {exported_file}",
+                    title="Export Complete",
+                    border_style="green",
+                )
+            )
+
+    except Exception as e:
+        logger.error(f"Data export failed: {e}")
+        console.print(
+            Panel(
+                f"[red]✗[/red] Data export failed: {str(e)}",
+                title="Error",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)