diffai-python 0.3.4__py3-none-win_amd64.whl

diffai/__init__.py

@@ -0,0 +1,303 @@
+"""
+diffai - AI/ML specialized diff tool for deep tensor comparison and analysis
+
+This package provides a Python wrapper around the diffai Rust binary,
+following the same pattern as ruff for optimal performance and reliability.
+"""
+
+# No backward compatibility imports
+
+import json
+import subprocess
+import sys
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+from dataclasses import dataclass
+from enum import Enum
+
+# Version is now managed dynamically from pyproject.toml
+# This prevents hardcoded version mismatches during releases
+try:
+    from importlib.metadata import version
+    __version__ = version("diffai-python")
+except ImportError:
+    # Fallback for Python < 3.8
+    try:
+        import pkg_resources
+        __version__ = pkg_resources.get_distribution("diffai-python").version
+    except Exception:
+        __version__ = "unknown"
+
+class OutputFormat(Enum):
+    """Supported output formats for diffai results."""
+    CLI = "cli"
+    JSON = "json"
+    YAML = "yaml"
+
+@dataclass
+class DiffOptions:
+    """Configuration options for diffai analysis."""
+    
+    # Basic options
+    input_format: Optional[str] = None
+    output_format: Optional[OutputFormat] = None
+    recursive: bool = False
+    verbose: bool = False
+    path: Optional[str] = None
+    ignore_keys_regex: Optional[str] = None
+    epsilon: Optional[float] = None
+    array_id_key: Optional[str] = None
+    
+    # ML analysis options
+    show_layer_impact: bool = False
+    quantization_analysis: bool = False
+    sort_by_change_magnitude: bool = False
+    stats: bool = False
+    learning_progress: bool = False
+    convergence_analysis: bool = False
+    anomaly_detection: bool = False
+    gradient_analysis: bool = False
+    memory_analysis: bool = False
+    inference_speed_estimate: bool = False
+    regression_test: bool = False
+    alert_on_degradation: bool = False
+    review_friendly: bool = False
+    change_summary: bool = False
+    deployment_readiness: bool = False
+    architecture_comparison: bool = False
+    param_efficiency_analysis: bool = False
+    hyperparameter_impact: bool = False
+    learning_rate_analysis: bool = False
+    performance_impact_estimate: bool = False
+    generate_report: bool = False
+    markdown_output: bool = False
+    include_charts: bool = False
+    embedding_analysis: bool = False
+    similarity_matrix: bool = False
+    clustering_change: bool = False
+    attention_analysis: bool = False
+    head_importance: bool = False
+    attention_pattern_diff: bool = False
+    hyperparameter_comparison: bool = False
+    learning_curve_analysis: bool = False
+    statistical_significance: bool = False
+    
+    def to_args(self) -> List[str]:
+        """Convert options to command line arguments."""
+        args = []
+        
+        # Basic options
+        if self.input_format:
+            args.extend(["--format", self.input_format])
+        if self.output_format:
+            args.extend(["--output", self.output_format.value])
+        if self.recursive:
+            args.append("--recursive")
+        if self.verbose:
+            args.append("--verbose")
+        if self.path:
+            args.extend(["--path", self.path])
+        if self.ignore_keys_regex:
+            args.extend(["--ignore-keys-regex", self.ignore_keys_regex])
+        if self.epsilon is not None:
+            args.extend(["--epsilon", str(self.epsilon)])
+        if self.array_id_key:
+            args.extend(["--array-id-key", self.array_id_key])
+            
+        # ML analysis options
+        if self.show_layer_impact:
+            args.append("--show-layer-impact")
+        if self.quantization_analysis:
+            args.append("--quantization-analysis")
+        if self.sort_by_change_magnitude:
+            args.append("--sort-by-change-magnitude")
+        if self.stats:
+            args.append("--stats")
+        if self.learning_progress:
+            args.append("--learning-progress")
+        if self.convergence_analysis:
+            args.append("--convergence-analysis")
+        if self.anomaly_detection:
+            args.append("--anomaly-detection")
+        if self.gradient_analysis:
+            args.append("--gradient-analysis")
+        if self.memory_analysis:
+            args.append("--memory-analysis")
+        if self.inference_speed_estimate:
+            args.append("--inference-speed-estimate")
+        if self.regression_test:
+            args.append("--regression-test")
+        if self.alert_on_degradation:
+            args.append("--alert-on-degradation")
+        if self.review_friendly:
+            args.append("--review-friendly")
+        if self.change_summary:
+            args.append("--change-summary")
+        if self.deployment_readiness:
+            args.append("--deployment-readiness")
+        if self.architecture_comparison:
+            args.append("--architecture-comparison")
+        if self.param_efficiency_analysis:
+            args.append("--param-efficiency-analysis")
+        if self.hyperparameter_impact:
+            args.append("--hyperparameter-impact")
+        if self.learning_rate_analysis:
+            args.append("--learning-rate-analysis")
+        if self.performance_impact_estimate:
+            args.append("--performance-impact-estimate")
+        if self.generate_report:
+            args.append("--generate-report")
+        if self.markdown_output:
+            args.append("--markdown-output")
+        if self.include_charts:
+            args.append("--include-charts")
+        if self.embedding_analysis:
+            args.append("--embedding-analysis")
+        if self.similarity_matrix:
+            args.append("--similarity-matrix")
+        if self.clustering_change:
+            args.append("--clustering-change")
+        if self.attention_analysis:
+            args.append("--attention-analysis")
+        if self.head_importance:
+            args.append("--head-importance")
+        if self.attention_pattern_diff:
+            args.append("--attention-pattern-diff")
+        if self.hyperparameter_comparison:
+            args.append("--hyperparameter-comparison")
+        if self.learning_curve_analysis:
+            args.append("--learning-curve-analysis")
+        if self.statistical_significance:
+            args.append("--statistical-significance")
+            
+        return args
+
+class DiffaiError(Exception):
+    """Base exception for diffai-related errors."""
+    pass
+
+class DiffResult:
+    """Result from diffai analysis."""
+    
+    def __init__(self, raw_output: str, format_type: str = "cli", return_code: int = 0):
+        self.raw_output = raw_output
+        self.format_type = format_type
+        self.return_code = return_code
+        self._parsed_data = None
+        
+    @property
+    def data(self) -> Any:
+        """Get parsed data (JSON objects for JSON output, raw string otherwise)."""
+        if self._parsed_data is None:
+            if self.format_type == "json" and self.raw_output.strip():
+                try:
+                    self._parsed_data = json.loads(self.raw_output)
+                except json.JSONDecodeError:
+                    self._parsed_data = self.raw_output
+            else:
+                self._parsed_data = self.raw_output
+        return self._parsed_data
+    
+    @property
+    def is_json(self) -> bool:
+        """True if result is in JSON format."""
+        return self.format_type == "json" and isinstance(self.data, (dict, list))
+    
+    def __str__(self) -> str:
+        return self.raw_output
+
+def _find_diffai_binary() -> str:
+    """Find the diffai binary, checking bundled location first."""
+    # Check if bundled with package
+    package_dir = Path(__file__).parent.parent.parent
+    bundled_binary = package_dir / "diffai"
+    
+    if bundled_binary.exists() and bundled_binary.is_file():
+        return str(bundled_binary)
+    
+    # Fallback to system PATH
+    system_binary = shutil.which("diffai")
+    if system_binary:
+        return system_binary
+    
+    raise DiffaiError(
+        "diffai binary not found. Please ensure diffai is installed or available in PATH."
+    )
+
+def diff(
+    input1: str,
+    input2: str,
+    options: Optional[Union[DiffOptions, Dict[str, Any]]] = None,
+    **kwargs
+) -> DiffResult:
+    """
+    Compare two files using diffai.
+    
+    Args:
+        input1: Path to first input file
+        input2: Path to second input file
+        options: DiffOptions object or dict of options
+        **kwargs: Additional options as keyword arguments
+        
+    Returns:
+        DiffResult object containing comparison results
+    """
+    # Handle different option formats
+    if options is None:
+        options = DiffOptions(**kwargs)
+    elif isinstance(options, dict):
+        combined_options = {**options, **kwargs}
+        options = DiffOptions(**combined_options)
+    elif kwargs:
+        # Merge kwargs into existing DiffOptions
+        option_dict = {
+            field.name: getattr(options, field.name) 
+            for field in options.__dataclass_fields__.values()
+        }
+        combined_options = {**option_dict, **kwargs}
+        options = DiffOptions(**combined_options)
+    
+    try:
+        binary_path = _find_diffai_binary()
+        cmd = [binary_path] + options.to_args() + [input1, input2]
+        
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=False
+        )
+        
+        if result.returncode != 0 and result.stderr:
+            raise DiffaiError(f"diffai failed: {result.stderr}")
+        
+        format_type = options.output_format.value if options.output_format else "cli"
+        return DiffResult(result.stdout, format_type, result.returncode)
+        
+    except FileNotFoundError:
+        raise DiffaiError("diffai binary not found")
+    except Exception as e:
+        raise DiffaiError(f"Diff failed: {e}")
+
+def main():
+    """CLI entry point for the diffai command."""
+    try:
+        binary_path = _find_diffai_binary()
+        # Forward all arguments to the binary
+        result = subprocess.run([binary_path] + sys.argv[1:])
+        sys.exit(result.returncode)
+    except DiffaiError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+# Export main API
+__all__ = [
+    "diff",
+    "DiffOptions",
+    "DiffResult",
+    "OutputFormat",
+    "DiffaiError",
+    "__version__",
+    "main",
+]

diffai/__main__.py

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

diffai/installer.py

@@ -0,0 +1,206 @@
+"""
+Binary installer for diffai Python package.
+
+This module handles downloading and installing the diffai binary
+when the package is installed via pip.
+
+Supports platforms: Windows, Linux, Darwin (macOS) with x86_64 and aarch64 architectures.
+"""
+
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib.request
+import zipfile
+from pathlib import Path
+
+# Package version constant for GitHub releases
+PACKAGE_VERSION = "0.3.4"
+
+
+def get_platform_info():
+    """Get platform-specific information for binary download.
+    
+    Supported platforms: Windows, Linux, Darwin
+    Supported architectures: x86_64, aarch64
+    """
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    
+    if system == "linux":  # Linux systems
+        if machine in ("x86_64", "amd64"):
+            return "linux-x86_64", "diffai"
+        else:
+            raise RuntimeError(f"Unsupported Linux architecture: {machine}")
+    elif system == "darwin":  # Darwin (macOS) systems
+        if machine == "arm64":
+            return "macos-aarch64", "diffai"
+        elif machine in ("x86_64", "amd64"):
+            return "macos-x86_64", "diffai"
+        else:
+            raise RuntimeError(f"Unsupported Darwin architecture: {machine}")
+    elif system == "windows":  # Windows systems
+        if machine in ("x86_64", "amd64"):
+            return "windows-x86_64", "diffai.exe"
+        else:
+            raise RuntimeError(f"Unsupported Windows architecture: {machine}")
+    else:
+        raise RuntimeError(f"Unsupported operating system: {system}")
+
+
+def download_file(url, dest_path):
+    """Download a file from URL to destination path."""
+    try:
+        with urllib.request.urlopen(url) as response:
+            with open(dest_path, 'wb') as f:
+                f.write(response.read())
+    except Exception as e:
+        raise RuntimeError(f"Failed to download file: {e}")
+
+
+def extract_archive(archive_path, extract_to):
+    """Extract archive file to destination directory."""
+    try:
+        if archive_path.endswith('.zip'):
+            with zipfile.ZipFile(archive_path, 'r') as zip_ref:
+                zip_ref.extractall(extract_to)
+        elif archive_path.endswith(('.tar.gz', '.tgz')):
+            with tarfile.open(archive_path, 'r:gz') as tar_ref:
+                tar_ref.extractall(extract_to)
+        else:
+            raise RuntimeError(f"Unsupported archive format: {archive_path}")
+    except Exception as e:
+        raise RuntimeError(f"Failed to extract archive: {e}")
+
+
+def verify_binary(binary_path):
+    """Verify that the downloaded binary works correctly."""
+    try:
+        # Test binary with --version flag
+        result = subprocess.run(
+            [binary_path, "--version"],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode == 0:
+            return True
+        else:
+            raise RuntimeError(f"Binary verification failed: {result.stderr}")
+            
+    except subprocess.TimeoutExpired:
+        raise RuntimeError("Binary verification timed out")
+    except Exception as e:
+        raise RuntimeError(f"Failed to verify binary: {e}")
+
+
+def get_latest_release_info():
+    """Get information about the latest GitHub release from github.com."""
+    try:
+        import json
+        
+        # GitHub API URL for latest release
+        url = "https://api.github.com/repos/kako-jun/diffai/releases/latest"
+        with urllib.request.urlopen(url) as response:
+            data = json.loads(response.read().decode())
+            
+        return data["tag_name"], data["assets"]
+    except Exception as e:
+        raise RuntimeError(f"Failed to get release information from github.com: {e}")
+
+
+def download_binary(version=None):
+    """Download the diffai binary for the current platform."""
+    platform_name, binary_name = get_platform_info()
+    
+    if version is None:
+        version, assets = get_latest_release_info()
+    else:
+        # For specific version, construct asset URL manually
+        assets = None
+    
+    # Construct download URL
+    if assets:
+        # Find the correct asset
+        asset_name = f"diffai-{platform_name}.tar.gz"
+        if platform_name.startswith("windows"):
+            asset_name = f"diffai-{platform_name}.zip"
+            
+        asset_url = None
+        for asset in assets:
+            if asset["name"] == asset_name:
+                asset_url = asset["browser_download_url"]
+                break
+                
+        if not asset_url:
+            raise RuntimeError(f"Binary not found for platform: {platform_name}")
+    else:
+        # Fallback URL construction
+        base_url = "https://github.com/kako-jun/diffai/releases/download"
+        if platform_name.startswith("windows"):
+            asset_name = f"diffai-{platform_name}.zip"
+        else:
+            asset_name = f"diffai-{platform_name}.tar.gz"
+        asset_url = f"{base_url}/{version}/{asset_name}"
+    
+    # Download to temporary location
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+        archive_path = temp_path / asset_name
+        
+        print(f"Downloading {asset_url}...")
+        urllib.request.urlretrieve(asset_url, archive_path)
+        
+        # Extract archive
+        if asset_name.endswith(".tar.gz"):
+            subprocess.run(["tar", "-xzf", archive_path, "-C", temp_path], check=True)
+        elif asset_name.endswith(".zip"):
+            import zipfile
+            with zipfile.ZipFile(archive_path, 'r') as zip_ref:
+                zip_ref.extractall(temp_path)
+        
+        # Find the binary
+        binary_path = temp_path / binary_name
+        if not binary_path.exists():
+            raise RuntimeError(f"Binary not found in archive: {binary_name}")
+        
+        return binary_path
+
+
+def install_binary():
+    """Install the diffai binary to the package directory."""
+    try:
+        # Get package directory
+        package_dir = Path(__file__).parent.parent.parent
+        binary_dir = package_dir / "bin"
+        binary_dir.mkdir(exist_ok=True)
+        
+        # Download binary
+        temp_binary = download_binary()
+        
+        # Copy to package directory
+        platform_name, binary_name = get_platform_info()
+        target_path = binary_dir / binary_name
+        
+        shutil.copy2(temp_binary, target_path)
+        
+        # Make executable on Unix-like systems
+        if not platform_name.startswith("windows"):
+            os.chmod(target_path, 0o755)
+        
+        print(f"Successfully installed diffai binary to {target_path}")
+        return target_path
+        
+    except Exception as e:
+        print(f"Warning: Failed to install diffai binary: {e}")
+        print("The Python API will still work if diffai is available in PATH")
+        return None
+
+
+if __name__ == "__main__":
+    install_binary()

diffai_python-0.3.4.dist-info/METADATA

@@ -0,0 +1,385 @@
+Metadata-Version: 2.4
+Name: diffai-python
+Version: 0.3.4
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: General
+Classifier: Topic :: Utilities
+Requires-Dist: pytest>=6.0 ; extra == 'dev'
+Requires-Dist: pytest-cov ; extra == 'dev'
+Requires-Dist: black ; extra == 'dev'
+Requires-Dist: isort ; extra == 'dev'
+Requires-Dist: mypy ; extra == 'dev'
+Requires-Dist: ruff ; extra == 'dev'
+Provides-Extra: dev
+Summary: AI/ML specialized diff tool for deep tensor comparison and analysis
+Keywords: ai,ml,machine-learning,diff,tensor,pytorch,safetensors,numpy,matlab,model-comparison,diffai,artificial-intelligence
+Author: kako-jun
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/kako-jun/diffai
+Project-URL: Documentation, https://github.com/kako-jun/diffai/blob/main/docs/
+Project-URL: Repository, https://github.com/kako-jun/diffai.git
+Project-URL: Issues, https://github.com/kako-jun/diffai/issues
+Project-URL: Changelog, https://github.com/kako-jun/diffai/blob/main/CHANGELOG.md
+
+# diffai-python
+
+AI/ML specialized diff tool for deep tensor comparison and analysis - Python Package
+
+[![PyPI version](https://badge.fury.io/py/diffai-python.svg)](https://badge.fury.io/py/diffai-python)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Overview
+
+**diffai-python** provides Python bindings for [diffai](https://github.com/kako-jun/diffai), an AI/ML specialized diff tool. This package bundles the high-performance Rust binary and provides a clean Python API for integration into ML workflows, notebooks, and automation scripts.
+
+Following the same distribution pattern as [ruff](https://github.com/astral-sh/ruff), this package distributes a pre-compiled binary for maximum performance while providing a convenient Python interface.
+
+## Features
+
+- **High Performance**: Uses the native diffai Rust binary for maximum speed
+- **Zero Dependencies**: Self-contained package with bundled binary
+- **ML-Focused**: Specialized analysis for PyTorch, Safetensors, NumPy, and MATLAB files
+- **Scientific Computing**: Full support for NumPy arrays and MATLAB .mat files
+- **Multiple Output Formats**: CLI, JSON, and YAML outputs for different use cases
+- **Python Integration**: Clean API for programmatic use in ML pipelines
+
+## Installation
+
+```bash
+pip install diffai-python
+```
+
+## Quick Start
+
+### Command Line Usage
+
+After installation, the `diffai` command is available:
+
+```bash
+# Compare ML models
+diffai model_v1.safetensors model_v2.safetensors --stats
+
+# Compare NumPy arrays
+diffai data_v1.npy data_v2.npy --stats
+
+# JSON output for automation
+diffai model_v1.pt model_v2.pt --output json
+```
+
+### Python API Usage
+
+```python
+import diffai
+
+# Basic comparison
+result = diffai.diff("model_v1.safetensors", "model_v2.safetensors")
+print(result.raw_output)
+
+# With options
+options = diffai.DiffOptions(
+    stats=True,
+    architecture_comparison=True,
+    output_format=diffai.OutputFormat.JSON
+)
+result = diffai.diff("model_v1.pt", "model_v2.pt", options)
+
+# Access structured data
+if result.is_json:
+    data = result.data
+    print(f"Found {len(data)} differences")
+```
+
+### Advanced ML Analysis
+
+```python
+# Comprehensive ML model analysis
+result = diffai.diff(
+    "baseline.safetensors", 
+    "improved.safetensors",
+    stats=True,
+    architecture_comparison=True,
+    memory_analysis=True,
+    anomaly_detection=True,
+    convergence_analysis=True
+)
+
+print(result.raw_output)
+```
+
+## Supported Formats
+
+### Input Formats
+- **ML Models**: `.safetensors`, `.pt`, `.pth`, `.bin` (PyTorch)
+- **Scientific Data**: `.npy`, `.npz` (NumPy), `.mat` (MATLAB)  
+- **Structured Data**: `.json`, `.yaml`, `.toml`, `.xml`, `.ini`, `.csv`
+
+### Output Formats
+- **CLI**: Colored terminal output (default)
+- **JSON**: Machine-readable format for automation
+- **YAML**: Human-readable structured format
+
+## ML Analysis Features
+
+The package provides 11 specialized ML analysis features:
+
+- `--stats`: Detailed tensor statistics
+- `--architecture-comparison`: Model structure comparison
+- `--memory-analysis`: Memory usage analysis  
+- `--anomaly-detection`: Numerical anomaly detection
+- `--convergence-analysis`: Training convergence analysis
+- `--gradient-analysis`: Gradient information analysis
+- `--similarity-matrix`: Layer similarity comparison
+- `--change-summary`: Detailed change summary
+- `--quantization-analysis`: Quantization impact analysis
+- `--sort-by-change-magnitude`: Sort by change magnitude
+- `--show-layer-impact`: Layer-specific impact analysis
+
+## API Reference
+
+### Main Functions
+
+```python
+# Compare two files
+def diff(input1: str, input2: str, options: Optional[DiffOptions] = None, **kwargs) -> DiffResult
+
+# Main CLI entry point
+def main() -> None
+```
+
+### Configuration
+
+```python
+@dataclass
+class DiffOptions:
+    # Basic options
+    input_format: Optional[str] = None
+    output_format: Optional[OutputFormat] = None
+    recursive: bool = False
+    verbose: bool = False
+    
+    # ML analysis options  
+    stats: bool = False
+    architecture_comparison: bool = False
+    memory_analysis: bool = False
+    anomaly_detection: bool = False
+    # ... and more
+```
+
+### Results
+
+```python
+class DiffResult:
+    raw_output: str           # Raw output from diffai
+    format_type: str          # Output format used
+    return_code: int          # Process return code
+    
+    @property
+    def data(self) -> Any     # Parsed data (JSON when applicable)
+    
+    @property  
+    def is_json(self) -> bool # True if JSON format
+```
+
+## Use Cases
+
+### Research & Development
+```python
+# Compare fine-tuning results
+before = "model_baseline.safetensors"
+after = "model_finetuned.safetensors"
+
+result = diffai.diff(before, after, 
+                    stats=True, 
+                    convergence_analysis=True)
+```
+
+### MLOps Integration
+```python
+# Automated model validation in CI/CD
+def validate_model_changes(old_model, new_model):
+    result = diffai.diff(old_model, new_model,
+                        output_format=diffai.OutputFormat.JSON,
+                        anomaly_detection=True,
+                        memory_analysis=True)
+    
+    if result.is_json:
+        # Check for critical issues
+        for item in result.data:
+            if 'AnomalyDetection' in item and 'critical' in str(item):
+                raise ValueError("Critical model anomaly detected")
+    
+    return result
+
+### MLflow Integration
+```python
+import mlflow
+import diffai
+
+def log_model_comparison(run_id1, run_id2):
+    """Compare models between MLflow runs"""
+    
+    # Download models from MLflow
+    model1_path = mlflow.artifacts.download_artifacts(
+        run_id=run_id1, artifact_path="model/model.pt"
+    )
+    model2_path = mlflow.artifacts.download_artifacts(
+        run_id=run_id2, artifact_path="model/model.pt"
+    )
+    
+    # Compare with diffai
+    result = diffai.diff(model1_path, model2_path,
+                        output_format=diffai.OutputFormat.JSON,
+                        stats=True,
+                        architecture_comparison=True)
+    
+    # Log results to MLflow
+    with mlflow.start_run():
+        mlflow.log_dict(result.data, "model_comparison.json")
+        if result.is_json:
+            # Extract metrics for logging
+            for item in result.data:
+                if 'TensorStatsChanged' in item:
+                    mlflow.log_metric("tensor_changes", len(result.data))
+                    break
+                    
+    return result
+
+### Weights & Biases Integration  
+```python
+import wandb
+import diffai
+
+def log_model_comparison_wandb(model1_path, model2_path):
+    """Log model comparison to Weights & Biases"""
+    
+    result = diffai.diff(model1_path, model2_path,
+                        output_format=diffai.OutputFormat.JSON,
+                        stats=True,
+                        memory_analysis=True,
+                        convergence_analysis=True)
+    
+    # Log to wandb
+    wandb.log({"model_comparison": result.data})
+    
+    if result.is_json:
+        # Log specific metrics
+        memory_changes = [item for item in result.data if 'MemoryAnalysis' in item]
+        if memory_changes:
+            wandb.log({"memory_impact_detected": len(memory_changes)})
+            
+    return result
+```
+
+### Jupyter Notebooks
+```python
+# Interactive analysis in notebooks
+result = diffai.diff("checkpoint_100.pt", "checkpoint_200.pt", 
+                    stats=True, memory_analysis=True)
+
+# Display results
+if result.is_json:
+    from IPython.display import display, JSON
+    display(JSON(result.data))
+else:
+    print(result.raw_output)
+```
+
+## Binary Distribution
+
+This package follows the same pattern as [ruff](https://github.com/astral-sh/ruff):
+
+- Pre-compiled `diffai` binary is bundled with the Python package
+- No external dependencies or system requirements
+- Cross-platform compatibility (Windows, macOS, Linux)
+- Maximum performance through native Rust implementation
+
+## Testing
+
+Run the integration tests:
+
+```bash
+cd diffai-python
+python test_integration.py
+```
+
+The test suite includes:
+- Binary availability verification
+- Basic diff functionality
+- JSON output parsing
+- ML analysis options
+- Error handling
+
+## Contributing
+
+This package is part of the [diffai](https://github.com/kako-jun/diffai) project. Please see the main repository for contribution guidelines.
+
+## License
+
+MIT License - see [LICENSE](../LICENSE) for details.
+
+## Related Projects
+
+- **[diffai](https://github.com/kako-jun/diffai)**: Main Rust CLI tool
+- **[diffx](https://github.com/kako-jun/diffx)**: Generic structured data diff tool
+- **[ruff](https://github.com/astral-sh/ruff)**: Inspiration for Python packaging approach
+
+## Error Handling
+
+The diffai-python package provides comprehensive error handling for various failure scenarios:
+
+### DiffaiError
+The base exception class for all diffai-related errors:
+
+```python
+import diffai
+
+try:
+    result = diffai.diff("model1.pt", "model2.pt")
+except diffai.DiffaiError as e:
+    print(f"Diffai error: {e}")
+```
+
+### BinaryNotFoundError
+Raised when the diffai binary cannot be found:
+
+```python
+import diffai
+
+try:
+    result = diffai.diff("model1.pt", "model2.pt")
+except diffai.DiffaiError as e:
+    if "binary not found" in str(e):
+        print("Please install diffai binary or ensure it's in PATH")
+        # Fallback or installation logic here
+```
+
+### Binary Installation
+If the binary is not found, you can install it manually:
+
+```bash
+# Install via pip (includes binary)
+pip install diffai-python
+
+# Or install Rust version globally
+cargo install diffai-cli
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

diffai_python-0.3.4.dist-info/RECORD

@@ -0,0 +1,7 @@
+diffai/__init__.py,sha256=eL_ZqXdoct718oT9v7smtFVbvRSrV1WjP0w4oRNMnjs,10653
+diffai/__main__.py,sha256=0ABdXiMt3e1FQ3Bept_jgjEoU6unvf-pW9iG50YuS70,106
+diffai/installer.py,sha256=8aLhL6sZ8uDgCoZQM6Ea_dR2jiF4k7mN81I7TghO12U,7132
+diffai_python-0.3.4.data/scripts/diffai.exe,sha256=QbYwNMaJYi0GrN6cnoYGsL20votEsgXxbZR-hyRR1Ps,243200
+diffai_python-0.3.4.dist-info/METADATA,sha256=rBxjiqkzA7U2IDQA63iAf7LJmbAhxucJEmZhXTfexJA,11912
+diffai_python-0.3.4.dist-info/WHEEL,sha256=T1-x9ZAB-aE3ewIGbYuockW5ywV7fI-Nla9FsiR1vW4,93
+diffai_python-0.3.4.dist-info/RECORD,,

diffai_python-0.3.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.1)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64