diffx-python 0.3.0__tar.gz

diffx_python-0.3.0/.gitignore

@@ -0,0 +1,50 @@
+# Rust
+/target/
+**/*.rs.bk
+
+# IDEs
+.idea/
+.vscode/
+
+# OS
+.DS_Store
+thumbs.db
+
+# Cargo
+Cargo.lock
+
+# Test intermediate files (generated during tests)
+/tests/output/
+**/diff_report_v*.json
+
+# Node.js
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+**/dist/
+**/build/
+
+# Python
+__pycache__/
+*.py[cod]
+*~
+*.so
+.Python
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+*.egg-info/
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Binary downloads
+**/packages/*/bin/
+**/packages/*/temp/

diffx_python-0.3.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: diffx-python
+Version: 0.3.0
+Summary: Python wrapper for diffx - semantic diff for structured data
+Project-URL: Homepage, https://github.com/kako-jun/diffx
+Project-URL: Repository, https://github.com/kako-jun/diffx
+Project-URL: Issues, https://github.com/kako-jun/diffx/issues
+Project-URL: Documentation, https://github.com/kako-jun/diffx/tree/main/docs
+Author-email: kako-jun <kako.jun.42@gmail.com>
+License-Expression: MIT
+Keywords: comparison,csv,diff,ini,json,semantic,structured-data,toml,xml,yaml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=6.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# diffx
+
+Python wrapper for the `diffx` CLI tool - semantic diff for structured data.
+
+## Installation
+
+```bash
+pip install diffx-py
+```
+
+This will automatically download the appropriate `diffx` binary for your system from GitHub Releases.
+
+## Usage
+
+### Modern API (Recommended)
+
+```python
+import diffx
+
+# Compare two JSON files
+result = diffx.diff('file1.json', 'file2.json')
+print(result)
+
+# Get structured output as JSON
+json_result = diffx.diff(
+    'config1.yaml', 
+    'config2.yaml',
+    diffx.DiffOptions(format='yaml', output='json')
+)
+
+for diff_item in json_result:
+    if diff_item.added:
+        print(f"Added: {diff_item.added}")
+    elif diff_item.modified:
+        print(f"Modified: {diff_item.modified}")
+
+# Compare directory trees
+dir_result = diffx.diff(
+    'dir1/', 
+    'dir2/',
+    diffx.DiffOptions(recursive=True, path='config')
+)
+
+# Compare strings directly
+json1 = '{"name": "Alice", "age": 30}'
+json2 = '{"name": "Alice", "age": 31}'
+string_result = diffx.diff_string(
+    json1, json2, 'json',
+    diffx.DiffOptions(output='json')
+)
+```
+
+### Legacy API (Backward Compatibility)
+
+```python
+from diffx import run_diffx
+
+# Compare two JSON files (legacy)
+result = run_diffx(["file1.json", "file2.json"])
+
+if result.returncode == 0:
+    print("No differences found.")
+else:
+    print("Differences found:")
+    print(result.stdout)
+```
+
+## Features
+
+- **Multiple formats**: JSON, YAML, TOML, XML, INI, CSV
+- **Smart diffing**: Understands structure, not just text
+- **Flexible output**: CLI, JSON, YAML, unified diff formats
+- **Advanced options**: 
+  - Regex-based key filtering
+  - Floating-point tolerance
+  - Array element identification
+  - Path-based filtering
+- **Cross-platform**: Automatically downloads the right binary
+
+## Development
+
+To install in development mode with uv:
+
+```bash
+uv venv
+source .venv/bin/activate
+uv pip install -e .[dev]
+```
+
+## Manual Binary Installation
+
+If automatic download fails:
+
+```bash
+diffx-download-binary
+```
+
+## License
+
+This project is licensed under the MIT License.

diffx_python-0.3.0/README.md

@@ -0,0 +1,100 @@
+# diffx
+
+Python wrapper for the `diffx` CLI tool - semantic diff for structured data.
+
+## Installation
+
+```bash
+pip install diffx-py
+```
+
+This will automatically download the appropriate `diffx` binary for your system from GitHub Releases.
+
+## Usage
+
+### Modern API (Recommended)
+
+```python
+import diffx
+
+# Compare two JSON files
+result = diffx.diff('file1.json', 'file2.json')
+print(result)
+
+# Get structured output as JSON
+json_result = diffx.diff(
+    'config1.yaml', 
+    'config2.yaml',
+    diffx.DiffOptions(format='yaml', output='json')
+)
+
+for diff_item in json_result:
+    if diff_item.added:
+        print(f"Added: {diff_item.added}")
+    elif diff_item.modified:
+        print(f"Modified: {diff_item.modified}")
+
+# Compare directory trees
+dir_result = diffx.diff(
+    'dir1/', 
+    'dir2/',
+    diffx.DiffOptions(recursive=True, path='config')
+)
+
+# Compare strings directly
+json1 = '{"name": "Alice", "age": 30}'
+json2 = '{"name": "Alice", "age": 31}'
+string_result = diffx.diff_string(
+    json1, json2, 'json',
+    diffx.DiffOptions(output='json')
+)
+```
+
+### Legacy API (Backward Compatibility)
+
+```python
+from diffx import run_diffx
+
+# Compare two JSON files (legacy)
+result = run_diffx(["file1.json", "file2.json"])
+
+if result.returncode == 0:
+    print("No differences found.")
+else:
+    print("Differences found:")
+    print(result.stdout)
+```
+
+## Features
+
+- **Multiple formats**: JSON, YAML, TOML, XML, INI, CSV
+- **Smart diffing**: Understands structure, not just text
+- **Flexible output**: CLI, JSON, YAML, unified diff formats
+- **Advanced options**: 
+  - Regex-based key filtering
+  - Floating-point tolerance
+  - Array element identification
+  - Path-based filtering
+- **Cross-platform**: Automatically downloads the right binary
+
+## Development
+
+To install in development mode with uv:
+
+```bash
+uv venv
+source .venv/bin/activate
+uv pip install -e .[dev]
+```
+
+## Manual Binary Installation
+
+If automatic download fails:
+
+```bash
+diffx-download-binary
+```
+
+## License
+
+This project is licensed under the MIT License.

diffx_python-0.3.0/pyproject.toml

@@ -0,0 +1,85 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "diffx-python"
+version = "0.3.0"
+description = "Python wrapper for diffx - semantic diff for structured data"
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "kako-jun", email = "kako.jun.42@gmail.com" }
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Text Processing",
+    "Topic :: Utilities"
+]
+keywords = [
+    "diff",
+    "semantic",
+    "json",
+    "yaml",
+    "toml",
+    "xml",
+    "ini",
+    "csv",
+    "structured-data",
+    "comparison"
+]
+requires-python = ">=3.8"
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/kako-jun/diffx"
+Repository = "https://github.com/kako-jun/diffx"
+Issues = "https://github.com/kako-jun/diffx/issues"
+Documentation = "https://github.com/kako-jun/diffx/tree/main/docs"
+
+[project.optional-dependencies]
+dev = [
+    "pytest >= 6.0",
+    "pytest-cov",
+    "black",
+    "isort",
+    "mypy",
+    "ruff"
+]
+
+[project.scripts]
+diffx-download-binary = "diffx.installer:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/diffx"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src",
+    "/scripts",
+    "/README.md"
+]
+
+[tool.ruff]
+line-length = 88
+target-version = "py38"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "N", "UP", "YTT", "ANN", "S", "BLE", "FBT", "B", "A", "COM", "C4", "DTZ", "T10", "ISC", "ICN", "G", "PIE", "T20", "PYI", "PT", "Q", "RSE", "RET", "SLF", "SIM", "TID", "TCH", "ARG", "PTH", "ERA", "PGH", "PL", "TRY", "NPY", "RUF"]
+ignore = ["ANN101", "ANN102", "COM812", "ISC001"]
+
+[tool.mypy]
+python_version = "3.8"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true

diffx_python-0.3.0/src/diffx/__init__.py

@@ -0,0 +1,33 @@
+"""
+diffx: Python wrapper for the diffx CLI tool
+
+This package provides a Python interface to the diffx CLI tool for semantic
+diffing of structured data formats like JSON, YAML, TOML, XML, INI, and CSV.
+"""
+
+from .diffx import (
+    diff,
+    diff_string,
+    is_diffx_available,
+    DiffOptions,
+    DiffResult,
+    DiffError,
+    Format,
+    OutputFormat,
+)
+
+# For backward compatibility with existing diffx_python users
+from .compat import run_diffx
+
+__version__ = "0.3.0"
+__all__ = [
+    "diff",
+    "diff_string", 
+    "is_diffx_available",
+    "DiffOptions",
+    "DiffResult", 
+    "DiffError",
+    "Format",
+    "OutputFormat",
+    "run_diffx",  # Backward compatibility
+]

diffx_python-0.3.0/src/diffx/compat.py

@@ -0,0 +1,56 @@
+"""
+Backward compatibility layer for existing diffx_python users
+"""
+
+import os
+import subprocess
+import sys
+import platform
+from pathlib import Path
+
+
+def run_diffx(args):
+    """
+    Run diffx command with given arguments (backward compatibility)
+    
+    This function maintains compatibility with the original diffx_python API.
+    
+    Args:
+        args: List of command line arguments for diffx
+        
+    Returns:
+        subprocess.CompletedProcess object with stdout, stderr, and returncode
+        
+    Examples:
+        >>> result = run_diffx(["file1.json", "file2.json"])
+        >>> print(result.stdout)
+    """
+    # Determine the path to the diffx binary
+    package_dir = Path(__file__).parent.parent.parent
+    binary_name = "diffx.exe" if platform.system() == "Windows" else "diffx"
+    diffx_binary_path = package_dir / "bin" / binary_name
+
+    # Fall back to system PATH if local binary doesn't exist
+    if not diffx_binary_path.exists():
+        diffx_binary_path = "diffx"
+
+    command = [str(diffx_binary_path)] + args
+    
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=False)
+        
+        if result.returncode != 0 and result.stderr:
+            print(f"Error running diffx: {result.stderr}", file=sys.stderr)
+        
+        return result
+    except FileNotFoundError:
+        # Create a mock result object for consistency
+        class MockResult:
+            def __init__(self):
+                self.stdout = ""
+                self.stderr = "diffx binary not found. Please ensure the package is installed correctly."
+                self.returncode = -1
+        
+        result = MockResult()
+        print(f"Error: {result.stderr}", file=sys.stderr)
+        return result

diffx_python-0.3.0/src/diffx/diffx.py

@@ -0,0 +1,244 @@
+"""
+Main diffx wrapper implementation
+"""
+
+import json
+import subprocess
+import tempfile
+import os
+import platform
+from pathlib import Path
+from typing import Union, List, Dict, Any, Optional, Literal
+from dataclasses import dataclass
+
+
+# Type definitions
+Format = Literal["json", "yaml", "toml", "xml", "ini", "csv"]
+OutputFormat = Literal["cli", "json", "yaml", "unified"]
+
+
+@dataclass
+class DiffOptions:
+    """Options for the diff operation"""
+    format: Optional[Format] = None
+    output: Optional[OutputFormat] = None
+    recursive: bool = False
+    path: Optional[str] = None
+    ignore_keys_regex: Optional[str] = None
+    epsilon: Optional[float] = None
+    array_id_key: Optional[str] = None
+
+
+class DiffResult:
+    """Result of a diff operation when output format is 'json'"""
+    def __init__(self, data: Dict[str, Any]):
+        self.data = data
+    
+    @property
+    def added(self) -> Optional[tuple]:
+        """Get Added result if present"""
+        return tuple(self.data["Added"]) if "Added" in self.data else None
+    
+    @property
+    def removed(self) -> Optional[tuple]:
+        """Get Removed result if present"""
+        return tuple(self.data["Removed"]) if "Removed" in self.data else None
+    
+    @property
+    def modified(self) -> Optional[tuple]:
+        """Get Modified result if present"""
+        return tuple(self.data["Modified"]) if "Modified" in self.data else None
+    
+    @property
+    def type_changed(self) -> Optional[tuple]:
+        """Get TypeChanged result if present"""
+        return tuple(self.data["TypeChanged"]) if "TypeChanged" in self.data else None
+    
+    def __repr__(self) -> str:
+        return f"DiffResult({self.data})"
+
+
+class DiffError(Exception):
+    """Error thrown when diffx command fails"""
+    def __init__(self, message: str, exit_code: int, stderr: str):
+        super().__init__(message)
+        self.exit_code = exit_code
+        self.stderr = stderr
+
+
+def _get_diffx_binary_path() -> str:
+    """Get the path to the diffx binary"""
+    # Check if local binary exists (installed via postinstall)
+    package_dir = Path(__file__).parent.parent.parent
+    binary_name = "diffx.exe" if platform.system() == "Windows" else "diffx"
+    local_binary_path = package_dir / "bin" / binary_name
+    
+    if local_binary_path.exists():
+        return str(local_binary_path)
+    
+    # Fall back to system PATH
+    return "diffx"
+
+
+def _execute_diffx(args: List[str]) -> tuple[str, str]:
+    """Execute diffx command and return stdout, stderr"""
+    diffx_path = _get_diffx_binary_path()
+    
+    try:
+        result = subprocess.run(
+            [diffx_path] + args,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return result.stdout, result.stderr
+    except subprocess.CalledProcessError as e:
+        raise DiffError(
+            f"diffx exited with code {e.returncode}",
+            e.returncode,
+            e.stderr or ""
+        )
+    except FileNotFoundError:
+        raise DiffError(
+            "diffx command not found. Please install diffx CLI tool.",
+            -1,
+            ""
+        )
+
+
+def diff(
+    input1: str,
+    input2: str,
+    options: Optional[DiffOptions] = None
+) -> Union[str, List[DiffResult]]:
+    """
+    Compare two files or directories using diffx
+    
+    Args:
+        input1: Path to first file/directory or '-' for stdin
+        input2: Path to second file/directory
+        options: Comparison options
+        
+    Returns:
+        String output for CLI format, or list of DiffResult for JSON format
+        
+    Examples:
+        >>> result = diff('file1.json', 'file2.json')
+        >>> print(result)
+        
+        >>> json_result = diff('config1.yaml', 'config2.yaml', 
+        ...                   DiffOptions(format='yaml', output='json'))
+        >>> for diff_item in json_result:
+        ...     print(diff_item)
+        
+        >>> dir_result = diff('dir1/', 'dir2/', 
+        ...                  DiffOptions(recursive=True, path='config'))
+    """
+    if options is None:
+        options = DiffOptions()
+    
+    args = [input1, input2]
+    
+    # Add format option
+    if options.format:
+        args.extend(["--format", options.format])
+    
+    # Add output format option
+    if options.output:
+        args.extend(["--output", options.output])
+    
+    # Add recursive option
+    if options.recursive:
+        args.append("--recursive")
+    
+    # Add path filter option
+    if options.path:
+        args.extend(["--path", options.path])
+    
+    # Add ignore keys regex option
+    if options.ignore_keys_regex:
+        args.extend(["--ignore-keys-regex", options.ignore_keys_regex])
+    
+    # Add epsilon option
+    if options.epsilon is not None:
+        args.extend(["--epsilon", str(options.epsilon)])
+    
+    # Add array ID key option
+    if options.array_id_key:
+        args.extend(["--array-id-key", options.array_id_key])
+    
+    stdout, stderr = _execute_diffx(args)
+    
+    # If output format is JSON, parse the result
+    if options.output == "json":
+        try:
+            json_data = json.loads(stdout)
+            return [DiffResult(item) for item in json_data]
+        except json.JSONDecodeError as e:
+            raise DiffError(f"Failed to parse JSON output: {e}", -1, "")
+    
+    # Return raw output for other formats
+    return stdout
+
+
+def diff_string(
+    content1: str,
+    content2: str,
+    format: Format,
+    options: Optional[DiffOptions] = None
+) -> Union[str, List[DiffResult]]:
+    """
+    Compare two strings directly (writes to temporary files)
+    
+    Args:
+        content1: First content string
+        content2: Second content string
+        format: Content format
+        options: Comparison options
+        
+    Returns:
+        String output for CLI format, or list of DiffResult for JSON format
+        
+    Examples:
+        >>> json1 = '{"name": "Alice", "age": 30}'
+        >>> json2 = '{"name": "Alice", "age": 31}'
+        >>> result = diff_string(json1, json2, 'json', 
+        ...                     DiffOptions(output='json'))
+        >>> print(result)
+    """
+    if options is None:
+        options = DiffOptions()
+    
+    # Ensure format is set
+    options.format = format
+    
+    # Create temporary files
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        tmp_file1 = Path(tmp_dir) / f"file1.{format}"
+        tmp_file2 = Path(tmp_dir) / f"file2.{format}"
+        
+        # Write content to temporary files
+        tmp_file1.write_text(content1, encoding="utf-8")
+        tmp_file2.write_text(content2, encoding="utf-8")
+        
+        # Perform diff
+        return diff(str(tmp_file1), str(tmp_file2), options)
+
+
+def is_diffx_available() -> bool:
+    """
+    Check if diffx command is available in the system
+    
+    Returns:
+        True if diffx is available, False otherwise
+        
+    Examples:
+        >>> if not is_diffx_available():
+        ...     print("Please install diffx CLI tool")
+        ...     exit(1)
+    """
+    try:
+        _execute_diffx(["--version"])
+        return True
+    except DiffError:
+        return False

diffx_python-0.3.0/src/diffx/installer.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""Binary installer for diffx."""
+
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib.request
+import zipfile
+from pathlib import Path
+
+DIFFX_VERSION = "0.3.0"
+
+
+def get_platform_info():
+    """Get platform-specific download information."""
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    
+    if system == "windows":
+        return "diffx-windows-x86_64.zip", "diffx.exe"
+    elif system == "darwin":
+        if machine in ["arm64", "aarch64"]:
+            return "diffx-macos-aarch64.tar.gz", "diffx"
+        else:
+            return "diffx-macos-x86_64.tar.gz", "diffx"
+    elif system == "linux":
+        return "diffx-linux-x86_64.tar.gz", "diffx"
+    else:
+        raise RuntimeError(f"Unsupported platform: {system}-{machine}")
+
+
+def download_file(url: str, dest_path: Path) -> None:
+    """Download a file from URL to destination."""
+    print(f"Downloading diffx binary from {url}...")
+    
+    try:
+        with urllib.request.urlopen(url) as response:
+            with open(dest_path, 'wb') as dest_file:
+                shutil.copyfileobj(response, dest_file)
+    except Exception as e:
+        raise RuntimeError(f"Failed to download {url}: {e}")
+
+
+def extract_archive(archive_path: Path, extract_dir: Path) -> None:
+    """Extract archive file."""
+    print("Extracting binary...")
+    
+    if archive_path.suffix == '.zip':
+        with zipfile.ZipFile(archive_path, 'r') as zip_file:
+            zip_file.extractall(extract_dir)
+    elif archive_path.name.endswith('.tar.gz'):
+        with tarfile.open(archive_path, 'r:gz') as tar_file:
+            tar_file.extractall(extract_dir)
+    else:
+        raise RuntimeError(f"Unsupported archive format: {archive_path}")
+
+
+def main():
+    """Main function to download and install diffx binary."""
+    try:
+        # Get the package directory (where this script will be installed)
+        if hasattr(sys, '_MEIPASS'):
+            # If running from PyInstaller bundle
+            package_dir = Path(sys._MEIPASS).parent
+        else:
+            # Normal installation
+            package_dir = Path(__file__).parent.parent.parent
+        
+        bin_dir = package_dir / "bin"
+        
+        # Get platform info
+        archive_name, binary_name = get_platform_info()
+        binary_path = bin_dir / binary_name
+        
+        # Skip download if binary already exists
+        if binary_path.exists():
+            print("diffx binary already exists, skipping download.")
+            return 0
+        
+        # Create bin directory
+        bin_dir.mkdir(exist_ok=True)
+        
+        # Download URL
+        download_url = f"https://github.com/kako-jun/diffx/releases/download/v{DIFFX_VERSION}/{archive_name}"
+        
+        # Download to temporary file
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            archive_path = temp_path / archive_name
+            
+            download_file(download_url, archive_path)
+            extract_archive(archive_path, bin_dir)
+        
+        # Make binary executable on Unix systems
+        if platform.system() != "Windows":
+            binary_path.chmod(0o755)
+        
+        print(f"✅ diffx binary installed successfully at {binary_path}")
+        return 0
+        
+    except Exception as error:
+        print(f"❌ Failed to download diffx binary: {error}")
+        print("You may need to install diffx manually from: https://github.com/kako-jun/diffx/releases")
+        # Don't fail the installation, just warn
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())