diffx-python 0.5.2__py3-none-win_amd64.whl

diffx/__init__.py

@@ -0,0 +1,46 @@
+"""
+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.
+
+The diffx binary is embedded in the wheel for offline installation.
+"""
+
+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 is now managed dynamically from pyproject.toml
+# This prevents hardcoded version mismatches during releases
+try:
+    from importlib.metadata import version
+    __version__ = version("diffx-python")
+except ImportError:
+    # Fallback for Python < 3.8
+    try:
+        import pkg_resources
+        __version__ = pkg_resources.get_distribution("diffx-python").version
+    except Exception:
+        __version__ = "unknown"
+__all__ = [
+    "diff",
+    "diff_string", 
+    "is_diffx_available",
+    "DiffOptions",
+    "DiffResult", 
+    "DiffError",
+    "Format",
+    "OutputFormat",
+    "run_diffx",  # Backward compatibility
+]

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/diffx.py

@@ -0,0 +1,293 @@
+"""
+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
+    context: Optional[int] = None
+    ignore_whitespace: bool = False
+    ignore_case: bool = False
+    quiet: bool = False
+    brief: bool = False
+    debug: bool = False
+
+
+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 embedded in the wheel"""
+    import sys
+    binary_name = "diffx.exe" if platform.system() == "Windows" else "diffx"
+    
+    # For maturin wheel with bindings = "bin", binary is installed in Scripts/bin
+    # Check the Python environment's Scripts/bin directory first
+    if hasattr(sys, 'prefix'):
+        env_scripts_paths = [
+            Path(sys.prefix) / "Scripts" / binary_name,  # Windows
+            Path(sys.prefix) / "bin" / binary_name,      # Unix
+        ]
+        
+        for path in env_scripts_paths:
+            if path.exists():
+                return str(path)
+    
+    # PyInstaller case
+    if hasattr(sys, '_MEIPASS'):
+        wheel_binary_path = Path(sys._MEIPASS) / binary_name
+        if wheel_binary_path.exists():
+            return str(wheel_binary_path)
+    
+    # Fall back to system PATH (for development)
+    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=False  # Don't raise exception on non-zero exit
+        )
+        
+        # Exit codes:
+        # 0 = No differences found
+        # 1 = Differences found (normal diff result)
+        # 2+ = Error conditions
+        if result.returncode in (0, 1):
+            return result.stdout, result.stderr
+        else:
+            raise DiffError(
+                f"diffx exited with code {result.returncode}",
+                result.returncode,
+                result.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])
+    
+    # Add context option
+    if options.context is not None:
+        args.extend(["--context", str(options.context)])
+    
+    # Add ignore whitespace option
+    if options.ignore_whitespace:
+        args.append("--ignore-whitespace")
+    
+    # Add ignore case option
+    if options.ignore_case:
+        args.append("--ignore-case")
+    
+    # Add quiet option
+    if options.quiet:
+        args.append("--quiet")
+    
+    # Add brief option
+    if options.brief:
+        args.append("--brief")
+    
+    # Add debug option
+    if options.debug:
+        args.append("--debug")
+    
+    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.5.2.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: diffx-python
+Version: 0.5.2
+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-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: Python wrapper for diffx - semantic diffing of JSON, YAML, TOML, XML, INI, and CSV files. Focuses on structural meaning rather than formatting.
+Keywords: diff,semantic,json,yaml,toml,xml,ini,csv,structured-data,comparison,devops,ci-cd,automation,data-analysis,configuration
+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/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
+
+# diffx-python
+
+Python wrapper for the `diffx` CLI tool - semantic diff for structured data.
+
+## Installation
+
+```bash
+pip install diffx-python
+```
+
+The `diffx` binary is automatically included in the wheel - no additional downloads required! This package uses [maturin](https://github.com/PyO3/maturin) to embed the native binary directly in the Python wheel, similar to tools like `ruff`.
+
+## Usage
+
+```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')
+)
+```
+
+
+## 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**: Native binary embedded in platform-specific wheels
+
+## Key Benefits
+
+- **🚀 Zero setup**: No external downloads or binary management
+- **📦 Self-contained**: Everything needed is in the wheel
+- **⚡ Fast installation**: No network dependencies after `pip install`
+- **🔒 Secure**: No runtime downloads from external sources
+- **🌐 Offline-ready**: Works in air-gapped environments
+
+## Development
+
+To install in development mode:
+
+```bash
+pip install -e .[dev]
+```
+
+## Verification
+
+Verify the installation:
+
+```python
+import diffx
+print("diffx available:", diffx.is_diffx_available())
+print("Version:", diffx.__version__)
+```
+
+## License
+
+This project is licensed under the MIT License.
+

diffx_python-0.5.2.dist-info/RECORD

@@ -0,0 +1,7 @@
+diffx/__init__.py,sha256=UqUxAz-5h4Wfp_PO9Qfe-pbxBvYxx5PXIL8bd6p-o_Y,1200
+diffx/compat.py,sha256=tvL1YMBKIHRCFzJMNuIvhO5zOHuXdX4IIRoKmVPoto0,1806
+diffx/diffx.py,sha256=b4WMgcBrgmar4zo08KDb2ZdXsyjWgTZXOc813HlgHYc,8853
+diffx_python-0.5.2.data/scripts/diffx.exe,sha256=o2SAoSq95J3kewOdlBmS_x_ZkQIUjAxgFlaR1opGE1A,3560960
+diffx_python-0.5.2.dist-info/METADATA,sha256=skeY5kKErOUy0NWPzr5if3SU6xKkJeI9_y6y6yqZu7M,3935
+diffx_python-0.5.2.dist-info/WHEEL,sha256=T1-x9ZAB-aE3ewIGbYuockW5ywV7fI-Nla9FsiR1vW4,93
+diffx_python-0.5.2.dist-info/RECORD,,

diffx_python-0.5.2.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